E7 BBKG NumSharp Sample
"E7 BBKG NumSharp Sample" logosu
03/09/2025
80
Desktop, Mobile, Web
"E7 BBKG NumSharp Sample" yüklenen resmi

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

0.0
Değerlendirmeler: 0
Müşteri değerlendirmeleri
Bu ürün için henüz bir değerlendirme yok. Ürünü denediniz mi? O zaman ona dair görüşlerini paylaşan ilk kişi olun!
Bu oluşturanın diğer ürünleri
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.
En yüksek puanlı
Ücretsiz
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.
Gösterge
Indices
E7 BlackScholes Model
Option pricing using the BlackScholes model and the Math.Numerics packages
Gösterge
Bollinger
E7 Indicators Free Overlays
Bollinger Band Cloud, Heiken Ashi, Trend Follower and Parabolic SAR.
Gösterge
Bollinger
E7 Indicators Free Studies
ADXR, KDJ, SineWave, Bollinger Band Volatility and AEOscillator.
Şunları da beğenebilirsiniz
cBot
RSI
Indices
XAUUSD
+9
Super USD Trio AI-DEMO-v1
Super USD Trio AI is a smart, multi-symbol Forex trading robot tailored for EURUSD, USDJPY, and GBPUSD.
cBot
USDJPY
777 - INTERMEDIATE - Adjustable risk cBOT Enc DEMO
USD/JPY Specialist cBOT
cBot
Supertrend
Signal
[Fx4U] EURAUD - Price Action
Bot is based on Price Action strategy to open & manage orders. It is effective capital management and high profitability
cBot
NAS100
NZDUSD
RSI
+18
Ai_Scalping Pro
cBot with a fully functional ATR-based trailing stop system and an optional trailing step filter for smoother adjustment
cBot
Forex
Signal
Golden Cross & Death Cross (Made with AlgoBuilderX)
The strategy uses EMA crossovers (Golden/Death Cross) on a 1H timeframe, opening 4 trades at a time for forex entries.
cBot
Forex
Supertrend
Signal
+1
[Fx4U] GBPUSD - Price Action
Bot is based on Price Action strategy to open & manage orders. It is effective capital management and high profitability
posilabel
Display the rate value for the position and the type of pending order.
cBot
Indices
Commodities
Forex
+1
Smart EMA Crossover Daily Trend Confirmation Net Profit
EMA Crossover Advanced Bot Smart Trend Trading Robot for cTrader with Daily Confirmation & USD Trailing Stop
cBot
Grid
Prop
XAUUSD
Prop Firm Strategy (Made with AlgoBuilderX)
This strategy is tailored for Prop Firm accounts, featuring automated risk management to prevent breaching loss limits.
cBot
Martingale
Forex
EURUSD
QUANTUM MASTER - FREE TEST
EURUSD M2 FREE BACKTEST UNTIL 16.01.2025 # 24% PER MONTH
cBot
ATR
LT_RiskGuardian
Auto-manages SL, TP, and position size to enforce risk discipline. Never enter a trade without a plan again.
GJ-M5-Scalper-V1
This cBot "GBPJPYM5ScalperX" implements a scalping strategy on the GBP/JPY 5-minute chart.
cBot
XAUUSD
Commodities
Supertrend
+2
PTFX Supertrend Gold
Dominate gold markets with Supertrend Gold – Backtested with +962% ROI!
cBot
NAS100
XAUUSD
Martingale
+3
Stop Order
Scalping V.1 (Stop Order TP + SL)
cBot
RSI
MACD
AI
needThaiBot The Ultimate Trading Bot
Auto increase lot on how many percent profits you made, please try default setting before making any changes
cBot
Crypto
BTCUSD
BITCOIN_BOT_V0
Transform Small Investments Into Bitcoin Success : It's not too late to make money with Bitcoin
cBot
Grid
NAS100
NZDUSD
+17
RISK SHIELD V1.0(ENG-RUS) be for 31.12.2026
RISK SHIELD - Smart Risk Manager for cTrader.• Your license is valid until: December 31, 2026.
Trailing Stop and Filter
After the position achieves a certain profit, I move the stop loss to the set distance to protect the profit.