tensorflow::ops::Dequantize

#include <array_ops.h>

Dequantize the 'input' tensor into a float or bfloat16 Tensor.

Summary

[min_range, max_range] are scalar floats that specify the range for the output. The 'mode' attribute controls exactly which calculations are used to convert the float values to their quantized equivalents.

In 'MIN_COMBINED' mode, each value of the tensor will undergo the following:

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

MIN_COMBINED Mode Example

If the input comes from a QuantizedRelu6, the output type is quint8 (range of 0-255) but the possible range of QuantizedRelu6 is 0-6. The min_range and max_range values are therefore 0.0 and 6.0. Dequantize on quint8 will take each value, cast to float, and multiply by 6 / 255. Note that if quantizedtype is qint8, the operation will additionally add each value by 128 prior to casting.

If the mode is 'MIN_FIRST', then this approach is used:

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(input) - lowest_quantized;
result = range_min + ((input - numeric_limits::min()) * range_scale)

If the mode is SCALED, dequantization is performed by multiplying each input value by a scaling_factor. (Thus an input of 0 always maps to 0.0).

The scaling_factor is determined from min_range, max_range, and narrow_range in a way that is compatible with QuantizeAndDequantize{V2|V3} and QuantizeV2, using the following algorithm:

  

  

    
  const int min_expected_T = std::numeric_limits::min() +
    (narrow_range ? 1 : 0);
  const int max_expected_T = std::numeric_limits::max();
  const float max_expected_T = std::numeric_limits::max();

  

  

    
  const float scale_factor =
    (std::numeric_limits::min() == 0) ? (max_range / max_expected_T)
                                         : std::max(min_range / min_expected_T,
                                                    max_range / max_expected_T);


  

  
Arguments:
    
      
  • scope: A Scope object
    • 
      
  • min_range: The minimum scalar value possibly produced for the input.
    • 
      
  • max_range: The maximum scalar value possibly produced for the input.
    • 
    

  
Optional attributes (see Attrs):
    
      
  • dtype: Type of the output tensor. Currently Dequantize supports float and bfloat16. If 'dtype' is 'bfloat16', it only supports 'MIN_COMBINED' mode.
    • 
    

  
Returns:

  

    

      
        
Constructors and Destructors

      		
    

    

      
        Dequantize(const ::tensorflow::Scope & scope, ::tensorflow::Input input, ::tensorflow::Input min_range, ::tensorflow::Input max_range)
        

      		
    

    

      
        Dequantize(const ::tensorflow::Scope & scope, ::tensorflow::Input input, ::tensorflow::Input min_range, ::tensorflow::Input max_range, const Dequantize::Attrs & attrs)
        

      		
    

  

  

    

      
        
Public attributes

      		
    

    

      
        operation
      
      
        
      
    

    

      
        output
      
      
        
      
    

  

  

    

      
        
Public functions

      		
    

    

      
        node() const 
      
      
        

          ::tensorflow::Node *
        

      		
    

    

      
        operator::tensorflow::Input() const 
      
      
        

          
        

      		
    

    

      
        operator::tensorflow::Output() const 
      
      
        

          
        

      		
    

  

  

    

      
        
Public static functions

      		
    

    

      
        Axis(int64 x)
      
      
        
      
    

    

      
        Dtype(DataType x)
      
      
        
      
    

    

      
        Mode(StringPiece x)
      
      
        
      
    

    

      
        NarrowRange(bool x)
      
      
        
      
    

  

  

    

      
        
Structs

      		
    

    

      
        tensorflow::ops::Dequantize::Attrs
      
      
        
Optional attribute setters for Dequantize. 

      		
    

  

  
Public attributes

  

    
operation

    
Operation operation

    

  

  

    
output

    
::tensorflow::Output output

    

  

  
Public functions

  

    
Dequantize

    
 Dequantize(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range
)

    

  

  

    
Dequantize

    
 Dequantize(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  const Dequantize::Attrs & attrs
)

    

  

  

    
node

    
::tensorflow::Node * node() const 

    

  

  

    
operator::tensorflow::Input

    
 operator::tensorflow::Input() const 

    

  

  

    
operator::tensorflow::Output

    
 operator::tensorflow::Output() const 

    

  

  
Public static functions

  

    
Axis

    
Attrs Axis(
  int64 x
)

    

  

  

    
Dtype

    
Attrs Dtype(
  DataType x
)

    

  

  

    
Mode

    
Attrs Mode(
  StringPiece x
)

    

  

  

    
NarrowRange

    
Attrs NarrowRange(
  bool x
)