DokumentationKategorien
Nachschlagewerk MQL5Operationen mit ArraysArrayFromFP16 

ArrayFromFP16

Kopiert ein Array vom Typ ushort in ein Array vom Typ float oder double mit dem angegebenen Format.

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

Überladung für den Typ double

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

Parameter

dst_array[]

[out]  Empfänger-Array des Typs float oder double.

src_array[]

[in]  Quellarray vom Typ ushort.

fmt

[in]  Format der Kopie aus der Enumeration ENUM_FLOAT16_FORMAT.

 

Rückgabewert

Gibt bei Erfolg „true“ zurück, andernfalls „false“.

Hinweis

Die Formate FLOAT16 und BFLOAT16 sind in der Enumeration ENUM_FLOAT16_FORMAT definiert und werden in MQL5 nur für Operationen mit ONNX-Modelle verwendet.

Wenn die aus der Ausführung der Funktion OnnxRun erhaltenen Ausgabeparameter vom Typ FLOAT16 und BFLOAT16 sind, können Sie diese Funktion verwenden, um das Ergebnis in Float- oder Double-Arrays zu konvertieren.

FLOAT16, auch bekannt als half-precision float (Halbgenaues-Float), verwendet 16 Bit zur Darstellung von Gleitkommazahlen. Dieses Format bietet ein Gleichgewicht zwischen Genauigkeit und Recheneffizienz. FLOAT16 wird häufig in Deep-Learning-Algorithmen und neuronalen Netzen verwendet, die eine Hochleistungsverarbeitung großer Datensätze erfordern. Dieses Format beschleunigt Berechnungen durch die Reduzierung der Zahlengröße, was besonders wichtig ist, wenn tiefe neuronale Netze auf GPUs trainiert werden.

BFLOAT16 (oder Brain Floating Point 16) verwendet ebenfalls 16 Bit, unterscheidet sich jedoch von FLOAT16 im Ansatz der Formatdarstellung. In diesem Format werden 8 Bits zur Darstellung des Exponenten zugewiesen, während die restlichen 7 Bits zur Darstellung der Mantisse verwendet werden. Dieses Format wurde für den Einsatz im Deep Learning und der künstlichen Intelligenz entwickelt, insbesondere in der Tensor Processing Unit (TPU) von Google. BFLOAT16 zeigt eine hervorragende Leistung beim Training neuronaler Netzwerke und kann Berechnungen effektiv beschleunigen.

Beispiel: Die Funktion aus dem Artikel „Arbeiten mit ONNX-Modellen in den Formaten float16 und 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);
  }

Siehe auch

ArrayToFP16, ArrayCopy