DocumentazioneSezioni
MQL5 RiferimentoFunzioni di ArrayArrayToFP16 

ArrayToFP16

Copia un array di tipo float o double in un array di tipo ushort con il formato specificato.

bool   ArrayToFP16(
   const ushort&        dst_array[],        // copy to
   const float&         src_array[],        // copy from
   ENUM_FLOAT16_FORMAT  fmt                 // format
   );

Overloading (sovraccarico) per il tipo double

bool   ArrayToFP16(
   const ushort&        dst_array[],        // copy to
   const double&        src_array[],        // copy from
   ENUM_FLOAT16_FORMAT  fmt                 // format
   );

Parametri

dst_array[]

[out] Array ricevitore di tipo ushort.

src_array[]

[in] Array sorgente di tipo float o double.

fmt

[in] Copia del formato dall'enumerazione ENUM_FLOAT16_FORMAT.

 

Valore Restituito

Restituisce true in caso di esito positivo altrimenti false.

Note

I formati FLOAT16 e BFLOAT16 sono definiti nell'enumerazione ENUM_FLOAT16_FORMAT e sono utilizzati in MQL5 solo per operazioni con modelli ONNX.

La funzione converte i parametri in ingresso di tipo float o double nel tipo FLOAT16 e BFLOAT16. Questi parametri di input sono poi utilizzati nella funzione OnnxRun.

FLOAT16, noto anche come half-precision float, utilizza 16 bit per rappresentare numeri in virgola mobile. Questo formato fornisce un equilibrio tra precisione ed efficienza computazionale. FLOAT16 è ampiamente utilizzato in algoritmi di deep learning e reti neurali, che richiedono un'elaborazione ad alte prestazioni di grandi set di dati. Questo formato accelera i calcoli riducendo la dimensione dei numeri, che è particolarmente importante quando si allenano reti neurali profonde su GPU.

Anche BFLOAT16 (o Brain Floating Point 16) utilizza 16 bit ma differisce da FLOAT16 nell'approccio alla rappresentazione del formato. In questo formato, 8 bit sono allocati per rappresentare l'esponente, mentre i restanti 7 bit sono usati per rappresentare la mantissa. Questo formato è stato sviluppato per l'uso nel deep learning e nell'intelligenza artificiale, in particolare nella Tensor Processing Unit (TPU) di Google. BFLOAT16 dimostra eccellenti prestazioni nell'allenamento della rete neurale e può efficacemente accelerare i calcoli.

 

Esempio: funzione dall'articolo Lavorare con i modelli ONNX nei formati 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);
  }

Vedere anche

ArrayFromFP16, ArrayCopy