Quantize

lớp cuối cùng công khai Lượng tử hóa

Lượng tử hóa tenxơ 'đầu vào' của loại float thành tenxơ 'đầu ra' của loại 'T'.

[min_range, max_range] là các số float vô hướng chỉ định phạm vi cho dữ liệu 'đầu vào'. Thuộc tính 'mode' kiểm soát chính xác những phép tính nào được sử dụng để chuyển đổi các giá trị float thành giá trị lượng tử hóa tương đương của chúng. Thuộc tính 'round_mode' kiểm soát thuật toán ngắt kết nối làm tròn nào được sử dụng khi làm tròn các giá trị float thành giá trị tương đương được lượng tử hóa của chúng.

Trong chế độ 'MIN_COMBIND', mỗi giá trị của tenxơ sẽ trải qua các bước sau:

out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
 if T == qint8: out[i] -= (range(T) + 1) / 2.0
 
ở đây `phạm vi (T) = số_limits ::max() - số_limits ::min()`

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())
 
Sự khác biệt lớn nhất giữa giá trị này và MIN_COMBINED là phạm vi tối thiểu được làm tròn trước khi bị trừ khỏi giá trị làm tròn. Với MIN_COMBINED, một sai lệch nhỏ được đưa ra trong đó việc lặp lại lượng tử hóa và giải lượng tử sẽ gây ra lỗi ngày càng lớn hơn.

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);
 
Tiếp theo chúng ta sử dụng thang đo_factor để điều chỉnh min_range và max_range như sau:
min_range = min_T / scale_factor;
       max_range = max_T / scale_factor;
 
ví dụ: nếu T = qint8 và ban đầu min_range = -10 và max_range = 9, chúng tôi sẽ so sánh -128/-10,0 = 12,8 với 127/9,0 = 14,11 và đặt Scaling_factor = 12,8 Trong trường hợp này, min_range sẽ vẫn là -10, nhưng max_range sẽ được điều chỉnh thành 127 / 12,8 = 9,921875

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)
 
`min_range` và `max_range` đã điều chỉnh được trả về dưới dạng kết quả đầu ra 2 và 3 của thao tác này. Những kết quả đầu ra này nên được sử dụng làm phạm vi cho bất kỳ phép tính nào tiếp theo.

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.

Các lớp lồng nhau

lớp học Lượng tử hóa.Options Thuộc tính tùy chọn cho Quantize

Hằng số

Sợi dây OP_NAME Tên của op này, được biết đến bởi công cụ lõi TensorFlow

Phương pháp công cộng

tĩnh Quantize.Options
trục (Trục dài)
tĩnh <T mở rộng TType > Định lượng <T>
tạo ( Phạm vi phạm vi, Toán hạng < TFloat32 > đầu vào, Toán hạng < TFloat32 > minRange, Toán hạng < TFloat32 > maxRange, Lớp <T> T, Tùy chọn... tùy chọn)
Phương thức xuất xưởng để tạo một lớp bao bọc một hoạt động Lượng tử hóa mới.
tĩnh Quantize.Options
AssuranceMinimumRange (Float AssuranceMinimumRange)
tĩnh Quantize.Options
chế độ (Chế độ chuỗi)
tĩnh Quantize.Options
phạm vi hẹp (Phạm vi hẹp Boolean)
Đầu ra <T>
đầu ra ()
Dữ liệu lượng tử hóa được tạo ra từ đầu vào float.
Đầu ra < TFloat32 >
đầu raMax ()
Phạm vi lượng tử hóa cuối cùng tối đa, được sử dụng để cắt các giá trị đầu vào trước khi chia tỷ lệ và làm tròn chúng thành các giá trị lượng tử hóa.
Đầu ra < TFloat32 >
đầu raMin ()
Phạm vi lượng tử hóa cuối cùng tối thiểu, được sử dụng để cắt các giá trị đầu vào trước khi chia tỷ lệ và làm tròn chúng thành các giá trị lượng tử hóa.
tĩnh Quantize.Options
roundMode (Chuỗi roundMode)

Phương pháp kế thừa

Hằng số

Chuỗi cuối cùng tĩnh công khai OP_NAME

Tên của op này, được biết đến bởi công cụ lõi TensorFlow

Giá trị không đổi: "QuantizeV2"

Phương pháp công cộng

trục Quantize.Options tĩnh công khai (Trục dài)

public static Định lượng <T> tạo ( Phạm vi phạm vi, Toán hạng < TFloat32 > đầu vào, Toán hạng < TFloat32 > minRange, Toán hạng < TFloat32 > maxRange, Lớp <T> T, Tùy chọn... tùy chọn)

Phương thức xuất xưởng để tạo một lớp bao bọc một hoạt động Lượng tử hóa mới.

Thông số
phạm vi phạm vi hiện tại
phạm vi phút Giá trị tối thiểu của phạm vi lượng tử hóa. Giá trị này có thể được điều chỉnh bởi op tùy thuộc vào các thông số khác. Giá trị điều chỉnh được ghi vào `output_min`. Nếu thuộc tính `axis` được chỉ định, thì thuộc tính này phải là tensor 1-D có kích thước khớp với kích thước `axis` của tensor đầu vào và đầu ra.
phạm vi tối đa Giá trị tối đa của phạm vi lượng tử hóa. Giá trị này có thể được điều chỉnh bởi op tùy thuộc vào các thông số khác. Giá trị điều chỉnh được ghi vào `output_max`. Nếu thuộc tính `axis` được chỉ định, thì thuộc tính này phải là tensor 1-D có kích thước khớp với kích thước `axis` của tensor đầu vào và đầu ra.
tùy chọn mang các giá trị thuộc tính tùy chọn
Trả lại
  • một phiên bản mới của Lượng tử hóa

tĩnh công khai Quantize.Options đảm bảoMinimumRange (Float đảm bảoMinimumRange)

chế độ Quantize.Options tĩnh công khai (Chế độ chuỗi)

public static Quantize.Options thu hẹpRange (Boolean thu hẹpRange)

Đầu ra công khai đầu ra <T> ()

Dữ liệu lượng tử hóa được tạo ra từ đầu vào float.

Đầu ra công khai < TFloat32 > đầu raMax ()

Phạm vi lượng tử hóa cuối cùng tối đa, được sử dụng để cắt các giá trị đầu vào trước khi chia tỷ lệ và làm tròn chúng thành các giá trị lượng tử hóa. Nếu thuộc tính `axis` được chỉ định, thì đây sẽ là tensor 1-D có kích thước khớp với kích thước `axis` của tensor đầu vào và đầu ra.

Đầu ra công khai < TFloat32 > đầu raMin ()

Phạm vi lượng tử hóa cuối cùng tối thiểu, được sử dụng để cắt các giá trị đầu vào trước khi chia tỷ lệ và làm tròn chúng thành các giá trị lượng tử hóa. Nếu thuộc tính `axis` được chỉ định, thì đây sẽ là tensor 1-D có kích thước khớp với kích thước `axis` của tensor đầu vào và đầu ra.

public static Quantize.Options roundMode (Chuỗi roundMode)