tf.raw_ops.QuantizedConv2DWithBiasAndRelu  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedConv2DWithBiasAndRelu
tf.raw_ops.QuantizedConv2DWithBiasAndRelu(
    input, filter, bias, min_input, max_input, min_filter, max_filter, strides,
    padding, out_type=tf.dtypes.qint32, dilations=[1, 1, 1, 1], padding_list=[],
    name=None
)

 Args
  input   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  filter   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  bias   A Tensor of type float32.
  min_input   A Tensor of type float32.
  max_input   A Tensor of type float32.
  min_filter   A Tensor of type float32.
  max_filter   A Tensor of type float32.
  strides   A list of ints.
  padding   A string from: "SAME", "VALID".
  out_type   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.qint32.
  dilations   An optional list of ints. Defaults to [1, 1, 1, 1].
  padding_list   An optional list of ints. Defaults to [].
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output, min_output, max_output).     output   A Tensor of type out_type.
  min_output   A Tensor of type float32.
  max_output   A Tensor of type float32.


tf.raw_ops.QuantizedConv2DWithBiasAndReluAndRequantize  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedConv2DWithBiasAndReluAndRequantize
tf.raw_ops.QuantizedConv2DWithBiasAndReluAndRequantize(
    input, filter, bias, min_input, max_input, min_filter, max_filter,
    min_freezed_output, max_freezed_output, strides, padding,
    out_type=tf.dtypes.quint8, dilations=[1, 1, 1, 1], padding_list=[], name=None
)

 Args
  input   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  filter   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  bias   A Tensor. Must be one of the following types: float32, qint32.
  min_input   A Tensor of type float32.
  max_input   A Tensor of type float32.
  min_filter   A Tensor of type float32.
  max_filter   A Tensor of type float32.
  min_freezed_output   A Tensor of type float32.
  max_freezed_output   A Tensor of type float32.
  strides   A list of ints.
  padding   A string from: "SAME", "VALID".
  out_type   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.quint8.
  dilations   An optional list of ints. Defaults to [1, 1, 1, 1].
  padding_list   An optional list of ints. Defaults to [].
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output, min_output, max_output).     output   A Tensor of type out_type.
  min_output   A Tensor of type float32.
  max_output   A Tensor of type float32.


tf.raw_ops.QuantizedConv2DWithBiasAndRequantize  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedConv2DWithBiasAndRequantize
tf.raw_ops.QuantizedConv2DWithBiasAndRequantize(
    input, filter, bias, min_input, max_input, min_filter, max_filter,
    min_freezed_output, max_freezed_output, strides, padding,
    out_type=tf.dtypes.qint8, dilations=[1, 1, 1, 1], padding_list=[], name=None
)

 Args
  input   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  filter   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  bias   A Tensor. Must be one of the following types: float32, qint32.
  min_input   A Tensor of type float32.
  max_input   A Tensor of type float32.
  min_filter   A Tensor of type float32.
  max_filter   A Tensor of type float32.
  min_freezed_output   A Tensor of type float32.
  max_freezed_output   A Tensor of type float32.
  strides   A list of ints.
  padding   A string from: "SAME", "VALID".
  out_type   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.qint8.
  dilations   An optional list of ints. Defaults to [1, 1, 1, 1].
  padding_list   An optional list of ints. Defaults to [].
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output, min_output, max_output).     output   A Tensor of type out_type.
  min_output   A Tensor of type float32.
  max_output   A Tensor of type float32.


tf.raw_ops.QuantizedConv2DWithBiasSignedSumAndReluAndRequantize  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedConv2DWithBiasSignedSumAndReluAndRequantize
tf.raw_ops.QuantizedConv2DWithBiasSignedSumAndReluAndRequantize(
    input, filter, bias, min_input, max_input, min_filter, max_filter,
    min_freezed_output, max_freezed_output, summand, min_summand, max_summand,
    strides, padding, out_type=tf.dtypes.quint8, dilations=[1, 1, 1, 1],
    padding_list=[], name=None
)

 Args
  input   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  filter   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  bias   A Tensor. Must be one of the following types: float32, qint32.
  min_input   A Tensor of type float32.
  max_input   A Tensor of type float32.
  min_filter   A Tensor of type float32.
  max_filter   A Tensor of type float32.
  min_freezed_output   A Tensor of type float32.
  max_freezed_output   A Tensor of type float32.
  summand   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  min_summand   A Tensor of type float32.
  max_summand   A Tensor of type float32.
  strides   A list of ints.
  padding   A string from: "SAME", "VALID".
  out_type   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.quint8.
  dilations   An optional list of ints. Defaults to [1, 1, 1, 1].
  padding_list   An optional list of ints. Defaults to [].
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output, min_output, max_output).     output   A Tensor of type out_type.
  min_output   A Tensor of type float32.
  max_output   A Tensor of type float32.


tf.raw_ops.QuantizedConv2DWithBiasSumAndRelu  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedConv2DWithBiasSumAndRelu
tf.raw_ops.QuantizedConv2DWithBiasSumAndRelu(
    input, filter, bias, min_input, max_input, min_filter, max_filter, summand,
    strides, padding, out_type=tf.dtypes.qint32, dilations=[1, 1, 1, 1],
    padding_list=[], name=None
)

 Args
  input   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  filter   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  bias   A Tensor of type float32.
  min_input   A Tensor of type float32.
  max_input   A Tensor of type float32.
  min_filter   A Tensor of type float32.
  max_filter   A Tensor of type float32.
  summand   A Tensor of type float32.
  strides   A list of ints.
  padding   A string from: "SAME", "VALID".
  out_type   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.qint32.
  dilations   An optional list of ints. Defaults to [1, 1, 1, 1].
  padding_list   An optional list of ints. Defaults to [].
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output, min_output, max_output).     output   A Tensor of type out_type.
  min_output   A Tensor of type float32.
  max_output   A Tensor of type float32.


tf.raw_ops.QuantizedConv2DWithBiasSumAndReluAndRequantize  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedConv2DWithBiasSumAndReluAndRequantize
tf.raw_ops.QuantizedConv2DWithBiasSumAndReluAndRequantize(
    input, filter, bias, min_input, max_input, min_filter, max_filter,
    min_freezed_output, max_freezed_output, summand, min_summand, max_summand,
    strides, padding, out_type=tf.dtypes.quint8, dilations=[1, 1, 1, 1],
    padding_list=[], name=None
)

 Args
  input   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  filter   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  bias   A Tensor. Must be one of the following types: float32, qint32.
  min_input   A Tensor of type float32.
  max_input   A Tensor of type float32.
  min_filter   A Tensor of type float32.
  max_filter   A Tensor of type float32.
  min_freezed_output   A Tensor of type float32.
  max_freezed_output   A Tensor of type float32.
  summand   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  min_summand   A Tensor of type float32.
  max_summand   A Tensor of type float32.
  strides   A list of ints.
  padding   A string from: "SAME", "VALID".
  out_type   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.quint8.
  dilations   An optional list of ints. Defaults to [1, 1, 1, 1].
  padding_list   An optional list of ints. Defaults to [].
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output, min_output, max_output).     output   A Tensor of type out_type.
  min_output   A Tensor of type float32.
  max_output   A Tensor of type float32.


tf.raw_ops.QuantizedDepthwiseConv2D Computes quantized depthwise Conv2D.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedDepthwiseConv2D
tf.raw_ops.QuantizedDepthwiseConv2D(
    input, filter, min_input, max_input, min_filter, max_filter, strides, padding,
    out_type=tf.dtypes.qint32, dilations=[1, 1, 1, 1], name=None
)

 Args
  input   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. The original input tensor.
  filter   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. The original filter tensor.
  min_input   A Tensor of type float32. The float value that the minimum quantized input value represents.
  max_input   A Tensor of type float32. The float value that the maximum quantized input value represents.
  min_filter   A Tensor of type float32. The float value that the minimum quantized filter value represents.
  max_filter   A Tensor of type float32. The float value that the maximum quantized filter value represents.
  strides   A list of ints. List of stride values.
  padding   A string from: "SAME", "VALID".
  out_type   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.qint32. The type of the output.
  dilations   An optional list of ints. Defaults to [1, 1, 1, 1]. List of dilation values.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output, min_output, max_output).     output   A Tensor of type out_type.
  min_output   A Tensor of type float32.
  max_output   A Tensor of type float32.


tf.raw_ops.QuantizedDepthwiseConv2DWithBias Computes quantized depthwise Conv2D with Bias.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedDepthwiseConv2DWithBias
tf.raw_ops.QuantizedDepthwiseConv2DWithBias(
    input, filter, bias, min_input, max_input, min_filter, max_filter, strides,
    padding, out_type=tf.dtypes.qint32, dilations=[1, 1, 1, 1], name=None
)

 Args
  input   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. The original input tensor.
  filter   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. The original filter tensor.
  bias   A Tensor of type float32. The original bias tensor.
  min_input   A Tensor of type float32. The float value that the minimum quantized input value represents.
  max_input   A Tensor of type float32. The float value that the maximum quantized input value represents.
  min_filter   A Tensor of type float32. The float value that the minimum quantized filter value represents.
  max_filter   A Tensor of type float32. The float value that the maximum quantized filter value represents.
  strides   A list of ints. List of stride values.
  padding   A string from: "SAME", "VALID".
  out_type   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.qint32. The type of the output.
  dilations   An optional list of ints. Defaults to [1, 1, 1, 1]. List of dilation values.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output, min_output, max_output).     output   A Tensor of type out_type.
  min_output   A Tensor of type float32.
  max_output   A Tensor of type float32.


