Quantize

Ví dụ về chế độ MIN_COMBIND

Giả sử đầu vào là loại float và có phạm vi có thể là [0,0, 6,0] và loại đầu ra là quint8 ([0, 255]). Các giá trị min_range và max_range phải được chỉ định là 0,0 và 6,0. Lượng tử hóa từ float đến quint8 sẽ nhân mỗi giá trị của đầu vào với 255/6 và chuyển sang quint8.

Nếu loại đầu ra là qint8 ([-128, 127]), thao tác sẽ trừ thêm mỗi giá trị 128 trước khi truyền, sao cho phạm vi giá trị căn chỉnh với phạm vi của qint8.

Nếu chế độ là 'MIN_FIRST' thì phương pháp này được sử dụng:

num_discrete_values = 1 << (# of bits in T)
 range_adjust = num_discrete_values / (num_discrete_values - 1)
 range = (range_max - range_min) * range_adjust
 range_scale = num_discrete_values / range
 quantized = round(input * range_scale) - round(range_min * range_scale) +
   numeric_limits<T>::min()
 quantized = max(quantized, numeric_limits<T>::min())
 quantized = min(quantized, numeric_limits<T>::max())
 

Chế độ SCALED Ví dụ

Chế độ `SCALED` phù hợp với phương pháp lượng tử hóa được sử dụng trong `QuantizeAndDequantize{V2|V3}`.

Nếu chế độ là `SCALED`, việc lượng tử hóa được thực hiện bằng cách nhân mỗi giá trị đầu vào với một hệ số chia tỷ lệ. Hệ số chia tỷ lệ được xác định từ `min_range` và `max_range` càng lớn càng tốt sao cho phạm vi từ `min_range` đến `max_range` có thể biểu thị trong các giá trị của loại T.

const int min_T = std::numeric_limits<T>::min();
   const int max_T = std::numeric_limits<T>::max();
   const float max_float = std::numeric_limits<float>::max();
 
   const float scale_factor_from_min_side =
       (min_T * min_range > 0) ? min_T / min_range : max_float;
   const float scale_factor_from_max_side =
       (max_T * max_range > 0) ? max_T / max_range : max_float;
 
   const float scale_factor = std::min(scale_factor_from_min_side,
                                       scale_factor_from_max_side);
 

min_range = min_T / scale_factor;
       max_range = max_T / scale_factor;
 

Vì vậy chúng ta sẽ lượng tử hóa các giá trị đầu vào trong khoảng (-10, 9,921875) đến (-128, 127).

Hiện tại, tenxơ đầu vào có thể được lượng tử hóa bằng cách cắt các giá trị thành phạm vi `min_range` đến `max_range`, sau đó nhân với thang đo_factor như sau:

result = round(min(max_range, max(min_range, input)) * scale_factor)
 

Thuộc tính hẹp_range (bool)

Nếu đúng, chúng tôi không sử dụng giá trị lượng tử hóa tối thiểu. tức là đối với int8 đầu ra được lượng tử hóa, nó sẽ bị giới hạn trong phạm vi -127..127 thay vì phạm vi -128..127 đầy đủ. Điều này được cung cấp để tương thích với các phụ trợ suy luận nhất định. (Chỉ áp dụng cho chế độ SCALED)

thuộc tính trục (int)

Thuộc tính `axis` tùy chọn có thể chỉ định chỉ số thứ nguyên của tensor đầu vào, sao cho phạm vi lượng tử hóa sẽ được tính toán và áp dụng riêng cho từng lát của tensor dọc theo chiều đó. Điều này rất hữu ích cho việc lượng tử hóa trên mỗi kênh.

Nếu trục được chỉ định, min_range và max_range

nếu `axis`=Không, lượng tử hóa trên mỗi tensor được thực hiện như bình thường.

Thuộc tính đảm bảo_minimum_range (float)

Đảm bảo phạm vi lượng tử hóa tối thiểu ít nhất là giá trị này. Giá trị mặc định cũ cho giá trị này là 0,01, nhưng chúng tôi khuyên bạn nên đặt giá trị này thành 0 cho các mục đích sử dụng mới.