DocumentaçãoSeções
Referência MQL5Funções para ArrayArrayFromFP16 

ArrayFromFP16

Realiza a cópia de um array do tipo ushort para um array do tipo float ou double com um formato especificado.

bool   ArrayFromFP16(
   const float&         dst_array[],        // para onde copiamos
   const ushort&        src_array[],        // de onde copiamos
   ENUM_FLOAT16_FORMAT  fmt                 // formato
   );

Sobrecarga para o tipo double

bool   ArrayFromFP16(
   const double&        dst_array[],        // para onde copiamos
   const ushort&        src_array[],        // de onde copiamos
   ENUM_FLOAT16_FORMAT  fmt                 // formato
   );

Parâmetros

dst_array[]

[out]  Array receptor do tipo float ou double.

src_array[]

[in]  Array fonte do tipo ushort.

fmt

[in]  Formato de cópia a partir da enumeração ENUM_FLOAT16_FORMAT.

 

Valor retornado

Retorna true se for bem-sucedido, caso contrário, false.

Observação

Os formatos FLOAT16 e BFLOAT16 são definidos no enum ENUM_FLOAT16_FORMAT e são usados no MQL5 exclusivamente para trabalhar com modelos ONNX.

Se os parâmetros de saída obtidos ao executar a função OnnxRun são do tipo FLOAT16 e BFLOAT16, então esta função permite converter o resultado em arrays do tipo float ou double.

FLOAT16, também conhecido como precisão média ou formato "half-precision float", utiliza 16 bits para representar um número de ponto flutuante. Este formato oferece um equilíbrio entre precisão e eficiência de cálculo. FLOAT16 é amplamente usado em aprendizado profundo e redes neurais, onde a alta performance no processamento de grandes volumes de dados é requerida. Este formato permite acelerar os cálculos por meio da redução do tamanho dos números, o que é especialmente importante no treinamento de redes neurais profundas em unidades de processamento gráfico (GPUs).

BFLOAT16 (ou Brain Floating Point 16) também usa 16 bits, mas difere do FLOAT16 na forma como os números são representados. Neste formato, 8 bits são alocados para a representação do expoente, e os 7 bits restantes são usados para a mantissa. Este formato foi desenvolvido para uso em aprendizado profundo e inteligência artificial, especialmente em unidades de processamento Tensor do Google (TPUs). BFLOAT16 tem bom desempenho no treinamento de redes neurais e pode ser efetivamente usado para acelerar os cálculos.

Exemplo: função do artigo Trabalhando com modelos ONNX nos formatos float16 e float8

//+------------------------------------------------------------------+
//| RunCastFloat16ToDouble                                           |
//+------------------------------------------------------------------+
bool RunCastFloat16ToDouble(long model_handle)
  {
   PrintFormat("test=%s",__FUNCTION__);
   double test_data[12]= {1,2,3,4,5,6,7,8,9,10,11,12};
   ushort data_uint16[12];
   if(!ArrayToFP16(data_uint16,test_data,FLOAT_FP16))
     {
      Print("error in ArrayToFP16. error code=",GetLastError());
      return(false);
     }
   Print("test array:");
   ArrayPrint(test_data);
   Print("ArrayToFP16:");
   ArrayPrint(data_uint16);
   U<ushort> input_float16_values[3*4];
   U<double> output_double_values[3*4];
   float test_data_float[];
   if(!ArrayFromFP16(test_data_float,data_uint16,FLOAT_FP16))
     {
      Print("error in ArrayFromFP16. error code=",GetLastError());
      return(false);
     }
   for(int i=0; i<12; i++)
     {
      input_float16_values[i].value=data_uint16[i];
      PrintFormat("%d input value =%f  Hex float16 = %s  ushort value=%d",i,test_data_float[i],ArrayToString(input_float16_values[i].uc),input_float16_values[i].value);
     }
   Print("ONNX input array:");
   ArrayPrint(input_float16_values);
   bool res=OnnxRun(model_handle,ONNX_NO_CONVERSION,input_float16_values,output_double_values);
   if(!res)
     {
      PrintFormat("error in OnnxRun. error code=%d",GetLastError());
      return(false);
     }
   Print("ONNX output array:");
   ArrayPrint(output_double_values);
//---
   double sum_error=0.0;
   for(int i=0; i<12; i++)
     {
      double delta=test_data[i]-output_double_values[i].value;
      sum_error+=MathAbs(delta);
      PrintFormat("%d output double %f = %s  difference=%f",i,output_double_values[i].value,ArrayToString(output_double_values[i].uc),delta);
     }
//---
   PrintFormat("test=%s   sum_error=%f",__FUNCTION__,sum_error);
//---
   return(true);
  }

Veja também

ArrayToFP16, ArrayCopy