def testExecuteListTypeListShapeAttr(self):
execute.execute(
'Barrier',
num_outputs=1,
inputs=[],
attrs=('component_types', [dtypes.float64.as_datatype_enum], 'shapes',
[[1, 2]], 'capacity', -1, 'container', '', 'shared_name', ''))
def testExecuteUnknownAttr(self):
with self.assertRaises(errors.InvalidArgumentError):
execute.execute(
'Identity',
num_outputs=1,
inputs=[tensor.Tensor(3)],
attrs=('T', dtypes.int32.as_datatype_enum, 'unknown_attr', 'blah'))
def testExecuteListFloatAttrBadValue(self):
with self.assertRaises(errors.InvalidArgumentError):
execute.execute(
'Bucketize',
num_outputs=1,
inputs=[tensor.Tensor([3.0, 5.0, 7.0])],
attrs=('T', dtypes.float32.as_datatype_enum, 'boundaries', 4.0))
def testExecuteShapeAttr(self):
execute.execute(
'VarHandleOp',
num_outputs=1,
inputs=[],
attrs=('shape', [1, 2], 'dtype', dtypes.int32.as_datatype_enum,
'container', '', 'shared_name', ''))
def testExecuteListIntAttrBadValue(self):
with self.assertRaises(errors.InvalidArgumentError):
execute.execute(
'Squeeze',
num_outputs=1,
inputs=[tensor.Tensor([[[3.0]]])],
attrs=('T', dtypes.float32.as_datatype_enum, 'squeeze_dims', 0))
def testExecuteListShapeAttrBadListValue(self):
with self.assertRaises(errors.InvalidArgumentError):
execute.execute(
'Barrier',
num_outputs=1,
inputs=[],
attrs=('component_types', [dtypes.float64.as_datatype_enum], 'shapes',
[1], 'capacity', -1, 'container', '', 'shared_name', ''))
def testExecuteListTypeAttrBadListValue(self):
with self.assertRaises(errors.InvalidArgumentError):
execute.execute(
b'Barrier',
num_outputs=1,
inputs=[],
attrs=('component_types', '1', 'shapes', [[1, 2]], 'capacity', -1,
'container', '', 'shared_name', ''))
def testExecuteListIntAttrBadListValue(self):
with self.assertRaises(errors.InvalidArgumentError):
execute.execute(
b'Squeeze',
num_outputs=1,
inputs=[constant_op.constant([[[3.0]]])],
attrs=('T', dtypes.float32.as_datatype_enum, 'squeeze_dims',
['0', '2']))
def testExecuteListFloatAttrBadListValue(self):
with self.assertRaises(errors.InvalidArgumentError):
execute.execute(
b'Bucketize',
num_outputs=1,
inputs=[constant_op.constant([3.0, 5.0, 7.0])],
attrs=('T', dtypes.float32.as_datatype_enum, 'boundaries',
['4.0', '6.0']))
def testExecuteListStringAttrBadListValue(self):
with self.assertRaises(errors.InvalidArgumentError):
execute.execute(
'TensorSummary',
num_outputs=1,
inputs=[tensor.Tensor(3.0)],
attrs=('T', dtypes.float32.as_datatype_enum, 'description', '',
'labels', [3], 'display_name', 'test'))
def testExecuteListStringAttr(self):
execute.execute(
'TensorSummary',
num_outputs=1,
inputs=[tensor.Tensor(3.0)],
attrs=('T', dtypes.float32.as_datatype_enum, 'description',
'tensor_summary', 'labels', ['3',
'summary'], 'display_name', 'test'))
def testExecuteShapeAttrBadValue(self):
with self.assertRaises(errors.InvalidArgumentError):
execute.execute(
'VarHandleOp',
num_outputs=1,
inputs=[],
attrs=('shape', 1, 'dtype', dtypes.int32.as_datatype_enum,
'container', '', 'shared_name', ''))
def testOperationWithNoInputsRunsOnDevice(self):
if not context.context().num_gpus():
self.skipTest('No GPUs found')
shape = tensor.Tensor([], dtype=dtypes.int32)
# x: Run the "TruncatedNormal" op CPU and copy result to GPU.
x = truncated_normal(shape).as_gpu_tensor()
# y: Explicitly run the "TruncatedNormal" op on GPU.
with context.device('gpu:0'):
y = truncated_normal(shape)
# Add would fail if x and y were not on the same device.
execute.execute(
'Add', 1, inputs=[x, y], attrs=('T', x.dtype.as_datatype_enum))
def __call__(self, *args):
"""Executes the passed function in eager mode."""
tensor_inputs = [
x for x in nest.flatten(args)
if isinstance(x, ops.Tensor)
]
if tape.should_record(tensor_inputs) or tape.should_record(
self._extra_inputs):
if not self._has_backprop:
self._compute_backprop()
return self._backprop_call(tensor_inputs)
if context.in_graph_mode():
g = ops.get_default_graph()
if self._fdef.name not in g._functions: # pylint: disable=protected-access
g._add_function(self._fdef) # pylint: disable=protected-access
signature = self._fdef.definition.signature
args = list(tensor_inputs) + self._extra_inputs
op = g.create_op(
signature.name, [ops.convert_to_tensor(x) for x in args],
[dtypes.DType(x.type) for x in signature.output_arg],
op_def=signature,
name="FunctionCall",
compute_shapes=False)
result = op.outputs
for i, s in enumerate(self._output_shapes):
result[i].set_shape(s)
else:
result = execute.execute(
str(self._func_name),
num_outputs=self._num_outputs,
inputs=tensor_inputs + self._extra_inputs)
return self._build_call_outputs(self._returns, result)
def testExecuteIntAttr(self):
total = execute.execute(
b'AddN',
num_outputs=1,
inputs=[constant_op.constant(3), constant_op.constant(4)],
attrs=('T', dtypes.int32.as_datatype_enum, 'N', 2))[0]
self.assertEqual(7, total.numpy())
def xla_launch_eager_fallback(constants, args, resources, Tresults, function, name=None, ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function xla_launch
"""
_ctx = ctx if ctx else _context.context()
if not isinstance(resources, (list, tuple)):
raise TypeError(
"Expected list for 'resources' argument to "
"'xla_launch' Op, not %r." % resources)
_attr_Nresources = len(resources)
if not isinstance(Tresults, (list, tuple)):
raise TypeError(
"Expected list for 'Tresults' argument to "
"'xla_launch' Op, not %r." % Tresults)
Tresults = [_execute.make_type(_t, "Tresults") for _t in Tresults]
_attr_Tconstants, constants = _execute.convert_to_mixed_eager_tensors(constants, _ctx)
_attr_Targs, args = _execute.convert_to_mixed_eager_tensors(args, _ctx)
resources = _ops.convert_n_to_tensor(resources, _dtypes.resource)
_inputs_flat = list(constants) + list(args) + list(resources)
_attrs = ("Tconstants", _attr_Tconstants, "Targs", _attr_Targs,
"Nresources", _attr_Nresources, "Tresults", Tresults, "function", function)
_result = _execute.execute(b"XlaLaunch", len(Tresults), inputs=_inputs_flat,
attrs=_attrs, ctx=_ctx, name=name)
_execute.record_gradient(
"XlaLaunch", _inputs_flat, _attrs, _result, name)
return _result
def _capture_by_value(
self,
op_type,
inputs,
dtypes, # pylint: disable=redefined-outer-name
input_types=None,
name=None,
attrs=None,
op_def=None,
compute_shapes=True,
compute_device=True):
# When capturing by value, do the read outside
reverse_captures = dict((v, k) for k, v in self.captures.items())
uncaptured_inputs = [reverse_captures.get(t, t) for t in inputs]
with ops.init_scope():
if context.executing_eagerly():
attr_list = ("dtype", int(attrs["dtype"].type))
value, = execute.execute(
compat.as_bytes(op_type), 1, uncaptured_inputs, attr_list,
context.context())
else:
op = ops.get_default_graph().create_op(
op_type, uncaptured_inputs, dtypes, input_types, name, attrs,
op_def, compute_shapes, compute_device)
value = op.outputs[0]
captured_value = self.capture(value)
return captured_value.op
def build_sparse_inequality_splits_eager_fallback(num_minibatches, partition_ids, bucket_ids, gradients, hessians, bucket_boundaries, class_id, feature_column_group_id, bias_feature_id, l1_regularization, l2_regularization, tree_complexity_regularization, min_node_weight, multiclass_strategy, name=None, ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function build_sparse_inequality_splits
"""
_ctx = ctx if ctx else _context.context()
num_minibatches = _ops.convert_to_tensor(num_minibatches, _dtypes.int64)
partition_ids = _ops.convert_to_tensor(partition_ids, _dtypes.int32)
bucket_ids = _ops.convert_to_tensor(bucket_ids, _dtypes.int64)
gradients = _ops.convert_to_tensor(gradients, _dtypes.float32)
hessians = _ops.convert_to_tensor(hessians, _dtypes.float32)
bucket_boundaries = _ops.convert_to_tensor(bucket_boundaries, _dtypes.float32)
class_id = _ops.convert_to_tensor(class_id, _dtypes.int32)
feature_column_group_id = _ops.convert_to_tensor(feature_column_group_id, _dtypes.int32)
bias_feature_id = _ops.convert_to_tensor(bias_feature_id, _dtypes.int64)
l1_regularization = _ops.convert_to_tensor(l1_regularization, _dtypes.float32)
l2_regularization = _ops.convert_to_tensor(l2_regularization, _dtypes.float32)
tree_complexity_regularization = _ops.convert_to_tensor(tree_complexity_regularization, _dtypes.float32)
min_node_weight = _ops.convert_to_tensor(min_node_weight, _dtypes.float32)
multiclass_strategy = _ops.convert_to_tensor(multiclass_strategy, _dtypes.int32)
_inputs_flat = [num_minibatches, partition_ids, bucket_ids, gradients, hessians, bucket_boundaries, class_id, feature_column_group_id, bias_feature_id, l1_regularization, l2_regularization, tree_complexity_regularization, min_node_weight, multiclass_strategy]
_attrs = None
_result = _execute.execute(b"BuildSparseInequalitySplits", 3,
inputs=_inputs_flat, attrs=_attrs, ctx=_ctx,
name=name)
_execute.record_gradient(
"BuildSparseInequalitySplits", _inputs_flat, _attrs, _result, name)
_result = _BuildSparseInequalitySplitsOutput._make(_result)
return _result
def testExecuteStringAttrBadValue(self):
with self.assertRaises(errors.InvalidArgumentError):
_ = execute.execute(
'CheckNumerics',
num_outputs=1,
inputs=[tensor.Tensor(3.)],
attrs=('message', 1, 'T', dtypes.float32.as_datatype_enum))
def testExecuteFloatAttr(self):
almost_equal = execute.execute(
'ApproximateEqual',
num_outputs=1,
inputs=[tensor.Tensor(3.0), tensor.Tensor(2.9)],
attrs=('tolerance', 0.3, 'T', dtypes.float32.as_datatype_enum))[0]
self.assertTrue(almost_equal.numpy())
def testExecuteFloatAttrBadValue(self):
with self.assertRaises(errors.InvalidArgumentError):
_ = execute.execute(
'ApproximateEqual',
num_outputs=1,
inputs=[tensor.Tensor(3.0), tensor.Tensor(2.9)],
attrs=('tolerance', '0.3', 'T', dtypes.float32.as_datatype_enum))
def testExecuteIntAttr(self):
total = execute.execute(
'AddN',
num_outputs=1,
inputs=[tensor.Tensor(3), tensor.Tensor(4)],
attrs=('T', dtypes.int32.as_datatype_enum, 'N', 2))[0]
self.assertEqual(7, total.numpy())
def truncated_normal(shape):
return execute.execute(
'TruncatedNormal',
1,
inputs=[shape],
attrs=('dtype', dtypes.float32.as_datatype_enum, 'T',
shape.dtype.as_datatype_enum, 'seed', 0, 'seed2', 0))[0]
def testExecuteIntAttrBadValue(self):
with self.assertRaises(errors.InvalidArgumentError):
_ = execute.execute(
'AddN',
num_outputs=1,
inputs=[tensor.Tensor(3), tensor.Tensor(4)],
attrs=('T', dtypes.int32.as_datatype_enum, 'N', '2'))
def testExecuteListIntAttr(self):
b = execute.execute(
'Squeeze',
num_outputs=1,
inputs=[tensor.Tensor([[[3.0]]])],
attrs=('T', dtypes.float32.as_datatype_enum, 'squeeze_dims', [0, 2]))[0]
self.assertAllEqual([3], b.numpy())
def testExecuteStringAttr(self):
checked_three = execute.execute(
'CheckNumerics',
num_outputs=1,
inputs=[tensor.Tensor(3.)],
attrs=('message', 'just checking', 'T',
dtypes.float32.as_datatype_enum))[0]
self.assertEqual([[3]], checked_three.numpy())
def _eager_fill(dims, value):
"""Eager-only version of Fill op; requires value is an eager Tensor."""
attr_t = value.dtype.as_datatype_enum
dims = convert_to_eager_tensor(dims, dtypes.int32)
inputs_flat = [dims, value]
attrs = ("T", attr_t)
result, = execute.execute(b"Fill", 1, inputs=inputs_flat, attrs=attrs)
return result
def testExecuteListFloatAttr(self):
b = execute.execute(
'Bucketize',
num_outputs=1,
inputs=[tensor.Tensor([3.0, 5.0, 7.0])],
attrs=('T', dtypes.float32.as_datatype_enum, 'boundaries', [4.0,
6.0]))[0]
self.assertAllEqual([0, 1, 2], b.numpy())
def testExecuteBoolAttr(self):
product = execute.execute(
'MatMul',
num_outputs=1,
inputs=[tensor.Tensor([[3]]),
tensor.Tensor([[5]])],
attrs=('transpose_a', True, 'transpose_b', False, 'T',
dtypes.int32.as_datatype_enum))[0]
self.assertEqual([[15]], product.numpy())
def testExecuteTooManyNumOutputs(self):
# num_outputs provided is 50, but only one output is produced.
# That should be okay.
product = execute.execute(
'Mul',
num_outputs=50,
inputs=[tensor.Tensor(3), tensor.Tensor(5)],
attrs=('T', dtypes.int32.as_datatype_enum))[0]
self.assertEqual(15, product.numpy())
def decision_tree_ensemble_resource_handle_op(container="", shared_name="", name=None):
r"""Creates a handle to a DecisionTreeEnsembleResource
Args:
container: An optional `string`. Defaults to `""`.
shared_name: An optional `string`. Defaults to `""`.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `resource`.
"""
if container is None:
container = ""
container = _execute.make_str(container, "container")
if shared_name is None:
shared_name = ""
shared_name = _execute.make_str(shared_name, "shared_name")
_ctx = _context.context()
if _ctx.in_graph_mode():
_, _, _op = _op_def_lib._apply_op_helper(
"DecisionTreeEnsembleResourceHandleOp", container=container,
shared_name=shared_name, name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("container", _op.get_attr("container"), "shared_name",
_op.get_attr("shared_name"))
else:
_inputs_flat = []
_attrs = ("container", container, "shared_name", shared_name)
_result = _execute.execute(b"DecisionTreeEnsembleResourceHandleOp", 1,
inputs=_inputs_flat, attrs=_attrs, ctx=_ctx,
name=name)
_execute.record_gradient(
"DecisionTreeEnsembleResourceHandleOp", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
def try_rpc_eager_fallback(address,
method,
request,
protocol="",
fail_fast=True,
timeout_in_ms=0,
name=None,
ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function try_rpc
"""
_ctx = ctx if ctx else _context.context()
if protocol is None:
protocol = ""
protocol = _execute.make_str(protocol, "protocol")
if fail_fast is None:
fail_fast = True
fail_fast = _execute.make_bool(fail_fast, "fail_fast")
if timeout_in_ms is None:
timeout_in_ms = 0
timeout_in_ms = _execute.make_int(timeout_in_ms, "timeout_in_ms")
address = _ops.convert_to_tensor(address, _dtypes.string)
method = _ops.convert_to_tensor(method, _dtypes.string)
request = _ops.convert_to_tensor(request, _dtypes.string)
_inputs_flat = [address, method, request]
_attrs = ("protocol", protocol, "fail_fast", fail_fast, "timeout_in_ms",
timeout_in_ms)
_result = _execute.execute(b"TryRpc",
3,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("TryRpc", _inputs_flat, _attrs, _result, name)
_result = _TryRpcOutput._make(_result)
return _result
def population_count_eager_fallback(x, name, ctx):
_attr_T, (x, ) = _execute.args_to_matching_eager([x], ctx, [
_dtypes.int8,
_dtypes.int16,
_dtypes.int32,
_dtypes.int64,
_dtypes.uint8,
_dtypes.uint16,
_dtypes.uint32,
_dtypes.uint64,
])
_inputs_flat = [x]
_attrs = ("T", _attr_T)
_result = _execute.execute(b"PopulationCount",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=ctx,
name=name)
if _execute.must_record_gradient():
_execute.record_gradient("PopulationCount", _inputs_flat, _attrs,
_result)
_result, = _result
return _result
def image_projective_transform_eager_fallback(images,
transforms,
interpolation,
name=None,
ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function image_projective_transform
"""
_ctx = ctx if ctx else _context.context()
interpolation = _execute.make_str(interpolation, "interpolation")
_attr_dtype, (images, ) = _execute.args_to_matching_eager([images], _ctx)
transforms = _ops.convert_to_tensor(transforms, _dtypes.float32)
_inputs_flat = [images, transforms]
_attrs = ("dtype", _attr_dtype, "interpolation", interpolation)
_result = _execute.execute(b"ImageProjectiveTransform",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("ImageProjectiveTransform", _inputs_flat, _attrs,
_result, name)
_result, = _result
return _result
def ignite_dataset_eager_fallback(cache_name,
host,
port,
local,
part,
page_size,
schema,
permutation,
name=None,
ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function ignite_dataset
"""
_ctx = ctx if ctx else _context.context()
cache_name = _ops.convert_to_tensor(cache_name, _dtypes.string)
host = _ops.convert_to_tensor(host, _dtypes.string)
port = _ops.convert_to_tensor(port, _dtypes.int32)
local = _ops.convert_to_tensor(local, _dtypes.bool)
part = _ops.convert_to_tensor(part, _dtypes.int32)
page_size = _ops.convert_to_tensor(page_size, _dtypes.int32)
schema = _ops.convert_to_tensor(schema, _dtypes.int32)
permutation = _ops.convert_to_tensor(permutation, _dtypes.int32)
_inputs_flat = [
cache_name, host, port, local, part, page_size, schema, permutation
]
_attrs = None
_result = _execute.execute(b"IgniteDataset",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("IgniteDataset", _inputs_flat, _attrs, _result,
name)
_result, = _result
return _result
def ragged_count_sparse_output_eager_fallback(splits, values, weights,
binary_output, minlength,
maxlength, name, ctx):
binary_output = _execute.make_bool(binary_output, "binary_output")
if minlength is None:
minlength = -1
minlength = _execute.make_int(minlength, "minlength")
if maxlength is None:
maxlength = -1
maxlength = _execute.make_int(maxlength, "maxlength")
_attr_T, (values, ) = _execute.args_to_matching_eager([values], ctx, [
_dtypes.int32,
_dtypes.int64,
])
_attr_output_type, (weights, ) = _execute.args_to_matching_eager(
[weights], ctx, [
_dtypes.int32,
_dtypes.int64,
_dtypes.float32,
_dtypes.float64,
])
splits = _ops.convert_to_tensor(splits, _dtypes.int64)
_inputs_flat = [splits, values, weights]
_attrs = ("T", _attr_T, "minlength", minlength, "maxlength", maxlength,
"binary_output", binary_output, "output_type", _attr_output_type)
_result = _execute.execute(b"RaggedCountSparseOutput",
3,
inputs=_inputs_flat,
attrs=_attrs,
ctx=ctx,
name=name)
if _execute.must_record_gradient():
_execute.record_gradient("RaggedCountSparseOutput", _inputs_flat,
_attrs, _result)
_result = _RaggedCountSparseOutputOutput._make(_result)
return _result
def ctc_beam_search_decoder_eager_fallback(inputs,
sequence_length,
beam_width,
top_paths,
merge_repeated=True,
name=None,
ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function ctc_beam_search_decoder
"""
_ctx = ctx if ctx else _context.context()
beam_width = _execute.make_int(beam_width, "beam_width")
top_paths = _execute.make_int(top_paths, "top_paths")
if merge_repeated is None:
merge_repeated = True
merge_repeated = _execute.make_bool(merge_repeated, "merge_repeated")
inputs = _ops.convert_to_tensor(inputs, _dtypes.float32)
sequence_length = _ops.convert_to_tensor(sequence_length, _dtypes.int32)
_inputs_flat = [inputs, sequence_length]
_attrs = ("beam_width", beam_width, "top_paths", top_paths,
"merge_repeated", merge_repeated)
_result = _execute.execute(b"CTCBeamSearchDecoder",
top_paths + top_paths + top_paths + 1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("CTCBeamSearchDecoder", _inputs_flat, _attrs,
_result, name)
_result = [_result[:top_paths]] + _result[top_paths:]
_result = _result[:1] + [_result[1:1 + top_paths]
] + _result[1 + top_paths:]
_result = _result[:2] + [_result[2:2 + top_paths]
] + _result[2 + top_paths:]
_result = _CTCBeamSearchDecoderOutput._make(_result)
return _result
def dense_table_push_pull_eager_fallback(vars, grads, table_handle, name, ctx):
if not isinstance(vars, (list, tuple)):
raise TypeError(
"Expected list for 'vars' argument to "
"'dense_table_push_pull' Op, not %r." % vars)
_attr_N = len(vars)
if not isinstance(grads, (list, tuple)):
raise TypeError(
"Expected list for 'grads' argument to "
"'dense_table_push_pull' Op, not %r." % grads)
if len(grads) != _attr_N:
raise ValueError(
"List argument 'grads' to 'dense_table_push_pull' Op with length %d "
"must match length %d of argument 'vars'." %
(len(grads), _attr_N))
table_handle = _execute.make_int(table_handle, "table_handle")
vars = _ops.convert_n_to_tensor(vars, _dtypes.resource)
grads = _ops.convert_n_to_tensor(grads, _dtypes.float32)
_inputs_flat = list(vars) + list(grads)
_attrs = ("table_handle", table_handle, "N", _attr_N)
_result = _execute.execute(b"DenseTablePushPull", 0, inputs=_inputs_flat,
attrs=_attrs, ctx=ctx, name=name)
_result = None
return _result
def unbatch_eager_fallback(batched_tensor, batch_index, id, timeout_micros, container="", shared_name="", name=None, ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function unbatch
"""
_ctx = ctx if ctx else _context.context()
timeout_micros = _execute.make_int(timeout_micros, "timeout_micros")
if container is None:
container = ""
container = _execute.make_str(container, "container")
if shared_name is None:
shared_name = ""
shared_name = _execute.make_str(shared_name, "shared_name")
_attr_T, (batched_tensor,) = _execute.args_to_matching_eager([batched_tensor], _ctx)
batch_index = _ops.convert_to_tensor(batch_index, _dtypes.int64)
id = _ops.convert_to_tensor(id, _dtypes.int64)
_inputs_flat = [batched_tensor, batch_index, id]
_attrs = ("timeout_micros", timeout_micros, "container", container,
"shared_name", shared_name, "T", _attr_T)
_result = _execute.execute(b"Unbatch", 1, inputs=_inputs_flat, attrs=_attrs,
ctx=_ctx, name=name)
_execute.record_gradient(
"Unbatch", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
def generate_vocab_remapping_eager_fallback(new_vocab_file, old_vocab_file,
new_vocab_offset, num_new_vocab,
old_vocab_size, name, ctx):
new_vocab_offset = _execute.make_int(new_vocab_offset, "new_vocab_offset")
num_new_vocab = _execute.make_int(num_new_vocab, "num_new_vocab")
if old_vocab_size is None:
old_vocab_size = -1
old_vocab_size = _execute.make_int(old_vocab_size, "old_vocab_size")
new_vocab_file = _ops.convert_to_tensor(new_vocab_file, _dtypes.string)
old_vocab_file = _ops.convert_to_tensor(old_vocab_file, _dtypes.string)
_inputs_flat = [new_vocab_file, old_vocab_file]
_attrs = ("new_vocab_offset", new_vocab_offset, "num_new_vocab",
num_new_vocab, "old_vocab_size", old_vocab_size)
_result = _execute.execute(b"GenerateVocabRemapping",
2,
inputs=_inputs_flat,
attrs=_attrs,
ctx=ctx,
name=name)
if _execute.must_record_gradient():
_execute.record_gradient("GenerateVocabRemapping", _inputs_flat,
_attrs, _result)
_result = _GenerateVocabRemappingOutput._make(_result)
return _result
def bigtable_range_key_dataset_eager_fallback(table,
start_key,
end_key,
name=None,
ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function bigtable_range_key_dataset
"""
_ctx = ctx if ctx else _context.context()
table = _ops.convert_to_tensor(table, _dtypes.resource)
start_key = _ops.convert_to_tensor(start_key, _dtypes.string)
end_key = _ops.convert_to_tensor(end_key, _dtypes.string)
_inputs_flat = [table, start_key, end_key]
_attrs = None
_result = _execute.execute(b"BigtableRangeKeyDataset",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("BigtableRangeKeyDataset", _inputs_flat, _attrs,
_result, name)
_result, = _result
return _result
def tree_ensemble_deserialize_eager_fallback(tree_ensemble_handle,
stamp_token,
tree_ensemble_config,
name=None,
ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function tree_ensemble_deserialize
"""
_ctx = ctx if ctx else _context.context()
tree_ensemble_handle = _ops.convert_to_tensor(tree_ensemble_handle,
_dtypes.resource)
stamp_token = _ops.convert_to_tensor(stamp_token, _dtypes.int64)
tree_ensemble_config = _ops.convert_to_tensor(tree_ensemble_config,
_dtypes.string)
_inputs_flat = [tree_ensemble_handle, stamp_token, tree_ensemble_config]
_attrs = None
_result = _execute.execute(b"TreeEnsembleDeserialize",
0,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_result = None
return _result
def stateful_random_binomial_eager_fallback(resource, algorithm, shape, counts,
probs, dtype, name, ctx):
if dtype is None:
dtype = _dtypes.int64
dtype = _execute.make_type(dtype, "dtype")
_attr_S, (shape, ) = _execute.args_to_matching_eager([shape], ctx)
_attr_T, _inputs_T = _execute.args_to_matching_eager([counts, probs], ctx,
_dtypes.float64)
(counts, probs) = _inputs_T
resource = _ops.convert_to_tensor(resource, _dtypes.resource)
algorithm = _ops.convert_to_tensor(algorithm, _dtypes.int64)
_inputs_flat = [resource, algorithm, shape, counts, probs]
_attrs = ("S", _attr_S, "T", _attr_T, "dtype", dtype)
_result = _execute.execute(b"StatefulRandomBinomial",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=ctx,
name=name)
if _execute.must_record_gradient():
_execute.record_gradient("StatefulRandomBinomial", _inputs_flat,
_attrs, _result)
_result, = _result
return _result
def assign_sub_variable_op(resource, value, name=None):
r"""Subtracts a value from the current value of a variable.
Any ReadVariableOp with a control dependency on this op is guaranteed to
see the decremented value or a subsequent newer one.
Args:
resource: A `Tensor` of type `resource`.
handle to the resource in which to store the variable.
value: A `Tensor`. the value by which the variable will be incremented.
name: A name for the operation (optional).
Returns:
The created Operation.
"""
_ctx = _context.context()
if _ctx.in_graph_mode():
_, _, _op = _op_def_lib._apply_op_helper("AssignSubVariableOp",
resource=resource,
value=value,
name=name)
return _op
else:
_attr_dtype, (value, ) = _execute.args_to_matching_eager([value], _ctx)
resource = _ops.convert_to_tensor(resource, _dtypes.resource)
_inputs_flat = [resource, value]
_attrs = ("dtype", _attr_dtype)
_result = _execute.execute(b"AssignSubVariableOp",
0,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_result = None
return _result
def tree_ensemble_used_handlers_eager_fallback(tree_ensemble_handle,
stamp_token,
num_all_handlers,
name=None):
r"""This is the slowpath function for Eager mode.
This is for function tree_ensemble_used_handlers
"""
_ctx = _context.context()
num_all_handlers = _execute.make_int(num_all_handlers, "num_all_handlers")
tree_ensemble_handle = _ops.convert_to_tensor(tree_ensemble_handle,
_dtypes.resource)
stamp_token = _ops.convert_to_tensor(stamp_token, _dtypes.int64)
_inputs_flat = [tree_ensemble_handle, stamp_token]
_attrs = ("num_all_handlers", num_all_handlers)
_result = _execute.execute(b"TreeEnsembleUsedHandlers",
2,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("TreeEnsembleUsedHandlers", _inputs_flat, _attrs,
_result, name)
_result = _TreeEnsembleUsedHandlersOutput._make(_result)
return _result
def right_shift_eager_fallback(x, y, name, ctx):
_attr_T, _inputs_T = _execute.args_to_matching_eager([x, y], ctx, [
_dtypes.int8,
_dtypes.int16,
_dtypes.int32,
_dtypes.int64,
_dtypes.uint8,
_dtypes.uint16,
_dtypes.uint32,
_dtypes.uint64,
])
(x, y) = _inputs_T
_inputs_flat = [x, y]
_attrs = ("T", _attr_T)
_result = _execute.execute(b"RightShift",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=ctx,
name=name)
if _execute.must_record_gradient():
_execute.record_gradient("RightShift", _inputs_flat, _attrs, _result)
_result, = _result
return _result
def _backprop_call(self, args):
"""Calls the wrapped function and records the result on a tape."""
all_args = args + self._extra_inputs
signature = self._forward_fdef.definition.signature
if context.in_graph_mode():
g = ops.get_default_graph()
g._add_function(self._forward_fdef) # pylint: disable=protected-access
def make_tensor(x):
if isinstance(x, ops.Tensor):
return x
return ops.convert_to_tensor(x)
op = g.create_op(
signature.name, [make_tensor(x) for x in all_args],
[dtypes.DType(x.type) for x in signature.output_arg],
op_def=signature,
name="FunctionCall",
compute_shapes=False)
outputs = op.outputs
outputs = [outputs] if isinstance(outputs,
(ops.Tensor,
type(None))) else list(outputs)
for i, s in enumerate(self._output_shapes):
outputs[i].set_shape(s)
else:
outputs = execute.execute(str(signature.name),
num_outputs=len(signature.output_arg),
inputs=all_args)
real_outputs = outputs[:len(self._returns)]
side_outputs = outputs[len(self._returns):]
tape.record_operation(real_outputs, (args + self._extra_inputs),
side_outputs, self._backward_function)
return self._build_call_outputs(self._returns, real_outputs)
def loop_cond(input, name=None):
r"""Forwards the input to the output.
This operator represents the loop termination condition used by the
"pivot" switches of a loop.
Args:
input: A `Tensor` of type `bool`.
A boolean scalar, representing the branch predicate of the Switch op.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `bool`.
"""
_ctx = _context.context()
if _ctx.in_graph_mode():
_, _, _op = _op_def_lib._apply_op_helper("LoopCond",
input=input,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = None
else:
input = _ops.convert_to_tensor(input, _dtypes.bool)
_inputs_flat = [input]
_attrs = None
_result = _execute.execute(b"LoopCond",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("LoopCond", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
def stateless_random_binomial_eager_fallback(shape, seed, counts, probs, dtype,
name, ctx):
if dtype is None:
dtype = _dtypes.int64
dtype = _execute.make_type(dtype, "dtype")
_attr_S, (shape, ) = _execute.args_to_matching_eager([shape], ctx)
_attr_Tseed, (seed, ) = _execute.args_to_matching_eager([seed], ctx,
_dtypes.int64)
_attr_T, _inputs_T = _execute.args_to_matching_eager([counts, probs], ctx,
_dtypes.float64)
(counts, probs) = _inputs_T
_inputs_flat = [shape, seed, counts, probs]
_attrs = ("S", _attr_S, "Tseed", _attr_Tseed, "T", _attr_T, "dtype", dtype)
_result = _execute.execute(b"StatelessRandomBinomial",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=ctx,
name=name)
if _execute.must_record_gradient():
_execute.record_gradient("StatelessRandomBinomial", _inputs_flat,
_attrs, _result)
_result, = _result
return _result
def tensor_summary_v2_eager_fallback(tag,
tensor,
serialized_summary_metadata,
name=None):
r"""This is the slowpath function for Eager mode.
This is for function tensor_summary_v2
"""
_ctx = _context.context()
_attr_T, (tensor, ) = _execute.args_to_matching_eager([tensor], _ctx)
tag = _ops.convert_to_tensor(tag, _dtypes.string)
serialized_summary_metadata = _ops.convert_to_tensor(
serialized_summary_metadata, _dtypes.string)
_inputs_flat = [tag, tensor, serialized_summary_metadata]
_attrs = ("T", _attr_T)
_result = _execute.execute(b"TensorSummaryV2",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("TensorSummaryV2", _inputs_flat, _attrs, _result,
name)
_result, = _result
return _result
def write_image_summary_eager_fallback(writer, step, tag, tensor, bad_color,
max_images, name, ctx):
if max_images is None:
max_images = 3
max_images = _execute.make_int(max_images, "max_images")
_attr_T, (tensor, ) = _execute.args_to_matching_eager([tensor], ctx, [
_dtypes.uint8,
_dtypes.float32,
_dtypes.half,
], _dtypes.float32)
writer = _ops.convert_to_tensor(writer, _dtypes.resource)
step = _ops.convert_to_tensor(step, _dtypes.int64)
tag = _ops.convert_to_tensor(tag, _dtypes.string)
bad_color = _ops.convert_to_tensor(bad_color, _dtypes.uint8)
_inputs_flat = [writer, step, tag, tensor, bad_color]
_attrs = ("max_images", max_images, "T", _attr_T)
_result = _execute.execute(b"WriteImageSummary",
0,
inputs=_inputs_flat,
attrs=_attrs,
ctx=ctx,
name=name)
_result = None
return _result
def grow_tree_v4_eager_fallback(tree_handle,
stats_handle,
finished_nodes,
params,
name=None,
ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function grow_tree_v4
"""
_ctx = ctx if ctx else _context.context()
params = _execute.make_str(params, "params")
tree_handle = _ops.convert_to_tensor(tree_handle, _dtypes.resource)
stats_handle = _ops.convert_to_tensor(stats_handle, _dtypes.resource)
finished_nodes = _ops.convert_to_tensor(finished_nodes, _dtypes.int32)
_inputs_flat = [tree_handle, stats_handle, finished_nodes]
_attrs = ("params", params)
_result = _execute.execute(b"GrowTreeV4",
0,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_result = None
return _result
def no_op(name=None):
r"""Does nothing. Only useful as a placeholder for control edges.
Args:
name: A name for the operation (optional).
Returns:
The created Operation.
"""
_ctx = _context.context()
if _ctx.in_graph_mode():
_, _, _op = _op_def_lib._apply_op_helper("NoOp", name=name)
return _op
else:
_inputs_flat = []
_attrs = None
_result = _execute.execute(b"NoOp",
0,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_result = None
return _result
def image_summary_eager_fallback(
tag,
tensor,
max_images=3,
bad_color=_execute.
make_tensor(
"""dtype: DT_UINT8 tensor_shape { dim { size: 4 } } int_val: 255 int_val: 0 int_val: 0 int_val: 255""",
"bad_color"),
name=None):
r"""This is the slowpath function for Eager mode.
This is for function image_summary
"""
_ctx = _context.context()
if max_images is None:
max_images = 3
max_images = _execute.make_int(max_images, "max_images")
if bad_color is None:
bad_color = _execute.make_tensor(
"""dtype: DT_UINT8 tensor_shape { dim { size: 4 } } int_val: 255 int_val: 0 int_val: 0 int_val: 255""",
"bad_color")
bad_color = _execute.make_tensor(bad_color, "bad_color")
_attr_T, (tensor, ) = _execute.args_to_matching_eager([tensor], _ctx,
_dtypes.float32)
tag = _ops.convert_to_tensor(tag, _dtypes.string)
_inputs_flat = [tag, tensor]
_attrs = ("max_images", max_images, "T", _attr_T, "bad_color", bad_color)
_result = _execute.execute(b"ImageSummary",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("ImageSummary", _inputs_flat, _attrs, _result,
name)
_result, = _result
return _result
def mfcc_eager_fallback(spectrogram, sample_rate, upper_frequency_limit,
lower_frequency_limit, filterbank_channel_count,
dct_coefficient_count, name, ctx):
if upper_frequency_limit is None:
upper_frequency_limit = 4000
upper_frequency_limit = _execute.make_float(upper_frequency_limit,
"upper_frequency_limit")
if lower_frequency_limit is None:
lower_frequency_limit = 20
lower_frequency_limit = _execute.make_float(lower_frequency_limit,
"lower_frequency_limit")
if filterbank_channel_count is None:
filterbank_channel_count = 40
filterbank_channel_count = _execute.make_int(filterbank_channel_count,
"filterbank_channel_count")
if dct_coefficient_count is None:
dct_coefficient_count = 13
dct_coefficient_count = _execute.make_int(dct_coefficient_count,
"dct_coefficient_count")
spectrogram = _ops.convert_to_tensor(spectrogram, _dtypes.float32)
sample_rate = _ops.convert_to_tensor(sample_rate, _dtypes.int32)
_inputs_flat = [spectrogram, sample_rate]
_attrs = ("upper_frequency_limit", upper_frequency_limit,
"lower_frequency_limit", lower_frequency_limit,
"filterbank_channel_count", filterbank_channel_count,
"dct_coefficient_count", dct_coefficient_count)
_result = _execute.execute(b"Mfcc",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=ctx,
name=name)
if _execute.must_record_gradient():
_execute.record_gradient("Mfcc", _inputs_flat, _attrs, _result)
_result, = _result
return _result
def tensor_forest_tree_predict_eager_fallback(tree_handle,
dense_features,
logits_dimension,
name=None,
ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function tensor_forest_tree_predict
"""
_ctx = ctx if ctx else _context.context()
logits_dimension = _execute.make_int(logits_dimension, "logits_dimension")
tree_handle = _ops.convert_to_tensor(tree_handle, _dtypes.resource)
dense_features = _ops.convert_to_tensor(dense_features, _dtypes.float32)
_inputs_flat = [tree_handle, dense_features]
_attrs = ("logits_dimension", logits_dimension)
_result = _execute.execute(b"TensorForestTreePredict",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("TensorForestTreePredict", _inputs_flat, _attrs,
_result, name)
_result, = _result
return _result
def enter_eager_fallback(data, frame_name, is_constant, parallel_iterations,
name, ctx):
frame_name = _execute.make_str(frame_name, "frame_name")
if is_constant is None:
is_constant = False
is_constant = _execute.make_bool(is_constant, "is_constant")
if parallel_iterations is None:
parallel_iterations = 10
parallel_iterations = _execute.make_int(parallel_iterations,
"parallel_iterations")
_attr_T, (data, ) = _execute.args_to_matching_eager([data], ctx)
_inputs_flat = [data]
_attrs = ("T", _attr_T, "frame_name", frame_name, "is_constant",
is_constant, "parallel_iterations", parallel_iterations)
_result = _execute.execute(b"Enter",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=ctx,
name=name)
if _execute.must_record_gradient():
_execute.record_gradient("Enter", _inputs_flat, _attrs, _result)
_result, = _result
return _result
def tensor_forest_tree_resource_handle_op_eager_fallback(
container="", shared_name="", name=None, ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function tensor_forest_tree_resource_handle_op
"""
_ctx = ctx if ctx else _context.context()
if container is None:
container = ""
container = _execute.make_str(container, "container")
if shared_name is None:
shared_name = ""
shared_name = _execute.make_str(shared_name, "shared_name")
_inputs_flat = []
_attrs = ("container", container, "shared_name", shared_name)
_result = _execute.execute(b"TensorForestTreeResourceHandleOp",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("TensorForestTreeResourceHandleOp", _inputs_flat,
_attrs, _result, name)
_result, = _result
return _result
def ignore_errors_dataset_eager_fallback(input_dataset, output_types, output_shapes, name=None, ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function ignore_errors_dataset
"""
_ctx = ctx if ctx else _context.context()
if not isinstance(output_types, (list, tuple)):
raise TypeError(
"Expected list for 'output_types' argument to "
"'ignore_errors_dataset' Op, not %r." % output_types)
output_types = [_execute.make_type(_t, "output_types") for _t in output_types]
if not isinstance(output_shapes, (list, tuple)):
raise TypeError(
"Expected list for 'output_shapes' argument to "
"'ignore_errors_dataset' Op, not %r." % output_shapes)
output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes]
input_dataset = _ops.convert_to_tensor(input_dataset, _dtypes.variant)
_inputs_flat = [input_dataset]
_attrs = ("output_types", output_types, "output_shapes", output_shapes)
_result = _execute.execute(b"IgnoreErrorsDataset", 1, inputs=_inputs_flat,
attrs=_attrs, ctx=_ctx, name=name)
_execute.record_gradient(
"IgnoreErrorsDataset", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
def resampler_grad_eager_fallback(data,
warp,
grad_output,
name=None,
ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function resampler_grad
"""
_ctx = ctx if ctx else _context.context()
_attr_T, _inputs_T = _execute.args_to_matching_eager(
[data, warp, grad_output], _ctx)
(data, warp, grad_output) = _inputs_T
_inputs_flat = [data, warp, grad_output]
_attrs = ("T", _attr_T)
_result = _execute.execute(b"ResamplerGrad",
2,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("ResamplerGrad", _inputs_flat, _attrs, _result,
name)
_result = _ResamplerGradOutput._make(_result)
return _result
