DocumentaciónSecciones
Manual de referencia de MQL5Operaciones con arraysArrayToFP16 

ArrayToFP16

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

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

Sobrecarga para el tipo double

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

Parámetros

dst_array[]

[out]  Array receptor de tipo ushort.

src_array[]

[in]  Array fuente de tipo float o double.

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.

La función se utiliza para convertir parámetros de entrada de tipo float o doulbe a tipo FLOAT16 y BFLOAT16. Estos parámetros de entrada se utilizan en la función OnnxRun.

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

ArrayFromFP16, ArrayCopy