Dequantize

Clase public final descuantificar

Descuantizar el tensor de 'entrada' en un tensor float o bfloat16.

[rango_mín, rango_máx] son ​​flotantes escalares que especifican el rango para la salida. El atributo 'modo' controla exactamente qué cálculos se utilizan para convertir los valores flotantes a sus equivalentes cuantificados.

En el modo de 'MIN_COMBINED', cada valor del tensor se someterá a la siguiente: 

if T == qint8: in[i] += (range(T) + 1)/ 2.0
 out[i] = min_range + (in[i]* (max_range - min_range) / range(T))
aquí `gama (T) = numeric_limits :: max () - límites_numéricos :: min () `

Ejemplo de modo MIN_COMBINED

Si la entrada proviene de QuantizedRelu6, el tipo de salida es quint8 (rango de 0-255) pero el rango posible de QuantizedRelu6 es 0-6. Por lo tanto, los valores min_range y max_range son 0.0 y 6.0. Dequantize on quint8 tomará cada valor, se convertirá en flotante y se multiplicará por 6 / 255. Tenga en cuenta que si el tipo cuantizado es qint8, la operación agregará adicionalmente cada valor por 128 antes de la conversión.

Si el modo es 'MIN_FIRST', entonces este enfoque se utiliza: 

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)
Si el modo es `SCALED`, descuantificación se realiza multiplicando cada valor de entrada por un factor de escalado. (Por lo tanto, una entrada de 0 siempre se asigna a 0.0).

El factor de escalado se determina a partir min_range` `` max_range`, y `narrow_range` de una manera que sea compatible con` QuantizeAndDequantize {V2 | V3} `y` QuantizeV2`, utilizando el siguiente 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);

Clases anidadas

clase Descuantizar.Opciones Los atributos opcionales para Dequantize

Constantes

Cuerda OP_NAME El nombre de esta operación, como lo conoce el motor central de TensorFlow

Métodos públicos

Salida <U>
asOutput ()
Devuelve el identificador simbólico del tensor.
estáticas Dequantize.Options
eje (eje largo)
estática <U se extiende TNumber > descuantificar <U>
crear ( Alcance alcance, operando <? extiende Ttype > entrada, operando < TFloat32 > minRange, operando < TFloat32 > maxRange, Clase <U> dtype, Opciones ... Opciones)
Método de fábrica para crear una clase que envuelva una nueva operación Dequantize.
estática descuantificar < TFloat32 >
crear ( Alcance alcance, operando <? extiende Ttype > entrada, operando < TFloat32 > minRange, operando < TFloat32 > maxRange, Opciones ... Opciones)
Método de fábrica para crear una clase que envuelva una nueva operación Dequantize utilizando tipos de salida predeterminados.
estáticas Dequantize.Options
el modo (modo String)
estáticas Dequantize.Options
narrowRange (Boolean narrowRange)
Salida <U>
salida ()

Métodos heredados

Constantes

OP_NAME pública final static String

El nombre de esta operación, como lo conoce el motor central de TensorFlow

Valor constante: "descuantificar"

Métodos públicos

pública de salida <U> asOutput ()

Devuelve el identificador simbólico del tensor.

Las entradas a las operaciones de TensorFlow son salidas de otra operación de TensorFlow. Este método se utiliza para obtener un identificador simbólico que representa el cálculo de la entrada.

public static Dequantize.Options eje (eje largo)

public static descuantificar <U> crear ( Alcance alcance, operando <? extiende Ttype > entrada, operando < TFloat32 > minRange, operando < TFloat32 > maxRange, Clase <U> dtype, Opciones ... Opciones)

Método de fábrica para crear una clase que envuelva una nueva operación Dequantize.

Parámetros
alcance alcance actual
minRange El valor escalar mínimo posiblemente producido para la entrada.
rango máximo El valor escalar máximo posiblemente producido para la entrada.
dtype Tipo de tensor de salida. Actualmente, Dequantize admite float y bfloat16. Si 'dtype' es 'bfloat16', solo admite el modo 'MIN_COMBINED'.
opciones lleva valores de atributos opcionales
Devoluciones
  • una nueva instancia de Dequantize

public static descuantificar < TFloat32 > create ( Alcance alcance, operando <? extiende Ttype > entrada, operando < TFloat32 > minRange, operando < TFloat32 > maxRange, Opciones ... Opciones)

Método de fábrica para crear una clase que envuelva una nueva operación Dequantize utilizando tipos de salida predeterminados.

Parámetros
alcance alcance actual
minRange El valor escalar mínimo posiblemente producido para la entrada.
rango máximo El valor escalar máximo posiblemente producido para la entrada.
opciones lleva valores de atributos opcionales
Devoluciones
  • una nueva instancia de Dequantize

estáticas pública Dequantize.Options modo (modo de cadena)

public static Dequantize.Options narrowRange (booleano narrowRange)

pública de salida <U> salida ()