E7 BBKG NumSharp Sample
Logo "E7 BBKG NumSharp Sample"
03/09/2025
71
Desktop, Mobile, Web
Since 18/12/2024
Free installs
2344
Ảnh "E7 BBKG NumSharp Sample" được tải lên

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;
                }
            }
        }
    }
}

Sản phẩm khác của tác giả này
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.
Chỉ báo
Indices
E7 BlackScholes Model
Option pricing using the BlackScholes model and the Math.Numerics packages
Chỉ báo
Bollinger
E7 Indicators Free Overlays
Bollinger Band Cloud, Heiken Ashi, Trend Follower and Parabolic SAR.
Chỉ báo
Bollinger
E7 Indicators Free Studies
ADXR, KDJ, SineWave, Bollinger Band Volatility and AEOscillator.
Bạn cũng có thể thích
Order Block Hedging Strategy (Made with AlgoBuilderX)
The strategy identifies order blocks from impulsive moves, opening trades with fixed stop loss and take profit.
cBot
ATR
Signal
BTCUSD
+1
CriptoCrossoverBotFree
Adquiere su máximo potencial con la versión de paga / Get your full potential with the paid version.
cBot
NAS100
NZDUSD
XAUUSD
+7
DragonNewsBot
This is a fully automated news-driven trading robo
cBot
Martingale
Range Bar Strategy and Martingale (Made With AlgoBuilderX)
The Range Bar Strategy uses candlestick shadow conditions and a Martingale system for precise trade entries and sizing.
cBot
Forex
DMG SPEED LIKE a JET DEMO
Il DMG SPEED LIKE a JET DEMO è un sistema di trading automatico progettato per operare esclusivamente su Valute e Gold
cBot
RSI
US2000 up to 100 % (24-11-2024 - 09-03-2025) Short edition
🚀 N.B.: Results with an initial invested capital of 100 euros.🚀 📌 Tested on US2000 with Accurate Prices
cBot
Grid
XAUUSD
ATR
+2
QuantumLimit (Full Version)
QuantumLimit - XAUUSD/BTCUSD - up to 100 000 %+ cumulative ROI
cBot
RSI
Indices
Stocks
+2
WCAP
Wealthcraft Auto Profit is a smart trading robot with Auto Stop-Loss, Trailing Stop, and maximum profit management
cBot
Indices
Prop
Commodities
+3
Lot Sizer Pro
Lot Sizer Pro Risk Management Tool with Draggable Lines
cBot
Supertrend
Signal
High Profit EURAUD
Bot is based on Price Action strategy to open & manage orders. It is effective capital management and high profitability
needThaiBot for Sniping Trade
This is a Sniper bot is for Fast Sniping Trade , suitable for shorter Timeframes
jj trading
🚀 cBot Profissional para XAUUSD – Performance, Precisão e Automação Total Otimize seus resultados no mercado com nosso
USH-AUDUSD
Perfectly optimized to trade AUDUSD. Over 85% win rate
cBot
Grid
XAUUSD
Commodities
+2
DragonGoldEAProNet6Demo
Demo version of https://ctrader.com/products/315
cBot
Grid
Martingale
Forex
+1
GridStormX
Aggressive scalping grid strategy using martingale with rapid order stacking and dynamic recovery.
cBot
Breakout
XAUUSD
Martingale
+3
Elite_Tactics_BotWith bot
EliteTactics Bot è un algoritmo avanzato per cTrader per operare su XAUUSD (oro) e coppie forex
cBot
RSI
Forex
Signal
+1
BollingerRsiCombinedBot
This strategy combines two popular technical indicators to identify high‑probability trading opportunities
cBot
Indices
RSI
SmartBot-Fibonacci
This bot is made of Fibonacci, EMA and RSI.