tf.raw_ops.QuantizedDepthwiseConv2DWithBiasAndRelu Computes quantized depthwise Conv2D with Bias and Relu.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedDepthwiseConv2DWithBiasAndRelu
tf.raw_ops.QuantizedDepthwiseConv2DWithBiasAndRelu(
    input, filter, bias, min_input, max_input, min_filter, max_filter, strides,
    padding, out_type=tf.dtypes.qint32, dilations=[1, 1, 1, 1], padding_list=[],
    name=None
)

 Args
  input   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. The original input tensor.
  filter   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. The original filter tensor.
  bias   A Tensor of type float32. The original bias tensor.
  min_input   A Tensor of type float32. The float value that the minimum quantized input value represents.
  max_input   A Tensor of type float32. The float value that the maximum quantized input value represents.
  min_filter   A Tensor of type float32. The float value that the minimum quantized filter value represents.
  max_filter   A Tensor of type float32. The float value that the maximum quantized filter value represents.
  strides   A list of ints. List of stride values.
  padding   A string from: "SAME", "VALID".
  out_type   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.qint32. The type of the output.
  dilations   An optional list of ints. Defaults to [1, 1, 1, 1]. List of dilation values.
  padding_list   An optional list of ints. Defaults to [].
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output, min_output, max_output).     output   A Tensor of type out_type.
  min_output   A Tensor of type float32.
  max_output   A Tensor of type float32.


tf.raw_ops.QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize Computes quantized depthwise Conv2D with Bias, Relu and Requantize.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize
tf.raw_ops.QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize(
    input, filter, bias, min_input, max_input, min_filter, max_filter,
    min_freezed_output, max_freezed_output, strides, padding,
    out_type=tf.dtypes.quint8, dilations=[1, 1, 1, 1], padding_list=[], name=None
)

 Args
  input   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. The original input tensor.
  filter   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. The original filter tensor.
  bias   A Tensor. Must be one of the following types: float32, qint32. The original bias tensor.
  min_input   A Tensor of type float32. The float value that the minimum quantized input value represents.
  max_input   A Tensor of type float32. The float value that the maximum quantized input value represents.
  min_filter   A Tensor of type float32. The float value that the minimum quantized filter value represents.
  max_filter   A Tensor of type float32. The float value that the maximum quantized filter value represents.
  min_freezed_output   A Tensor of type float32. The minimum float value of the output tensor.
  max_freezed_output   A Tensor of type float32. The maximum float value of the output tensor.
  strides   A list of ints. List of stride values.
  padding   A string from: "SAME", "VALID".
  out_type   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.quint8. The type of the output.
  dilations   An optional list of ints. Defaults to [1, 1, 1, 1]. List of dilation values.
  padding_list   An optional list of ints. Defaults to [].
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output, min_output, max_output).     output   A Tensor of type out_type.
  min_output   A Tensor of type float32.
  max_output   A Tensor of type float32.


tf.raw_ops.QuantizedInstanceNorm Quantized Instance normalization.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedInstanceNorm
tf.raw_ops.QuantizedInstanceNorm(
    x, x_min, x_max, output_range_given=False, given_y_min=0, given_y_max=0,
    variance_epsilon=1e-05, min_separation=0.001, name=None
)

 Args
  x   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. A 4D input Tensor.
  x_min   A Tensor of type float32. The value represented by the lowest quantized input.
  x_max   A Tensor of type float32. The value represented by the highest quantized input.
  output_range_given   An optional bool. Defaults to False. 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   An optional float. Defaults to 0. Output in y_min if output_range_given is True.
  given_y_max   An optional float. Defaults to 0. Output in y_max if output_range_given is True.
  variance_epsilon   An optional float. Defaults to 1e-05. A small float number to avoid dividing by 0.
  min_separation   An optional float. Defaults to 0.001. Minimum value of y_max - y_min
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (y, y_min, y_max).     y   A Tensor. Has the same type as x.
  y_min   A Tensor of type float32.
  y_max   A Tensor of type float32.


tf.raw_ops.QuantizedMatMul Perform a quantized matrix multiplication of a by the matrix b.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedMatMul
tf.raw_ops.QuantizedMatMul(
    a, b, min_a, max_a, min_b, max_b, Toutput=tf.dtypes.qint32, transpose_a=False,
    transpose_b=False, Tactivation=tf.dtypes.quint8, name=None
)
 The inputs must be two-dimensional matrices and the inner dimension of a (after being transposed if transpose_a is non-zero) must match the outer dimension of b (after being transposed if transposed_b is non-zero).

 Args
  a   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. Must be a two-dimensional tensor.
  b   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. Must be a two-dimensional tensor.
  min_a   A Tensor of type float32. The float value that the lowest quantized a value represents.
  max_a   A Tensor of type float32. The float value that the highest quantized a value represents.
  min_b   A Tensor of type float32. The float value that the lowest quantized b value represents.
  max_b   A Tensor of type float32. The float value that the highest quantized b value represents.
  Toutput   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.qint32.
  transpose_a   An optional bool. Defaults to False. If true, a is transposed before multiplication.
  transpose_b   An optional bool. Defaults to False. If true, b is transposed before multiplication.
  Tactivation   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.quint8. The type of output produced by activation function following this operation.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (out, min_out, max_out).     out   A Tensor of type Toutput.
  min_out   A Tensor of type float32.
  max_out   A Tensor of type float32.


tf.raw_ops.QuantizedMatMulWithBias Performs a quantized matrix multiplication of a by the matrix b with bias  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedMatMulWithBias
tf.raw_ops.QuantizedMatMulWithBias(
    a, b, bias, min_a, max_a, min_b, max_b, Toutput=tf.dtypes.qint32,
    transpose_a=False, transpose_b=False, input_quant_mode='MIN_FIRST',
    name=None
)
 add. The inputs must be two-dimensional matrices and 1D bias vector. And the inner dimension of a (after being transposed if transpose_a is non-zero) must match the outer dimension of b (after being transposed if transposed_b is non-zero). Then do broadcast add operation with bias values on the matrix multiplication result. The bias size must match inner dimension of b. Args: a: A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. A matrix to be multiplied. Must be a two-dimensional tensor of type quint8. b: A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. A matrix to be multiplied and must be a two-dimensional tensor of type qint8. bias: A Tensor. Must be one of the following types: float32, qint32. A 1D bias tensor with size matching inner dimension of b (after being transposed if transposed_b is non-zero). min_a: A Tensor of type float32. The float value that the lowest quantized a value represents. max_a: A Tensor of type float32. The float value that the highest quantized a value represents. min_b: A Tensor of type float32. The float value that the lowest quantized b value represents. max_b: A Tensor of type float32. The float value that the highest quantized b value represents. Toutput: An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.qint32. transpose_a: An optional bool. Defaults to False. If true, a is transposed before multiplication. transpose_b: An optional bool. Defaults to False. If true, b is transposed before multiplication. input_quant_mode: An optional string from: "MIN_FIRST", "SCALED". Defaults to "MIN_FIRST". Input data quantization mode. Either MIN_FIRST(default) or SCALED. name: A name for the operation (optional). Returns: A tuple of Tensor objects (out, min_out, max_out). out: A `Tensor` of type `Toutput`.
min_out: A `Tensor` of type `float32`.
max_out: A `Tensor` of type `float32`.


tf.raw_ops.QuantizedMatMulWithBiasAndDequantize  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedMatMulWithBiasAndDequantize
tf.raw_ops.QuantizedMatMulWithBiasAndDequantize(
    a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output,
    Toutput, transpose_a=False, transpose_b=False,
    input_quant_mode='MIN_FIRST', name=None
)

 Args
  a   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  b   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  bias   A Tensor. Must be one of the following types: float32, qint32.
  min_a   A Tensor of type float32.
  max_a   A Tensor of type float32.
  min_b   A Tensor of type float32.
  max_b   A Tensor of type float32.
  min_freezed_output   A Tensor of type float32.
  max_freezed_output   A Tensor of type float32.
  Toutput   A tf.DType from: tf.float32.
  transpose_a   An optional bool. Defaults to False.
  transpose_b   An optional bool. Defaults to False.
  input_quant_mode   An optional string from: "MIN_FIRST", "SCALED". Defaults to "MIN_FIRST".
  name   A name for the operation (optional).

 Returns   A Tensor of type Toutput.


tf.raw_ops.QuantizedMatMulWithBiasAndRelu Perform a quantized matrix multiplication of a by the matrix b with bias  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedMatMulWithBiasAndRelu
tf.raw_ops.QuantizedMatMulWithBiasAndRelu(
    a, b, bias, min_a, max_a, min_b, max_b, Toutput=tf.dtypes.qint32,
    transpose_a=False, transpose_b=False, input_quant_mode='MIN_FIRST',
    name=None
)
 add and relu fusion. The inputs must be two-dimensional matrices and 1D bias vector. And the inner dimension of a (after being transposed if transpose_a is non-zero) must match the outer dimension of b (after being transposed if transposed_b is non-zero). Then do broadcast add operation with bias values on the matrix multiplication result. The bias size must match inner dimension of b. Then do relu activation to get non-negative result. Args: a: A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. A matrix to be multiplied. Must be a two-dimensional tensor of type quint8. b: A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. A matrix to be multiplied and must be a two-dimensional tensor of type qint8. bias: A Tensor of type float32. A 1D bias tensor with size matching with inner dimension of b (after being transposed if transposed_b is non-zero). min_a: A Tensor of type float32. The float value that the lowest quantized a value represents. max_a: A Tensor of type float32. The float value that the highest quantized a value represents. min_b: A Tensor of type float32. The float value that the lowest quantized b value represents. max_b: A Tensor of type float32. The float value that the highest quantized b value represents. Toutput: An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.qint32. transpose_a: An optional bool. Defaults to False. If true, a is transposed before multiplication. transpose_b: An optional bool. Defaults to False. If true, b is transposed before multiplication. input_quant_mode: An optional string from: "MIN_FIRST", "SCALED". Defaults to "MIN_FIRST". Input data quantization mode. Either MIN_FIRST(default) or SCALED. name: A name for the operation (optional). Returns: A tuple of Tensor objects (out, min_out, max_out). out: A `Tensor` of type `Toutput`.
min_out: A `Tensor` of type `float32`.
max_out: A `Tensor` of type `float32`.


tf.raw_ops.QuantizedMatMulWithBiasAndReluAndRequantize Perform a quantized matrix multiplication of a by the matrix b with bias  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedMatMulWithBiasAndReluAndRequantize
tf.raw_ops.QuantizedMatMulWithBiasAndReluAndRequantize(
    a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output,
    Toutput=tf.dtypes.quint8, transpose_a=False, transpose_b=False,
    input_quant_mode='MIN_FIRST', name=None
)
 add and relu and requantize fusion. The inputs must be two-dimensional matrices and 1D bias vector. And the inner dimension of a (after being transposed if transpose_a is non-zero) must match the outer dimension of b (after being transposed if transposed_b is non-zero). Then do broadcast add operation with bias values on the matrix multiplication result. The bias size must match inner dimension of b. Then do relu activation to get non-negative result. Then do requantize operation to get final uint8 result. Args: a: A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. A matrix to be multiplied. Must be a two-dimensional tensor of type quint8. b: A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. A matrix to be multiplied and must be a two-dimensional tensor of type qint8. bias: A Tensor. Must be one of the following types: float32, qint32. A 1D bias tensor with size matching with inner dimension of b (after being transposed if transposed_b is non-zero). min_a: A Tensor of type float32. The float value that the lowest quantized a value represents. max_a: A Tensor of type float32. The float value that the highest quantized a value represents. min_b: A Tensor of type float32. The float value that the lowest quantized b value represents. max_b: A Tensor of type float32. The float value that the highest quantized b value represents. min_freezed_output: A Tensor of type float32. The float value that the highest quantized output value after requantize. max_freezed_output: A Tensor of type float32. Toutput: An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.quint8. transpose_a: An optional bool. Defaults to False. If true, a is transposed before multiplication. transpose_b: An optional bool. Defaults to False. If true, b is transposed before multiplication. input_quant_mode: An optional string from: "MIN_FIRST", "SCALED". Defaults to "MIN_FIRST". Input data quantization mode. Either MIN_FIRST(default) or SCALED. name: A name for the operation (optional). Returns: A tuple of Tensor objects (out, min_out, max_out). out: A `Tensor` of type `Toutput`.
min_out: A `Tensor` of type `float32`.
max_out: A `Tensor` of type `float32`.


tf.raw_ops.QuantizedMatMulWithBiasAndRequantize  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedMatMulWithBiasAndRequantize
tf.raw_ops.QuantizedMatMulWithBiasAndRequantize(
    a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output,
    Toutput=tf.dtypes.quint8, transpose_a=False, transpose_b=False,
    input_quant_mode='MIN_FIRST', name=None
)

 Args
  a   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  b   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  bias   A Tensor. Must be one of the following types: float32, qint32.
  min_a   A Tensor of type float32.
  max_a   A Tensor of type float32.
  min_b   A Tensor of type float32.
  max_b   A Tensor of type float32.
  min_freezed_output   A Tensor of type float32.
  max_freezed_output   A Tensor of type float32.
  Toutput   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.quint8.
  transpose_a   An optional bool. Defaults to False.
  transpose_b   An optional bool. Defaults to False.
  input_quant_mode   An optional string from: "MIN_FIRST", "SCALED". Defaults to "MIN_FIRST".
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (out, min_out, max_out).     out   A Tensor of type Toutput.
  min_out   A Tensor of type float32.
  max_out   A Tensor of type float32.


tf.raw_ops.QuantizedMaxPool Produces the max pool of the input tensor for quantized types.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedMaxPool
tf.raw_ops.QuantizedMaxPool(
    input, min_input, max_input, ksize, strides, padding, name=None
)

 Args
  input   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16. The 4D (batch x rows x cols x depth) Tensor to MaxReduce over.
  min_input   A Tensor of type float32. The float value that the lowest quantized input value represents.
  max_input   A Tensor of type float32. The float value that the highest quantized input value represents.
  ksize   A list of ints. The size of the window for each dimension of the input tensor. The length must be 4 to match the number of dimensions of the input.
  strides   A list of ints. The stride of the sliding window for each dimension of the input tensor. The length must be 4 to match the number of dimensions of the input.
  padding   A string from: "SAME", "VALID". The type of padding algorithm to use.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output, min_output, max_output).     output   A Tensor. Has the same type as input.
  min_output   A Tensor of type float32.
  max_output   A Tensor of type float32.


tf.raw_ops.QuantizedMul Returns x * y element-wise, working on quantized buffers.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedMul
tf.raw_ops.QuantizedMul(
    x, y, min_x, max_x, min_y, max_y, Toutput=tf.dtypes.qint32, name=None
)

 Args
  x   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  y   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  min_x   A Tensor of type float32. The float value that the lowest quantized x value represents.
  max_x   A Tensor of type float32. The float value that the highest quantized x value represents.
  min_y   A Tensor of type float32. The float value that the lowest quantized y value represents.
  max_y   A Tensor of type float32. The float value that the highest quantized y value represents.
  Toutput   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.qint32.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (z, min_z, max_z).     z   A Tensor of type Toutput.
  min_z   A Tensor of type float32.
  max_z   A Tensor of type float32.


tf.raw_ops.QuantizeDownAndShrinkRange Convert the quantized 'input' tensor into a lower-precision 'output', using the  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizeDownAndShrinkRange
tf.raw_ops.QuantizeDownAndShrinkRange(
    input, input_min, input_max, out_type, name=None
)
 actual distribution of the values to maximize the usage of the lower bit depth and adjusting the output min and max ranges accordingly. [input_min, input_max] are scalar floats that specify the range for the float interpretation of the 'input' data. For example, if input_min is -1.0f and input_max is 1.0f, and we are dealing with quint16 quantized data, then a 0 value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f. This operator tries to squeeze as much precision as possible into an output with a lower bit depth by calculating the actual min and max values found in the data. For example, maybe that quint16 input has no values lower than 16,384 and none higher than 49,152. That means only half the range is actually needed, all the float interpretations are between -0.5f and 0.5f, so if we want to compress the data into a quint8 output, we can use that range rather than the theoretical -1.0f to 1.0f that is suggested by the input min and max. In practice, this is most useful for taking output from operations like QuantizedMatMul that can produce higher bit-depth outputs than their inputs and may have large potential output ranges, but in practice have a distribution of input values that only uses a small fraction of the possible range. By feeding that output into this operator, we can reduce it from 32 bits down to 8 with minimal loss of accuracy.

 Args
  input   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  input_min   A Tensor of type float32. The float value that the minimum quantized input value represents.
  input_max   A Tensor of type float32. The float value that the maximum quantized input value represents.
  out_type   A tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. The type of the output. Should be a lower bit depth than Tinput.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output, output_min, output_max).     output   A Tensor of type out_type.
  output_min   A Tensor of type float32.
  output_max   A Tensor of type float32.


tf.raw_ops.QuantizedRelu Computes Quantized Rectified Linear: max(features, 0)  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedRelu
tf.raw_ops.QuantizedRelu(
    features, min_features, max_features, out_type=tf.dtypes.quint8, name=None
)

 Args
  features   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  min_features   A Tensor of type float32. The float value that the lowest quantized value represents.
  max_features   A Tensor of type float32. The float value that the highest quantized value represents.
  out_type   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.quint8.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (activations, min_activations, max_activations).     activations   A Tensor of type out_type.
  min_activations   A Tensor of type float32.
  max_activations   A Tensor of type float32.


tf.raw_ops.QuantizedRelu6 Computes Quantized Rectified Linear 6: min(max(features, 0), 6)  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedRelu6
tf.raw_ops.QuantizedRelu6(
    features, min_features, max_features, out_type=tf.dtypes.quint8, name=None
)

 Args
  features   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  min_features   A Tensor of type float32. The float value that the lowest quantized value represents.
  max_features   A Tensor of type float32. The float value that the highest quantized value represents.
  out_type   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.quint8.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (activations, min_activations, max_activations).     activations   A Tensor of type out_type.
  min_activations   A Tensor of type float32.
  max_activations   A Tensor of type float32.


tf.raw_ops.QuantizedReluX Computes Quantized Rectified Linear X: min(max(features, 0), max_value)  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedReluX
tf.raw_ops.QuantizedReluX(
    features, max_value, min_features, max_features, out_type=tf.dtypes.quint8,
    name=None
)

 Args
  features   A Tensor. Must be one of the following types: qint8, quint8, qint32, qint16, quint16.
  max_value   A Tensor of type float32.
  min_features   A Tensor of type float32. The float value that the lowest quantized value represents.
  max_features   A Tensor of type float32. The float value that the highest quantized value represents.
  out_type   An optional tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16. Defaults to tf.quint8.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (activations, min_activations, max_activations).     activations   A Tensor of type out_type.
  min_activations   A Tensor of type float32.
  max_activations   A Tensor of type float32.


tf.raw_ops.QuantizedReshape Reshapes a quantized tensor as per the Reshape op.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedReshape
tf.raw_ops.QuantizedReshape(
    tensor, shape, input_min, input_max, name=None
)

<colgroup><col width="214px"><col></colgroup>

Args

`tensor`

A `Tensor`.

`shape`

A `Tensor`. Must be one of the following types: `int32`, `int64`.
Defines the shape of the output tensor.

`input_min`

A `Tensor` of type `float32`. The minimum value of the input.

`input_max`

A `Tensor` of type `float32`. The maximum value of the input.

`name`

A name for the operation (optional).

<colgroup><col width="214px"><col></colgroup>

Returns

A tuple of `Tensor` objects (output, output_min, output_max).

`output`

A `Tensor`. Has the same type as `tensor`.

`output_min`

A `Tensor` of type `float32`.

`output_max`

A `Tensor` of type `float32`.


tf.raw_ops.QuantizedResizeBilinear Resize quantized images to size using quantized bilinear interpolation.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizedResizeBilinear
tf.raw_ops.QuantizedResizeBilinear(
    images, size, min, max, align_corners=False, half_pixel_centers=False, name=None
)
 Input images and output images must be quantized types.

 Args
  images   A Tensor. Must be one of the following types: quint8, qint32, float32. 4-D with shape [batch, height, width, channels].
  size   A 1-D int32 Tensor of 2 elements: new_height, new_width. The new size for the images.
  min   A Tensor of type float32.
  max   A Tensor of type float32.
  align_corners   An optional bool. Defaults to False. If true, the centers of the 4 corner pixels of the input and output tensors are aligned, preserving the values at the corner pixels. Defaults to false.
  half_pixel_centers   An optional bool. Defaults to False.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (resized_images, out_min, out_max).     resized_images   A Tensor. Has the same type as images.
  out_min   A Tensor of type float32.
  out_max   A Tensor of type float32.


tf.raw_ops.QuantizeV2 Quantize the 'input' tensor of type float to 'output' tensor of type 'T'.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QuantizeV2
tf.raw_ops.QuantizeV2(
    input, min_range, max_range, T, mode='MIN_COMBINED',
    round_mode='HALF_AWAY_FROM_ZERO', narrow_range=False, axis=-1,
    ensure_minimum_range=0.01, name=None
)
 [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: out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
if T == qint8: out[i] -= (range(T) + 1) / 2.0
 here range(T) = numeric_limits<T>::max() - numeric_limits<T>::min() MIN_COMBINED Mode Example 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. 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 = num_discrete_values / range
quantized = round(input * range_scale) - round(range_min * range_scale) +
  numeric_limits<T>::min()
quantized = max(quantized, numeric_limits<T>::min())
quantized = min(quantized, numeric_limits<T>::max())
 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, the quantization is performed by multiplying each input value by a scaling_factor. The scaling_factor is determined from min_range and max_range to be as large as possible such that the range from min_range to max_range is representable within values of type T.
const int min_T = std::numeric_limits<T>::min();
const int max_T = std::numeric_limits<T>::max();
const float max_float = std::numeric_limits<float>::max();

const float scale_factor_from_min_side =
    (min_T * min_range > 0) ? min_T / min_range : max_float;
const float scale_factor_from_max_side =
    (max_T * max_range > 0) ? max_T / max_range : max_float;

const float scale_factor = std::min(scale_factor_from_min_side,
                                    scale_factor_from_max_side);
 We next use the scale_factor to adjust min_range and max_range as follows: min_range = min_T / scale_factor;
max_range = max_T / scale_factor;
 e.g. if T = qint8, and initially min_range = -10, and max_range = 9, we would compare -128/-10.0 = 12.8 to 127/9.0 = 14.11, and set scaling_factor = 12.8 In this case, min_range would remain -10, but max_range would be adjusted to 127 / 12.8 = 9.921875 So we will quantize input values in the range (-10, 9.921875) to (-128, 127). The input tensor can now be quantized by clipping values to the range min_range to max_range, then multiplying by scale_factor as follows: result = round(min(max_range, max(min_range, input)) * scale_factor)
 The adjusted min_range and max_range are returned as outputs 2 and 3 of this operation. These outputs should be used as the range for any further calculations. narrow_range (bool) attribute If true, we do not use the minimum quantized value. i.e. for int8 the quantized output, it would be restricted to the range -127..127 instead of the full -128..127 range. This is provided for compatibility with certain inference backends. (Only applies to SCALED mode) axis (int) attribute An optional axis attribute can specify a dimension index of the input tensor, such that quantization ranges will be calculated and applied separately for each slice of the tensor along that dimension. This is useful for per-channel quantization. If axis is specified, min_range and max_range if axis=None, per-tensor quantization is performed as normal. ensure_minimum_range (float) attribute Ensures the minimum quantization range is at least this value. The legacy default value for this is 0.01, but it is strongly suggested to set it to 0 for new uses.

 Args
  input   A Tensor of type float32.
  min_range   A Tensor of type float32. The minimum value of the quantization range. This value may be adjusted by the op depending on other parameters. The adjusted value is written to output_min. If the axis attribute is specified, this must be a 1-D tensor whose size matches the axis dimension of the input and output tensors.
  max_range   A Tensor of type float32. The maximum value of the quantization range. This value may be adjusted by the op depending on other parameters. The adjusted value is written to output_max. If the axis attribute is specified, this must be a 1-D tensor whose size matches the axis dimension of the input and output tensors.
  T   A tf.DType from: tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16.
  mode   An optional string from: "MIN_COMBINED", "MIN_FIRST", "SCALED". Defaults to "MIN_COMBINED".
  round_mode   An optional string from: "HALF_AWAY_FROM_ZERO", "HALF_TO_EVEN". Defaults to "HALF_AWAY_FROM_ZERO".
  narrow_range   An optional bool. Defaults to False.
  axis   An optional int. Defaults to -1.
  ensure_minimum_range   An optional float. Defaults to 0.01.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output, output_min, output_max).     output   A Tensor of type T.
  output_min   A Tensor of type float32.
  output_max   A Tensor of type float32.


tf.raw_ops.QueueClose Closes the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueClose
tf.raw_ops.QueueClose(
    handle, cancel_pending_enqueues=False, name=None
)
 This operation signals that no more elements will be enqueued in the given queue. Subsequent Enqueue(Many) operations will fail. Subsequent Dequeue(Many) operations will continue to succeed if sufficient elements remain in the queue. Subsequent Dequeue(Many) operations that would block will fail immediately.

 Args
  handle   A Tensor of type mutable string. The handle to a queue.
  cancel_pending_enqueues   An optional bool. Defaults to False. If true, all pending enqueue requests that are blocked on the given queue will be canceled.
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.QueueCloseV2 Closes the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueCloseV2
tf.raw_ops.QueueCloseV2(
    handle, cancel_pending_enqueues=False, name=None
)
 This operation signals that no more elements will be enqueued in the given queue. Subsequent Enqueue(Many) operations will fail. Subsequent Dequeue(Many) operations will continue to succeed if sufficient elements remain in the queue. Subsequent Dequeue(Many) operations that would block will fail immediately.

 Args
  handle   A Tensor of type resource. The handle to a queue.
  cancel_pending_enqueues   An optional bool. Defaults to False. If true, all pending enqueue requests that are blocked on the given queue will be canceled.
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.QueueDequeue Dequeues a tuple of one or more tensors from the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueDequeue
tf.raw_ops.QueueDequeue(
    handle, component_types, timeout_ms=-1, name=None
)
 This operation has k outputs, where k is the number of components in the tuples stored in the given queue, and output i is the ith component of the dequeued tuple. N.B. If the queue is empty, this operation will block until an element has been dequeued (or 'timeout_ms' elapses, if specified).

 Args
  handle   A Tensor of type mutable string. The handle to a queue.
  component_types   A list of tf.DTypes that has length >= 1. The type of each component in a tuple.
  timeout_ms   An optional int. Defaults to -1. If the queue is empty, this operation will block for up to timeout_ms milliseconds. Note: This option is not supported yet.
  name   A name for the operation (optional).

 Returns   A list of Tensor objects of type component_types.


tf.raw_ops.QueueDequeueMany Dequeues n tuples of one or more tensors from the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueDequeueMany
tf.raw_ops.QueueDequeueMany(
    handle, n, component_types, timeout_ms=-1, name=None
)
 If the queue is closed and there are fewer than n elements, then an OutOfRange error is returned. This operation concatenates queue-element component tensors along the 0th dimension to make a single component tensor. All of the components in the dequeued tuple will have size n in the 0th dimension. This operation has k outputs, where k is the number of components in the tuples stored in the given queue, and output i is the ith component of the dequeued tuple. N.B. If the queue is empty, this operation will block until n elements have been dequeued (or 'timeout_ms' elapses, if specified).

 Args
  handle   A Tensor of type mutable string. The handle to a queue.
  n   A Tensor of type int32. The number of tuples to dequeue.
  component_types   A list of tf.DTypes that has length >= 1. The type of each component in a tuple.
  timeout_ms   An optional int. Defaults to -1. If the queue has fewer than n elements, this operation will block for up to timeout_ms milliseconds. Note: This option is not supported yet.
  name   A name for the operation (optional).

 Returns   A list of Tensor objects of type component_types.


tf.raw_ops.QueueDequeueManyV2 Dequeues n tuples of one or more tensors from the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueDequeueManyV2
tf.raw_ops.QueueDequeueManyV2(
    handle, n, component_types, timeout_ms=-1, name=None
)
 If the queue is closed and there are fewer than n elements, then an OutOfRange error is returned. This operation concatenates queue-element component tensors along the 0th dimension to make a single component tensor. All of the components in the dequeued tuple will have size n in the 0th dimension. This operation has k outputs, where k is the number of components in the tuples stored in the given queue, and output i is the ith component of the dequeued tuple. N.B. If the queue is empty, this operation will block until n elements have been dequeued (or 'timeout_ms' elapses, if specified).

 Args
  handle   A Tensor of type resource. The handle to a queue.
  n   A Tensor of type int32. The number of tuples to dequeue.
  component_types   A list of tf.DTypes that has length >= 1. The type of each component in a tuple.
  timeout_ms   An optional int. Defaults to -1. If the queue has fewer than n elements, this operation will block for up to timeout_ms milliseconds. Note: This option is not supported yet.
  name   A name for the operation (optional).

 Returns   A list of Tensor objects of type component_types.


tf.raw_ops.QueueDequeueUpTo Dequeues n tuples of one or more tensors from the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueDequeueUpTo
tf.raw_ops.QueueDequeueUpTo(
    handle, n, component_types, timeout_ms=-1, name=None
)
 This operation is not supported by all queues. If a queue does not support DequeueUpTo, then an Unimplemented error is returned. If the queue is closed and there are more than 0 but less than n elements remaining, then instead of returning an OutOfRange error like QueueDequeueMany, less than n elements are returned immediately. If the queue is closed and there are 0 elements left in the queue, then an OutOfRange error is returned just like in QueueDequeueMany. Otherwise the behavior is identical to QueueDequeueMany: This operation concatenates queue-element component tensors along the 0th dimension to make a single component tensor. All of the components in the dequeued tuple will have size n in the 0th dimension. This operation has k outputs, where k is the number of components in the tuples stored in the given queue, and output i is the ith component of the dequeued tuple.

 Args
  handle   A Tensor of type mutable string. The handle to a queue.
  n   A Tensor of type int32. The number of tuples to dequeue.
  component_types   A list of tf.DTypes that has length >= 1. The type of each component in a tuple.
  timeout_ms   An optional int. Defaults to -1. If the queue has fewer than n elements, this operation will block for up to timeout_ms milliseconds. Note: This option is not supported yet.
  name   A name for the operation (optional).

 Returns   A list of Tensor objects of type component_types.


tf.raw_ops.QueueDequeueUpToV2 Dequeues n tuples of one or more tensors from the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueDequeueUpToV2
tf.raw_ops.QueueDequeueUpToV2(
    handle, n, component_types, timeout_ms=-1, name=None
)
 This operation is not supported by all queues. If a queue does not support DequeueUpTo, then an Unimplemented error is returned. If the queue is closed and there are more than 0 but less than n elements remaining, then instead of returning an OutOfRange error like QueueDequeueMany, less than n elements are returned immediately. If the queue is closed and there are 0 elements left in the queue, then an OutOfRange error is returned just like in QueueDequeueMany. Otherwise the behavior is identical to QueueDequeueMany: This operation concatenates queue-element component tensors along the 0th dimension to make a single component tensor. All of the components in the dequeued tuple will have size n in the 0th dimension. This operation has k outputs, where k is the number of components in the tuples stored in the given queue, and output i is the ith component of the dequeued tuple.

 Args
  handle   A Tensor of type resource. The handle to a queue.
  n   A Tensor of type int32. The number of tuples to dequeue.
  component_types   A list of tf.DTypes that has length >= 1. The type of each component in a tuple.
  timeout_ms   An optional int. Defaults to -1. If the queue has fewer than n elements, this operation will block for up to timeout_ms milliseconds. Note: This option is not supported yet.
  name   A name for the operation (optional).

 Returns   A list of Tensor objects of type component_types.


tf.raw_ops.QueueDequeueV2 Dequeues a tuple of one or more tensors from the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueDequeueV2
tf.raw_ops.QueueDequeueV2(
    handle, component_types, timeout_ms=-1, name=None
)
 This operation has k outputs, where k is the number of components in the tuples stored in the given queue, and output i is the ith component of the dequeued tuple. N.B. If the queue is empty, this operation will block until an element has been dequeued (or 'timeout_ms' elapses, if specified).

 Args
  handle   A Tensor of type resource. The handle to a queue.
  component_types   A list of tf.DTypes that has length >= 1. The type of each component in a tuple.
  timeout_ms   An optional int. Defaults to -1. If the queue is empty, this operation will block for up to timeout_ms milliseconds. Note: This option is not supported yet.
  name   A name for the operation (optional).

 Returns   A list of Tensor objects of type component_types.


tf.raw_ops.QueueEnqueue Enqueues a tuple of one or more tensors in the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueEnqueue
tf.raw_ops.QueueEnqueue(
    handle, components, timeout_ms=-1, name=None
)
 The components input has k elements, which correspond to the components of tuples stored in the given queue. N.B. If the queue is full, this operation will block until the given element has been enqueued (or 'timeout_ms' elapses, if specified).

 Args
  handle   A Tensor of type mutable string. The handle to a queue.
  components   A list of Tensor objects. One or more tensors from which the enqueued tensors should be taken.
  timeout_ms   An optional int. Defaults to -1. If the queue is full, this operation will block for up to timeout_ms milliseconds. Note: This option is not supported yet.
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.QueueEnqueueMany Enqueues zero or more tuples of one or more tensors in the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueEnqueueMany
tf.raw_ops.QueueEnqueueMany(
    handle, components, timeout_ms=-1, name=None
)
 This operation slices each component tensor along the 0th dimension to make multiple queue elements. All of the tuple components must have the same size in the 0th dimension. The components input has k elements, which correspond to the components of tuples stored in the given queue. N.B. If the queue is full, this operation will block until the given elements have been enqueued (or 'timeout_ms' elapses, if specified).

 Args
  handle   A Tensor of type mutable string. The handle to a queue.
  components   A list of Tensor objects. One or more tensors from which the enqueued tensors should be taken.
  timeout_ms   An optional int. Defaults to -1. If the queue is too full, this operation will block for up to timeout_ms milliseconds. Note: This option is not supported yet.
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.QueueEnqueueManyV2 Enqueues zero or more tuples of one or more tensors in the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueEnqueueManyV2
tf.raw_ops.QueueEnqueueManyV2(
    handle, components, timeout_ms=-1, name=None
)
 This operation slices each component tensor along the 0th dimension to make multiple queue elements. All of the tuple components must have the same size in the 0th dimension. The components input has k elements, which correspond to the components of tuples stored in the given queue. N.B. If the queue is full, this operation will block until the given elements have been enqueued (or 'timeout_ms' elapses, if specified).

 Args
  handle   A Tensor of type resource. The handle to a queue.
  components   A list of Tensor objects. One or more tensors from which the enqueued tensors should be taken.
  timeout_ms   An optional int. Defaults to -1. If the queue is too full, this operation will block for up to timeout_ms milliseconds. Note: This option is not supported yet.
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.QueueEnqueueV2 Enqueues a tuple of one or more tensors in the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueEnqueueV2
tf.raw_ops.QueueEnqueueV2(
    handle, components, timeout_ms=-1, name=None
)
 The components input has k elements, which correspond to the components of tuples stored in the given queue. N.B. If the queue is full, this operation will block until the given element has been enqueued (or 'timeout_ms' elapses, if specified).

 Args
  handle   A Tensor of type resource. The handle to a queue.
  components   A list of Tensor objects. One or more tensors from which the enqueued tensors should be taken.
  timeout_ms   An optional int. Defaults to -1. If the queue is full, this operation will block for up to timeout_ms milliseconds. Note: This option is not supported yet.
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.QueueIsClosed Returns true if queue is closed.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueIsClosed
tf.raw_ops.QueueIsClosed(
    handle, name=None
)
 This operation returns true if the queue is closed and false if the queue is open.

 Args
  handle   A Tensor of type mutable string. The handle to a queue.
  name   A name for the operation (optional).

 Returns   A Tensor of type bool.


tf.raw_ops.QueueIsClosedV2 Returns true if queue is closed.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueIsClosedV2
tf.raw_ops.QueueIsClosedV2(
    handle, name=None
)
 This operation returns true if the queue is closed and false if the queue is open.

 Args
  handle   A Tensor of type resource. The handle to a queue.
  name   A name for the operation (optional).

 Returns   A Tensor of type bool.


tf.raw_ops.QueueSize Computes the number of elements in the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueSize
tf.raw_ops.QueueSize(
    handle, name=None
)

 Args
  handle   A Tensor of type mutable string. The handle to a queue.
  name   A name for the operation (optional).

 Returns   A Tensor of type int32.


tf.raw_ops.QueueSizeV2 Computes the number of elements in the given queue.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.QueueSizeV2
tf.raw_ops.QueueSizeV2(
    handle, name=None
)

 Args
  handle   A Tensor of type resource. The handle to a queue.
  name   A name for the operation (optional).

 Returns   A Tensor of type int32.


tf.raw_ops.RaggedBincount Counts the number of occurrences of each value in an integer array.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RaggedBincount
tf.raw_ops.RaggedBincount(
    splits, values, size, weights, binary_output=False, name=None
)
 Outputs a vector with length size and the same dtype as weights. If weights are empty, then index i stores the number of times the value i is counted in arr. If weights are non-empty, then index i stores the sum of the value in weights at each index where the corresponding value in arr is i. Values in arr outside of the range [0, size) are ignored.

 Args
  splits   A Tensor of type int64. 1D int64 Tensor.
  values   A Tensor. Must be one of the following types: int32, int64. 2D int Tensor.
  size   A Tensor. Must have the same type as values. non-negative int scalar Tensor.
  weights   A Tensor. Must be one of the following types: int32, int64, float32, float64. is an int32, int64, float32, or float64 Tensor with the same shape as input, or a length-0 Tensor, in which case it acts as all weights equal to 1.
  binary_output   An optional bool. Defaults to False. bool; Whether the kernel should count the appearance or number of occurrences.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as weights.


tf.raw_ops.RaggedCountSparseOutput Performs sparse-output bin counting for a ragged tensor input.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RaggedCountSparseOutput
tf.raw_ops.RaggedCountSparseOutput(
    splits, values, weights, binary_output, minlength=-1, maxlength=-1, name=None
)
 Counts the number of times each value occurs in the input.

 Args
  splits   A Tensor of type int64. Tensor containing the row splits of the ragged tensor to count.
  values   A Tensor. Must be one of the following types: int32, int64. Tensor containing values of the sparse tensor to count.
  weights   A Tensor. Must be one of the following types: int32, int64, float32, float64. A Tensor of the same shape as indices containing per-index weight values. May also be the empty tensor if no weights are used.
  binary_output   A bool. Whether to output the number of occurrences of each value or 1.
  minlength   An optional int that is >= -1. Defaults to -1. Minimum value to count. Can be set to -1 for no minimum.
  maxlength   An optional int that is >= -1. Defaults to -1. Maximum value to count. Can be set to -1 for no maximum.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output_indices, output_values, output_dense_shape).     output_indices   A Tensor of type int64.
  output_values   A Tensor. Has the same type as weights.
  output_dense_shape   A Tensor of type int64.


tf.raw_ops.RaggedCross Generates a feature cross from a list of tensors, and returns it as a  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RaggedCross
tf.raw_ops.RaggedCross(
    ragged_values, ragged_row_splits, sparse_indices, sparse_values, sparse_shape,
    dense_inputs, input_order, hashed_output, num_buckets, hash_key,
    out_values_type, out_row_splits_type, name=None
)
 RaggedTensor. See tf.ragged.cross for more details. Args: ragged_values: A list of Tensor objects with types from: int64, string. The values tensor for each RaggedTensor input. ragged_row_splits: A list of Tensor objects with types from: int32, int64. The row_splits tensor for each RaggedTensor input. sparse_indices: A list of Tensor objects with type int64. The indices tensor for each SparseTensor input. sparse_values: A list of Tensor objects with types from: int64, string. The values tensor for each SparseTensor input. sparse_shape: A list with the same length as sparse_indices of Tensor objects with type int64. The dense_shape tensor for each SparseTensor input. dense_inputs: A list of Tensor objects with types from: int64, string. The tf.Tensor inputs. input_order: A string. String specifying the tensor type for each input. The ith character in this string specifies the type of the ith input, and is one of: 'R' (ragged), 'D' (dense), or 'S' (sparse). This attr is used to ensure that the crossed values are combined in the order of the inputs from the call to tf.ragged.cross. hashed_output: A bool. num_buckets: An int that is >= 0. hash_key: An int. out_values_type: A tf.DType from: tf.int64, tf.string. out_row_splits_type: A tf.DType from: tf.int32, tf.int64. name: A name for the operation (optional). Returns: A tuple of Tensor objects (output_values, output_row_splits). output_values: A `Tensor` of type `out_values_type`.
output_row_splits: A `Tensor` of type `out_row_splits_type`.


tf.raw_ops.RaggedGather Gather ragged slices from params axis 0 according to indices.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RaggedGather
tf.raw_ops.RaggedGather(
    params_nested_splits, params_dense_values, indices, OUTPUT_RAGGED_RANK,
    name=None
)
 Outputs a RaggedTensor output composed from output_dense_values and output_nested_splits, such that: output.shape = indices.shape + params.shape[1:]
output.ragged_rank = indices.shape.ndims + params.ragged_rank
output[i...j, d0...dn] = params[indices[i...j], d0...dn]
 where
params = ragged.from_nested_row_splits(params_dense_values, params_nested_splits) provides the values that should be gathered.
indices ia a dense tensor with dtype int32 or int64, indicating which values should be gathered.
output = ragged.from_nested_row_splits(output_dense_values, output_nested_splits) is the output tensor.  (Note: This c++ op is used to implement the higher-level python tf.ragged.gather op, which also supports ragged indices.)

 Args
  params_nested_splits   A list of at least 1 Tensor objects with the same type in: int32, int64. The nested_row_splits tensors that define the row-partitioning for the params RaggedTensor input.
  params_dense_values   A Tensor. The flat_values for the params RaggedTensor. There was a terminology change at the python level from dense_values to flat_values, so dense_values is the deprecated name.
  indices   A Tensor. Must be one of the following types: int32, int64. Indices in the outermost dimension of params of the values that should be gathered.
  OUTPUT_RAGGED_RANK   An int that is >= 0. The ragged rank of the output RaggedTensor. output_nested_splits will contain this number of row_splits tensors. This value should equal indices.shape.ndims + params.ragged_rank - 1.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output_nested_splits, output_dense_values).     output_nested_splits   A list of OUTPUT_RAGGED_RANK Tensor objects with the same type as params_nested_splits.
  output_dense_values   A Tensor. Has the same type as params_dense_values.


tf.raw_ops.RaggedRange Returns a RaggedTensor containing the specified sequences of numbers.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RaggedRange
tf.raw_ops.RaggedRange(
    starts, limits, deltas, Tsplits=tf.dtypes.int64, name=None
)
 Returns a RaggedTensor result composed from rt_dense_values and rt_nested_splits, such that result[i] = range(starts[i], limits[i], deltas[i]). (rt_nested_splits, rt_dense_values) = ragged_range(
      starts=[2, 5, 8], limits=[3, 5, 12], deltas=1)
result = tf.ragged.from_row_splits(rt_dense_values, rt_nested_splits)
print(result)
<tf.RaggedTensor [[2], [], [8, 9, 10, 11]] >
 The input tensors starts, limits, and deltas may be scalars or vectors. The vector inputs must all have the same size. Scalar inputs are broadcast to match the size of the vector inputs.

 Args
  starts   A Tensor. Must be one of the following types: bfloat16, float32, float64, int32, int64. The starts of each range.
  limits   A Tensor. Must have the same type as starts. The limits of each range.
  deltas   A Tensor. Must have the same type as starts. The deltas of each range.
  Tsplits   An optional tf.DType from: tf.int32, tf.int64. Defaults to tf.int64.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (rt_nested_splits, rt_dense_values).     rt_nested_splits   A Tensor of type Tsplits.
  rt_dense_values   A Tensor. Has the same type as starts.


tf.raw_ops.RaggedTensorFromVariant Decodes a variant Tensor into a RaggedTensor.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RaggedTensorFromVariant
tf.raw_ops.RaggedTensorFromVariant(
    encoded_ragged, input_ragged_rank, output_ragged_rank, Tvalues,
    Tsplits=tf.dtypes.int64, name=None
)
 Decodes the given variant Tensor and returns a RaggedTensor. The input could be a scalar, meaning it encodes a single RaggedTensor with ragged_rank output_ragged_rank. It could also have an arbitrary rank, in which case each element is decoded into a RaggedTensor with ragged_rank input_ragged_rank and these are then stacked according to the input shape to output a single RaggedTensor with ragged_rank output_ragged_rank. Each variant element in the input Tensor is decoded by retrieving from the element a 1-D variant Tensor with input_ragged_rank + 1 Tensors, corresponding to the splits and values of the decoded RaggedTensor. If input_ragged_rank is -1, then it is inferred as output_ragged_rank - rank(encoded_ragged). See RaggedTensorToVariant for the corresponding encoding logic.

 Args
  encoded_ragged   A Tensor of type variant. A variant Tensor containing encoded RaggedTensors.
  input_ragged_rank   An int that is >= -1. The ragged rank of each encoded RaggedTensor component in the input. If set to -1, this is inferred as output_ragged_rank - rank(encoded_ragged)
  output_ragged_rank   An int that is >= 0. The expected ragged rank of the output RaggedTensor. The following must hold: output_ragged_rank = rank(encoded_ragged) + input_ragged_rank.
  Tvalues   A tf.DType.
  Tsplits   An optional tf.DType from: tf.int32, tf.int64. Defaults to tf.int64.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (output_nested_splits, output_dense_values).     output_nested_splits   A list of output_ragged_rank Tensor objects with type Tsplits.
  output_dense_values   A Tensor of type Tvalues.


tf.raw_ops.RaggedTensorToSparse Converts a RaggedTensor into a SparseTensor with the same values.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RaggedTensorToSparse
tf.raw_ops.RaggedTensorToSparse(
    rt_nested_splits, rt_dense_values, name=None
)
 input=ragged.from_nested_row_splits(rt_dense_values, rt_nested_splits) output=SparseTensor(indices=sparse_indices, values=sparse_values, dense_shape=sparse_dense_shape)

 Args
  rt_nested_splits   A list of at least 1 Tensor objects with the same type in: int32, int64. The row_splits for the RaggedTensor.
  rt_dense_values   A Tensor. The flat_values for the RaggedTensor.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (sparse_indices, sparse_values, sparse_dense_shape).     sparse_indices   A Tensor of type int64.
  sparse_values   A Tensor. Has the same type as rt_dense_values.
  sparse_dense_shape   A Tensor of type int64.


tf.raw_ops.RaggedTensorToTensor Create a dense tensor from a ragged tensor, possibly altering its shape.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RaggedTensorToTensor
tf.raw_ops.RaggedTensorToTensor(
    shape, values, default_value, row_partition_tensors, row_partition_types,
    name=None
)
 The ragged_to_dense op creates a dense tensor from a list of row partition tensors, a value vector, and default values. If the shape is unspecified, the minimal shape required to contain all the elements in the ragged tensor (the natural shape) will be used. If some dimensions are left unspecified, then the size of the natural shape is used in that dimension. The default_value will be broadcast to the output shape. After that, the values from the ragged tensor overwrite the default values. Note that the default_value must have less dimensions than the value. The row partition tensors are in the order of the dimensions. At present, the types can be:  "ROW_SPLITS": the row_splits tensor from the ragged tensor. "VALUE_ROWIDS": the value_rowids tensor from the ragged tensor. "FIRST_DIM_SIZE": if value_rowids is used for the first dimension, then it is preceded by "FIRST_DIM_SIZE".

 Args
  shape   A Tensor. Must be one of the following types: int64, int32. The desired shape of the the output tensor. If left unspecified (empty), the minimal shape required to contain all the elements in the ragged tensor (the natural shape) will be used. If some dimensions are left unspecified, then the size of the natural shape is used in that dimension. Note that dense dimensions cannot be modified by the shape argument. Trying to change the size of a dense dimension will cause the op to fail. Examples: natural shape: [4, 5, 6] shape: -1 output shape: [4, 5, 6] natural shape: [4, 5, 6] shape: [3, -1, 2] output shape: [3, 5, 2] natural shape: [4, 5, 6] shape: [3, 7, 2] output shape: [3, 7, 2]

  values   A Tensor. A 1D tensor representing the values of the ragged tensor.
  default_value   A Tensor. Must have the same type as values. The default_value when the shape is larger than the ragged tensor. The default_value is broadcast until it is the shape of the output tensor, and then overwritten by values in the ragged tensor. The default value must be compatible with this broadcast operation, and must have fewer dimensions than the value tensor.
  row_partition_tensors   A list of at least 1 Tensor objects with the same type in: int64, int32.
  row_partition_types   A list of strings. The types of the row partition tensors. At present, these can be:  "ROW_SPLITS": the row_splits tensor from the ragged tensor. "VALUE_ROWIDS": the value_rowids tensor from the ragged tensor. "FIRST_DIM_SIZE": if value_rowids is used for the first dimension, then it is preceeded by "FIRST_DIM_SIZE". The tensors are in the order of the dimensions.

  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as values.


tf.raw_ops.RaggedTensorToVariant Encodes a RaggedTensor into a variant Tensor.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RaggedTensorToVariant
tf.raw_ops.RaggedTensorToVariant(
    rt_nested_splits, rt_dense_values, batched_input, name=None
)
 Encodes the given RaggedTensor and returns a variant Tensor. If batched_input is True, then input RaggedTensor is unbatched along the zero-th dimension, each component RaggedTensor is encoded into a scalar variant Tensor, and these are stacked to return a 1-D variant Tensor. If batched_input is False, then the input RaggedTensor is encoded as is and a scalar variant Tensor is returned. A RaggedTensor is encoded by first creating a 1-D variant Tensor with ragged_rank + 1 elements, containing the splits and values Tensors of the RaggedTensor. Then the 1-D variant Tensor is wrapped in a scalar variant Tensor. See RaggedTensorFromVariant for the corresponding decoding logic.

 Args
  rt_nested_splits   A list of Tensor objects with the same type in: int32, int64. A list of one or more Tensors representing the splits of the input RaggedTensor.
  rt_dense_values   A Tensor. A Tensor representing the values of the input RaggedTensor.
  batched_input   A bool. A bool denoting whether the input is a batched RaggedTensor.
  name   A name for the operation (optional).

 Returns   A Tensor of type variant.


tf.raw_ops.RaggedTensorToVariantGradient Helper used to compute the gradient for RaggedTensorToVariant.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RaggedTensorToVariantGradient
tf.raw_ops.RaggedTensorToVariantGradient(
    encoded_ragged_grad, row_splits, dense_values_shape, Tvalues, name=None
)
 Computes the gradient for the dense_values input to the RaggedTensorToVariant op, given the variant-encoded ragged gradients of the outputs, along with the outer row-splits and the shape of the dense-values that were provided as inputs to the RaggedTensorToVariant op.

 Args
  encoded_ragged_grad   A Tensor of type variant. A variant Tensor containing encoded RaggedTensor gradients.
  row_splits   A Tensor. Must be one of the following types: int32, int64. Outermost row-splits that were used as input to the RaggedTensorToVariant op.
  dense_values_shape   A Tensor of type int32. Shape of the dense_values that was used as an input to the RaggedTensorToVariant op.
  Tvalues   A tf.DType.
  name   A name for the operation (optional).

 Returns   A Tensor of type Tvalues.


tf.raw_ops.RandomCrop Randomly crop image.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RandomCrop
tf.raw_ops.RandomCrop(
    image, size, seed=0, seed2=0, name=None
)
 size is a 1-D int64 tensor with 2 elements representing the crop height and width. The values must be non negative. This Op picks a random location in image and crops a height by width rectangle from that location. The random location is picked so the cropped area will fit inside the original image.

 Args
  image   A Tensor. Must be one of the following types: uint8, int8, int16, int32, int64, float32, float64. 3-D of shape [height, width, channels].
  size   A Tensor of type int64. 1-D of length 2 containing: crop_height, crop_width..
  seed   An optional int. Defaults to 0. If either seed or seed2 are set to be non-zero, the random number generator is seeded by the given seed. Otherwise, it is seeded by a random seed.
  seed2   An optional int. Defaults to 0. An second seed to avoid seed collision.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as image.


tf.raw_ops.RandomDataset Creates a Dataset that returns pseudorandom numbers.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RandomDataset
tf.raw_ops.RandomDataset(
    seed, seed2, output_types, output_shapes, name=None
)
 Creates a Dataset that returns a stream of uniformly distributed pseudorandom 64-bit signed integers. In the TensorFlow Python API, you can instantiate this dataset via the class tf.data.experimental.RandomDataset. Instances of this dataset are also created as a result of the hoist_random_uniform static optimization. Whether this optimization is performed is determined by the experimental_optimization.hoist_random_uniform option of tf.data.Options.

 Args
  seed   A Tensor of type int64. A scalar seed for the random number generator. If either seed or seed2 is set to be non-zero, the random number generator is seeded by the given seed. Otherwise, a random seed is used.
  seed2   A Tensor of type int64. A second scalar seed to avoid seed collision.
  output_types   A list of tf.DTypes that has length >= 1.
  output_shapes   A list of shapes (each a tf.TensorShape or list of ints) that has length >= 1.
  name   A name for the operation (optional).

 Returns   A Tensor of type variant.


tf.raw_ops.RandomGamma Outputs random values from the Gamma distribution(s) described by alpha.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RandomGamma
tf.raw_ops.RandomGamma(
    shape, alpha, seed=0, seed2=0, name=None
)
 This op uses the algorithm by Marsaglia et al. to acquire samples via transformation-rejection from pairs of uniform and normal random variables. See http://dl.acm.org/citation.cfm?id=358414

 Args
  shape   A Tensor. Must be one of the following types: int32, int64. 1-D integer tensor. Shape of independent samples to draw from each distribution described by the shape parameters given in alpha.
  alpha   A Tensor. Must be one of the following types: half, float32, float64. A tensor in which each scalar is a "shape" parameter describing the associated gamma distribution.
  seed   An optional int. Defaults to 0. If either seed or seed2 are set to be non-zero, the random number generator is seeded by the given seed. Otherwise, it is seeded by a random seed.
  seed2   An optional int. Defaults to 0. A second seed to avoid seed collision.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as alpha.


tf.raw_ops.RandomGammaGrad Computes the derivative of a Gamma random sample w.r.t. alpha.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RandomGammaGrad
tf.raw_ops.RandomGammaGrad(
    alpha, sample, name=None
)

 Args
  alpha   A Tensor. Must be one of the following types: float32, float64.
  sample   A Tensor. Must have the same type as alpha.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as alpha.


tf.raw_ops.RandomPoisson Use RandomPoissonV2 instead.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RandomPoisson
tf.raw_ops.RandomPoisson(
    shape, rate, seed=0, seed2=0, name=None
)

 Args
  shape   A Tensor. Must be one of the following types: int32, int64.
  rate   A Tensor. Must be one of the following types: half, float32, float64.
  seed   An optional int. Defaults to 0.
  seed2   An optional int. Defaults to 0.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as rate.


tf.raw_ops.RandomPoissonV2 Outputs random values from the Poisson distribution(s) described by rate.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RandomPoissonV2
tf.raw_ops.RandomPoissonV2(
    shape, rate, seed=0, seed2=0, dtype=tf.dtypes.int64, name=None
)
 This op uses two algorithms, depending on rate. If rate >= 10, then the algorithm by Hormann is used to acquire samples via transformation-rejection. See http://www.sciencedirect.com/science/article/pii/0167668793909974 Otherwise, Knuth's algorithm is used to acquire samples via multiplying uniform random variables. See Donald E. Knuth (1969). Seminumerical Algorithms. The Art of Computer Programming, Volume 2. Addison Wesley

 Args
  shape   A Tensor. Must be one of the following types: int32, int64. 1-D integer tensor. Shape of independent samples to draw from each distribution described by the shape parameters given in rate.
  rate   A Tensor. Must be one of the following types: half, float32, float64, int32, int64. A tensor in which each scalar is a "rate" parameter describing the associated poisson distribution.
  seed   An optional int. Defaults to 0. If either seed or seed2 are set to be non-zero, the random number generator is seeded by the given seed. Otherwise, it is seeded by a random seed.
  seed2   An optional int. Defaults to 0. A second seed to avoid seed collision.
  dtype   An optional tf.DType from: tf.half, tf.float32, tf.float64, tf.int32, tf.int64. Defaults to tf.int64.
  name   A name for the operation (optional).

 Returns   A Tensor of type dtype.


tf.raw_ops.RandomShuffle Randomly shuffles a tensor along its first dimension.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RandomShuffle
tf.raw_ops.RandomShuffle(
    value, seed=0, seed2=0, name=None
)
 The tensor is shuffled along dimension 0, such that each value[j] is mapped to one and only one output[i]. For example, a mapping that might occur for a 3x2 tensor is: [[1, 2],       [[5, 6],
 [3, 4],  ==>   [1, 2],
 [5, 6]]        [3, 4]]

 Args
  value   A Tensor. The tensor to be shuffled.
  seed   An optional int. Defaults to 0. If either seed or seed2 are set to be non-zero, the random number generator is seeded by the given seed. Otherwise, it is seeded by a random seed.
  seed2   An optional int. Defaults to 0. A second seed to avoid seed collision.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as value.


