12138 lines
580 KiB
Python
12138 lines
580 KiB
Python
"""Python wrappers around TensorFlow ops.
|
|
|
|
This file is MACHINE GENERATED! Do not edit.
|
|
"""
|
|
|
|
import collections
|
|
|
|
from tensorflow.python import pywrap_tfe as pywrap_tfe
|
|
from tensorflow.python.eager import context as _context
|
|
from tensorflow.python.eager import core as _core
|
|
from tensorflow.python.eager import execute as _execute
|
|
from tensorflow.python.framework import dtypes as _dtypes
|
|
|
|
from tensorflow.python.framework import op_def_registry as _op_def_registry
|
|
from tensorflow.python.framework import ops as _ops
|
|
from tensorflow.python.framework import op_def_library as _op_def_library
|
|
from tensorflow.python.util.deprecation import deprecated_endpoints
|
|
from tensorflow.python.util import dispatch as _dispatch
|
|
from tensorflow.python.util.tf_export import tf_export
|
|
|
|
from typing import TypeVar
|
|
_ApproxTopKOutput = collections.namedtuple(
|
|
"ApproxTopK",
|
|
["values", "indices"])
|
|
|
|
|
|
@_dispatch.add_fallback_dispatch_list
|
|
@_dispatch.add_type_based_api_dispatcher
|
|
@tf_export('approx_top_k')
|
|
def approx_top_k(input, k, reduction_dimension=-1, recall_target=0.95, is_max_k=True, reduction_input_size_override=-1, aggregate_to_topk=True, name=None):
|
|
r"""Returns min/max k values and their indices of the input operand in an approximate manner.
|
|
|
|
See https://arxiv.org/abs/2206.14286 for the algorithm details.
|
|
|
|
This op is only optimized on TPU currently.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`.
|
|
Array to search. Must be at least 1-D of the floating type
|
|
k: An `int` that is `>= 0`. Specifies the number of min/max-k.
|
|
reduction_dimension: An optional `int`. Defaults to `-1`.
|
|
Integer dimension along which to search. Default: -1.
|
|
recall_target: An optional `float`. Defaults to `0.95`.
|
|
Recall target for the approximation. Range in (0,1]
|
|
is_max_k: An optional `bool`. Defaults to `True`.
|
|
When true, computes max-k; otherwise computes min-k.
|
|
reduction_input_size_override: An optional `int`. Defaults to `-1`.
|
|
When set to a positive value, it overrides the size determined by
|
|
|
|
`input[reduction_dim]` for evaluating the recall. This option is useful when
|
|
|
|
the given `input` is only a subset of the overall computation in SPMD or
|
|
|
|
distributed pipelines, where the true input size cannot be deferred by the
|
|
|
|
`input` shape.
|
|
aggregate_to_topk: An optional `bool`. Defaults to `True`.
|
|
When true, aggregates approximate results to top-k. When false, returns the
|
|
|
|
approximate results. The number of the approximate results is implementation
|
|
|
|
defined and is greater equals to the specified `k`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (values, indices).
|
|
|
|
values: A `Tensor`. Has the same type as `input`.
|
|
indices: A `Tensor` of type `int32`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "ApproxTopK", name, input, "k", k, "reduction_dimension",
|
|
reduction_dimension, "recall_target", recall_target, "is_max_k",
|
|
is_max_k, "reduction_input_size_override",
|
|
reduction_input_size_override, "aggregate_to_topk", aggregate_to_topk)
|
|
_result = _ApproxTopKOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
_result = _dispatcher_for_approx_top_k(
|
|
(input, k, reduction_dimension, recall_target, is_max_k,
|
|
reduction_input_size_override, aggregate_to_topk, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
return approx_top_k_eager_fallback(
|
|
input, k=k, reduction_dimension=reduction_dimension,
|
|
recall_target=recall_target, is_max_k=is_max_k,
|
|
reduction_input_size_override=reduction_input_size_override,
|
|
aggregate_to_topk=aggregate_to_topk, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
approx_top_k, (), dict(input=input, k=k,
|
|
reduction_dimension=reduction_dimension,
|
|
recall_target=recall_target,
|
|
is_max_k=is_max_k,
|
|
reduction_input_size_override=reduction_input_size_override,
|
|
aggregate_to_topk=aggregate_to_topk,
|
|
name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
else:
|
|
_result = _dispatcher_for_approx_top_k(
|
|
(input, k, reduction_dimension, recall_target, is_max_k,
|
|
reduction_input_size_override, aggregate_to_topk, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
# Add nodes to the TensorFlow graph.
|
|
k = _execute.make_int(k, "k")
|
|
if reduction_dimension is None:
|
|
reduction_dimension = -1
|
|
reduction_dimension = _execute.make_int(reduction_dimension, "reduction_dimension")
|
|
if recall_target is None:
|
|
recall_target = 0.95
|
|
recall_target = _execute.make_float(recall_target, "recall_target")
|
|
if is_max_k is None:
|
|
is_max_k = True
|
|
is_max_k = _execute.make_bool(is_max_k, "is_max_k")
|
|
if reduction_input_size_override is None:
|
|
reduction_input_size_override = -1
|
|
reduction_input_size_override = _execute.make_int(reduction_input_size_override, "reduction_input_size_override")
|
|
if aggregate_to_topk is None:
|
|
aggregate_to_topk = True
|
|
aggregate_to_topk = _execute.make_bool(aggregate_to_topk, "aggregate_to_topk")
|
|
try:
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"ApproxTopK", input=input, k=k,
|
|
reduction_dimension=reduction_dimension,
|
|
recall_target=recall_target, is_max_k=is_max_k,
|
|
reduction_input_size_override=reduction_input_size_override,
|
|
aggregate_to_topk=aggregate_to_topk, name=name)
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
approx_top_k, (), dict(input=input, k=k,
|
|
reduction_dimension=reduction_dimension,
|
|
recall_target=recall_target,
|
|
is_max_k=is_max_k,
|
|
reduction_input_size_override=reduction_input_size_override,
|
|
aggregate_to_topk=aggregate_to_topk,
|
|
name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("k", _op._get_attr_int("k"), "reduction_dimension",
|
|
_op._get_attr_int("reduction_dimension"), "recall_target",
|
|
_op.get_attr("recall_target"), "is_max_k",
|
|
_op._get_attr_bool("is_max_k"), "reduction_input_size_override",
|
|
_op._get_attr_int("reduction_input_size_override"),
|
|
"aggregate_to_topk", _op._get_attr_bool("aggregate_to_topk"),
|
|
"T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"ApproxTopK", _inputs_flat, _attrs, _result)
|
|
_result = _ApproxTopKOutput._make(_result)
|
|
return _result
|
|
|
|
ApproxTopK = tf_export("raw_ops.ApproxTopK")(_ops.to_raw_op(approx_top_k))
|
|
_dispatcher_for_approx_top_k = approx_top_k._tf_type_based_dispatcher.Dispatch
|
|
|
|
|
|
def approx_top_k_eager_fallback(input, k, reduction_dimension, recall_target, is_max_k, reduction_input_size_override, aggregate_to_topk, name, ctx):
|
|
k = _execute.make_int(k, "k")
|
|
if reduction_dimension is None:
|
|
reduction_dimension = -1
|
|
reduction_dimension = _execute.make_int(reduction_dimension, "reduction_dimension")
|
|
if recall_target is None:
|
|
recall_target = 0.95
|
|
recall_target = _execute.make_float(recall_target, "recall_target")
|
|
if is_max_k is None:
|
|
is_max_k = True
|
|
is_max_k = _execute.make_bool(is_max_k, "is_max_k")
|
|
if reduction_input_size_override is None:
|
|
reduction_input_size_override = -1
|
|
reduction_input_size_override = _execute.make_int(reduction_input_size_override, "reduction_input_size_override")
|
|
if aggregate_to_topk is None:
|
|
aggregate_to_topk = True
|
|
aggregate_to_topk = _execute.make_bool(aggregate_to_topk, "aggregate_to_topk")
|
|
_attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, ])
|
|
_inputs_flat = [input]
|
|
_attrs = ("k", k, "reduction_dimension", reduction_dimension,
|
|
"recall_target", recall_target, "is_max_k", is_max_k,
|
|
"reduction_input_size_override", reduction_input_size_override,
|
|
"aggregate_to_topk", aggregate_to_topk, "T", _attr_T)
|
|
_result = _execute.execute(b"ApproxTopK", 2, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"ApproxTopK", _inputs_flat, _attrs, _result)
|
|
_result = _ApproxTopKOutput._make(_result)
|
|
return _result
|
|
|
|
|
|
def avg_pool(value, ksize, strides, padding, data_format="NHWC", name=None):
|
|
r"""Performs average pooling on the input.
|
|
|
|
Each entry in `output` is the mean of the corresponding size `ksize`
|
|
|
|
window in `value`.
|
|
|
|
Args:
|
|
value: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
4-D with shape `[batch, height, width, channels]`.
|
|
ksize: A list of `ints` that has length `>= 4`.
|
|
The size of the sliding window for each dimension of `value`.
|
|
strides: A list of `ints` that has length `>= 4`.
|
|
The stride of the sliding window for each dimension of `value`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `value`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "AvgPool", name, value, "ksize", ksize, "strides", strides,
|
|
"padding", padding, "data_format", data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return avg_pool_eager_fallback(
|
|
value, ksize=ksize, strides=strides, padding=padding,
|
|
data_format=data_format, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'avg_pool' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'avg_pool' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"AvgPool", value=value, ksize=ksize, strides=strides, padding=padding,
|
|
data_format=data_format, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("ksize", _op.get_attr("ksize"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"data_format", _op.get_attr("data_format"), "T",
|
|
_op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"AvgPool", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
AvgPool = tf_export("raw_ops.AvgPool")(_ops.to_raw_op(avg_pool))
|
|
|
|
|
|
def avg_pool_eager_fallback(value, ksize, strides, padding, data_format, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'avg_pool' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'avg_pool' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, (value,) = _execute.args_to_matching_eager([value], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
_inputs_flat = [value]
|
|
_attrs = ("ksize", ksize, "strides", strides, "padding", padding,
|
|
"data_format", data_format, "T", _attr_T)
|
|
_result = _execute.execute(b"AvgPool", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"AvgPool", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def avg_pool3d(input, ksize, strides, padding, data_format="NDHWC", name=None):
|
|
r"""Performs 3D average pooling on the input.
|
|
|
|
Each entry in `output` is the mean of the corresponding size `ksize` window in
|
|
|
|
`value`.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
Shape `[batch, depth, rows, cols, channels]` tensor to pool over.
|
|
ksize: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The size of the window for each dimension of
|
|
|
|
the input tensor. Must have `ksize[0] = ksize[4] = 1`.
|
|
strides: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The stride of the sliding window for each
|
|
|
|
dimension of `input`. Must have `strides[0] = strides[4] = 1`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`.
|
|
The data format of the input and output data. With the
|
|
|
|
default format "NDHWC", the data is stored in the order of:
|
|
|
|
[batch, in_depth, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCDHW", the data storage order is:
|
|
|
|
[batch, in_channels, in_depth, in_height, in_width].
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "AvgPool3D", name, input, "ksize", ksize, "strides", strides,
|
|
"padding", padding, "data_format", data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return avg_pool3d_eager_fallback(
|
|
input, ksize=ksize, strides=strides, padding=padding,
|
|
data_format=data_format, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'avg_pool3d' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'avg_pool3d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"AvgPool3D", input=input, ksize=ksize, strides=strides,
|
|
padding=padding, data_format=data_format, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("ksize", _op.get_attr("ksize"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"data_format", _op.get_attr("data_format"), "T",
|
|
_op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"AvgPool3D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
AvgPool3D = tf_export("raw_ops.AvgPool3D")(_ops.to_raw_op(avg_pool3d))
|
|
|
|
|
|
def avg_pool3d_eager_fallback(input, ksize, strides, padding, data_format, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'avg_pool3d' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'avg_pool3d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
_inputs_flat = [input]
|
|
_attrs = ("ksize", ksize, "strides", strides, "padding", padding,
|
|
"data_format", data_format, "T", _attr_T)
|
|
_result = _execute.execute(b"AvgPool3D", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"AvgPool3D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def avg_pool3d_grad(orig_input_shape, grad, ksize, strides, padding, data_format="NDHWC", name=None):
|
|
r"""Computes gradients of average pooling function.
|
|
|
|
Args:
|
|
orig_input_shape: A `Tensor` of type `int32`.
|
|
The original input dimensions.
|
|
grad: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
Output backprop of shape `[batch, depth, rows, cols, channels]`.
|
|
ksize: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The size of the window for each dimension of
|
|
|
|
the input tensor. Must have `ksize[0] = ksize[4] = 1`.
|
|
strides: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The stride of the sliding window for each
|
|
|
|
dimension of `input`. Must have `strides[0] = strides[4] = 1`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`.
|
|
The data format of the input and output data. With the
|
|
|
|
default format "NDHWC", the data is stored in the order of:
|
|
|
|
[batch, in_depth, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCDHW", the data storage order is:
|
|
|
|
[batch, in_channels, in_depth, in_height, in_width].
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `grad`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "AvgPool3DGrad", name, orig_input_shape, grad, "ksize", ksize,
|
|
"strides", strides, "padding", padding, "data_format", data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return avg_pool3d_grad_eager_fallback(
|
|
orig_input_shape, grad, ksize=ksize, strides=strides,
|
|
padding=padding, data_format=data_format, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'avg_pool3d_grad' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'avg_pool3d_grad' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"AvgPool3DGrad", orig_input_shape=orig_input_shape, grad=grad,
|
|
ksize=ksize, strides=strides, padding=padding,
|
|
data_format=data_format, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("ksize", _op.get_attr("ksize"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"data_format", _op.get_attr("data_format"), "T",
|
|
_op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"AvgPool3DGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
AvgPool3DGrad = tf_export("raw_ops.AvgPool3DGrad")(_ops.to_raw_op(avg_pool3d_grad))
|
|
|
|
|
|
def avg_pool3d_grad_eager_fallback(orig_input_shape, grad, ksize, strides, padding, data_format, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'avg_pool3d_grad' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'avg_pool3d_grad' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, (grad,) = _execute.args_to_matching_eager([grad], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
orig_input_shape = _ops.convert_to_tensor(orig_input_shape, _dtypes.int32)
|
|
_inputs_flat = [orig_input_shape, grad]
|
|
_attrs = ("ksize", ksize, "strides", strides, "padding", padding,
|
|
"data_format", data_format, "T", _attr_T)
|
|
_result = _execute.execute(b"AvgPool3DGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"AvgPool3DGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def avg_pool_grad(orig_input_shape, grad, ksize, strides, padding, data_format="NHWC", name=None):
|
|
r"""Computes gradients of the average pooling function.
|
|
|
|
Args:
|
|
orig_input_shape: A `Tensor` of type `int32`.
|
|
1-D. Shape of the original input to `avg_pool`.
|
|
grad: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
4-D with shape `[batch, height, width, channels]`. Gradients w.r.t.
|
|
|
|
the output of `avg_pool`.
|
|
ksize: A list of `ints` that has length `>= 4`.
|
|
The size of the sliding window for each dimension of the input.
|
|
strides: A list of `ints` that has length `>= 4`.
|
|
The stride of the sliding window for each dimension of the input.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `grad`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "AvgPoolGrad", name, orig_input_shape, grad, "ksize", ksize,
|
|
"strides", strides, "padding", padding, "data_format", data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return avg_pool_grad_eager_fallback(
|
|
orig_input_shape, grad, ksize=ksize, strides=strides,
|
|
padding=padding, data_format=data_format, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'avg_pool_grad' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'avg_pool_grad' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"AvgPoolGrad", orig_input_shape=orig_input_shape, grad=grad,
|
|
ksize=ksize, strides=strides, padding=padding,
|
|
data_format=data_format, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("ksize", _op.get_attr("ksize"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"data_format", _op.get_attr("data_format"), "T",
|
|
_op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"AvgPoolGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
AvgPoolGrad = tf_export("raw_ops.AvgPoolGrad")(_ops.to_raw_op(avg_pool_grad))
|
|
|
|
|
|
def avg_pool_grad_eager_fallback(orig_input_shape, grad, ksize, strides, padding, data_format, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'avg_pool_grad' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'avg_pool_grad' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, (grad,) = _execute.args_to_matching_eager([grad], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
orig_input_shape = _ops.convert_to_tensor(orig_input_shape, _dtypes.int32)
|
|
_inputs_flat = [orig_input_shape, grad]
|
|
_attrs = ("ksize", ksize, "strides", strides, "padding", padding,
|
|
"data_format", data_format, "T", _attr_T)
|
|
_result = _execute.execute(b"AvgPoolGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"AvgPoolGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def _batch_norm_with_global_normalization(t, m, v, beta, gamma, variance_epsilon, scale_after_normalization, name=None):
|
|
r"""Batch normalization.
|
|
|
|
This op is deprecated. Prefer `tf.nn.batch_normalization`.
|
|
|
|
Args:
|
|
t: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.
|
|
A 4D input Tensor.
|
|
m: A `Tensor`. Must have the same type as `t`.
|
|
A 1D mean Tensor with size matching the last dimension of t.
|
|
|
|
This is the first output from tf.nn.moments,
|
|
|
|
or a saved moving average thereof.
|
|
v: A `Tensor`. Must have the same type as `t`.
|
|
A 1D variance Tensor with size matching the last dimension of t.
|
|
|
|
This is the second output from tf.nn.moments,
|
|
|
|
or a saved moving average thereof.
|
|
beta: A `Tensor`. Must have the same type as `t`.
|
|
A 1D beta Tensor with size matching the last dimension of t.
|
|
|
|
An offset to be added to the normalized tensor.
|
|
gamma: A `Tensor`. Must have the same type as `t`.
|
|
A 1D gamma Tensor with size matching the last dimension of t.
|
|
|
|
If "scale_after_normalization" is true, this tensor will be multiplied
|
|
|
|
with the normalized tensor.
|
|
variance_epsilon: A `float`. A small float number to avoid dividing by 0.
|
|
scale_after_normalization: A `bool`.
|
|
A bool indicating whether the resulted tensor
|
|
|
|
needs to be multiplied with gamma.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `t`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "BatchNormWithGlobalNormalization", name, t, m, v, beta, gamma,
|
|
"variance_epsilon", variance_epsilon, "scale_after_normalization",
|
|
scale_after_normalization)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return _batch_norm_with_global_normalization_eager_fallback(
|
|
t, m, v, beta, gamma, variance_epsilon=variance_epsilon,
|
|
scale_after_normalization=scale_after_normalization, name=name,
|
|
ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
variance_epsilon = _execute.make_float(variance_epsilon, "variance_epsilon")
|
|
scale_after_normalization = _execute.make_bool(scale_after_normalization, "scale_after_normalization")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"BatchNormWithGlobalNormalization", t=t, m=m, v=v, beta=beta,
|
|
gamma=gamma,
|
|
variance_epsilon=variance_epsilon,
|
|
scale_after_normalization=scale_after_normalization,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "variance_epsilon",
|
|
_op.get_attr("variance_epsilon"), "scale_after_normalization",
|
|
_op._get_attr_bool("scale_after_normalization"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"BatchNormWithGlobalNormalization", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
BatchNormWithGlobalNormalization = tf_export("raw_ops.BatchNormWithGlobalNormalization")(_ops.to_raw_op(_batch_norm_with_global_normalization))
|
|
|
|
|
|
def _batch_norm_with_global_normalization_eager_fallback(t, m, v, beta, gamma, variance_epsilon, scale_after_normalization, name, ctx):
|
|
variance_epsilon = _execute.make_float(variance_epsilon, "variance_epsilon")
|
|
scale_after_normalization = _execute.make_bool(scale_after_normalization, "scale_after_normalization")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([t, m, v, beta, gamma], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.complex64, _dtypes.int64, _dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.bfloat16, _dtypes.qint16, _dtypes.quint16, _dtypes.uint16, _dtypes.complex128, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(t, m, v, beta, gamma) = _inputs_T
|
|
_inputs_flat = [t, m, v, beta, gamma]
|
|
_attrs = ("T", _attr_T, "variance_epsilon", variance_epsilon,
|
|
"scale_after_normalization", scale_after_normalization)
|
|
_result = _execute.execute(b"BatchNormWithGlobalNormalization", 1,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"BatchNormWithGlobalNormalization", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
_BatchNormWithGlobalNormalizationGradOutput = collections.namedtuple(
|
|
"BatchNormWithGlobalNormalizationGrad",
|
|
["dx", "dm", "dv", "db", "dg"])
|
|
|
|
|
|
def batch_norm_with_global_normalization_grad(t, m, v, gamma, backprop, variance_epsilon, scale_after_normalization, name=None):
|
|
r"""Gradients for batch normalization.
|
|
|
|
This op is deprecated. See `tf.nn.batch_normalization`.
|
|
|
|
Args:
|
|
t: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.
|
|
A 4D input Tensor.
|
|
m: A `Tensor`. Must have the same type as `t`.
|
|
A 1D mean Tensor with size matching the last dimension of t.
|
|
|
|
This is the first output from tf.nn.moments,
|
|
|
|
or a saved moving average thereof.
|
|
v: A `Tensor`. Must have the same type as `t`.
|
|
A 1D variance Tensor with size matching the last dimension of t.
|
|
|
|
This is the second output from tf.nn.moments,
|
|
|
|
or a saved moving average thereof.
|
|
gamma: A `Tensor`. Must have the same type as `t`.
|
|
A 1D gamma Tensor with size matching the last dimension of t.
|
|
|
|
If "scale_after_normalization" is true, this Tensor will be multiplied
|
|
|
|
with the normalized Tensor.
|
|
backprop: A `Tensor`. Must have the same type as `t`. 4D backprop Tensor.
|
|
variance_epsilon: A `float`. A small float number to avoid dividing by 0.
|
|
scale_after_normalization: A `bool`.
|
|
A bool indicating whether the resulted tensor
|
|
|
|
needs to be multiplied with gamma.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (dx, dm, dv, db, dg).
|
|
|
|
dx: A `Tensor`. Has the same type as `t`.
|
|
dm: A `Tensor`. Has the same type as `t`.
|
|
dv: A `Tensor`. Has the same type as `t`.
|
|
db: A `Tensor`. Has the same type as `t`.
|
|
dg: A `Tensor`. Has the same type as `t`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "BatchNormWithGlobalNormalizationGrad", name, t, m, v, gamma,
|
|
backprop, "variance_epsilon", variance_epsilon,
|
|
"scale_after_normalization", scale_after_normalization)
|
|
_result = _BatchNormWithGlobalNormalizationGradOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return batch_norm_with_global_normalization_grad_eager_fallback(
|
|
t, m, v, gamma, backprop, variance_epsilon=variance_epsilon,
|
|
scale_after_normalization=scale_after_normalization, name=name,
|
|
ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
variance_epsilon = _execute.make_float(variance_epsilon, "variance_epsilon")
|
|
scale_after_normalization = _execute.make_bool(scale_after_normalization, "scale_after_normalization")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"BatchNormWithGlobalNormalizationGrad", t=t, m=m, v=v, gamma=gamma,
|
|
backprop=backprop,
|
|
variance_epsilon=variance_epsilon,
|
|
scale_after_normalization=scale_after_normalization,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "variance_epsilon",
|
|
_op.get_attr("variance_epsilon"), "scale_after_normalization",
|
|
_op._get_attr_bool("scale_after_normalization"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"BatchNormWithGlobalNormalizationGrad", _inputs_flat, _attrs, _result)
|
|
_result = _BatchNormWithGlobalNormalizationGradOutput._make(_result)
|
|
return _result
|
|
|
|
BatchNormWithGlobalNormalizationGrad = tf_export("raw_ops.BatchNormWithGlobalNormalizationGrad")(_ops.to_raw_op(batch_norm_with_global_normalization_grad))
|
|
|
|
|
|
def batch_norm_with_global_normalization_grad_eager_fallback(t, m, v, gamma, backprop, variance_epsilon, scale_after_normalization, name, ctx):
|
|
variance_epsilon = _execute.make_float(variance_epsilon, "variance_epsilon")
|
|
scale_after_normalization = _execute.make_bool(scale_after_normalization, "scale_after_normalization")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([t, m, v, gamma, backprop], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.complex64, _dtypes.int64, _dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.bfloat16, _dtypes.qint16, _dtypes.quint16, _dtypes.uint16, _dtypes.complex128, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(t, m, v, gamma, backprop) = _inputs_T
|
|
_inputs_flat = [t, m, v, gamma, backprop]
|
|
_attrs = ("T", _attr_T, "variance_epsilon", variance_epsilon,
|
|
"scale_after_normalization", scale_after_normalization)
|
|
_result = _execute.execute(b"BatchNormWithGlobalNormalizationGrad", 5,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"BatchNormWithGlobalNormalizationGrad", _inputs_flat, _attrs, _result)
|
|
_result = _BatchNormWithGlobalNormalizationGradOutput._make(_result)
|
|
return _result
|
|
|
|
|
|
def bias_add(value, bias, data_format="NHWC", name=None):
|
|
r"""Adds `bias` to `value`.
|
|
|
|
This is a special case of `tf.add` where `bias` is restricted to be 1-D.
|
|
|
|
Broadcasting is supported, so `value` may have any number of dimensions.
|
|
|
|
Args:
|
|
value: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.
|
|
Any number of dimensions.
|
|
bias: A `Tensor`. Must have the same type as `value`.
|
|
1-D with size the last dimension of `value`.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the bias tensor will be added to the last dimension
|
|
|
|
of the value tensor.
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
|
|
The tensor will be added to "in_channels", the third-to-the-last
|
|
|
|
dimension.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `value`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "BiasAdd", name, value, bias, "data_format", data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return bias_add_eager_fallback(
|
|
value, bias, data_format=data_format, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"BiasAdd", value=value, bias=bias, data_format=data_format, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "data_format",
|
|
_op.get_attr("data_format"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"BiasAdd", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
BiasAdd = tf_export("raw_ops.BiasAdd")(_ops.to_raw_op(bias_add))
|
|
|
|
|
|
def bias_add_eager_fallback(value, bias, data_format, name, ctx):
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([value, bias], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.complex64, _dtypes.int64, _dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.bfloat16, _dtypes.qint16, _dtypes.quint16, _dtypes.uint16, _dtypes.complex128, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(value, bias) = _inputs_T
|
|
_inputs_flat = [value, bias]
|
|
_attrs = ("T", _attr_T, "data_format", data_format)
|
|
_result = _execute.execute(b"BiasAdd", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"BiasAdd", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def bias_add_grad(out_backprop, data_format="NHWC", name=None):
|
|
r"""The backward operation for "BiasAdd" on the "bias" tensor.
|
|
|
|
It accumulates all the values from out_backprop into the feature dimension.
|
|
|
|
For NHWC data format, the feature dimension is the last. For NCHW data format,
|
|
|
|
the feature dimension is the third-to-last.
|
|
|
|
Args:
|
|
out_backprop: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.
|
|
Any number of dimensions.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the bias tensor will be added to the last dimension
|
|
|
|
of the value tensor.
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
|
|
The tensor will be added to "in_channels", the third-to-the-last
|
|
|
|
dimension.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `out_backprop`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "BiasAddGrad", name, out_backprop, "data_format", data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return bias_add_grad_eager_fallback(
|
|
out_backprop, data_format=data_format, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"BiasAddGrad", out_backprop=out_backprop, data_format=data_format,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "data_format",
|
|
_op.get_attr("data_format"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"BiasAddGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
BiasAddGrad = tf_export("raw_ops.BiasAddGrad")(_ops.to_raw_op(bias_add_grad))
|
|
|
|
|
|
def bias_add_grad_eager_fallback(out_backprop, data_format, name, ctx):
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, (out_backprop,) = _execute.args_to_matching_eager([out_backprop], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.complex64, _dtypes.int64, _dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.bfloat16, _dtypes.qint16, _dtypes.quint16, _dtypes.uint16, _dtypes.complex128, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
_inputs_flat = [out_backprop]
|
|
_attrs = ("T", _attr_T, "data_format", data_format)
|
|
_result = _execute.execute(b"BiasAddGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"BiasAddGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def bias_add_v1(value, bias, name=None):
|
|
r"""Adds `bias` to `value`.
|
|
|
|
This is a deprecated version of BiasAdd and will be soon removed.
|
|
|
|
|
|
|
|
This is a special case of `tf.add` where `bias` is restricted to be 1-D.
|
|
|
|
Broadcasting is supported, so `value` may have any number of dimensions.
|
|
|
|
Args:
|
|
value: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.
|
|
Any number of dimensions.
|
|
bias: A `Tensor`. Must have the same type as `value`.
|
|
1-D with size the last dimension of `value`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `value`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "BiasAddV1", name, value, bias)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return bias_add_v1_eager_fallback(
|
|
value, bias, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"BiasAddV1", value=value, bias=bias, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"BiasAddV1", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
BiasAddV1 = tf_export("raw_ops.BiasAddV1")(_ops.to_raw_op(bias_add_v1))
|
|
|
|
|
|
def bias_add_v1_eager_fallback(value, bias, name, ctx):
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([value, bias], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.complex64, _dtypes.int64, _dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.bfloat16, _dtypes.qint16, _dtypes.quint16, _dtypes.uint16, _dtypes.complex128, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(value, bias) = _inputs_T
|
|
_inputs_flat = [value, bias]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"BiasAddV1", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"BiasAddV1", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def conv2d(input, filter, strides, padding, use_cudnn_on_gpu=True, explicit_paddings=[], data_format="NHWC", dilations=[1, 1, 1, 1], name=None):
|
|
r"""Computes a 2-D convolution given 4-D `input` and `filter` tensors.
|
|
|
|
Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
|
|
|
|
and a filter / kernel tensor of shape
|
|
|
|
`[filter_height, filter_width, in_channels, out_channels]`, this op
|
|
|
|
performs the following:
|
|
|
|
|
|
|
|
1. Flattens the filter to a 2-D matrix with shape
|
|
|
|
`[filter_height * filter_width * in_channels, output_channels]`.
|
|
|
|
2. Extracts image patches from the input tensor to form a *virtual*
|
|
|
|
tensor of shape `[batch, out_height, out_width,
|
|
|
|
filter_height * filter_width * in_channels]`.
|
|
|
|
3. For each patch, right-multiplies the filter matrix and the image patch
|
|
|
|
vector.
|
|
|
|
|
|
|
|
In detail, with the default NHWC format,
|
|
|
|
|
|
|
|
output[b, i, j, k] =
|
|
|
|
sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] *
|
|
|
|
filter[di, dj, q, k]
|
|
|
|
|
|
|
|
Must have `strides[0] = strides[3] = 1`. For the most common case of the same
|
|
|
|
horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`, `int32`.
|
|
A 4-D tensor. The dimension order is interpreted according to the value
|
|
|
|
of `data_format`, see below for details.
|
|
filter: A `Tensor`. Must have the same type as `input`.
|
|
A 4-D tensor of shape
|
|
|
|
`[filter_height, filter_width, in_channels, out_channels]`
|
|
strides: A list of `ints`.
|
|
1-D tensor of length 4. The stride of the sliding window for each
|
|
|
|
dimension of `input`. The dimension order is determined by the value of
|
|
|
|
`data_format`, see below for details.
|
|
padding: A `string` from: `"SAME", "VALID", "EXPLICIT"`.
|
|
The type of padding algorithm to use.
|
|
use_cudnn_on_gpu: An optional `bool`. Defaults to `True`.
|
|
explicit_paddings: An optional list of `ints`. Defaults to `[]`.
|
|
If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
|
|
|
|
dimension, the amount of padding inserted before and after the dimension is
|
|
|
|
`explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
|
|
|
|
`padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, height, width, channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, channels, height, width].
|
|
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1]`.
|
|
1-D tensor of length 4. The dilation factor for each dimension of
|
|
|
|
`input`. If set to k > 1, there will be k-1 skipped cells between each
|
|
|
|
filter element on that dimension. The dimension order is determined by the
|
|
|
|
value of `data_format`, see above for details. Dilations in the batch and
|
|
|
|
depth dimensions must be 1.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Conv2D", name, input, filter, "strides", strides,
|
|
"use_cudnn_on_gpu", use_cudnn_on_gpu, "padding", padding,
|
|
"explicit_paddings", explicit_paddings, "data_format", data_format,
|
|
"dilations", dilations)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return conv2d_eager_fallback(
|
|
input, filter, strides=strides, use_cudnn_on_gpu=use_cudnn_on_gpu,
|
|
padding=padding, explicit_paddings=explicit_paddings,
|
|
data_format=data_format, dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv2d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if use_cudnn_on_gpu is None:
|
|
use_cudnn_on_gpu = True
|
|
use_cudnn_on_gpu = _execute.make_bool(use_cudnn_on_gpu, "use_cudnn_on_gpu")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'conv2d' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv2d' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Conv2D", input=input, filter=filter, strides=strides,
|
|
padding=padding, use_cudnn_on_gpu=use_cudnn_on_gpu,
|
|
explicit_paddings=explicit_paddings,
|
|
data_format=data_format, dilations=dilations, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "use_cudnn_on_gpu",
|
|
_op._get_attr_bool("use_cudnn_on_gpu"), "padding",
|
|
_op.get_attr("padding"), "explicit_paddings",
|
|
_op.get_attr("explicit_paddings"), "data_format",
|
|
_op.get_attr("data_format"), "dilations",
|
|
_op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Conv2D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Conv2D = tf_export("raw_ops.Conv2D")(_ops.to_raw_op(conv2d))
|
|
|
|
|
|
def conv2d_eager_fallback(input, filter, strides, padding, use_cudnn_on_gpu, explicit_paddings, data_format, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv2d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if use_cudnn_on_gpu is None:
|
|
use_cudnn_on_gpu = True
|
|
use_cudnn_on_gpu = _execute.make_bool(use_cudnn_on_gpu, "use_cudnn_on_gpu")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'conv2d' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv2d' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, filter], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, _dtypes.int32, ])
|
|
(input, filter) = _inputs_T
|
|
_inputs_flat = [input, filter]
|
|
_attrs = ("T", _attr_T, "strides", strides, "use_cudnn_on_gpu",
|
|
use_cudnn_on_gpu, "padding", padding, "explicit_paddings",
|
|
explicit_paddings, "data_format", data_format, "dilations", dilations)
|
|
_result = _execute.execute(b"Conv2D", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Conv2D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def conv2d_backprop_filter(input, filter_sizes, out_backprop, strides, padding, use_cudnn_on_gpu=True, explicit_paddings=[], data_format="NHWC", dilations=[1, 1, 1, 1], name=None):
|
|
r"""Computes the gradients of convolution with respect to the filter.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
4-D with shape `[batch, in_height, in_width, in_channels]`.
|
|
filter_sizes: A `Tensor` of type `int32`.
|
|
An integer vector representing the tensor shape of `filter`,
|
|
|
|
where `filter` is a 4-D
|
|
|
|
`[filter_height, filter_width, in_channels, out_channels]` tensor.
|
|
out_backprop: A `Tensor`. Must have the same type as `input`.
|
|
4-D with shape `[batch, out_height, out_width, out_channels]`.
|
|
|
|
Gradients w.r.t. the output of the convolution.
|
|
strides: A list of `ints`.
|
|
The stride of the sliding window for each dimension of the input
|
|
|
|
of the convolution. Must be in the same order as the dimension specified with
|
|
|
|
format.
|
|
padding: A `string` from: `"SAME", "VALID", "EXPLICIT"`.
|
|
The type of padding algorithm to use.
|
|
use_cudnn_on_gpu: An optional `bool`. Defaults to `True`.
|
|
explicit_paddings: An optional list of `ints`. Defaults to `[]`.
|
|
If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
|
|
|
|
dimension, the amount of padding inserted before and after the dimension is
|
|
|
|
`explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
|
|
|
|
`padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1]`.
|
|
1-D tensor of length 4. The dilation factor for each dimension of
|
|
|
|
`input`. If set to k > 1, there will be k-1 skipped cells between each filter
|
|
|
|
element on that dimension. The dimension order is determined by the value of
|
|
|
|
`data_format`, see above for details. Dilations in the batch and depth
|
|
|
|
dimensions must be 1.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Conv2DBackpropFilter", name, input, filter_sizes, out_backprop,
|
|
"strides", strides, "use_cudnn_on_gpu", use_cudnn_on_gpu, "padding",
|
|
padding, "explicit_paddings", explicit_paddings, "data_format",
|
|
data_format, "dilations", dilations)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return conv2d_backprop_filter_eager_fallback(
|
|
input, filter_sizes, out_backprop, strides=strides,
|
|
use_cudnn_on_gpu=use_cudnn_on_gpu, padding=padding,
|
|
explicit_paddings=explicit_paddings, data_format=data_format,
|
|
dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv2d_backprop_filter' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if use_cudnn_on_gpu is None:
|
|
use_cudnn_on_gpu = True
|
|
use_cudnn_on_gpu = _execute.make_bool(use_cudnn_on_gpu, "use_cudnn_on_gpu")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'conv2d_backprop_filter' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv2d_backprop_filter' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Conv2DBackpropFilter", input=input, filter_sizes=filter_sizes,
|
|
out_backprop=out_backprop, strides=strides,
|
|
padding=padding,
|
|
use_cudnn_on_gpu=use_cudnn_on_gpu,
|
|
explicit_paddings=explicit_paddings,
|
|
data_format=data_format, dilations=dilations,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "use_cudnn_on_gpu",
|
|
_op._get_attr_bool("use_cudnn_on_gpu"), "padding",
|
|
_op.get_attr("padding"), "explicit_paddings",
|
|
_op.get_attr("explicit_paddings"), "data_format",
|
|
_op.get_attr("data_format"), "dilations",
|
|
_op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Conv2DBackpropFilter", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Conv2DBackpropFilter = tf_export("raw_ops.Conv2DBackpropFilter")(_ops.to_raw_op(conv2d_backprop_filter))
|
|
|
|
|
|
def conv2d_backprop_filter_eager_fallback(input, filter_sizes, out_backprop, strides, padding, use_cudnn_on_gpu, explicit_paddings, data_format, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv2d_backprop_filter' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if use_cudnn_on_gpu is None:
|
|
use_cudnn_on_gpu = True
|
|
use_cudnn_on_gpu = _execute.make_bool(use_cudnn_on_gpu, "use_cudnn_on_gpu")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'conv2d_backprop_filter' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv2d_backprop_filter' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, out_backprop], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
(input, out_backprop) = _inputs_T
|
|
filter_sizes = _ops.convert_to_tensor(filter_sizes, _dtypes.int32)
|
|
_inputs_flat = [input, filter_sizes, out_backprop]
|
|
_attrs = ("T", _attr_T, "strides", strides, "use_cudnn_on_gpu",
|
|
use_cudnn_on_gpu, "padding", padding, "explicit_paddings",
|
|
explicit_paddings, "data_format", data_format, "dilations", dilations)
|
|
_result = _execute.execute(b"Conv2DBackpropFilter", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Conv2DBackpropFilter", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
@_dispatch.add_fallback_dispatch_list
|
|
@_dispatch.add_type_based_api_dispatcher
|
|
@tf_export('conv2d_backprop_filter_v2')
|
|
def conv2d_backprop_filter_v2(input, filter, out_backprop, strides, padding, use_cudnn_on_gpu=True, explicit_paddings=[], data_format="NHWC", dilations=[1, 1, 1, 1], name=None):
|
|
r"""Computes the gradients of convolution with respect to the filter.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
4-D with shape `[batch, in_height, in_width, in_channels]`.
|
|
filter: A `Tensor`. Must have the same type as `input`.
|
|
4-D with shape `[filter_height, filter_width, in_channels, out_channels]`.
|
|
|
|
Only shape of tensor is used.
|
|
out_backprop: A `Tensor`. Must have the same type as `input`.
|
|
4-D with shape `[batch, out_height, out_width, out_channels]`.
|
|
|
|
Gradients w.r.t. the output of the convolution.
|
|
strides: A list of `ints`.
|
|
The stride of the sliding window for each dimension of the input
|
|
|
|
of the convolution. Must be in the same order as the dimension specified with
|
|
|
|
format.
|
|
padding: A `string` from: `"SAME", "VALID", "EXPLICIT"`.
|
|
The type of padding algorithm to use.
|
|
use_cudnn_on_gpu: An optional `bool`. Defaults to `True`.
|
|
explicit_paddings: An optional list of `ints`. Defaults to `[]`.
|
|
If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
|
|
|
|
dimension, the amount of padding inserted before and after the dimension is
|
|
|
|
`explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
|
|
|
|
`padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1]`.
|
|
1-D tensor of length 4. The dilation factor for each dimension of
|
|
|
|
`input`. If set to k > 1, there will be k-1 skipped cells between each filter
|
|
|
|
element on that dimension. The dimension order is determined by the value of
|
|
|
|
`data_format`, see above for details. Dilations in the batch and depth
|
|
|
|
dimensions must be 1.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Conv2DBackpropFilterV2", name, input, filter, out_backprop,
|
|
"strides", strides, "use_cudnn_on_gpu", use_cudnn_on_gpu, "padding",
|
|
padding, "explicit_paddings", explicit_paddings, "data_format",
|
|
data_format, "dilations", dilations)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
_result = _dispatcher_for_conv2d_backprop_filter_v2(
|
|
(input, filter, out_backprop, strides, padding, use_cudnn_on_gpu,
|
|
explicit_paddings, data_format, dilations, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
return conv2d_backprop_filter_v2_eager_fallback(
|
|
input, filter, out_backprop, strides=strides,
|
|
use_cudnn_on_gpu=use_cudnn_on_gpu, padding=padding,
|
|
explicit_paddings=explicit_paddings, data_format=data_format,
|
|
dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
conv2d_backprop_filter_v2, (), dict(input=input, filter=filter,
|
|
out_backprop=out_backprop,
|
|
strides=strides,
|
|
padding=padding,
|
|
use_cudnn_on_gpu=use_cudnn_on_gpu,
|
|
explicit_paddings=explicit_paddings,
|
|
data_format=data_format,
|
|
dilations=dilations,
|
|
name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
else:
|
|
_result = _dispatcher_for_conv2d_backprop_filter_v2(
|
|
(input, filter, out_backprop, strides, padding, use_cudnn_on_gpu,
|
|
explicit_paddings, data_format, dilations, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv2d_backprop_filter_v2' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if use_cudnn_on_gpu is None:
|
|
use_cudnn_on_gpu = True
|
|
use_cudnn_on_gpu = _execute.make_bool(use_cudnn_on_gpu, "use_cudnn_on_gpu")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'conv2d_backprop_filter_v2' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv2d_backprop_filter_v2' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
try:
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Conv2DBackpropFilterV2", input=input, filter=filter,
|
|
out_backprop=out_backprop, strides=strides,
|
|
padding=padding,
|
|
use_cudnn_on_gpu=use_cudnn_on_gpu,
|
|
explicit_paddings=explicit_paddings,
|
|
data_format=data_format,
|
|
dilations=dilations, name=name)
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
conv2d_backprop_filter_v2, (), dict(input=input, filter=filter,
|
|
out_backprop=out_backprop,
|
|
strides=strides,
|
|
padding=padding,
|
|
use_cudnn_on_gpu=use_cudnn_on_gpu,
|
|
explicit_paddings=explicit_paddings,
|
|
data_format=data_format,
|
|
dilations=dilations, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "use_cudnn_on_gpu",
|
|
_op._get_attr_bool("use_cudnn_on_gpu"), "padding",
|
|
_op.get_attr("padding"), "explicit_paddings",
|
|
_op.get_attr("explicit_paddings"), "data_format",
|
|
_op.get_attr("data_format"), "dilations",
|
|
_op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Conv2DBackpropFilterV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Conv2DBackpropFilterV2 = tf_export("raw_ops.Conv2DBackpropFilterV2")(_ops.to_raw_op(conv2d_backprop_filter_v2))
|
|
_dispatcher_for_conv2d_backprop_filter_v2 = conv2d_backprop_filter_v2._tf_type_based_dispatcher.Dispatch
|
|
|
|
|
|
def conv2d_backprop_filter_v2_eager_fallback(input, filter, out_backprop, strides, padding, use_cudnn_on_gpu, explicit_paddings, data_format, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv2d_backprop_filter_v2' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if use_cudnn_on_gpu is None:
|
|
use_cudnn_on_gpu = True
|
|
use_cudnn_on_gpu = _execute.make_bool(use_cudnn_on_gpu, "use_cudnn_on_gpu")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'conv2d_backprop_filter_v2' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv2d_backprop_filter_v2' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, filter, out_backprop], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
(input, filter, out_backprop) = _inputs_T
|
|
_inputs_flat = [input, filter, out_backprop]
|
|
_attrs = ("T", _attr_T, "strides", strides, "use_cudnn_on_gpu",
|
|
use_cudnn_on_gpu, "padding", padding, "explicit_paddings",
|
|
explicit_paddings, "data_format", data_format, "dilations", dilations)
|
|
_result = _execute.execute(b"Conv2DBackpropFilterV2", 1,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Conv2DBackpropFilterV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def conv2d_backprop_input(input_sizes, filter, out_backprop, strides, padding, use_cudnn_on_gpu=True, explicit_paddings=[], data_format="NHWC", dilations=[1, 1, 1, 1], name=None):
|
|
r"""Computes the gradients of convolution with respect to the input.
|
|
|
|
Args:
|
|
input_sizes: A `Tensor` of type `int32`.
|
|
An integer vector representing the shape of `input`,
|
|
|
|
where `input` is a 4-D `[batch, height, width, channels]` tensor.
|
|
filter: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`, `int32`.
|
|
4-D with shape
|
|
|
|
`[filter_height, filter_width, in_channels, out_channels]`.
|
|
out_backprop: A `Tensor`. Must have the same type as `filter`.
|
|
4-D with shape `[batch, out_height, out_width, out_channels]`.
|
|
|
|
Gradients w.r.t. the output of the convolution.
|
|
strides: A list of `ints`.
|
|
The stride of the sliding window for each dimension of the input
|
|
|
|
of the convolution. Must be in the same order as the dimension specified with
|
|
|
|
format.
|
|
padding: A `string` from: `"SAME", "VALID", "EXPLICIT"`.
|
|
The type of padding algorithm to use.
|
|
use_cudnn_on_gpu: An optional `bool`. Defaults to `True`.
|
|
explicit_paddings: An optional list of `ints`. Defaults to `[]`.
|
|
If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
|
|
|
|
dimension, the amount of padding inserted before and after the dimension is
|
|
|
|
`explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
|
|
|
|
`padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1]`.
|
|
1-D tensor of length 4. The dilation factor for each dimension of
|
|
|
|
`input`. If set to k > 1, there will be k-1 skipped cells between each filter
|
|
|
|
element on that dimension. The dimension order is determined by the value of
|
|
|
|
`data_format`, see above for details. Dilations in the batch and depth
|
|
|
|
dimensions must be 1.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `filter`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Conv2DBackpropInput", name, input_sizes, filter, out_backprop,
|
|
"strides", strides, "use_cudnn_on_gpu", use_cudnn_on_gpu, "padding",
|
|
padding, "explicit_paddings", explicit_paddings, "data_format",
|
|
data_format, "dilations", dilations)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return conv2d_backprop_input_eager_fallback(
|
|
input_sizes, filter, out_backprop, strides=strides,
|
|
use_cudnn_on_gpu=use_cudnn_on_gpu, padding=padding,
|
|
explicit_paddings=explicit_paddings, data_format=data_format,
|
|
dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv2d_backprop_input' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if use_cudnn_on_gpu is None:
|
|
use_cudnn_on_gpu = True
|
|
use_cudnn_on_gpu = _execute.make_bool(use_cudnn_on_gpu, "use_cudnn_on_gpu")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'conv2d_backprop_input' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv2d_backprop_input' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Conv2DBackpropInput", input_sizes=input_sizes, filter=filter,
|
|
out_backprop=out_backprop, strides=strides,
|
|
padding=padding,
|
|
use_cudnn_on_gpu=use_cudnn_on_gpu,
|
|
explicit_paddings=explicit_paddings,
|
|
data_format=data_format, dilations=dilations,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "use_cudnn_on_gpu",
|
|
_op._get_attr_bool("use_cudnn_on_gpu"), "padding",
|
|
_op.get_attr("padding"), "explicit_paddings",
|
|
_op.get_attr("explicit_paddings"), "data_format",
|
|
_op.get_attr("data_format"), "dilations",
|
|
_op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Conv2DBackpropInput", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Conv2DBackpropInput = tf_export("raw_ops.Conv2DBackpropInput")(_ops.to_raw_op(conv2d_backprop_input))
|
|
|
|
|
|
def conv2d_backprop_input_eager_fallback(input_sizes, filter, out_backprop, strides, padding, use_cudnn_on_gpu, explicit_paddings, data_format, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv2d_backprop_input' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if use_cudnn_on_gpu is None:
|
|
use_cudnn_on_gpu = True
|
|
use_cudnn_on_gpu = _execute.make_bool(use_cudnn_on_gpu, "use_cudnn_on_gpu")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'conv2d_backprop_input' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv2d_backprop_input' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([filter, out_backprop], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, _dtypes.int32, ])
|
|
(filter, out_backprop) = _inputs_T
|
|
input_sizes = _ops.convert_to_tensor(input_sizes, _dtypes.int32)
|
|
_inputs_flat = [input_sizes, filter, out_backprop]
|
|
_attrs = ("T", _attr_T, "strides", strides, "use_cudnn_on_gpu",
|
|
use_cudnn_on_gpu, "padding", padding, "explicit_paddings",
|
|
explicit_paddings, "data_format", data_format, "dilations", dilations)
|
|
_result = _execute.execute(b"Conv2DBackpropInput", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Conv2DBackpropInput", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
@_dispatch.add_fallback_dispatch_list
|
|
@_dispatch.add_type_based_api_dispatcher
|
|
@tf_export('conv2d_backprop_input_v2')
|
|
def conv2d_backprop_input_v2(input, filter, out_backprop, strides, padding, use_cudnn_on_gpu=True, explicit_paddings=[], data_format="NHWC", dilations=[1, 1, 1, 1], name=None):
|
|
r"""Computes the gradients of convolution with respect to the input.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`, `int32`.
|
|
4-D with shape `[batch, in_height, in_width, in_channels]`.
|
|
|
|
Only shape of tensor is used.
|
|
filter: A `Tensor`. Must have the same type as `input`. 4-D with shape
|
|
|
|
`[filter_height, filter_width, in_channels, out_channels]`.
|
|
out_backprop: A `Tensor`. Must have the same type as `input`.
|
|
4-D with shape `[batch, out_height, out_width, out_channels]`.
|
|
|
|
Gradients w.r.t. the output of the convolution.
|
|
strides: A list of `ints`.
|
|
The stride of the sliding window for each dimension of the input
|
|
|
|
of the convolution. Must be in the same order as the dimension specified with
|
|
|
|
format.
|
|
padding: A `string` from: `"SAME", "VALID", "EXPLICIT"`.
|
|
The type of padding algorithm to use.
|
|
use_cudnn_on_gpu: An optional `bool`. Defaults to `True`.
|
|
explicit_paddings: An optional list of `ints`. Defaults to `[]`.
|
|
If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
|
|
|
|
dimension, the amount of padding inserted before and after the dimension is
|
|
|
|
`explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
|
|
|
|
`padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1]`.
|
|
1-D tensor of length 4. The dilation factor for each dimension of
|
|
|
|
`input`. If set to k > 1, there will be k-1 skipped cells between each filter
|
|
|
|
element on that dimension. The dimension order is determined by the value of
|
|
|
|
`data_format`, see above for details. Dilations in the batch and depth
|
|
|
|
dimensions must be 1.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Conv2DBackpropInputV2", name, input, filter, out_backprop,
|
|
"strides", strides, "use_cudnn_on_gpu", use_cudnn_on_gpu, "padding",
|
|
padding, "explicit_paddings", explicit_paddings, "data_format",
|
|
data_format, "dilations", dilations)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
_result = _dispatcher_for_conv2d_backprop_input_v2(
|
|
(input, filter, out_backprop, strides, padding, use_cudnn_on_gpu,
|
|
explicit_paddings, data_format, dilations, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
return conv2d_backprop_input_v2_eager_fallback(
|
|
input, filter, out_backprop, strides=strides,
|
|
use_cudnn_on_gpu=use_cudnn_on_gpu, padding=padding,
|
|
explicit_paddings=explicit_paddings, data_format=data_format,
|
|
dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
conv2d_backprop_input_v2, (), dict(input=input, filter=filter,
|
|
out_backprop=out_backprop,
|
|
strides=strides,
|
|
padding=padding,
|
|
use_cudnn_on_gpu=use_cudnn_on_gpu,
|
|
explicit_paddings=explicit_paddings,
|
|
data_format=data_format,
|
|
dilations=dilations, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
else:
|
|
_result = _dispatcher_for_conv2d_backprop_input_v2(
|
|
(input, filter, out_backprop, strides, padding, use_cudnn_on_gpu,
|
|
explicit_paddings, data_format, dilations, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv2d_backprop_input_v2' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if use_cudnn_on_gpu is None:
|
|
use_cudnn_on_gpu = True
|
|
use_cudnn_on_gpu = _execute.make_bool(use_cudnn_on_gpu, "use_cudnn_on_gpu")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'conv2d_backprop_input_v2' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv2d_backprop_input_v2' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
try:
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Conv2DBackpropInputV2", input=input, filter=filter,
|
|
out_backprop=out_backprop, strides=strides,
|
|
padding=padding,
|
|
use_cudnn_on_gpu=use_cudnn_on_gpu,
|
|
explicit_paddings=explicit_paddings,
|
|
data_format=data_format, dilations=dilations,
|
|
name=name)
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
conv2d_backprop_input_v2, (), dict(input=input, filter=filter,
|
|
out_backprop=out_backprop,
|
|
strides=strides, padding=padding,
|
|
use_cudnn_on_gpu=use_cudnn_on_gpu,
|
|
explicit_paddings=explicit_paddings,
|
|
data_format=data_format,
|
|
dilations=dilations, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "use_cudnn_on_gpu",
|
|
_op._get_attr_bool("use_cudnn_on_gpu"), "padding",
|
|
_op.get_attr("padding"), "explicit_paddings",
|
|
_op.get_attr("explicit_paddings"), "data_format",
|
|
_op.get_attr("data_format"), "dilations",
|
|
_op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Conv2DBackpropInputV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Conv2DBackpropInputV2 = tf_export("raw_ops.Conv2DBackpropInputV2")(_ops.to_raw_op(conv2d_backprop_input_v2))
|
|
_dispatcher_for_conv2d_backprop_input_v2 = conv2d_backprop_input_v2._tf_type_based_dispatcher.Dispatch
|
|
|
|
|
|
def conv2d_backprop_input_v2_eager_fallback(input, filter, out_backprop, strides, padding, use_cudnn_on_gpu, explicit_paddings, data_format, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv2d_backprop_input_v2' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if use_cudnn_on_gpu is None:
|
|
use_cudnn_on_gpu = True
|
|
use_cudnn_on_gpu = _execute.make_bool(use_cudnn_on_gpu, "use_cudnn_on_gpu")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'conv2d_backprop_input_v2' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv2d_backprop_input_v2' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, filter, out_backprop], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, _dtypes.int32, ])
|
|
(input, filter, out_backprop) = _inputs_T
|
|
_inputs_flat = [input, filter, out_backprop]
|
|
_attrs = ("T", _attr_T, "strides", strides, "use_cudnn_on_gpu",
|
|
use_cudnn_on_gpu, "padding", padding, "explicit_paddings",
|
|
explicit_paddings, "data_format", data_format, "dilations", dilations)
|
|
_result = _execute.execute(b"Conv2DBackpropInputV2", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Conv2DBackpropInputV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def conv3d(input, filter, strides, padding, data_format="NDHWC", dilations=[1, 1, 1, 1, 1], name=None):
|
|
r"""Computes a 3-D convolution given 5-D `input` and `filter` tensors.
|
|
|
|
In signal processing, cross-correlation is a measure of similarity of
|
|
|
|
two waveforms as a function of a time-lag applied to one of them. This
|
|
|
|
is also known as a sliding dot product or sliding inner-product.
|
|
|
|
|
|
|
|
Our Conv3D implements a form of cross-correlation.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
Shape `[batch, in_depth, in_height, in_width, in_channels]`.
|
|
filter: A `Tensor`. Must have the same type as `input`.
|
|
Shape `[filter_depth, filter_height, filter_width, in_channels,
|
|
|
|
out_channels]`. `in_channels` must match between `input` and `filter`.
|
|
strides: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The stride of the sliding window for each
|
|
|
|
dimension of `input`. Must have `strides[0] = strides[4] = 1`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`.
|
|
The data format of the input and output data. With the
|
|
|
|
default format "NDHWC", the data is stored in the order of:
|
|
|
|
[batch, in_depth, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCDHW", the data storage order is:
|
|
|
|
[batch, in_channels, in_depth, in_height, in_width].
|
|
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1, 1]`.
|
|
1-D tensor of length 5. The dilation factor for each dimension of
|
|
|
|
`input`. If set to k > 1, there will be k-1 skipped cells between each
|
|
|
|
filter element on that dimension. The dimension order is determined by the
|
|
|
|
value of `data_format`, see above for details. Dilations in the batch and
|
|
|
|
depth dimensions must be 1.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Conv3D", name, input, filter, "strides", strides, "padding",
|
|
padding, "data_format", data_format, "dilations", dilations)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return conv3d_eager_fallback(
|
|
input, filter, strides=strides, padding=padding,
|
|
data_format=data_format, dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv3d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv3d' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Conv3D", input=input, filter=filter, strides=strides,
|
|
padding=padding, data_format=data_format,
|
|
dilations=dilations, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"data_format", _op.get_attr("data_format"), "dilations",
|
|
_op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Conv3D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Conv3D = tf_export("raw_ops.Conv3D")(_ops.to_raw_op(conv3d))
|
|
|
|
|
|
def conv3d_eager_fallback(input, filter, strides, padding, data_format, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv3d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv3d' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, filter], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
(input, filter) = _inputs_T
|
|
_inputs_flat = [input, filter]
|
|
_attrs = ("T", _attr_T, "strides", strides, "padding", padding,
|
|
"data_format", data_format, "dilations", dilations)
|
|
_result = _execute.execute(b"Conv3D", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Conv3D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def conv3d_backprop_filter(input, filter, out_backprop, strides, padding, dilations=[1, 1, 1, 1, 1], name=None):
|
|
r"""Computes the gradients of 3-D convolution with respect to the filter.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`.
|
|
Shape `[batch, depth, rows, cols, in_channels]`.
|
|
filter: A `Tensor`. Must have the same type as `input`.
|
|
Shape `[depth, rows, cols, in_channels, out_channels]`.
|
|
|
|
`in_channels` must match between `input` and `filter`.
|
|
out_backprop: A `Tensor`. Must have the same type as `input`.
|
|
Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
|
|
|
|
out_channels]`.
|
|
strides: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The stride of the sliding window for each
|
|
|
|
dimension of `input`. Must have `strides[0] = strides[4] = 1`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1, 1]`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Conv3DBackpropFilter", name, input, filter, out_backprop,
|
|
"strides", strides, "padding", padding, "dilations", dilations)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return conv3d_backprop_filter_eager_fallback(
|
|
input, filter, out_backprop, strides=strides, padding=padding,
|
|
dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv3d_backprop_filter' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv3d_backprop_filter' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Conv3DBackpropFilter", input=input, filter=filter,
|
|
out_backprop=out_backprop, strides=strides,
|
|
padding=padding, dilations=dilations,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Conv3DBackpropFilter", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Conv3DBackpropFilter = tf_export("raw_ops.Conv3DBackpropFilter")(_ops.to_raw_op(conv3d_backprop_filter))
|
|
|
|
|
|
def conv3d_backprop_filter_eager_fallback(input, filter, out_backprop, strides, padding, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv3d_backprop_filter' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv3d_backprop_filter' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, filter, out_backprop], ctx, [_dtypes.half, _dtypes.float32, _dtypes.float64, ])
|
|
(input, filter, out_backprop) = _inputs_T
|
|
_inputs_flat = [input, filter, out_backprop]
|
|
_attrs = ("T", _attr_T, "strides", strides, "padding", padding, "dilations",
|
|
dilations)
|
|
_result = _execute.execute(b"Conv3DBackpropFilter", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Conv3DBackpropFilter", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
@_dispatch.add_fallback_dispatch_list
|
|
@_dispatch.add_type_based_api_dispatcher
|
|
@tf_export(v1=['nn.conv3d_backprop_filter', 'nn.conv3d_backprop_filter_v2'])
|
|
@deprecated_endpoints('nn.conv3d_backprop_filter', 'nn.conv3d_backprop_filter_v2')
|
|
def conv3d_backprop_filter_v2(input, filter_sizes, out_backprop, strides, padding, data_format="NDHWC", dilations=[1, 1, 1, 1, 1], name=None):
|
|
r"""Computes the gradients of 3-D convolution with respect to the filter.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
Shape `[batch, depth, rows, cols, in_channels]`.
|
|
filter_sizes: A `Tensor` of type `int32`.
|
|
An integer vector representing the tensor shape of `filter`,
|
|
|
|
where `filter` is a 5-D
|
|
|
|
`[filter_depth, filter_height, filter_width, in_channels, out_channels]`
|
|
|
|
tensor.
|
|
out_backprop: A `Tensor`. Must have the same type as `input`.
|
|
Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
|
|
|
|
out_channels]`.
|
|
strides: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The stride of the sliding window for each
|
|
|
|
dimension of `input`. Must have `strides[0] = strides[4] = 1`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`.
|
|
The data format of the input and output data. With the
|
|
|
|
default format "NDHWC", the data is stored in the order of:
|
|
|
|
[batch, in_depth, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCDHW", the data storage order is:
|
|
|
|
[batch, in_channels, in_depth, in_height, in_width].
|
|
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1, 1]`.
|
|
1-D tensor of length 5. The dilation factor for each dimension of
|
|
|
|
`input`. If set to k > 1, there will be k-1 skipped cells between each
|
|
|
|
filter element on that dimension. The dimension order is determined by the
|
|
|
|
value of `data_format`, see above for details. Dilations in the batch and
|
|
|
|
depth dimensions must be 1.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Conv3DBackpropFilterV2", name, input, filter_sizes,
|
|
out_backprop, "strides", strides, "padding", padding, "data_format",
|
|
data_format, "dilations", dilations)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
_result = _dispatcher_for_conv3d_backprop_filter_v2(
|
|
(input, filter_sizes, out_backprop, strides, padding, data_format,
|
|
dilations, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
return conv3d_backprop_filter_v2_eager_fallback(
|
|
input, filter_sizes, out_backprop, strides=strides, padding=padding,
|
|
data_format=data_format, dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
conv3d_backprop_filter_v2, (), dict(input=input,
|
|
filter_sizes=filter_sizes,
|
|
out_backprop=out_backprop,
|
|
strides=strides,
|
|
padding=padding,
|
|
data_format=data_format,
|
|
dilations=dilations,
|
|
name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
else:
|
|
_result = _dispatcher_for_conv3d_backprop_filter_v2(
|
|
(input, filter_sizes, out_backprop, strides, padding, data_format,
|
|
dilations, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv3d_backprop_filter_v2' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv3d_backprop_filter_v2' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
try:
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Conv3DBackpropFilterV2", input=input, filter_sizes=filter_sizes,
|
|
out_backprop=out_backprop, strides=strides,
|
|
padding=padding, data_format=data_format,
|
|
dilations=dilations, name=name)
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
conv3d_backprop_filter_v2, (), dict(input=input,
|
|
filter_sizes=filter_sizes,
|
|
out_backprop=out_backprop,
|
|
strides=strides,
|
|
padding=padding,
|
|
data_format=data_format,
|
|
dilations=dilations, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"data_format", _op.get_attr("data_format"), "dilations",
|
|
_op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Conv3DBackpropFilterV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Conv3DBackpropFilterV2 = tf_export("raw_ops.Conv3DBackpropFilterV2")(_ops.to_raw_op(conv3d_backprop_filter_v2))
|
|
_dispatcher_for_conv3d_backprop_filter_v2 = conv3d_backprop_filter_v2._tf_type_based_dispatcher.Dispatch
|
|
|
|
|
|
def conv3d_backprop_filter_v2_eager_fallback(input, filter_sizes, out_backprop, strides, padding, data_format, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv3d_backprop_filter_v2' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv3d_backprop_filter_v2' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, out_backprop], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
(input, out_backprop) = _inputs_T
|
|
filter_sizes = _ops.convert_to_tensor(filter_sizes, _dtypes.int32)
|
|
_inputs_flat = [input, filter_sizes, out_backprop]
|
|
_attrs = ("T", _attr_T, "strides", strides, "padding", padding,
|
|
"data_format", data_format, "dilations", dilations)
|
|
_result = _execute.execute(b"Conv3DBackpropFilterV2", 1,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Conv3DBackpropFilterV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def conv3d_backprop_input(input, filter, out_backprop, strides, padding, dilations=[1, 1, 1, 1, 1], name=None):
|
|
r"""Computes the gradients of 3-D convolution with respect to the input.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`.
|
|
Shape `[batch, depth, rows, cols, in_channels]`.
|
|
filter: A `Tensor`. Must have the same type as `input`.
|
|
Shape `[depth, rows, cols, in_channels, out_channels]`.
|
|
|
|
`in_channels` must match between `input` and `filter`.
|
|
out_backprop: A `Tensor`. Must have the same type as `input`.
|
|
Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
|
|
|
|
out_channels]`.
|
|
strides: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The stride of the sliding window for each
|
|
|
|
dimension of `input`. Must have `strides[0] = strides[4] = 1`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1, 1]`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Conv3DBackpropInput", name, input, filter, out_backprop,
|
|
"strides", strides, "padding", padding, "dilations", dilations)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return conv3d_backprop_input_eager_fallback(
|
|
input, filter, out_backprop, strides=strides, padding=padding,
|
|
dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv3d_backprop_input' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv3d_backprop_input' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Conv3DBackpropInput", input=input, filter=filter,
|
|
out_backprop=out_backprop, strides=strides,
|
|
padding=padding, dilations=dilations,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Conv3DBackpropInput", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Conv3DBackpropInput = tf_export("raw_ops.Conv3DBackpropInput")(_ops.to_raw_op(conv3d_backprop_input))
|
|
|
|
|
|
def conv3d_backprop_input_eager_fallback(input, filter, out_backprop, strides, padding, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv3d_backprop_input' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv3d_backprop_input' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, filter, out_backprop], ctx, [_dtypes.half, _dtypes.float32, _dtypes.float64, ])
|
|
(input, filter, out_backprop) = _inputs_T
|
|
_inputs_flat = [input, filter, out_backprop]
|
|
_attrs = ("T", _attr_T, "strides", strides, "padding", padding, "dilations",
|
|
dilations)
|
|
_result = _execute.execute(b"Conv3DBackpropInput", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Conv3DBackpropInput", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def conv3d_backprop_input_v2(input_sizes, filter, out_backprop, strides, padding, data_format="NDHWC", dilations=[1, 1, 1, 1, 1], name=None):
|
|
r"""Computes the gradients of 3-D convolution with respect to the input.
|
|
|
|
Args:
|
|
input_sizes: A `Tensor`. Must be one of the following types: `int32`, `int64`.
|
|
An integer vector representing the tensor shape of `input`,
|
|
|
|
where `input` is a 5-D
|
|
|
|
`[batch, depth, rows, cols, in_channels]` tensor.
|
|
filter: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
Shape `[depth, rows, cols, in_channels, out_channels]`.
|
|
|
|
`in_channels` must match between `input` and `filter`.
|
|
out_backprop: A `Tensor`. Must have the same type as `filter`.
|
|
Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
|
|
|
|
out_channels]`.
|
|
strides: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The stride of the sliding window for each
|
|
|
|
dimension of `input`. Must have `strides[0] = strides[4] = 1`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`.
|
|
The data format of the input and output data. With the
|
|
|
|
default format "NDHWC", the data is stored in the order of:
|
|
|
|
[batch, in_depth, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCDHW", the data storage order is:
|
|
|
|
[batch, in_channels, in_depth, in_height, in_width].
|
|
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1, 1]`.
|
|
1-D tensor of length 5. The dilation factor for each dimension of
|
|
|
|
`input`. If set to k > 1, there will be k-1 skipped cells between each
|
|
|
|
filter element on that dimension. The dimension order is determined by the
|
|
|
|
value of `data_format`, see above for details. Dilations in the batch and
|
|
|
|
depth dimensions must be 1.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `filter`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Conv3DBackpropInputV2", name, input_sizes, filter,
|
|
out_backprop, "strides", strides, "padding", padding, "data_format",
|
|
data_format, "dilations", dilations)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return conv3d_backprop_input_v2_eager_fallback(
|
|
input_sizes, filter, out_backprop, strides=strides, padding=padding,
|
|
data_format=data_format, dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv3d_backprop_input_v2' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv3d_backprop_input_v2' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Conv3DBackpropInputV2", input_sizes=input_sizes, filter=filter,
|
|
out_backprop=out_backprop, strides=strides,
|
|
padding=padding, data_format=data_format,
|
|
dilations=dilations, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"data_format", _op.get_attr("data_format"), "dilations",
|
|
_op.get_attr("dilations"), "Tshape",
|
|
_op._get_attr_type("Tshape"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Conv3DBackpropInputV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Conv3DBackpropInputV2 = tf_export("raw_ops.Conv3DBackpropInputV2")(_ops.to_raw_op(conv3d_backprop_input_v2))
|
|
|
|
|
|
def conv3d_backprop_input_v2_eager_fallback(input_sizes, filter, out_backprop, strides, padding, data_format, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'conv3d_backprop_input_v2' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'conv3d_backprop_input_v2' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([filter, out_backprop], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
(filter, out_backprop) = _inputs_T
|
|
_attr_Tshape, (input_sizes,) = _execute.args_to_matching_eager([input_sizes], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int32)
|
|
_inputs_flat = [input_sizes, filter, out_backprop]
|
|
_attrs = ("T", _attr_T, "strides", strides, "padding", padding,
|
|
"data_format", data_format, "dilations", dilations, "Tshape", _attr_Tshape)
|
|
_result = _execute.execute(b"Conv3DBackpropInputV2", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Conv3DBackpropInputV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def data_format_dim_map(x, src_format="NHWC", dst_format="NCHW", name=None):
|
|
r"""Returns the dimension index in the destination data format given the one in
|
|
|
|
the source data format.
|
|
|
|
Args:
|
|
x: A `Tensor`. Must be one of the following types: `int32`, `int64`.
|
|
A Tensor with each element as a dimension index in source data format.
|
|
|
|
Must be in the range [-4, 4).
|
|
src_format: An optional `string`. Defaults to `"NHWC"`.
|
|
source data format.
|
|
dst_format: An optional `string`. Defaults to `"NCHW"`.
|
|
destination data format.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `x`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "DataFormatDimMap", name, x, "src_format", src_format,
|
|
"dst_format", dst_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return data_format_dim_map_eager_fallback(
|
|
x, src_format=src_format, dst_format=dst_format, name=name,
|
|
ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if src_format is None:
|
|
src_format = "NHWC"
|
|
src_format = _execute.make_str(src_format, "src_format")
|
|
if dst_format is None:
|
|
dst_format = "NCHW"
|
|
dst_format = _execute.make_str(dst_format, "dst_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"DataFormatDimMap", x=x, src_format=src_format, dst_format=dst_format,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "src_format",
|
|
_op.get_attr("src_format"), "dst_format",
|
|
_op.get_attr("dst_format"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"DataFormatDimMap", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
DataFormatDimMap = tf_export("raw_ops.DataFormatDimMap")(_ops.to_raw_op(data_format_dim_map))
|
|
|
|
|
|
def data_format_dim_map_eager_fallback(x, src_format, dst_format, name, ctx):
|
|
if src_format is None:
|
|
src_format = "NHWC"
|
|
src_format = _execute.make_str(src_format, "src_format")
|
|
if dst_format is None:
|
|
dst_format = "NCHW"
|
|
dst_format = _execute.make_str(dst_format, "dst_format")
|
|
_attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int32)
|
|
_inputs_flat = [x]
|
|
_attrs = ("T", _attr_T, "src_format", src_format, "dst_format", dst_format)
|
|
_result = _execute.execute(b"DataFormatDimMap", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"DataFormatDimMap", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def data_format_vec_permute(x, src_format="NHWC", dst_format="NCHW", name=None):
|
|
r"""Permute input tensor from `src_format` to `dst_format`.
|
|
|
|
Given source and destination format strings of length n=4 or 5, the input
|
|
|
|
tensor must be a vector of size n or n-2, or a 2D tensor of shape
|
|
|
|
(n, 2) or (n-2, 2).
|
|
|
|
|
|
|
|
If the first dimension of the input tensor is n-2, it is assumed that
|
|
|
|
non-spatial dimensions are omitted (i.e `N`, `C`).
|
|
|
|
|
|
|
|
For example, with `src_format` of `NHWC`, `dst_format` of `NCHW`, and input:
|
|
|
|
```
|
|
|
|
[1, 2, 3, 4]
|
|
|
|
```
|
|
|
|
, the output will be:
|
|
|
|
```
|
|
|
|
[1, 4, 2, 3]
|
|
|
|
```
|
|
|
|
With `src_format` of `NDHWC`, `dst_format` of `NCDHW`, and input:
|
|
|
|
```
|
|
|
|
[[1, 6], [2, 7], [3, 8], [4, 9], [5, 10]]
|
|
|
|
```
|
|
|
|
, the output will be:
|
|
|
|
```
|
|
|
|
[[1, 6], [5, 10], [2, 7], [3, 8], [4, 9]]
|
|
|
|
```
|
|
|
|
With `src_format` of `NHWC`, `dst_format` of `NCHW`, and input:
|
|
|
|
```
|
|
|
|
[1, 2]
|
|
|
|
```
|
|
|
|
, the output will be:
|
|
|
|
```
|
|
|
|
[1, 2]
|
|
|
|
```
|
|
|
|
Args:
|
|
x: A `Tensor`. Must be one of the following types: `int32`, `int64`.
|
|
Tensor of rank 1 or 2 in source data format.
|
|
src_format: An optional `string`. Defaults to `"NHWC"`.
|
|
source data format.
|
|
dst_format: An optional `string`. Defaults to `"NCHW"`.
|
|
destination data format.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `x`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "DataFormatVecPermute", name, x, "src_format", src_format,
|
|
"dst_format", dst_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return data_format_vec_permute_eager_fallback(
|
|
x, src_format=src_format, dst_format=dst_format, name=name,
|
|
ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if src_format is None:
|
|
src_format = "NHWC"
|
|
src_format = _execute.make_str(src_format, "src_format")
|
|
if dst_format is None:
|
|
dst_format = "NCHW"
|
|
dst_format = _execute.make_str(dst_format, "dst_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"DataFormatVecPermute", x=x, src_format=src_format,
|
|
dst_format=dst_format, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "src_format",
|
|
_op.get_attr("src_format"), "dst_format",
|
|
_op.get_attr("dst_format"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"DataFormatVecPermute", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
DataFormatVecPermute = tf_export("raw_ops.DataFormatVecPermute")(_ops.to_raw_op(data_format_vec_permute))
|
|
|
|
|
|
def data_format_vec_permute_eager_fallback(x, src_format, dst_format, name, ctx):
|
|
if src_format is None:
|
|
src_format = "NHWC"
|
|
src_format = _execute.make_str(src_format, "src_format")
|
|
if dst_format is None:
|
|
dst_format = "NCHW"
|
|
dst_format = _execute.make_str(dst_format, "dst_format")
|
|
_attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int32)
|
|
_inputs_flat = [x]
|
|
_attrs = ("T", _attr_T, "src_format", src_format, "dst_format", dst_format)
|
|
_result = _execute.execute(b"DataFormatVecPermute", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"DataFormatVecPermute", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def depthwise_conv2d_native(input, filter, strides, padding, explicit_paddings=[], data_format="NHWC", dilations=[1, 1, 1, 1], name=None):
|
|
r"""Computes a 2-D depthwise convolution given 4-D `input` and `filter` tensors.
|
|
|
|
Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
|
|
|
|
and a filter / kernel tensor of shape
|
|
|
|
`[filter_height, filter_width, in_channels, channel_multiplier]`, containing
|
|
|
|
`in_channels` convolutional filters of depth 1, `depthwise_conv2d` applies
|
|
|
|
a different filter to each input channel (expanding from 1 channel to
|
|
|
|
`channel_multiplier` channels for each), then concatenates the results
|
|
|
|
together. Thus, the output has `in_channels * channel_multiplier` channels.
|
|
|
|
|
|
|
|
```
|
|
|
|
for k in 0..in_channels-1
|
|
|
|
for q in 0..channel_multiplier-1
|
|
|
|
output[b, i, j, k * channel_multiplier + q] =
|
|
|
|
sum_{di, dj} input[b, strides[1] * i + di, strides[2] * j + dj, k] *
|
|
|
|
filter[di, dj, k, q]
|
|
|
|
```
|
|
|
|
|
|
|
|
Must have `strides[0] = strides[3] = 1`. For the most common case of the same
|
|
|
|
horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
filter: A `Tensor`. Must have the same type as `input`.
|
|
strides: A list of `ints`.
|
|
1-D of length 4. The stride of the sliding window for each dimension
|
|
|
|
of `input`.
|
|
padding: A `string` from: `"SAME", "VALID", "EXPLICIT"`.
|
|
The type of padding algorithm to use.
|
|
explicit_paddings: An optional list of `ints`. Defaults to `[]`.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, height, width, channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, channels, height, width].
|
|
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1]`.
|
|
1-D tensor of length 4. The dilation factor for each dimension of
|
|
|
|
`input`. If set to k > 1, there will be k-1 skipped cells between each filter
|
|
|
|
element on that dimension. The dimension order is determined by the value of
|
|
|
|
`data_format`, see above for details. Dilations in the batch and depth
|
|
|
|
dimensions must be 1.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "DepthwiseConv2dNative", name, input, filter, "strides",
|
|
strides, "padding", padding, "explicit_paddings", explicit_paddings,
|
|
"data_format", data_format, "dilations", dilations)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return depthwise_conv2d_native_eager_fallback(
|
|
input, filter, strides=strides, padding=padding,
|
|
explicit_paddings=explicit_paddings, data_format=data_format,
|
|
dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'depthwise_conv2d_native' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'depthwise_conv2d_native' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'depthwise_conv2d_native' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"DepthwiseConv2dNative", input=input, filter=filter, strides=strides,
|
|
padding=padding,
|
|
explicit_paddings=explicit_paddings,
|
|
data_format=data_format, dilations=dilations,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"explicit_paddings", _op.get_attr("explicit_paddings"),
|
|
"data_format", _op.get_attr("data_format"), "dilations",
|
|
_op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"DepthwiseConv2dNative", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
DepthwiseConv2dNative = tf_export("raw_ops.DepthwiseConv2dNative")(_ops.to_raw_op(depthwise_conv2d_native))
|
|
|
|
|
|
def depthwise_conv2d_native_eager_fallback(input, filter, strides, padding, explicit_paddings, data_format, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'depthwise_conv2d_native' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'depthwise_conv2d_native' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'depthwise_conv2d_native' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, filter], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
(input, filter) = _inputs_T
|
|
_inputs_flat = [input, filter]
|
|
_attrs = ("T", _attr_T, "strides", strides, "padding", padding,
|
|
"explicit_paddings", explicit_paddings, "data_format", data_format,
|
|
"dilations", dilations)
|
|
_result = _execute.execute(b"DepthwiseConv2dNative", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"DepthwiseConv2dNative", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def depthwise_conv2d_native_backprop_filter(input, filter_sizes, out_backprop, strides, padding, explicit_paddings=[], data_format="NHWC", dilations=[1, 1, 1, 1], name=None):
|
|
r"""Computes the gradients of depthwise convolution with respect to the filter.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
4-D with shape based on `data_format`. For example, if
|
|
|
|
`data_format` is 'NHWC' then `input` is a 4-D `[batch, in_height,
|
|
|
|
in_width, in_channels]` tensor.
|
|
filter_sizes: A `Tensor` of type `int32`.
|
|
An integer vector representing the tensor shape of `filter`,
|
|
|
|
where `filter` is a 4-D
|
|
|
|
`[filter_height, filter_width, in_channels, depthwise_multiplier]` tensor.
|
|
out_backprop: A `Tensor`. Must have the same type as `input`.
|
|
4-D with shape based on `data_format`.
|
|
|
|
For example, if `data_format` is 'NHWC' then
|
|
|
|
out_backprop shape is `[batch, out_height, out_width, out_channels]`.
|
|
|
|
Gradients w.r.t. the output of the convolution.
|
|
strides: A list of `ints`.
|
|
The stride of the sliding window for each dimension of the input
|
|
|
|
of the convolution.
|
|
padding: A `string` from: `"SAME", "VALID", "EXPLICIT"`.
|
|
The type of padding algorithm to use.
|
|
explicit_paddings: An optional list of `ints`. Defaults to `[]`.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, height, width, channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, channels, height, width].
|
|
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1]`.
|
|
1-D tensor of length 4. The dilation factor for each dimension of
|
|
|
|
`input`. If set to k > 1, there will be k-1 skipped cells between each filter
|
|
|
|
element on that dimension. The dimension order is determined by the value of
|
|
|
|
`data_format`, see above for details. Dilations in the batch and depth
|
|
|
|
dimensions must be 1.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "DepthwiseConv2dNativeBackpropFilter", name, input,
|
|
filter_sizes, out_backprop, "strides", strides, "padding", padding,
|
|
"explicit_paddings", explicit_paddings, "data_format", data_format,
|
|
"dilations", dilations)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return depthwise_conv2d_native_backprop_filter_eager_fallback(
|
|
input, filter_sizes, out_backprop, strides=strides, padding=padding,
|
|
explicit_paddings=explicit_paddings, data_format=data_format,
|
|
dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'depthwise_conv2d_native_backprop_filter' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'depthwise_conv2d_native_backprop_filter' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'depthwise_conv2d_native_backprop_filter' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"DepthwiseConv2dNativeBackpropFilter", input=input,
|
|
filter_sizes=filter_sizes,
|
|
out_backprop=out_backprop,
|
|
strides=strides,
|
|
padding=padding,
|
|
explicit_paddings=explicit_paddings,
|
|
data_format=data_format,
|
|
dilations=dilations, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"explicit_paddings", _op.get_attr("explicit_paddings"),
|
|
"data_format", _op.get_attr("data_format"), "dilations",
|
|
_op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"DepthwiseConv2dNativeBackpropFilter", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
DepthwiseConv2dNativeBackpropFilter = tf_export("raw_ops.DepthwiseConv2dNativeBackpropFilter")(_ops.to_raw_op(depthwise_conv2d_native_backprop_filter))
|
|
|
|
|
|
def depthwise_conv2d_native_backprop_filter_eager_fallback(input, filter_sizes, out_backprop, strides, padding, explicit_paddings, data_format, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'depthwise_conv2d_native_backprop_filter' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'depthwise_conv2d_native_backprop_filter' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'depthwise_conv2d_native_backprop_filter' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, out_backprop], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
(input, out_backprop) = _inputs_T
|
|
filter_sizes = _ops.convert_to_tensor(filter_sizes, _dtypes.int32)
|
|
_inputs_flat = [input, filter_sizes, out_backprop]
|
|
_attrs = ("T", _attr_T, "strides", strides, "padding", padding,
|
|
"explicit_paddings", explicit_paddings, "data_format", data_format,
|
|
"dilations", dilations)
|
|
_result = _execute.execute(b"DepthwiseConv2dNativeBackpropFilter", 1,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"DepthwiseConv2dNativeBackpropFilter", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def depthwise_conv2d_native_backprop_input(input_sizes, filter, out_backprop, strides, padding, explicit_paddings=[], data_format="NHWC", dilations=[1, 1, 1, 1], name=None):
|
|
r"""Computes the gradients of depthwise convolution with respect to the input.
|
|
|
|
Args:
|
|
input_sizes: A `Tensor` of type `int32`.
|
|
An integer vector representing the shape of `input`, based
|
|
|
|
on `data_format`. For example, if `data_format` is 'NHWC' then
|
|
|
|
`input` is a 4-D `[batch, height, width, channels]` tensor.
|
|
filter: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
4-D with shape
|
|
|
|
`[filter_height, filter_width, in_channels, depthwise_multiplier]`.
|
|
out_backprop: A `Tensor`. Must have the same type as `filter`.
|
|
4-D with shape based on `data_format`.
|
|
|
|
For example, if `data_format` is 'NHWC' then
|
|
|
|
out_backprop shape is `[batch, out_height, out_width, out_channels]`.
|
|
|
|
Gradients w.r.t. the output of the convolution.
|
|
strides: A list of `ints`.
|
|
The stride of the sliding window for each dimension of the input
|
|
|
|
of the convolution.
|
|
padding: A `string` from: `"SAME", "VALID", "EXPLICIT"`.
|
|
The type of padding algorithm to use.
|
|
explicit_paddings: An optional list of `ints`. Defaults to `[]`.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, height, width, channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, channels, height, width].
|
|
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1]`.
|
|
1-D tensor of length 4. The dilation factor for each dimension of
|
|
|
|
`input`. If set to k > 1, there will be k-1 skipped cells between each filter
|
|
|
|
element on that dimension. The dimension order is determined by the value of
|
|
|
|
`data_format`, see above for details. Dilations in the batch and depth
|
|
|
|
dimensions must be 1.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `filter`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "DepthwiseConv2dNativeBackpropInput", name, input_sizes, filter,
|
|
out_backprop, "strides", strides, "padding", padding,
|
|
"explicit_paddings", explicit_paddings, "data_format", data_format,
|
|
"dilations", dilations)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return depthwise_conv2d_native_backprop_input_eager_fallback(
|
|
input_sizes, filter, out_backprop, strides=strides, padding=padding,
|
|
explicit_paddings=explicit_paddings, data_format=data_format,
|
|
dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'depthwise_conv2d_native_backprop_input' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'depthwise_conv2d_native_backprop_input' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'depthwise_conv2d_native_backprop_input' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"DepthwiseConv2dNativeBackpropInput", input_sizes=input_sizes,
|
|
filter=filter,
|
|
out_backprop=out_backprop,
|
|
strides=strides,
|
|
padding=padding,
|
|
explicit_paddings=explicit_paddings,
|
|
data_format=data_format,
|
|
dilations=dilations, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"explicit_paddings", _op.get_attr("explicit_paddings"),
|
|
"data_format", _op.get_attr("data_format"), "dilations",
|
|
_op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"DepthwiseConv2dNativeBackpropInput", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
DepthwiseConv2dNativeBackpropInput = tf_export("raw_ops.DepthwiseConv2dNativeBackpropInput")(_ops.to_raw_op(depthwise_conv2d_native_backprop_input))
|
|
|
|
|
|
def depthwise_conv2d_native_backprop_input_eager_fallback(input_sizes, filter, out_backprop, strides, padding, explicit_paddings, data_format, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'depthwise_conv2d_native_backprop_input' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'depthwise_conv2d_native_backprop_input' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'depthwise_conv2d_native_backprop_input' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([filter, out_backprop], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
(filter, out_backprop) = _inputs_T
|
|
input_sizes = _ops.convert_to_tensor(input_sizes, _dtypes.int32)
|
|
_inputs_flat = [input_sizes, filter, out_backprop]
|
|
_attrs = ("T", _attr_T, "strides", strides, "padding", padding,
|
|
"explicit_paddings", explicit_paddings, "data_format", data_format,
|
|
"dilations", dilations)
|
|
_result = _execute.execute(b"DepthwiseConv2dNativeBackpropInput", 1,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"DepthwiseConv2dNativeBackpropInput", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def dilation2d(input, filter, strides, rates, padding, name=None):
|
|
r"""Computes the grayscale dilation of 4-D `input` and 3-D `filter` tensors.
|
|
|
|
The `input` tensor has shape `[batch, in_height, in_width, depth]` and the
|
|
|
|
`filter` tensor has shape `[filter_height, filter_width, depth]`, i.e., each
|
|
|
|
input channel is processed independently of the others with its own structuring
|
|
|
|
function. The `output` tensor has shape
|
|
|
|
`[batch, out_height, out_width, depth]`. The spatial dimensions of the output
|
|
|
|
tensor depend on the `padding` algorithm. We currently only support the default
|
|
|
|
"NHWC" `data_format`.
|
|
|
|
|
|
|
|
In detail, the grayscale morphological 2-D dilation is the max-sum correlation
|
|
|
|
(for consistency with `conv2d`, we use unmirrored filters):
|
|
|
|
|
|
|
|
output[b, y, x, c] =
|
|
|
|
max_{dy, dx} input[b,
|
|
|
|
strides[1] * y + rates[1] * dy,
|
|
|
|
strides[2] * x + rates[2] * dx,
|
|
|
|
c] +
|
|
|
|
filter[dy, dx, c]
|
|
|
|
|
|
|
|
Max-pooling is a special case when the filter has size equal to the pooling
|
|
|
|
kernel size and contains all zeros.
|
|
|
|
|
|
|
|
Note on duality: The dilation of `input` by the `filter` is equal to the
|
|
|
|
negation of the erosion of `-input` by the reflected `filter`.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
4-D with shape `[batch, in_height, in_width, depth]`.
|
|
filter: A `Tensor`. Must have the same type as `input`.
|
|
3-D with shape `[filter_height, filter_width, depth]`.
|
|
strides: A list of `ints` that has length `>= 4`.
|
|
The stride of the sliding window for each dimension of the input
|
|
|
|
tensor. Must be: `[1, stride_height, stride_width, 1]`.
|
|
rates: A list of `ints` that has length `>= 4`.
|
|
The input stride for atrous morphological dilation. Must be:
|
|
|
|
`[1, rate_height, rate_width, 1]`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Dilation2D", name, input, filter, "strides", strides, "rates",
|
|
rates, "padding", padding)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return dilation2d_eager_fallback(
|
|
input, filter, strides=strides, rates=rates, padding=padding,
|
|
name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'dilation2d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
if not isinstance(rates, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'rates' argument to "
|
|
"'dilation2d' Op, not %r." % rates)
|
|
rates = [_execute.make_int(_i, "rates") for _i in rates]
|
|
padding = _execute.make_str(padding, "padding")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Dilation2D", input=input, filter=filter, strides=strides,
|
|
rates=rates, padding=padding, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "rates", _op.get_attr("rates"),
|
|
"padding", _op.get_attr("padding"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Dilation2D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Dilation2D = tf_export("raw_ops.Dilation2D")(_ops.to_raw_op(dilation2d))
|
|
|
|
|
|
def dilation2d_eager_fallback(input, filter, strides, rates, padding, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'dilation2d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
if not isinstance(rates, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'rates' argument to "
|
|
"'dilation2d' Op, not %r." % rates)
|
|
rates = [_execute.make_int(_i, "rates") for _i in rates]
|
|
padding = _execute.make_str(padding, "padding")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, filter], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(input, filter) = _inputs_T
|
|
_inputs_flat = [input, filter]
|
|
_attrs = ("T", _attr_T, "strides", strides, "rates", rates, "padding",
|
|
padding)
|
|
_result = _execute.execute(b"Dilation2D", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Dilation2D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def dilation2d_backprop_filter(input, filter, out_backprop, strides, rates, padding, name=None):
|
|
r"""Computes the gradient of morphological 2-D dilation with respect to the filter.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
4-D with shape `[batch, in_height, in_width, depth]`.
|
|
filter: A `Tensor`. Must have the same type as `input`.
|
|
3-D with shape `[filter_height, filter_width, depth]`.
|
|
out_backprop: A `Tensor`. Must have the same type as `input`.
|
|
4-D with shape `[batch, out_height, out_width, depth]`.
|
|
strides: A list of `ints` that has length `>= 4`.
|
|
1-D of length 4. The stride of the sliding window for each dimension of
|
|
|
|
the input tensor. Must be: `[1, stride_height, stride_width, 1]`.
|
|
rates: A list of `ints` that has length `>= 4`.
|
|
1-D of length 4. The input stride for atrous morphological dilation.
|
|
|
|
Must be: `[1, rate_height, rate_width, 1]`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Dilation2DBackpropFilter", name, input, filter, out_backprop,
|
|
"strides", strides, "rates", rates, "padding", padding)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return dilation2d_backprop_filter_eager_fallback(
|
|
input, filter, out_backprop, strides=strides, rates=rates,
|
|
padding=padding, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'dilation2d_backprop_filter' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
if not isinstance(rates, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'rates' argument to "
|
|
"'dilation2d_backprop_filter' Op, not %r." % rates)
|
|
rates = [_execute.make_int(_i, "rates") for _i in rates]
|
|
padding = _execute.make_str(padding, "padding")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Dilation2DBackpropFilter", input=input, filter=filter,
|
|
out_backprop=out_backprop,
|
|
strides=strides, rates=rates,
|
|
padding=padding, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "rates", _op.get_attr("rates"),
|
|
"padding", _op.get_attr("padding"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Dilation2DBackpropFilter", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Dilation2DBackpropFilter = tf_export("raw_ops.Dilation2DBackpropFilter")(_ops.to_raw_op(dilation2d_backprop_filter))
|
|
|
|
|
|
def dilation2d_backprop_filter_eager_fallback(input, filter, out_backprop, strides, rates, padding, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'dilation2d_backprop_filter' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
if not isinstance(rates, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'rates' argument to "
|
|
"'dilation2d_backprop_filter' Op, not %r." % rates)
|
|
rates = [_execute.make_int(_i, "rates") for _i in rates]
|
|
padding = _execute.make_str(padding, "padding")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, filter, out_backprop], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(input, filter, out_backprop) = _inputs_T
|
|
_inputs_flat = [input, filter, out_backprop]
|
|
_attrs = ("T", _attr_T, "strides", strides, "rates", rates, "padding",
|
|
padding)
|
|
_result = _execute.execute(b"Dilation2DBackpropFilter", 1,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Dilation2DBackpropFilter", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def dilation2d_backprop_input(input, filter, out_backprop, strides, rates, padding, name=None):
|
|
r"""Computes the gradient of morphological 2-D dilation with respect to the input.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
4-D with shape `[batch, in_height, in_width, depth]`.
|
|
filter: A `Tensor`. Must have the same type as `input`.
|
|
3-D with shape `[filter_height, filter_width, depth]`.
|
|
out_backprop: A `Tensor`. Must have the same type as `input`.
|
|
4-D with shape `[batch, out_height, out_width, depth]`.
|
|
strides: A list of `ints` that has length `>= 4`.
|
|
1-D of length 4. The stride of the sliding window for each dimension of
|
|
|
|
the input tensor. Must be: `[1, stride_height, stride_width, 1]`.
|
|
rates: A list of `ints` that has length `>= 4`.
|
|
1-D of length 4. The input stride for atrous morphological dilation.
|
|
|
|
Must be: `[1, rate_height, rate_width, 1]`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Dilation2DBackpropInput", name, input, filter, out_backprop,
|
|
"strides", strides, "rates", rates, "padding", padding)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return dilation2d_backprop_input_eager_fallback(
|
|
input, filter, out_backprop, strides=strides, rates=rates,
|
|
padding=padding, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'dilation2d_backprop_input' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
if not isinstance(rates, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'rates' argument to "
|
|
"'dilation2d_backprop_input' Op, not %r." % rates)
|
|
rates = [_execute.make_int(_i, "rates") for _i in rates]
|
|
padding = _execute.make_str(padding, "padding")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Dilation2DBackpropInput", input=input, filter=filter,
|
|
out_backprop=out_backprop, strides=strides,
|
|
rates=rates, padding=padding, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "strides",
|
|
_op.get_attr("strides"), "rates", _op.get_attr("rates"),
|
|
"padding", _op.get_attr("padding"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Dilation2DBackpropInput", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Dilation2DBackpropInput = tf_export("raw_ops.Dilation2DBackpropInput")(_ops.to_raw_op(dilation2d_backprop_input))
|
|
|
|
|
|
def dilation2d_backprop_input_eager_fallback(input, filter, out_backprop, strides, rates, padding, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'dilation2d_backprop_input' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
if not isinstance(rates, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'rates' argument to "
|
|
"'dilation2d_backprop_input' Op, not %r." % rates)
|
|
rates = [_execute.make_int(_i, "rates") for _i in rates]
|
|
padding = _execute.make_str(padding, "padding")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, filter, out_backprop], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(input, filter, out_backprop) = _inputs_T
|
|
_inputs_flat = [input, filter, out_backprop]
|
|
_attrs = ("T", _attr_T, "strides", strides, "rates", rates, "padding",
|
|
padding)
|
|
_result = _execute.execute(b"Dilation2DBackpropInput", 1,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Dilation2DBackpropInput", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
@_dispatch.add_fallback_dispatch_list
|
|
@_dispatch.add_type_based_api_dispatcher
|
|
@tf_export('nn.elu')
|
|
def elu(features, name=None):
|
|
r"""Computes the exponential linear function.
|
|
|
|
The ELU function is defined as:
|
|
|
|
|
|
|
|
* $ e ^ x - 1 $ if $ x < 0 $
|
|
|
|
* $ x $ if $ x >= 0 $
|
|
|
|
|
|
|
|
Examples:
|
|
|
|
|
|
|
|
>>> tf.nn.elu(1.0)
|
|
|
|
<tf.Tensor: shape=(), dtype=float32, numpy=1.0>
|
|
|
|
>>> tf.nn.elu(0.0)
|
|
|
|
<tf.Tensor: shape=(), dtype=float32, numpy=0.0>
|
|
|
|
>>> tf.nn.elu(-1000.0)
|
|
|
|
<tf.Tensor: shape=(), dtype=float32, numpy=-1.0>
|
|
|
|
|
|
|
|
See [Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)
|
|
|
|
](http://arxiv.org/abs/1511.07289)
|
|
|
|
Args:
|
|
features: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `features`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Elu", name, features)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
_result = _dispatcher_for_elu(
|
|
(features, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
return elu_eager_fallback(
|
|
features, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
elu, (), dict(features=features, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
else:
|
|
_result = _dispatcher_for_elu(
|
|
(features, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
# Add nodes to the TensorFlow graph.
|
|
try:
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Elu", features=features, name=name)
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
elu, (), dict(features=features, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Elu", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Elu = tf_export("raw_ops.Elu")(_ops.to_raw_op(elu))
|
|
_dispatcher_for_elu = elu._tf_type_based_dispatcher.Dispatch
|
|
|
|
|
|
def elu_eager_fallback(features, name, ctx):
|
|
_attr_T, (features,) = _execute.args_to_matching_eager([features], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
_inputs_flat = [features]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"Elu", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Elu", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def elu_grad(gradients, outputs, name=None):
|
|
r"""Computes gradients for the exponential linear (Elu) operation.
|
|
|
|
Args:
|
|
gradients: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
The backpropagated gradients to the corresponding Elu operation.
|
|
outputs: A `Tensor`. Must have the same type as `gradients`.
|
|
The outputs of the corresponding Elu operation.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `gradients`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "EluGrad", name, gradients, outputs)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return elu_grad_eager_fallback(
|
|
gradients, outputs, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"EluGrad", gradients=gradients, outputs=outputs, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"EluGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
EluGrad = tf_export("raw_ops.EluGrad")(_ops.to_raw_op(elu_grad))
|
|
|
|
|
|
def elu_grad_eager_fallback(gradients, outputs, name, ctx):
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([gradients, outputs], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
(gradients, outputs) = _inputs_T
|
|
_inputs_flat = [gradients, outputs]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"EluGrad", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"EluGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
_FractionalAvgPoolOutput = collections.namedtuple(
|
|
"FractionalAvgPool",
|
|
["output", "row_pooling_sequence", "col_pooling_sequence"])
|
|
|
|
|
|
def fractional_avg_pool(value, pooling_ratio, pseudo_random=False, overlapping=False, deterministic=False, seed=0, seed2=0, name=None):
|
|
r"""Performs fractional average pooling on the input.
|
|
|
|
Fractional average pooling is similar to Fractional max pooling in the pooling
|
|
|
|
region generation step. The only difference is that after pooling regions are
|
|
|
|
generated, a mean operation is performed instead of a max operation in each
|
|
|
|
pooling region.
|
|
|
|
Args:
|
|
value: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `int64`.
|
|
4-D with shape `[batch, height, width, channels]`.
|
|
pooling_ratio: A list of `floats` that has length `>= 4`.
|
|
Pooling ratio for each dimension of `value`, currently only
|
|
|
|
supports row and col dimension and should be >= 1.0. For example, a valid
|
|
|
|
pooling ratio looks like [1.0, 1.44, 1.73, 1.0]. The first and last elements
|
|
|
|
must be 1.0 because we don't allow pooling on batch and channels
|
|
|
|
dimensions. 1.44 and 1.73 are pooling ratio on height and width dimensions
|
|
|
|
respectively.
|
|
pseudo_random: An optional `bool`. Defaults to `False`.
|
|
When set to True, generates the pooling sequence in a
|
|
|
|
pseudorandom fashion, otherwise, in a random fashion. Check paper [Benjamin
|
|
|
|
Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071) for
|
|
|
|
difference between pseudorandom and random.
|
|
overlapping: An optional `bool`. Defaults to `False`.
|
|
When set to True, it means when pooling, the values at the boundary
|
|
|
|
of adjacent pooling cells are used by both cells. For example:
|
|
|
|
|
|
|
|
`index 0 1 2 3 4`
|
|
|
|
|
|
|
|
`value 20 5 16 3 7`
|
|
|
|
|
|
|
|
If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
|
|
|
|
The result would be [41/3, 26/3] for fractional avg pooling.
|
|
deterministic: An optional `bool`. Defaults to `False`.
|
|
When set to True, a fixed pooling region will be used when
|
|
|
|
iterating over a FractionalAvgPool node in the computation graph. Mainly used
|
|
|
|
in unit test to make FractionalAvgPool deterministic.
|
|
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 tuple of `Tensor` objects (output, row_pooling_sequence, col_pooling_sequence).
|
|
|
|
output: A `Tensor`. Has the same type as `value`.
|
|
row_pooling_sequence: A `Tensor` of type `int64`.
|
|
col_pooling_sequence: A `Tensor` of type `int64`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "FractionalAvgPool", name, value, "pooling_ratio",
|
|
pooling_ratio, "pseudo_random", pseudo_random, "overlapping",
|
|
overlapping, "deterministic", deterministic, "seed", seed, "seed2",
|
|
seed2)
|
|
_result = _FractionalAvgPoolOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return fractional_avg_pool_eager_fallback(
|
|
value, pooling_ratio=pooling_ratio, pseudo_random=pseudo_random,
|
|
overlapping=overlapping, deterministic=deterministic, seed=seed,
|
|
seed2=seed2, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(pooling_ratio, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'pooling_ratio' argument to "
|
|
"'fractional_avg_pool' Op, not %r." % pooling_ratio)
|
|
pooling_ratio = [_execute.make_float(_f, "pooling_ratio") for _f in pooling_ratio]
|
|
if pseudo_random is None:
|
|
pseudo_random = False
|
|
pseudo_random = _execute.make_bool(pseudo_random, "pseudo_random")
|
|
if overlapping is None:
|
|
overlapping = False
|
|
overlapping = _execute.make_bool(overlapping, "overlapping")
|
|
if deterministic is None:
|
|
deterministic = False
|
|
deterministic = _execute.make_bool(deterministic, "deterministic")
|
|
if seed is None:
|
|
seed = 0
|
|
seed = _execute.make_int(seed, "seed")
|
|
if seed2 is None:
|
|
seed2 = 0
|
|
seed2 = _execute.make_int(seed2, "seed2")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"FractionalAvgPool", value=value, pooling_ratio=pooling_ratio,
|
|
pseudo_random=pseudo_random,
|
|
overlapping=overlapping,
|
|
deterministic=deterministic, seed=seed,
|
|
seed2=seed2, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("pooling_ratio", _op.get_attr("pooling_ratio"), "pseudo_random",
|
|
_op._get_attr_bool("pseudo_random"), "overlapping",
|
|
_op._get_attr_bool("overlapping"), "deterministic",
|
|
_op._get_attr_bool("deterministic"), "seed",
|
|
_op._get_attr_int("seed"), "seed2", _op._get_attr_int("seed2"),
|
|
"T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"FractionalAvgPool", _inputs_flat, _attrs, _result)
|
|
_result = _FractionalAvgPoolOutput._make(_result)
|
|
return _result
|
|
|
|
FractionalAvgPool = tf_export("raw_ops.FractionalAvgPool")(_ops.to_raw_op(fractional_avg_pool))
|
|
|
|
|
|
def fractional_avg_pool_eager_fallback(value, pooling_ratio, pseudo_random, overlapping, deterministic, seed, seed2, name, ctx):
|
|
if not isinstance(pooling_ratio, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'pooling_ratio' argument to "
|
|
"'fractional_avg_pool' Op, not %r." % pooling_ratio)
|
|
pooling_ratio = [_execute.make_float(_f, "pooling_ratio") for _f in pooling_ratio]
|
|
if pseudo_random is None:
|
|
pseudo_random = False
|
|
pseudo_random = _execute.make_bool(pseudo_random, "pseudo_random")
|
|
if overlapping is None:
|
|
overlapping = False
|
|
overlapping = _execute.make_bool(overlapping, "overlapping")
|
|
if deterministic is None:
|
|
deterministic = False
|
|
deterministic = _execute.make_bool(deterministic, "deterministic")
|
|
if seed is None:
|
|
seed = 0
|
|
seed = _execute.make_int(seed, "seed")
|
|
if seed2 is None:
|
|
seed2 = 0
|
|
seed2 = _execute.make_int(seed2, "seed2")
|
|
_attr_T, (value,) = _execute.args_to_matching_eager([value], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
|
|
_inputs_flat = [value]
|
|
_attrs = ("pooling_ratio", pooling_ratio, "pseudo_random", pseudo_random,
|
|
"overlapping", overlapping, "deterministic", deterministic, "seed", seed,
|
|
"seed2", seed2, "T", _attr_T)
|
|
_result = _execute.execute(b"FractionalAvgPool", 3, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"FractionalAvgPool", _inputs_flat, _attrs, _result)
|
|
_result = _FractionalAvgPoolOutput._make(_result)
|
|
return _result
|
|
|
|
|
|
def fractional_avg_pool_grad(orig_input_tensor_shape, out_backprop, row_pooling_sequence, col_pooling_sequence, overlapping=False, name=None):
|
|
r"""Computes gradient of the FractionalAvgPool function.
|
|
|
|
Unlike FractionalMaxPoolGrad, we don't need to find arg_max for
|
|
|
|
FractionalAvgPoolGrad, we just need to evenly back-propagate each element of
|
|
|
|
out_backprop to those indices that form the same pooling cell. Therefore, we
|
|
|
|
just need to know the shape of original input tensor, instead of the whole
|
|
|
|
tensor.
|
|
|
|
Args:
|
|
orig_input_tensor_shape: A `Tensor` of type `int64`.
|
|
Original input tensor shape for `fractional_avg_pool`
|
|
out_backprop: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `int64`.
|
|
4-D with shape `[batch, height, width, channels]`. Gradients
|
|
|
|
w.r.t. the output of `fractional_avg_pool`.
|
|
row_pooling_sequence: A `Tensor` of type `int64`.
|
|
row pooling sequence, form pooling region with
|
|
|
|
col_pooling_sequence.
|
|
col_pooling_sequence: A `Tensor` of type `int64`.
|
|
column pooling sequence, form pooling region with
|
|
|
|
row_pooling sequence.
|
|
overlapping: An optional `bool`. Defaults to `False`.
|
|
When set to True, it means when pooling, the values at the boundary
|
|
|
|
of adjacent pooling cells are used by both cells. For example:
|
|
|
|
|
|
|
|
`index 0 1 2 3 4`
|
|
|
|
|
|
|
|
`value 20 5 16 3 7`
|
|
|
|
|
|
|
|
If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
|
|
|
|
The result would be [41/3, 26/3] for fractional avg pooling.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `out_backprop`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "FractionalAvgPoolGrad", name, orig_input_tensor_shape,
|
|
out_backprop, row_pooling_sequence, col_pooling_sequence,
|
|
"overlapping", overlapping)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return fractional_avg_pool_grad_eager_fallback(
|
|
orig_input_tensor_shape, out_backprop, row_pooling_sequence,
|
|
col_pooling_sequence, overlapping=overlapping, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if overlapping is None:
|
|
overlapping = False
|
|
overlapping = _execute.make_bool(overlapping, "overlapping")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"FractionalAvgPoolGrad", orig_input_tensor_shape=orig_input_tensor_shape,
|
|
out_backprop=out_backprop,
|
|
row_pooling_sequence=row_pooling_sequence,
|
|
col_pooling_sequence=col_pooling_sequence,
|
|
overlapping=overlapping, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("overlapping", _op._get_attr_bool("overlapping"), "T",
|
|
_op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"FractionalAvgPoolGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
FractionalAvgPoolGrad = tf_export("raw_ops.FractionalAvgPoolGrad")(_ops.to_raw_op(fractional_avg_pool_grad))
|
|
|
|
|
|
def fractional_avg_pool_grad_eager_fallback(orig_input_tensor_shape, out_backprop, row_pooling_sequence, col_pooling_sequence, overlapping, name, ctx):
|
|
if overlapping is None:
|
|
overlapping = False
|
|
overlapping = _execute.make_bool(overlapping, "overlapping")
|
|
_attr_T, (out_backprop,) = _execute.args_to_matching_eager([out_backprop], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
|
|
orig_input_tensor_shape = _ops.convert_to_tensor(orig_input_tensor_shape, _dtypes.int64)
|
|
row_pooling_sequence = _ops.convert_to_tensor(row_pooling_sequence, _dtypes.int64)
|
|
col_pooling_sequence = _ops.convert_to_tensor(col_pooling_sequence, _dtypes.int64)
|
|
_inputs_flat = [orig_input_tensor_shape, out_backprop, row_pooling_sequence, col_pooling_sequence]
|
|
_attrs = ("overlapping", overlapping, "T", _attr_T)
|
|
_result = _execute.execute(b"FractionalAvgPoolGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"FractionalAvgPoolGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
_FractionalMaxPoolOutput = collections.namedtuple(
|
|
"FractionalMaxPool",
|
|
["output", "row_pooling_sequence", "col_pooling_sequence"])
|
|
|
|
|
|
def fractional_max_pool(value, pooling_ratio, pseudo_random=False, overlapping=False, deterministic=False, seed=0, seed2=0, name=None):
|
|
r"""Performs fractional max pooling on the input.
|
|
|
|
Fractional max pooling is slightly different than regular max pooling. In
|
|
|
|
regular max pooling, you downsize an input set by taking the maximum value of
|
|
|
|
smaller N x N subsections of the set (often 2x2), and try to reduce the set by
|
|
|
|
a factor of N, where N is an integer. Fractional max pooling, as you might
|
|
|
|
expect from the word "fractional", means that the overall reduction ratio N
|
|
|
|
does not have to be an integer.
|
|
|
|
|
|
|
|
The sizes of the pooling regions are generated randomly but are fairly uniform.
|
|
|
|
For example, let's look at the height dimension, and the constraints on the
|
|
|
|
list of rows that will be pool boundaries.
|
|
|
|
|
|
|
|
First we define the following:
|
|
|
|
|
|
|
|
1. input_row_length : the number of rows from the input set
|
|
|
|
2. output_row_length : which will be smaller than the input
|
|
|
|
3. alpha = input_row_length / output_row_length : our reduction ratio
|
|
|
|
4. K = floor(alpha)
|
|
|
|
5. row_pooling_sequence : this is the result list of pool boundary rows
|
|
|
|
|
|
|
|
Then, row_pooling_sequence should satisfy:
|
|
|
|
|
|
|
|
1. a[0] = 0 : the first value of the sequence is 0
|
|
|
|
2. a[end] = input_row_length : the last value of the sequence is the size
|
|
|
|
3. K <= (a[i+1] - a[i]) <= K+1 : all intervals are K or K+1 size
|
|
|
|
4. length(row_pooling_sequence) = output_row_length+1
|
|
|
|
|
|
|
|
For more details on fractional max pooling, see this paper:
|
|
|
|
[Benjamin Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071)
|
|
|
|
Args:
|
|
value: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `int64`.
|
|
4-D with shape `[batch, height, width, channels]`.
|
|
pooling_ratio: A list of `floats` that has length `>= 4`.
|
|
Pooling ratio for each dimension of `value`, currently only
|
|
|
|
supports row and col dimension and should be >= 1.0. For example, a valid
|
|
|
|
pooling ratio looks like [1.0, 1.44, 1.73, 1.0]. The first and last elements
|
|
|
|
must be 1.0 because we don't allow pooling on batch and channels
|
|
|
|
dimensions. 1.44 and 1.73 are pooling ratio on height and width dimensions
|
|
|
|
respectively.
|
|
pseudo_random: An optional `bool`. Defaults to `False`.
|
|
When set to True, generates the pooling sequence in a
|
|
|
|
pseudorandom fashion, otherwise, in a random fashion. Check paper [Benjamin
|
|
|
|
Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071) for
|
|
|
|
difference between pseudorandom and random.
|
|
overlapping: An optional `bool`. Defaults to `False`.
|
|
When set to True, it means when pooling, the values at the boundary
|
|
|
|
of adjacent pooling cells are used by both cells. For example:
|
|
|
|
|
|
|
|
`index 0 1 2 3 4`
|
|
|
|
|
|
|
|
`value 20 5 16 3 7`
|
|
|
|
|
|
|
|
If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
|
|
|
|
The result would be [20, 16] for fractional max pooling.
|
|
deterministic: An optional `bool`. Defaults to `False`.
|
|
When set to True, a fixed pooling region will be used when
|
|
|
|
iterating over a FractionalMaxPool node in the computation graph. Mainly used
|
|
|
|
in unit test to make FractionalMaxPool deterministic.
|
|
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 tuple of `Tensor` objects (output, row_pooling_sequence, col_pooling_sequence).
|
|
|
|
output: A `Tensor`. Has the same type as `value`.
|
|
row_pooling_sequence: A `Tensor` of type `int64`.
|
|
col_pooling_sequence: A `Tensor` of type `int64`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "FractionalMaxPool", name, value, "pooling_ratio",
|
|
pooling_ratio, "pseudo_random", pseudo_random, "overlapping",
|
|
overlapping, "deterministic", deterministic, "seed", seed, "seed2",
|
|
seed2)
|
|
_result = _FractionalMaxPoolOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return fractional_max_pool_eager_fallback(
|
|
value, pooling_ratio=pooling_ratio, pseudo_random=pseudo_random,
|
|
overlapping=overlapping, deterministic=deterministic, seed=seed,
|
|
seed2=seed2, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(pooling_ratio, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'pooling_ratio' argument to "
|
|
"'fractional_max_pool' Op, not %r." % pooling_ratio)
|
|
pooling_ratio = [_execute.make_float(_f, "pooling_ratio") for _f in pooling_ratio]
|
|
if pseudo_random is None:
|
|
pseudo_random = False
|
|
pseudo_random = _execute.make_bool(pseudo_random, "pseudo_random")
|
|
if overlapping is None:
|
|
overlapping = False
|
|
overlapping = _execute.make_bool(overlapping, "overlapping")
|
|
if deterministic is None:
|
|
deterministic = False
|
|
deterministic = _execute.make_bool(deterministic, "deterministic")
|
|
if seed is None:
|
|
seed = 0
|
|
seed = _execute.make_int(seed, "seed")
|
|
if seed2 is None:
|
|
seed2 = 0
|
|
seed2 = _execute.make_int(seed2, "seed2")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"FractionalMaxPool", value=value, pooling_ratio=pooling_ratio,
|
|
pseudo_random=pseudo_random,
|
|
overlapping=overlapping,
|
|
deterministic=deterministic, seed=seed,
|
|
seed2=seed2, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("pooling_ratio", _op.get_attr("pooling_ratio"), "pseudo_random",
|
|
_op._get_attr_bool("pseudo_random"), "overlapping",
|
|
_op._get_attr_bool("overlapping"), "deterministic",
|
|
_op._get_attr_bool("deterministic"), "seed",
|
|
_op._get_attr_int("seed"), "seed2", _op._get_attr_int("seed2"),
|
|
"T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"FractionalMaxPool", _inputs_flat, _attrs, _result)
|
|
_result = _FractionalMaxPoolOutput._make(_result)
|
|
return _result
|
|
|
|
FractionalMaxPool = tf_export("raw_ops.FractionalMaxPool")(_ops.to_raw_op(fractional_max_pool))
|
|
|
|
|
|
def fractional_max_pool_eager_fallback(value, pooling_ratio, pseudo_random, overlapping, deterministic, seed, seed2, name, ctx):
|
|
if not isinstance(pooling_ratio, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'pooling_ratio' argument to "
|
|
"'fractional_max_pool' Op, not %r." % pooling_ratio)
|
|
pooling_ratio = [_execute.make_float(_f, "pooling_ratio") for _f in pooling_ratio]
|
|
if pseudo_random is None:
|
|
pseudo_random = False
|
|
pseudo_random = _execute.make_bool(pseudo_random, "pseudo_random")
|
|
if overlapping is None:
|
|
overlapping = False
|
|
overlapping = _execute.make_bool(overlapping, "overlapping")
|
|
if deterministic is None:
|
|
deterministic = False
|
|
deterministic = _execute.make_bool(deterministic, "deterministic")
|
|
if seed is None:
|
|
seed = 0
|
|
seed = _execute.make_int(seed, "seed")
|
|
if seed2 is None:
|
|
seed2 = 0
|
|
seed2 = _execute.make_int(seed2, "seed2")
|
|
_attr_T, (value,) = _execute.args_to_matching_eager([value], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
|
|
_inputs_flat = [value]
|
|
_attrs = ("pooling_ratio", pooling_ratio, "pseudo_random", pseudo_random,
|
|
"overlapping", overlapping, "deterministic", deterministic, "seed", seed,
|
|
"seed2", seed2, "T", _attr_T)
|
|
_result = _execute.execute(b"FractionalMaxPool", 3, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"FractionalMaxPool", _inputs_flat, _attrs, _result)
|
|
_result = _FractionalMaxPoolOutput._make(_result)
|
|
return _result
|
|
|
|
|
|
def fractional_max_pool_grad(orig_input, orig_output, out_backprop, row_pooling_sequence, col_pooling_sequence, overlapping=False, name=None):
|
|
r"""Computes gradient of the FractionalMaxPool function.
|
|
|
|
Args:
|
|
orig_input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `int64`.
|
|
Original input for `fractional_max_pool`
|
|
orig_output: A `Tensor`. Must have the same type as `orig_input`.
|
|
Original output for `fractional_max_pool`
|
|
out_backprop: A `Tensor`. Must have the same type as `orig_input`.
|
|
4-D with shape `[batch, height, width, channels]`. Gradients
|
|
|
|
w.r.t. the output of `fractional_max_pool`.
|
|
row_pooling_sequence: A `Tensor` of type `int64`.
|
|
row pooling sequence, form pooling region with
|
|
|
|
col_pooling_sequence.
|
|
col_pooling_sequence: A `Tensor` of type `int64`.
|
|
column pooling sequence, form pooling region with
|
|
|
|
row_pooling sequence.
|
|
overlapping: An optional `bool`. Defaults to `False`.
|
|
When set to True, it means when pooling, the values at the boundary
|
|
|
|
of adjacent pooling cells are used by both cells. For example:
|
|
|
|
|
|
|
|
`index 0 1 2 3 4`
|
|
|
|
|
|
|
|
`value 20 5 16 3 7`
|
|
|
|
|
|
|
|
If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
|
|
|
|
The result would be [20, 16] for fractional max pooling.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `orig_input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "FractionalMaxPoolGrad", name, orig_input, orig_output,
|
|
out_backprop, row_pooling_sequence, col_pooling_sequence,
|
|
"overlapping", overlapping)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return fractional_max_pool_grad_eager_fallback(
|
|
orig_input, orig_output, out_backprop, row_pooling_sequence,
|
|
col_pooling_sequence, overlapping=overlapping, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if overlapping is None:
|
|
overlapping = False
|
|
overlapping = _execute.make_bool(overlapping, "overlapping")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"FractionalMaxPoolGrad", orig_input=orig_input,
|
|
orig_output=orig_output,
|
|
out_backprop=out_backprop,
|
|
row_pooling_sequence=row_pooling_sequence,
|
|
col_pooling_sequence=col_pooling_sequence,
|
|
overlapping=overlapping, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("overlapping", _op._get_attr_bool("overlapping"), "T",
|
|
_op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"FractionalMaxPoolGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
FractionalMaxPoolGrad = tf_export("raw_ops.FractionalMaxPoolGrad")(_ops.to_raw_op(fractional_max_pool_grad))
|
|
|
|
|
|
def fractional_max_pool_grad_eager_fallback(orig_input, orig_output, out_backprop, row_pooling_sequence, col_pooling_sequence, overlapping, name, ctx):
|
|
if overlapping is None:
|
|
overlapping = False
|
|
overlapping = _execute.make_bool(overlapping, "overlapping")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([orig_input, orig_output, out_backprop], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
|
|
(orig_input, orig_output, out_backprop) = _inputs_T
|
|
row_pooling_sequence = _ops.convert_to_tensor(row_pooling_sequence, _dtypes.int64)
|
|
col_pooling_sequence = _ops.convert_to_tensor(col_pooling_sequence, _dtypes.int64)
|
|
_inputs_flat = [orig_input, orig_output, out_backprop, row_pooling_sequence, col_pooling_sequence]
|
|
_attrs = ("overlapping", overlapping, "T", _attr_T)
|
|
_result = _execute.execute(b"FractionalMaxPoolGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"FractionalMaxPoolGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
_FusedBatchNormOutput = collections.namedtuple(
|
|
"FusedBatchNorm",
|
|
["y", "batch_mean", "batch_variance", "reserve_space_1", "reserve_space_2"])
|
|
|
|
|
|
def _fused_batch_norm(x, scale, offset, mean, variance, epsilon=0.0001, exponential_avg_factor=1, data_format="NHWC", is_training=True, name=None):
|
|
r"""Batch normalization.
|
|
|
|
Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
|
|
|
|
The size of 1D Tensors matches the dimension C of the 4D Tensors.
|
|
|
|
Args:
|
|
x: A `Tensor`. Must be one of the following types: `float32`.
|
|
A 4D Tensor for input data.
|
|
scale: A `Tensor`. Must have the same type as `x`.
|
|
A 1D Tensor for scaling factor, to scale the normalized x.
|
|
offset: A `Tensor`. Must have the same type as `x`.
|
|
A 1D Tensor for offset, to shift to the normalized x.
|
|
mean: A `Tensor`. Must have the same type as `x`.
|
|
A 1D Tensor for population mean. Used for inference only;
|
|
|
|
must be empty for training.
|
|
variance: A `Tensor`. Must have the same type as `x`.
|
|
A 1D Tensor for population variance. Used for inference only;
|
|
|
|
must be empty for training.
|
|
epsilon: An optional `float`. Defaults to `0.0001`.
|
|
A small float number added to the variance of x.
|
|
exponential_avg_factor: An optional `float`. Defaults to `1`.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
The data format for x and y. Either "NHWC" (default) or "NCHW".
|
|
is_training: An optional `bool`. Defaults to `True`.
|
|
A bool value to indicate the operation is for training (default)
|
|
|
|
or inference.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (y, batch_mean, batch_variance, reserve_space_1, reserve_space_2).
|
|
|
|
y: A `Tensor`. Has the same type as `x`.
|
|
batch_mean: A `Tensor`. Has the same type as `x`.
|
|
batch_variance: A `Tensor`. Has the same type as `x`.
|
|
reserve_space_1: A `Tensor`. Has the same type as `x`.
|
|
reserve_space_2: A `Tensor`. Has the same type as `x`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "FusedBatchNorm", name, x, scale, offset, mean, variance,
|
|
"epsilon", epsilon, "exponential_avg_factor", exponential_avg_factor,
|
|
"data_format", data_format, "is_training", is_training)
|
|
_result = _FusedBatchNormOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return _fused_batch_norm_eager_fallback(
|
|
x, scale, offset, mean, variance, epsilon=epsilon,
|
|
exponential_avg_factor=exponential_avg_factor,
|
|
data_format=data_format, is_training=is_training, name=name,
|
|
ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if epsilon is None:
|
|
epsilon = 0.0001
|
|
epsilon = _execute.make_float(epsilon, "epsilon")
|
|
if exponential_avg_factor is None:
|
|
exponential_avg_factor = 1
|
|
exponential_avg_factor = _execute.make_float(exponential_avg_factor, "exponential_avg_factor")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if is_training is None:
|
|
is_training = True
|
|
is_training = _execute.make_bool(is_training, "is_training")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"FusedBatchNorm", x=x, scale=scale, offset=offset, mean=mean,
|
|
variance=variance, epsilon=epsilon,
|
|
exponential_avg_factor=exponential_avg_factor,
|
|
data_format=data_format, is_training=is_training,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "epsilon",
|
|
_op.get_attr("epsilon"), "exponential_avg_factor",
|
|
_op.get_attr("exponential_avg_factor"), "data_format",
|
|
_op.get_attr("data_format"), "is_training",
|
|
_op._get_attr_bool("is_training"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"FusedBatchNorm", _inputs_flat, _attrs, _result)
|
|
_result = _FusedBatchNormOutput._make(_result)
|
|
return _result
|
|
|
|
FusedBatchNorm = tf_export("raw_ops.FusedBatchNorm")(_ops.to_raw_op(_fused_batch_norm))
|
|
|
|
|
|
def _fused_batch_norm_eager_fallback(x, scale, offset, mean, variance, epsilon, exponential_avg_factor, data_format, is_training, name, ctx):
|
|
if epsilon is None:
|
|
epsilon = 0.0001
|
|
epsilon = _execute.make_float(epsilon, "epsilon")
|
|
if exponential_avg_factor is None:
|
|
exponential_avg_factor = 1
|
|
exponential_avg_factor = _execute.make_float(exponential_avg_factor, "exponential_avg_factor")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if is_training is None:
|
|
is_training = True
|
|
is_training = _execute.make_bool(is_training, "is_training")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([x, scale, offset, mean, variance], ctx, [_dtypes.float32, ])
|
|
(x, scale, offset, mean, variance) = _inputs_T
|
|
_inputs_flat = [x, scale, offset, mean, variance]
|
|
_attrs = ("T", _attr_T, "epsilon", epsilon, "exponential_avg_factor",
|
|
exponential_avg_factor, "data_format", data_format, "is_training",
|
|
is_training)
|
|
_result = _execute.execute(b"FusedBatchNorm", 5, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"FusedBatchNorm", _inputs_flat, _attrs, _result)
|
|
_result = _FusedBatchNormOutput._make(_result)
|
|
return _result
|
|
|
|
_FusedBatchNormGradOutput = collections.namedtuple(
|
|
"FusedBatchNormGrad",
|
|
["x_backprop", "scale_backprop", "offset_backprop", "reserve_space_3", "reserve_space_4"])
|
|
|
|
|
|
def fused_batch_norm_grad(y_backprop, x, scale, reserve_space_1, reserve_space_2, epsilon=0.0001, data_format="NHWC", is_training=True, name=None):
|
|
r"""Gradient for batch normalization.
|
|
|
|
Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
|
|
|
|
The size of 1D Tensors matches the dimension C of the 4D Tensors.
|
|
|
|
Args:
|
|
y_backprop: A `Tensor`. Must be one of the following types: `float32`.
|
|
A 4D Tensor for the gradient with respect to y.
|
|
x: A `Tensor`. Must have the same type as `y_backprop`.
|
|
A 4D Tensor for input data.
|
|
scale: A `Tensor`. Must have the same type as `y_backprop`.
|
|
A 1D Tensor for scaling factor, to scale the normalized x.
|
|
reserve_space_1: A `Tensor`. Must have the same type as `y_backprop`.
|
|
When is_training is True, a 1D Tensor for the computed batch
|
|
|
|
mean to be reused in gradient computation. When is_training is
|
|
|
|
False, a 1D Tensor for the population mean to be reused in both
|
|
|
|
1st and 2nd order gradient computation.
|
|
reserve_space_2: A `Tensor`. Must have the same type as `y_backprop`.
|
|
When is_training is True, a 1D Tensor for the computed batch
|
|
|
|
variance (inverted variance in the cuDNN case) to be reused in
|
|
|
|
gradient computation. When is_training is False, a 1D Tensor
|
|
|
|
for the population variance to be reused in both 1st and 2nd
|
|
|
|
order gradient computation.
|
|
epsilon: An optional `float`. Defaults to `0.0001`.
|
|
A small float number added to the variance of x.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
The data format for y_backprop, x, x_backprop.
|
|
|
|
Either "NHWC" (default) or "NCHW".
|
|
is_training: An optional `bool`. Defaults to `True`.
|
|
A bool value to indicate the operation is for training (default)
|
|
|
|
or inference.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (x_backprop, scale_backprop, offset_backprop, reserve_space_3, reserve_space_4).
|
|
|
|
x_backprop: A `Tensor`. Has the same type as `y_backprop`.
|
|
scale_backprop: A `Tensor`. Has the same type as `y_backprop`.
|
|
offset_backprop: A `Tensor`. Has the same type as `y_backprop`.
|
|
reserve_space_3: A `Tensor`. Has the same type as `y_backprop`.
|
|
reserve_space_4: A `Tensor`. Has the same type as `y_backprop`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "FusedBatchNormGrad", name, y_backprop, x, scale,
|
|
reserve_space_1, reserve_space_2, "epsilon", epsilon, "data_format",
|
|
data_format, "is_training", is_training)
|
|
_result = _FusedBatchNormGradOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return fused_batch_norm_grad_eager_fallback(
|
|
y_backprop, x, scale, reserve_space_1, reserve_space_2,
|
|
epsilon=epsilon, data_format=data_format, is_training=is_training,
|
|
name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if epsilon is None:
|
|
epsilon = 0.0001
|
|
epsilon = _execute.make_float(epsilon, "epsilon")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if is_training is None:
|
|
is_training = True
|
|
is_training = _execute.make_bool(is_training, "is_training")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"FusedBatchNormGrad", y_backprop=y_backprop, x=x, scale=scale,
|
|
reserve_space_1=reserve_space_1,
|
|
reserve_space_2=reserve_space_2,
|
|
epsilon=epsilon, data_format=data_format,
|
|
is_training=is_training, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "epsilon",
|
|
_op.get_attr("epsilon"), "data_format",
|
|
_op.get_attr("data_format"), "is_training",
|
|
_op._get_attr_bool("is_training"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"FusedBatchNormGrad", _inputs_flat, _attrs, _result)
|
|
_result = _FusedBatchNormGradOutput._make(_result)
|
|
return _result
|
|
|
|
FusedBatchNormGrad = tf_export("raw_ops.FusedBatchNormGrad")(_ops.to_raw_op(fused_batch_norm_grad))
|
|
|
|
|
|
def fused_batch_norm_grad_eager_fallback(y_backprop, x, scale, reserve_space_1, reserve_space_2, epsilon, data_format, is_training, name, ctx):
|
|
if epsilon is None:
|
|
epsilon = 0.0001
|
|
epsilon = _execute.make_float(epsilon, "epsilon")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if is_training is None:
|
|
is_training = True
|
|
is_training = _execute.make_bool(is_training, "is_training")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([y_backprop, x, scale, reserve_space_1, reserve_space_2], ctx, [_dtypes.float32, ])
|
|
(y_backprop, x, scale, reserve_space_1, reserve_space_2) = _inputs_T
|
|
_inputs_flat = [y_backprop, x, scale, reserve_space_1, reserve_space_2]
|
|
_attrs = ("T", _attr_T, "epsilon", epsilon, "data_format", data_format,
|
|
"is_training", is_training)
|
|
_result = _execute.execute(b"FusedBatchNormGrad", 5, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"FusedBatchNormGrad", _inputs_flat, _attrs, _result)
|
|
_result = _FusedBatchNormGradOutput._make(_result)
|
|
return _result
|
|
|
|
_FusedBatchNormGradV2Output = collections.namedtuple(
|
|
"FusedBatchNormGradV2",
|
|
["x_backprop", "scale_backprop", "offset_backprop", "reserve_space_3", "reserve_space_4"])
|
|
|
|
|
|
def fused_batch_norm_grad_v2(y_backprop, x, scale, reserve_space_1, reserve_space_2, epsilon=0.0001, data_format="NHWC", is_training=True, name=None):
|
|
r"""Gradient for batch normalization.
|
|
|
|
Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
|
|
|
|
The size of 1D Tensors matches the dimension C of the 4D Tensors.
|
|
|
|
Args:
|
|
y_backprop: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`.
|
|
A 4D Tensor for the gradient with respect to y.
|
|
x: A `Tensor`. Must have the same type as `y_backprop`.
|
|
A 4D Tensor for input data.
|
|
scale: A `Tensor` of type `float32`.
|
|
A 1D Tensor for scaling factor, to scale the normalized x.
|
|
reserve_space_1: A `Tensor`. Must be one of the following types: `float32`.
|
|
When is_training is True, a 1D Tensor for the computed batch
|
|
|
|
mean to be reused in gradient computation. When is_training is
|
|
|
|
False, a 1D Tensor for the population mean to be reused in both
|
|
|
|
1st and 2nd order gradient computation.
|
|
reserve_space_2: A `Tensor`. Must have the same type as `reserve_space_1`.
|
|
When is_training is True, a 1D Tensor for the computed batch
|
|
|
|
variance (inverted variance in the cuDNN case) to be reused in
|
|
|
|
gradient computation. When is_training is False, a 1D Tensor
|
|
|
|
for the population variance to be reused in both 1st and 2nd
|
|
|
|
order gradient computation.
|
|
epsilon: An optional `float`. Defaults to `0.0001`.
|
|
A small float number added to the variance of x.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
The data format for y_backprop, x, x_backprop.
|
|
|
|
Either "NHWC" (default) or "NCHW".
|
|
is_training: An optional `bool`. Defaults to `True`.
|
|
A bool value to indicate the operation is for training (default)
|
|
|
|
or inference.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (x_backprop, scale_backprop, offset_backprop, reserve_space_3, reserve_space_4).
|
|
|
|
x_backprop: A `Tensor`. Has the same type as `y_backprop`.
|
|
scale_backprop: A `Tensor`. Has the same type as `reserve_space_1`.
|
|
offset_backprop: A `Tensor`. Has the same type as `reserve_space_1`.
|
|
reserve_space_3: A `Tensor`. Has the same type as `reserve_space_1`.
|
|
reserve_space_4: A `Tensor`. Has the same type as `reserve_space_1`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "FusedBatchNormGradV2", name, y_backprop, x, scale,
|
|
reserve_space_1, reserve_space_2, "epsilon", epsilon, "data_format",
|
|
data_format, "is_training", is_training)
|
|
_result = _FusedBatchNormGradV2Output._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return fused_batch_norm_grad_v2_eager_fallback(
|
|
y_backprop, x, scale, reserve_space_1, reserve_space_2,
|
|
epsilon=epsilon, data_format=data_format, is_training=is_training,
|
|
name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if epsilon is None:
|
|
epsilon = 0.0001
|
|
epsilon = _execute.make_float(epsilon, "epsilon")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if is_training is None:
|
|
is_training = True
|
|
is_training = _execute.make_bool(is_training, "is_training")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"FusedBatchNormGradV2", y_backprop=y_backprop, x=x, scale=scale,
|
|
reserve_space_1=reserve_space_1,
|
|
reserve_space_2=reserve_space_2,
|
|
epsilon=epsilon, data_format=data_format,
|
|
is_training=is_training, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "U", _op._get_attr_type("U"),
|
|
"epsilon", _op.get_attr("epsilon"), "data_format",
|
|
_op.get_attr("data_format"), "is_training",
|
|
_op._get_attr_bool("is_training"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"FusedBatchNormGradV2", _inputs_flat, _attrs, _result)
|
|
_result = _FusedBatchNormGradV2Output._make(_result)
|
|
return _result
|
|
|
|
FusedBatchNormGradV2 = tf_export("raw_ops.FusedBatchNormGradV2")(_ops.to_raw_op(fused_batch_norm_grad_v2))
|
|
|
|
|
|
def fused_batch_norm_grad_v2_eager_fallback(y_backprop, x, scale, reserve_space_1, reserve_space_2, epsilon, data_format, is_training, name, ctx):
|
|
if epsilon is None:
|
|
epsilon = 0.0001
|
|
epsilon = _execute.make_float(epsilon, "epsilon")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if is_training is None:
|
|
is_training = True
|
|
is_training = _execute.make_bool(is_training, "is_training")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([y_backprop, x], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, ])
|
|
(y_backprop, x) = _inputs_T
|
|
_attr_U, _inputs_U = _execute.args_to_matching_eager([reserve_space_1, reserve_space_2], ctx, [_dtypes.float32, ])
|
|
(reserve_space_1, reserve_space_2) = _inputs_U
|
|
scale = _ops.convert_to_tensor(scale, _dtypes.float32)
|
|
_inputs_flat = [y_backprop, x, scale, reserve_space_1, reserve_space_2]
|
|
_attrs = ("T", _attr_T, "U", _attr_U, "epsilon", epsilon, "data_format",
|
|
data_format, "is_training", is_training)
|
|
_result = _execute.execute(b"FusedBatchNormGradV2", 5, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"FusedBatchNormGradV2", _inputs_flat, _attrs, _result)
|
|
_result = _FusedBatchNormGradV2Output._make(_result)
|
|
return _result
|
|
|
|
_FusedBatchNormGradV3Output = collections.namedtuple(
|
|
"FusedBatchNormGradV3",
|
|
["x_backprop", "scale_backprop", "offset_backprop", "reserve_space_4", "reserve_space_5"])
|
|
|
|
|
|
def fused_batch_norm_grad_v3(y_backprop, x, scale, reserve_space_1, reserve_space_2, reserve_space_3, epsilon=0.0001, data_format="NHWC", is_training=True, name=None):
|
|
r"""Gradient for batch normalization.
|
|
|
|
Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
|
|
|
|
The size of 1D Tensors matches the dimension C of the 4D Tensors.
|
|
|
|
Args:
|
|
y_backprop: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`.
|
|
A 4D Tensor for the gradient with respect to y.
|
|
x: A `Tensor`. Must have the same type as `y_backprop`.
|
|
A 4D Tensor for input data.
|
|
scale: A `Tensor` of type `float32`.
|
|
A 1D Tensor for scaling factor, to scale the normalized x.
|
|
reserve_space_1: A `Tensor`. Must be one of the following types: `float32`.
|
|
When is_training is True, a 1D Tensor for the computed batch
|
|
|
|
mean to be reused in gradient computation. When is_training is
|
|
|
|
False, a 1D Tensor for the population mean to be reused in both
|
|
|
|
1st and 2nd order gradient computation.
|
|
reserve_space_2: A `Tensor`. Must have the same type as `reserve_space_1`.
|
|
When is_training is True, a 1D Tensor for the computed batch
|
|
|
|
variance (inverted variance in the cuDNN case) to be reused in
|
|
|
|
gradient computation. When is_training is False, a 1D Tensor
|
|
|
|
for the population variance to be reused in both 1st and 2nd
|
|
|
|
order gradient computation.
|
|
reserve_space_3: A `Tensor`. Must have the same type as `reserve_space_1`.
|
|
When is_training is True, a 1D Tensor for some intermediate results to be reused
|
|
|
|
in gradient computation. When is_training is False, a dummy empty Tensor will be
|
|
|
|
created.
|
|
epsilon: An optional `float`. Defaults to `0.0001`.
|
|
A small float number added to the variance of x.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW", "NDHWC", "NCDHW"`. Defaults to `"NHWC"`.
|
|
The data format for y_backprop, x, x_backprop.
|
|
|
|
Either "NHWC" (default) or "NCHW".
|
|
is_training: An optional `bool`. Defaults to `True`.
|
|
A bool value to indicate the operation is for training (default)
|
|
|
|
or inference.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (x_backprop, scale_backprop, offset_backprop, reserve_space_4, reserve_space_5).
|
|
|
|
x_backprop: A `Tensor`. Has the same type as `y_backprop`.
|
|
scale_backprop: A `Tensor`. Has the same type as `reserve_space_1`.
|
|
offset_backprop: A `Tensor`. Has the same type as `reserve_space_1`.
|
|
reserve_space_4: A `Tensor`. Has the same type as `reserve_space_1`.
|
|
reserve_space_5: A `Tensor`. Has the same type as `reserve_space_1`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "FusedBatchNormGradV3", name, y_backprop, x, scale,
|
|
reserve_space_1, reserve_space_2, reserve_space_3, "epsilon", epsilon,
|
|
"data_format", data_format, "is_training", is_training)
|
|
_result = _FusedBatchNormGradV3Output._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return fused_batch_norm_grad_v3_eager_fallback(
|
|
y_backprop, x, scale, reserve_space_1, reserve_space_2,
|
|
reserve_space_3, epsilon=epsilon, data_format=data_format,
|
|
is_training=is_training, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if epsilon is None:
|
|
epsilon = 0.0001
|
|
epsilon = _execute.make_float(epsilon, "epsilon")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if is_training is None:
|
|
is_training = True
|
|
is_training = _execute.make_bool(is_training, "is_training")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"FusedBatchNormGradV3", y_backprop=y_backprop, x=x, scale=scale,
|
|
reserve_space_1=reserve_space_1,
|
|
reserve_space_2=reserve_space_2,
|
|
reserve_space_3=reserve_space_3,
|
|
epsilon=epsilon, data_format=data_format,
|
|
is_training=is_training, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "U", _op._get_attr_type("U"),
|
|
"epsilon", _op.get_attr("epsilon"), "data_format",
|
|
_op.get_attr("data_format"), "is_training",
|
|
_op._get_attr_bool("is_training"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"FusedBatchNormGradV3", _inputs_flat, _attrs, _result)
|
|
_result = _FusedBatchNormGradV3Output._make(_result)
|
|
return _result
|
|
|
|
FusedBatchNormGradV3 = tf_export("raw_ops.FusedBatchNormGradV3")(_ops.to_raw_op(fused_batch_norm_grad_v3))
|
|
|
|
|
|
def fused_batch_norm_grad_v3_eager_fallback(y_backprop, x, scale, reserve_space_1, reserve_space_2, reserve_space_3, epsilon, data_format, is_training, name, ctx):
|
|
if epsilon is None:
|
|
epsilon = 0.0001
|
|
epsilon = _execute.make_float(epsilon, "epsilon")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if is_training is None:
|
|
is_training = True
|
|
is_training = _execute.make_bool(is_training, "is_training")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([y_backprop, x], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, ])
|
|
(y_backprop, x) = _inputs_T
|
|
_attr_U, _inputs_U = _execute.args_to_matching_eager([reserve_space_1, reserve_space_2, reserve_space_3], ctx, [_dtypes.float32, ])
|
|
(reserve_space_1, reserve_space_2, reserve_space_3) = _inputs_U
|
|
scale = _ops.convert_to_tensor(scale, _dtypes.float32)
|
|
_inputs_flat = [y_backprop, x, scale, reserve_space_1, reserve_space_2, reserve_space_3]
|
|
_attrs = ("T", _attr_T, "U", _attr_U, "epsilon", epsilon, "data_format",
|
|
data_format, "is_training", is_training)
|
|
_result = _execute.execute(b"FusedBatchNormGradV3", 5, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"FusedBatchNormGradV3", _inputs_flat, _attrs, _result)
|
|
_result = _FusedBatchNormGradV3Output._make(_result)
|
|
return _result
|
|
|
|
_FusedBatchNormV2Output = collections.namedtuple(
|
|
"FusedBatchNormV2",
|
|
["y", "batch_mean", "batch_variance", "reserve_space_1", "reserve_space_2"])
|
|
|
|
|
|
def fused_batch_norm_v2(x, scale, offset, mean, variance, epsilon=0.0001, exponential_avg_factor=1, data_format="NHWC", is_training=True, name=None):
|
|
r"""Batch normalization.
|
|
|
|
Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
|
|
|
|
The size of 1D Tensors matches the dimension C of the 4D Tensors.
|
|
|
|
Args:
|
|
x: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`.
|
|
A 4D Tensor for input data.
|
|
scale: A `Tensor`. Must be one of the following types: `float32`.
|
|
A 1D Tensor for scaling factor, to scale the normalized x.
|
|
offset: A `Tensor`. Must have the same type as `scale`.
|
|
A 1D Tensor for offset, to shift to the normalized x.
|
|
mean: A `Tensor`. Must have the same type as `scale`.
|
|
A 1D Tensor for population mean. Used for inference only;
|
|
|
|
must be empty for training.
|
|
variance: A `Tensor`. Must have the same type as `scale`.
|
|
A 1D Tensor for population variance. Used for inference only;
|
|
|
|
must be empty for training.
|
|
epsilon: An optional `float`. Defaults to `0.0001`.
|
|
A small float number added to the variance of x.
|
|
exponential_avg_factor: An optional `float`. Defaults to `1`.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
The data format for x and y. Either "NHWC" (default) or "NCHW".
|
|
is_training: An optional `bool`. Defaults to `True`.
|
|
A bool value to indicate the operation is for training (default)
|
|
|
|
or inference.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (y, batch_mean, batch_variance, reserve_space_1, reserve_space_2).
|
|
|
|
y: A `Tensor`. Has the same type as `x`.
|
|
batch_mean: A `Tensor`. Has the same type as `scale`.
|
|
batch_variance: A `Tensor`. Has the same type as `scale`.
|
|
reserve_space_1: A `Tensor`. Has the same type as `scale`.
|
|
reserve_space_2: A `Tensor`. Has the same type as `scale`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "FusedBatchNormV2", name, x, scale, offset, mean, variance,
|
|
"epsilon", epsilon, "exponential_avg_factor", exponential_avg_factor,
|
|
"data_format", data_format, "is_training", is_training)
|
|
_result = _FusedBatchNormV2Output._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return fused_batch_norm_v2_eager_fallback(
|
|
x, scale, offset, mean, variance, epsilon=epsilon,
|
|
exponential_avg_factor=exponential_avg_factor,
|
|
data_format=data_format, is_training=is_training, name=name,
|
|
ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if epsilon is None:
|
|
epsilon = 0.0001
|
|
epsilon = _execute.make_float(epsilon, "epsilon")
|
|
if exponential_avg_factor is None:
|
|
exponential_avg_factor = 1
|
|
exponential_avg_factor = _execute.make_float(exponential_avg_factor, "exponential_avg_factor")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if is_training is None:
|
|
is_training = True
|
|
is_training = _execute.make_bool(is_training, "is_training")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"FusedBatchNormV2", x=x, scale=scale, offset=offset, mean=mean,
|
|
variance=variance, epsilon=epsilon,
|
|
exponential_avg_factor=exponential_avg_factor,
|
|
data_format=data_format, is_training=is_training,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "U", _op._get_attr_type("U"),
|
|
"epsilon", _op.get_attr("epsilon"), "exponential_avg_factor",
|
|
_op.get_attr("exponential_avg_factor"), "data_format",
|
|
_op.get_attr("data_format"), "is_training",
|
|
_op._get_attr_bool("is_training"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"FusedBatchNormV2", _inputs_flat, _attrs, _result)
|
|
_result = _FusedBatchNormV2Output._make(_result)
|
|
return _result
|
|
|
|
FusedBatchNormV2 = tf_export("raw_ops.FusedBatchNormV2")(_ops.to_raw_op(fused_batch_norm_v2))
|
|
|
|
|
|
def fused_batch_norm_v2_eager_fallback(x, scale, offset, mean, variance, epsilon, exponential_avg_factor, data_format, is_training, name, ctx):
|
|
if epsilon is None:
|
|
epsilon = 0.0001
|
|
epsilon = _execute.make_float(epsilon, "epsilon")
|
|
if exponential_avg_factor is None:
|
|
exponential_avg_factor = 1
|
|
exponential_avg_factor = _execute.make_float(exponential_avg_factor, "exponential_avg_factor")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if is_training is None:
|
|
is_training = True
|
|
is_training = _execute.make_bool(is_training, "is_training")
|
|
_attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, ])
|
|
_attr_U, _inputs_U = _execute.args_to_matching_eager([scale, offset, mean, variance], ctx, [_dtypes.float32, ])
|
|
(scale, offset, mean, variance) = _inputs_U
|
|
_inputs_flat = [x, scale, offset, mean, variance]
|
|
_attrs = ("T", _attr_T, "U", _attr_U, "epsilon", epsilon,
|
|
"exponential_avg_factor", exponential_avg_factor, "data_format",
|
|
data_format, "is_training", is_training)
|
|
_result = _execute.execute(b"FusedBatchNormV2", 5, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"FusedBatchNormV2", _inputs_flat, _attrs, _result)
|
|
_result = _FusedBatchNormV2Output._make(_result)
|
|
return _result
|
|
|
|
_FusedBatchNormV3Output = collections.namedtuple(
|
|
"FusedBatchNormV3",
|
|
["y", "batch_mean", "batch_variance", "reserve_space_1", "reserve_space_2", "reserve_space_3"])
|
|
|
|
|
|
def fused_batch_norm_v3(x, scale, offset, mean, variance, epsilon=0.0001, exponential_avg_factor=1, data_format="NHWC", is_training=True, name=None):
|
|
r"""Batch normalization.
|
|
|
|
Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
|
|
|
|
The size of 1D Tensors matches the dimension C of the 4D Tensors.
|
|
|
|
Args:
|
|
x: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`.
|
|
A 4D Tensor for input data.
|
|
scale: A `Tensor`. Must be one of the following types: `bfloat16`, `float32`.
|
|
A 1D Tensor for scaling factor, to scale the normalized x.
|
|
offset: A `Tensor`. Must have the same type as `scale`.
|
|
A 1D Tensor for offset, to shift to the normalized x.
|
|
mean: A `Tensor`. Must have the same type as `scale`.
|
|
A 1D Tensor for population mean. Used for inference only;
|
|
|
|
must be empty for training.
|
|
variance: A `Tensor`. Must have the same type as `scale`.
|
|
A 1D Tensor for population variance. Used for inference only;
|
|
|
|
must be empty for training.
|
|
epsilon: An optional `float`. Defaults to `0.0001`.
|
|
A small float number added to the variance of x.
|
|
exponential_avg_factor: An optional `float`. Defaults to `1`.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW", "NDHWC", "NCDHW"`. Defaults to `"NHWC"`.
|
|
The data format for x and y. Either "NHWC" (default) or "NCHW".
|
|
is_training: An optional `bool`. Defaults to `True`.
|
|
A bool value to indicate the operation is for training (default)
|
|
|
|
or inference.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (y, batch_mean, batch_variance, reserve_space_1, reserve_space_2, reserve_space_3).
|
|
|
|
y: A `Tensor`. Has the same type as `x`.
|
|
batch_mean: A `Tensor`. Has the same type as `scale`.
|
|
batch_variance: A `Tensor`. Has the same type as `scale`.
|
|
reserve_space_1: A `Tensor`. Has the same type as `scale`.
|
|
reserve_space_2: A `Tensor`. Has the same type as `scale`.
|
|
reserve_space_3: A `Tensor`. Has the same type as `scale`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "FusedBatchNormV3", name, x, scale, offset, mean, variance,
|
|
"epsilon", epsilon, "exponential_avg_factor", exponential_avg_factor,
|
|
"data_format", data_format, "is_training", is_training)
|
|
_result = _FusedBatchNormV3Output._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return fused_batch_norm_v3_eager_fallback(
|
|
x, scale, offset, mean, variance, epsilon=epsilon,
|
|
exponential_avg_factor=exponential_avg_factor,
|
|
data_format=data_format, is_training=is_training, name=name,
|
|
ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if epsilon is None:
|
|
epsilon = 0.0001
|
|
epsilon = _execute.make_float(epsilon, "epsilon")
|
|
if exponential_avg_factor is None:
|
|
exponential_avg_factor = 1
|
|
exponential_avg_factor = _execute.make_float(exponential_avg_factor, "exponential_avg_factor")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if is_training is None:
|
|
is_training = True
|
|
is_training = _execute.make_bool(is_training, "is_training")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"FusedBatchNormV3", x=x, scale=scale, offset=offset, mean=mean,
|
|
variance=variance, epsilon=epsilon,
|
|
exponential_avg_factor=exponential_avg_factor,
|
|
data_format=data_format, is_training=is_training,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "U", _op._get_attr_type("U"),
|
|
"epsilon", _op.get_attr("epsilon"), "exponential_avg_factor",
|
|
_op.get_attr("exponential_avg_factor"), "data_format",
|
|
_op.get_attr("data_format"), "is_training",
|
|
_op._get_attr_bool("is_training"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"FusedBatchNormV3", _inputs_flat, _attrs, _result)
|
|
_result = _FusedBatchNormV3Output._make(_result)
|
|
return _result
|
|
|
|
FusedBatchNormV3 = tf_export("raw_ops.FusedBatchNormV3")(_ops.to_raw_op(fused_batch_norm_v3))
|
|
|
|
|
|
def fused_batch_norm_v3_eager_fallback(x, scale, offset, mean, variance, epsilon, exponential_avg_factor, data_format, is_training, name, ctx):
|
|
if epsilon is None:
|
|
epsilon = 0.0001
|
|
epsilon = _execute.make_float(epsilon, "epsilon")
|
|
if exponential_avg_factor is None:
|
|
exponential_avg_factor = 1
|
|
exponential_avg_factor = _execute.make_float(exponential_avg_factor, "exponential_avg_factor")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
if is_training is None:
|
|
is_training = True
|
|
is_training = _execute.make_bool(is_training, "is_training")
|
|
_attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, ])
|
|
_attr_U, _inputs_U = _execute.args_to_matching_eager([scale, offset, mean, variance], ctx, [_dtypes.bfloat16, _dtypes.float32, ])
|
|
(scale, offset, mean, variance) = _inputs_U
|
|
_inputs_flat = [x, scale, offset, mean, variance]
|
|
_attrs = ("T", _attr_T, "U", _attr_U, "epsilon", epsilon,
|
|
"exponential_avg_factor", exponential_avg_factor, "data_format",
|
|
data_format, "is_training", is_training)
|
|
_result = _execute.execute(b"FusedBatchNormV3", 6, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"FusedBatchNormV3", _inputs_flat, _attrs, _result)
|
|
_result = _FusedBatchNormV3Output._make(_result)
|
|
return _result
|
|
|
|
|
|
def fused_pad_conv2d(input, paddings, filter, mode, strides, padding, name=None):
|
|
r"""Performs a padding as a preprocess during a convolution.
|
|
|
|
Similar to FusedResizeAndPadConv2d, this op allows for an optimized
|
|
|
|
implementation where the spatial padding transformation stage is fused with the
|
|
|
|
im2col lookup, but in this case without the bilinear filtering required for
|
|
|
|
resizing. Fusing the padding prevents the need to write out the intermediate
|
|
|
|
results as whole tensors, reducing memory pressure, and we can get some latency
|
|
|
|
gains by merging the transformation calculations.
|
|
|
|
The data_format attribute for Conv2D isn't supported by this op, and 'NHWC'
|
|
|
|
order is used instead.
|
|
|
|
Internally this op uses a single per-graph scratch buffer, which means that it
|
|
|
|
will block if multiple versions are being run in parallel. This is because this
|
|
|
|
operator is primarily an optimization to minimize memory usage.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`.
|
|
4-D with shape `[batch, in_height, in_width, in_channels]`.
|
|
paddings: A `Tensor` of type `int32`.
|
|
A two-column matrix specifying the padding sizes. The number of
|
|
|
|
rows must be the same as the rank of `input`.
|
|
filter: A `Tensor`. Must have the same type as `input`. 4-D with shape
|
|
|
|
`[filter_height, filter_width, in_channels, out_channels]`.
|
|
mode: A `string` from: `"REFLECT", "SYMMETRIC"`.
|
|
strides: A list of `ints`.
|
|
1-D of length 4. The stride of the sliding window for each dimension
|
|
|
|
of `input`. Must be in the same order as the dimension specified with format.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "FusedPadConv2D", name, input, paddings, filter, "mode", mode,
|
|
"strides", strides, "padding", padding)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return fused_pad_conv2d_eager_fallback(
|
|
input, paddings, filter, mode=mode, strides=strides,
|
|
padding=padding, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
mode = _execute.make_str(mode, "mode")
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'fused_pad_conv2d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"FusedPadConv2D", input=input, paddings=paddings, filter=filter,
|
|
mode=mode, strides=strides, padding=padding,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "mode", _op.get_attr("mode"),
|
|
"strides", _op.get_attr("strides"), "padding",
|
|
_op.get_attr("padding"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"FusedPadConv2D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
FusedPadConv2D = tf_export("raw_ops.FusedPadConv2D")(_ops.to_raw_op(fused_pad_conv2d))
|
|
|
|
|
|
def fused_pad_conv2d_eager_fallback(input, paddings, filter, mode, strides, padding, name, ctx):
|
|
mode = _execute.make_str(mode, "mode")
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'fused_pad_conv2d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, filter], ctx, [_dtypes.half, _dtypes.float32, _dtypes.float64, ])
|
|
(input, filter) = _inputs_T
|
|
paddings = _ops.convert_to_tensor(paddings, _dtypes.int32)
|
|
_inputs_flat = [input, paddings, filter]
|
|
_attrs = ("T", _attr_T, "mode", mode, "strides", strides, "padding",
|
|
padding)
|
|
_result = _execute.execute(b"FusedPadConv2D", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"FusedPadConv2D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def fused_resize_and_pad_conv2d(input, size, paddings, filter, mode, strides, padding, resize_align_corners=False, name=None):
|
|
r"""Performs a resize and padding as a preprocess during a convolution.
|
|
|
|
It's often possible to do spatial transformations more efficiently as part of
|
|
|
|
the packing stage of a convolution, so this op allows for an optimized
|
|
|
|
implementation where these stages are fused together. This prevents the need to
|
|
|
|
write out the intermediate results as whole tensors, reducing memory pressure,
|
|
|
|
and we can get some latency gains by merging the transformation calculations.
|
|
|
|
The data_format attribute for Conv2D isn't supported by this op, and defaults to
|
|
|
|
'NHWC' order.
|
|
|
|
Internally this op uses a single per-graph scratch buffer, which means that it
|
|
|
|
will block if multiple versions are being run in parallel. This is because this
|
|
|
|
operator is primarily an optimization to minimize memory usage.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`.
|
|
4-D with shape `[batch, in_height, in_width, in_channels]`.
|
|
size: A `Tensor` of type `int32`.
|
|
A 1-D int32 Tensor of 2 elements: `new_height, new_width`. The
|
|
|
|
new size for the images.
|
|
paddings: A `Tensor` of type `int32`.
|
|
A two-column matrix specifying the padding sizes. The number of
|
|
|
|
rows must be the same as the rank of `input`.
|
|
filter: A `Tensor`. Must have the same type as `input`. 4-D with shape
|
|
|
|
`[filter_height, filter_width, in_channels, out_channels]`.
|
|
mode: A `string` from: `"REFLECT", "SYMMETRIC"`.
|
|
strides: A list of `ints`.
|
|
1-D of length 4. The stride of the sliding window for each dimension
|
|
|
|
of `input`. Must be in the same order as the dimension specified with format.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
resize_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.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "FusedResizeAndPadConv2D", name, input, size, paddings, filter,
|
|
"resize_align_corners", resize_align_corners, "mode", mode, "strides",
|
|
strides, "padding", padding)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return fused_resize_and_pad_conv2d_eager_fallback(
|
|
input, size, paddings, filter,
|
|
resize_align_corners=resize_align_corners, mode=mode,
|
|
strides=strides, padding=padding, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
mode = _execute.make_str(mode, "mode")
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'fused_resize_and_pad_conv2d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if resize_align_corners is None:
|
|
resize_align_corners = False
|
|
resize_align_corners = _execute.make_bool(resize_align_corners, "resize_align_corners")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"FusedResizeAndPadConv2D", input=input, size=size, paddings=paddings,
|
|
filter=filter, mode=mode, strides=strides,
|
|
padding=padding,
|
|
resize_align_corners=resize_align_corners,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "resize_align_corners",
|
|
_op._get_attr_bool("resize_align_corners"), "mode",
|
|
_op.get_attr("mode"), "strides", _op.get_attr("strides"),
|
|
"padding", _op.get_attr("padding"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"FusedResizeAndPadConv2D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
FusedResizeAndPadConv2D = tf_export("raw_ops.FusedResizeAndPadConv2D")(_ops.to_raw_op(fused_resize_and_pad_conv2d))
|
|
|
|
|
|
def fused_resize_and_pad_conv2d_eager_fallback(input, size, paddings, filter, mode, strides, padding, resize_align_corners, name, ctx):
|
|
mode = _execute.make_str(mode, "mode")
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'fused_resize_and_pad_conv2d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if resize_align_corners is None:
|
|
resize_align_corners = False
|
|
resize_align_corners = _execute.make_bool(resize_align_corners, "resize_align_corners")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, filter], ctx, [_dtypes.half, _dtypes.float32, _dtypes.float64, ])
|
|
(input, filter) = _inputs_T
|
|
size = _ops.convert_to_tensor(size, _dtypes.int32)
|
|
paddings = _ops.convert_to_tensor(paddings, _dtypes.int32)
|
|
_inputs_flat = [input, size, paddings, filter]
|
|
_attrs = ("T", _attr_T, "resize_align_corners", resize_align_corners,
|
|
"mode", mode, "strides", strides, "padding", padding)
|
|
_result = _execute.execute(b"FusedResizeAndPadConv2D", 1,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"FusedResizeAndPadConv2D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def in_top_k(predictions, targets, k, name=None):
|
|
r"""Says whether the targets are in the top `K` predictions.
|
|
|
|
This outputs a `batch_size` bool array, an entry `out[i]` is `true` if the
|
|
|
|
prediction for the target class is among the top `k` predictions among
|
|
|
|
all predictions for example `i`. Note that the behavior of `InTopK` differs
|
|
|
|
from the `TopK` op in its handling of ties; if multiple classes have the
|
|
|
|
same prediction value and straddle the top-`k` boundary, all of those
|
|
|
|
classes are considered to be in the top `k`.
|
|
|
|
|
|
|
|
More formally, let
|
|
|
|
|
|
|
|
\\(predictions_i\\) be the predictions for all classes for example `i`,
|
|
|
|
\\(targets_i\\) be the target class for example `i`,
|
|
|
|
\\(out_i\\) be the output for example `i`,
|
|
|
|
|
|
|
|
$$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$
|
|
|
|
Args:
|
|
predictions: A `Tensor` of type `float32`.
|
|
A `batch_size` x `classes` tensor.
|
|
targets: A `Tensor`. Must be one of the following types: `int32`, `int64`.
|
|
A `batch_size` vector of class ids.
|
|
k: An `int`. Number of top elements to look at for computing precision.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor` of type `bool`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "InTopK", name, predictions, targets, "k", k)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return in_top_k_eager_fallback(
|
|
predictions, targets, k=k, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
k = _execute.make_int(k, "k")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"InTopK", predictions=predictions, targets=targets, k=k, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("k", _op._get_attr_int("k"), "T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"InTopK", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
InTopK = tf_export("raw_ops.InTopK")(_ops.to_raw_op(in_top_k))
|
|
|
|
|
|
def in_top_k_eager_fallback(predictions, targets, k, name, ctx):
|
|
k = _execute.make_int(k, "k")
|
|
_attr_T, (targets,) = _execute.args_to_matching_eager([targets], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int32)
|
|
predictions = _ops.convert_to_tensor(predictions, _dtypes.float32)
|
|
_inputs_flat = [predictions, targets]
|
|
_attrs = ("k", k, "T", _attr_T)
|
|
_result = _execute.execute(b"InTopK", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"InTopK", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def in_top_kv2(predictions, targets, k, name=None):
|
|
r"""Says whether the targets are in the top `K` predictions.
|
|
|
|
This outputs a `batch_size` bool array, an entry `out[i]` is `true` if the
|
|
|
|
prediction for the target class is among the top `k` predictions among
|
|
|
|
all predictions for example `i`. Note that the behavior of `InTopK` differs
|
|
|
|
from the `TopK` op in its handling of ties; if multiple classes have the
|
|
|
|
same prediction value and straddle the top-`k` boundary, all of those
|
|
|
|
classes are considered to be in the top `k`.
|
|
|
|
|
|
|
|
More formally, let
|
|
|
|
|
|
|
|
\\(predictions_i\\) be the predictions for all classes for example `i`,
|
|
|
|
\\(targets_i\\) be the target class for example `i`,
|
|
|
|
\\(out_i\\) be the output for example `i`,
|
|
|
|
|
|
|
|
$$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$
|
|
|
|
Args:
|
|
predictions: A `Tensor` of type `float32`.
|
|
A `batch_size` x `classes` tensor.
|
|
targets: A `Tensor`. Must be one of the following types: `int32`, `int64`.
|
|
A `batch_size` vector of class ids.
|
|
k: A `Tensor`. Must have the same type as `targets`.
|
|
Number of top elements to look at for computing precision.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor` of type `bool`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "InTopKV2", name, predictions, targets, k)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return in_top_kv2_eager_fallback(
|
|
predictions, targets, k, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"InTopKV2", predictions=predictions, targets=targets, k=k, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"InTopKV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
InTopKV2 = tf_export("raw_ops.InTopKV2")(_ops.to_raw_op(in_top_kv2))
|
|
|
|
|
|
def in_top_kv2_eager_fallback(predictions, targets, k, name, ctx):
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([targets, k], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int32)
|
|
(targets, k) = _inputs_T
|
|
predictions = _ops.convert_to_tensor(predictions, _dtypes.float32)
|
|
_inputs_flat = [predictions, targets, k]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"InTopKV2", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"InTopKV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
_IsotonicRegressionOutput = collections.namedtuple(
|
|
"IsotonicRegression",
|
|
["output", "segments"])
|
|
|
|
|
|
def isotonic_regression(input, output_dtype=_dtypes.float32, name=None):
|
|
r"""Solves a batch of isotonic regression problems.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
A (batch_size, dim)-tensor holding a batch of inputs.
|
|
output_dtype: An optional `tf.DType` from: `tf.half, tf.bfloat16, tf.float32, tf.float64`. Defaults to `tf.float32`.
|
|
Dtype of output.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (output, segments).
|
|
|
|
output: A `Tensor` of type `output_dtype`.
|
|
segments: A `Tensor` of type `int32`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "IsotonicRegression", name, input, "output_dtype", output_dtype)
|
|
_result = _IsotonicRegressionOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return isotonic_regression_eager_fallback(
|
|
input, output_dtype=output_dtype, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if output_dtype is None:
|
|
output_dtype = _dtypes.float32
|
|
output_dtype = _execute.make_type(output_dtype, "output_dtype")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"IsotonicRegression", input=input, output_dtype=output_dtype,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "output_dtype",
|
|
_op._get_attr_type("output_dtype"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"IsotonicRegression", _inputs_flat, _attrs, _result)
|
|
_result = _IsotonicRegressionOutput._make(_result)
|
|
return _result
|
|
|
|
IsotonicRegression = tf_export("raw_ops.IsotonicRegression")(_ops.to_raw_op(isotonic_regression))
|
|
|
|
|
|
def isotonic_regression_eager_fallback(input, output_dtype, name, ctx):
|
|
if output_dtype is None:
|
|
output_dtype = _dtypes.float32
|
|
output_dtype = _execute.make_type(output_dtype, "output_dtype")
|
|
_attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
_inputs_flat = [input]
|
|
_attrs = ("T", _attr_T, "output_dtype", output_dtype)
|
|
_result = _execute.execute(b"IsotonicRegression", 2, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"IsotonicRegression", _inputs_flat, _attrs, _result)
|
|
_result = _IsotonicRegressionOutput._make(_result)
|
|
return _result
|
|
|
|
|
|
@_dispatch.add_fallback_dispatch_list
|
|
@_dispatch.add_type_based_api_dispatcher
|
|
@tf_export('nn.l2_loss')
|
|
def l2_loss(t, name=None):
|
|
r"""L2 Loss.
|
|
|
|
Computes half the L2 norm of a tensor without the `sqrt`:
|
|
|
|
|
|
|
|
output = sum(t ** 2) / 2
|
|
|
|
Args:
|
|
t: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
Typically 2-D, but may have any dimensions.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `t`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "L2Loss", name, t)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
_result = _dispatcher_for_l2_loss(
|
|
(t, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
return l2_loss_eager_fallback(
|
|
t, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
l2_loss, (), dict(t=t, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
else:
|
|
_result = _dispatcher_for_l2_loss(
|
|
(t, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
# Add nodes to the TensorFlow graph.
|
|
try:
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"L2Loss", t=t, name=name)
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
l2_loss, (), dict(t=t, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"L2Loss", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
L2Loss = tf_export("raw_ops.L2Loss")(_ops.to_raw_op(l2_loss))
|
|
_dispatcher_for_l2_loss = l2_loss._tf_type_based_dispatcher.Dispatch
|
|
|
|
|
|
def l2_loss_eager_fallback(t, name, ctx):
|
|
_attr_T, (t,) = _execute.args_to_matching_eager([t], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
_inputs_flat = [t]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"L2Loss", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"L2Loss", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
@_dispatch.add_fallback_dispatch_list
|
|
@_dispatch.add_type_based_api_dispatcher
|
|
@tf_export('nn.local_response_normalization', 'nn.lrn')
|
|
def lrn(input, depth_radius=5, bias=1, alpha=1, beta=0.5, name=None):
|
|
r"""Local Response Normalization.
|
|
|
|
The 4-D `input` tensor is treated as a 3-D array of 1-D vectors (along the last
|
|
|
|
dimension), and each vector is normalized independently. Within a given vector,
|
|
|
|
each component is divided by the weighted, squared sum of inputs within
|
|
|
|
`depth_radius`. In detail,
|
|
|
|
|
|
|
|
sqr_sum[a, b, c, d] =
|
|
|
|
sum(input[a, b, c, d - depth_radius : d + depth_radius + 1] ** 2)
|
|
|
|
output = input / (bias + alpha * sqr_sum) ** beta
|
|
|
|
|
|
|
|
For details, see [Krizhevsky et al., ImageNet classification with deep
|
|
|
|
convolutional neural networks (NIPS 2012)](http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks).
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`.
|
|
4-D.
|
|
depth_radius: An optional `int`. Defaults to `5`.
|
|
0-D. Half-width of the 1-D normalization window.
|
|
bias: An optional `float`. Defaults to `1`.
|
|
An offset (usually positive to avoid dividing by 0).
|
|
alpha: An optional `float`. Defaults to `1`.
|
|
A scale factor, usually positive.
|
|
beta: An optional `float`. Defaults to `0.5`. An exponent.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "LRN", name, input, "depth_radius", depth_radius, "bias", bias,
|
|
"alpha", alpha, "beta", beta)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
_result = _dispatcher_for_lrn(
|
|
(input, depth_radius, bias, alpha, beta, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
return lrn_eager_fallback(
|
|
input, depth_radius=depth_radius, bias=bias, alpha=alpha, beta=beta,
|
|
name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
lrn, (), dict(input=input, depth_radius=depth_radius, bias=bias,
|
|
alpha=alpha, beta=beta, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
else:
|
|
_result = _dispatcher_for_lrn(
|
|
(input, depth_radius, bias, alpha, beta, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
# Add nodes to the TensorFlow graph.
|
|
if depth_radius is None:
|
|
depth_radius = 5
|
|
depth_radius = _execute.make_int(depth_radius, "depth_radius")
|
|
if bias is None:
|
|
bias = 1
|
|
bias = _execute.make_float(bias, "bias")
|
|
if alpha is None:
|
|
alpha = 1
|
|
alpha = _execute.make_float(alpha, "alpha")
|
|
if beta is None:
|
|
beta = 0.5
|
|
beta = _execute.make_float(beta, "beta")
|
|
try:
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"LRN", input=input, depth_radius=depth_radius, bias=bias, alpha=alpha,
|
|
beta=beta, name=name)
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
lrn, (), dict(input=input, depth_radius=depth_radius, bias=bias,
|
|
alpha=alpha, beta=beta, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("depth_radius", _op._get_attr_int("depth_radius"), "bias",
|
|
_op.get_attr("bias"), "alpha", _op.get_attr("alpha"), "beta",
|
|
_op.get_attr("beta"), "T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"LRN", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
LRN = tf_export("raw_ops.LRN")(_ops.to_raw_op(lrn))
|
|
_dispatcher_for_lrn = lrn._tf_type_based_dispatcher.Dispatch
|
|
|
|
|
|
def lrn_eager_fallback(input, depth_radius, bias, alpha, beta, name, ctx):
|
|
if depth_radius is None:
|
|
depth_radius = 5
|
|
depth_radius = _execute.make_int(depth_radius, "depth_radius")
|
|
if bias is None:
|
|
bias = 1
|
|
bias = _execute.make_float(bias, "bias")
|
|
if alpha is None:
|
|
alpha = 1
|
|
alpha = _execute.make_float(alpha, "alpha")
|
|
if beta is None:
|
|
beta = 0.5
|
|
beta = _execute.make_float(beta, "beta")
|
|
_attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, ], _dtypes.float32)
|
|
_inputs_flat = [input]
|
|
_attrs = ("depth_radius", depth_radius, "bias", bias, "alpha", alpha,
|
|
"beta", beta, "T", _attr_T)
|
|
_result = _execute.execute(b"LRN", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"LRN", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def lrn_grad(input_grads, input_image, output_image, depth_radius=5, bias=1, alpha=1, beta=0.5, name=None):
|
|
r"""Gradients for Local Response Normalization.
|
|
|
|
Args:
|
|
input_grads: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`.
|
|
4-D with shape `[batch, height, width, channels]`.
|
|
input_image: A `Tensor`. Must have the same type as `input_grads`.
|
|
4-D with shape `[batch, height, width, channels]`.
|
|
output_image: A `Tensor`. Must have the same type as `input_grads`.
|
|
4-D with shape `[batch, height, width, channels]`.
|
|
depth_radius: An optional `int`. Defaults to `5`. A depth radius.
|
|
bias: An optional `float`. Defaults to `1`.
|
|
An offset (usually > 0 to avoid dividing by 0).
|
|
alpha: An optional `float`. Defaults to `1`.
|
|
A scale factor, usually positive.
|
|
beta: An optional `float`. Defaults to `0.5`. An exponent.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input_grads`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "LRNGrad", name, input_grads, input_image, output_image,
|
|
"depth_radius", depth_radius, "bias", bias, "alpha", alpha, "beta",
|
|
beta)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return lrn_grad_eager_fallback(
|
|
input_grads, input_image, output_image, depth_radius=depth_radius,
|
|
bias=bias, alpha=alpha, beta=beta, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if depth_radius is None:
|
|
depth_radius = 5
|
|
depth_radius = _execute.make_int(depth_radius, "depth_radius")
|
|
if bias is None:
|
|
bias = 1
|
|
bias = _execute.make_float(bias, "bias")
|
|
if alpha is None:
|
|
alpha = 1
|
|
alpha = _execute.make_float(alpha, "alpha")
|
|
if beta is None:
|
|
beta = 0.5
|
|
beta = _execute.make_float(beta, "beta")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"LRNGrad", input_grads=input_grads, input_image=input_image,
|
|
output_image=output_image, depth_radius=depth_radius,
|
|
bias=bias, alpha=alpha, beta=beta, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("depth_radius", _op._get_attr_int("depth_radius"), "bias",
|
|
_op.get_attr("bias"), "alpha", _op.get_attr("alpha"), "beta",
|
|
_op.get_attr("beta"), "T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"LRNGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
LRNGrad = tf_export("raw_ops.LRNGrad")(_ops.to_raw_op(lrn_grad))
|
|
|
|
|
|
def lrn_grad_eager_fallback(input_grads, input_image, output_image, depth_radius, bias, alpha, beta, name, ctx):
|
|
if depth_radius is None:
|
|
depth_radius = 5
|
|
depth_radius = _execute.make_int(depth_radius, "depth_radius")
|
|
if bias is None:
|
|
bias = 1
|
|
bias = _execute.make_float(bias, "bias")
|
|
if alpha is None:
|
|
alpha = 1
|
|
alpha = _execute.make_float(alpha, "alpha")
|
|
if beta is None:
|
|
beta = 0.5
|
|
beta = _execute.make_float(beta, "beta")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input_grads, input_image, output_image], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, ], _dtypes.float32)
|
|
(input_grads, input_image, output_image) = _inputs_T
|
|
_inputs_flat = [input_grads, input_image, output_image]
|
|
_attrs = ("depth_radius", depth_radius, "bias", bias, "alpha", alpha,
|
|
"beta", beta, "T", _attr_T)
|
|
_result = _execute.execute(b"LRNGrad", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"LRNGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def leaky_relu(features, alpha=0.2, name=None):
|
|
r"""Computes rectified linear: `max(features, features * alpha)`.
|
|
|
|
Args:
|
|
features: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
alpha: An optional `float`. Defaults to `0.2`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `features`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "LeakyRelu", name, features, "alpha", alpha)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return leaky_relu_eager_fallback(
|
|
features, alpha=alpha, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if alpha is None:
|
|
alpha = 0.2
|
|
alpha = _execute.make_float(alpha, "alpha")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"LeakyRelu", features=features, alpha=alpha, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("alpha", _op.get_attr("alpha"), "T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"LeakyRelu", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
LeakyRelu = tf_export("raw_ops.LeakyRelu")(_ops.to_raw_op(leaky_relu))
|
|
|
|
|
|
def leaky_relu_eager_fallback(features, alpha, name, ctx):
|
|
if alpha is None:
|
|
alpha = 0.2
|
|
alpha = _execute.make_float(alpha, "alpha")
|
|
_attr_T, (features,) = _execute.args_to_matching_eager([features], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ], _dtypes.float32)
|
|
_inputs_flat = [features]
|
|
_attrs = ("alpha", alpha, "T", _attr_T)
|
|
_result = _execute.execute(b"LeakyRelu", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"LeakyRelu", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def leaky_relu_grad(gradients, features, alpha=0.2, name=None):
|
|
r"""Computes rectified linear gradients for a LeakyRelu operation.
|
|
|
|
Args:
|
|
gradients: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
The backpropagated gradients to the corresponding LeakyRelu operation.
|
|
features: A `Tensor`. Must have the same type as `gradients`.
|
|
The features passed as input to the corresponding LeakyRelu operation,
|
|
|
|
OR the outputs of that operation (both work equivalently).
|
|
alpha: An optional `float`. Defaults to `0.2`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `gradients`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "LeakyReluGrad", name, gradients, features, "alpha", alpha)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return leaky_relu_grad_eager_fallback(
|
|
gradients, features, alpha=alpha, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if alpha is None:
|
|
alpha = 0.2
|
|
alpha = _execute.make_float(alpha, "alpha")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"LeakyReluGrad", gradients=gradients, features=features, alpha=alpha,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("alpha", _op.get_attr("alpha"), "T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"LeakyReluGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
LeakyReluGrad = tf_export("raw_ops.LeakyReluGrad")(_ops.to_raw_op(leaky_relu_grad))
|
|
|
|
|
|
def leaky_relu_grad_eager_fallback(gradients, features, alpha, name, ctx):
|
|
if alpha is None:
|
|
alpha = 0.2
|
|
alpha = _execute.make_float(alpha, "alpha")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([gradients, features], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ], _dtypes.float32)
|
|
(gradients, features) = _inputs_T
|
|
_inputs_flat = [gradients, features]
|
|
_attrs = ("alpha", alpha, "T", _attr_T)
|
|
_result = _execute.execute(b"LeakyReluGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"LeakyReluGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def log_softmax(logits, name=None):
|
|
r"""Computes log softmax activations.
|
|
|
|
For each batch `i` and class `j` we have
|
|
|
|
|
|
|
|
logsoftmax[i, j] = logits[i, j] - log(sum(exp(logits[i])))
|
|
|
|
Args:
|
|
logits: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
2-D with shape `[batch_size, num_classes]`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `logits`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "LogSoftmax", name, logits)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return log_softmax_eager_fallback(
|
|
logits, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"LogSoftmax", logits=logits, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"LogSoftmax", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
LogSoftmax = tf_export("raw_ops.LogSoftmax")(_ops.to_raw_op(log_softmax))
|
|
|
|
|
|
def log_softmax_eager_fallback(logits, name, ctx):
|
|
_attr_T, (logits,) = _execute.args_to_matching_eager([logits], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
_inputs_flat = [logits]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"LogSoftmax", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"LogSoftmax", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def max_pool(input, ksize, strides, padding, explicit_paddings=[], data_format="NHWC", name=None):
|
|
r"""Performs max pooling on the input.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`, `int32`, `int64`, `uint8`, `int16`, `int8`, `uint16`, `qint8`.
|
|
4-D input to pool over.
|
|
ksize: A list of `ints` that has length `>= 4`.
|
|
The size of the window for each dimension of the input tensor.
|
|
strides: A list of `ints` that has length `>= 4`.
|
|
The stride of the sliding window for each dimension of the
|
|
|
|
input tensor.
|
|
padding: A `string` from: `"SAME", "VALID", "EXPLICIT"`.
|
|
The type of padding algorithm to use.
|
|
explicit_paddings: An optional list of `ints`. Defaults to `[]`.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW", "NCHW_VECT_C"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "MaxPool", name, input, "ksize", ksize, "strides", strides,
|
|
"padding", padding, "explicit_paddings", explicit_paddings,
|
|
"data_format", data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return max_pool_eager_fallback(
|
|
input, ksize=ksize, strides=strides, padding=padding,
|
|
explicit_paddings=explicit_paddings, data_format=data_format,
|
|
name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'max_pool' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"MaxPool", input=input, ksize=ksize, strides=strides, padding=padding,
|
|
explicit_paddings=explicit_paddings,
|
|
data_format=data_format, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "ksize", _op.get_attr("ksize"),
|
|
"strides", _op.get_attr("strides"), "padding",
|
|
_op.get_attr("padding"), "explicit_paddings",
|
|
_op.get_attr("explicit_paddings"), "data_format",
|
|
_op.get_attr("data_format"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"MaxPool", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
MaxPool = tf_export("raw_ops.MaxPool")(_ops.to_raw_op(max_pool))
|
|
|
|
|
|
def max_pool_eager_fallback(input, ksize, strides, padding, explicit_paddings, data_format, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'max_pool' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.int64, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.uint16, _dtypes.qint8, ], _dtypes.float32)
|
|
_inputs_flat = [input]
|
|
_attrs = ("T", _attr_T, "ksize", ksize, "strides", strides, "padding",
|
|
padding, "explicit_paddings", explicit_paddings, "data_format", data_format)
|
|
_result = _execute.execute(b"MaxPool", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"MaxPool", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def max_pool3d(input, ksize, strides, padding, data_format="NDHWC", name=None):
|
|
r"""Performs 3D max pooling on the input.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`.
|
|
Shape `[batch, depth, rows, cols, channels]` tensor to pool over.
|
|
ksize: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The size of the window for each dimension of
|
|
|
|
the input tensor. Must have `ksize[0] = ksize[4] = 1`.
|
|
strides: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The stride of the sliding window for each
|
|
|
|
dimension of `input`. Must have `strides[0] = strides[4] = 1`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`.
|
|
The data format of the input and output data. With the
|
|
|
|
default format "NDHWC", the data is stored in the order of:
|
|
|
|
[batch, in_depth, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCDHW", the data storage order is:
|
|
|
|
[batch, in_channels, in_depth, in_height, in_width].
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "MaxPool3D", name, input, "ksize", ksize, "strides", strides,
|
|
"padding", padding, "data_format", data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return max_pool3d_eager_fallback(
|
|
input, ksize=ksize, strides=strides, padding=padding,
|
|
data_format=data_format, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool3d' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool3d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"MaxPool3D", input=input, ksize=ksize, strides=strides,
|
|
padding=padding, data_format=data_format, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("ksize", _op.get_attr("ksize"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"data_format", _op.get_attr("data_format"), "T",
|
|
_op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"MaxPool3D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
MaxPool3D = tf_export("raw_ops.MaxPool3D")(_ops.to_raw_op(max_pool3d))
|
|
|
|
|
|
def max_pool3d_eager_fallback(input, ksize, strides, padding, data_format, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool3d' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool3d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, ])
|
|
_inputs_flat = [input]
|
|
_attrs = ("ksize", ksize, "strides", strides, "padding", padding,
|
|
"data_format", data_format, "T", _attr_T)
|
|
_result = _execute.execute(b"MaxPool3D", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"MaxPool3D", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def max_pool3d_grad(orig_input, orig_output, grad, ksize, strides, padding, data_format="NDHWC", name=None):
|
|
r"""Computes gradients of 3D max pooling function.
|
|
|
|
Args:
|
|
orig_input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`.
|
|
The original input tensor.
|
|
orig_output: A `Tensor`. Must have the same type as `orig_input`.
|
|
The original output tensor.
|
|
grad: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`.
|
|
Output backprop of shape `[batch, depth, rows, cols, channels]`.
|
|
ksize: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The size of the window for each dimension of
|
|
|
|
the input tensor. Must have `ksize[0] = ksize[4] = 1`.
|
|
strides: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The stride of the sliding window for each
|
|
|
|
dimension of `input`. Must have `strides[0] = strides[4] = 1`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`.
|
|
The data format of the input and output data. With the
|
|
|
|
default format "NDHWC", the data is stored in the order of:
|
|
|
|
[batch, in_depth, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCDHW", the data storage order is:
|
|
|
|
[batch, in_channels, in_depth, in_height, in_width].
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `grad`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "MaxPool3DGrad", name, orig_input, orig_output, grad, "ksize",
|
|
ksize, "strides", strides, "padding", padding, "data_format",
|
|
data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return max_pool3d_grad_eager_fallback(
|
|
orig_input, orig_output, grad, ksize=ksize, strides=strides,
|
|
padding=padding, data_format=data_format, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool3d_grad' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool3d_grad' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"MaxPool3DGrad", orig_input=orig_input, orig_output=orig_output,
|
|
grad=grad, ksize=ksize, strides=strides,
|
|
padding=padding, data_format=data_format, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("ksize", _op.get_attr("ksize"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"data_format", _op.get_attr("data_format"), "T",
|
|
_op._get_attr_type("T"), "TInput", _op._get_attr_type("TInput"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"MaxPool3DGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
MaxPool3DGrad = tf_export("raw_ops.MaxPool3DGrad")(_ops.to_raw_op(max_pool3d_grad))
|
|
|
|
|
|
def max_pool3d_grad_eager_fallback(orig_input, orig_output, grad, ksize, strides, padding, data_format, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool3d_grad' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool3d_grad' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, (grad,) = _execute.args_to_matching_eager([grad], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, ], _dtypes.float32)
|
|
_attr_TInput, _inputs_TInput = _execute.args_to_matching_eager([orig_input, orig_output], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, ], _dtypes.float32)
|
|
(orig_input, orig_output) = _inputs_TInput
|
|
_inputs_flat = [orig_input, orig_output, grad]
|
|
_attrs = ("ksize", ksize, "strides", strides, "padding", padding,
|
|
"data_format", data_format, "T", _attr_T, "TInput", _attr_TInput)
|
|
_result = _execute.execute(b"MaxPool3DGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"MaxPool3DGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def max_pool3d_grad_grad(orig_input, orig_output, grad, ksize, strides, padding, data_format="NDHWC", name=None):
|
|
r"""Computes second-order gradients of the maxpooling function.
|
|
|
|
Args:
|
|
orig_input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
The original input tensor.
|
|
orig_output: A `Tensor`. Must have the same type as `orig_input`.
|
|
The original output tensor.
|
|
grad: A `Tensor`. Must have the same type as `orig_input`.
|
|
Output backprop of shape `[batch, depth, rows, cols, channels]`.
|
|
ksize: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The size of the window for each dimension of
|
|
|
|
the input tensor. Must have `ksize[0] = ksize[4] = 1`.
|
|
strides: A list of `ints` that has length `>= 5`.
|
|
1-D tensor of length 5. The stride of the sliding window for each
|
|
|
|
dimension of `input`. Must have `strides[0] = strides[4] = 1`.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`.
|
|
The data format of the input and output data. With the
|
|
|
|
default format "NDHWC", the data is stored in the order of:
|
|
|
|
[batch, in_depth, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCDHW", the data storage order is:
|
|
|
|
[batch, in_channels, in_depth, in_height, in_width].
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `orig_input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "MaxPool3DGradGrad", name, orig_input, orig_output, grad,
|
|
"ksize", ksize, "strides", strides, "padding", padding, "data_format",
|
|
data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return max_pool3d_grad_grad_eager_fallback(
|
|
orig_input, orig_output, grad, ksize=ksize, strides=strides,
|
|
padding=padding, data_format=data_format, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool3d_grad_grad' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool3d_grad_grad' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"MaxPool3DGradGrad", orig_input=orig_input, orig_output=orig_output,
|
|
grad=grad, ksize=ksize, strides=strides,
|
|
padding=padding, data_format=data_format,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("ksize", _op.get_attr("ksize"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"data_format", _op.get_attr("data_format"), "T",
|
|
_op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"MaxPool3DGradGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
MaxPool3DGradGrad = tf_export("raw_ops.MaxPool3DGradGrad")(_ops.to_raw_op(max_pool3d_grad_grad))
|
|
|
|
|
|
def max_pool3d_grad_grad_eager_fallback(orig_input, orig_output, grad, ksize, strides, padding, data_format, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool3d_grad_grad' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool3d_grad_grad' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NDHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([orig_input, orig_output, grad], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(orig_input, orig_output, grad) = _inputs_T
|
|
_inputs_flat = [orig_input, orig_output, grad]
|
|
_attrs = ("ksize", ksize, "strides", strides, "padding", padding,
|
|
"data_format", data_format, "T", _attr_T)
|
|
_result = _execute.execute(b"MaxPool3DGradGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"MaxPool3DGradGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def max_pool_grad(orig_input, orig_output, grad, ksize, strides, padding, explicit_paddings=[], data_format="NHWC", name=None):
|
|
r"""Computes gradients of the maxpooling function.
|
|
|
|
Args:
|
|
orig_input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
The original input tensor.
|
|
orig_output: A `Tensor`. Must have the same type as `orig_input`.
|
|
The original output tensor.
|
|
grad: A `Tensor`. Must have the same type as `orig_input`.
|
|
4-D. Gradients w.r.t. the output of `max_pool`.
|
|
ksize: A list of `ints` that has length `>= 4`.
|
|
The size of the window for each dimension of the input tensor.
|
|
strides: A list of `ints` that has length `>= 4`.
|
|
The stride of the sliding window for each dimension of the
|
|
|
|
input tensor.
|
|
padding: A `string` from: `"SAME", "VALID", "EXPLICIT"`.
|
|
The type of padding algorithm to use.
|
|
explicit_paddings: An optional list of `ints`. Defaults to `[]`.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `orig_input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "MaxPoolGrad", name, orig_input, orig_output, grad, "ksize",
|
|
ksize, "strides", strides, "padding", padding, "explicit_paddings",
|
|
explicit_paddings, "data_format", data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return max_pool_grad_eager_fallback(
|
|
orig_input, orig_output, grad, ksize=ksize, strides=strides,
|
|
padding=padding, explicit_paddings=explicit_paddings,
|
|
data_format=data_format, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool_grad' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool_grad' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'max_pool_grad' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"MaxPoolGrad", orig_input=orig_input, orig_output=orig_output,
|
|
grad=grad, ksize=ksize, strides=strides,
|
|
padding=padding, explicit_paddings=explicit_paddings,
|
|
data_format=data_format, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("ksize", _op.get_attr("ksize"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"explicit_paddings", _op.get_attr("explicit_paddings"),
|
|
"data_format", _op.get_attr("data_format"), "T",
|
|
_op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"MaxPoolGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
MaxPoolGrad = tf_export("raw_ops.MaxPoolGrad")(_ops.to_raw_op(max_pool_grad))
|
|
|
|
|
|
def max_pool_grad_eager_fallback(orig_input, orig_output, grad, ksize, strides, padding, explicit_paddings, data_format, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool_grad' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool_grad' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if explicit_paddings is None:
|
|
explicit_paddings = []
|
|
if not isinstance(explicit_paddings, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'explicit_paddings' argument to "
|
|
"'max_pool_grad' Op, not %r." % explicit_paddings)
|
|
explicit_paddings = [_execute.make_int(_i, "explicit_paddings") for _i in explicit_paddings]
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([orig_input, orig_output, grad], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ], _dtypes.float32)
|
|
(orig_input, orig_output, grad) = _inputs_T
|
|
_inputs_flat = [orig_input, orig_output, grad]
|
|
_attrs = ("ksize", ksize, "strides", strides, "padding", padding,
|
|
"explicit_paddings", explicit_paddings, "data_format", data_format, "T",
|
|
_attr_T)
|
|
_result = _execute.execute(b"MaxPoolGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"MaxPoolGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def max_pool_grad_grad(orig_input, orig_output, grad, ksize, strides, padding, data_format="NHWC", name=None):
|
|
r"""Computes second-order gradients of the maxpooling function.
|
|
|
|
Args:
|
|
orig_input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
The original input tensor.
|
|
orig_output: A `Tensor`. Must have the same type as `orig_input`.
|
|
The original output tensor.
|
|
grad: A `Tensor`. Must have the same type as `orig_input`.
|
|
4-D. Gradients of gradients w.r.t. the input of `max_pool`.
|
|
ksize: A list of `ints` that has length `>= 4`.
|
|
The size of the window for each dimension of the input tensor.
|
|
strides: A list of `ints` that has length `>= 4`.
|
|
The stride of the sliding window for each dimension of the
|
|
|
|
input tensor.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `orig_input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "MaxPoolGradGrad", name, orig_input, orig_output, grad, "ksize",
|
|
ksize, "strides", strides, "padding", padding, "data_format",
|
|
data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return max_pool_grad_grad_eager_fallback(
|
|
orig_input, orig_output, grad, ksize=ksize, strides=strides,
|
|
padding=padding, data_format=data_format, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool_grad_grad' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool_grad_grad' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"MaxPoolGradGrad", orig_input=orig_input, orig_output=orig_output,
|
|
grad=grad, ksize=ksize, strides=strides,
|
|
padding=padding, data_format=data_format,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("ksize", _op.get_attr("ksize"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"data_format", _op.get_attr("data_format"), "T",
|
|
_op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"MaxPoolGradGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
MaxPoolGradGrad = tf_export("raw_ops.MaxPoolGradGrad")(_ops.to_raw_op(max_pool_grad_grad))
|
|
|
|
|
|
def max_pool_grad_grad_eager_fallback(orig_input, orig_output, grad, ksize, strides, padding, data_format, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool_grad_grad' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool_grad_grad' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([orig_input, orig_output, grad], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(orig_input, orig_output, grad) = _inputs_T
|
|
_inputs_flat = [orig_input, orig_output, grad]
|
|
_attrs = ("ksize", ksize, "strides", strides, "padding", padding,
|
|
"data_format", data_format, "T", _attr_T)
|
|
_result = _execute.execute(b"MaxPoolGradGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"MaxPoolGradGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def max_pool_grad_grad_v2(orig_input, orig_output, grad, ksize, strides, padding, data_format="NHWC", name=None):
|
|
r"""Computes second-order gradients of the maxpooling function.
|
|
|
|
Args:
|
|
orig_input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
The original input tensor.
|
|
orig_output: A `Tensor`. Must have the same type as `orig_input`.
|
|
The original output tensor.
|
|
grad: A `Tensor`. Must have the same type as `orig_input`.
|
|
4-D. Gradients of gradients w.r.t. the input of `max_pool`.
|
|
ksize: A `Tensor` of type `int32`.
|
|
The size of the window for each dimension of the input tensor.
|
|
strides: A `Tensor` of type `int32`.
|
|
The stride of the sliding window for each dimension of the
|
|
|
|
input tensor.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `orig_input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "MaxPoolGradGradV2", name, orig_input, orig_output, grad, ksize,
|
|
strides, "padding", padding, "data_format", data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return max_pool_grad_grad_v2_eager_fallback(
|
|
orig_input, orig_output, grad, ksize, strides, padding=padding,
|
|
data_format=data_format, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"MaxPoolGradGradV2", orig_input=orig_input, orig_output=orig_output,
|
|
grad=grad, ksize=ksize, strides=strides,
|
|
padding=padding, data_format=data_format,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("padding", _op.get_attr("padding"), "data_format",
|
|
_op.get_attr("data_format"), "T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"MaxPoolGradGradV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
MaxPoolGradGradV2 = tf_export("raw_ops.MaxPoolGradGradV2")(_ops.to_raw_op(max_pool_grad_grad_v2))
|
|
|
|
|
|
def max_pool_grad_grad_v2_eager_fallback(orig_input, orig_output, grad, ksize, strides, padding, data_format, name, ctx):
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([orig_input, orig_output, grad], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(orig_input, orig_output, grad) = _inputs_T
|
|
ksize = _ops.convert_to_tensor(ksize, _dtypes.int32)
|
|
strides = _ops.convert_to_tensor(strides, _dtypes.int32)
|
|
_inputs_flat = [orig_input, orig_output, grad, ksize, strides]
|
|
_attrs = ("padding", padding, "data_format", data_format, "T", _attr_T)
|
|
_result = _execute.execute(b"MaxPoolGradGradV2", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"MaxPoolGradGradV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def max_pool_grad_grad_with_argmax(input, grad, argmax, ksize, strides, padding, include_batch_in_index=False, name=None):
|
|
r"""Computes second-order gradients of the maxpooling function.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
The original input.
|
|
grad: A `Tensor`. Must have the same type as `input`.
|
|
4-D with shape `[batch, height, width, channels]`. Gradients w.r.t. the
|
|
|
|
input of `max_pool`.
|
|
argmax: A `Tensor`. Must be one of the following types: `int32`, `int64`.
|
|
The indices of the maximum values chosen for each output of `max_pool`.
|
|
ksize: A list of `ints` that has length `>= 4`.
|
|
The size of the window for each dimension of the input tensor.
|
|
strides: A list of `ints` that has length `>= 4`.
|
|
The stride of the sliding window for each dimension of the
|
|
|
|
input tensor.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
include_batch_in_index: An optional `bool`. Defaults to `False`.
|
|
Whether to include batch dimension in flattened index of `argmax`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "MaxPoolGradGradWithArgmax", name, input, grad, argmax, "ksize",
|
|
ksize, "strides", strides, "padding", padding,
|
|
"include_batch_in_index", include_batch_in_index)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return max_pool_grad_grad_with_argmax_eager_fallback(
|
|
input, grad, argmax, ksize=ksize, strides=strides, padding=padding,
|
|
include_batch_in_index=include_batch_in_index, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool_grad_grad_with_argmax' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool_grad_grad_with_argmax' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if include_batch_in_index is None:
|
|
include_batch_in_index = False
|
|
include_batch_in_index = _execute.make_bool(include_batch_in_index, "include_batch_in_index")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"MaxPoolGradGradWithArgmax", input=input, grad=grad, argmax=argmax,
|
|
ksize=ksize, strides=strides,
|
|
padding=padding,
|
|
include_batch_in_index=include_batch_in_index,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("ksize", _op.get_attr("ksize"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"include_batch_in_index",
|
|
_op._get_attr_bool("include_batch_in_index"), "Targmax",
|
|
_op._get_attr_type("Targmax"), "T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"MaxPoolGradGradWithArgmax", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
MaxPoolGradGradWithArgmax = tf_export("raw_ops.MaxPoolGradGradWithArgmax")(_ops.to_raw_op(max_pool_grad_grad_with_argmax))
|
|
|
|
|
|
def max_pool_grad_grad_with_argmax_eager_fallback(input, grad, argmax, ksize, strides, padding, include_batch_in_index, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool_grad_grad_with_argmax' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool_grad_grad_with_argmax' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if include_batch_in_index is None:
|
|
include_batch_in_index = False
|
|
include_batch_in_index = _execute.make_bool(include_batch_in_index, "include_batch_in_index")
|
|
_attr_Targmax, (argmax,) = _execute.args_to_matching_eager([argmax], ctx, [_dtypes.int32, _dtypes.int64, ])
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, grad], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(input, grad) = _inputs_T
|
|
_inputs_flat = [input, grad, argmax]
|
|
_attrs = ("ksize", ksize, "strides", strides, "padding", padding,
|
|
"include_batch_in_index", include_batch_in_index, "Targmax", _attr_Targmax,
|
|
"T", _attr_T)
|
|
_result = _execute.execute(b"MaxPoolGradGradWithArgmax", 1,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"MaxPoolGradGradWithArgmax", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def max_pool_grad_v2(orig_input, orig_output, grad, ksize, strides, padding, data_format="NHWC", name=None):
|
|
r"""Computes gradients of the maxpooling function.
|
|
|
|
Args:
|
|
orig_input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
The original input tensor.
|
|
orig_output: A `Tensor`. Must have the same type as `orig_input`.
|
|
The original output tensor.
|
|
grad: A `Tensor`. Must have the same type as `orig_input`.
|
|
4-D. Gradients w.r.t. the output of `max_pool`.
|
|
ksize: A `Tensor` of type `int32`.
|
|
The size of the window for each dimension of the input tensor.
|
|
strides: A `Tensor` of type `int32`.
|
|
The stride of the sliding window for each dimension of the
|
|
|
|
input tensor.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `orig_input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "MaxPoolGradV2", name, orig_input, orig_output, grad, ksize,
|
|
strides, "padding", padding, "data_format", data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return max_pool_grad_v2_eager_fallback(
|
|
orig_input, orig_output, grad, ksize, strides, padding=padding,
|
|
data_format=data_format, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"MaxPoolGradV2", orig_input=orig_input, orig_output=orig_output,
|
|
grad=grad, ksize=ksize, strides=strides,
|
|
padding=padding, data_format=data_format, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("padding", _op.get_attr("padding"), "data_format",
|
|
_op.get_attr("data_format"), "T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"MaxPoolGradV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
MaxPoolGradV2 = tf_export("raw_ops.MaxPoolGradV2")(_ops.to_raw_op(max_pool_grad_v2))
|
|
|
|
|
|
def max_pool_grad_v2_eager_fallback(orig_input, orig_output, grad, ksize, strides, padding, data_format, name, ctx):
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([orig_input, orig_output, grad], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ], _dtypes.float32)
|
|
(orig_input, orig_output, grad) = _inputs_T
|
|
ksize = _ops.convert_to_tensor(ksize, _dtypes.int32)
|
|
strides = _ops.convert_to_tensor(strides, _dtypes.int32)
|
|
_inputs_flat = [orig_input, orig_output, grad, ksize, strides]
|
|
_attrs = ("padding", padding, "data_format", data_format, "T", _attr_T)
|
|
_result = _execute.execute(b"MaxPoolGradV2", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"MaxPoolGradV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def max_pool_grad_with_argmax(input, grad, argmax, ksize, strides, padding, include_batch_in_index=False, name=None):
|
|
r"""Computes gradients of the maxpooling function.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
The original input.
|
|
grad: A `Tensor`. Must have the same type as `input`.
|
|
4-D with shape `[batch, height, width, channels]`. Gradients w.r.t. the
|
|
|
|
output of `max_pool`.
|
|
argmax: A `Tensor`. Must be one of the following types: `int32`, `int64`.
|
|
The indices of the maximum values chosen for each output of `max_pool`.
|
|
ksize: A list of `ints` that has length `>= 4`.
|
|
The size of the window for each dimension of the input tensor.
|
|
strides: A list of `ints` that has length `>= 4`.
|
|
The stride of the sliding window for each dimension of the
|
|
|
|
input tensor.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
include_batch_in_index: An optional `bool`. Defaults to `False`.
|
|
Whether to include batch dimension in flattened index of `argmax`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "MaxPoolGradWithArgmax", name, input, grad, argmax, "ksize",
|
|
ksize, "strides", strides, "padding", padding,
|
|
"include_batch_in_index", include_batch_in_index)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return max_pool_grad_with_argmax_eager_fallback(
|
|
input, grad, argmax, ksize=ksize, strides=strides, padding=padding,
|
|
include_batch_in_index=include_batch_in_index, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool_grad_with_argmax' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool_grad_with_argmax' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if include_batch_in_index is None:
|
|
include_batch_in_index = False
|
|
include_batch_in_index = _execute.make_bool(include_batch_in_index, "include_batch_in_index")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"MaxPoolGradWithArgmax", input=input, grad=grad, argmax=argmax,
|
|
ksize=ksize, strides=strides,
|
|
padding=padding,
|
|
include_batch_in_index=include_batch_in_index,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("ksize", _op.get_attr("ksize"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"include_batch_in_index",
|
|
_op._get_attr_bool("include_batch_in_index"), "Targmax",
|
|
_op._get_attr_type("Targmax"), "T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"MaxPoolGradWithArgmax", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
MaxPoolGradWithArgmax = tf_export("raw_ops.MaxPoolGradWithArgmax")(_ops.to_raw_op(max_pool_grad_with_argmax))
|
|
|
|
|
|
def max_pool_grad_with_argmax_eager_fallback(input, grad, argmax, ksize, strides, padding, include_batch_in_index, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool_grad_with_argmax' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool_grad_with_argmax' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if include_batch_in_index is None:
|
|
include_batch_in_index = False
|
|
include_batch_in_index = _execute.make_bool(include_batch_in_index, "include_batch_in_index")
|
|
_attr_Targmax, (argmax,) = _execute.args_to_matching_eager([argmax], ctx, [_dtypes.int32, _dtypes.int64, ])
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([input, grad], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(input, grad) = _inputs_T
|
|
_inputs_flat = [input, grad, argmax]
|
|
_attrs = ("ksize", ksize, "strides", strides, "padding", padding,
|
|
"include_batch_in_index", include_batch_in_index, "Targmax", _attr_Targmax,
|
|
"T", _attr_T)
|
|
_result = _execute.execute(b"MaxPoolGradWithArgmax", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"MaxPoolGradWithArgmax", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def max_pool_v2(input, ksize, strides, padding, data_format="NHWC", name=None):
|
|
r"""Performs max pooling on the input.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`, `int32`, `int64`, `uint8`, `int16`, `int8`, `uint16`, `qint8`.
|
|
4-D input to pool over.
|
|
ksize: A `Tensor` of type `int32`.
|
|
The size of the window for each dimension of the input tensor.
|
|
strides: A `Tensor` of type `int32`.
|
|
The stride of the sliding window for each dimension of the
|
|
|
|
input tensor.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
data_format: An optional `string` from: `"NHWC", "NCHW", "NCHW_VECT_C"`. Defaults to `"NHWC"`.
|
|
Specify the data format of the input and output data. With the
|
|
|
|
default format "NHWC", the data is stored in the order of:
|
|
|
|
[batch, in_height, in_width, in_channels].
|
|
|
|
Alternatively, the format could be "NCHW", the data storage order of:
|
|
|
|
[batch, in_channels, in_height, in_width].
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "MaxPoolV2", name, input, ksize, strides, "padding", padding,
|
|
"data_format", data_format)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return max_pool_v2_eager_fallback(
|
|
input, ksize, strides, padding=padding, data_format=data_format,
|
|
name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"MaxPoolV2", input=input, ksize=ksize, strides=strides,
|
|
padding=padding, data_format=data_format, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "padding",
|
|
_op.get_attr("padding"), "data_format",
|
|
_op.get_attr("data_format"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"MaxPoolV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
MaxPoolV2 = tf_export("raw_ops.MaxPoolV2")(_ops.to_raw_op(max_pool_v2))
|
|
|
|
|
|
def max_pool_v2_eager_fallback(input, ksize, strides, padding, data_format, name, ctx):
|
|
padding = _execute.make_str(padding, "padding")
|
|
if data_format is None:
|
|
data_format = "NHWC"
|
|
data_format = _execute.make_str(data_format, "data_format")
|
|
_attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.int64, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.uint16, _dtypes.qint8, ], _dtypes.float32)
|
|
ksize = _ops.convert_to_tensor(ksize, _dtypes.int32)
|
|
strides = _ops.convert_to_tensor(strides, _dtypes.int32)
|
|
_inputs_flat = [input, ksize, strides]
|
|
_attrs = ("T", _attr_T, "padding", padding, "data_format", data_format)
|
|
_result = _execute.execute(b"MaxPoolV2", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"MaxPoolV2", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
_MaxPoolWithArgmaxOutput = collections.namedtuple(
|
|
"MaxPoolWithArgmax",
|
|
["output", "argmax"])
|
|
|
|
|
|
def max_pool_with_argmax(input, ksize, strides, padding, Targmax=_dtypes.int64, include_batch_in_index=False, name=None):
|
|
r"""Performs max pooling on the input and outputs both max values and indices.
|
|
|
|
The indices in `argmax` are flattened, so that a maximum value at position
|
|
|
|
`[b, y, x, c]` becomes flattened index:
|
|
|
|
`(y * width + x) * channels + c` if `include_batch_in_index` is False;
|
|
|
|
`((b * height + y) * width + x) * channels + c` if `include_batch_in_index` is True.
|
|
|
|
|
|
|
|
The indices returned are always in `[0, height) x [0, width)` before flattening,
|
|
|
|
even if padding is involved and the mathematically correct answer is outside
|
|
|
|
(either negative or too large). This is a bug, but fixing it is difficult to do
|
|
|
|
in a safe backwards compatible way, especially due to flattening.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
4-D with shape `[batch, height, width, channels]`. Input to pool over.
|
|
ksize: A list of `ints` that has length `>= 4`.
|
|
The size of the window for each dimension of the input tensor.
|
|
strides: A list of `ints` that has length `>= 4`.
|
|
The stride of the sliding window for each dimension of the
|
|
|
|
input tensor.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
Targmax: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int64`.
|
|
include_batch_in_index: An optional `bool`. Defaults to `False`.
|
|
Whether to include batch dimension in flattened index of `argmax`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (output, argmax).
|
|
|
|
output: A `Tensor`. Has the same type as `input`.
|
|
argmax: A `Tensor` of type `Targmax`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "MaxPoolWithArgmax", name, input, "ksize", ksize, "strides",
|
|
strides, "Targmax", Targmax, "padding", padding,
|
|
"include_batch_in_index", include_batch_in_index)
|
|
_result = _MaxPoolWithArgmaxOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return max_pool_with_argmax_eager_fallback(
|
|
input, ksize=ksize, strides=strides, Targmax=Targmax,
|
|
padding=padding, include_batch_in_index=include_batch_in_index,
|
|
name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool_with_argmax' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool_with_argmax' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if Targmax is None:
|
|
Targmax = _dtypes.int64
|
|
Targmax = _execute.make_type(Targmax, "Targmax")
|
|
if include_batch_in_index is None:
|
|
include_batch_in_index = False
|
|
include_batch_in_index = _execute.make_bool(include_batch_in_index, "include_batch_in_index")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"MaxPoolWithArgmax", input=input, ksize=ksize, strides=strides,
|
|
padding=padding, Targmax=Targmax,
|
|
include_batch_in_index=include_batch_in_index,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("ksize", _op.get_attr("ksize"), "strides",
|
|
_op.get_attr("strides"), "Targmax",
|
|
_op._get_attr_type("Targmax"), "padding",
|
|
_op.get_attr("padding"), "include_batch_in_index",
|
|
_op._get_attr_bool("include_batch_in_index"), "T",
|
|
_op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"MaxPoolWithArgmax", _inputs_flat, _attrs, _result)
|
|
_result = _MaxPoolWithArgmaxOutput._make(_result)
|
|
return _result
|
|
|
|
MaxPoolWithArgmax = tf_export("raw_ops.MaxPoolWithArgmax")(_ops.to_raw_op(max_pool_with_argmax))
|
|
|
|
|
|
def max_pool_with_argmax_eager_fallback(input, ksize, strides, padding, Targmax, include_batch_in_index, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'max_pool_with_argmax' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'max_pool_with_argmax' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if Targmax is None:
|
|
Targmax = _dtypes.int64
|
|
Targmax = _execute.make_type(Targmax, "Targmax")
|
|
if include_batch_in_index is None:
|
|
include_batch_in_index = False
|
|
include_batch_in_index = _execute.make_bool(include_batch_in_index, "include_batch_in_index")
|
|
_attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
_inputs_flat = [input]
|
|
_attrs = ("ksize", ksize, "strides", strides, "Targmax", Targmax, "padding",
|
|
padding, "include_batch_in_index", include_batch_in_index, "T", _attr_T)
|
|
_result = _execute.execute(b"MaxPoolWithArgmax", 2, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"MaxPoolWithArgmax", _inputs_flat, _attrs, _result)
|
|
_result = _MaxPoolWithArgmaxOutput._make(_result)
|
|
return _result
|
|
|
|
|
|
def nth_element(input, n, reverse=False, name=None):
|
|
r"""Finds values of the `n`-th order statistic for the last dimension.
|
|
|
|
If the input is a vector (rank-1), finds the entries which is the nth-smallest
|
|
|
|
value in the vector and outputs their values as scalar tensor.
|
|
|
|
|
|
|
|
For matrices (resp. higher rank input), computes the entries which is the
|
|
|
|
nth-smallest value in each row (resp. vector along the last dimension). Thus,
|
|
|
|
|
|
|
|
values.shape = input.shape[:-1]
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
1-D or higher with last dimension at least `n+1`.
|
|
n: A `Tensor` of type `int32`.
|
|
0-D. Position of sorted vector to select along the last dimension (along
|
|
|
|
each row for matrices). Valid range of n is `[0, input.shape[:-1])`
|
|
reverse: An optional `bool`. Defaults to `False`.
|
|
When set to True, find the nth-largest value in the vector and vice
|
|
|
|
versa.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `input`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "NthElement", name, input, n, "reverse", reverse)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return nth_element_eager_fallback(
|
|
input, n, reverse=reverse, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if reverse is None:
|
|
reverse = False
|
|
reverse = _execute.make_bool(reverse, "reverse")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"NthElement", input=input, n=n, reverse=reverse, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("reverse", _op._get_attr_bool("reverse"), "T",
|
|
_op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"NthElement", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
NthElement = tf_export("raw_ops.NthElement")(_ops.to_raw_op(nth_element))
|
|
|
|
|
|
def nth_element_eager_fallback(input, n, reverse, name, ctx):
|
|
if reverse is None:
|
|
reverse = False
|
|
reverse = _execute.make_bool(reverse, "reverse")
|
|
_attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
n = _ops.convert_to_tensor(n, _dtypes.int32)
|
|
_inputs_flat = [input, n]
|
|
_attrs = ("reverse", reverse, "T", _attr_T)
|
|
_result = _execute.execute(b"NthElement", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"NthElement", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
_QuantizedAvgPoolOutput = collections.namedtuple(
|
|
"QuantizedAvgPool",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_avg_pool(input, min_input, max_input, ksize, strides, padding, name=None):
|
|
r"""Produces the average pool of the input tensor for quantized types.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`.
|
|
4-D with shape `[batch, height, width, channels]`.
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedAvgPool", name, input, min_input, max_input, "ksize",
|
|
ksize, "strides", strides, "padding", padding)
|
|
_result = _QuantizedAvgPoolOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_avg_pool_eager_fallback(
|
|
input, min_input, max_input, ksize=ksize, strides=strides,
|
|
padding=padding, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'quantized_avg_pool' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_avg_pool' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedAvgPool", input=input, min_input=min_input,
|
|
max_input=max_input, ksize=ksize, strides=strides,
|
|
padding=padding, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "ksize", _op.get_attr("ksize"),
|
|
"strides", _op.get_attr("strides"), "padding",
|
|
_op.get_attr("padding"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedAvgPool", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedAvgPoolOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedAvgPool = tf_export("raw_ops.QuantizedAvgPool")(_ops.to_raw_op(quantized_avg_pool))
|
|
|
|
|
|
def quantized_avg_pool_eager_fallback(input, min_input, max_input, ksize, strides, padding, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'quantized_avg_pool' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_avg_pool' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
_attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
_inputs_flat = [input, min_input, max_input]
|
|
_attrs = ("T", _attr_T, "ksize", ksize, "strides", strides, "padding",
|
|
padding)
|
|
_result = _execute.execute(b"QuantizedAvgPool", 3, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedAvgPool", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedAvgPoolOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedBatchNormWithGlobalNormalizationOutput = collections.namedtuple(
|
|
"QuantizedBatchNormWithGlobalNormalization",
|
|
["result", "result_min", "result_max"])
|
|
|
|
|
|
def quantized_batch_norm_with_global_normalization(t, t_min, t_max, m, m_min, m_max, v, v_min, v_max, beta, beta_min, beta_max, gamma, gamma_min, gamma_max, out_type, variance_epsilon, scale_after_normalization, name=None):
|
|
r"""Quantized Batch normalization.
|
|
|
|
This op is deprecated and will be removed in the future. Prefer
|
|
|
|
`tf.nn.batch_normalization`.
|
|
|
|
Args:
|
|
t: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`.
|
|
A 4D input Tensor.
|
|
t_min: A `Tensor` of type `float32`.
|
|
The value represented by the lowest quantized input.
|
|
t_max: A `Tensor` of type `float32`.
|
|
The value represented by the highest quantized input.
|
|
m: A `Tensor`. Must have the same type as `t`.
|
|
A 1D mean Tensor with size matching the last dimension of t.
|
|
|
|
This is the first output from tf.nn.moments,
|
|
|
|
or a saved moving average thereof.
|
|
m_min: A `Tensor` of type `float32`.
|
|
The value represented by the lowest quantized mean.
|
|
m_max: A `Tensor` of type `float32`.
|
|
The value represented by the highest quantized mean.
|
|
v: A `Tensor`. Must have the same type as `t`.
|
|
A 1D variance Tensor with size matching the last dimension of t.
|
|
|
|
This is the second output from tf.nn.moments,
|
|
|
|
or a saved moving average thereof.
|
|
v_min: A `Tensor` of type `float32`.
|
|
The value represented by the lowest quantized variance.
|
|
v_max: A `Tensor` of type `float32`.
|
|
The value represented by the highest quantized variance.
|
|
beta: A `Tensor`. Must have the same type as `t`.
|
|
A 1D beta Tensor with size matching the last dimension of t.
|
|
|
|
An offset to be added to the normalized tensor.
|
|
beta_min: A `Tensor` of type `float32`.
|
|
The value represented by the lowest quantized offset.
|
|
beta_max: A `Tensor` of type `float32`.
|
|
The value represented by the highest quantized offset.
|
|
gamma: A `Tensor`. Must have the same type as `t`.
|
|
A 1D gamma Tensor with size matching the last dimension of t.
|
|
|
|
If "scale_after_normalization" is true, this tensor will be multiplied
|
|
|
|
with the normalized tensor.
|
|
gamma_min: A `Tensor` of type `float32`.
|
|
The value represented by the lowest quantized gamma.
|
|
gamma_max: A `Tensor` of type `float32`.
|
|
The value represented by the highest quantized gamma.
|
|
out_type: A `tf.DType` from: `tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16`.
|
|
variance_epsilon: A `float`. A small float number to avoid dividing by 0.
|
|
scale_after_normalization: A `bool`.
|
|
A bool indicating whether the resulted tensor
|
|
|
|
needs to be multiplied with gamma.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (result, result_min, result_max).
|
|
|
|
result: A `Tensor` of type `out_type`.
|
|
result_min: A `Tensor` of type `float32`.
|
|
result_max: A `Tensor` of type `float32`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedBatchNormWithGlobalNormalization", name, t, t_min,
|
|
t_max, m, m_min, m_max, v, v_min, v_max, beta, beta_min, beta_max,
|
|
gamma, gamma_min, gamma_max, "out_type", out_type, "variance_epsilon",
|
|
variance_epsilon, "scale_after_normalization",
|
|
scale_after_normalization)
|
|
_result = _QuantizedBatchNormWithGlobalNormalizationOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_batch_norm_with_global_normalization_eager_fallback(
|
|
t, t_min, t_max, m, m_min, m_max, v, v_min, v_max, beta, beta_min,
|
|
beta_max, gamma, gamma_min, gamma_max, out_type=out_type,
|
|
variance_epsilon=variance_epsilon,
|
|
scale_after_normalization=scale_after_normalization, name=name,
|
|
ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
variance_epsilon = _execute.make_float(variance_epsilon, "variance_epsilon")
|
|
scale_after_normalization = _execute.make_bool(scale_after_normalization, "scale_after_normalization")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedBatchNormWithGlobalNormalization", t=t, t_min=t_min,
|
|
t_max=t_max, m=m,
|
|
m_min=m_min, m_max=m_max,
|
|
v=v, v_min=v_min,
|
|
v_max=v_max, beta=beta,
|
|
beta_min=beta_min,
|
|
beta_max=beta_max,
|
|
gamma=gamma,
|
|
gamma_min=gamma_min,
|
|
gamma_max=gamma_max,
|
|
out_type=out_type,
|
|
variance_epsilon=variance_epsilon,
|
|
scale_after_normalization=scale_after_normalization,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "out_type",
|
|
_op._get_attr_type("out_type"), "variance_epsilon",
|
|
_op.get_attr("variance_epsilon"), "scale_after_normalization",
|
|
_op._get_attr_bool("scale_after_normalization"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedBatchNormWithGlobalNormalization", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedBatchNormWithGlobalNormalizationOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedBatchNormWithGlobalNormalization = tf_export("raw_ops.QuantizedBatchNormWithGlobalNormalization")(_ops.to_raw_op(quantized_batch_norm_with_global_normalization))
|
|
|
|
|
|
def quantized_batch_norm_with_global_normalization_eager_fallback(t, t_min, t_max, m, m_min, m_max, v, v_min, v_max, beta, beta_min, beta_max, gamma, gamma_min, gamma_max, out_type, variance_epsilon, scale_after_normalization, name, ctx):
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
variance_epsilon = _execute.make_float(variance_epsilon, "variance_epsilon")
|
|
scale_after_normalization = _execute.make_bool(scale_after_normalization, "scale_after_normalization")
|
|
_attr_Tinput, _inputs_Tinput = _execute.args_to_matching_eager([t, m, v, beta, gamma], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
(t, m, v, beta, gamma) = _inputs_Tinput
|
|
t_min = _ops.convert_to_tensor(t_min, _dtypes.float32)
|
|
t_max = _ops.convert_to_tensor(t_max, _dtypes.float32)
|
|
m_min = _ops.convert_to_tensor(m_min, _dtypes.float32)
|
|
m_max = _ops.convert_to_tensor(m_max, _dtypes.float32)
|
|
v_min = _ops.convert_to_tensor(v_min, _dtypes.float32)
|
|
v_max = _ops.convert_to_tensor(v_max, _dtypes.float32)
|
|
beta_min = _ops.convert_to_tensor(beta_min, _dtypes.float32)
|
|
beta_max = _ops.convert_to_tensor(beta_max, _dtypes.float32)
|
|
gamma_min = _ops.convert_to_tensor(gamma_min, _dtypes.float32)
|
|
gamma_max = _ops.convert_to_tensor(gamma_max, _dtypes.float32)
|
|
_inputs_flat = [t, t_min, t_max, m, m_min, m_max, v, v_min, v_max, beta, beta_min, beta_max, gamma, gamma_min, gamma_max]
|
|
_attrs = ("Tinput", _attr_Tinput, "out_type", out_type, "variance_epsilon",
|
|
variance_epsilon, "scale_after_normalization", scale_after_normalization)
|
|
_result = _execute.execute(b"QuantizedBatchNormWithGlobalNormalization", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedBatchNormWithGlobalNormalization", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedBatchNormWithGlobalNormalizationOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedBiasAddOutput = collections.namedtuple(
|
|
"QuantizedBiasAdd",
|
|
["output", "min_out", "max_out"])
|
|
|
|
|
|
def quantized_bias_add(input, bias, min_input, max_input, min_bias, max_bias, out_type, name=None):
|
|
r"""Adds Tensor 'bias' to Tensor 'input' for Quantized types.
|
|
|
|
Broadcasts the values of bias on dimensions 0..N-2 of 'input'.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`.
|
|
bias: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`.
|
|
A 1D bias Tensor with size matching the last dimension of 'input'.
|
|
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.
|
|
min_bias: A `Tensor` of type `float32`.
|
|
The float value that the lowest quantized bias value represents.
|
|
max_bias: A `Tensor` of type `float32`.
|
|
The float value that the highest quantized bias value represents.
|
|
out_type: A `tf.DType` from: `tf.qint8, tf.quint8, tf.qint32, tf.qint16, tf.quint16`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (output, min_out, max_out).
|
|
|
|
output: A `Tensor` of type `out_type`.
|
|
min_out: A `Tensor` of type `float32`.
|
|
max_out: A `Tensor` of type `float32`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedBiasAdd", name, input, bias, min_input, max_input,
|
|
min_bias, max_bias, "out_type", out_type)
|
|
_result = _QuantizedBiasAddOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_bias_add_eager_fallback(
|
|
input, bias, min_input, max_input, min_bias, max_bias,
|
|
out_type=out_type, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedBiasAdd", input=input, bias=bias, min_input=min_input,
|
|
max_input=max_input, min_bias=min_bias,
|
|
max_bias=max_bias, out_type=out_type, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T1", _op._get_attr_type("T1"), "T2", _op._get_attr_type("T2"),
|
|
"out_type", _op._get_attr_type("out_type"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedBiasAdd", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedBiasAddOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedBiasAdd = tf_export("raw_ops.QuantizedBiasAdd")(_ops.to_raw_op(quantized_bias_add))
|
|
|
|
|
|
def quantized_bias_add_eager_fallback(input, bias, min_input, max_input, min_bias, max_bias, out_type, name, ctx):
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
_attr_T1, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_T2, (bias,) = _execute.args_to_matching_eager([bias], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_bias = _ops.convert_to_tensor(min_bias, _dtypes.float32)
|
|
max_bias = _ops.convert_to_tensor(max_bias, _dtypes.float32)
|
|
_inputs_flat = [input, bias, min_input, max_input, min_bias, max_bias]
|
|
_attrs = ("T1", _attr_T1, "T2", _attr_T2, "out_type", out_type)
|
|
_result = _execute.execute(b"QuantizedBiasAdd", 3, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedBiasAdd", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedBiasAddOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedConv2DOutput = collections.namedtuple(
|
|
"QuantizedConv2D",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_conv2d(input, filter, min_input, max_input, min_filter, max_filter, strides, padding, out_type=_dtypes.qint32, dilations=[1, 1, 1, 1], name=None):
|
|
r"""Computes a 2D convolution given quantized 4D input and filter tensors.
|
|
|
|
The inputs are quantized tensors where the lowest value represents the real
|
|
|
|
number of the associated minimum, and the highest represents the maximum.
|
|
|
|
This means that you can only interpret the quantized output in the same way, by
|
|
|
|
taking the returned minimum and maximum values into account.
|
|
|
|
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`.
|
|
filter's input_depth dimension must match input's depth dimensions.
|
|
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.
|
|
min_filter: A `Tensor` of type `float32`.
|
|
The float value that the lowest quantized filter value represents.
|
|
max_filter: A `Tensor` of type `float32`.
|
|
The float value that the highest quantized filter value represents.
|
|
strides: A list of `ints`.
|
|
The stride of the sliding window for each dimension of the input
|
|
|
|
tensor.
|
|
padding: A `string` from: `"SAME", "VALID"`.
|
|
The type of padding algorithm to use.
|
|
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]`.
|
|
1-D tensor of length 4. The dilation factor for each dimension of
|
|
|
|
`input`. If set to k > 1, there will be k-1 skipped cells between each
|
|
|
|
filter element on that dimension. The dimension order is determined by the
|
|
|
|
value of `data_format`, see above for details. Dilations in the batch and
|
|
|
|
depth dimensions must be 1.
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedConv2D", name, input, filter, min_input, max_input,
|
|
min_filter, max_filter, "out_type", out_type, "strides", strides,
|
|
"padding", padding, "dilations", dilations)
|
|
_result = _QuantizedConv2DOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_conv2d_eager_fallback(
|
|
input, filter, min_input, max_input, min_filter, max_filter,
|
|
out_type=out_type, strides=strides, padding=padding,
|
|
dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedConv2D", input=input, filter=filter, min_input=min_input,
|
|
max_input=max_input, min_filter=min_filter,
|
|
max_filter=max_filter, strides=strides,
|
|
padding=padding, out_type=out_type,
|
|
dilations=dilations, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedConv2D", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedConv2D = tf_export("raw_ops.QuantizedConv2D")(_ops.to_raw_op(quantized_conv2d))
|
|
|
|
|
|
def quantized_conv2d_eager_fallback(input, filter, min_input, max_input, min_filter, max_filter, strides, padding, out_type, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
_inputs_flat = [input, filter, min_input, max_input, min_filter, max_filter]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "out_type",
|
|
out_type, "strides", strides, "padding", padding, "dilations", dilations)
|
|
_result = _execute.execute(b"QuantizedConv2D", 3, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedConv2D", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedConv2DAndReluOutput = collections.namedtuple(
|
|
"QuantizedConv2DAndRelu",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_conv2d_and_relu(input, filter, min_input, max_input, min_filter, max_filter, strides, padding, out_type=_dtypes.qint32, dilations=[1, 1, 1, 1], padding_list=[], name=None):
|
|
r"""TODO: add doc.
|
|
|
|
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`.
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedConv2DAndRelu", name, input, filter, min_input,
|
|
max_input, min_filter, max_filter, "out_type", out_type, "strides",
|
|
strides, "padding", padding, "dilations", dilations, "padding_list",
|
|
padding_list)
|
|
_result = _QuantizedConv2DAndReluOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_conv2d_and_relu_eager_fallback(
|
|
input, filter, min_input, max_input, min_filter, max_filter,
|
|
out_type=out_type, strides=strides, padding=padding,
|
|
dilations=dilations, padding_list=padding_list, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_and_relu' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_and_relu' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_and_relu' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedConv2DAndRelu", input=input, filter=filter,
|
|
min_input=min_input, max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter, strides=strides,
|
|
padding=padding, out_type=out_type,
|
|
dilations=dilations,
|
|
padding_list=padding_list, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"), "padding_list",
|
|
_op.get_attr("padding_list"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DAndRelu", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DAndReluOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedConv2DAndRelu = tf_export("raw_ops.QuantizedConv2DAndRelu")(_ops.to_raw_op(quantized_conv2d_and_relu))
|
|
|
|
|
|
def quantized_conv2d_and_relu_eager_fallback(input, filter, min_input, max_input, min_filter, max_filter, strides, padding, out_type, dilations, padding_list, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_and_relu' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_and_relu' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_and_relu' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
_inputs_flat = [input, filter, min_input, max_input, min_filter, max_filter]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "out_type",
|
|
out_type, "strides", strides, "padding", padding, "dilations", dilations,
|
|
"padding_list", padding_list)
|
|
_result = _execute.execute(b"QuantizedConv2DAndRelu", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DAndRelu", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DAndReluOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedConv2DAndReluAndRequantizeOutput = collections.namedtuple(
|
|
"QuantizedConv2DAndReluAndRequantize",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_conv2d_and_relu_and_requantize(input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, strides, padding, out_type=_dtypes.quint8, dilations=[1, 1, 1, 1], padding_list=[], name=None):
|
|
r"""TODO: add doc.
|
|
|
|
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`.
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedConv2DAndReluAndRequantize", name, input, filter,
|
|
min_input, max_input, min_filter, max_filter, min_freezed_output,
|
|
max_freezed_output, "out_type", out_type, "strides", strides,
|
|
"padding", padding, "dilations", dilations, "padding_list",
|
|
padding_list)
|
|
_result = _QuantizedConv2DAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_conv2d_and_relu_and_requantize_eager_fallback(
|
|
input, filter, min_input, max_input, min_filter, max_filter,
|
|
min_freezed_output, max_freezed_output, out_type=out_type,
|
|
strides=strides, padding=padding, dilations=dilations,
|
|
padding_list=padding_list, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_and_relu_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_and_relu_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_and_relu_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedConv2DAndReluAndRequantize", input=input, filter=filter,
|
|
min_input=min_input,
|
|
max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter,
|
|
min_freezed_output=min_freezed_output,
|
|
max_freezed_output=max_freezed_output,
|
|
strides=strides,
|
|
padding=padding,
|
|
out_type=out_type,
|
|
dilations=dilations,
|
|
padding_list=padding_list,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"), "padding_list",
|
|
_op.get_attr("padding_list"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DAndReluAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedConv2DAndReluAndRequantize = tf_export("raw_ops.QuantizedConv2DAndReluAndRequantize")(_ops.to_raw_op(quantized_conv2d_and_relu_and_requantize))
|
|
|
|
|
|
def quantized_conv2d_and_relu_and_requantize_eager_fallback(input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, strides, padding, out_type, dilations, padding_list, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_and_relu_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_and_relu_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_and_relu_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
min_freezed_output = _ops.convert_to_tensor(min_freezed_output, _dtypes.float32)
|
|
max_freezed_output = _ops.convert_to_tensor(max_freezed_output, _dtypes.float32)
|
|
_inputs_flat = [input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "out_type",
|
|
out_type, "strides", strides, "padding", padding, "dilations", dilations,
|
|
"padding_list", padding_list)
|
|
_result = _execute.execute(b"QuantizedConv2DAndReluAndRequantize", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DAndReluAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedConv2DAndRequantizeOutput = collections.namedtuple(
|
|
"QuantizedConv2DAndRequantize",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_conv2d_and_requantize(input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, strides, padding, out_type=_dtypes.qint8, dilations=[1, 1, 1, 1], padding_list=[], name=None):
|
|
r"""TODO: add doc.
|
|
|
|
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`.
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedConv2DAndRequantize", name, input, filter, min_input,
|
|
max_input, min_filter, max_filter, min_freezed_output,
|
|
max_freezed_output, "out_type", out_type, "strides", strides,
|
|
"padding", padding, "dilations", dilations, "padding_list",
|
|
padding_list)
|
|
_result = _QuantizedConv2DAndRequantizeOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_conv2d_and_requantize_eager_fallback(
|
|
input, filter, min_input, max_input, min_filter, max_filter,
|
|
min_freezed_output, max_freezed_output, out_type=out_type,
|
|
strides=strides, padding=padding, dilations=dilations,
|
|
padding_list=padding_list, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedConv2DAndRequantize", input=input, filter=filter,
|
|
min_input=min_input,
|
|
max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter,
|
|
min_freezed_output=min_freezed_output,
|
|
max_freezed_output=max_freezed_output,
|
|
strides=strides, padding=padding,
|
|
out_type=out_type,
|
|
dilations=dilations,
|
|
padding_list=padding_list, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"), "padding_list",
|
|
_op.get_attr("padding_list"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedConv2DAndRequantize = tf_export("raw_ops.QuantizedConv2DAndRequantize")(_ops.to_raw_op(quantized_conv2d_and_requantize))
|
|
|
|
|
|
def quantized_conv2d_and_requantize_eager_fallback(input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, strides, padding, out_type, dilations, padding_list, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
min_freezed_output = _ops.convert_to_tensor(min_freezed_output, _dtypes.float32)
|
|
max_freezed_output = _ops.convert_to_tensor(max_freezed_output, _dtypes.float32)
|
|
_inputs_flat = [input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "out_type",
|
|
out_type, "strides", strides, "padding", padding, "dilations", dilations,
|
|
"padding_list", padding_list)
|
|
_result = _execute.execute(b"QuantizedConv2DAndRequantize", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedConv2DPerChannelOutput = collections.namedtuple(
|
|
"QuantizedConv2DPerChannel",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_conv2d_per_channel(input, filter, min_input, max_input, min_filter, max_filter, strides, padding, out_type=_dtypes.qint32, dilations=[1, 1, 1, 1], name=None):
|
|
r"""Computes QuantizedConv2D per channel.
|
|
|
|
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 minimum value of the input tensor
|
|
max_input: A `Tensor` of type `float32`.
|
|
The maximum value of the input tensor.
|
|
min_filter: A `Tensor` of type `float32`.
|
|
The minimum value of the filter tensor.
|
|
max_filter: A `Tensor` of type `float32`.
|
|
The maximum value of the filter 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.qint32`.
|
|
The quantized type of output tensor that needs to be converted.
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedConv2DPerChannel", name, input, filter, min_input,
|
|
max_input, min_filter, max_filter, "out_type", out_type, "strides",
|
|
strides, "padding", padding, "dilations", dilations)
|
|
_result = _QuantizedConv2DPerChannelOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_conv2d_per_channel_eager_fallback(
|
|
input, filter, min_input, max_input, min_filter, max_filter,
|
|
out_type=out_type, strides=strides, padding=padding,
|
|
dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_per_channel' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_per_channel' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedConv2DPerChannel", input=input, filter=filter,
|
|
min_input=min_input, max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter, strides=strides,
|
|
padding=padding, out_type=out_type,
|
|
dilations=dilations, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DPerChannel", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DPerChannelOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedConv2DPerChannel = tf_export("raw_ops.QuantizedConv2DPerChannel")(_ops.to_raw_op(quantized_conv2d_per_channel))
|
|
|
|
|
|
def quantized_conv2d_per_channel_eager_fallback(input, filter, min_input, max_input, min_filter, max_filter, strides, padding, out_type, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_per_channel' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_per_channel' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
_inputs_flat = [input, filter, min_input, max_input, min_filter, max_filter]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "out_type",
|
|
out_type, "strides", strides, "padding", padding, "dilations", dilations)
|
|
_result = _execute.execute(b"QuantizedConv2DPerChannel", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DPerChannel", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DPerChannelOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedConv2DWithBiasOutput = collections.namedtuple(
|
|
"QuantizedConv2DWithBias",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_conv2d_with_bias(input, filter, bias, min_input, max_input, min_filter, max_filter, strides, padding, out_type=_dtypes.qint32, dilations=[1, 1, 1, 1], padding_list=[], name=None):
|
|
r"""TODO: add doc.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedConv2DWithBias", name, input, filter, bias, min_input,
|
|
max_input, min_filter, max_filter, "out_type", out_type, "strides",
|
|
strides, "padding", padding, "dilations", dilations, "padding_list",
|
|
padding_list)
|
|
_result = _QuantizedConv2DWithBiasOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_conv2d_with_bias_eager_fallback(
|
|
input, filter, bias, min_input, max_input, min_filter, max_filter,
|
|
out_type=out_type, strides=strides, padding=padding,
|
|
dilations=dilations, padding_list=padding_list, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedConv2DWithBias", input=input, filter=filter, bias=bias,
|
|
min_input=min_input, max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter, strides=strides,
|
|
padding=padding, out_type=out_type,
|
|
dilations=dilations,
|
|
padding_list=padding_list, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"), "padding_list",
|
|
_op.get_attr("padding_list"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBias", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedConv2DWithBias = tf_export("raw_ops.QuantizedConv2DWithBias")(_ops.to_raw_op(quantized_conv2d_with_bias))
|
|
|
|
|
|
def quantized_conv2d_with_bias_eager_fallback(input, filter, bias, min_input, max_input, min_filter, max_filter, strides, padding, out_type, dilations, padding_list, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
bias = _ops.convert_to_tensor(bias, _dtypes.float32)
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
_inputs_flat = [input, filter, bias, min_input, max_input, min_filter, max_filter]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "out_type",
|
|
out_type, "strides", strides, "padding", padding, "dilations", dilations,
|
|
"padding_list", padding_list)
|
|
_result = _execute.execute(b"QuantizedConv2DWithBias", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBias", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedConv2DWithBiasAndReluOutput = collections.namedtuple(
|
|
"QuantizedConv2DWithBiasAndRelu",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_conv2d_with_bias_and_relu(input, filter, bias, min_input, max_input, min_filter, max_filter, strides, padding, out_type=_dtypes.qint32, dilations=[1, 1, 1, 1], padding_list=[], name=None):
|
|
r"""TODO: add doc.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedConv2DWithBiasAndRelu", name, input, filter, bias,
|
|
min_input, max_input, min_filter, max_filter, "out_type", out_type,
|
|
"strides", strides, "padding", padding, "dilations", dilations,
|
|
"padding_list", padding_list)
|
|
_result = _QuantizedConv2DWithBiasAndReluOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_conv2d_with_bias_and_relu_eager_fallback(
|
|
input, filter, bias, min_input, max_input, min_filter, max_filter,
|
|
out_type=out_type, strides=strides, padding=padding,
|
|
dilations=dilations, padding_list=padding_list, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias_and_relu' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias_and_relu' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias_and_relu' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedConv2DWithBiasAndRelu", input=input, filter=filter,
|
|
bias=bias, min_input=min_input,
|
|
max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter,
|
|
strides=strides, padding=padding,
|
|
out_type=out_type,
|
|
dilations=dilations,
|
|
padding_list=padding_list,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"), "padding_list",
|
|
_op.get_attr("padding_list"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBiasAndRelu", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasAndReluOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedConv2DWithBiasAndRelu = tf_export("raw_ops.QuantizedConv2DWithBiasAndRelu")(_ops.to_raw_op(quantized_conv2d_with_bias_and_relu))
|
|
|
|
|
|
def quantized_conv2d_with_bias_and_relu_eager_fallback(input, filter, bias, min_input, max_input, min_filter, max_filter, strides, padding, out_type, dilations, padding_list, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias_and_relu' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias_and_relu' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias_and_relu' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
bias = _ops.convert_to_tensor(bias, _dtypes.float32)
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
_inputs_flat = [input, filter, bias, min_input, max_input, min_filter, max_filter]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "out_type",
|
|
out_type, "strides", strides, "padding", padding, "dilations", dilations,
|
|
"padding_list", padding_list)
|
|
_result = _execute.execute(b"QuantizedConv2DWithBiasAndRelu", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBiasAndRelu", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasAndReluOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedConv2DWithBiasAndReluAndRequantizeOutput = collections.namedtuple(
|
|
"QuantizedConv2DWithBiasAndReluAndRequantize",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_conv2d_with_bias_and_relu_and_requantize(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, strides, padding, out_type=_dtypes.quint8, dilations=[1, 1, 1, 1], padding_list=[], name=None):
|
|
r"""TODO: add doc.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedConv2DWithBiasAndReluAndRequantize", name, input,
|
|
filter, bias, min_input, max_input, min_filter, max_filter,
|
|
min_freezed_output, max_freezed_output, "out_type", out_type,
|
|
"strides", strides, "padding", padding, "dilations", dilations,
|
|
"padding_list", padding_list)
|
|
_result = _QuantizedConv2DWithBiasAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_conv2d_with_bias_and_relu_and_requantize_eager_fallback(
|
|
input, filter, bias, min_input, max_input, min_filter, max_filter,
|
|
min_freezed_output, max_freezed_output, out_type=out_type,
|
|
strides=strides, padding=padding, dilations=dilations,
|
|
padding_list=padding_list, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias_and_relu_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias_and_relu_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias_and_relu_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedConv2DWithBiasAndReluAndRequantize", input=input,
|
|
filter=filter,
|
|
bias=bias,
|
|
min_input=min_input,
|
|
max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter,
|
|
min_freezed_output=min_freezed_output,
|
|
max_freezed_output=max_freezed_output,
|
|
strides=strides,
|
|
padding=padding,
|
|
out_type=out_type,
|
|
dilations=dilations,
|
|
padding_list=padding_list,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "Tbias",
|
|
_op._get_attr_type("Tbias"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"), "padding_list",
|
|
_op.get_attr("padding_list"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBiasAndReluAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedConv2DWithBiasAndReluAndRequantize = tf_export("raw_ops.QuantizedConv2DWithBiasAndReluAndRequantize")(_ops.to_raw_op(quantized_conv2d_with_bias_and_relu_and_requantize))
|
|
|
|
|
|
def quantized_conv2d_with_bias_and_relu_and_requantize_eager_fallback(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, strides, padding, out_type, dilations, padding_list, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias_and_relu_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias_and_relu_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias_and_relu_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tbias, (bias,) = _execute.args_to_matching_eager([bias], ctx, [_dtypes.float32, _dtypes.qint32, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
min_freezed_output = _ops.convert_to_tensor(min_freezed_output, _dtypes.float32)
|
|
max_freezed_output = _ops.convert_to_tensor(max_freezed_output, _dtypes.float32)
|
|
_inputs_flat = [input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "Tbias",
|
|
_attr_Tbias, "out_type", out_type, "strides", strides, "padding", padding,
|
|
"dilations", dilations, "padding_list", padding_list)
|
|
_result = _execute.execute(b"QuantizedConv2DWithBiasAndReluAndRequantize",
|
|
3, inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBiasAndReluAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedConv2DWithBiasAndRequantizeOutput = collections.namedtuple(
|
|
"QuantizedConv2DWithBiasAndRequantize",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_conv2d_with_bias_and_requantize(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, strides, padding, out_type=_dtypes.qint8, dilations=[1, 1, 1, 1], padding_list=[], name=None):
|
|
r"""TODO: add doc.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedConv2DWithBiasAndRequantize", name, input, filter,
|
|
bias, min_input, max_input, min_filter, max_filter,
|
|
min_freezed_output, max_freezed_output, "out_type", out_type,
|
|
"strides", strides, "padding", padding, "dilations", dilations,
|
|
"padding_list", padding_list)
|
|
_result = _QuantizedConv2DWithBiasAndRequantizeOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_conv2d_with_bias_and_requantize_eager_fallback(
|
|
input, filter, bias, min_input, max_input, min_filter, max_filter,
|
|
min_freezed_output, max_freezed_output, out_type=out_type,
|
|
strides=strides, padding=padding, dilations=dilations,
|
|
padding_list=padding_list, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedConv2DWithBiasAndRequantize", input=input, filter=filter,
|
|
bias=bias,
|
|
min_input=min_input,
|
|
max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter,
|
|
min_freezed_output=min_freezed_output,
|
|
max_freezed_output=max_freezed_output,
|
|
strides=strides,
|
|
padding=padding,
|
|
out_type=out_type,
|
|
dilations=dilations,
|
|
padding_list=padding_list,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "Tbias",
|
|
_op._get_attr_type("Tbias"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"), "padding_list",
|
|
_op.get_attr("padding_list"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBiasAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedConv2DWithBiasAndRequantize = tf_export("raw_ops.QuantizedConv2DWithBiasAndRequantize")(_ops.to_raw_op(quantized_conv2d_with_bias_and_requantize))
|
|
|
|
|
|
def quantized_conv2d_with_bias_and_requantize_eager_fallback(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, strides, padding, out_type, dilations, padding_list, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tbias, (bias,) = _execute.args_to_matching_eager([bias], ctx, [_dtypes.float32, _dtypes.qint32, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
min_freezed_output = _ops.convert_to_tensor(min_freezed_output, _dtypes.float32)
|
|
max_freezed_output = _ops.convert_to_tensor(max_freezed_output, _dtypes.float32)
|
|
_inputs_flat = [input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "Tbias",
|
|
_attr_Tbias, "out_type", out_type, "strides", strides, "padding", padding,
|
|
"dilations", dilations, "padding_list", padding_list)
|
|
_result = _execute.execute(b"QuantizedConv2DWithBiasAndRequantize", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBiasAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedConv2DWithBiasSignedSumAndReluAndRequantizeOutput = collections.namedtuple(
|
|
"QuantizedConv2DWithBiasSignedSumAndReluAndRequantize",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_conv2d_with_bias_signed_sum_and_relu_and_requantize(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=_dtypes.quint8, dilations=[1, 1, 1, 1], padding_list=[], name=None):
|
|
r"""TODO: add doc.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedConv2DWithBiasSignedSumAndReluAndRequantize", name,
|
|
input, filter, bias, min_input, max_input, min_filter, max_filter,
|
|
min_freezed_output, max_freezed_output, summand, min_summand,
|
|
max_summand, "out_type", out_type, "strides", strides, "padding",
|
|
padding, "dilations", dilations, "padding_list", padding_list)
|
|
_result = _QuantizedConv2DWithBiasSignedSumAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_conv2d_with_bias_signed_sum_and_relu_and_requantize_eager_fallback(
|
|
input, filter, bias, min_input, max_input, min_filter, max_filter,
|
|
min_freezed_output, max_freezed_output, summand, min_summand,
|
|
max_summand, out_type=out_type, strides=strides, padding=padding,
|
|
dilations=dilations, padding_list=padding_list, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias_signed_sum_and_relu_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias_signed_sum_and_relu_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias_signed_sum_and_relu_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedConv2DWithBiasSignedSumAndReluAndRequantize", input=input,
|
|
filter=filter,
|
|
bias=bias,
|
|
min_input=min_input,
|
|
max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter,
|
|
min_freezed_output=min_freezed_output,
|
|
max_freezed_output=max_freezed_output,
|
|
summand=summand,
|
|
min_summand=min_summand,
|
|
max_summand=max_summand,
|
|
strides=strides,
|
|
padding=padding,
|
|
out_type=out_type,
|
|
dilations=dilations,
|
|
padding_list=padding_list,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "Tbias",
|
|
_op._get_attr_type("Tbias"), "Tsummand",
|
|
_op._get_attr_type("Tsummand"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"), "padding_list",
|
|
_op.get_attr("padding_list"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBiasSignedSumAndReluAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasSignedSumAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedConv2DWithBiasSignedSumAndReluAndRequantize = tf_export("raw_ops.QuantizedConv2DWithBiasSignedSumAndReluAndRequantize")(_ops.to_raw_op(quantized_conv2d_with_bias_signed_sum_and_relu_and_requantize))
|
|
|
|
|
|
def quantized_conv2d_with_bias_signed_sum_and_relu_and_requantize_eager_fallback(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, dilations, padding_list, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias_signed_sum_and_relu_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias_signed_sum_and_relu_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias_signed_sum_and_relu_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tbias, (bias,) = _execute.args_to_matching_eager([bias], ctx, [_dtypes.float32, _dtypes.qint32, ])
|
|
_attr_Tsummand, (summand,) = _execute.args_to_matching_eager([summand], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
min_freezed_output = _ops.convert_to_tensor(min_freezed_output, _dtypes.float32)
|
|
max_freezed_output = _ops.convert_to_tensor(max_freezed_output, _dtypes.float32)
|
|
min_summand = _ops.convert_to_tensor(min_summand, _dtypes.float32)
|
|
max_summand = _ops.convert_to_tensor(max_summand, _dtypes.float32)
|
|
_inputs_flat = [input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, summand, min_summand, max_summand]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "Tbias",
|
|
_attr_Tbias, "Tsummand", _attr_Tsummand, "out_type", out_type, "strides",
|
|
strides, "padding", padding, "dilations", dilations, "padding_list",
|
|
padding_list)
|
|
_result = _execute.execute(b"QuantizedConv2DWithBiasSignedSumAndReluAndRequantize",
|
|
3, inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBiasSignedSumAndReluAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasSignedSumAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedConv2DWithBiasSumAndReluOutput = collections.namedtuple(
|
|
"QuantizedConv2DWithBiasSumAndRelu",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_conv2d_with_bias_sum_and_relu(input, filter, bias, min_input, max_input, min_filter, max_filter, summand, strides, padding, out_type=_dtypes.qint32, dilations=[1, 1, 1, 1], padding_list=[], name=None):
|
|
r"""TODO: add doc.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedConv2DWithBiasSumAndRelu", name, input, filter, bias,
|
|
min_input, max_input, min_filter, max_filter, summand, "out_type",
|
|
out_type, "strides", strides, "padding", padding, "dilations",
|
|
dilations, "padding_list", padding_list)
|
|
_result = _QuantizedConv2DWithBiasSumAndReluOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_conv2d_with_bias_sum_and_relu_eager_fallback(
|
|
input, filter, bias, min_input, max_input, min_filter, max_filter,
|
|
summand, out_type=out_type, strides=strides, padding=padding,
|
|
dilations=dilations, padding_list=padding_list, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias_sum_and_relu' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias_sum_and_relu' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias_sum_and_relu' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedConv2DWithBiasSumAndRelu", input=input, filter=filter,
|
|
bias=bias, min_input=min_input,
|
|
max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter,
|
|
summand=summand, strides=strides,
|
|
padding=padding,
|
|
out_type=out_type,
|
|
dilations=dilations,
|
|
padding_list=padding_list,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"), "padding_list",
|
|
_op.get_attr("padding_list"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBiasSumAndRelu", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasSumAndReluOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedConv2DWithBiasSumAndRelu = tf_export("raw_ops.QuantizedConv2DWithBiasSumAndRelu")(_ops.to_raw_op(quantized_conv2d_with_bias_sum_and_relu))
|
|
|
|
|
|
def quantized_conv2d_with_bias_sum_and_relu_eager_fallback(input, filter, bias, min_input, max_input, min_filter, max_filter, summand, strides, padding, out_type, dilations, padding_list, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias_sum_and_relu' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias_sum_and_relu' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias_sum_and_relu' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
bias = _ops.convert_to_tensor(bias, _dtypes.float32)
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
summand = _ops.convert_to_tensor(summand, _dtypes.float32)
|
|
_inputs_flat = [input, filter, bias, min_input, max_input, min_filter, max_filter, summand]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "out_type",
|
|
out_type, "strides", strides, "padding", padding, "dilations", dilations,
|
|
"padding_list", padding_list)
|
|
_result = _execute.execute(b"QuantizedConv2DWithBiasSumAndRelu", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBiasSumAndRelu", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasSumAndReluOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedConv2DWithBiasSumAndReluAndRequantizeOutput = collections.namedtuple(
|
|
"QuantizedConv2DWithBiasSumAndReluAndRequantize",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_conv2d_with_bias_sum_and_relu_and_requantize(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=_dtypes.quint8, dilations=[1, 1, 1, 1], padding_list=[], name=None):
|
|
r"""TODO: add doc.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedConv2DWithBiasSumAndReluAndRequantize", name, input,
|
|
filter, bias, min_input, max_input, min_filter, max_filter,
|
|
min_freezed_output, max_freezed_output, summand, min_summand,
|
|
max_summand, "out_type", out_type, "strides", strides, "padding",
|
|
padding, "dilations", dilations, "padding_list", padding_list)
|
|
_result = _QuantizedConv2DWithBiasSumAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_conv2d_with_bias_sum_and_relu_and_requantize_eager_fallback(
|
|
input, filter, bias, min_input, max_input, min_filter, max_filter,
|
|
min_freezed_output, max_freezed_output, summand, min_summand,
|
|
max_summand, out_type=out_type, strides=strides, padding=padding,
|
|
dilations=dilations, padding_list=padding_list, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias_sum_and_relu_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias_sum_and_relu_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias_sum_and_relu_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedConv2DWithBiasSumAndReluAndRequantize", input=input,
|
|
filter=filter,
|
|
bias=bias,
|
|
min_input=min_input,
|
|
max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter,
|
|
min_freezed_output=min_freezed_output,
|
|
max_freezed_output=max_freezed_output,
|
|
summand=summand,
|
|
min_summand=min_summand,
|
|
max_summand=max_summand,
|
|
strides=strides,
|
|
padding=padding,
|
|
out_type=out_type,
|
|
dilations=dilations,
|
|
padding_list=padding_list,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "Tbias",
|
|
_op._get_attr_type("Tbias"), "Tsummand",
|
|
_op._get_attr_type("Tsummand"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"), "padding_list",
|
|
_op.get_attr("padding_list"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBiasSumAndReluAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasSumAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedConv2DWithBiasSumAndReluAndRequantize = tf_export("raw_ops.QuantizedConv2DWithBiasSumAndReluAndRequantize")(_ops.to_raw_op(quantized_conv2d_with_bias_sum_and_relu_and_requantize))
|
|
|
|
|
|
def quantized_conv2d_with_bias_sum_and_relu_and_requantize_eager_fallback(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, dilations, padding_list, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_conv2d_with_bias_sum_and_relu_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_conv2d_with_bias_sum_and_relu_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_conv2d_with_bias_sum_and_relu_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tbias, (bias,) = _execute.args_to_matching_eager([bias], ctx, [_dtypes.float32, _dtypes.qint32, ])
|
|
_attr_Tsummand, (summand,) = _execute.args_to_matching_eager([summand], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
min_freezed_output = _ops.convert_to_tensor(min_freezed_output, _dtypes.float32)
|
|
max_freezed_output = _ops.convert_to_tensor(max_freezed_output, _dtypes.float32)
|
|
min_summand = _ops.convert_to_tensor(min_summand, _dtypes.float32)
|
|
max_summand = _ops.convert_to_tensor(max_summand, _dtypes.float32)
|
|
_inputs_flat = [input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, summand, min_summand, max_summand]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "Tbias",
|
|
_attr_Tbias, "Tsummand", _attr_Tsummand, "out_type", out_type, "strides",
|
|
strides, "padding", padding, "dilations", dilations, "padding_list",
|
|
padding_list)
|
|
_result = _execute.execute(b"QuantizedConv2DWithBiasSumAndReluAndRequantize",
|
|
3, inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedConv2DWithBiasSumAndReluAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedConv2DWithBiasSumAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedDepthwiseConv2DOutput = collections.namedtuple(
|
|
"QuantizedDepthwiseConv2D",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_depthwise_conv2d(input, filter, min_input, max_input, min_filter, max_filter, strides, padding, out_type=_dtypes.qint32, dilations=[1, 1, 1, 1], name=None):
|
|
r"""Computes quantized depthwise Conv2D.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedDepthwiseConv2D", name, input, filter, min_input,
|
|
max_input, min_filter, max_filter, "out_type", out_type, "strides",
|
|
strides, "padding", padding, "dilations", dilations)
|
|
_result = _QuantizedDepthwiseConv2DOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_depthwise_conv2d_eager_fallback(
|
|
input, filter, min_input, max_input, min_filter, max_filter,
|
|
out_type=out_type, strides=strides, padding=padding,
|
|
dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_depthwise_conv2d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_depthwise_conv2d' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedDepthwiseConv2D", input=input, filter=filter,
|
|
min_input=min_input, max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter, strides=strides,
|
|
padding=padding, out_type=out_type,
|
|
dilations=dilations, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedDepthwiseConv2D", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedDepthwiseConv2DOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedDepthwiseConv2D = tf_export("raw_ops.QuantizedDepthwiseConv2D")(_ops.to_raw_op(quantized_depthwise_conv2d))
|
|
|
|
|
|
def quantized_depthwise_conv2d_eager_fallback(input, filter, min_input, max_input, min_filter, max_filter, strides, padding, out_type, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_depthwise_conv2d' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_depthwise_conv2d' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
_inputs_flat = [input, filter, min_input, max_input, min_filter, max_filter]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "out_type",
|
|
out_type, "strides", strides, "padding", padding, "dilations", dilations)
|
|
_result = _execute.execute(b"QuantizedDepthwiseConv2D", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedDepthwiseConv2D", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedDepthwiseConv2DOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedDepthwiseConv2DWithBiasOutput = collections.namedtuple(
|
|
"QuantizedDepthwiseConv2DWithBias",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_depthwise_conv2d_with_bias(input, filter, bias, min_input, max_input, min_filter, max_filter, strides, padding, out_type=_dtypes.qint32, dilations=[1, 1, 1, 1], name=None):
|
|
r"""Computes quantized depthwise Conv2D with Bias.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedDepthwiseConv2DWithBias", name, input, filter, bias,
|
|
min_input, max_input, min_filter, max_filter, "out_type", out_type,
|
|
"strides", strides, "padding", padding, "dilations", dilations)
|
|
_result = _QuantizedDepthwiseConv2DWithBiasOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_depthwise_conv2d_with_bias_eager_fallback(
|
|
input, filter, bias, min_input, max_input, min_filter, max_filter,
|
|
out_type=out_type, strides=strides, padding=padding,
|
|
dilations=dilations, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedDepthwiseConv2DWithBias", input=input, filter=filter,
|
|
bias=bias, min_input=min_input,
|
|
max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter,
|
|
strides=strides, padding=padding,
|
|
out_type=out_type,
|
|
dilations=dilations, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedDepthwiseConv2DWithBias", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedDepthwiseConv2DWithBiasOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedDepthwiseConv2DWithBias = tf_export("raw_ops.QuantizedDepthwiseConv2DWithBias")(_ops.to_raw_op(quantized_depthwise_conv2d_with_bias))
|
|
|
|
|
|
def quantized_depthwise_conv2d_with_bias_eager_fallback(input, filter, bias, min_input, max_input, min_filter, max_filter, strides, padding, out_type, dilations, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
bias = _ops.convert_to_tensor(bias, _dtypes.float32)
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
_inputs_flat = [input, filter, bias, min_input, max_input, min_filter, max_filter]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "out_type",
|
|
out_type, "strides", strides, "padding", padding, "dilations", dilations)
|
|
_result = _execute.execute(b"QuantizedDepthwiseConv2DWithBias", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedDepthwiseConv2DWithBias", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedDepthwiseConv2DWithBiasOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedDepthwiseConv2DWithBiasAndReluOutput = collections.namedtuple(
|
|
"QuantizedDepthwiseConv2DWithBiasAndRelu",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_depthwise_conv2d_with_bias_and_relu(input, filter, bias, min_input, max_input, min_filter, max_filter, strides, padding, out_type=_dtypes.qint32, dilations=[1, 1, 1, 1], padding_list=[], name=None):
|
|
r"""Computes quantized depthwise Conv2D with Bias and Relu.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedDepthwiseConv2DWithBiasAndRelu", name, input, filter,
|
|
bias, min_input, max_input, min_filter, max_filter, "out_type",
|
|
out_type, "strides", strides, "padding", padding, "dilations",
|
|
dilations, "padding_list", padding_list)
|
|
_result = _QuantizedDepthwiseConv2DWithBiasAndReluOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_depthwise_conv2d_with_bias_and_relu_eager_fallback(
|
|
input, filter, bias, min_input, max_input, min_filter, max_filter,
|
|
out_type=out_type, strides=strides, padding=padding,
|
|
dilations=dilations, padding_list=padding_list, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias_and_relu' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias_and_relu' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias_and_relu' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedDepthwiseConv2DWithBiasAndRelu", input=input, filter=filter,
|
|
bias=bias,
|
|
min_input=min_input,
|
|
max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter,
|
|
strides=strides,
|
|
padding=padding,
|
|
out_type=out_type,
|
|
dilations=dilations,
|
|
padding_list=padding_list,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"), "padding_list",
|
|
_op.get_attr("padding_list"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedDepthwiseConv2DWithBiasAndRelu", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedDepthwiseConv2DWithBiasAndReluOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedDepthwiseConv2DWithBiasAndRelu = tf_export("raw_ops.QuantizedDepthwiseConv2DWithBiasAndRelu")(_ops.to_raw_op(quantized_depthwise_conv2d_with_bias_and_relu))
|
|
|
|
|
|
def quantized_depthwise_conv2d_with_bias_and_relu_eager_fallback(input, filter, bias, min_input, max_input, min_filter, max_filter, strides, padding, out_type, dilations, padding_list, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias_and_relu' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.qint32
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias_and_relu' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias_and_relu' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
bias = _ops.convert_to_tensor(bias, _dtypes.float32)
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
_inputs_flat = [input, filter, bias, min_input, max_input, min_filter, max_filter]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "out_type",
|
|
out_type, "strides", strides, "padding", padding, "dilations", dilations,
|
|
"padding_list", padding_list)
|
|
_result = _execute.execute(b"QuantizedDepthwiseConv2DWithBiasAndRelu", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedDepthwiseConv2DWithBiasAndRelu", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedDepthwiseConv2DWithBiasAndReluOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedDepthwiseConv2DWithBiasAndReluAndRequantizeOutput = collections.namedtuple(
|
|
"QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_depthwise_conv2d_with_bias_and_relu_and_requantize(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, strides, padding, out_type=_dtypes.quint8, dilations=[1, 1, 1, 1], padding_list=[], name=None):
|
|
r"""Computes quantized depthwise Conv2D with Bias, Relu and Requantize.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize", name,
|
|
input, filter, bias, min_input, max_input, min_filter, max_filter,
|
|
min_freezed_output, max_freezed_output, "out_type", out_type,
|
|
"strides", strides, "padding", padding, "dilations", dilations,
|
|
"padding_list", padding_list)
|
|
_result = _QuantizedDepthwiseConv2DWithBiasAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_depthwise_conv2d_with_bias_and_relu_and_requantize_eager_fallback(
|
|
input, filter, bias, min_input, max_input, min_filter, max_filter,
|
|
min_freezed_output, max_freezed_output, out_type=out_type,
|
|
strides=strides, padding=padding, dilations=dilations,
|
|
padding_list=padding_list, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias_and_relu_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias_and_relu_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias_and_relu_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize", input=input,
|
|
filter=filter,
|
|
bias=bias,
|
|
min_input=min_input,
|
|
max_input=max_input,
|
|
min_filter=min_filter,
|
|
max_filter=max_filter,
|
|
min_freezed_output=min_freezed_output,
|
|
max_freezed_output=max_freezed_output,
|
|
strides=strides,
|
|
padding=padding,
|
|
out_type=out_type,
|
|
dilations=dilations,
|
|
padding_list=padding_list,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "Tfilter",
|
|
_op._get_attr_type("Tfilter"), "Tbias",
|
|
_op._get_attr_type("Tbias"), "out_type",
|
|
_op._get_attr_type("out_type"), "strides",
|
|
_op.get_attr("strides"), "padding", _op.get_attr("padding"),
|
|
"dilations", _op.get_attr("dilations"), "padding_list",
|
|
_op.get_attr("padding_list"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedDepthwiseConv2DWithBiasAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize = tf_export("raw_ops.QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize")(_ops.to_raw_op(quantized_depthwise_conv2d_with_bias_and_relu_and_requantize))
|
|
|
|
|
|
def quantized_depthwise_conv2d_with_bias_and_relu_and_requantize_eager_fallback(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, strides, padding, out_type, dilations, padding_list, name, ctx):
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias_and_relu_and_requantize' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
if dilations is None:
|
|
dilations = [1, 1, 1, 1]
|
|
if not isinstance(dilations, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'dilations' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias_and_relu_and_requantize' Op, not %r." % dilations)
|
|
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
|
|
if padding_list is None:
|
|
padding_list = []
|
|
if not isinstance(padding_list, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'padding_list' argument to "
|
|
"'quantized_depthwise_conv2d_with_bias_and_relu_and_requantize' Op, not %r." % padding_list)
|
|
padding_list = [_execute.make_int(_i, "padding_list") for _i in padding_list]
|
|
_attr_Tinput, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tfilter, (filter,) = _execute.args_to_matching_eager([filter], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tbias, (bias,) = _execute.args_to_matching_eager([bias], ctx, [_dtypes.float32, _dtypes.qint32, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
min_filter = _ops.convert_to_tensor(min_filter, _dtypes.float32)
|
|
max_filter = _ops.convert_to_tensor(max_filter, _dtypes.float32)
|
|
min_freezed_output = _ops.convert_to_tensor(min_freezed_output, _dtypes.float32)
|
|
max_freezed_output = _ops.convert_to_tensor(max_freezed_output, _dtypes.float32)
|
|
_inputs_flat = [input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output]
|
|
_attrs = ("Tinput", _attr_Tinput, "Tfilter", _attr_Tfilter, "Tbias",
|
|
_attr_Tbias, "out_type", out_type, "strides", strides, "padding", padding,
|
|
"dilations", dilations, "padding_list", padding_list)
|
|
_result = _execute.execute(b"QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize",
|
|
3, inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedDepthwiseConv2DWithBiasAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedMatMulWithBiasOutput = collections.namedtuple(
|
|
"QuantizedMatMulWithBias",
|
|
["out", "min_out", "max_out"])
|
|
|
|
|
|
def quantized_mat_mul_with_bias(a, b, bias, min_a, max_a, min_b, max_b, Toutput=_dtypes.qint32, transpose_a=False, transpose_b=False, input_quant_mode="MIN_FIRST", name=None):
|
|
r"""Performs a quantized matrix multiplication of `a` by the matrix `b` with bias
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedMatMulWithBias", name, a, b, bias, min_a, max_a,
|
|
min_b, max_b, "Toutput", Toutput, "transpose_a", transpose_a,
|
|
"transpose_b", transpose_b, "input_quant_mode", input_quant_mode)
|
|
_result = _QuantizedMatMulWithBiasOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_mat_mul_with_bias_eager_fallback(
|
|
a, b, bias, min_a, max_a, min_b, max_b, Toutput=Toutput,
|
|
transpose_a=transpose_a, transpose_b=transpose_b,
|
|
input_quant_mode=input_quant_mode, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if Toutput is None:
|
|
Toutput = _dtypes.qint32
|
|
Toutput = _execute.make_type(Toutput, "Toutput")
|
|
if transpose_a is None:
|
|
transpose_a = False
|
|
transpose_a = _execute.make_bool(transpose_a, "transpose_a")
|
|
if transpose_b is None:
|
|
transpose_b = False
|
|
transpose_b = _execute.make_bool(transpose_b, "transpose_b")
|
|
if input_quant_mode is None:
|
|
input_quant_mode = "MIN_FIRST"
|
|
input_quant_mode = _execute.make_str(input_quant_mode, "input_quant_mode")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedMatMulWithBias", a=a, b=b, bias=bias, min_a=min_a,
|
|
max_a=max_a, min_b=min_b, max_b=max_b,
|
|
Toutput=Toutput, transpose_a=transpose_a,
|
|
transpose_b=transpose_b,
|
|
input_quant_mode=input_quant_mode,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T1", _op._get_attr_type("T1"), "T2", _op._get_attr_type("T2"),
|
|
"Tbias", _op._get_attr_type("Tbias"), "Toutput",
|
|
_op._get_attr_type("Toutput"), "transpose_a",
|
|
_op._get_attr_bool("transpose_a"), "transpose_b",
|
|
_op._get_attr_bool("transpose_b"), "input_quant_mode",
|
|
_op.get_attr("input_quant_mode"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedMatMulWithBias", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedMatMulWithBiasOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedMatMulWithBias = tf_export("raw_ops.QuantizedMatMulWithBias")(_ops.to_raw_op(quantized_mat_mul_with_bias))
|
|
|
|
|
|
def quantized_mat_mul_with_bias_eager_fallback(a, b, bias, min_a, max_a, min_b, max_b, Toutput, transpose_a, transpose_b, input_quant_mode, name, ctx):
|
|
if Toutput is None:
|
|
Toutput = _dtypes.qint32
|
|
Toutput = _execute.make_type(Toutput, "Toutput")
|
|
if transpose_a is None:
|
|
transpose_a = False
|
|
transpose_a = _execute.make_bool(transpose_a, "transpose_a")
|
|
if transpose_b is None:
|
|
transpose_b = False
|
|
transpose_b = _execute.make_bool(transpose_b, "transpose_b")
|
|
if input_quant_mode is None:
|
|
input_quant_mode = "MIN_FIRST"
|
|
input_quant_mode = _execute.make_str(input_quant_mode, "input_quant_mode")
|
|
_attr_T1, (a,) = _execute.args_to_matching_eager([a], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_T2, (b,) = _execute.args_to_matching_eager([b], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tbias, (bias,) = _execute.args_to_matching_eager([bias], ctx, [_dtypes.float32, _dtypes.qint32, ])
|
|
min_a = _ops.convert_to_tensor(min_a, _dtypes.float32)
|
|
max_a = _ops.convert_to_tensor(max_a, _dtypes.float32)
|
|
min_b = _ops.convert_to_tensor(min_b, _dtypes.float32)
|
|
max_b = _ops.convert_to_tensor(max_b, _dtypes.float32)
|
|
_inputs_flat = [a, b, bias, min_a, max_a, min_b, max_b]
|
|
_attrs = ("T1", _attr_T1, "T2", _attr_T2, "Tbias", _attr_Tbias, "Toutput",
|
|
Toutput, "transpose_a", transpose_a, "transpose_b", transpose_b,
|
|
"input_quant_mode", input_quant_mode)
|
|
_result = _execute.execute(b"QuantizedMatMulWithBias", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedMatMulWithBias", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedMatMulWithBiasOutput._make(_result)
|
|
return _result
|
|
|
|
|
|
def quantized_mat_mul_with_bias_and_dequantize(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):
|
|
r"""TODO: add doc.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedMatMulWithBiasAndDequantize", name, a, b, bias, min_a,
|
|
max_a, min_b, max_b, min_freezed_output, max_freezed_output,
|
|
"Toutput", Toutput, "transpose_a", transpose_a, "transpose_b",
|
|
transpose_b, "input_quant_mode", input_quant_mode)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_mat_mul_with_bias_and_dequantize_eager_fallback(
|
|
a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output,
|
|
max_freezed_output, Toutput=Toutput, transpose_a=transpose_a,
|
|
transpose_b=transpose_b, input_quant_mode=input_quant_mode,
|
|
name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
Toutput = _execute.make_type(Toutput, "Toutput")
|
|
if transpose_a is None:
|
|
transpose_a = False
|
|
transpose_a = _execute.make_bool(transpose_a, "transpose_a")
|
|
if transpose_b is None:
|
|
transpose_b = False
|
|
transpose_b = _execute.make_bool(transpose_b, "transpose_b")
|
|
if input_quant_mode is None:
|
|
input_quant_mode = "MIN_FIRST"
|
|
input_quant_mode = _execute.make_str(input_quant_mode, "input_quant_mode")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedMatMulWithBiasAndDequantize", a=a, b=b, bias=bias,
|
|
min_a=min_a, max_a=max_a,
|
|
min_b=min_b, max_b=max_b,
|
|
min_freezed_output=min_freezed_output,
|
|
max_freezed_output=max_freezed_output,
|
|
Toutput=Toutput,
|
|
transpose_a=transpose_a,
|
|
transpose_b=transpose_b,
|
|
input_quant_mode=input_quant_mode,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T1", _op._get_attr_type("T1"), "T2", _op._get_attr_type("T2"),
|
|
"Tbias", _op._get_attr_type("Tbias"), "Toutput",
|
|
_op._get_attr_type("Toutput"), "transpose_a",
|
|
_op._get_attr_bool("transpose_a"), "transpose_b",
|
|
_op._get_attr_bool("transpose_b"), "input_quant_mode",
|
|
_op.get_attr("input_quant_mode"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedMatMulWithBiasAndDequantize", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
QuantizedMatMulWithBiasAndDequantize = tf_export("raw_ops.QuantizedMatMulWithBiasAndDequantize")(_ops.to_raw_op(quantized_mat_mul_with_bias_and_dequantize))
|
|
|
|
|
|
def quantized_mat_mul_with_bias_and_dequantize_eager_fallback(a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output, Toutput, transpose_a, transpose_b, input_quant_mode, name, ctx):
|
|
Toutput = _execute.make_type(Toutput, "Toutput")
|
|
if transpose_a is None:
|
|
transpose_a = False
|
|
transpose_a = _execute.make_bool(transpose_a, "transpose_a")
|
|
if transpose_b is None:
|
|
transpose_b = False
|
|
transpose_b = _execute.make_bool(transpose_b, "transpose_b")
|
|
if input_quant_mode is None:
|
|
input_quant_mode = "MIN_FIRST"
|
|
input_quant_mode = _execute.make_str(input_quant_mode, "input_quant_mode")
|
|
_attr_T1, (a,) = _execute.args_to_matching_eager([a], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_T2, (b,) = _execute.args_to_matching_eager([b], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tbias, (bias,) = _execute.args_to_matching_eager([bias], ctx, [_dtypes.float32, _dtypes.qint32, ])
|
|
min_a = _ops.convert_to_tensor(min_a, _dtypes.float32)
|
|
max_a = _ops.convert_to_tensor(max_a, _dtypes.float32)
|
|
min_b = _ops.convert_to_tensor(min_b, _dtypes.float32)
|
|
max_b = _ops.convert_to_tensor(max_b, _dtypes.float32)
|
|
min_freezed_output = _ops.convert_to_tensor(min_freezed_output, _dtypes.float32)
|
|
max_freezed_output = _ops.convert_to_tensor(max_freezed_output, _dtypes.float32)
|
|
_inputs_flat = [a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output]
|
|
_attrs = ("T1", _attr_T1, "T2", _attr_T2, "Tbias", _attr_Tbias, "Toutput",
|
|
Toutput, "transpose_a", transpose_a, "transpose_b", transpose_b,
|
|
"input_quant_mode", input_quant_mode)
|
|
_result = _execute.execute(b"QuantizedMatMulWithBiasAndDequantize", 1,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedMatMulWithBiasAndDequantize", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
_QuantizedMatMulWithBiasAndReluOutput = collections.namedtuple(
|
|
"QuantizedMatMulWithBiasAndRelu",
|
|
["out", "min_out", "max_out"])
|
|
|
|
|
|
def quantized_mat_mul_with_bias_and_relu(a, b, bias, min_a, max_a, min_b, max_b, Toutput=_dtypes.qint32, transpose_a=False, transpose_b=False, input_quant_mode="MIN_FIRST", name=None):
|
|
r"""Perform a quantized matrix multiplication of `a` by the matrix `b` with bias
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedMatMulWithBiasAndRelu", name, a, b, bias, min_a,
|
|
max_a, min_b, max_b, "Toutput", Toutput, "transpose_a", transpose_a,
|
|
"transpose_b", transpose_b, "input_quant_mode", input_quant_mode)
|
|
_result = _QuantizedMatMulWithBiasAndReluOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_mat_mul_with_bias_and_relu_eager_fallback(
|
|
a, b, bias, min_a, max_a, min_b, max_b, Toutput=Toutput,
|
|
transpose_a=transpose_a, transpose_b=transpose_b,
|
|
input_quant_mode=input_quant_mode, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if Toutput is None:
|
|
Toutput = _dtypes.qint32
|
|
Toutput = _execute.make_type(Toutput, "Toutput")
|
|
if transpose_a is None:
|
|
transpose_a = False
|
|
transpose_a = _execute.make_bool(transpose_a, "transpose_a")
|
|
if transpose_b is None:
|
|
transpose_b = False
|
|
transpose_b = _execute.make_bool(transpose_b, "transpose_b")
|
|
if input_quant_mode is None:
|
|
input_quant_mode = "MIN_FIRST"
|
|
input_quant_mode = _execute.make_str(input_quant_mode, "input_quant_mode")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedMatMulWithBiasAndRelu", a=a, b=b, bias=bias, min_a=min_a,
|
|
max_a=max_a, min_b=min_b,
|
|
max_b=max_b, Toutput=Toutput,
|
|
transpose_a=transpose_a,
|
|
transpose_b=transpose_b,
|
|
input_quant_mode=input_quant_mode,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T1", _op._get_attr_type("T1"), "T2", _op._get_attr_type("T2"),
|
|
"Toutput", _op._get_attr_type("Toutput"), "transpose_a",
|
|
_op._get_attr_bool("transpose_a"), "transpose_b",
|
|
_op._get_attr_bool("transpose_b"), "input_quant_mode",
|
|
_op.get_attr("input_quant_mode"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedMatMulWithBiasAndRelu", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedMatMulWithBiasAndReluOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedMatMulWithBiasAndRelu = tf_export("raw_ops.QuantizedMatMulWithBiasAndRelu")(_ops.to_raw_op(quantized_mat_mul_with_bias_and_relu))
|
|
|
|
|
|
def quantized_mat_mul_with_bias_and_relu_eager_fallback(a, b, bias, min_a, max_a, min_b, max_b, Toutput, transpose_a, transpose_b, input_quant_mode, name, ctx):
|
|
if Toutput is None:
|
|
Toutput = _dtypes.qint32
|
|
Toutput = _execute.make_type(Toutput, "Toutput")
|
|
if transpose_a is None:
|
|
transpose_a = False
|
|
transpose_a = _execute.make_bool(transpose_a, "transpose_a")
|
|
if transpose_b is None:
|
|
transpose_b = False
|
|
transpose_b = _execute.make_bool(transpose_b, "transpose_b")
|
|
if input_quant_mode is None:
|
|
input_quant_mode = "MIN_FIRST"
|
|
input_quant_mode = _execute.make_str(input_quant_mode, "input_quant_mode")
|
|
_attr_T1, (a,) = _execute.args_to_matching_eager([a], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_T2, (b,) = _execute.args_to_matching_eager([b], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
bias = _ops.convert_to_tensor(bias, _dtypes.float32)
|
|
min_a = _ops.convert_to_tensor(min_a, _dtypes.float32)
|
|
max_a = _ops.convert_to_tensor(max_a, _dtypes.float32)
|
|
min_b = _ops.convert_to_tensor(min_b, _dtypes.float32)
|
|
max_b = _ops.convert_to_tensor(max_b, _dtypes.float32)
|
|
_inputs_flat = [a, b, bias, min_a, max_a, min_b, max_b]
|
|
_attrs = ("T1", _attr_T1, "T2", _attr_T2, "Toutput", Toutput, "transpose_a",
|
|
transpose_a, "transpose_b", transpose_b, "input_quant_mode",
|
|
input_quant_mode)
|
|
_result = _execute.execute(b"QuantizedMatMulWithBiasAndRelu", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedMatMulWithBiasAndRelu", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedMatMulWithBiasAndReluOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedMatMulWithBiasAndReluAndRequantizeOutput = collections.namedtuple(
|
|
"QuantizedMatMulWithBiasAndReluAndRequantize",
|
|
["out", "min_out", "max_out"])
|
|
|
|
|
|
def quantized_mat_mul_with_bias_and_relu_and_requantize(a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output, Toutput=_dtypes.quint8, transpose_a=False, transpose_b=False, input_quant_mode="MIN_FIRST", name=None):
|
|
r"""Perform a quantized matrix multiplication of `a` by the matrix `b` with bias
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedMatMulWithBiasAndReluAndRequantize", name, a, b, bias,
|
|
min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output,
|
|
"Toutput", Toutput, "transpose_a", transpose_a, "transpose_b",
|
|
transpose_b, "input_quant_mode", input_quant_mode)
|
|
_result = _QuantizedMatMulWithBiasAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_mat_mul_with_bias_and_relu_and_requantize_eager_fallback(
|
|
a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output,
|
|
max_freezed_output, Toutput=Toutput, transpose_a=transpose_a,
|
|
transpose_b=transpose_b, input_quant_mode=input_quant_mode,
|
|
name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if Toutput is None:
|
|
Toutput = _dtypes.quint8
|
|
Toutput = _execute.make_type(Toutput, "Toutput")
|
|
if transpose_a is None:
|
|
transpose_a = False
|
|
transpose_a = _execute.make_bool(transpose_a, "transpose_a")
|
|
if transpose_b is None:
|
|
transpose_b = False
|
|
transpose_b = _execute.make_bool(transpose_b, "transpose_b")
|
|
if input_quant_mode is None:
|
|
input_quant_mode = "MIN_FIRST"
|
|
input_quant_mode = _execute.make_str(input_quant_mode, "input_quant_mode")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedMatMulWithBiasAndReluAndRequantize", a=a, b=b, bias=bias,
|
|
min_a=min_a,
|
|
max_a=max_a,
|
|
min_b=min_b,
|
|
max_b=max_b,
|
|
min_freezed_output=min_freezed_output,
|
|
max_freezed_output=max_freezed_output,
|
|
Toutput=Toutput,
|
|
transpose_a=transpose_a,
|
|
transpose_b=transpose_b,
|
|
input_quant_mode=input_quant_mode,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T1", _op._get_attr_type("T1"), "T2", _op._get_attr_type("T2"),
|
|
"Tbias", _op._get_attr_type("Tbias"), "Toutput",
|
|
_op._get_attr_type("Toutput"), "transpose_a",
|
|
_op._get_attr_bool("transpose_a"), "transpose_b",
|
|
_op._get_attr_bool("transpose_b"), "input_quant_mode",
|
|
_op.get_attr("input_quant_mode"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedMatMulWithBiasAndReluAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedMatMulWithBiasAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedMatMulWithBiasAndReluAndRequantize = tf_export("raw_ops.QuantizedMatMulWithBiasAndReluAndRequantize")(_ops.to_raw_op(quantized_mat_mul_with_bias_and_relu_and_requantize))
|
|
|
|
|
|
def quantized_mat_mul_with_bias_and_relu_and_requantize_eager_fallback(a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output, Toutput, transpose_a, transpose_b, input_quant_mode, name, ctx):
|
|
if Toutput is None:
|
|
Toutput = _dtypes.quint8
|
|
Toutput = _execute.make_type(Toutput, "Toutput")
|
|
if transpose_a is None:
|
|
transpose_a = False
|
|
transpose_a = _execute.make_bool(transpose_a, "transpose_a")
|
|
if transpose_b is None:
|
|
transpose_b = False
|
|
transpose_b = _execute.make_bool(transpose_b, "transpose_b")
|
|
if input_quant_mode is None:
|
|
input_quant_mode = "MIN_FIRST"
|
|
input_quant_mode = _execute.make_str(input_quant_mode, "input_quant_mode")
|
|
_attr_T1, (a,) = _execute.args_to_matching_eager([a], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_T2, (b,) = _execute.args_to_matching_eager([b], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tbias, (bias,) = _execute.args_to_matching_eager([bias], ctx, [_dtypes.float32, _dtypes.qint32, ])
|
|
min_a = _ops.convert_to_tensor(min_a, _dtypes.float32)
|
|
max_a = _ops.convert_to_tensor(max_a, _dtypes.float32)
|
|
min_b = _ops.convert_to_tensor(min_b, _dtypes.float32)
|
|
max_b = _ops.convert_to_tensor(max_b, _dtypes.float32)
|
|
min_freezed_output = _ops.convert_to_tensor(min_freezed_output, _dtypes.float32)
|
|
max_freezed_output = _ops.convert_to_tensor(max_freezed_output, _dtypes.float32)
|
|
_inputs_flat = [a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output]
|
|
_attrs = ("T1", _attr_T1, "T2", _attr_T2, "Tbias", _attr_Tbias, "Toutput",
|
|
Toutput, "transpose_a", transpose_a, "transpose_b", transpose_b,
|
|
"input_quant_mode", input_quant_mode)
|
|
_result = _execute.execute(b"QuantizedMatMulWithBiasAndReluAndRequantize",
|
|
3, inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedMatMulWithBiasAndReluAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedMatMulWithBiasAndReluAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedMatMulWithBiasAndRequantizeOutput = collections.namedtuple(
|
|
"QuantizedMatMulWithBiasAndRequantize",
|
|
["out", "min_out", "max_out"])
|
|
|
|
|
|
def quantized_mat_mul_with_bias_and_requantize(a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output, Toutput=_dtypes.quint8, transpose_a=False, transpose_b=False, input_quant_mode="MIN_FIRST", name=None):
|
|
r"""TODO: add doc.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedMatMulWithBiasAndRequantize", name, a, b, bias, min_a,
|
|
max_a, min_b, max_b, min_freezed_output, max_freezed_output,
|
|
"Toutput", Toutput, "transpose_a", transpose_a, "transpose_b",
|
|
transpose_b, "input_quant_mode", input_quant_mode)
|
|
_result = _QuantizedMatMulWithBiasAndRequantizeOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_mat_mul_with_bias_and_requantize_eager_fallback(
|
|
a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output,
|
|
max_freezed_output, Toutput=Toutput, transpose_a=transpose_a,
|
|
transpose_b=transpose_b, input_quant_mode=input_quant_mode,
|
|
name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if Toutput is None:
|
|
Toutput = _dtypes.quint8
|
|
Toutput = _execute.make_type(Toutput, "Toutput")
|
|
if transpose_a is None:
|
|
transpose_a = False
|
|
transpose_a = _execute.make_bool(transpose_a, "transpose_a")
|
|
if transpose_b is None:
|
|
transpose_b = False
|
|
transpose_b = _execute.make_bool(transpose_b, "transpose_b")
|
|
if input_quant_mode is None:
|
|
input_quant_mode = "MIN_FIRST"
|
|
input_quant_mode = _execute.make_str(input_quant_mode, "input_quant_mode")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedMatMulWithBiasAndRequantize", a=a, b=b, bias=bias,
|
|
min_a=min_a, max_a=max_a,
|
|
min_b=min_b, max_b=max_b,
|
|
min_freezed_output=min_freezed_output,
|
|
max_freezed_output=max_freezed_output,
|
|
Toutput=Toutput,
|
|
transpose_a=transpose_a,
|
|
transpose_b=transpose_b,
|
|
input_quant_mode=input_quant_mode,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T1", _op._get_attr_type("T1"), "T2", _op._get_attr_type("T2"),
|
|
"Tbias", _op._get_attr_type("Tbias"), "Toutput",
|
|
_op._get_attr_type("Toutput"), "transpose_a",
|
|
_op._get_attr_bool("transpose_a"), "transpose_b",
|
|
_op._get_attr_bool("transpose_b"), "input_quant_mode",
|
|
_op.get_attr("input_quant_mode"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedMatMulWithBiasAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedMatMulWithBiasAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedMatMulWithBiasAndRequantize = tf_export("raw_ops.QuantizedMatMulWithBiasAndRequantize")(_ops.to_raw_op(quantized_mat_mul_with_bias_and_requantize))
|
|
|
|
|
|
def quantized_mat_mul_with_bias_and_requantize_eager_fallback(a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output, Toutput, transpose_a, transpose_b, input_quant_mode, name, ctx):
|
|
if Toutput is None:
|
|
Toutput = _dtypes.quint8
|
|
Toutput = _execute.make_type(Toutput, "Toutput")
|
|
if transpose_a is None:
|
|
transpose_a = False
|
|
transpose_a = _execute.make_bool(transpose_a, "transpose_a")
|
|
if transpose_b is None:
|
|
transpose_b = False
|
|
transpose_b = _execute.make_bool(transpose_b, "transpose_b")
|
|
if input_quant_mode is None:
|
|
input_quant_mode = "MIN_FIRST"
|
|
input_quant_mode = _execute.make_str(input_quant_mode, "input_quant_mode")
|
|
_attr_T1, (a,) = _execute.args_to_matching_eager([a], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_T2, (b,) = _execute.args_to_matching_eager([b], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
_attr_Tbias, (bias,) = _execute.args_to_matching_eager([bias], ctx, [_dtypes.float32, _dtypes.qint32, ])
|
|
min_a = _ops.convert_to_tensor(min_a, _dtypes.float32)
|
|
max_a = _ops.convert_to_tensor(max_a, _dtypes.float32)
|
|
min_b = _ops.convert_to_tensor(min_b, _dtypes.float32)
|
|
max_b = _ops.convert_to_tensor(max_b, _dtypes.float32)
|
|
min_freezed_output = _ops.convert_to_tensor(min_freezed_output, _dtypes.float32)
|
|
max_freezed_output = _ops.convert_to_tensor(max_freezed_output, _dtypes.float32)
|
|
_inputs_flat = [a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output]
|
|
_attrs = ("T1", _attr_T1, "T2", _attr_T2, "Tbias", _attr_Tbias, "Toutput",
|
|
Toutput, "transpose_a", transpose_a, "transpose_b", transpose_b,
|
|
"input_quant_mode", input_quant_mode)
|
|
_result = _execute.execute(b"QuantizedMatMulWithBiasAndRequantize", 3,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedMatMulWithBiasAndRequantize", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedMatMulWithBiasAndRequantizeOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedMaxPoolOutput = collections.namedtuple(
|
|
"QuantizedMaxPool",
|
|
["output", "min_output", "max_output"])
|
|
|
|
|
|
def quantized_max_pool(input, min_input, max_input, ksize, strides, padding, name=None):
|
|
r"""Produces the max pool of the input tensor for quantized types.
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedMaxPool", name, input, min_input, max_input, "ksize",
|
|
ksize, "strides", strides, "padding", padding)
|
|
_result = _QuantizedMaxPoolOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_max_pool_eager_fallback(
|
|
input, min_input, max_input, ksize=ksize, strides=strides,
|
|
padding=padding, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'quantized_max_pool' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_max_pool' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedMaxPool", input=input, min_input=min_input,
|
|
max_input=max_input, ksize=ksize, strides=strides,
|
|
padding=padding, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "ksize", _op.get_attr("ksize"),
|
|
"strides", _op.get_attr("strides"), "padding",
|
|
_op.get_attr("padding"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedMaxPool", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedMaxPoolOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedMaxPool = tf_export("raw_ops.QuantizedMaxPool")(_ops.to_raw_op(quantized_max_pool))
|
|
|
|
|
|
def quantized_max_pool_eager_fallback(input, min_input, max_input, ksize, strides, padding, name, ctx):
|
|
if not isinstance(ksize, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'ksize' argument to "
|
|
"'quantized_max_pool' Op, not %r." % ksize)
|
|
ksize = [_execute.make_int(_i, "ksize") for _i in ksize]
|
|
if not isinstance(strides, (list, tuple)):
|
|
raise TypeError(
|
|
"Expected list for 'strides' argument to "
|
|
"'quantized_max_pool' Op, not %r." % strides)
|
|
strides = [_execute.make_int(_i, "strides") for _i in strides]
|
|
padding = _execute.make_str(padding, "padding")
|
|
_attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
min_input = _ops.convert_to_tensor(min_input, _dtypes.float32)
|
|
max_input = _ops.convert_to_tensor(max_input, _dtypes.float32)
|
|
_inputs_flat = [input, min_input, max_input]
|
|
_attrs = ("T", _attr_T, "ksize", ksize, "strides", strides, "padding",
|
|
padding)
|
|
_result = _execute.execute(b"QuantizedMaxPool", 3, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedMaxPool", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedMaxPoolOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedReluOutput = collections.namedtuple(
|
|
"QuantizedRelu",
|
|
["activations", "min_activations", "max_activations"])
|
|
|
|
|
|
def quantized_relu(features, min_features, max_features, out_type=_dtypes.quint8, name=None):
|
|
r"""Computes Quantized Rectified Linear: `max(features, 0)`
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedRelu", name, features, min_features, max_features,
|
|
"out_type", out_type)
|
|
_result = _QuantizedReluOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_relu_eager_fallback(
|
|
features, min_features, max_features, out_type=out_type, name=name,
|
|
ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedRelu", features=features, min_features=min_features,
|
|
max_features=max_features, out_type=out_type,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "out_type",
|
|
_op._get_attr_type("out_type"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedRelu", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedReluOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedRelu = tf_export("raw_ops.QuantizedRelu")(_ops.to_raw_op(quantized_relu))
|
|
|
|
|
|
def quantized_relu_eager_fallback(features, min_features, max_features, out_type, name, ctx):
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
_attr_Tinput, (features,) = _execute.args_to_matching_eager([features], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
min_features = _ops.convert_to_tensor(min_features, _dtypes.float32)
|
|
max_features = _ops.convert_to_tensor(max_features, _dtypes.float32)
|
|
_inputs_flat = [features, min_features, max_features]
|
|
_attrs = ("Tinput", _attr_Tinput, "out_type", out_type)
|
|
_result = _execute.execute(b"QuantizedRelu", 3, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedRelu", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedReluOutput._make(_result)
|
|
return _result
|
|
|
|
_QuantizedRelu6Output = collections.namedtuple(
|
|
"QuantizedRelu6",
|
|
["activations", "min_activations", "max_activations"])
|
|
|
|
|
|
def quantized_relu6(features, min_features, max_features, out_type=_dtypes.quint8, name=None):
|
|
r"""Computes Quantized Rectified Linear 6: `min(max(features, 0), 6)`
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedRelu6", name, features, min_features, max_features,
|
|
"out_type", out_type)
|
|
_result = _QuantizedRelu6Output._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_relu6_eager_fallback(
|
|
features, min_features, max_features, out_type=out_type, name=name,
|
|
ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedRelu6", features=features, min_features=min_features,
|
|
max_features=max_features, out_type=out_type,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "out_type",
|
|
_op._get_attr_type("out_type"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedRelu6", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedRelu6Output._make(_result)
|
|
return _result
|
|
|
|
QuantizedRelu6 = tf_export("raw_ops.QuantizedRelu6")(_ops.to_raw_op(quantized_relu6))
|
|
|
|
|
|
def quantized_relu6_eager_fallback(features, min_features, max_features, out_type, name, ctx):
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
_attr_Tinput, (features,) = _execute.args_to_matching_eager([features], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
min_features = _ops.convert_to_tensor(min_features, _dtypes.float32)
|
|
max_features = _ops.convert_to_tensor(max_features, _dtypes.float32)
|
|
_inputs_flat = [features, min_features, max_features]
|
|
_attrs = ("Tinput", _attr_Tinput, "out_type", out_type)
|
|
_result = _execute.execute(b"QuantizedRelu6", 3, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedRelu6", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedRelu6Output._make(_result)
|
|
return _result
|
|
|
|
_QuantizedReluXOutput = collections.namedtuple(
|
|
"QuantizedReluX",
|
|
["activations", "min_activations", "max_activations"])
|
|
|
|
|
|
def quantized_relu_x(features, max_value, min_features, max_features, out_type=_dtypes.quint8, name=None):
|
|
r"""Computes Quantized Rectified Linear X: `min(max(features, 0), max_value)`
|
|
|
|
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`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "QuantizedReluX", name, features, max_value, min_features,
|
|
max_features, "out_type", out_type)
|
|
_result = _QuantizedReluXOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return quantized_relu_x_eager_fallback(
|
|
features, max_value, min_features, max_features, out_type=out_type,
|
|
name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"QuantizedReluX", features=features, max_value=max_value,
|
|
min_features=min_features,
|
|
max_features=max_features, out_type=out_type,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("Tinput", _op._get_attr_type("Tinput"), "out_type",
|
|
_op._get_attr_type("out_type"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"QuantizedReluX", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedReluXOutput._make(_result)
|
|
return _result
|
|
|
|
QuantizedReluX = tf_export("raw_ops.QuantizedReluX")(_ops.to_raw_op(quantized_relu_x))
|
|
|
|
|
|
def quantized_relu_x_eager_fallback(features, max_value, min_features, max_features, out_type, name, ctx):
|
|
if out_type is None:
|
|
out_type = _dtypes.quint8
|
|
out_type = _execute.make_type(out_type, "out_type")
|
|
_attr_Tinput, (features,) = _execute.args_to_matching_eager([features], ctx, [_dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.qint16, _dtypes.quint16, ])
|
|
max_value = _ops.convert_to_tensor(max_value, _dtypes.float32)
|
|
min_features = _ops.convert_to_tensor(min_features, _dtypes.float32)
|
|
max_features = _ops.convert_to_tensor(max_features, _dtypes.float32)
|
|
_inputs_flat = [features, max_value, min_features, max_features]
|
|
_attrs = ("Tinput", _attr_Tinput, "out_type", out_type)
|
|
_result = _execute.execute(b"QuantizedReluX", 3, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"QuantizedReluX", _inputs_flat, _attrs, _result)
|
|
_result = _QuantizedReluXOutput._make(_result)
|
|
return _result
|
|
|
|
|
|
@_dispatch.add_fallback_dispatch_list
|
|
@_dispatch.add_type_based_api_dispatcher
|
|
@tf_export('nn.relu')
|
|
def relu(features, name=None):
|
|
r"""Computes rectified linear: `max(features, 0)`.
|
|
|
|
See: https://en.wikipedia.org/wiki/Rectifier_(neural_networks)
|
|
|
|
Example usage:
|
|
|
|
>>> tf.nn.relu([-2., 0., 3.]).numpy()
|
|
|
|
array([0., 0., 3.], dtype=float32)
|
|
|
|
Args:
|
|
features: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`, `qint8`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `features`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Relu", name, features)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
_result = _dispatcher_for_relu(
|
|
(features, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
return relu_eager_fallback(
|
|
features, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
relu, (), dict(features=features, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
else:
|
|
_result = _dispatcher_for_relu(
|
|
(features, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
# Add nodes to the TensorFlow graph.
|
|
try:
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Relu", features=features, name=name)
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
relu, (), dict(features=features, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Relu", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Relu = tf_export("raw_ops.Relu")(_ops.to_raw_op(relu))
|
|
_dispatcher_for_relu = relu._tf_type_based_dispatcher.Dispatch
|
|
|
|
|
|
def relu_eager_fallback(features, name, ctx):
|
|
_attr_T, (features,) = _execute.args_to_matching_eager([features], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, _dtypes.qint8, ])
|
|
_inputs_flat = [features]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"Relu", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Relu", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def relu6(features, name=None):
|
|
r"""Computes rectified linear 6: `min(max(features, 0), 6)`.
|
|
|
|
Args:
|
|
features: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `features`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Relu6", name, features)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return relu6_eager_fallback(
|
|
features, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Relu6", features=features, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Relu6", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Relu6 = tf_export("raw_ops.Relu6")(_ops.to_raw_op(relu6))
|
|
|
|
|
|
def relu6_eager_fallback(features, name, ctx):
|
|
_attr_T, (features,) = _execute.args_to_matching_eager([features], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
_inputs_flat = [features]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"Relu6", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Relu6", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def relu6_grad(gradients, features, name=None):
|
|
r"""Computes rectified linear 6 gradients for a Relu6 operation.
|
|
|
|
Args:
|
|
gradients: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
The backpropagated gradients to the corresponding Relu6 operation.
|
|
features: A `Tensor`. Must have the same type as `gradients`.
|
|
The features passed as input to the corresponding Relu6 operation, or
|
|
|
|
its output; using either one produces the same result.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `gradients`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Relu6Grad", name, gradients, features)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return relu6_grad_eager_fallback(
|
|
gradients, features, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Relu6Grad", gradients=gradients, features=features, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Relu6Grad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Relu6Grad = tf_export("raw_ops.Relu6Grad")(_ops.to_raw_op(relu6_grad))
|
|
|
|
|
|
def relu6_grad_eager_fallback(gradients, features, name, ctx):
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([gradients, features], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(gradients, features) = _inputs_T
|
|
_inputs_flat = [gradients, features]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"Relu6Grad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Relu6Grad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def relu_grad(gradients, features, name=None):
|
|
r"""Computes rectified linear gradients for a Relu operation.
|
|
|
|
Args:
|
|
gradients: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
The backpropagated gradients to the corresponding Relu operation.
|
|
features: A `Tensor`. Must have the same type as `gradients`.
|
|
The features passed as input to the corresponding Relu operation, OR
|
|
|
|
the outputs of that operation (both work equivalently).
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `gradients`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "ReluGrad", name, gradients, features)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return relu_grad_eager_fallback(
|
|
gradients, features, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"ReluGrad", gradients=gradients, features=features, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"ReluGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
ReluGrad = tf_export("raw_ops.ReluGrad")(_ops.to_raw_op(relu_grad))
|
|
|
|
|
|
def relu_grad_eager_fallback(gradients, features, name, ctx):
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([gradients, features], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
(gradients, features) = _inputs_T
|
|
_inputs_flat = [gradients, features]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"ReluGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"ReluGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
@_dispatch.add_fallback_dispatch_list
|
|
@_dispatch.add_type_based_api_dispatcher
|
|
@tf_export('nn.selu')
|
|
def selu(features, name=None):
|
|
r"""Computes scaled exponential linear: `scale * alpha * (exp(features) - 1)`
|
|
|
|
if < 0, `scale * features` otherwise.
|
|
|
|
|
|
|
|
To be used together with
|
|
|
|
`initializer = tf.variance_scaling_initializer(factor=1.0, mode='FAN_IN')`.
|
|
|
|
For correct dropout, use `tf.contrib.nn.alpha_dropout`.
|
|
|
|
|
|
|
|
See [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515)
|
|
|
|
Args:
|
|
features: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `features`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Selu", name, features)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
_result = _dispatcher_for_selu(
|
|
(features, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
return selu_eager_fallback(
|
|
features, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
selu, (), dict(features=features, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
else:
|
|
_result = _dispatcher_for_selu(
|
|
(features, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
# Add nodes to the TensorFlow graph.
|
|
try:
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Selu", features=features, name=name)
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
selu, (), dict(features=features, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Selu", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Selu = tf_export("raw_ops.Selu")(_ops.to_raw_op(selu))
|
|
_dispatcher_for_selu = selu._tf_type_based_dispatcher.Dispatch
|
|
|
|
|
|
def selu_eager_fallback(features, name, ctx):
|
|
_attr_T, (features,) = _execute.args_to_matching_eager([features], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
_inputs_flat = [features]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"Selu", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Selu", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def selu_grad(gradients, outputs, name=None):
|
|
r"""Computes gradients for the scaled exponential linear (Selu) operation.
|
|
|
|
Args:
|
|
gradients: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
The backpropagated gradients to the corresponding Selu operation.
|
|
outputs: A `Tensor`. Must have the same type as `gradients`.
|
|
The outputs of the corresponding Selu operation.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `gradients`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "SeluGrad", name, gradients, outputs)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return selu_grad_eager_fallback(
|
|
gradients, outputs, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"SeluGrad", gradients=gradients, outputs=outputs, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"SeluGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
SeluGrad = tf_export("raw_ops.SeluGrad")(_ops.to_raw_op(selu_grad))
|
|
|
|
|
|
def selu_grad_eager_fallback(gradients, outputs, name, ctx):
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([gradients, outputs], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
(gradients, outputs) = _inputs_T
|
|
_inputs_flat = [gradients, outputs]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"SeluGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"SeluGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def softmax(logits, name=None):
|
|
r"""Computes softmax activations.
|
|
|
|
For each batch `i` and class `j` we have
|
|
|
|
|
|
|
|
$$softmax[i, j] = exp(logits[i, j]) / sum_j(exp(logits[i, j]))$$
|
|
|
|
Args:
|
|
logits: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
2-D with shape `[batch_size, num_classes]`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `logits`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Softmax", name, logits)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return softmax_eager_fallback(
|
|
logits, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Softmax", logits=logits, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Softmax", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Softmax = tf_export("raw_ops.Softmax")(_ops.to_raw_op(softmax))
|
|
|
|
|
|
def softmax_eager_fallback(logits, name, ctx):
|
|
_attr_T, (logits,) = _execute.args_to_matching_eager([logits], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
_inputs_flat = [logits]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"Softmax", 1, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Softmax", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
_SoftmaxCrossEntropyWithLogitsOutput = collections.namedtuple(
|
|
"SoftmaxCrossEntropyWithLogits",
|
|
["loss", "backprop"])
|
|
|
|
|
|
def softmax_cross_entropy_with_logits(features, labels, name=None):
|
|
r"""Computes softmax cross entropy cost and gradients to backpropagate.
|
|
|
|
Inputs are the logits, not probabilities.
|
|
|
|
Args:
|
|
features: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
batch_size x num_classes matrix
|
|
labels: A `Tensor`. Must have the same type as `features`.
|
|
batch_size x num_classes matrix
|
|
|
|
The caller must ensure that each batch of labels represents a valid
|
|
|
|
probability distribution.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (loss, backprop).
|
|
|
|
loss: A `Tensor`. Has the same type as `features`.
|
|
backprop: A `Tensor`. Has the same type as `features`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "SoftmaxCrossEntropyWithLogits", name, features, labels)
|
|
_result = _SoftmaxCrossEntropyWithLogitsOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return softmax_cross_entropy_with_logits_eager_fallback(
|
|
features, labels, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"SoftmaxCrossEntropyWithLogits", features=features, labels=labels,
|
|
name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"SoftmaxCrossEntropyWithLogits", _inputs_flat, _attrs, _result)
|
|
_result = _SoftmaxCrossEntropyWithLogitsOutput._make(_result)
|
|
return _result
|
|
|
|
SoftmaxCrossEntropyWithLogits = tf_export("raw_ops.SoftmaxCrossEntropyWithLogits")(_ops.to_raw_op(softmax_cross_entropy_with_logits))
|
|
|
|
|
|
def softmax_cross_entropy_with_logits_eager_fallback(features, labels, name, ctx):
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([features, labels], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
(features, labels) = _inputs_T
|
|
_inputs_flat = [features, labels]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"SoftmaxCrossEntropyWithLogits", 2,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"SoftmaxCrossEntropyWithLogits", _inputs_flat, _attrs, _result)
|
|
_result = _SoftmaxCrossEntropyWithLogitsOutput._make(_result)
|
|
return _result
|
|
|
|
|
|
def softplus(features, name=None):
|
|
r"""TODO: add doc.
|
|
|
|
Args:
|
|
features: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `features`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Softplus", name, features)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return softplus_eager_fallback(
|
|
features, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Softplus", features=features, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Softplus", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Softplus = tf_export("raw_ops.Softplus")(_ops.to_raw_op(softplus))
|
|
|
|
|
|
def softplus_eager_fallback(features, name, ctx):
|
|
_attr_T, (features,) = _execute.args_to_matching_eager([features], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
_inputs_flat = [features]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"Softplus", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Softplus", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def softplus_grad(gradients, features, name=None):
|
|
r"""Computes softplus gradients for a softplus operation.
|
|
|
|
Args:
|
|
gradients: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
The backpropagated gradients to the corresponding softplus operation.
|
|
features: A `Tensor`. Must have the same type as `gradients`.
|
|
The features passed as input to the corresponding softplus operation.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `gradients`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "SoftplusGrad", name, gradients, features)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return softplus_grad_eager_fallback(
|
|
gradients, features, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"SoftplusGrad", gradients=gradients, features=features, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"SoftplusGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
SoftplusGrad = tf_export("raw_ops.SoftplusGrad")(_ops.to_raw_op(softplus_grad))
|
|
|
|
|
|
def softplus_grad_eager_fallback(gradients, features, name, ctx):
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([gradients, features], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
(gradients, features) = _inputs_T
|
|
_inputs_flat = [gradients, features]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"SoftplusGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"SoftplusGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
@_dispatch.add_fallback_dispatch_list
|
|
@_dispatch.add_type_based_api_dispatcher
|
|
@tf_export('nn.softsign', 'math.softsign')
|
|
def softsign(features, name=None):
|
|
r"""Computes softsign: `features / (abs(features) + 1)`.
|
|
|
|
Args:
|
|
features: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `features`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "Softsign", name, features)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
_result = _dispatcher_for_softsign(
|
|
(features, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
return softsign_eager_fallback(
|
|
features, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
softsign, (), dict(features=features, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
else:
|
|
_result = _dispatcher_for_softsign(
|
|
(features, name,), None)
|
|
if _result is not NotImplemented:
|
|
return _result
|
|
# Add nodes to the TensorFlow graph.
|
|
try:
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"Softsign", features=features, name=name)
|
|
except (TypeError, ValueError):
|
|
_result = _dispatch.dispatch(
|
|
softsign, (), dict(features=features, name=name)
|
|
)
|
|
if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
|
|
return _result
|
|
raise
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"Softsign", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
Softsign = tf_export("raw_ops.Softsign")(_ops.to_raw_op(softsign))
|
|
_dispatcher_for_softsign = softsign._tf_type_based_dispatcher.Dispatch
|
|
|
|
|
|
def softsign_eager_fallback(features, name, ctx):
|
|
_attr_T, (features,) = _execute.args_to_matching_eager([features], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
_inputs_flat = [features]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"Softsign", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"Softsign", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
|
|
def softsign_grad(gradients, features, name=None):
|
|
r"""Computes softsign gradients for a softsign operation.
|
|
|
|
Args:
|
|
gradients: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
The backpropagated gradients to the corresponding softsign operation.
|
|
features: A `Tensor`. Must have the same type as `gradients`.
|
|
The features passed as input to the corresponding softsign operation.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A `Tensor`. Has the same type as `gradients`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "SoftsignGrad", name, gradients, features)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return softsign_grad_eager_fallback(
|
|
gradients, features, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"SoftsignGrad", gradients=gradients, features=features, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"SoftsignGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
SoftsignGrad = tf_export("raw_ops.SoftsignGrad")(_ops.to_raw_op(softsign_grad))
|
|
|
|
|
|
def softsign_grad_eager_fallback(gradients, features, name, ctx):
|
|
_attr_T, _inputs_T = _execute.args_to_matching_eager([gradients, features], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
(gradients, features) = _inputs_T
|
|
_inputs_flat = [gradients, features]
|
|
_attrs = ("T", _attr_T)
|
|
_result = _execute.execute(b"SoftsignGrad", 1, inputs=_inputs_flat,
|
|
attrs=_attrs, ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"SoftsignGrad", _inputs_flat, _attrs, _result)
|
|
_result, = _result
|
|
return _result
|
|
|
|
_SparseSoftmaxCrossEntropyWithLogitsOutput = collections.namedtuple(
|
|
"SparseSoftmaxCrossEntropyWithLogits",
|
|
["loss", "backprop"])
|
|
|
|
|
|
def sparse_softmax_cross_entropy_with_logits(features, labels, name=None):
|
|
r"""Computes softmax cross entropy cost and gradients to backpropagate.
|
|
|
|
Unlike `SoftmaxCrossEntropyWithLogits`, this operation does not accept
|
|
|
|
a matrix of label probabilities, but rather a single label per row
|
|
|
|
of features. This label is considered to have probability 1.0 for the
|
|
|
|
given row.
|
|
|
|
|
|
|
|
Inputs are the logits, not probabilities.
|
|
|
|
Args:
|
|
features: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`.
|
|
batch_size x num_classes matrix
|
|
labels: A `Tensor`. Must be one of the following types: `int32`, `int64`.
|
|
batch_size vector with values in [0, num_classes).
|
|
|
|
This is the label for the given minibatch entry.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (loss, backprop).
|
|
|
|
loss: A `Tensor`. Has the same type as `features`.
|
|
backprop: A `Tensor`. Has the same type as `features`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "SparseSoftmaxCrossEntropyWithLogits", name, features, labels)
|
|
_result = _SparseSoftmaxCrossEntropyWithLogitsOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return sparse_softmax_cross_entropy_with_logits_eager_fallback(
|
|
features, labels, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"SparseSoftmaxCrossEntropyWithLogits", features=features,
|
|
labels=labels, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("T", _op._get_attr_type("T"), "Tlabels",
|
|
_op._get_attr_type("Tlabels"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"SparseSoftmaxCrossEntropyWithLogits", _inputs_flat, _attrs, _result)
|
|
_result = _SparseSoftmaxCrossEntropyWithLogitsOutput._make(_result)
|
|
return _result
|
|
|
|
SparseSoftmaxCrossEntropyWithLogits = tf_export("raw_ops.SparseSoftmaxCrossEntropyWithLogits")(_ops.to_raw_op(sparse_softmax_cross_entropy_with_logits))
|
|
|
|
|
|
def sparse_softmax_cross_entropy_with_logits_eager_fallback(features, labels, name, ctx):
|
|
_attr_T, (features,) = _execute.args_to_matching_eager([features], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ])
|
|
_attr_Tlabels, (labels,) = _execute.args_to_matching_eager([labels], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int64)
|
|
_inputs_flat = [features, labels]
|
|
_attrs = ("T", _attr_T, "Tlabels", _attr_Tlabels)
|
|
_result = _execute.execute(b"SparseSoftmaxCrossEntropyWithLogits", 2,
|
|
inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
|
|
name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"SparseSoftmaxCrossEntropyWithLogits", _inputs_flat, _attrs, _result)
|
|
_result = _SparseSoftmaxCrossEntropyWithLogitsOutput._make(_result)
|
|
return _result
|
|
|
|
_TopKOutput = collections.namedtuple(
|
|
"TopK",
|
|
["values", "indices"])
|
|
|
|
|
|
def top_k(input, k, sorted=True, name=None):
|
|
r"""Finds values and indices of the `k` largest elements for the last dimension.
|
|
|
|
If the input is a vector (rank-1), finds the `k` largest entries in the vector
|
|
|
|
and outputs their values and indices as vectors. Thus `values[j]` is the
|
|
|
|
`j`-th largest entry in `input`, and its index is `indices[j]`.
|
|
|
|
|
|
|
|
For matrices (resp. higher rank input), computes the top `k` entries in each
|
|
|
|
row (resp. vector along the last dimension). Thus,
|
|
|
|
|
|
|
|
values.shape = indices.shape = input.shape[:-1] + [k]
|
|
|
|
|
|
|
|
If two elements are equal, the lower-index element appears first.
|
|
|
|
|
|
|
|
If `k` varies dynamically, use `TopKV2` below.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
1-D or higher with last dimension at least `k`.
|
|
k: An `int` that is `>= 0`.
|
|
Number of top elements to look for along the last dimension (along each
|
|
|
|
row for matrices).
|
|
sorted: An optional `bool`. Defaults to `True`.
|
|
If true the resulting `k` elements will be sorted by the values in
|
|
|
|
descending order.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (values, indices).
|
|
|
|
values: A `Tensor`. Has the same type as `input`.
|
|
indices: A `Tensor` of type `int32`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "TopK", name, input, "k", k, "sorted", sorted)
|
|
_result = _TopKOutput._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return top_k_eager_fallback(
|
|
input, k=k, sorted=sorted, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
k = _execute.make_int(k, "k")
|
|
if sorted is None:
|
|
sorted = True
|
|
sorted = _execute.make_bool(sorted, "sorted")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"TopK", input=input, k=k, sorted=sorted, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("k", _op._get_attr_int("k"), "sorted",
|
|
_op._get_attr_bool("sorted"), "T", _op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"TopK", _inputs_flat, _attrs, _result)
|
|
_result = _TopKOutput._make(_result)
|
|
return _result
|
|
|
|
TopK = tf_export("raw_ops.TopK")(_ops.to_raw_op(top_k))
|
|
|
|
|
|
def top_k_eager_fallback(input, k, sorted, name, ctx):
|
|
k = _execute.make_int(k, "k")
|
|
if sorted is None:
|
|
sorted = True
|
|
sorted = _execute.make_bool(sorted, "sorted")
|
|
_attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
_inputs_flat = [input]
|
|
_attrs = ("k", k, "sorted", sorted, "T", _attr_T)
|
|
_result = _execute.execute(b"TopK", 2, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"TopK", _inputs_flat, _attrs, _result)
|
|
_result = _TopKOutput._make(_result)
|
|
return _result
|
|
|
|
_TopKV2Output = collections.namedtuple(
|
|
"TopKV2",
|
|
["values", "indices"])
|
|
|
|
|
|
def top_kv2(input, k, sorted=True, name=None):
|
|
r"""Finds values and indices of the `k` largest elements for the last dimension.
|
|
|
|
If the input is a vector (rank-1), finds the `k` largest entries in the vector
|
|
|
|
and outputs their values and indices as vectors. Thus `values[j]` is the
|
|
|
|
`j`-th largest entry in `input`, and its index is `indices[j]`.
|
|
|
|
|
|
|
|
For matrices (resp. higher rank input), computes the top `k` entries in each
|
|
|
|
row (resp. vector along the last dimension). Thus,
|
|
|
|
|
|
|
|
values.shape = indices.shape = input.shape[:-1] + [k]
|
|
|
|
|
|
|
|
If two elements are equal, the lower-index element appears first.
|
|
|
|
Args:
|
|
input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
|
|
1-D or higher with last dimension at least `k`.
|
|
k: A `Tensor` of type `int32`.
|
|
0-D. Number of top elements to look for along the last dimension (along each
|
|
|
|
row for matrices).
|
|
sorted: An optional `bool`. Defaults to `True`.
|
|
If true the resulting `k` elements will be sorted by the values in
|
|
|
|
descending order.
|
|
name: A name for the operation (optional).
|
|
|
|
Returns:
|
|
A tuple of `Tensor` objects (values, indices).
|
|
|
|
values: A `Tensor`. Has the same type as `input`.
|
|
indices: A `Tensor` of type `int32`.
|
|
"""
|
|
_ctx = _context._context or _context.context()
|
|
tld = _ctx._thread_local_data
|
|
if tld.is_eager:
|
|
try:
|
|
_result = pywrap_tfe.TFE_Py_FastPathExecute(
|
|
_ctx, "TopKV2", name, input, k, "sorted", sorted)
|
|
_result = _TopKV2Output._make(_result)
|
|
return _result
|
|
except _core._NotOkStatusException as e:
|
|
_ops.raise_from_not_ok_status(e, name)
|
|
except _core._FallbackException:
|
|
pass
|
|
try:
|
|
return top_kv2_eager_fallback(
|
|
input, k, sorted=sorted, name=name, ctx=_ctx)
|
|
except _core._SymbolicException:
|
|
pass # Add nodes to the TensorFlow graph.
|
|
# Add nodes to the TensorFlow graph.
|
|
if sorted is None:
|
|
sorted = True
|
|
sorted = _execute.make_bool(sorted, "sorted")
|
|
_, _, _op, _outputs = _op_def_library._apply_op_helper(
|
|
"TopKV2", input=input, k=k, sorted=sorted, name=name)
|
|
_result = _outputs[:]
|
|
if _execute.must_record_gradient():
|
|
_attrs = ("sorted", _op._get_attr_bool("sorted"), "T",
|
|
_op._get_attr_type("T"))
|
|
_inputs_flat = _op.inputs
|
|
_execute.record_gradient(
|
|
"TopKV2", _inputs_flat, _attrs, _result)
|
|
_result = _TopKV2Output._make(_result)
|
|
return _result
|
|
|
|
TopKV2 = tf_export("raw_ops.TopKV2")(_ops.to_raw_op(top_kv2))
|
|
|
|
|
|
def top_kv2_eager_fallback(input, k, sorted, name, ctx):
|
|
if sorted is None:
|
|
sorted = True
|
|
sorted = _execute.make_bool(sorted, "sorted")
|
|
_attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ])
|
|
k = _ops.convert_to_tensor(k, _dtypes.int32)
|
|
_inputs_flat = [input, k]
|
|
_attrs = ("sorted", sorted, "T", _attr_T)
|
|
_result = _execute.execute(b"TopKV2", 2, inputs=_inputs_flat, attrs=_attrs,
|
|
ctx=ctx, name=name)
|
|
if _execute.must_record_gradient():
|
|
_execute.record_gradient(
|
|
"TopKV2", _inputs_flat, _attrs, _result)
|
|
_result = _TopKV2Output._make(_result)
|
|
return _result
|
|
|