E7 BBKG NumSharp Sample
شعار "E7 BBKG NumSharp Sample"
03/09/2025
71
Desktop, Mobile, Web
Since 18/12/2024
Free installs
2347
صورة "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.
مؤشر
Indices
E7 BlackScholes Model
Option pricing using the BlackScholes model and the Math.Numerics packages
مؤشر
Bollinger
E7 Indicators Free Overlays
Bollinger Band Cloud, Heiken Ashi, Trend Follower and Parabolic SAR.
مؤشر
Bollinger
E7 Indicators Free Studies
ADXR, KDJ, SineWave, Bollinger Band Volatility and AEOscillator.
قد يعجبك أيضًا
cBot
RSI
NZDUSD
XAUUSD
+16
Fpmarket ORB 1-5min
ORB fully automated trading strategies #candle confirmation
cBot
Forex
Crypto
DMG GOLDEN For Time M5 Trial Day -15
DMG Golden for Bot Time
cBot
USDJPY
777 - Propfirm PASS Low Risk - adjustable cBOT Enc DEMO
USD/JPY Specialist
cBot
Breakout
XAUUSD
Commodities
+3
Gold Pulse Pro
Gold Pulse Pro – An automated trading system for gold (XAUUSD) precisely engineered and powered by advanced algorithms
cBot
Signal
High Profit CADJPY
Bot is based on Price Action strategy to open & manage orders. It is effective capital management and high profitability
Scalping Bot
Der MultiStrategyScalpingBot ist ein automatisierter Handelsroboter für die cAlgo-Plattform.
cBot
NAS100
XAUUSD
Commodities
+8
Ai Forex Driven Lite
AI Forex Lite · 14 Symbols · $50 Profit Cap Auto-trade NAS100, Gold, EURUSD, BTC and more with low risk. Smart limits.
PREMIUM AUTOEXIT BOT
AUTOEXIT BOT: SL de Seguridad y Trailing Stop para Trades Manuales, diseñado para gestionar automática de salidas.
Rsi Div (1)
RSI Scalping cBot—plug‑and‑play precision scalper for volatile indexes and symbols.
cBot
RSI
Breakout
XAUUSD
+7
Professional Multi-Tech EA Demo
Advanced Trading Robot - RSI + MACD + Ichimoku Strategy with Dynamic Risk Management for Gold and Major Currency Pairs
cBot
Grid
NAS100
NZDUSD
+12
🎯 Cwebhook Trade Manager
Trade manager with partial TP %, breakeven, trailing stop, equity protection, and drawdown recovery.
11 YEARS PROFITABLE - EURUSD RENKO CHART - FREE TEST
EURUSD RE5 PROFITABLE SINCE 2014
FTMO_1
XAU/USD SWING BOT
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
Indices
Stocks
Forex
+1
WeeklySMACrossBot_777_Cloud
Smart automated trading. Our bot works 24/7 to grow your capital while you relax. Effortless, intelligent, and secure.
cBot
Forex
Crypto
DMG BTCUSD-ETHUSD Cbot 15 DAY TRIAL
DMG BTCUSD-ETHUSD C bot 15 DAY TRIAL
cBot
Indices
Martingale
EURUSD
+1
USTEC 3000,- EURO per MONTH FREE TEST
FREE TEST UNTIL 07.02.25 - profitable since 01.01.2020 with average 15% per Month
cBot
Grid
XAUUSD
Prop
Prop Firm Strategy (Made with AlgoBuilderX)
This strategy is tailored for Prop Firm accounts, featuring automated risk management to prevent breaching loss limits.