Challenges and Strategies for Developing Trading Robots with Advanced AI and Neural Networks

Canberk Dogan Denizli 2023.03.22 15:00

Trading robots, also known as Expert Advisors (EAs) in the MQL5 language, have become increasingly popular in the financial markets. With the advancement of artificial intelligence and machine learning techniques, trading robots can now incorporate sophisticated algorithms that can learn from data and make intelligent trading decisions.

However, developing trading robots with advanced AI and neural networks is not without its challenges. One of the main difficulties is the complexity of the algorithms involved. Neural networks can have many layers and parameters, and optimizing them can be a time-consuming process. Additionally, creating a trading strategy that performs well in different market conditions can be challenging.

In this discussion, we can explore the challenges of developing trading robots with advanced AI and neural networks and discuss strategies for overcoming these challenges. We can share tips on how to optimize neural network parameters and how to create effective trading strategies. We can also discuss the best practices for testing and backtesting trading robots to ensure their reliability and accuracy.

Overall, this topic can be a great opportunity for developers to share their experiences and learn from each other on the complex and rewarding journey of building trading robots with advanced AI and neural networks.

One of the key features of MQL5 is its support for machine learning libraries, such as TensorFlow and PyTorch. These libraries can be integrated with MQL5 to create powerful trading robots that can learn from data and make intelligent decisions.

To use these libraries, developers can write custom code in MQL5 to interface with the machine learning libraries. This involves creating functions to load data into the library, train the neural network, and make predictions based on the trained model. Developers can also create custom indicators and other tools to visualize the data and results of the machine learning algorithms.

One challenge of using machine learning in trading robots is the need for large amounts of data. Developers need to gather and process data from multiple sources, such as financial databases and news feeds, to train the neural network effectively. Additionally, developers need to carefully select the data to ensure that it is relevant to the trading strategy and free of biases.

Another challenge is the optimization of the neural network's parameters. This involves tuning the values of the network's hyperparameters, such as the number of layers, the number of neurons in each layer, and the learning rate. Developers can use various techniques, such as grid search and random search, to optimize these parameters and find the best configuration for the network.

MQL5 also provides a range of tools for testing and backtesting trading robots. The built-in Strategy Tester allows developers to test their robots on historical data and evaluate their performance. Additionally, MQL5 supports real-time testing and optimization, which allows developers to fine-tune their robots based on current market conditions.

In conclusion, developing trading robots with advanced AI and neural networks in MQL5 requires a combination of technical skills in programming and machine learning, as well as a deep understanding of the financial markets. MQL5's support for machine learning libraries and advanced testing and optimization tools make it a powerful platform for developing intelligent trading robots.

Moving Average Crossover Robot: This is a simple but popular strategy in which the robot enters a long position when the short-term moving average crosses above the long-term moving average, and enters a short position when the short-term moving average crosses below the long-term moving average.

Here is an example of MQL5 code for a moving average crossover robot:

int OnInit()
{
   // Set up indicators
   IndicatorShortName("MA Cross");
   SetIndexBuffer(0, ma);
   SetIndexStyle(0, DRAW_LINE);
   SetIndexLabel(0, "MA");

   // Set up parameters
   SetInputParameters(
      "MA Period", 12,
      "MA Shift", 0
   );

   return(INIT_SUCCEEDED);
}

void OnTick()
{
   double ma_short = iMA(_Symbol, _Period, 12, 0, MODE_SMA, PRICE_CLOSE, 0);
   double ma_long = iMA(_Symbol, _Period, 24, 0, MODE_SMA, PRICE_CLOSE, 0);

   if (ma_short > ma_long)
   {
      OrderSend(_Symbol, OP_BUY, 0.1, Ask, 3, Bid-StopLoss*Point, Ask+TakeProfit*Point, "MA Cross", 12345, 0, Green);
   }
   else if (ma_short < ma_long)
   {
      OrderSend(_Symbol, OP_SELL, 0.1, Bid, 3, Ask+StopLoss*Point, Bid-TakeProfit*Point, "MA Cross", 12345, 0, Red);
   }
}

Here's an example of how you can create a simple trading robot using a neural network in MQL5:

// Include the necessary libraries
#include <TensorFlow.mqh>
#include <Trade\Trade.mqh>

// Define the input and output layers of the neural network
#define INPUT_SIZE 4
#define OUTPUT_SIZE 1

// Define the number of hidden layers and nodes
#define NUM_HIDDEN_LAYERS 2
#define NUM_NODES 8

// Define the trading parameters
input double Lots = 0.1;
input double StopLoss = 50;
input double TakeProfit = 100;

