Dequantize

aula final pública Desquantizar

Desquantize o tensor de 'entrada' em um tensor float ou bfloat16.

[min_range, max_range] são valores flutuantes escalares que especificam o intervalo para a saída. O atributo 'mode' controla exatamente quais cálculos são usados ​​para converter os valores flutuantes em seus equivalentes quantizados.

No modo 'MIN_COMBINED', cada valor do tensor passará pelo seguinte: 

if T == qint8: in[i] += (range(T) + 1)/ 2.0
 out[i] = min_range + (in[i]* (max_range - min_range) / range(T))
aqui `range(T) = numeric_limits ::max() - limites_numéricos ::min()`

Exemplo de modo MIN_COMBINED

Se a entrada vier de um QuantizedRelu6, o tipo de saída será quint8 (intervalo de 0 a 255), mas o intervalo possível de QuantizedRelu6 será de 0 a 6. Os valores min_range e max_range são, portanto, 0,0 e 6,0. Dequantize em quint8 pegará cada valor, converterá em float e multiplicará por 6/255. Observe que se quantizedtype for qint8, a operação adicionará adicionalmente cada valor por 128 antes da conversão.

Se o modo for 'MIN_FIRST', então esta abordagem será usada: 

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 = range / num_discrete_values
 const double offset_input = static_cast<double>(input) - lowest_quantized;
 result = range_min + ((input - numeric_limits<T>::min()) * range_scale)
Se o modo for `SCALED`, a desquantização é realizada multiplicando cada valor de entrada por um scaling_factor. (Assim, uma entrada de 0 sempre mapeia para 0,0).

O scaling_factor é determinado a partir de `min_range`, `max_range` e `narrow_range` de uma forma que seja compatível com `QuantizeAndDequantize{V2|V3}` e `QuantizeV2`, usando o seguinte algoritmo: 

const int min_expected_T = std::numeric_limits<T>::min() +
     (narrow_range ? 1 : 0);
   const int max_expected_T = std::numeric_limits<T>::max();
   const float max_expected_T = std::numeric_limits<float>::max();
 
   const float scale_factor =
     (std::numeric_limits<T>::min() == 0) ? (max_range / max_expected_T)
                                          : std::max(min_range / min_expected_T,
                                                     max_range / max_expected_T);

Classes aninhadas

aula Desquantizar.Opções Atributos opcionais para Dequantize

Constantes

Corda OP_NAME O nome desta operação, conforme conhecido pelo mecanismo principal do TensorFlow

Métodos Públicos

Saída <U>
asOutput ()
Retorna o identificador simbólico do tensor.
Dequantize.Options estático
eixo (eixo longo)
estático <U estende TNumber > Desquantizar <U>
create ( Escopo do escopo , Operando <? estende TType > entrada, Operando < TFloat32 > minRange, Operando < TFloat32 > maxRange, Classe<U> dtype, Opções... opções)
Método de fábrica para criar uma classe que envolve uma nova operação Dequantize.
Desquantização estática < TFloat32 >
create ( Escopo do escopo , Operando <? estende TType > entrada, Operando < TFloat32 > minRange, Operando < TFloat32 > maxRange, Opções... opções)
Método de fábrica para criar uma classe que envolve uma nova operação Dequantize usando tipos de saída padrão.
Dequantize.Options estático
modo (modo String)
Dequantize.Options estático
NarrowRange (Booleano NarrowRange)
Saída <U>
saída ()

Métodos herdados

Constantes

String final estática pública OP_NAME

O nome desta operação, conforme conhecido pelo mecanismo principal do TensorFlow

Valor Constante: "Desquantizar"

Métodos Públicos

Saída pública <U> asOutput ()

Retorna o identificador simbólico do tensor.

As entradas para operações do TensorFlow são saídas de outra operação do TensorFlow. Este método é usado para obter um identificador simbólico que representa o cálculo da entrada.

Eixo público estático Dequantize.Options (eixo longo)

public static Dequantize <U> create ( Escopo do escopo , Operando <? estende TType > entrada, Operando < TFloat32 > minRange, Operando < TFloat32 > maxRange, Classe<U> dtype, Opções... opções)

Método de fábrica para criar uma classe que envolve uma nova operação Dequantize.

Parâmetros
escopo escopo atual
intervalo mínimo O valor escalar mínimo possivelmente produzido para a entrada.
intervalo máximo O valor escalar máximo possivelmente produzido para a entrada.
tipo d Tipo do tensor de saída. Atualmente o Dequantize suporta float e bfloat16. Se 'dtype' for 'bfloat16', ele suporta apenas o modo 'MIN_COMBINED'.
opções carrega valores de atributos opcionais
Devoluções
  • uma nova instância de Dequantize

public static Dequantize < TFloat32 > create ( Escopo de escopo , Operando <? estende TType > entrada, Operando < TFloat32 > minRange, Operando < TFloat32 > maxRange, Opções... opções)

Método de fábrica para criar uma classe que envolve uma nova operação Dequantize usando tipos de saída padrão.

Parâmetros
escopo escopo atual
intervalo mínimo O valor escalar mínimo possivelmente produzido para a entrada.
intervalo máximo O valor escalar máximo possivelmente produzido para a entrada.
opções carrega valores de atributos opcionais
Devoluções
  • uma nova instância de Dequantize

modo Dequantize.Options estático público (modo String)

public static Dequantize.Options strictRange (Boolean strictRange)

Saída pública <U> saída ()