ArrayFromFP8

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

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

Nạp chồng cho kiểu double

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

Tham số

dst_array[]

[out] Mảng đích kiểu float hoặc double.

src_array[]

[in] Mảng nguồn kiểu uchar.

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à được sử dụng trong MQL5 chỉ cho các thao tác với mô hình ONNX.

Nếu các tham số đầu ra thu được từ việc thực thi hàm OnnxRun thuộc kiểu FP8 từ bảng liệt kê ENUM_FLOAT8_FORMAT, bạn có thể sử dụng hàm này để chuyển đổi kết quả thành mảng float hoặc double.

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

//+------------------------------------------------------------------+
//| RunCastFloat8ToFloat                                             |
//+------------------------------------------------------------------+
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

ArrayToFP8, ArrayCopy