NeuroBook/Include/realization/defines.mqh

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+

//|                                                      Defines.mqh |

//|                                  Copyright 2021, MetaQuotes Ltd. |

//|                                             https://www.mql5.com |

//+------------------------------------------------------------------+

#property copyright "Copyright 2021, MetaQuotes Ltd."

#property link      "https://www.mql5.com"

//+------------------------------------------------------------------+

//| Resources                                                        |

//+------------------------------------------------------------------+

#resource "opencl_program.cl" as string OCLprogram

//---

#define TYPE                          double

#define MATRIX                        matrix<TYPE>

#define VECTOR                        vector<TYPE>

#define LOCAL_SIZE                    256

const string ExtType=StringFormat("#define TYPE %s\r\n"

                                  "#define TYPE4 %s4\r\n"

                                  "#define LOCAL_SIZE %d\r\n",

                                   typename(TYPE),typename(TYPE),LOCAL_SIZE);

#define cl_program                    ExtType+OCLprogram

//---

#define defLossSmoothFactor            1000

#define defLearningRate                (TYPE)3.0e-4

#define defBeta1                       (TYPE)0.9

#define defBeta2                       (TYPE)0.999

#define defLambdaL1                    (TYPE)0

#define defLambdaL2                    (TYPE)0

//+------------------------------------------------------------------+

//| Constants                                                        |

//+------------------------------------------------------------------+

#define Defines

#define defNeuronNet                0x8000

#define defArrayLayers              0x8001

#define defBuffer                   0x8002

#define defActivation               0x8003

#define defLayerDescription         0x8004

#define defNeuronBase               0x8010

#define defNeuronConv               0x8011

#define defNeuronProof              0x8012

#define defNeuronLSTM               0x8013

#define defNeuronAttention          0x8014

#define defNeuronMHAttention        0x8015

#define defNeuronGPT                0x8016

#define defNeuronDropout            0x8017

#define defNeuronBatchNorm          0x8018

//---

#define defFileName                 StringFormat("%s_%s_%s.nns",MQLInfoString(MQL_PROGRAM_NAME),_Symbol,StringSubstr(EnumToString(_Period),7))

//+------------------------------------------------------------------+

//| OpenCL kernels                                                   |

//+------------------------------------------------------------------+

#define def_k_PerceptronFeedForward    0

#define def_k_LineActivation           1

#define def_k_SigmoidActivation        2

#define def_k_SigmoidDerivative        3

#define def_k_TANHActivation           4

#define def_k_TANHDerivative           5

#define def_k_LReLuActivation          6

#define def_k_LReLuDerivative          7

#define def_k_SoftMAXActivation        8

#define def_k_SoftMAXDerivative        9

#define def_k_SwishActivation          10

#define def_k_SwishDerivative          11

#define def_k_CalcOutputGradient       12

#define def_k_CalcHiddenGradient       13

#define def_k_CalcDeltaWeights         14

#define def_k_SGDUpdate                15

#define def_k_MomentumUpdate           16

#define def_k_AdaGradUpdate            17

#define def_k_RMSPropUpdate            18

#define def_k_AdaDeltaUpdate           19

#define def_k_AdamUpdate               20

#define def_k_ProofFeedForward         21

#define def_k_ProofHiddenGradients     22

#define def_k_ConvolutionFeedForward   23

#define def_k_ConvolutionHiddenGradients  24

#define def_k_ConvolutionDeltaWeights  25

#define def_k_LSTMFeedForward          26

#define def_k_LSTMHiddenGradients      27

#define def_k_AttentionFeedForward     28

#define def_k_AttentionScoreGradients  29

#define def_k_AttentionHiddenGradients 30

#define def_k_Sum                      31

#define def_k_LayerNormalize           32

#define def_k_LayerNormalizeGradient   33

#define def_k_GPTFeedForward           34

#define def_k_GPTScoreGradients        35

#define def_k_GPTHiddenGradients       36

