Nova versão da plataforma MetaTrader 5 build 3390: Float em OpenCL e funções matemáticas, métodos de ativação e perda para aprendizado de máquina

 

Na quarta-feira, 4 de agosto de 2022, será liberada uma versão atualizada da plataforma MetaTrader 5. A atualização cobre as seguintes alterações:

  1. Terminal: adicionada a abertura automática de tutorial ao se conectar a uma conta de negociação pela primeira vez. Isso permite que os iniciantes dominem rapidamente os fundamentos da negociação e se familiarizem com os recursos da plataforma diretamente no terminal. O tutorial é dividido em várias seções, cada uma das quais fornece informações breves. O progresso de cada tópico a aprender é mostrado com uma linha azul.

    Abertura automática de tutoriais ao se conectar pela primeira vez a uma conta de negociação

  2. Terminal: corrigido o erro das operações em massa "Fechar posições lucrativas/não lucrativas". Anteriormente, a plataforma usava posições opostas, se houvesse, para fechar as posições correspondentes. Por exemplo, se você tivesse duas posições de compra não lucrativas em EURUSD e uma posição de venda lucrativa em EURUSD, todas as três posições existentes seriam encerradas durante o fechamento em massa de posições não lucrativas. A compra e a venda seriam fechadas com uma operação de fechamento com a posição oposta, e a compra restante seria fechada com uma operação de fechamento normal. Agora as equipes trabalham conforme o planejado, fechando apenas posições selecionadas - lucrativas ou não lucrativas.

  3. Terminal: corrigida a exibição do histórico de preços para preços negativos em gráficos com período D1. Agora os gráficos com preços negativos são exibidos corretamente em todos os períodos gráficos.
  4. Terminal: otimizado e reduzido significativamente o consumo de recursos do sistema pelo terminal.
  5. Terminal: atualizada a base de dados fundamental de instrumentos de negociação. O número de agregadores disponíveis para visualização de um instrumento de mercado foi ampliado para 15, o que permite encontrar informações sobre o número máximo de tickers nos agregadores econômicos mais populares.


    Atualizada base de dados fundamental contendo instrumentos de negociação

    Existem pelo menos 7.000 ações líquidas e mais de 2.000 ETFs listados no mercado global. Além disso, existem muitos futuros e outros derivativos. A plataforma MetaTrader 5 contém um enorme banco de dados de instrumentos bolsistas e também permite que você acesse o site do agregador em um clique e, assim, obtenha dados fundamentais diretamente do Market Watch. Para conforto dos investidores, oferecemos uma variedade de fontes de informação para cada título.


  6. Terminal: corrigida a substituição dos níveis de Stop Loss e Take Profit na janela para posicionar uma nova ordem. Agora, para contas operando no modo FIFO, os níveis de stop serão definidos automaticamente de acordo com os níveis de stop das posições já abertas para o mesmo instrumento. Isso é necessário para cumprir a regra FIFO.

  7. MQL5: as funções matemáticas agora podem trabalhar com matrizes e vetores.

    Continuamos a expandir os recursos da plataforma MetaTrader 5 para negociação algorítmica e aprendizado de máquina. Anteriormente, adicionamos um novo tipo de dados, isto é, matrizes e vetores, que permitem abandonar o uso de matrizes para processamento de dados. Para trabalhar com ele, adicionamos mais de 70 métodos à linguagem MQL5 que permitem realizar cálculos de álgebra linear e estatística na forma de uma única operação. Agora multiplicação, transformação e solução de sistema de equações são feitas de forma simples e sem programação desnecessária. A adição de novos tipos não deixou de lado as funções matemáticas.

    As funções matemáticas foram originalmente projetadas para operações matemáticas em valores escalares. Agora, a maioria dessas funções pode ser usada com novos tipos de dados - matrizes e vetores - MathAbs, MathArccos, MathArcsin, MathArctan, MathCeil, MathCos, MathExp, MathFloor, MathLog, MathLog10, MathMod, MathPow, MathRound, MathSin, MathSqrt, MathTan, MathExpm1 , MathLog1p, MathArccosh, MathArcsinh, MathArctanh, MathCosh, MathSinh, MathTanh. Neste caso, a matriz ou vetor é processado termo a termo, por exemplo:
    //---
      matrix a= {{1, 4}, {9, 16}};
      Print("matrix a=\n",a);
    
      a=MathSqrt(a);
      Print("MatrSqrt(a)=\n",a);
      /*
       matrix a=
       [[1,4]
        [9,16]]
       MatrSqrt(a)=
       [[1,2]
        [3,4]]
      */
    No caso de MathMod e MathPow, um escalar, uma matriz ou um vetor de tamanho apropriado pode ser usado como segundo parâmetro.

    Vamos usar um exemplo para mostrar como calcular o desvio padrão usando funções matemáticas sobre um vetor.
    //+------------------------------------------------------------------+
    //| Script program start function                                    |
    //+------------------------------------------------------------------+
    void OnStart()
     {
    //--- используем инициализирующую функцию для заполнения вектора
      vector r(10, ArrayRandom); // массив случайных чисел от 0 до 1
    //--- вычислим среднее значение
      double avr=r.Mean();       // среднее значение массива
      vector d=r-avr;            // вычислим массив отклонений от среднего значения
      Print("avr(r)=", avr);
      Print("r=", r);
      Print("d=", d);
      vector s2=MathPow(d, 2);   // массив квадратов отклонений
      double sum=s2.Sum();       // сумма квадратов отклонений
    //--- вычислим стандартное отклонение 2-мя способами
      double std=MathSqrt(sum/r.Size());
      Print(" std(r)=", std);
      Print("r.Std()=", r.Std());    
     }
    /*
      avr(r)=0.5300302133243813
      r=[0.8346201971495713,0.8031556138798182,0.6696676534318063,0.05386516922513505,0.5491195410016175,0.8224433118686484,...
      d=[0.30458998382519,0.2731254005554369,0.1396374401074251,-0.4761650440992462,0.01908932767723626,0.2924130985442671, ...
       std(r)=0.2838269732183663
      r.Std()=0.2838269732183663
    */ 
    //+------------------------------------------------------------------+
    //| Заполняет вектор случайными значениями                           |
    //+------------------------------------------------------------------+
    void ArrayRandom(vector& v)
     {
      for(ulong i=0; i<v.Size(); i++)
        v[i]=double(MathRand())/32767.;
     }
    

  8. MQL5: as funções de modelo agora podem usar as entradas matrix<double>, matrix<float>, vector<double>, vector<float> em vez dos tipos matrix, matrixf, vector, vectorf correspondentes.

  9. MQL5: aprimoradas as funções matemáticas para trabalhar com o tipo float. Devido ao surgimento da aplicação de funções matemáticas a matrizes e vetores flutuantes, as funções correspondentes aplicadas a escalares flutuantes também foram melhoradas. Anteriormente, os parâmetros dessas funções eram convertidos incondicionalmente no tipo double, a implementação correspondente da função matemática era chamada e, em seguida, o resultado era convertido no tipo float. Agora, no caso do tipo float, os parâmetros e resultados não são convertidos, pois são chamadas as implementações das funções matemáticas correspondentes ao tipo float.

    A diferença nos cálculos usando o exemplo de um seno matemático:

    //+------------------------------------------------------------------+
    //| Script program start function                                    |
    //+------------------------------------------------------------------+
    void OnStart()
     {
    //---  массив случайных чисел от 0 до 1
      vector d(10, ArrayRandom);
      for(ulong i=0; i<d.Size(); i++)
       {
        double delta=MathSin(d[i])-MathSin((float)d[i]);
        Print(i,". delta=",delta);
       }
     }
    /*
       0. delta=5.198186103783087e-09
       1. delta=8.927621308885136e-09
       2. delta=2.131878673594656e-09
       3. delta=1.0228555918923021e-09
       4. delta=2.0585739779477308e-09
       5. delta=-4.199390279957527e-09
       6. delta=-1.3221741035351897e-08
       7. delta=-1.742922250969059e-09
       8. delta=-8.770715820283215e-10
       9. delta=-1.2543186267421902e-08
    */
    //+------------------------------------------------------------------+
    //| Заполняет вектор случайными значениями                           |
    //+------------------------------------------------------------------+
    void ArrayRandom(vector& v)
     {
      for(ulong i=0; i<v.Size(); i++)
        v[i]=double(MathRand())/32767.;
     }

  10. MQL5: adicionados métodos de matrizes e vetores Ativation (função de ativação) e Derivative (derivada da função de ativação) com parâmetros:
    AF_ELU               Exponential Linear Unit
    AF_EXP               Exponencial
    AF_GELU              Gaussian Error Linear Unit
    AF_HARD_SIGMOID      Hard Sigmoid
    AF_LINEAR            Linear
    AF_LRELU             Leaky REctified Linear Unit
    AF_RELU              REctified Linear Unit
    AF_SELU              Scaled Exponential Linear Unit
    AF_SIGMOID           Sigmoid
    AF_SOFTMAX           Softmax
    AF_SOFTPLUS          Softplus
    AF_SOFTSIGN          Softsign
    AF_SWISH             Swish
    AF_TANH              Hyperbolic Tangent
    AF_TRELU             Thresholded REctified Linear Unit
    Uma função de ativação em uma rede neural determina como a soma ponderada de um sinal de entrada é convertida no sinal de saída de um nó ou nós a nível da rede. A escolha da função de ativação tem um grande impacto nas capacidades e no desempenho da rede neural. Diferentes partes do modelo podem usar diferentes funções de ativação. A linguagem MQL5 implementa não apenas todas as funções de ativação conhecidas, mas também derivações da função de ativação. Funções derivadas são necessárias para calcular rapidamente a correção com base no erro recebido durante o treinamento da rede neural.
  11. MQL5: adicionado método de matrizes e vetores Loss (função de perda) com os seguintes parâmetros:

    LOSS_MSE            Mean Squared Error
    LOSS_MAE            Mean Absolute Error
    LOSS_CCE            Categorical Crossentropy
    LOSS_BCE            Binary Crossentropy
    LOSS_MAPE           Mean Absolute Percentage Error
    LOSS_MSLE           Mean Squared Logarithmic Error
    LOSS_KLD            Kullback-Leibler Divergence
    LOSS_COSINE         Cosine similarity/proximity
    LOSS_POISSON        Poisson
    LOSS_HINGE          Hinge
    LOSS_SQ_HINGE       Squared Hinge
    LOSS_CAT_HINGE      Categorical Hinge
    LOSS_LOG_COSH       Logarithm of the Hyperbolic Cosine
    LOSS_HUBER          Huber

    A função de perda é responsável por avaliar quão bem o modelo prevê o valor real. Construir um modelo é basicamente resolver o problema de minimizar o valor dessa função em cada estágio. Dependendo do tipo de dados, você precisa usar abordagens diferentes, ou seja, funções diferentes. A função de perda também pode depender de pesos e tendências variáveis. A função de perda é unidimensional e não é um vetor porque avalia o desempenho da rede neural como um todo.

  12. Adicionados métodos de matrizes e vetores matrix::CompareByDigits e vector::CompareByDigits. Eles comparam se dígitos significativos dos elementos de duas matrizes/vetores coincidem.

  13. Adicionado suporte a funções MathMin e MathMax para strings. Nesse caso, as funções usarão comparação lexicográfica, isto é, as letras são comparadas alfabeticamente e diferenciam maiúsculas de minúsculas.

  14. MQL5: aumentado o número máximo de objetos OpenCL de 256 para 65536. As CLContextCreate, CLBufferCreate e CLProgramCreate ajudam a criar identificadores para objetos OpenCL em programas MQL5. O limite anterior de 256 identificadores não permitia que você trabalhasse efetivamente em métodos de aprendizado de máquina.

  15. MQL5: permitido usar OpenCL em placas sem suporte para double. Anteriormente, os programas MQL5 usavam apenas GPUs com suporte para double, embora muitas tarefas permitissem e fossem projetadas para cálculos usando floats. O tipo float é inicialmente considerado nativo para computação paralela, pois ocupa menos espaço. Este requisito já foi removido.

    Se uma tarefa precisar usar apenas uma GPU com suporte para double, isso poderá ser especificado explicitamente ao chamar CLContextCreate usando o novo valor CL_USE_GPU_DOUBLE_ONLY (somente dispositivos que suportam cálculos com o tipo double podem ser usados).
       int cl_ctx;
    //--- инициализация OpenCL контекста
       if((cl_ctx=CLContextCreate(CL_USE_GPU_DOUBLE_ONLY))==INVALID_HANDLE)
         {
          Print("OpenCL not found");
          return;
         }

  16. MQL5: corrigido o trabalho da função CustomBookAdd. Anteriormente, se um valor zero fosse especificado no campo MqlBookInfo::volume_real, o devido instantâneo do livro de ofertas não era criado. Agora a verificação é feita assim:
    A exatidão dos dados transmitidos é verificada, sendo que o tipo, o preço e o volume devem ser indicados para cada elemento. Ao mesmo tempo, MqlBookInfo.volume e MqlBookInfo.volume_real não devem ser zero ou negativos: se ambos os volumes forem negativos, isso será considerado um erro. Você pode especificar qualquer um dos volumes ou ambos, pois é tomado o que é indicado ou positivo:

       volume=-1 && volume_real=2 — será usado volume_real=2,

       volume=3 && volume_real=0 — será usado volume=3.

    Volume com maior precisão MqlBookInfo.volume_real tem uma prioridade mais alta do que MqlBookInfo.volume normal. Se ambos os valores forem especificados para o elemento do livro de ofertas, será utilizado volume_real.

    Se pelo menos um elemento do livro de ofertas for descrito incorretamente, o sistema descartará completamente o estado transferido.

  17. MQL5: corrigida a operação da função CalendarValueLast. O bug era que, em alguns casos, chamadas sucessivas para a função após alterações no calendário econômico (o parâmetro de alteração recebia um novo valor após a chamada) podiam ignorar eventos ao usar o filtro de moeda.
    CalendarValueLast(change, result, "", "EUR")
  18. MQL5: Corrigido o comportamento da função ArrayBSearch. Se houver vários elementos idênticos, será retornada uma referência ao primeiro e não, a um aleatório, como era antes.
  19. MQL5: corrigida a visibilidade de função de modelo em uma classe. O erro era que as funções do modelo de classe declaradas como private/protected acabavam sendo de fato public (public).
  20. MetaEditor: corrigidos bugs e comportamento ambíguo MetaAssist.
  21. MetaEditor: adicionado suporte para a macro %terminal%, que significa o caminho para o diretório de dados da plataforma onde este terminal está instalado. Por exemplo, %terminal%\MQL5\Experts. 


    Adicionado suporte para a macro %terminal%, que significa o caminho para o diretório de dados da plataforma onde dado terminal está instalado

  22. MetaEditor: aprimorada a exibição de matrizes no depurador.
  23. MetaEditor: aumento do buffer para copiar valores a partir do depurador.
  24. MetaEditor: Aprimoradas dicas de erro.
  25. MetaEditor: caminhos relativos agora são escritos no arquivo de projeto *.mproj. Anteriormente, os caminhos eram absolutos, o que resultava em erros de compilação ao mover um projeto.
  26. MetaEditor: adicionada incorporação automática de recursos BMP como matrizes de bitmap de 32 bits disponíveis globalmente quando incluídas em projetos. Isso elimina a necessidade de chamar ResourceReadImage no código para ler o recurso gráfico.
    'levels.bmp' as 'uint levels[18990]'
    
  27. MetaEditor: aprimorada a leitura de formatos de arquivos BMP estendidos.
  28. MetaEditor: traduções de IU atualizadas.
  29. Correções de crash-logs.

A atualização estará disponível através do sistema LiveUpdate.

Razão: