This operation pads a `input` with zeros according to the `paddings` you
specify. `paddings` is an integer tensor with shape `[Dn, 2]`, where n is the
rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
how many zeros to add before the contents of `input` in that dimension, and
`paddings[D, 1]` indicates how many zeros to add after the contents of `input`
in that dimension.

This operation pads `input` according to the `paddings` and `constant_values`
you specify. `paddings` is an integer tensor with shape `[Dn, 2]`, where n is
the rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
how many padding values to add before the contents of `input` in that dimension,
and `paddings[D, 1]` indicates how many padding values to add after the contents
of `input` in that dimension. `constant_values` is a scalar tensor of the same
type as `input` that indicates the value to use for padding `input`.

'x' is [[1, 4]]

'y' is [[2, 5]]

'z' is [[3, 6]]

The difference between concat and parallel_concat is that concat requires all
of the inputs be computed before the operation will begin but doesn't require
that the input shapes be known during graph construction. Parallel concat
will copy pieces of the input into the output as they become available, in
some situations this can provide a performance benefit.

Arguments:
* scope: A Scope object
* values: Tensors to be concatenated. All must have size 1 in the first dimension
and same shape.
* shape: the final shape of the result; should be equal to the shapes of any input
but with the number of input values in the first dimension.

/** A placeholder op for a value that will be fed into the computation.

N.B. This operation will fail with an error if it is executed. It is
intended as a way to represent a value that will always be fed, and to
provide attrs that enable the fed value to be checked at runtime.

Arguments:
* scope: A Scope object
* dtype: The type of elements in the tensor.

Optional attributes (see `Attrs`):
* shape: (Optional) The shape of the tensor. If the shape has 0 dimensions, the
shape is unconstrained.

Returns:
* `Output`: A placeholder tensor that must be replaced using the feed mechanism. */
class Placeholder {
public:
/// Optional attribute setters for Placeholder
struct Attrs {
/** (Optional) The shape of the tensor. If the shape has 0 dimensions, the
shape is unconstrained.

When building ops to compute gradients, the TensorFlow gradient system
will return an error when trying to lookup the gradient of this op,
because no gradient must ever be registered for this function. This
op exists to prevent subtle bugs from silently returning unimplemented
gradients in some corner cases.

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.

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.

Arguments:
* scope: A Scope object
* input: Tensor to quantize and then dequantize.
* input_min: 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.
* input_max: 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.

Optional attributes (see `Attrs`):
* signed_input: Whether the quantization is signed or unsigned. (actually this parameter should
have been called `signed_output`)
* num_bits: The bitwidth of the quantization.
* range_given: Whether the range is given or should be determined from the `input` tensor.

Returns:
* `Output`: The output tensor. */
class QuantizeAndDequantizeV2 {
public:
/// Optional attribute setters for QuantizeAndDequantizeV2
struct Attrs {
/** Whether the quantization is signed or unsigned. (actually this parameter should
have been called `signed_output`)

[min_range, max_range] are scalar floats that specify the range for
the 'input' data. The 'mode' attribute controls exactly which calculations are
used to convert the float values to their quantized equivalents. The
'round_mode' attribute controls which rounding tie-breaking algorithm is used
when rounding float values to their quantized equivalents.

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

Assume the input is type float and has a possible range of [0.0, 6.0] and the
output type is quint8 ([0, 255]). The min_range and max_range values should be
specified as 0.0 and 6.0. Quantizing from float to quint8 will multiply each
value of the input by 255/6 and cast to quint8.

If the output type was qint8 ([-128, 127]), the operation will additionally
subtract each value by 128 prior to casting, so that the range of values aligns
with the range of qint8.

The biggest difference between this and MIN_COMBINED is that the minimum range
is rounded first, before it's subtracted from the rounded value. With
MIN_COMBINED, a small bias is introduced where repeated iterations of quantizing
and dequantizing will introduce a larger and larger error.

*SCALED mode Example*

`SCALED` mode matches the quantization approach used in
`QuantizeAndDequantize{V2|V3}`.

If the mode is `SCALED`, we do not use the full range of the output type,
choosing to elide the lowest possible value for symmetry (e.g., output range is
-127 to 127, not -128 to 127 for signed 8 bit quantization), so that 0.0 maps to
0.

We first find the range of values in our tensor. The
range we use is always centered on 0, so we find m such that

c++ m = max(abs(input_min), abs(input_max))

Our input tensor range is then `[-m, m]`.

Next, we choose our fixed-point quantization buckets, `[min_fixed, max_fixed]`.
If T is signed, this is

One thing to watch out for is that the operator may choose to adjust the
requested minimum and maximum values slightly during the quantization process,
so you should always use the output ports as the range for further calculations.
For example, if the requested minimum and maximum values are close to equal,
they will be separated by a small epsilon value to prevent ill-formed quantized
buffers from being created. Otherwise, you can end up with buffers where all the
quantized values map to the same float value, which causes problems for
operations that have to perform further calculations on them.

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.

Arguments:
* scope: A Scope object
* concat_dim: 0-D. The dimension along which to concatenate. Must be in the
range [0, rank(values)).
* values: The `N` Tensors to concatenate. Their ranks and types must match,
and their sizes must match in all dimensions except `concat_dim`.
* input_mins: The minimum scalar values for each of the input tensors.
* input_maxes: The maximum scalar values for each of the input tensors.

Optional attributes (see `Attrs`):
* output_range_given: If True, `given_y_min` and `given_y_min`
and `given_y_max` are used as the output range. Otherwise,
the implementation computes the output range.
* given_y_min: Output in `y_min` if `output_range_given` is True.
* given_y_max: Output in `y_max` if `output_range_given` is True.
* variance_epsilon: A small float number to avoid dividing by 0.
* min_separation: Minimum value of `y_max - y_min`