DocumentazioneSezioni
MQL5 RiferimentoFunzioni di ArrayArrayFromFP16 

ArrayFromFP16

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

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

Overloading (sovraccarico) per il tipo double

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

Parametri

dst_array[]

[out] Array ricevitore di tipo float o double.

src_array[]

[in] Array sorgente di tipo ushort.

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.

Se i parametri di output ottenuti dall'esecuzione della funzione OnnxRun sono di tipo FLOAT16 e BFLOAT16, è possibile utilizzare questa funzione per convertire il risultato in un array float o double.

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

ArrayToFP16, ArrayCopy