#define def_k_BatchNormFeedForward     37

#define def_k_BatchNormCalcHiddenGradient 38

#define def_k_BatchNormCalcDeltaWeights   39

#define def_k_MaskMult                 40

#define def_k_Split                    41

#define def_k_Concatenate              42

//+------------------------------------------------------------------+

//| OpenCL parameters                                                |

//+------------------------------------------------------------------+

//--- perceptron feed-forward pass

#define def_pff_inputs                 0

#define def_pff_weights                1

#define def_pff_outputs                2

#define def_pff_inputs_total           3

//--- define the error gradient of the results layer

#define def_outgr_target               0

#define def_outgr_outputs              1

#define def_outgr_gradients            2

#define def_outgr_loss_function        3

//--- define the error gradient of the hidden layer

#define def_hidgr_gradient_inputs      0

#define def_hidgr_weights              1

#define def_hidgr_gradients            2

#define def_hidgr_outputs_total        3

//--- define the error gradient at the weight matrix level

#define def_delt_inputs                0

#define def_delt_delta_weights         1

#define def_delt_gradients             2

//--- optimize parameters using stochastic gradient descent

#define def_sgd_delta_weights          0

#define def_sgd_weights                1

#define def_sgd_total                  2

#define def_sgd_batch_size             3

#define def_sgd_learningRate           4

#define def_sgd_Lambda1                5

#define def_sgd_Lambda2                6

//--- optimize parameters using momentum method

#define def_moment_delta_weights       0

#define def_moment_weights             1

#define def_moment_momentum            2

#define def_moment_total               3

#define def_moment_batch_size          4

#define def_moment_learningRate        5

#define def_moment_beta                6

#define def_moment_Lambda1             7

#define def_moment_Lambda2             8

//--- optimize parameters using the AdaGrad method

#define def_adagrad_delta_weights      0

#define def_adagrad_weights            1

#define def_adagrad_momentum           2

#define def_adagrad_total              3

#define def_adagrad_batch_size         4

#define def_adagrad_learningRate       5

#define def_adagrad_Lambda1            6

#define def_adagrad_Lambda2            7

//--- optimize parameters using the RMSProp method

#define def_rms_delta_weights          0

#define def_rms_weights                1

#define def_rms_momentum               2

#define def_rms_total                  3

#define def_rms_batch_size             4

#define def_rms_learningRate           5

#define def_rms_beta                   6

#define def_rms_Lambda1                7

#define def_rms_Lambda2                8

//--- optimize parameters using the AdaDelta method

#define def_adadelt_delta_weights      0

#define def_adadelt_weights            1

#define def_adadelt_momentumW          2

#define def_adadelt_momentumG          3

#define def_adadelt_total              4

#define def_adadelt_batch_size         5

#define def_adadelt_beta1              6

#define def_adadelt_beta2              7

#define def_adadelt_Lambda1            8

#define def_adadelt_Lambda2            9

//--- optimize parameters using the Adam method

#define def_adam_delta_weights         0

#define def_adam_weights               1

#define def_adam_momentumM             2

#define def_adam_momentumV             3

#define def_adam_total                 4

#define def_adam_batch_size            5

#define def_adam_learningRate          6

#define def_adam_beta1                 7

#define def_adam_beta2                 8

#define def_adam_Lambda1               9

#define def_adam_Lambda2               10

//--- feed-forward of the pooling layer

#define def_prff_inputs                0

#define def_prff_outputs               1

#define def_prff_inputs_total          2

#define def_prff_input_neurons         3

#define def_prff_window                4

#define def_prff_step                  5

#define def_prff_activation            6

//--- gradient propagation through the pooling layer

#define def_prhgr_inputs               0

#define def_prhgr_gradient_inputs      1

#define def_prhgr_outputs              2

#define def_prhgr_gradients            3

#define def_prhgr_inputs_total         4

#define def_prhgr_outputs_total        5

#define def_prhgr_window               6