tf.raw_ops.RandomShuffleQueue A queue that randomizes the order of elements.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RandomShuffleQueue
tf.raw_ops.RandomShuffleQueue(
    component_types, shapes=[], capacity=-1, min_after_dequeue=0, seed=0, seed2=0,
    container='', shared_name='', name=None
)

 Args
  component_types   A list of tf.DTypes that has length >= 1. The type of each component in a value.
  shapes   An optional list of shapes (each a tf.TensorShape or list of ints). Defaults to []. The shape of each component in a value. The length of this attr must be either 0 or the same as the length of component_types. If the length of this attr is 0, the shapes of queue elements are not constrained, and only one element may be dequeued at a time.
  capacity   An optional int. Defaults to -1. The upper bound on the number of elements in this queue. Negative numbers mean no limit.
  min_after_dequeue   An optional int. Defaults to 0. Dequeue will block unless there would be this many elements after the dequeue or the queue is closed. This ensures a minimum level of mixing of elements.
  seed   An optional int. Defaults to 0. If either seed or seed2 is set to be non-zero, the random number generator is seeded by the given seed. Otherwise, a random seed is used.
  seed2   An optional int. Defaults to 0. A second seed to avoid seed collision.
  container   An optional string. Defaults to "". If non-empty, this queue is placed in the given container. Otherwise, a default container is used.
  shared_name   An optional string. Defaults to "". If non-empty, this queue will be shared under the given name across multiple sessions.
  name   A name for the operation (optional).

 Returns   A Tensor of type mutable string.


tf.raw_ops.RandomShuffleQueueV2 A queue that randomizes the order of elements.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RandomShuffleQueueV2
tf.raw_ops.RandomShuffleQueueV2(
    component_types, shapes=[], capacity=-1, min_after_dequeue=0, seed=0, seed2=0,
    container='', shared_name='', name=None
)

 Args
  component_types   A list of tf.DTypes that has length >= 1. The type of each component in a value.
  shapes   An optional list of shapes (each a tf.TensorShape or list of ints). Defaults to []. The shape of each component in a value. The length of this attr must be either 0 or the same as the length of component_types. If the length of this attr is 0, the shapes of queue elements are not constrained, and only one element may be dequeued at a time.
  capacity   An optional int. Defaults to -1. The upper bound on the number of elements in this queue. Negative numbers mean no limit.
  min_after_dequeue   An optional int. Defaults to 0. Dequeue will block unless there would be this many elements after the dequeue or the queue is closed. This ensures a minimum level of mixing of elements.
  seed   An optional int. Defaults to 0. If either seed or seed2 is set to be non-zero, the random number generator is seeded by the given seed. Otherwise, a random seed is used.
  seed2   An optional int. Defaults to 0. A second seed to avoid seed collision.
  container   An optional string. Defaults to "". If non-empty, this queue is placed in the given container. Otherwise, a default container is used.
  shared_name   An optional string. Defaults to "". If non-empty, this queue will be shared under the given name across multiple sessions.
  name   A name for the operation (optional).

 Returns   A Tensor of type resource.


tf.raw_ops.RandomStandardNormal Outputs random values from a normal distribution.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RandomStandardNormal
tf.raw_ops.RandomStandardNormal(
    shape, dtype, seed=0, seed2=0, name=None
)
 The generated values will have mean 0 and standard deviation 1.

 Args
  shape   A Tensor. Must be one of the following types: int32, int64. The shape of the output tensor.
  dtype   A tf.DType from: tf.half, tf.bfloat16, tf.float32, tf.float64. The type of the output.
  seed   An optional int. Defaults to 0. If either seed or seed2 are set to be non-zero, the random number generator is seeded by the given seed. Otherwise, it is seeded by a random seed.
  seed2   An optional int. Defaults to 0. A second seed to avoid seed collision.
  name   A name for the operation (optional).

 Returns   A Tensor of type dtype.


tf.raw_ops.RandomUniform Outputs random values from a uniform distribution.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RandomUniform
tf.raw_ops.RandomUniform(
    shape, dtype, seed=0, seed2=0, name=None
)
 The generated values follow a uniform distribution in the range [0, 1). The lower bound 0 is included in the range, while the upper bound 1 is excluded.

 Args
  shape   A Tensor. Must be one of the following types: int32, int64. The shape of the output tensor.
  dtype   A tf.DType from: tf.half, tf.bfloat16, tf.float32, tf.float64. The type of the output.
  seed   An optional int. Defaults to 0. If either seed or seed2 are set to be non-zero, the random number generator is seeded by the given seed. Otherwise, it is seeded by a random seed.
  seed2   An optional int. Defaults to 0. A second seed to avoid seed collision.
  name   A name for the operation (optional).

 Returns   A Tensor of type dtype.


tf.raw_ops.RandomUniformInt Outputs random integers from a uniform distribution.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RandomUniformInt
tf.raw_ops.RandomUniformInt(
    shape, minval, maxval, seed=0, seed2=0, name=None
)
 The generated values are uniform integers in the range [minval, maxval). The lower bound minval is included in the range, while the upper bound maxval is excluded. The random integers are slightly biased unless maxval - minval is an exact power of two. The bias is small for values of maxval - minval significantly smaller than the range of the output (either 2^32 or 2^64).

 Args
  shape   A Tensor. Must be one of the following types: int32, int64. The shape of the output tensor.
  minval   A Tensor. Must be one of the following types: int32, int64. 0-D. Inclusive lower bound on the generated integers.
  maxval   A Tensor. Must have the same type as minval. 0-D. Exclusive upper bound on the generated integers.
  seed   An optional int. Defaults to 0. If either seed or seed2 are set to be non-zero, the random number generator is seeded by the given seed. Otherwise, it is seeded by a random seed.
  seed2   An optional int. Defaults to 0. A second seed to avoid seed collision.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as minval.


tf.raw_ops.Range Creates a sequence of numbers.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.Range
tf.raw_ops.Range(
    start, limit, delta, name=None
)
 This operation creates a sequence of numbers that begins at start and extends by increments of delta up to but not including limit. For example: # 'start' is 3
# 'limit' is 18
# 'delta' is 3
tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15]

 Args
  start   A Tensor. Must be one of the following types: bfloat16, half, float32, float64, int32, int64. 0-D (scalar). First entry in the sequence.
  limit   A Tensor. Must have the same type as start. 0-D (scalar). Upper limit of sequence, exclusive.
  delta   A Tensor. Must have the same type as start. 0-D (scalar). Optional. Default is 1. Number that increments start.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as start.


tf.raw_ops.RangeDataset Creates a dataset with a range of values. Corresponds to python's xrange.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.RangeDataset
tf.raw_ops.RangeDataset(
    start, stop, step, output_types, output_shapes, name=None
)

 Args
  start   A Tensor of type int64. corresponds to start in python's xrange().
  stop   A Tensor of type int64. corresponds to stop in python's xrange().
  step   A Tensor of type int64. corresponds to step in python's xrange().
  output_types   A list of tf.DTypes that has length >= 1.
  output_shapes   A list of shapes (each a tf.TensorShape or list of ints) that has length >= 1.
  name   A name for the operation (optional).

 Returns   A Tensor of type variant.


tf.raw_ops.Rank Returns the rank of a tensor.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.Rank
tf.raw_ops.Rank(
    input, name=None
)
 This operation returns an integer representing the rank of input. For example: # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
# shape of tensor 't' is [2, 2, 3]
rank(t) ==> 3

Note: The rank of a tensor is not the same as the rank of a matrix. The rank of a tensor is the number of indices required to uniquely select each element of the tensor. Rank is also known as "order", "degree", or "ndims."

 Args
  input   A Tensor.
  name   A name for the operation (optional).

 Returns   A Tensor of type int32.


tf.raw_ops.ReaderNumRecordsProduced Returns the number of records this Reader has produced.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.ReaderNumRecordsProduced
tf.raw_ops.ReaderNumRecordsProduced(
    reader_handle, name=None
)
 This is the same as the number of ReaderRead executions that have succeeded.

 Args
  reader_handle   A Tensor of type mutable string. Handle to a Reader.
  name   A name for the operation (optional).

 Returns   A Tensor of type int64.


tf.raw_ops.ReaderNumRecordsProducedV2 Returns the number of records this Reader has produced.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.ReaderNumRecordsProducedV2
tf.raw_ops.ReaderNumRecordsProducedV2(
    reader_handle, name=None
)
 This is the same as the number of ReaderRead executions that have succeeded.

 Args
  reader_handle   A Tensor of type resource. Handle to a Reader.
  name   A name for the operation (optional).

 Returns   A Tensor of type int64.


tf.raw_ops.ReaderNumWorkUnitsCompleted Returns the number of work units this Reader has finished processing.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.ReaderNumWorkUnitsCompleted
tf.raw_ops.ReaderNumWorkUnitsCompleted(
    reader_handle, name=None
)

 Args
  reader_handle   A Tensor of type mutable string. Handle to a Reader.
  name   A name for the operation (optional).

 Returns   A Tensor of type int64.


tf.raw_ops.ReaderNumWorkUnitsCompletedV2 Returns the number of work units this Reader has finished processing.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.ReaderNumWorkUnitsCompletedV2
tf.raw_ops.ReaderNumWorkUnitsCompletedV2(
    reader_handle, name=None
)

 Args
  reader_handle   A Tensor of type resource. Handle to a Reader.
  name   A name for the operation (optional).

 Returns   A Tensor of type int64.


tf.raw_ops.ReaderRead Returns the next record (key, value pair) produced by a Reader.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.ReaderRead
tf.raw_ops.ReaderRead(
    reader_handle, queue_handle, name=None
)
 Will dequeue from the input queue if necessary (e.g. when the Reader needs to start reading from a new file since it has finished with the previous file).

 Args
  reader_handle   A Tensor of type mutable string. Handle to a Reader.
  queue_handle   A Tensor of type mutable string. Handle to a Queue, with string work items.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (key, value).     key   A Tensor of type string.
  value   A Tensor of type string.