DocumentationSections
Référence MQL5Fonctions sur les TableauxArrayFromFP16 

ArrayFromFP16

Copie un tableau de type ushort dans un tableau de type float ou double avec le format donné.

bool   ArrayFromFP16(
   const float&         dst_array[],        // destination
   const ushort&        src_array[],        // source
   ENUM_FLOAT16_FORMAT  fmt                 // format
   );

Surcharge pour le type "double"

bool   ArrayFromFP16(
   const double&        dst_array[],        // destination
   const ushort&        src_array[],        // source
   ENUM_FLOAT16_FORMAT  fmt                 // format
   );

Paramètres

dst_array[]

[out] Tableau destination d'élements de type float ou double.

src_array[]

[in] Tableau source de type ushort.

fmt

[in]  Copie du format à partir de l'énumération ENUM_FLOAT16_FORMAT.

 

Valeur de Retour

Renvoie true en cas de succès ou false sinon.

Note

Les formats FLOAT16 et BFLOAT16 sont définis dans l'énumération ENUM_FLOAT16_FORMAT et sont utilisés dans MQL5 uniquement pour les opérations avec les modèles ONNX.

Si les paramètres de sortie obtenus à partir de l'exécution de la fonction OnnxRun sont de type FLOAT16 et BFLOAT16, vous pouvez utiliser cette fonction pour convertir le résultat en tableaux d'éléments de type float ou double.

FLOAT16, également connu sous le nom de flottant demi-précision, utilise 16 bits pour représenter les nombres à virgule flottante. Ce format offre un équilibre entre précision et efficacité de calcul. FLOAT16 est largement utilisé dans les algorithmes d'apprentissage profond et dans les réseaux de neurones, qui nécessitent un traitement très performant de grands ensembles de données. Ce format accélère les calculs en réduisant la taille des nombres, ce qui est particulièrement important lors de la formation de réseaux de neurones profonds sur des GPU.

BFLOAT16 (ou Brain Floating Point 16) utilise également 16 bits mais diffère de FLOAT16 dans l'approche de la représentation du format. Dans ce format, 8 bits sont alloués pour représenter l'exposant, tandis que les 7 bits restants sont utilisés pour représenter la mantisse. Ce format a été développé pour être utilisé dans l'apprentissage profond (deep learning) et dans l'intelligence artificielle, notamment dans le Tensor Processing Unit (TPU) de Google. BFLOAT16 démontre d'excellentes performances dans la formation des réseaux neuronaux et peut accélérer efficacement les calculs.

Exemple : fonction issue de l'article Travailler avec des modèles ONNX aux formats float16 et 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);
  }

Voir également

ArrayToFP16, ArrayCopy