Descripción
Como muchos de ustedes solicitaron, ahora estamos trabajando arduamente para proporcionar ejemplos de algunos de nuestros códigos y paquetes de aprendizaje automático.
TensorFlow, PyTorch, Keras, Numpy, Pandas y muchos más paquetes .NET para comenzar dentro de cTrader.
Nuestra misión es hacer que el aprendizaje automático dentro de cTrader sea más fácil para todos.
¡Buena caza!
*** Este código no realiza operaciones (solo imprime datos, etc.). Es simplemente un código de ejemplo de cómo puedes comenzar a crear tus propios modelos de IA usando nuestros paquetes de aprendizaje automático.
.......................................................
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("Versión 1.01", DefaultValue = "Versión 1.01")]
public string Version { get; set; }
[Parameter("Fuente")]
public DataSeries Source { get; set; }
[Parameter("Barras Requeridas", DefaultValue = 50, MinValue = 1, MaxValue = 10000, Step = 1)]
public int BarsRequired { get; set; }
[Parameter("Nombre del Método", DefaultValue = MethodName.DataSplitPrints)]
public MethodName Mode { get; set; }
public enum MethodName
{
DataSplitPrints,
PandasPrints,
NDArrayPrints
}
protected override void OnStart()
{
// Inicializar cualquier indicador
}
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($"Error: {ex.Message}");
if (ex.InnerException != null)
{
Print($"Excepción Interna: {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;
}
/// Impresiones de división de datos de NumSharp
public void DataSplitPrints()
{
// Remodelar los datos de entrada para que coincidan con la forma esperada por el modelo
//var inputShape = new Shape(-1, BarsRequired, 5);
NDArray inputData = np.array<float>(GetDataSet());
Print("NDarray de entrada: " + string.Join(", ", inputData));
// Remodelar los datos objetivo para que coincidan con la forma objetivo esperada por el modelo
//var targetShape = new Shape(-1, 5);
NDArray targetData = np.array<float>(GetTargetDataSet());
Print("NDarray objetivo: " + string.Join(", ", targetData));
// Dividir los datos en conjuntos de entrenamiento y prueba
int testSize = (int)(0.2 * inputData.shape[0]); // 20% para pruebas
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("Datos X_train: " + string.Join(", ", x_train));
Print("Datos X_test: " + string.Join(", ", x_test));
Print("Datos Y_train: " + string.Join(", ", y_train));
Print("Datos Y_test: " + string.Join(", ", y_test));
}
/// Impresiones de PandasNet
public void PandasPrints()
{
// Convertir float[,] a 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()));
}
// Crear DataFrames
DataFrame inputDataFrame = new DataFrame(inputSeriesList);
DataFrame targetDataFrame = new DataFrame(targetSeriesList);
Print("DataFrame de entrada: " + inputDataFrame);
Print("DataFrame objetivo: " + targetDataFrame);
//Print("Input DataFrame: " + string.Join(", ", inputDataFrame));
//Print("Target DataFrame: " + string.Join(", ", targetDataFrame));
}
/// Impresiones simples de NDArray de NumSharp
public void NDArrayPrints()
{
if (Bars.ClosePrices.Count < BarsRequired)
return;
try
{
// Llamando a tus datos de entrada float[,]
float[,] inputData = GetDataSet();
// Convertir a NDArray y remodelar a (BarsRequired, 5)
NDArray inputNDArray = np.array(inputData); // NumSharp
Print("Datos de NDarray NumSharp de entrada : " + string.Join(", ", inputNDArray));
Print("Forma de NDarray NumSharp de entrada: " + string.Join(", ", inputNDArray.shape));
int expectedLength = BarsRequired * 5;
Print($"Longitud esperada de NDarray NumSharp: {expectedLength}");
Print($"Tamaño de NDarray NumSharp de entrada: {inputNDArray.size}");
if (inputNDArray.size != expectedLength)
{
Print($"Desajuste de longitud: longitud esperada {expectedLength}, pero se obtuvo tamaño {inputNDArray.size}");
return;
}
}
catch (Exception ex)
{
Print("Excepción: " + ex.Message);
Print("Rastro de pila: " + ex.StackTrace);
Exception innerException = ex.InnerException;
while (innerException != null)
{
Print("Excepción interna: " + innerException.Message);
Print("Rastro de pila de excepción interna: " + innerException.StackTrace);
innerException = innerException.InnerException;
}
}
}
}
}
Resumen
Key functionalities include:
- Data extraction from market bars (open, high, low, close prices, and tick volumes) over a configurable number of bars.
- Conversion of this data into formats compatible with machine learning workflows, including NumSharp NDArrays and Pandas DataFrames.
- Methods to split data into training and testing sets, and to print these datasets for inspection.
- Three operational modes selectable via parameters: DataSplitPrints, PandasPrints, and NDArrayPrints, each demonstrating different data handling approaches.
This sample code aims to facilitate machine learning development inside cTrader by providing foundational examples of data preparation and manipulation using popular ML libraries in a .NET context.