dòng chảy :: hoạt động :: QuantizeV2

#include <array_ops.h>

Định lượng tensor 'đầu vào' kiểu float thành tensor 'đầu ra' kiểu 'T'.

Tóm lược

[min_range, max_range] là các phao 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 các phép tính nào được sử dụng để chuyển đổi các giá trị float thành các giá trị tương đương được lượng tử hóa 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 các giá trị tương đương đã lượng tử hóa của chúng.

Trong chế độ 'MIN_COMBINED', mỗi giá trị của tensor sẽ trải qua như sau:

out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
if T == qint8: out[i] -= (range(T) + 1) / 2.0

ở đây range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::min()

Ví dụ về chế độ MIN_COMBINED

Giả sử đầu vào là kiểu float và có thể có phạm vi [0.0, 6.0] và kiểu đầu ra là tạ8 ([0, 255]). Giá trị min_range và max_range phải được chỉ định là 0.0 và 6.0. Việc định lượng từ float đến weight8 sẽ nhân mỗi giá trị của dữ liệu đầu vào với 255/6 và chuyển thành ngũ phân vị8.

Nếu kiểu đầu ra là qint8 ([-128, 127]), thì phép toán sẽ trừ thêm từng giá trị 128 trước khi ép kiểu, để phạm vi giá trị phù hợp 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::min()
quantized = max(quantized, numeric_limits::min())
quantized = min(quantized, numeric_limits::max())

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

Ví dụ về chế độ SCALED

SCALED chế độ phù hợp với cách tiếp cận lượng tử sử dụng trong QuantizeAndDequantize{V2|V3} .

Nếu chế độ là SCALED , quá trình 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ố tỷ lệ. Hệ số scaling_range được xác định từ min_range và max_range là lớn nhất có thể để phạm vi từ min_range đến max_range có thể biểu diễn trong các giá trị của loại T.

  

  

    
  const int min_T = std::numeric_limits::min();
  const int max_T = std::numeric_limits::max();
  const float max_float = std::numeric_limits::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 tôi sử dụng scale_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 tôi sẽ lượng tử hóa các giá trị đầu vào trong phạm vi (-10, 9,921875) đến (-128, 127).
 Tensor đầu vào hiện 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 thành max_range , sau đó nhân với scale_factor như sau:
 
result = round(min(max_range, max(min_range, input)) * scale_factor)

 Các điều chỉnh min_range và max_range được trả về như kết quả đầu ra 2 và 3 của hoạt động này. Các kết quả đầu ra này nên được sử dụng làm phạm vi cho bất kỳ tính toán nào khác.
 thuộc tính phạm vi hẹp (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 lượng tử hóa, nó sẽ bị hạn chế 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 một số 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ố kích thước 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 thứ nguyên đó. Điều này rất hữu ích cho 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 mỗi tensor được thực hiện như bình thường.
 thuộc tính ensure_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 nó thành 0 cho các mục đích sử dụng mới.
 Tranh luận:
  •  phạm vi: Một đối tượng Phạm vi
  •  min_range: Giá trị nhỏ nhất 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ì đâ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.
  •  max_range: Giá trị lớn nhất 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ì đâ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.
 Lợi nhuận:
  •  Output đầu ra: Dữ liệu lượng tử hóa được tạo ra từ đầu vào float.
  •  Output output_min: 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, đâ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.
  •  Output output_max: 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 giá trị lượng tử hóa. Nếu thuộc tính axis được chỉ định, đâ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. 
 Người xây dựng và Người phá hủy
 QuantizeV2 (const :: tensorflow::Scope & scope, :: tensorflow::Input input, :: tensorflow::Input min_range, :: tensorflow::Input max_range, DataType T)
 QuantizeV2 (const :: tensorflow::Scope & scope, :: tensorflow::Input input, :: tensorflow::Input min_range, :: tensorflow::Input max_range, DataType T, const QuantizeV2::Attrs & attrs)
 
 Thuộc tính công cộng
 operation
 output
 output_max
 output_min 
 Các chức năng tĩnh công khai
 Axis (int64 x)
 EnsureMinimumRange (float x)
 Mode (StringPiece x)
 NarrowRange (bool x)
 RoundMode (StringPiece x) 
 Cấu trúc
 tensorflow :: ops :: QuantizeV2 :: Attrs
 Bộ thiết lập thuộc tính tùy chọn cho QuantizeV2 .
 Thuộc tính công cộng 
 hoạt động
 
Operation operation
 
 đầu ra
 
::tensorflow::Output output
 
 output_max
 
::tensorflow::Output output_max
 
 output_min
 
::tensorflow::Output output_min
 Chức năng công cộng 
 QuantizeV2
 
 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T
)
 
 QuantizeV2
 
 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T,
  const QuantizeV2::Attrs & attrs
)
 Các chức năng tĩnh công khai 
 Trục
 
Attrs Axis(
  int64 x
)
 
 EnsureMinimumRange
 
Attrs EnsureMinimumRange(
  float x
)
 
 Chế độ
 
Attrs Mode(
  StringPiece x
)
 
 Phạm vi hẹp
 
Attrs NarrowRange(
  bool x
)
 
 RoundMode
 
Attrs RoundMode(
  StringPiece x
)