ArrayToFP8

Sao chép một mảng kiểu float hoặc double vào một mảng kiểu uchar với định dạng được chỉ định.

bool ArrayToFP8(
   const uchar&         dst_array[],        // sao chép đến
   const float&         src_array[],        // sao chép từ
   ENUM_FLOAT8_FORMAT   fmt                 // định dạng
   );

Nạp chồng cho kiểu double

bool ArrayToFP8(
   const uchar&         dst_array[],        // sao chép đến
   const double&        src_array[],        // sao chép từ
   ENUM_FLOAT8_FORMAT   fmt                 // định dạng
   );

Tham số

dst_array[]

[out] Mảng đích kiểu uchar.

src_array[]

[in] Mảng nguồn kiểu float hoặc double.

fmt

[in] Định dạng sao chép từ bảng liệt kê ENUM_FLOAT8_FORMAT.

Giá trị trả về

Trả về true nếu thành công, ngược lại trả về false.

Ghi chú

Tất cả các loại định dạng FP8 được định nghĩa trong bảng liệt kê ENUM_FLOAT8_FORMAT và chỉ được sử dụng trong MQL5 cho các thao tác với mô hình ONNX.

Hàm này chuyển đổi các tham số đầu vào kiểu float hoặc double thành một trong những loại FP8. Các tham số đầu vào này sau đó được sử dụng trong hàm OnnxRun.

FP8 (số thực dấu phẩy động 8-bit) là một trong những kiểu dữ liệu được sử dụng để biểu diễn các số thực dấu phẩy động. Trong FP8, mỗi số được biểu diễn bằng 8 bit dữ liệu, thường được chia thành ba thành phần: dấu, số mũ và mantissa. Định dạng này cung cấp sự cân bằng giữa độ chính xác và hiệu quả lưu trữ, khiến nó trở nên hấp dẫn cho các ứng dụng yêu cầu tiết kiệm bộ nhớ và hiệu quả tính toán.

Bằng cách sử dụng biểu diễn số nhỏ gọn, FP8 giảm yêu cầu bộ nhớ và tăng tốc độ tính toán. Ngoài ra, FP8 có thể hữu ích cho việc thực hiện các thao tác cấp thấp như tính toán số học và xử lý tín hiệu.

Ví dụ:

Hàm từ bài viết Làm việc với mô hình ONNX ở định dạng float16 và float8

//+------------------------------------------------------------------+
//| RunCastFloat8Float                                               |
//+------------------------------------------------------------------+
bool RunCastFloat8ToFloat(long model_handle, const ENUM_FLOAT8_FORMAT fmt)
  {
   PrintFormat("TEST: %s(%s)", __FUNCTION__, EnumToString(fmt));
   //---
   float test_data[15] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
   uchar data_float8[15] = {};
   if(!ArrayToFP8(data_float8, test_data, fmt))
     {
      Print("error in ArrayToFP8. error code=", GetLastError());
      OnnxRelease(model_handle);
      return(false);
     }
   U<uchar> input_float8_values[3*5];
   U<float> output_float_values[3*5];
   float test_data_float[];
   //--- convert float8 to float
   if(!ArrayFromFP8(test_data_float, data_float8, fmt))
     {
      Print("error in ArrayFromFP8. error code=", GetLastError());
      OnnxRelease(model_handle);
      return(false);
     }
   for(uint i=0; i<data_float8.Size(); i++)
     {
      input_float8_values[i].value = data_float8[i];
      PrintFormat("%d input value =%f  Hex float8 = %s  ushort value=%d", i, test_data_float[i], ArrayToHexString(input_float8_values[i].uc), input_float8_values[i].value);
     }
   Print("ONNX input array: ", ArrayToString(input_float8_values));
   //--- execute model (convert float8 to float using ONNX)
   if(!OnnxRun(model_handle, ONNX_NO_CONVERSION, input_float8_values, output_float_values))
     {
      PrintFormat("error in OnnxRun. error code=%d", GetLastError());
      OnnxRelease(model_handle);
      return(false);
     }
   Print("ONNX output array: ", ArrayToString(output_float_values));
   //--- calculate error (compare ONNX and ArrayFromFP8 results)
   double sum_error = 0.0;
   for(uint i=0; i<test_data.Size(); i++)
     {
      double delta = test_data_float[i] - (double)output_float_values[i].value;
      sum_error += MathAbs(delta);
      PrintFormat("%d output float %f = %s difference=%f", i, output_float_values[i].value, ArrayToHexString(output_float_values[i].uc), delta);
     }
   //---
   PrintFormat("%s(%s): sum_error=%f\n", __FUNCTION__, EnumToString(fmt), sum_error);
   return(true);
  }

Xem thêm

ArrayFromFP8, ArrayCopy