// Define the neural network class
class NeuralNetwork
{
private:
    int m_NumInputNodes;
    int m_NumOutputNodes;
    int m_NumHiddenLayers;
    int m_NumNodesPerLayer;
    tf::Session m_Session;
    tf::GraphDef m_GraphDef;
    tf::Tensor m_InputTensor;
    tf::Tensor m_OutputTensor;
public:
    NeuralNetwork(int num_input_nodes, int num_output_nodes, int num_hidden_layers, int num_nodes_per_layer)
    {
        // Initialize the variables
        m_NumInputNodes = num_input_nodes;
        m_NumOutputNodes = num_output_nodes;
        m_NumHiddenLayers = num_hidden_layers;
        m_NumNodesPerLayer = num_nodes_per_layer;
        
        // Load the TensorFlow graph
        m_Session.LoadGraph("neural_network.pb", m_GraphDef);
        
        // Initialize the input and output tensors
        m_InputTensor = tf::Tensor(tf::DT_FLOAT, {1, m_NumInputNodes});
        m_OutputTensor = tf::Tensor(tf::DT_FLOAT, {1, m_NumOutputNodes});
    }
    
    double Predict(double input[])
    {
        // Copy the input data to the input tensor
        for (int i = 0; i < m_NumInputNodes; i++)
        {
            m_InputTensor.tensor<float, 2>()(0, i) = input[i];
        }
        
        // Run the input through the neural network
        tf::Session::FeedDict feed_dict = {
            { m_GraphDef.node(0).name(), m_InputTensor }
        };
        std::vector<tf::Tensor> output_tensors = m_Session.Run(feed_dict, { m_OutputTensor });
        
        // Return the output value
        return output_tensors[0].tensor<float, 2>()(0, 0);
    }
};

// Define the trading robot class
class TradingRobot
{
private:
    NeuralNetwork m_NeuralNetwork;
    CTrade m_Trade;
public:
    TradingRobot()
    {
        // Initialize the neural network

William Roeder 2023.03.22 21:43 #1

Canberk Dogan Denizli: Here is an example of MQL5 code for a moving average crossover robot:

   double ma_short = iMA(_Symbol, _Period, 12, 0, MODE_SMA, PRICE_CLOSE, 0);
   double ma_long = iMA(_Symbol, _Period, 24, 0, MODE_SMA, PRICE_CLOSE, 0);
        
        OrderSend(_Symbol, OP_BUY, 0.1, Ask, 3, Bid-StopLoss*Point, Ask+TakeProfit*Point, "MA Cross", 12345, 0, Green);

MT5 iMA does not return a double, and does not contain a bar index. MQL5 OrderSend only has two. That is NOT MQL5 code.

```
SetInputParameters
```
There is no such function in MQLx
You buy at the Ask and sell at the Bid. Pending Buy Stop orders become market orders when hit by the Ask.
1. Your buy order's TP/SL (or Sell Stop's/Sell Limit's entry) are triggered when the Bid / OrderClosePrice reaches it. Using Ask±n, makes your SL shorter and your TP longer, by the spread. Don't you want the specified amount used in either direction?
2. Your sell order's TP/SL (or Buy Stop's/Buy Limit's entry) will be triggered when the Ask / OrderClosePrice reaches it. To trigger close at a specific Bid price, add the average spread.
  MODE_SPREAD (Paul) - MQL4 programming forum - Page 3 #25
3. The charts show Bid prices only. Turn on the Ask line to see how big the spread is (Tools → Options (control+O) → charts → Show ask line.)
  
  Most brokers with variable spreads widen considerably at end of day (5 PM ET) ± 30 minutes.
  My GBPJPY shows average spread = 26 points, average maximum spread = 134.
  My EURCHF shows average spread = 18 points, average maximum spread = 106.
  (your broker will be similar).
  Is it reasonable to have such a huge spreads (20 PIP spreads) in EURCHF? - General - MQL5 programming forum (2022)

Ask and Bid price Problem with average price 'OnInit' - unexpected token

Alain Verleyen 2023.03.22 21:48 #2

William Roeder #:

MT5 iMA does not return a double, and does not contain a bar index. MQL5 OrderSend only has two. That is NOT MQL5 code.

Don't worry, this is only an advertising topic from a product's seller.

Fernando Carreiro 2023.03.22 22:26 #3

Alain Verleyen #: Don't worry, this is only an advertising topic from a product's seller.

Then, if it is "advertising", it should be deleted.

Alain Verleyen 2023.03.22 22:52 #4

Fernando Carreiro #:

Then, if it is "advertising", it should be deleted.

It's my opinion only, there is no direct advertising.

New comment