org.tensorflow.op.core

Class QuantizeAndDequantizeV2<T extends Number>

java.lang.Object

org.tensorflow.op.PrimitiveOp

org.tensorflow.op.core.QuantizeAndDequantizeV2<T>

Type Parameters:

T - data type for output() output

All Implemented Interfaces:

Op, Operand<T>

@Operator
public final class QuantizeAndDequantizeV2<T extends Number>
extends PrimitiveOp
implements Operand<T>

Quantizes then dequantizes a tensor.

This op simulates the precision loss from the quantized forward pass by:

1. Quantizing the tensor to fixed point numbers, which should match the target quantization method when it is used in inference. 2. Dequantizing it back to floating point numbers for the following ops, most likely matmul.

There are different ways to quantize. This version uses only scaling, so 0.0 maps to 0.

From the specified 'num_bits' in the quantized output type, it determines minimum and maximum representable quantized values.

e.g.

• [-128, 127] for signed, num_bits = 8, or
• [0, 255] for unsigned, num_bits = 8.

If range_given == False, the initial input_min, input_max will be determined automatically as the minimum and maximum values in the input tensor, otherwise the specified values of input_min, input_max are used.

Note: If the input_min, input_max are specified, they do not need to equal the actual minimum and maximum values in the tensor. e.g. in some cases it may be beneficial to specify these values such that the low probability extremes of the input distribution are clipped.

This op determines the maximum scale_factor that would map the initial [input_min, input_max] range to a range that lies within the representable quantized range.

It determines the scale from one of input_min and input_max, then updates the other one to maximize the respresentable range.

e.g.

• if the output is signed, num_bits = 8, [input_min, input_max] = [-10.0, 5.0]: it would use a scale_factor of -128 / -10.0 = 12.8 In this case, it would update input_max to be 127 / 12.8 = 9.921875
• if the output is signed, num_bits = 8, [input_min, input_max] = [-10.0, 10.0]: it would use a scale_factor of 127 / 10.0 = 12.7 In this case, it would update input_min to be 128.0 / 12.7 = -10.07874
• if the output is unsigned, input_min is forced to be 0, and only the specified input_max is used.

After determining the scale_factor and updating the input range, it applies the following to each value in the 'input' tensor.

output = round(clamp(value, input_min, input_max) * scale_factor) / scale_factor.

The above round function rounds the value based on the given round_mode.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	QuantizeAndDequantizeV2.Options Optional attributes for QuantizeAndDequantizeV2

Field Summary

Fields inherited from class org.tensorflow.op.PrimitiveOp

operation

Method Summary

Modifier and Type	Method and Description
Output<T>	asOutput() Returns the symbolic handle of a tensor.
static <T extends Number> QuantizeAndDequantizeV2<T>	create(Scope scope, Operand<T> input, Operand<T> inputMin, Operand<T> inputMax, QuantizeAndDequantizeV2.Options... options) Factory method to create a class to wrap a new QuantizeAndDequantizeV2 operation to the graph.
static QuantizeAndDequantizeV2.Options	numBits(Long numBits)
Output<T>	output()
static QuantizeAndDequantizeV2.Options	rangeGiven(Boolean rangeGiven)
static QuantizeAndDequantizeV2.Options	roundMode(String roundMode)
static QuantizeAndDequantizeV2.Options	signedInput(Boolean signedInput)

Methods inherited from class org.tensorflow.op.PrimitiveOp

equals, hashCode, toString

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Method Detail

create

public static <T extends Number> QuantizeAndDequantizeV2<T> create(Scope scope,
                                                                   Operand<T> input,
                                                                   Operand<T> inputMin,
                                                                   Operand<T> inputMax,
                                                                   QuantizeAndDequantizeV2.Options... options)

Factory method to create a class to wrap a new QuantizeAndDequantizeV2 operation to the graph.

Parameters:

scope - current graph scope

input - Tensor to quantize and then dequantize.

inputMin - If `range_given == True`, this specifies the minimum input value that needs to be represented, otherwise it is determined from the min value of the `input` tensor.

inputMax - If `range_given == True`, this specifies the maximum input value that needs to be represented, otherwise it is determined from the max value of the `input` tensor.

options - carries optional attributes values

Returns:

a new instance of QuantizeAndDequantizeV2

signedInput

public static QuantizeAndDequantizeV2.Options signedInput(Boolean signedInput)

Parameters:

signedInput - Whether the quantization is signed or unsigned. (actually this parameter should have been called `signed_output`)

numBits

public static QuantizeAndDequantizeV2.Options numBits(Long numBits)

Parameters:

numBits - The bitwidth of the quantization.

rangeGiven

public static QuantizeAndDequantizeV2.Options rangeGiven(Boolean rangeGiven)

Parameters:

rangeGiven - Whether the range is given or should be determined from the `input` tensor.

roundMode

public static QuantizeAndDequantizeV2.Options roundMode(String roundMode)

Parameters:

roundMode - The 'round_mode' attribute controls which rounding tie-breaking algorithm is used when rounding float values to their quantized equivalents. The following rounding modes are currently supported:

• HALF_TO_EVEN: this is the default round_mode.
• HALF_UP: round towards positive. In this mode 7.5 rounds up to 8 and -7.5 rounds up to -7.

output

public Output<T> output()

asOutput

public Output<T> asOutput()

Description copied from interface: Operand

Returns the symbolic handle of a tensor.

Inputs to TensorFlow operations are outputs of another TensorFlow operation. This method is used to obtain a symbolic handle that represents the computation of the input.

Specified by:

asOutput in interface Operand<T extends Number>

See Also:

OperationBuilder.addInput(Output)