Comme beaucoup d'entre vous l'ont demandé, nous travaillons maintenant dur pour fournir des exemples de certains de nos codes et packages d'apprentissage automatique.

TensorFlow, PyTorch, Keras, Numpy, Pandas et bien d'autres packages .NET pour démarrer dans cTrader.

Notre mission est de rendre l'apprentissage automatique dans cTrader plus facile pour tout le monde.

Bonne chasse !

*** Ce code ne réalise aucun trade (il affiche seulement des données, etc.). C'est simplement un exemple de code montrant comment vous pouvez commencer à créer vos propres modèles d'IA en utilisant nos packages d'apprentissage automatique.

.......................................................

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

using NumSharp;
using np = NumSharp.np;
using Shape = NumSharp.Shape;

using PandasNet;
using static PandasNet.PandasApi;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class E7BBKGNumSharpSample : Robot
    {
        [Parameter("Version 1.01", DefaultValue = "Version 1.01")]
        public string Version { get; set; }

        [Parameter("Source")]
        public DataSeries Source { get; set; }

        [Parameter("Bars Required", DefaultValue = 50, MinValue = 1, MaxValue = 10000, Step = 1)]
        public int BarsRequired { get; set; }

        [Parameter("Method Name", DefaultValue = MethodName.DataSplitPrints)]
        public MethodName Mode { get; set; }
        public enum MethodName
        {
            DataSplitPrints,
            PandasPrints,
            NDArrayPrints
        }
        
        protected override void OnStart()
        {
            // Initialiser les indicateurs
        }

        protected override void OnBar()
        {
            try
            {
                if (Mode == MethodName.DataSplitPrints)
                {
                    DataSplitPrints();
                }
                else if (Mode == MethodName.PandasPrints)
                {
                    PandasPrints();
                }
                else if (Mode == MethodName.NDArrayPrints)
                {
                    NDArrayPrints();
                }
            }
            catch (Exception ex)
            {
                Print($"Erreur : {ex.Message}");
                if (ex.InnerException != null)
                {
                    Print($"Exception interne : {ex.InnerException.Message}");
                    throw;
                }
            }
        }

        private float[,] GetDataSet()
        {
            int startBar = Bars.ClosePrices.Count - BarsRequired;
            float[,] inputSignals = new float[BarsRequired, 5];

            for (int i = 0; i < BarsRequired; i++)
            {
                int barIndex = startBar + i;
                inputSignals[i, 0] = (float)Bars.OpenPrices[barIndex];
                inputSignals[i, 1] = (float)Bars.HighPrices[barIndex];
                inputSignals[i, 2] = (float)Bars.LowPrices[barIndex];
                inputSignals[i, 3] = (float)Bars.ClosePrices[barIndex];
                inputSignals[i, 4] = (float)Bars.TickVolumes[barIndex];
            }
            return inputSignals;
        }
        
        private float[,] GetTargetDataSet()
        {
            int startBar = Bars.ClosePrices.Count - BarsRequired;
            float[,] inputSignals = new float[BarsRequired, 5];

            for (int i = 0; i < BarsRequired; i++)
            {
                int barIndex = startBar + i;
                inputSignals[i, 0] = (float)Bars.OpenPrices[barIndex];
                inputSignals[i, 1] = (float)Bars.HighPrices[barIndex];
                inputSignals[i, 2] = (float)Bars.LowPrices[barIndex];
                inputSignals[i, 3] = (float)Bars.ClosePrices[barIndex];
                inputSignals[i, 4] = (float)Bars.TickVolumes[barIndex];
            }
            return inputSignals;
        }
        
        /// Impressions de la séparation des données NumSharp
        public void DataSplitPrints()
        {
            // Remodeler les données d'entrée pour correspondre à la forme attendue par le modèle
            //var inputShape = new Shape(-1, BarsRequired, 5);
            NDArray inputData = np.array<float>(GetDataSet());
            Print("NDarray d'entrée : " + string.Join(", ", inputData));
            
            // Remodeler les données cibles pour correspondre à la forme cible attendue par le modèle
            //var targetShape = new Shape(-1, 5);
            NDArray targetData = np.array<float>(GetTargetDataSet());
            Print("NDarray cible : " + string.Join(", ", targetData));
            
            // Diviser les données en ensembles d'entraînement et de test
            int testSize = (int)(0.2 * inputData.shape[0]); // 20 % pour les tests
            var (x_train, x_test) = (inputData[$":{inputData.shape[0] - testSize}"], inputData[$"{inputData.shape[0] - testSize}:"]);
            var (y_train, y_test) = (targetData[$":{targetData.shape[0] - testSize}"], targetData[$"{targetData.shape[0] - testSize}:"]);
            
            Print("Données X_train : " + string.Join(", ", x_train));
            Print("Données X_test : " + string.Join(", ", x_test));
            Print("Données Y_train : " + string.Join(", ", y_train));
            Print("Données Y_test : " + string.Join(", ", y_test));
        }
        
        /// Impressions PandasNet
        public void PandasPrints()
        {
            // Convertir float[,] en List<Series>
            var inputData = GetDataSet();
            var targetData = GetTargetDataSet();
            
            var inputSeriesList = new List<Series>();
            var targetSeriesList = new List<Series>();
            
            for (int col = 0; col < inputData.GetLength(1); col++)
            {
                List<float> columnData = new List<float>();
                for (int row = 0; row < inputData.GetLength(0); row++)
                {
                    columnData.Add(inputData[row, col]);
                }
                inputSeriesList.Add(new Series(columnData.ToArray()));
            }
            
            for (int col = 0; col < targetData.GetLength(1); col++)
            {
                List<float> columnData = new List<float>();
                for (int row = 0; row < targetData.GetLength(0); row++)
                {
                    columnData.Add(targetData[row, col]);
                }
                targetSeriesList.Add(new Series(columnData.ToArray()));
            }
            
            // Créer des DataFrames
            DataFrame inputDataFrame = new DataFrame(inputSeriesList);
            DataFrame targetDataFrame = new DataFrame(targetSeriesList);
            
            Print("DataFrame d'entrée : " + inputDataFrame);
            Print("DataFrame cible : " + targetDataFrame);
            
            //Print("Input DataFrame: " + string.Join(", ", inputDataFrame));
            //Print("Target DataFrame: " + string.Join(", ", targetDataFrame));
        }
        
        /// Impressions simples des NDArrays NumSharp
        public void NDArrayPrints()
        {
            if (Bars.ClosePrices.Count < BarsRequired)
                return;

            try
            {
                // Appel de vos données d'entrée float[,]
                float[,] inputData = GetDataSet();

                // Convertir en NDArray et remodeler en (BarsRequired, 5)
                NDArray inputNDArray = np.array(inputData);   // NumSharp
                Print("Données NDarray NumSharp d'entrée : " + string.Join(", ", inputNDArray));
                Print("Forme NDarray NumSharp d'entrée : " + string.Join(", ", inputNDArray.shape));
                
                int expectedLength = BarsRequired * 5;
                Print($"Longueur NDarray NumSharp attendue : {expectedLength}");
                Print($"Taille NDarray NumSharp d'entrée : {inputNDArray.size}");

                if (inputNDArray.size != expectedLength)
                {
                    Print($"Incohérence de longueur : longueur attendue {expectedLength}, mais taille obtenue {inputNDArray.size}");
                    return;
                }
            }
            catch (Exception ex)
            {
                Print("Exception : " + ex.Message);
                Print("Trace de la pile : " + ex.StackTrace);

                Exception innerException = ex.InnerException;
                while (innerException != null)
                {
                    Print("Exception interne : " + innerException.Message);
                    Print("Trace de la pile de l'exception interne : " + innerException.StackTrace);
                    innerException = innerException.InnerException;
                }
            }
        }
    }
}