dòng chảy căng:: ôi:: Lượng tử hóaV2

#include <array_ops.h>

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

Bản tóm tắ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 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_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::min()
quantized = max(quantized, numeric_limits::min())
quantized = min(quantized, numeric_limits::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ị được trong các giá trị thuộc 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 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ị trong phạm vi min_range thành 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 đầ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 những mục đích sử dụng mới.
 Lập luận:
  •  phạm vi: Một đối tượng Phạm vi
  •  min_range: 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ì đây phải là một 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ị 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ì đây phải là một 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.
 Trả về:
  •  Đầu ra Output : Dữ liệu lượng tử hóa được tạo ra từ đầu vào float.
  •  Output ra_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à một 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 : 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, đây sẽ là một 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. 
 Hàm tạo và hàm 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 khai
 operation
 output
 output_max
 output_min 
Các hàm 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ộ cài đặt thuộc tính tùy chọn cho QuantizeV2 .
 Thuộc tính công khai 
 hoạt động 
 
Operation operation
 đầu ra 
 
::tensorflow::Output output
 đầu ra_max 
 
::tensorflow::Output output_max
 đầu ra_min 
 
::tensorflow::Output output_min
 Chức năng công cộng 
 Lượng tử hóaV2 
 
 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T
)
 Lượng tử hóaV2 
 
 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T,
  const QuantizeV2::Attrs & attrs
)
 Các hàm tĩnh công khai 
 Trục 
 
Attrs Axis(
  int64 x
)
 Đảm bảoPhạm vi tối thiểu 
 
Attrs EnsureMinimumRange(
  float x
)
 Cách thức 
 
Attrs Mode(
  StringPiece x
)
 Phạm vi hẹp 
 
Attrs NarrowRange(
  bool x
)
 Chế độ tròn
 
Attrs RoundMode(
  StringPiece x
)