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

Terminal

1. 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.
   
   

   

2. 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. 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. Otimizado e reduzido significativamente o consumo de recursos do sistema pelo terminal.
   
5. 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.
   

   

   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. 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.

1. : 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.;
    }
   



2. 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.
   

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

   
   
4. 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.
   
5. 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.
   
6. 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.
   
   
7. 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.
   
   
8. 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.
   
   
9. 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;
        }

   
   
10. 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.
    
    
    
11. 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")

12. 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.
13. 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).

1. Corrigidos bugs e comportamento ambíguo MetaAssist.
2. 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. 
   

   
   
   

3. Aprimorada a exibição de matrizes no depurador.
4. Aumento do buffer para copiar valores a partir do depurador.
   
5. Aprimoradas dicas de erro.
6. 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.
   
7. 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]'
   

8. Aprimorada a leitura de formatos de arquivos BMP estendidos.
   
9. Traduções de IU atualizadas.
10. Correções de crash-logs.