Логотип продукта "E7 BBKG NumSharp Sample"
E7 BBKG NumSharp Sample
0.0
03/09/2025
58
Desktop, Mobile, Web
Загруженное изображение продукта "E7 BBKG NumSharp Sample"

As requested by many of you, we are now working hard to provide examples of some of our machine learning code and packages.

TensorFlow, PyTorch, Keras, Numpy, Pandas and many more .NET packages to get going inside of cTrader.

Our mission is to make Machine Learning inside cTrader easier for everyone.

Happy hunting!

*** This code does not trade anything (it only prints out data etc). It is simply sample code of how you can start creating your own AI models using our Machine Learning packages.

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

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()
        {
            // Initialize any indicators
        }

        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($"Inner Exception: {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;
        }
        
        /// NumSharp Data Split Prints
        public void DataSplitPrints()
        {
            // Reshape input data to match the model's expected input shape
            //var inputShape = new Shape(-1, BarsRequired, 5);
            NDArray inputData = np.array<float>(GetDataSet());
            Print("Input NDarray: " + string.Join(", ", inputData));
            
            // Reshape target data to match the target shape expected by the model
            //var targetShape = new Shape(-1, 5);
            NDArray targetData = np.array<float>(GetTargetDataSet());
            Print("Target NDarray: " + string.Join(", ", targetData));
            
            // Split data into training and test sets
            int testSize = (int)(0.2 * inputData.shape[0]); // 20% for testing
            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("X_train data: " + string.Join(", ", x_train));
            Print("X_test data: " + string.Join(", ", x_test));
            Print("Y_train data: " + string.Join(", ", y_train));
            Print("Y_test data: " + string.Join(", ", y_test));
        }
        
        /// PandasNet Prints
        public void PandasPrints()
        {
            // Convert float[,] to 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()));
            }
            
            // Create DataFrames
            DataFrame inputDataFrame = new DataFrame(inputSeriesList);
            DataFrame targetDataFrame = new DataFrame(targetSeriesList);
            
            Print("Input DataFrame: " + inputDataFrame);
            Print("Target DataFrame: " + targetDataFrame);
            
            //Print("Input DataFrame: " + string.Join(", ", inputDataFrame));
            //Print("Target DataFrame: " + string.Join(", ", targetDataFrame));
        }
        
        /// Simple NumSharp NDArrays Prints
        public void NDArrayPrints()
        {
            if (Bars.ClosePrices.Count < BarsRequired)
                return;

            try
            {
                // Calling your Input Data float[,]
                float[,] inputData = GetDataSet();

                // Convert to NDArray and reshape to (BarsRequired, 5)
                NDArray inputNDArray = np.array(inputData);   // NumSharp
                Print("Input NumSharp NDarray Data : " + string.Join(", ", inputNDArray));
                Print("Input NumSharp NDarray Shape: " + string.Join(", ", inputNDArray.shape));
                
                int expectedLength = BarsRequired * 5;
                Print($"Expected NumSharp NDarray Length: {expectedLength}");
                Print($"Input NumSharp NDarray Size: {inputNDArray.size}");

                if (inputNDArray.size != expectedLength)
                {
                    Print($"Length MisMatch: Expected Length {expectedLength}, but got Size {inputNDArray.size}");
                    return;
                }
            }
            catch (Exception ex)
            {
                Print("Exception: " + ex.Message);
                Print("StackTrace: " + ex.StackTrace);

                Exception innerException = ex.InnerException;
                while (innerException != null)
                {
                    Print("Inner Exception: " + innerException.Message);
                    Print("Inner Exception StackTrace: " + innerException.StackTrace);
                    innerException = innerException.InnerException;
                }
            }
        }
    }
}

Больше от этого автора
Высокий рейтинг
E7 Polynomial Regression Channel
Polynomial Regression Channel which also reflects the volatility of the underlying asset.
E7 BBKG Indicator
E7 BBKG indicator with 80% plus accuracy used to show both, possible reversal and trend.
E7 Volume Profile
E7 Volume Profile, more modern look and feel.
Высокий рейтинг
E7 Harmonic Structures Basic
E7 Harmonic Structures Basic.
E7 Correlation Dashboard
E7 Correlation Dashboard.
E7 BlackScholes Model
Option pricing using the BlackScholes model and the Math.Numerics packages
E7 Indicators Free Overlays
Bollinger Band Cloud, Heiken Ashi, Trend Follower and Parabolic SAR.
E7 Indicators Free Studies
ADXR, KDJ, SineWave, Bollinger Band Volatility and AEOscillator.
E7 cTrader User ID
cTrader ID
Вам также может понравиться
SNR Engulfing Pattern Bot
The SNR Engulfing Bot trades SNR levels and engulfing patterns, automating price action strategies for cTrader users.
Bot RSI Medio
Test the RSI Forex Bot for free on EURUSD & GBPJPY with core RSI reversal features. Upgrade to Pro for 50%+ monthly
сиБот
forex
scalping
UltimateScalper H1
Special H1-Version of UltimateScalper for EUR/GBP ... win rate 100% ... ROI 830%
Новинка
BETA DASHBOT
DASHBOT muestra en tiempo real el Spread, Lote, Comisión, Trailing Stop sugerido y Ruido de mercado en pips.
сиБот
forex
prop
eurusd
+2
QuantumGuard (Full Version)
QuantumGuard - EURUSD in H2 - More than 100% profit per year
сиБот
btcusd
xauusd
atr
+2
QuantumLimit (Full Version)
QuantumLimit - XAUUSD/BTCUSD - up to 100 000 %+ cumulative ROI
DexAI
Smart Trading, Powered by AI – Let Algorithms Work for You! ENJOY!
сиБот
ai
rsi
macd
needThai Smart Trend Trading AI Bot
Smart Trend Trading Bot, Best Trend Identified, Please try default setting before making any changes
SarahMM2
Un robot de trading intelligent basé sur le croisement de moyennes mobiles, avec un drawdown maîtrisé et une rentabilité
FibonacciStrategyCBot
FiboSmart cBot automates Fibonacci-based trading with trend, RSI, and MACD filters, plus built-in money management, trai
EngulfingCoreBotPro
Engulfing Pattern cBot Pro: Smart candlestick trading with filters, risk control & daily protection.
сиБот
indices
rsi
SP500 up to 40% (13-09-24 - 09-03-25) Short edition
N.B.: Results with an initial invested capital of 100 euros.
сиБот
breakout
forex
bollinger
+5
Investion X V1.9 - Intelligent Filter-Based Trading System
Trading system combining martingale strategy with multi-layered technical analysis and comprehensive protection features
сиБот
eurusd
grid
DistEMATrendBot1.1 (demo)
A trend following cBot using moving averages, ADX, and least squares regression to identify and extrapolate a trend.
RSI2 - F17and20EMA
This bot implements the well-known 2-period RSI strategy, enhanced by a powerful filter comprised of two exponential mov
GSE CancelSymbolPendingsOrdersAtTimeDemo_noSourceCode
Cancel Symbol Pendings Orders At Time - Discover the benefits of cBot for Pending Order Management! - FREE demo version
jj trading
🚀 cBot Profissional para XAUUSD – Performance, Precisão e Automação Total Otimize seus resultados no mercado com nosso
EMA SMA NASSIMI
SMA EMA NASSIMI" is a powerful and free cBot designed for cTrader, leveraging SMA (Simple Moving Average) and EMA (Expon