Quantize

Esempio di modalità MIN_COMBINED

Supponiamo che l'input sia di tipo float e abbia un intervallo possibile di [0.0, 6.0] e che il tipo di output sia quint8 ([0, 255]). I valori min_range e max_range devono essere specificati come 0,0 e 6,0. La quantizzazione da float a quint8 moltiplicherà ciascun valore dell'input per 255/6 e lo trasformerà in quint8.

Se il tipo di output era qint8 ([-128, 127]), l'operazione sottrarrà inoltre ciascun valore di 128 prima della conversione, in modo che l'intervallo di valori si allinei con l'intervallo di qint8.

Se la modalità è 'MIN_FIRST', viene utilizzato questo approccio:

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())
 

Esempio della modalità SCALA

La modalità "SCALED" corrisponde all'approccio di quantizzazione utilizzato in "QuantizeAndDequantize{V2|V3}".

Se la modalità è "SCALED", la quantizzazione viene eseguita moltiplicando ciascun valore di input per un fattore_di_scaling. Il fattore di scala è determinato da "min_range" e "max_range" in modo che sia il più ampio possibile in modo tale che l'intervallo da "min_range" a "max_range" sia rappresentabile all'interno di valori di tipo 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;
 

Quindi quantizzeremo i valori di input nell'intervallo da (-10, 9,921875) a (-128, 127).

Il tensore di input può ora essere quantizzato ritagliando i valori nell'intervallo da "min_range" a "max_range", quindi moltiplicando per scale_factor come segue:

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

Attributo narrow_range (bool).

Se vero, non utilizziamo il valore quantizzato minimo. cioè per int8 l'output quantizzato, sarebbe limitato all'intervallo -127..127 anziché all'intero intervallo -128..127. Questo è fornito per la compatibilità con alcuni backend di inferenza. (Si applica solo alla modalità SCALED)

attributo asse (int).

Un attributo opzionale `axis` può specificare un indice di dimensione del tensore di input, in modo tale che gli intervalli di quantizzazione verranno calcolati e applicati separatamente per ciascuna fetta del tensore lungo quella dimensione. Ciò è utile per la quantizzazione per canale.

Se è specificato l'asse, intervallo_min e intervallo_max

se `axis`=None, la quantizzazione per tensore viene eseguita normalmente.

Attributo Guarantee_minimum_range (float).

Garantisce che l'intervallo di quantizzazione minimo sia almeno questo valore. Il valore predefinito legacy per questo è 0,01, ma si consiglia vivamente di impostarlo su 0 per nuovi usi.