DocumentaciónSecciones
Manual de referencia de MQL5Operaciones con arraysArrayFromFP16 

ArrayFromFP16

Permite copiar un array de tipo ushort en un array de tipo float o double con el formato establecido.

bool   ArrayFromFP16(
   const float&         dst_array[],        // a dónde copiamos
   const ushort&        src_array[],        // de dónde copiamos
   ENUM_FLOAT16_FORMAT  fmt                 // formato
   );

Sobrecarga para el tipo double

bool   ArrayFromFP16(
   const double&        dst_array[],        // a dónde copiamos
   const ushort&        src_array[],        // de dónde copiamos
   ENUM_FLOAT16_FORMAT  fmt                 // formato
   );

Parámetros

dst_array[]

[out]  Array receptor del tipo float o double.

src_array[]

[in]  Array fuente del tipo ushort.

fmt

[in]  Formato de copiado de la enumeración ENUM_FLOAT16_FORMAT.

 

Valor retornado

Retorna true en el caso de éxito, de lo contrario, false.

Observación

Los formatos FLOAT16 y BFLOAT16 se definen en la enumeración ENUM_FLOAT16_FORMAT y se usan en MQL5 sola y exclusivamente para trabajar con modelos ONNX.

Si los parámetros de salida obtenidos al ejecutar la función OnnxRun son de tipo FLOAT16 y BFLOAT16, esta función permitirá convertir el resultado a arrays de tipo float o double.

FLOAT16, también conocido como formato de media precisión o "half-precision float", utiliza 16 bits para representar un número de coma flotante. Este formato ofrece un equilibrio entre precisión y eficiencia computacional. FLOAT16 se utiliza ampliamente en el aprendizaje profundo y las redes neuronales, donde se requiere un alto rendimiento al procesar grandes cantidades de datos. Este formato permite acelerar los cálculos reduciendo el tamaño de los números, lo cual resulta especialmente importante al entrenar redes neuronales profundas en unidades de procesamiento gráfico (GPU).

BFLOAT16 (o Brain Floating Point 16) también usa 16 bits, pero se diferencia de FLOAT16 en el modo de representación de los números. En este formato, se asignan 8 bits para representar el exponente y los 7 bits restantes se utilizan para representar la mantisa. Este formato se ha desarrollado para su uso en el aprendizaje profundo y la inteligencia artificial, especialmente en los procesadores Tensor Processing Unit (TPU) de Google. BFLOAT16 muestra un buen rendimiento en el entrenamiento de redes neuronales y puede utilizarse eficazmente para acelerar el cálculo.

Ejemplo: función del artículo Trabajamos con modelos ONNX en formatos float16 y 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);
  }

Ver también

ArrayToFP16, ArrayCopy