def single_image_random_dot_stereograms_eager_fallback(depth_values, hidden_surface_removal=True, convergence_dots_size=8, dots_per_inch=72, eye_separation=2.5, mu=0.3333, normalize=True, normalize_max=-100, normalize_min=100, border_level=0, number_colors=256, output_image_shape=[1024, 768, 1], output_data_window=[1022, 757], name=None, ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function single_image_random_dot_stereograms
"""
_ctx = ctx if ctx else _context.context()
if hidden_surface_removal is None:
hidden_surface_removal = True
hidden_surface_removal = _execute.make_bool(hidden_surface_removal, "hidden_surface_removal")
if convergence_dots_size is None:
convergence_dots_size = 8
convergence_dots_size = _execute.make_int(convergence_dots_size, "convergence_dots_size")
if dots_per_inch is None:
dots_per_inch = 72
dots_per_inch = _execute.make_int(dots_per_inch, "dots_per_inch")
if eye_separation is None:
eye_separation = 2.5
eye_separation = _execute.make_float(eye_separation, "eye_separation")
if mu is None:
mu = 0.3333
mu = _execute.make_float(mu, "mu")
if normalize is None:
normalize = True
normalize = _execute.make_bool(normalize, "normalize")
if normalize_max is None:
normalize_max = -100
normalize_max = _execute.make_float(normalize_max, "normalize_max")
if normalize_min is None:
normalize_min = 100
normalize_min = _execute.make_float(normalize_min, "normalize_min")
if border_level is None:
border_level = 0
border_level = _execute.make_float(border_level, "border_level")
if number_colors is None:
number_colors = 256
number_colors = _execute.make_int(number_colors, "number_colors")
if output_image_shape is None:
output_image_shape = [1024, 768, 1]
output_image_shape = _execute.make_shape(output_image_shape, "output_image_shape")
if output_data_window is None:
output_data_window = [1022, 757]
output_data_window = _execute.make_shape(output_data_window, "output_data_window")
_attr_T, (depth_values,) = _execute.args_to_matching_eager([depth_values], _ctx)
_inputs_flat = [depth_values]
_attrs = ("T", _attr_T, "hidden_surface_removal", hidden_surface_removal,
"convergence_dots_size", convergence_dots_size, "dots_per_inch",
dots_per_inch, "eye_separation", eye_separation, "mu", mu, "normalize",
normalize, "normalize_max", normalize_max, "normalize_min", normalize_min,
"border_level", border_level, "number_colors", number_colors,
"output_image_shape", output_image_shape, "output_data_window",
output_data_window)
_result = _execute.execute(b"SingleImageRandomDotStereograms", 1,
inputs=_inputs_flat, attrs=_attrs, ctx=_ctx,
name=name)
_execute.record_gradient(
"SingleImageRandomDotStereograms", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
def range_decode(encoded, shape, cdf, precision, name=None):
r"""Decodes a range-coded `code` into an int32 tensor of shape `shape`.
This is the reverse op of RangeEncode. The shape of the tensor that was encoded
should be known by the caller.
Implementation notes:
- If wrong input was given (e.g., corrupt `encoded` string, or `cdf` or
`precision` do not match encoder), the decode is unsuccessful. Because of
potential performance issues, the decoder does not return error status.
Args:
encoded: A `Tensor` of type `string`.
A scalar string tensor from RangeEncode.
shape: A `Tensor` of type `int32`.
An int32 1-D tensor representing the shape of the data encoded by
RangeEncode.
cdf: A `Tensor` of type `int32`.
precision: An `int` that is `>= 1`.
The number of bits for probability quantization. Must be <= 16, and
must match the precision used by RangeEncode that produced `encoded`.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `int16`. An int16 tensor with shape equal to `shape`.
"""
_ctx = _context._context
if _ctx is None or not _ctx._eager_context.is_eager:
precision = _execute.make_int(precision, "precision")
_, _, _op = _op_def_lib._apply_op_helper(
"RangeDecode", encoded=encoded, shape=shape, cdf=cdf,
precision=precision, name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("precision", _op.get_attr("precision"))
_execute.record_gradient(
"RangeDecode", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name, "RangeDecode",
name, _ctx._post_execution_callbacks, encoded, shape, cdf,
"precision", precision)
return _result
except _core._FallbackException:
return range_decode_eager_fallback(
encoded, shape, cdf, precision=precision, name=name, ctx=_ctx)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def tree_ensemble_used_handlers(tree_ensemble_handle, stamp_token, num_all_handlers, name=None):
r"""Returns the mask of used handlers along with the number of non-zero elements in
this mask. Used in feature selection.
Args:
tree_ensemble_handle: A `Tensor` of type `resource`.
Handle to the tree ensemble.
stamp_token: A `Tensor` of type `int64`.
Token to use as the new value of the resource stamp.
num_all_handlers: An `int` that is `>= 0`.
name: A name for the operation (optional).
Returns:
A tuple of `Tensor` objects (num_used_handlers, used_handlers_mask).
num_used_handlers: A `Tensor` of type `int64`. number of feature column handlers used in the model.
used_handlers_mask: A `Tensor` of type `bool`. A boolean vector of showing which handlers are used in the
model.
"""
_ctx = _context._context
if _ctx is None or not _ctx._eager_context.is_eager:
num_all_handlers = _execute.make_int(num_all_handlers, "num_all_handlers")
_, _, _op = _op_def_lib._apply_op_helper(
"TreeEnsembleUsedHandlers", tree_ensemble_handle=tree_ensemble_handle,
stamp_token=stamp_token, num_all_handlers=num_all_handlers, name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("num_all_handlers", _op.get_attr("num_all_handlers"))
_execute.record_gradient(
"TreeEnsembleUsedHandlers", _inputs_flat, _attrs, _result, name)
_result = _TreeEnsembleUsedHandlersOutput._make(_result)
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name,
"TreeEnsembleUsedHandlers", name, _ctx._post_execution_callbacks,
tree_ensemble_handle, stamp_token, "num_all_handlers",
num_all_handlers)
_result = _TreeEnsembleUsedHandlersOutput._make(_result)
return _result
except _core._FallbackException:
return tree_ensemble_used_handlers_eager_fallback(
tree_ensemble_handle, stamp_token,
num_all_handlers=num_all_handlers, name=name, ctx=_ctx)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def pmf_to_quantized_cdf(pmf, precision, name=None):
r"""Converts PMF to quantized CDF. This op uses floating-point operations
internally. Therefore the quantized output may not be consistent across multiple
platforms. For entropy encoders and decoders to have the same quantized CDF on
different platforms, the quantized CDF should be produced once and saved, then
the saved quantized CDF should be used everywhere.
After quantization, if PMF does not sum to 2^precision, then some values of PMF
are increased or decreased to adjust the sum to equal to 2^precision.
Note that the input PMF is pre-quantization. The input PMF is not normalized
by this op prior to quantization. Therefore the user is responsible for
normalizing PMF if necessary.
Args:
pmf: A `Tensor` of type `float32`.
precision: An `int` that is `>= 1`.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `int32`.
"""
_ctx = _context._context
if _ctx is None or not _ctx._eager_context.is_eager:
precision = _execute.make_int(precision, "precision")
_, _, _op = _op_def_lib._apply_op_helper(
"PmfToQuantizedCdf", pmf=pmf, precision=precision, name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("precision", _op.get_attr("precision"))
_execute.record_gradient(
"PmfToQuantizedCdf", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name,
"PmfToQuantizedCdf", name, _ctx._post_execution_callbacks, pmf,
"precision", precision)
return _result
except _core._FallbackException:
return pmf_to_quantized_cdf_eager_fallback(
pmf, precision=precision, name=name, ctx=_ctx)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def sparse_feature_cross_v2_eager_fallback(indices, values, shapes, dense, hashed_output, num_buckets, hash_key, out_type, internal_type, name=None, ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function sparse_feature_cross_v2
"""
_ctx = ctx if ctx else _context.context()
if not isinstance(indices, (list, tuple)):
raise TypeError(
"Expected list for 'indices' argument to "
"'sparse_feature_cross_v2' Op, not %r." % indices)
_attr_N = len(indices)
if not isinstance(shapes, (list, tuple)):
raise TypeError(
"Expected list for 'shapes' argument to "
"'sparse_feature_cross_v2' Op, not %r." % shapes)
if len(shapes) != _attr_N:
raise ValueError(
"List argument 'shapes' to 'sparse_feature_cross_v2' Op with length %d "
"must match length %d of argument 'indices'." %
(len(shapes), _attr_N))
hashed_output = _execute.make_bool(hashed_output, "hashed_output")
num_buckets = _execute.make_int(num_buckets, "num_buckets")
hash_key = _execute.make_int(hash_key, "hash_key")
out_type = _execute.make_type(out_type, "out_type")
internal_type = _execute.make_type(internal_type, "internal_type")
_attr_sparse_types, values = _execute.convert_to_mixed_eager_tensors(values, _ctx)
_attr_dense_types, dense = _execute.convert_to_mixed_eager_tensors(dense, _ctx)
indices = _ops.convert_n_to_tensor(indices, _dtypes.int64)
shapes = _ops.convert_n_to_tensor(shapes, _dtypes.int64)
_inputs_flat = list(indices) + list(values) + list(shapes) + list(dense)
_attrs = ("N", _attr_N, "hashed_output", hashed_output, "num_buckets",
num_buckets, "hash_key", hash_key, "sparse_types", _attr_sparse_types,
"dense_types", _attr_dense_types, "out_type", out_type, "internal_type",
internal_type)
_result = _execute.execute(b"SparseFeatureCrossV2", 3, inputs=_inputs_flat,
attrs=_attrs, ctx=_ctx, name=name)
_execute.record_gradient(
"SparseFeatureCrossV2", _inputs_flat, _attrs, _result, name)
_result = _SparseFeatureCrossV2Output._make(_result)
return _result
def pmf_to_quantized_cdf_eager_fallback(pmf, precision, name=None, ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function pmf_to_quantized_cdf
"""
_ctx = ctx if ctx else _context.context()
precision = _execute.make_int(precision, "precision")
pmf = _ops.convert_to_tensor(pmf, _dtypes.float32)
_inputs_flat = [pmf]
_attrs = ("precision", precision)
_result = _execute.execute(b"PmfToQuantizedCdf", 1, inputs=_inputs_flat,
attrs=_attrs, ctx=_ctx, name=name)
_execute.record_gradient(
"PmfToQuantizedCdf", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
def range_encode_eager_fallback(data, cdf, precision, name=None, ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function range_encode
"""
_ctx = ctx if ctx else _context.context()
precision = _execute.make_int(precision, "precision")
data = _ops.convert_to_tensor(data, _dtypes.int16)
cdf = _ops.convert_to_tensor(cdf, _dtypes.int32)
_inputs_flat = [data, cdf]
_attrs = ("precision", precision)
_result = _execute.execute(b"RangeEncode", 1, inputs=_inputs_flat,
attrs=_attrs, ctx=_ctx, name=name)
_execute.record_gradient(
"RangeEncode", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
def tree_ensemble_used_handlers_eager_fallback(tree_ensemble_handle, stamp_token, num_all_handlers, name=None, ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function tree_ensemble_used_handlers
"""
_ctx = ctx if ctx else _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 bipartite_match_eager_fallback(distance_mat, num_valid_rows, top_k=-1, name=None, ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function bipartite_match
"""
_ctx = ctx if ctx else _context.context()
if top_k is None:
top_k = -1
top_k = _execute.make_int(top_k, "top_k")
distance_mat = _ops.convert_to_tensor(distance_mat, _dtypes.float32)
num_valid_rows = _ops.convert_to_tensor(num_valid_rows, _dtypes.float32)
_inputs_flat = [distance_mat, num_valid_rows]
_attrs = ("top_k", top_k)
_result = _execute.execute(b"BipartiteMatch", 2, inputs=_inputs_flat,
attrs=_attrs, ctx=_ctx, name=name)
_execute.record_gradient(
"BipartiteMatch", _inputs_flat, _attrs, _result, name)
_result = _BipartiteMatchOutput._make(_result)
return _result
def rpc(address, method, request, protocol="", fail_fast=True, timeout_in_ms=0, name=None):
r"""TODO: add doc.
Args:
address: A `Tensor` of type `string`.
method: A `Tensor` of type `string`.
request: A `Tensor` of type `string`.
protocol: An optional `string`. Defaults to `""`.
fail_fast: An optional `bool`. Defaults to `True`.
timeout_in_ms: An optional `int`. Defaults to `0`.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `string`.
"""
_ctx = _context._context
if _ctx is not None and _ctx._eager_context.is_eager:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name, "Rpc", name,
_ctx._post_execution_callbacks, address, method, request, "protocol",
protocol, "fail_fast", fail_fast, "timeout_in_ms", timeout_in_ms)
return _result
except _core._FallbackException:
try:
return rpc_eager_fallback(
address, method, request, protocol=protocol, fail_fast=fail_fast,
timeout_in_ms=timeout_in_ms, name=name, ctx=_ctx)
except _core._SymbolicException:
pass # Add nodes to the TensorFlow graph.
except (TypeError, ValueError):
result = _dispatch.dispatch(
rpc, address=address, method=method, request=request,
protocol=protocol, fail_fast=fail_fast,
timeout_in_ms=timeout_in_ms, name=name)
if result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
return result
raise
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
# Add nodes to the TensorFlow graph.
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")
try:
_, _, _op = _op_def_lib._apply_op_helper(
"Rpc", address=address, method=method, request=request,
protocol=protocol, fail_fast=fail_fast,
timeout_in_ms=timeout_in_ms, name=name)
except (TypeError, ValueError):
result = _dispatch.dispatch(
rpc, address=address, method=method, request=request,
protocol=protocol, fail_fast=fail_fast,
timeout_in_ms=timeout_in_ms, name=name)
if result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
return result
raise
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("protocol", _op.get_attr("protocol"), "fail_fast",
_op.get_attr("fail_fast"), "timeout_in_ms",
_op.get_attr("timeout_in_ms"))
_execute.record_gradient(
"Rpc", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
def collective_reduce(input,
group_size,
group_key,
instance_key,
merge_op,
final_op,
subdiv_offsets,
name=None):
r"""Mutually reduces multiple tensors of identical type and shape.
Args:
input: A `Tensor`. Must be one of the following types: `float32`, `half`, `float64`, `int32`, `int64`.
group_size: An `int`.
group_key: An `int`.
instance_key: An `int`.
merge_op: A `string` from: `"Min", "Max", "Mul", "Add"`.
final_op: A `string` from: `"Id", "Div"`.
subdiv_offsets: A list of `ints`.
name: A name for the operation (optional).
Returns:
A `Tensor`. Has the same type as `input`.
"""
_ctx = _context._context
if _ctx is not None and _ctx._eager_context.is_eager:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name,
"CollectiveReduce", name, _ctx._post_execution_callbacks,
input, "group_size", group_size, "group_key", group_key,
"instance_key", instance_key, "merge_op", merge_op, "final_op",
final_op, "subdiv_offsets", subdiv_offsets)
return _result
except _core._FallbackException:
try:
return collective_reduce_eager_fallback(
input,
group_size=group_size,
group_key=group_key,
instance_key=instance_key,
merge_op=merge_op,
final_op=final_op,
subdiv_offsets=subdiv_offsets,
name=name,
ctx=_ctx)
except _core._SymbolicException:
pass # Add nodes to the TensorFlow graph.
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
# Add nodes to the TensorFlow graph.
group_size = _execute.make_int(group_size, "group_size")
group_key = _execute.make_int(group_key, "group_key")
instance_key = _execute.make_int(instance_key, "instance_key")
merge_op = _execute.make_str(merge_op, "merge_op")
final_op = _execute.make_str(final_op, "final_op")
if not isinstance(subdiv_offsets, (list, tuple)):
raise TypeError("Expected list for 'subdiv_offsets' argument to "
"'collective_reduce' Op, not %r." % subdiv_offsets)
subdiv_offsets = [
_execute.make_int(_i, "subdiv_offsets") for _i in subdiv_offsets
]
_, _, _op = _op_def_lib._apply_op_helper("CollectiveReduce",
input=input,
group_size=group_size,
group_key=group_key,
instance_key=instance_key,
merge_op=merge_op,
final_op=final_op,
subdiv_offsets=subdiv_offsets,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("T", _op.get_attr("T"), "group_size", _op.get_attr("group_size"),
"group_key", _op.get_attr("group_key"), "instance_key",
_op.get_attr("instance_key"),
"merge_op", _op.get_attr("merge_op"), "final_op",
_op.get_attr("final_op"), "subdiv_offsets",
_op.get_attr("subdiv_offsets"))
_execute.record_gradient("CollectiveReduce", _inputs_flat, _attrs, _result,
name)
_result, = _result
return _result
def mfcc(spectrogram,
sample_rate,
upper_frequency_limit=4000,
lower_frequency_limit=20,
filterbank_channel_count=40,
dct_coefficient_count=13,
name=None):
r"""Transforms a spectrogram into a form that's useful for speech recognition.
Mel Frequency Cepstral Coefficients are a way of representing audio data that's
been effective as an input feature for machine learning. They are created by
taking the spectrum of a spectrogram (a 'cepstrum'), and discarding some of the
higher frequencies that are less significant to the human ear. They have a long
history in the speech recognition world, and https://en.wikipedia.org/wiki/Mel-frequency_cepstrum
is a good resource to learn more.
Args:
spectrogram: A `Tensor` of type `float32`.
Typically produced by the Spectrogram op, with magnitude_squared
set to true.
sample_rate: A `Tensor` of type `int32`.
How many samples per second the source audio used.
upper_frequency_limit: An optional `float`. Defaults to `4000`.
The highest frequency to use when calculating the
ceptstrum.
lower_frequency_limit: An optional `float`. Defaults to `20`.
The lowest frequency to use when calculating the
ceptstrum.
filterbank_channel_count: An optional `int`. Defaults to `40`.
Resolution of the Mel bank used internally.
dct_coefficient_count: An optional `int`. Defaults to `13`.
How many output channels to produce per time slice.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `float32`.
"""
_ctx = _context.context()
if not _ctx.executing_eagerly():
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")
_, _, _op = _op_def_lib._apply_op_helper(
"Mfcc",
spectrogram=spectrogram,
sample_rate=sample_rate,
upper_frequency_limit=upper_frequency_limit,
lower_frequency_limit=lower_frequency_limit,
filterbank_channel_count=filterbank_channel_count,
dct_coefficient_count=dct_coefficient_count,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("upper_frequency_limit",
_op.get_attr("upper_frequency_limit"),
"lower_frequency_limit",
_op.get_attr("lower_frequency_limit"),
"filterbank_channel_count",
_op.get_attr("filterbank_channel_count"),
"dct_coefficient_count",
_op.get_attr("dct_coefficient_count"))
_execute.record_gradient("Mfcc", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._handle, _ctx.device_name, "Mfcc", name,
_ctx._post_execution_callbacks, spectrogram, sample_rate,
"upper_frequency_limit", upper_frequency_limit,
"lower_frequency_limit", lower_frequency_limit,
"filterbank_channel_count", filterbank_channel_count,
"dct_coefficient_count", dct_coefficient_count)
return _result
except _core._FallbackException:
return mfcc_eager_fallback(
spectrogram,
sample_rate,
upper_frequency_limit=upper_frequency_limit,
lower_frequency_limit=lower_frequency_limit,
filterbank_channel_count=filterbank_channel_count,
dct_coefficient_count=dct_coefficient_count,
name=name)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def decode_wav(contents, desired_channels=-1, desired_samples=-1, name=None):
r"""Decode a 16-bit PCM WAV file to a float tensor.
The -32768 to 32767 signed 16-bit values will be scaled to -1.0 to 1.0 in float.
When desired_channels is set, if the input contains fewer channels than this
then the last channel will be duplicated to give the requested number, else if
the input has more channels than requested then the additional channels will be
ignored.
If desired_samples is set, then the audio will be cropped or padded with zeroes
to the requested length.
The first output contains a Tensor with the content of the audio samples. The
lowest dimension will be the number of channels, and the second will be the
number of samples. For example, a ten-sample-long stereo WAV file should give an
output shape of [10, 2].
Args:
contents: A `Tensor` of type `string`.
The WAV-encoded audio, usually from a file.
desired_channels: An optional `int`. Defaults to `-1`.
Number of sample channels wanted.
desired_samples: An optional `int`. Defaults to `-1`.
Length of audio requested.
name: A name for the operation (optional).
Returns:
A tuple of `Tensor` objects (audio, sample_rate).
audio: A `Tensor` of type `float32`.
sample_rate: A `Tensor` of type `int32`.
"""
_ctx = _context.context()
if not _ctx.executing_eagerly():
if desired_channels is None:
desired_channels = -1
desired_channels = _execute.make_int(desired_channels,
"desired_channels")
if desired_samples is None:
desired_samples = -1
desired_samples = _execute.make_int(desired_samples, "desired_samples")
_, _, _op = _op_def_lib._apply_op_helper(
"DecodeWav",
contents=contents,
desired_channels=desired_channels,
desired_samples=desired_samples,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("desired_channels", _op.get_attr("desired_channels"),
"desired_samples", _op.get_attr("desired_samples"))
_execute.record_gradient("DecodeWav", _inputs_flat, _attrs, _result,
name)
_result = _DecodeWavOutput._make(_result)
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._handle, _ctx.device_name, "DecodeWav", name,
_ctx._post_execution_callbacks, contents, "desired_channels",
desired_channels, "desired_samples", desired_samples)
_result = _DecodeWavOutput._make(_result)
return _result
except _core._FallbackException:
return decode_wav_eager_fallback(contents,
desired_channels=desired_channels,
desired_samples=desired_samples,
name=name)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def sparse_feature_cross(indices,
values,
shapes,
dense,
hashed_output,
num_buckets,
out_type,
internal_type,
name=None):
r"""Generates sparse cross form a list of sparse tensors.
The op takes two lists, one of 2D `SparseTensor` and one of 2D `Tensor`, each
representing features of one feature column. It outputs a 2D `SparseTensor` with
the batchwise crosses of these features.
For example, if the inputs are
inputs[0]: SparseTensor with shape = [2, 2]
[0, 0]: "a"
[1, 0]: "b"
[1, 1]: "c"
inputs[1]: SparseTensor with shape = [2, 1]
[0, 0]: "d"
[1, 0]: "e"
inputs[2]: Tensor [["f"], ["g"]]
then the output will be
shape = [2, 2]
[0, 0]: "a_X_d_X_f"
[1, 0]: "b_X_e_X_g"
[1, 1]: "c_X_e_X_g"
if hashed_output=true then the output will be
shape = [2, 2]
[0, 0]: HashCombine(
Fingerprint64("f"), HashCombine(
Fingerprint64("d"), Fingerprint64("a")))
[1, 0]: HashCombine(
Fingerprint64("g"), HashCombine(
Fingerprint64("e"), Fingerprint64("b")))
[1, 1]: HashCombine(
Fingerprint64("g"), HashCombine(
Fingerprint64("e"), Fingerprint64("c")))
Args:
indices: A list of `Tensor` objects with type `int64`.
2-D. Indices of each input `SparseTensor`.
values: A list of `Tensor` objects with types from: `int64`, `string`.
1-D. values of each `SparseTensor`.
shapes: A list with the same length as `indices` of `Tensor` objects with type `int64`.
1-D. Shapes of each `SparseTensor`.
dense: A list of `Tensor` objects with types from: `int64`, `string`.
2-D. Columns represented by dense `Tensor`.
hashed_output: A `bool`.
num_buckets: An `int` that is `>= 0`.
out_type: A `tf.DType` from: `tf.int64, tf.string`.
internal_type: A `tf.DType` from: `tf.int64, tf.string`.
name: A name for the operation (optional).
Returns:
A tuple of `Tensor` objects (output_indices, output_values, output_shape).
output_indices: A `Tensor` of type `int64`. 2-D. Indices of the concatenated `SparseTensor`.
output_values: A `Tensor` of type `out_type`. 1-D. Non-empty values of the concatenated or hashed
`SparseTensor`.
output_shape: A `Tensor` of type `int64`. 1-D. Shape of the concatenated `SparseTensor`.
"""
if not isinstance(indices, (list, tuple)):
raise TypeError("Expected list for 'indices' argument to "
"'sparse_feature_cross' Op, not %r." % indices)
_attr_N = len(indices)
if not isinstance(shapes, (list, tuple)):
raise TypeError("Expected list for 'shapes' argument to "
"'sparse_feature_cross' Op, not %r." % shapes)
if len(shapes) != _attr_N:
raise ValueError(
"List argument 'shapes' to 'sparse_feature_cross' Op with length %d "
"must match length %d of argument 'indices'." %
(len(shapes), _attr_N))
hashed_output = _execute.make_bool(hashed_output, "hashed_output")
num_buckets = _execute.make_int(num_buckets, "num_buckets")
out_type = _execute.make_type(out_type, "out_type")
internal_type = _execute.make_type(internal_type, "internal_type")
_ctx = _context.context()
if _ctx.in_graph_mode():
_, _, _op = _op_def_lib._apply_op_helper("SparseFeatureCross",
indices=indices,
values=values,
shapes=shapes,
dense=dense,
hashed_output=hashed_output,
num_buckets=num_buckets,
out_type=out_type,
internal_type=internal_type,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("N", _op.get_attr("N"), "hashed_output",
_op.get_attr("hashed_output"), "num_buckets",
_op.get_attr("num_buckets"), "sparse_types",
_op.get_attr("sparse_types"), "dense_types",
_op.get_attr("dense_types"), "out_type",
_op.get_attr("out_type"), "internal_type",
_op.get_attr("internal_type"))
else:
_attr_sparse_types, values = _execute.convert_to_mixed_eager_tensors(
values, _ctx)
_attr_dense_types, dense = _execute.convert_to_mixed_eager_tensors(
dense, _ctx)
indices = _ops.convert_n_to_tensor(indices, _dtypes.int64)
shapes = _ops.convert_n_to_tensor(shapes, _dtypes.int64)
_inputs_flat = list(indices) + list(values) + list(shapes) + list(
dense)
_attrs = ("N", _attr_N, "hashed_output", hashed_output, "num_buckets",
num_buckets, "sparse_types", _attr_sparse_types,
"dense_types", _attr_dense_types, "out_type", out_type,
"internal_type", internal_type)
_result = _execute.execute(b"SparseFeatureCross",
3,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("SparseFeatureCross", _inputs_flat, _attrs,
_result, name)
_result = _SparseFeatureCrossOutput._make(_result)
return _result
def generate_vocab_remapping(new_vocab_file,
old_vocab_file,
new_vocab_offset,
num_new_vocab,
old_vocab_size=-1,
name=None):
r"""Given a path to new and old vocabulary files, returns a remapping Tensor of
length `num_new_vocab`, where `remapping[i]` contains the row number in the old
vocabulary that corresponds to row `i` in the new vocabulary (starting at line
`new_vocab_offset` and up to `num_new_vocab` entities), or `-1` if entry `i`
in the new vocabulary is not in the old vocabulary. The old vocabulary is
constrained to the first `old_vocab_size` entries if `old_vocab_size` is not the
default value of -1.
`num_vocab_offset` enables
use in the partitioned variable case, and should generally be set through
examining partitioning info. The format of the files should be a text file,
with each line containing a single entity within the vocabulary.
For example, with `new_vocab_file` a text file containing each of the following
elements on a single line: `[f0, f1, f2, f3]`, old_vocab_file = [f1, f0, f3],
`num_new_vocab = 3, new_vocab_offset = 1`, the returned remapping would be
`[0, -1, 2]`.
The op also returns a count of how many entries in the new vocabulary
were present in the old vocabulary, which is used to calculate the number of
values to initialize in a weight matrix remapping
This functionality can be used to remap both row vocabularies (typically,
features) and column vocabularies (typically, classes) from TensorFlow
checkpoints. Note that the partitioning logic relies on contiguous vocabularies
corresponding to div-partitioned variables. Moreover, the underlying remapping
uses an IndexTable (as opposed to an inexact CuckooTable), so client code should
use the corresponding index_table_from_file() as the FeatureColumn framework
does (as opposed to tf.feature_to_id(), which uses a CuckooTable).
Args:
new_vocab_file: A `Tensor` of type `string`. Path to the new vocab file.
old_vocab_file: A `Tensor` of type `string`. Path to the old vocab file.
new_vocab_offset: An `int` that is `>= 0`.
How many entries into the new vocab file to start reading.
num_new_vocab: An `int` that is `>= 0`.
Number of entries in the new vocab file to remap.
old_vocab_size: An optional `int` that is `>= -1`. Defaults to `-1`.
Number of entries in the old vocab file to consider. If -1,
use the entire old vocabulary.
name: A name for the operation (optional).
Returns:
A tuple of `Tensor` objects (remapping, num_present).
remapping: A `Tensor` of type `int64`.
num_present: A `Tensor` of type `int32`.
"""
_ctx = _context._context
if _ctx is None or not _ctx._eager_context.is_eager:
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")
_, _, _op = _op_def_lib._apply_op_helper(
"GenerateVocabRemapping",
new_vocab_file=new_vocab_file,
old_vocab_file=old_vocab_file,
new_vocab_offset=new_vocab_offset,
num_new_vocab=num_new_vocab,
old_vocab_size=old_vocab_size,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("new_vocab_offset", _op.get_attr("new_vocab_offset"),
"num_new_vocab", _op.get_attr("num_new_vocab"),
"old_vocab_size", _op.get_attr("old_vocab_size"))
_execute.record_gradient("GenerateVocabRemapping", _inputs_flat,
_attrs, _result, name)
_result = _GenerateVocabRemappingOutput._make(_result)
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name,
"GenerateVocabRemapping", name, _ctx._post_execution_callbacks,
new_vocab_file, old_vocab_file, "new_vocab_offset",
new_vocab_offset, "num_new_vocab", num_new_vocab,
"old_vocab_size", old_vocab_size)
_result = _GenerateVocabRemappingOutput._make(_result)
return _result
except _core._FallbackException:
return generate_vocab_remapping_eager_fallback(
new_vocab_file,
old_vocab_file,
new_vocab_offset=new_vocab_offset,
num_new_vocab=num_new_vocab,
old_vocab_size=old_vocab_size,
name=name,
ctx=_ctx)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def _compute_accidental_hits(true_classes,
sampled_candidates,
num_true,
seed=0,
seed2=0,
name=None):
r"""Computes the ids of the positions in sampled_candidates that match true_labels.
When doing log-odds NCE, the result of this op should be passed through a
SparseToDense op, then added to the logits of the sampled candidates. This has
the effect of 'removing' the sampled labels that match the true labels by
making the classifier sure that they are sampled labels.
Args:
true_classes: A `Tensor` of type `int64`.
The true_classes output of UnpackSparseLabels.
sampled_candidates: A `Tensor` of type `int64`.
The sampled_candidates output of CandidateSampler.
num_true: An `int`. Number of true labels per context.
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 (indices, ids, weights).
indices: A `Tensor` of type `int32`. A vector of indices corresponding to rows of true_candidates.
ids: A `Tensor` of type `int64`. A vector of IDs of positions in sampled_candidates that match a true_label
for the row with the corresponding index in indices.
weights: A `Tensor` of type `float32`. A vector of the same length as indices and ids, in which each element
is -FLOAT_MAX.
"""
num_true = _execute.make_int(num_true, "num_true")
if seed is None:
seed = 0
seed = _execute.make_int(seed, "seed")
if seed2 is None:
seed2 = 0
seed2 = _execute.make_int(seed2, "seed2")
_ctx = _context.context()
if _ctx.in_graph_mode():
_, _, _op = _op_def_lib._apply_op_helper(
"ComputeAccidentalHits",
true_classes=true_classes,
sampled_candidates=sampled_candidates,
num_true=num_true,
seed=seed,
seed2=seed2,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("num_true", _op.get_attr("num_true"), "seed",
_op.get_attr("seed"), "seed2", _op.get_attr("seed2"))
else:
true_classes = _ops.convert_to_tensor(true_classes, _dtypes.int64)
sampled_candidates = _ops.convert_to_tensor(sampled_candidates,
_dtypes.int64)
_inputs_flat = [true_classes, sampled_candidates]
_attrs = ("num_true", num_true, "seed", seed, "seed2", seed2)
_result = _execute.execute(b"ComputeAccidentalHits",
3,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("ComputeAccidentalHits", _inputs_flat, _attrs,
_result, name)
_result = _ComputeAccidentalHitsOutput._make(_result)
return _result
def random_uniform_int(shape, minval, maxval, seed=0, seed2=0, name=None):
r"""Outputs random integers from a uniform distribution.
The generated values are uniform integers in the range `[minval, maxval)`.
The lower bound `minval` is included in the range, while the upper bound
`maxval` is excluded.
The random integers are slightly biased unless `maxval - minval` is an exact
power of two. The bias is small for values of `maxval - minval` significantly
smaller than the range of the output (either `2^32` or `2^64`).
Args:
shape: A `Tensor`. Must be one of the following types: `int32`, `int64`.
The shape of the output tensor.
minval: A `Tensor`. Must be one of the following types: `int32`, `int64`.
0-D. Inclusive lower bound on the generated integers.
maxval: A `Tensor`. Must have the same type as `minval`.
0-D. Exclusive upper bound on the generated integers.
seed: An optional `int`. Defaults to `0`.
If either `seed` or `seed2` are set to be non-zero, the random number
generator is seeded by the given seed. Otherwise, it is seeded by a
random seed.
seed2: An optional `int`. Defaults to `0`.
A second seed to avoid seed collision.
name: A name for the operation (optional).
Returns:
A `Tensor`. Has the same type as `minval`.
"""
_ctx = _context.context()
if not _ctx.executing_eagerly():
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 = _op_def_lib._apply_op_helper(
"RandomUniformInt", shape=shape, minval=minval, maxval=maxval,
seed=seed, seed2=seed2, name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("seed", _op.get_attr("seed"), "seed2", _op.get_attr("seed2"),
"Tout", _op.get_attr("Tout"), "T", _op.get_attr("T"))
_execute.record_gradient(
"RandomUniformInt", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._handle, _ctx.device_name, "RandomUniformInt", name,
_ctx._post_execution_callbacks, shape, minval, maxval, "seed", seed,
"seed2", seed2)
return _result
except _core._FallbackException:
return random_uniform_int_eager_fallback(
shape, minval, maxval, seed=seed, seed2=seed2, name=name)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def enter(data, frame_name, is_constant=False, parallel_iterations=10, name=None):
r"""Creates or finds a child frame, and makes `data` available to the child frame.
This op is used together with `Exit` to create loops in the graph.
The unique `frame_name` is used by the `Executor` to identify frames. If
`is_constant` is true, `output` is a constant in the child frame; otherwise
it may be changed in the child frame. At most `parallel_iterations` iterations
are run in parallel in the child frame.
Args:
data: A `Tensor`. The tensor to be made available to the child frame.
frame_name: A `string`. The name of the child frame.
is_constant: An optional `bool`. Defaults to `False`.
If true, the output is constant within the child frame.
parallel_iterations: An optional `int`. Defaults to `10`.
The number of iterations allowed to run in parallel.
name: A name for the operation (optional).
Returns:
A `Tensor`. Has the same type as `data`.
"""
_ctx = _context._context or _context.context()
if _ctx is not None and _ctx._thread_local_data.is_eager:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._thread_local_data.device_name, "Enter",
name, _ctx._post_execution_callbacks, data, "frame_name", frame_name,
"is_constant", is_constant, "parallel_iterations",
parallel_iterations)
return _result
except _core._FallbackException:
try:
return enter_eager_fallback(
data, frame_name=frame_name, is_constant=is_constant,
parallel_iterations=parallel_iterations, name=name, ctx=_ctx)
except _core._SymbolicException:
pass # Add nodes to the TensorFlow graph.
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
# Add nodes to the TensorFlow graph.
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")
_, _, _op = _op_def_lib._apply_op_helper(
"Enter", data=data, frame_name=frame_name, is_constant=is_constant,
parallel_iterations=parallel_iterations, name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("T", _op.get_attr("T"), "frame_name", _op.get_attr("frame_name"),
"is_constant", _op.get_attr("is_constant"), "parallel_iterations",
_op.get_attr("parallel_iterations"))
_execute.record_gradient(
"Enter", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
def random_poisson_v2(shape, rate, seed=0, seed2=0, dtype=_dtypes.int64, name=None):
r"""Outputs random values from the Poisson distribution(s) described by rate.
This op uses two algorithms, depending on rate. If rate >= 10, then
the algorithm by Hormann is used to acquire samples via
transformation-rejection.
See http://www.sciencedirect.com/science/article/pii/0167668793909974.
Otherwise, Knuth's algorithm is used to acquire samples via multiplying uniform
random variables.
See Donald E. Knuth (1969). Seminumerical Algorithms. The Art of Computer
Programming, Volume 2. Addison Wesley
Args:
shape: A `Tensor`. Must be one of the following types: `int32`, `int64`.
1-D integer tensor. Shape of independent samples to draw from each
distribution described by the shape parameters given in rate.
rate: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`.
A tensor in which each scalar is a "rate" parameter describing the
associated poisson distribution.
seed: An optional `int`. Defaults to `0`.
If either `seed` or `seed2` are set to be non-zero, the random number
generator is seeded by the given seed. Otherwise, it is seeded by a
random seed.
seed2: An optional `int`. Defaults to `0`.
A second seed to avoid seed collision.
dtype: An optional `tf.DType` from: `tf.half, tf.float32, tf.float64, tf.int32, tf.int64`. Defaults to `tf.int64`.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `dtype`.
"""
_ctx = _context.context()
if not _ctx.executing_eagerly():
if seed is None:
seed = 0
seed = _execute.make_int(seed, "seed")
if seed2 is None:
seed2 = 0
seed2 = _execute.make_int(seed2, "seed2")
if dtype is None:
dtype = _dtypes.int64
dtype = _execute.make_type(dtype, "dtype")
_, _, _op = _op_def_lib._apply_op_helper(
"RandomPoissonV2", shape=shape, rate=rate, seed=seed, seed2=seed2,
dtype=dtype, name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("seed", _op.get_attr("seed"), "seed2", _op.get_attr("seed2"),
"S", _op.get_attr("S"), "R", _op.get_attr("R"), "dtype",
_op.get_attr("dtype"))
_execute.record_gradient(
"RandomPoissonV2", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._handle, _ctx.device_name, "RandomPoissonV2", name,
_ctx._post_execution_callbacks, shape, rate, "seed", seed, "seed2",
seed2, "dtype", dtype)
return _result
except _core._FallbackException:
return random_poisson_v2_eager_fallback(
shape, rate, seed=seed, seed2=seed2, dtype=dtype, name=name)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def multinomial(logits, num_samples, seed=0, seed2=0, output_dtype=_dtypes.int64, name=None):
r"""Draws samples from a multinomial distribution.
Args:
logits: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.
2-D Tensor with shape `[batch_size, num_classes]`. Each slice `[i, :]`
represents the unnormalized log probabilities for all classes.
num_samples: A `Tensor` of type `int32`.
0-D. Number of independent samples to draw for each row slice.
seed: An optional `int`. Defaults to `0`.
If either seed or seed2 is set to be non-zero, the internal random number
generator is seeded by the given seed. Otherwise, a random seed is used.
seed2: An optional `int`. Defaults to `0`.
A second seed to avoid seed collision.
output_dtype: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int64`.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `output_dtype`.
"""
_ctx = _context.context()
if not _ctx.executing_eagerly():
if seed is None:
seed = 0
seed = _execute.make_int(seed, "seed")
if seed2 is None:
seed2 = 0
seed2 = _execute.make_int(seed2, "seed2")
if output_dtype is None:
output_dtype = _dtypes.int64
output_dtype = _execute.make_type(output_dtype, "output_dtype")
_, _, _op = _op_def_lib._apply_op_helper(
"Multinomial", logits=logits, num_samples=num_samples, seed=seed,
seed2=seed2, output_dtype=output_dtype, name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("seed", _op.get_attr("seed"), "seed2", _op.get_attr("seed2"),
"T", _op.get_attr("T"), "output_dtype",
_op.get_attr("output_dtype"))
_execute.record_gradient(
"Multinomial", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._handle, _ctx.device_name, "Multinomial", name,
_ctx._post_execution_callbacks, logits, num_samples, "seed", seed,
"seed2", seed2, "output_dtype", output_dtype)
return _result
except _core._FallbackException:
return multinomial_eager_fallback(
logits, num_samples, seed=seed, seed2=seed2,
output_dtype=output_dtype, name=name)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def bipartite_match(distance_mat, num_valid_rows, top_k=-1, name=None):
r"""Find bipartite matching based on a given distance matrix.
A greedy bi-partite matching algorithm is used to obtain the matching with the
(greedy) minimum distance.
Args:
distance_mat: A `Tensor` of type `float32`.
A 2-D float tensor of shape `[num_rows, num_columns]`. It is a
pair-wise distance matrix between the entities represented by each row and
each column. It is an asymmetric matrix. The smaller the distance is, the more
similar the pairs are. The bipartite matching is to minimize the distances.
num_valid_rows: A `Tensor` of type `float32`.
A scalar or a 1-D tensor with one element describing the
number of valid rows of distance_mat to consider for the bipartite matching.
If set to be negative, then all rows from `distance_mat` are used.
top_k: An optional `int`. Defaults to `-1`.
A scalar that specifies the number of top-k matches to retrieve.
If set to be negative, then is set according to the maximum number of
matches from `distance_mat`.
name: A name for the operation (optional).
Returns:
A tuple of `Tensor` objects (row_to_col_match_indices, col_to_row_match_indices).
row_to_col_match_indices: A `Tensor` of type `int32`. A vector of length num_rows, which is the number of
rows of the input `distance_matrix`.
If `row_to_col_match_indices[i]` is not -1, row i is matched to column
`row_to_col_match_indices[i]`.
col_to_row_match_indices: A `Tensor` of type `int32`. A vector of length num_columns, which is the number
of columns of the input distance matrix.
If `col_to_row_match_indices[j]` is not -1, column j is matched to row
`col_to_row_match_indices[j]`.
"""
_ctx = _context._context
if _ctx is None or not _ctx._eager_context.is_eager:
if top_k is None:
top_k = -1
top_k = _execute.make_int(top_k, "top_k")
_, _, _op = _op_def_lib._apply_op_helper(
"BipartiteMatch", distance_mat=distance_mat,
num_valid_rows=num_valid_rows, top_k=top_k, name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("top_k", _op.get_attr("top_k"))
_execute.record_gradient(
"BipartiteMatch", _inputs_flat, _attrs, _result, name)
_result = _BipartiteMatchOutput._make(_result)
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name,
"BipartiteMatch", name, _ctx._post_execution_callbacks, distance_mat,
num_valid_rows, "top_k", top_k)
_result = _BipartiteMatchOutput._make(_result)
return _result
except _core._FallbackException:
return bipartite_match_eager_fallback(
distance_mat, num_valid_rows, top_k=top_k, name=name, ctx=_ctx)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def sdca_optimizer(sparse_example_indices,
sparse_feature_indices,
sparse_feature_values,
dense_features,
example_weights,
example_labels,
sparse_indices,
sparse_weights,
dense_weights,
example_state_data,
loss_type,
l1,
l2,
num_loss_partitions,
num_inner_iterations,
adaptative=True,
name=None):
r"""Distributed version of Stochastic Dual Coordinate Ascent (SDCA) optimizer for
linear models with L1 + L2 regularization. As global optimization objective is
strongly-convex, the optimizer optimizes the dual objective at each step. The
optimizer applies each update one example at a time. Examples are sampled
uniformly, and the optimizer is learning rate free and enjoys linear convergence
rate.
[Proximal Stochastic Dual Coordinate Ascent](http://arxiv.org/pdf/1211.2717v1.pdf).<br>
Shai Shalev-Shwartz, Tong Zhang. 2012
$$Loss Objective = \sum f_{i} (wx_{i}) + (l2 / 2) * |w|^2 + l1 * |w|$$
[Adding vs. Averaging in Distributed Primal-Dual Optimization](http://arxiv.org/abs/1502.03508).<br>
Chenxin Ma, Virginia Smith, Martin Jaggi, Michael I. Jordan,
Peter Richtarik, Martin Takac. 2015
[Stochastic Dual Coordinate Ascent with Adaptive Probabilities](https://arxiv.org/abs/1502.08053).<br>
Dominik Csiba, Zheng Qu, Peter Richtarik. 2015
Args:
sparse_example_indices: A list of `Tensor` objects with type `int64`.
a list of vectors which contain example indices.
sparse_feature_indices: A list with the same length as `sparse_example_indices` of `Tensor` objects with type `int64`.
a list of vectors which contain feature indices.
sparse_feature_values: A list of `Tensor` objects with type `float32`.
a list of vectors which contains feature value
associated with each feature group.
dense_features: A list of `Tensor` objects with type `float32`.
a list of matrices which contains the dense feature values.
example_weights: A `Tensor` of type `float32`.
a vector which contains the weight associated with each
example.
example_labels: A `Tensor` of type `float32`.
a vector which contains the label/target associated with each
example.
sparse_indices: A list with the same length as `sparse_example_indices` of `Tensor` objects with type `int64`.
a list of vectors where each value is the indices which has
corresponding weights in sparse_weights. This field maybe omitted for the
dense approach.
sparse_weights: A list with the same length as `sparse_example_indices` of `Tensor` objects with type `float32`.
a list of vectors where each value is the weight associated with
a sparse feature group.
dense_weights: A list with the same length as `dense_features` of `Tensor` objects with type `float32`.
a list of vectors where the values are the weights associated
with a dense feature group.
example_state_data: A `Tensor` of type `float32`.
a list of vectors containing the example state data.
loss_type: A `string` from: `"logistic_loss", "squared_loss", "hinge_loss", "smooth_hinge_loss", "poisson_loss"`.
Type of the primal loss. Currently SdcaSolver supports logistic,
squared and hinge losses.
l1: A `float`. Symmetric l1 regularization strength.
l2: A `float`. Symmetric l2 regularization strength.
num_loss_partitions: An `int` that is `>= 1`.
Number of partitions of the global loss function.
num_inner_iterations: An `int` that is `>= 1`.
Number of iterations per mini-batch.
adaptative: An optional `bool`. Defaults to `True`.
Whether to use Adaptive SDCA for the inner loop.
name: A name for the operation (optional).
Returns:
A tuple of `Tensor` objects (out_example_state_data, out_delta_sparse_weights, out_delta_dense_weights).
out_example_state_data: A `Tensor` of type `float32`.
out_delta_sparse_weights: A list with the same length as `sparse_example_indices` of `Tensor` objects with type `float32`.
out_delta_dense_weights: A list with the same length as `dense_features` of `Tensor` objects with type `float32`.
"""
_ctx = _context._context
if _ctx is None or not _ctx._eager_context.is_eager:
if not isinstance(sparse_example_indices, (list, tuple)):
raise TypeError(
"Expected list for 'sparse_example_indices' argument to "
"'sdca_optimizer' Op, not %r." % sparse_example_indices)
_attr_num_sparse_features = len(sparse_example_indices)
if not isinstance(sparse_feature_indices, (list, tuple)):
raise TypeError(
"Expected list for 'sparse_feature_indices' argument to "
"'sdca_optimizer' Op, not %r." % sparse_feature_indices)
if len(sparse_feature_indices) != _attr_num_sparse_features:
raise ValueError(
"List argument 'sparse_feature_indices' to 'sdca_optimizer' Op with length %d "
"must match length %d of argument 'sparse_example_indices'." %
(len(sparse_feature_indices), _attr_num_sparse_features))
if not isinstance(sparse_indices, (list, tuple)):
raise TypeError("Expected list for 'sparse_indices' argument to "
"'sdca_optimizer' Op, not %r." % sparse_indices)
if len(sparse_indices) != _attr_num_sparse_features:
raise ValueError(
"List argument 'sparse_indices' to 'sdca_optimizer' Op with length %d "
"must match length %d of argument 'sparse_example_indices'." %
(len(sparse_indices), _attr_num_sparse_features))
if not isinstance(sparse_weights, (list, tuple)):
raise TypeError("Expected list for 'sparse_weights' argument to "
"'sdca_optimizer' Op, not %r." % sparse_weights)
if len(sparse_weights) != _attr_num_sparse_features:
raise ValueError(
"List argument 'sparse_weights' to 'sdca_optimizer' Op with length %d "
"must match length %d of argument 'sparse_example_indices'." %
(len(sparse_weights), _attr_num_sparse_features))
if not isinstance(sparse_feature_values, (list, tuple)):
raise TypeError(
"Expected list for 'sparse_feature_values' argument to "
"'sdca_optimizer' Op, not %r." % sparse_feature_values)
_attr_num_sparse_features_with_values = len(sparse_feature_values)
if not isinstance(dense_features, (list, tuple)):
raise TypeError("Expected list for 'dense_features' argument to "
"'sdca_optimizer' Op, not %r." % dense_features)
_attr_num_dense_features = len(dense_features)
if not isinstance(dense_weights, (list, tuple)):
raise TypeError("Expected list for 'dense_weights' argument to "
"'sdca_optimizer' Op, not %r." % dense_weights)
if len(dense_weights) != _attr_num_dense_features:
raise ValueError(
"List argument 'dense_weights' to 'sdca_optimizer' Op with length %d "
"must match length %d of argument 'dense_features'." %
(len(dense_weights), _attr_num_dense_features))
loss_type = _execute.make_str(loss_type, "loss_type")
l1 = _execute.make_float(l1, "l1")
l2 = _execute.make_float(l2, "l2")
num_loss_partitions = _execute.make_int(num_loss_partitions,
"num_loss_partitions")
num_inner_iterations = _execute.make_int(num_inner_iterations,
"num_inner_iterations")
if adaptative is None:
adaptative = True
adaptative = _execute.make_bool(adaptative, "adaptative")
_, _, _op = _op_def_lib._apply_op_helper(
"SdcaOptimizer",
sparse_example_indices=sparse_example_indices,
sparse_feature_indices=sparse_feature_indices,
sparse_feature_values=sparse_feature_values,
dense_features=dense_features,
example_weights=example_weights,
example_labels=example_labels,
sparse_indices=sparse_indices,
sparse_weights=sparse_weights,
dense_weights=dense_weights,
example_state_data=example_state_data,
loss_type=loss_type,
l1=l1,
l2=l2,
num_loss_partitions=num_loss_partitions,
num_inner_iterations=num_inner_iterations,
adaptative=adaptative,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("loss_type", _op.get_attr("loss_type"), "adaptative",
_op.get_attr("adaptative"), "num_sparse_features",
_op.get_attr("num_sparse_features"),
"num_sparse_features_with_values",
_op.get_attr("num_sparse_features_with_values"),
"num_dense_features", _op.get_attr("num_dense_features"),
"l1", _op.get_attr("l1"), "l2",
_op.get_attr("l2"), "num_loss_partitions",
_op.get_attr("num_loss_partitions"), "num_inner_iterations",
_op.get_attr("num_inner_iterations"))
_execute.record_gradient("SdcaOptimizer", _inputs_flat, _attrs,
_result, name)
_result = _result[:1] + [_result[1:1 + _attr_num_sparse_features]
] + _result[1 + _attr_num_sparse_features:]
_result = _result[:2] + [_result[2:]]
_result = _SdcaOptimizerOutput._make(_result)
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name,
"SdcaOptimizer", name, _ctx._post_execution_callbacks,
sparse_example_indices, sparse_feature_indices,
sparse_feature_values, dense_features, example_weights,
example_labels, sparse_indices, sparse_weights, dense_weights,
example_state_data, "loss_type", loss_type, "adaptative",
adaptative, "l1", l1, "l2", l2, "num_loss_partitions",
num_loss_partitions, "num_inner_iterations",
num_inner_iterations)
_result = _SdcaOptimizerOutput._make(_result)
return _result
except _core._FallbackException:
return sdca_optimizer_eager_fallback(
sparse_example_indices,
sparse_feature_indices,
sparse_feature_values,
dense_features,
example_weights,
example_labels,
sparse_indices,
sparse_weights,
dense_weights,
example_state_data,
loss_type=loss_type,
adaptative=adaptative,
l1=l1,
l2=l2,
num_loss_partitions=num_loss_partitions,
num_inner_iterations=num_inner_iterations,
name=name,
ctx=_ctx)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def _fixed_unigram_candidate_sampler(true_classes,
num_true,
num_sampled,
unique,
range_max,
vocab_file="",
distortion=1,
num_reserved_ids=0,
num_shards=1,
shard=0,
unigrams=[],
seed=0,
seed2=0,
name=None):
r"""Generates labels for candidate sampling with a learned unigram distribution.
A unigram sampler could use a fixed unigram distribution read from a
file or passed in as an in-memory array instead of building up the distribution
from data on the fly. There is also an option to skew the distribution by
applying a distortion power to the weights.
The vocabulary file should be in CSV-like format, with the last field
being the weight associated with the word.
For each batch, this op picks a single set of sampled candidate labels.
The advantages of sampling candidates per-batch are simplicity and the
possibility of efficient dense matrix multiplication. The disadvantage is that
the sampled candidates must be chosen independently of the context and of the
true labels.
Args:
true_classes: A `Tensor` of type `int64`.
A batch_size * num_true matrix, in which each row contains the
IDs of the num_true target_classes in the corresponding original label.
num_true: An `int` that is `>= 1`. Number of true labels per context.
num_sampled: An `int` that is `>= 1`.
Number of candidates to randomly sample.
unique: A `bool`.
If unique is true, we sample with rejection, so that all sampled
candidates in a batch are unique. This requires some approximation to
estimate the post-rejection sampling probabilities.
range_max: An `int` that is `>= 1`.
The sampler will sample integers from the interval [0, range_max).
vocab_file: An optional `string`. Defaults to `""`.
Each valid line in this file (which should have a CSV-like format)
corresponds to a valid word ID. IDs are in sequential order, starting from
num_reserved_ids. The last entry in each line is expected to be a value
corresponding to the count or relative probability. Exactly one of vocab_file
and unigrams needs to be passed to this op.
distortion: An optional `float`. Defaults to `1`.
The distortion is used to skew the unigram probability distribution.
Each weight is first raised to the distortion's power before adding to the
internal unigram distribution. As a result, distortion = 1.0 gives regular
unigram sampling (as defined by the vocab file), and distortion = 0.0 gives
a uniform distribution.
num_reserved_ids: An optional `int`. Defaults to `0`.
Optionally some reserved IDs can be added in the range [0,
..., num_reserved_ids) by the users. One use case is that a special unknown
word token is used as ID 0. These IDs will have a sampling probability of 0.
num_shards: An optional `int` that is `>= 1`. Defaults to `1`.
A sampler can be used to sample from a subset of the original range
in order to speed up the whole computation through parallelism. This parameter
(together with 'shard') indicates the number of partitions that are being
used in the overall computation.
shard: An optional `int` that is `>= 0`. Defaults to `0`.
A sampler can be used to sample from a subset of the original range
in order to speed up the whole computation through parallelism. This parameter
(together with 'num_shards') indicates the particular partition number of a
sampler op, when partitioning is being used.
unigrams: An optional list of `floats`. Defaults to `[]`.
A list of unigram counts or probabilities, one per ID in sequential
order. Exactly one of vocab_file and unigrams should be passed to this op.
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 (sampled_candidates, true_expected_count, sampled_expected_count).
sampled_candidates: A `Tensor` of type `int64`. A vector of length num_sampled, in which each element is
the ID of a sampled candidate.
true_expected_count: A `Tensor` of type `float32`. A batch_size * num_true matrix, representing
the number of times each candidate is expected to occur in a batch
of sampled candidates. If unique=true, then this is a probability.
sampled_expected_count: A `Tensor` of type `float32`. A vector of length num_sampled, for each sampled
candidate representing the number of times the candidate is expected
to occur in a batch of sampled candidates. If unique=true, then this is a
probability.
"""
num_true = _execute.make_int(num_true, "num_true")
num_sampled = _execute.make_int(num_sampled, "num_sampled")
unique = _execute.make_bool(unique, "unique")
range_max = _execute.make_int(range_max, "range_max")
if vocab_file is None:
vocab_file = ""
vocab_file = _execute.make_str(vocab_file, "vocab_file")
if distortion is None:
distortion = 1
distortion = _execute.make_float(distortion, "distortion")
if num_reserved_ids is None:
num_reserved_ids = 0
num_reserved_ids = _execute.make_int(num_reserved_ids, "num_reserved_ids")
if num_shards is None:
num_shards = 1
num_shards = _execute.make_int(num_shards, "num_shards")
if shard is None:
shard = 0
shard = _execute.make_int(shard, "shard")
if unigrams is None:
unigrams = []
if not isinstance(unigrams, (list, tuple)):
raise TypeError("Expected list for 'unigrams' argument to "
"'fixed_unigram_candidate_sampler' Op, not %r." %
unigrams)
unigrams = [_execute.make_float(_f, "unigrams") for _f in unigrams]
if seed is None:
seed = 0
seed = _execute.make_int(seed, "seed")
if seed2 is None:
seed2 = 0
seed2 = _execute.make_int(seed2, "seed2")
_ctx = _context.context()
if _ctx.in_graph_mode():
_, _, _op = _op_def_lib._apply_op_helper(
"FixedUnigramCandidateSampler",
true_classes=true_classes,
num_true=num_true,
num_sampled=num_sampled,
unique=unique,
range_max=range_max,
vocab_file=vocab_file,
distortion=distortion,
num_reserved_ids=num_reserved_ids,
num_shards=num_shards,
shard=shard,
unigrams=unigrams,
seed=seed,
seed2=seed2,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("num_true", _op.get_attr("num_true"), "num_sampled",
_op.get_attr("num_sampled"),
"unique", _op.get_attr("unique"), "range_max",
_op.get_attr("range_max"), "vocab_file",
_op.get_attr("vocab_file"), "distortion",
_op.get_attr("distortion"), "num_reserved_ids",
_op.get_attr("num_reserved_ids"), "num_shards",
_op.get_attr("num_shards"), "shard", _op.get_attr("shard"),
"unigrams", _op.get_attr("unigrams"), "seed",
_op.get_attr("seed"), "seed2", _op.get_attr("seed2"))
else:
true_classes = _ops.convert_to_tensor(true_classes, _dtypes.int64)
_inputs_flat = [true_classes]
_attrs = ("num_true", num_true, "num_sampled", num_sampled, "unique",
unique, "range_max", range_max, "vocab_file", vocab_file,
"distortion", distortion, "num_reserved_ids",
num_reserved_ids, "num_shards", num_shards, "shard", shard,
"unigrams", unigrams, "seed", seed, "seed2", seed2)
_result = _execute.execute(b"FixedUnigramCandidateSampler",
3,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("FixedUnigramCandidateSampler", _inputs_flat,
_attrs, _result, name)
_result = _FixedUnigramCandidateSamplerOutput._make(_result)
return _result
def single_image_random_dot_stereograms(depth_values, hidden_surface_removal=True, convergence_dots_size=8, dots_per_inch=72, eye_separation=2.5, mu=0.3333, normalize=True, normalize_max=-100, normalize_min=100, border_level=0, number_colors=256, output_image_shape=[1024, 768, 1], output_data_window=[1022, 757], name=None):
r"""Outputs a single image random dot stereogram for export via encode_PNG/JPG OP.
Given the 2-D tensor 'depth_values' with encoded Z values, this operation will
encode 3-D data into a 2-D image. The output of this Op is suitable for the
encode_PNG/JPG ops. Be careful with image compression as this may corrupt the
encode 3-D data within the image.
This Op is based upon:
'http://www.learningace.com/doc/4331582/b6ab058d1e206d68ab60e4e1ead2fe6e/sirds-paper'
Example use which outputs a SIRDS image as picture_out.png:
```python
img=[[1,2,3,3,2,1],
[1,2,3,4,5,2],
[1,2,3,4,5,3],
[1,2,3,4,5,4],
[6,5,4,4,5,5]]
session = tf.InteractiveSession()
sirds = single_image_random_dot_stereograms(img,convergence_dots_size=8,number_colors=256,normalize=True)
out = sirds.eval()
png = tf.image.encode_png(out).eval()
with open('picture_out.png', 'wb') as f:
f.write(png)
```
Args:
depth_values: A `Tensor`. Must be one of the following types: `float64`, `float32`, `int64`, `int32`.
Z values of data to encode into 'output_data_window' window,
lower values are further away {0.0 floor(far), 1.0 ceiling(near) after normalization}, must be 2-D tensor
hidden_surface_removal: An optional `bool`. Defaults to `True`.
Activate hidden surface removal
convergence_dots_size: An optional `int`. Defaults to `8`.
Black dot size in pixels to help view converge image, drawn on bottom of image
dots_per_inch: An optional `int`. Defaults to `72`.
Output device in dots/inch
eye_separation: An optional `float`. Defaults to `2.5`.
Separation between eyes in inches
mu: An optional `float`. Defaults to `0.3333`.
Depth of field, Fraction of viewing distance (eg. 1/3 = .3333)
normalize: An optional `bool`. Defaults to `True`.
Normalize input data to [0.0, 1.0]
normalize_max: An optional `float`. Defaults to `-100`.
Fix MAX value for Normalization - if < MIN, autoscale
normalize_min: An optional `float`. Defaults to `100`.
Fix MIN value for Normalization - if > MAX, autoscale
border_level: An optional `float`. Defaults to `0`.
Value of border depth 0.0 {far} to 1.0 {near}
number_colors: An optional `int`. Defaults to `256`.
2 (Black & White),256 (grayscale), and Numbers > 256 (Full Color) are all that are supported currently
output_image_shape: An optional `tf.TensorShape` or list of `ints`. Defaults to `[1024, 768, 1]`.
Output size of returned image in X,Y, Channels 1-grayscale, 3 color (1024, 768, 1),
channels will be updated to 3 if 'number_colors' > 256
output_data_window: An optional `tf.TensorShape` or list of `ints`. Defaults to `[1022, 757]`.
Size of "DATA" window, must be equal to or smaller than 'output_image_shape', will be centered
and use 'convergence_dots_size' for best fit to avoid overlap if possible
name: A name for the operation (optional).
Returns:
A tensor of size 'output_image_shape' with the encoded 'depth_values'
"""
_ctx = _context._context
if _ctx is None or not _ctx._eager_context.is_eager:
if hidden_surface_removal is None:
hidden_surface_removal = True
hidden_surface_removal = _execute.make_bool(hidden_surface_removal, "hidden_surface_removal")
if convergence_dots_size is None:
convergence_dots_size = 8
convergence_dots_size = _execute.make_int(convergence_dots_size, "convergence_dots_size")
if dots_per_inch is None:
dots_per_inch = 72
dots_per_inch = _execute.make_int(dots_per_inch, "dots_per_inch")
if eye_separation is None:
eye_separation = 2.5
eye_separation = _execute.make_float(eye_separation, "eye_separation")
if mu is None:
mu = 0.3333
mu = _execute.make_float(mu, "mu")
if normalize is None:
normalize = True
normalize = _execute.make_bool(normalize, "normalize")
if normalize_max is None:
normalize_max = -100
normalize_max = _execute.make_float(normalize_max, "normalize_max")
if normalize_min is None:
normalize_min = 100
normalize_min = _execute.make_float(normalize_min, "normalize_min")
if border_level is None:
border_level = 0
border_level = _execute.make_float(border_level, "border_level")
if number_colors is None:
number_colors = 256
number_colors = _execute.make_int(number_colors, "number_colors")
if output_image_shape is None:
output_image_shape = [1024, 768, 1]
output_image_shape = _execute.make_shape(output_image_shape, "output_image_shape")
if output_data_window is None:
output_data_window = [1022, 757]
output_data_window = _execute.make_shape(output_data_window, "output_data_window")
_, _, _op = _op_def_lib._apply_op_helper(
"SingleImageRandomDotStereograms", depth_values=depth_values,
hidden_surface_removal=hidden_surface_removal,
convergence_dots_size=convergence_dots_size,
dots_per_inch=dots_per_inch, eye_separation=eye_separation, mu=mu,
normalize=normalize, normalize_max=normalize_max,
normalize_min=normalize_min, border_level=border_level,
number_colors=number_colors, output_image_shape=output_image_shape,
output_data_window=output_data_window, name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("T", _op.get_attr("T"), "hidden_surface_removal",
_op.get_attr("hidden_surface_removal"), "convergence_dots_size",
_op.get_attr("convergence_dots_size"), "dots_per_inch",
_op.get_attr("dots_per_inch"), "eye_separation",
_op.get_attr("eye_separation"), "mu", _op.get_attr("mu"),
"normalize", _op.get_attr("normalize"), "normalize_max",
_op.get_attr("normalize_max"), "normalize_min",
_op.get_attr("normalize_min"), "border_level",
_op.get_attr("border_level"), "number_colors",
_op.get_attr("number_colors"), "output_image_shape",
_op.get_attr("output_image_shape"), "output_data_window",
_op.get_attr("output_data_window"))
_execute.record_gradient(
"SingleImageRandomDotStereograms", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name,
"SingleImageRandomDotStereograms", name,
_ctx._post_execution_callbacks, depth_values,
"hidden_surface_removal", hidden_surface_removal,
"convergence_dots_size", convergence_dots_size, "dots_per_inch",
dots_per_inch, "eye_separation", eye_separation, "mu", mu,
"normalize", normalize, "normalize_max", normalize_max,
"normalize_min", normalize_min, "border_level", border_level,
"number_colors", number_colors, "output_image_shape",
output_image_shape, "output_data_window", output_data_window)
return _result
except _core._FallbackException:
return single_image_random_dot_stereograms_eager_fallback(
depth_values, hidden_surface_removal=hidden_surface_removal,
convergence_dots_size=convergence_dots_size,
dots_per_inch=dots_per_inch, eye_separation=eye_separation, mu=mu,
normalize=normalize, normalize_max=normalize_max,
normalize_min=normalize_min, border_level=border_level,
number_colors=number_colors, output_image_shape=output_image_shape,
output_data_window=output_data_window, name=name, ctx=_ctx)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def _uniform_candidate_sampler(true_classes,
num_true,
num_sampled,
unique,
range_max,
seed=0,
seed2=0,
name=None):
r"""Generates labels for candidate sampling with a uniform distribution.
See explanations of candidate sampling and the data formats at
go/candidate-sampling.
For each batch, this op picks a single set of sampled candidate labels.
The advantages of sampling candidates per-batch are simplicity and the
possibility of efficient dense matrix multiplication. The disadvantage is that
the sampled candidates must be chosen independently of the context and of the
true labels.
Args:
true_classes: A `Tensor` of type `int64`.
A batch_size * num_true matrix, in which each row contains the
IDs of the num_true target_classes in the corresponding original label.
num_true: An `int` that is `>= 1`. Number of true labels per context.
num_sampled: An `int` that is `>= 1`.
Number of candidates to randomly sample.
unique: A `bool`.
If unique is true, we sample with rejection, so that all sampled
candidates in a batch are unique. This requires some approximation to
estimate the post-rejection sampling probabilities.
range_max: An `int` that is `>= 1`.
The sampler will sample integers from the interval [0, range_max).
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 (sampled_candidates, true_expected_count, sampled_expected_count).
sampled_candidates: A `Tensor` of type `int64`. A vector of length num_sampled, in which each element is
the ID of a sampled candidate.
true_expected_count: A `Tensor` of type `float32`. A batch_size * num_true matrix, representing
the number of times each candidate is expected to occur in a batch
of sampled candidates. If unique=true, then this is a probability.
sampled_expected_count: A `Tensor` of type `float32`. A vector of length num_sampled, for each sampled
candidate representing the number of times the candidate is expected
to occur in a batch of sampled candidates. If unique=true, then this is a
probability.
"""
num_true = _execute.make_int(num_true, "num_true")
num_sampled = _execute.make_int(num_sampled, "num_sampled")
unique = _execute.make_bool(unique, "unique")
range_max = _execute.make_int(range_max, "range_max")
if seed is None:
seed = 0
seed = _execute.make_int(seed, "seed")
if seed2 is None:
seed2 = 0
seed2 = _execute.make_int(seed2, "seed2")
_ctx = _context.context()
if _ctx.in_graph_mode():
_, _, _op = _op_def_lib._apply_op_helper("UniformCandidateSampler",
true_classes=true_classes,
num_true=num_true,
num_sampled=num_sampled,
unique=unique,
range_max=range_max,
seed=seed,
seed2=seed2,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("num_true", _op.get_attr("num_true"), "num_sampled",
_op.get_attr("num_sampled"),
"unique", _op.get_attr("unique"), "range_max",
_op.get_attr("range_max"), "seed", _op.get_attr("seed"),
"seed2", _op.get_attr("seed2"))
else:
true_classes = _ops.convert_to_tensor(true_classes, _dtypes.int64)
_inputs_flat = [true_classes]
_attrs = ("num_true", num_true, "num_sampled", num_sampled, "unique",
unique, "range_max", range_max, "seed", seed, "seed2", seed2)
_result = _execute.execute(b"UniformCandidateSampler",
3,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("UniformCandidateSampler", _inputs_flat, _attrs,
_result, name)
_result = _UniformCandidateSamplerOutput._make(_result)
return _result
def load_and_remap_matrix(ckpt_path,
old_tensor_name,
row_remapping,
col_remapping,
initializing_values,
num_rows,
num_cols,
max_rows_in_memory=-1,
name=None):
r"""Loads a 2-D (matrix) `Tensor` with name `old_tensor_name` from the checkpoint
at `ckpt_path` and potentially reorders its rows and columns using the
specified remappings.
Most users should use one of the wrapper initializers (such as
`tf.contrib.framework.load_and_remap_matrix_initializer`) instead of this
function directly.
The remappings are 1-D tensors with the following properties:
* `row_remapping` must have exactly `num_rows` entries. Row `i` of the output
matrix will be initialized from the row corresponding to index
`row_remapping[i]` in the old `Tensor` from the checkpoint.
* `col_remapping` must have either 0 entries (indicating that no column
reordering is needed) or `num_cols` entries. If specified, column `j` of the
output matrix will be initialized from the column corresponding to index
`col_remapping[j]` in the old `Tensor` from the checkpoint.
* A value of -1 in either of the remappings signifies a "missing" entry. In that
case, values from the `initializing_values` tensor will be used to fill that
missing row or column. If `row_remapping` has `r` missing entries and
`col_remapping` has `c` missing entries, then the following condition must be
true:
`(r * num_cols) + (c * num_rows) - (r * c) == len(initializing_values)`
The remapping tensors can be generated using the GenerateVocabRemapping op.
As an example, with row_remapping = [1, 0, -1], col_remapping = [0, 2, -1],
initializing_values = [0.5, -0.5, 0.25, -0.25, 42], and w(i, j) representing
the value from row i, column j of the old tensor in the checkpoint, the output
matrix will look like the following:
[[w(1, 0), w(1, 2), 0.5],
[w(0, 0), w(0, 2), -0.5],
[0.25, -0.25, 42]]
Args:
ckpt_path: A `Tensor` of type `string`.
Path to the TensorFlow checkpoint (version 2, `TensorBundle`) from
which the old matrix `Tensor` will be loaded.
old_tensor_name: A `Tensor` of type `string`.
Name of the 2-D `Tensor` to load from checkpoint.
row_remapping: A `Tensor` of type `int64`.
An int `Tensor` of row remappings (generally created by
`generate_vocab_remapping`). Even if no row remapping is needed, this must
still be an index-valued Tensor (e.g. [0, 1, 2, ...]), or a shifted
index-valued `Tensor` (e.g. [8, 9, 10, ...], for partitioned `Variables`).
col_remapping: A `Tensor` of type `int64`.
An int `Tensor` of column remappings (generally created by
`generate_vocab_remapping`). May be a size-0 `Tensor` if only row remapping
is to be done (e.g. column ordering is the same).
initializing_values: A `Tensor` of type `float32`.
A float `Tensor` containing values to fill in for cells
in the output matrix that are not loaded from the checkpoint. Length must be
exactly the same as the number of missing / new cells.
num_rows: An `int` that is `>= 0`.
Number of rows (length of the 1st dimension) in the output matrix.
num_cols: An `int` that is `>= 1`.
Number of columns (length of the 2nd dimension) in the output matrix.
max_rows_in_memory: An optional `int`. Defaults to `-1`.
The maximum number of rows to load from the checkpoint at
once. If less than or equal to 0, the entire matrix will be loaded into
memory. Setting this arg trades increased disk reads for lower memory usage.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `float32`.
"""
_ctx = _context._context
if _ctx is None or not _ctx._eager_context.is_eager:
num_rows = _execute.make_int(num_rows, "num_rows")
num_cols = _execute.make_int(num_cols, "num_cols")
if max_rows_in_memory is None:
max_rows_in_memory = -1
max_rows_in_memory = _execute.make_int(max_rows_in_memory,
"max_rows_in_memory")
_, _, _op = _op_def_lib._apply_op_helper(
"LoadAndRemapMatrix",
ckpt_path=ckpt_path,
old_tensor_name=old_tensor_name,
row_remapping=row_remapping,
col_remapping=col_remapping,
initializing_values=initializing_values,
num_rows=num_rows,
num_cols=num_cols,
max_rows_in_memory=max_rows_in_memory,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("num_rows", _op.get_attr("num_rows"), "num_cols",
_op.get_attr("num_cols"), "max_rows_in_memory",
_op.get_attr("max_rows_in_memory"))
_execute.record_gradient("LoadAndRemapMatrix", _inputs_flat, _attrs,
_result, name)
_result, = _result
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name,
"LoadAndRemapMatrix", name, _ctx._post_execution_callbacks,
ckpt_path, old_tensor_name, row_remapping, col_remapping,
initializing_values, "num_rows", num_rows, "num_cols",
num_cols, "max_rows_in_memory", max_rows_in_memory)
return _result
except _core._FallbackException:
return load_and_remap_matrix_eager_fallback(
ckpt_path,
old_tensor_name,
row_remapping,
col_remapping,
initializing_values,
num_rows=num_rows,
num_cols=num_cols,
max_rows_in_memory=max_rows_in_memory,
name=name,
ctx=_ctx)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def write_image_summary(writer,
step,
tag,
tensor,
bad_color,
max_images=3,
name=None):
r"""TODO: add doc.
Args:
writer: A `Tensor` of type `resource`.
step: A `Tensor` of type `int64`.
tag: A `Tensor` of type `string`.
tensor: A `Tensor`. Must be one of the following types: `uint8`, `float32`, `half`.
bad_color: A `Tensor` of type `uint8`.
max_images: An optional `int` that is `>= 1`. Defaults to `3`.
name: A name for the operation (optional).
Returns:
The created Operation.
"""
_ctx = _context._context or _context.context()
if _ctx is not None and _ctx._thread_local_data.is_eager:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._thread_local_data.device_name,
"WriteImageSummary", name, _ctx._post_execution_callbacks,
writer, step, tag, tensor, bad_color, "max_images", max_images)
return _result
except _core._FallbackException:
try:
return write_image_summary_eager_fallback(
writer,
step,
tag,
tensor,
bad_color,
max_images=max_images,
name=name,
ctx=_ctx)
except _core._SymbolicException:
pass # Add nodes to the TensorFlow graph.
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
# Add nodes to the TensorFlow graph.
if max_images is None:
max_images = 3
max_images = _execute.make_int(max_images, "max_images")
_, _, _op = _op_def_lib._apply_op_helper("WriteImageSummary",
writer=writer,
step=step,
tag=tag,
tensor=tensor,
bad_color=bad_color,
max_images=max_images,
name=name)
return _op
_result = None
return _result
def decode_wav(contents, desired_channels=-1, desired_samples=-1, name=None):
r"""Decode a 16-bit PCM WAV file to a float tensor.
The -32768 to 32767 signed 16-bit values will be scaled to -1.0 to 1.0 in float.
When desired_channels is set, if the input contains fewer channels than this
then the last channel will be duplicated to give the requested number, else if
the input has more channels than requested then the additional channels will be
ignored.
If desired_samples is set, then the audio will be cropped or padded with zeroes
to the requested length.
The first output contains a Tensor with the content of the audio samples. The
lowest dimension will be the number of channels, and the second will be the
number of samples. For example, a ten-sample-long stereo WAV file should give an
output shape of [10, 2].
Args:
contents: A `Tensor` of type `string`.
The WAV-encoded audio, usually from a file.
desired_channels: An optional `int`. Defaults to `-1`.
Number of sample channels wanted.
desired_samples: An optional `int`. Defaults to `-1`.
Length of audio requested.
name: A name for the operation (optional).
Returns:
A tuple of `Tensor` objects (audio, sample_rate).
audio: A `Tensor` of type `float32`.
sample_rate: 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._context_handle, tld.device_name, "DecodeWav", name,
tld.op_callbacks, contents, "desired_channels",
desired_channels, "desired_samples", desired_samples)
_result = _DecodeWavOutput._make(_result)
return _result
except _core._NotOkStatusException as e:
_ops.raise_from_not_ok_status(e, name)
except _core._FallbackException:
pass
try:
return decode_wav_eager_fallback(contents,
desired_channels=desired_channels,
desired_samples=desired_samples,
name=name,
ctx=_ctx)
except _core._SymbolicException:
pass # Add nodes to the TensorFlow graph.
except (TypeError, ValueError):
result = _dispatch.dispatch(
decode_wav, (),
dict(contents=contents,
desired_channels=desired_channels,
desired_samples=desired_samples,
name=name))
if result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
return result
raise
# Add nodes to the TensorFlow graph.
if desired_channels is None:
desired_channels = -1
desired_channels = _execute.make_int(desired_channels, "desired_channels")
if desired_samples is None:
desired_samples = -1
desired_samples = _execute.make_int(desired_samples, "desired_samples")
try:
_, _, _op, _outputs = _op_def_library._apply_op_helper(
"DecodeWav",
contents=contents,
desired_channels=desired_channels,
desired_samples=desired_samples,
name=name)
except (TypeError, ValueError):
result = _dispatch.dispatch(
decode_wav, (),
dict(contents=contents,
desired_channels=desired_channels,
desired_samples=desired_samples,
name=name))
if result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
return result
raise
_result = _outputs[:]
if _execute.must_record_gradient():
_attrs = ("desired_channels", _op._get_attr_int("desired_channels"),
"desired_samples", _op._get_attr_int("desired_samples"))
_inputs_flat = _op.inputs
_execute.record_gradient("DecodeWav", _inputs_flat, _attrs, _result)
_result = _DecodeWavOutput._make(_result)
return _result
def try_rpc(address,
method,
request,
protocol="",
fail_fast=True,
timeout_in_ms=0,
name=None):
r"""TODO: add doc.
Args:
address: A `Tensor` of type `string`.
method: A `Tensor` of type `string`.
request: A `Tensor` of type `string`.
protocol: An optional `string`. Defaults to `""`.
fail_fast: An optional `bool`. Defaults to `True`.
timeout_in_ms: An optional `int`. Defaults to `0`.
name: A name for the operation (optional).
Returns:
A tuple of `Tensor` objects (response, status_code, status_message).
response: A `Tensor` of type `string`.
status_code: A `Tensor` of type `int32`.
status_message: A `Tensor` of type `string`.
"""
_ctx = _context._context
if _ctx is None or not _ctx._eager_context.is_eager:
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")
_, _, _op = _op_def_lib._apply_op_helper("TryRpc",
address=address,
method=method,
request=request,
protocol=protocol,
fail_fast=fail_fast,
timeout_in_ms=timeout_in_ms,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("protocol", _op.get_attr("protocol"), "fail_fast",
_op.get_attr("fail_fast"), "timeout_in_ms",
_op.get_attr("timeout_in_ms"))
_execute.record_gradient("TryRpc", _inputs_flat, _attrs, _result, name)
_result = _TryRpcOutput._make(_result)
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name,
"TryRpc", name, _ctx._post_execution_callbacks, address,
method, request, "protocol", protocol, "fail_fast", fail_fast,
"timeout_in_ms", timeout_in_ms)
_result = _TryRpcOutput._make(_result)
return _result
except _core._FallbackException:
return try_rpc_eager_fallback(address,
method,
request,
protocol=protocol,
fail_fast=fail_fast,
timeout_in_ms=timeout_in_ms,
name=name,
ctx=_ctx)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def process_input_v4(tree_handle, stats_handle, input_data, sparse_input_indices, sparse_input_values, sparse_input_shape, input_labels, input_weights, leaf_ids, random_seed, input_spec, params, name=None):
r"""Add labels to stats after traversing the tree for each example.
Outputs node ids that are finished.
Args:
tree_handle: A `Tensor` of type `resource`. The handle to the tree.
stats_handle: A `Tensor` of type `resource`. The handle to the stats.
input_data: A `Tensor` of type `float32`.
The training batch's features as a 2-d tensor; `input_data[i][j]`
gives the j-th feature of the i-th input.
sparse_input_indices: A `Tensor` of type `int64`.
The indices tensor from the SparseTensor input.
sparse_input_values: A `Tensor` of type `float32`.
The values tensor from the SparseTensor input.
sparse_input_shape: A `Tensor` of type `int64`.
The shape tensor from the SparseTensor input.
input_labels: A `Tensor` of type `float32`.
The training batch's labels as a 1 or 2-d tensor.
'input_labels[i][j]' gives the j-th label/target for the i-th input.
input_weights: A `Tensor` of type `float32`.
The training batch's eample weights as a 1-d tensor.
'input_weights[i]' gives the weight for the i-th input.
leaf_ids: A `Tensor` of type `int32`.
`leaf_ids[i]` is the leaf id for input i.
random_seed: An `int`.
input_spec: A `string`.
params: A `string`. A serialized TensorForestParams proto.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `int32`.
A 1-d tensor of node ids that have finished and are ready to
grow.
"""
random_seed = _execute.make_int(random_seed, "random_seed")
input_spec = _execute.make_str(input_spec, "input_spec")
params = _execute.make_str(params, "params")
_ctx = _context.context()
if _ctx.in_graph_mode():
_, _, _op = _op_def_lib._apply_op_helper(
"ProcessInputV4", tree_handle=tree_handle, stats_handle=stats_handle,
input_data=input_data, sparse_input_indices=sparse_input_indices,
sparse_input_values=sparse_input_values,
sparse_input_shape=sparse_input_shape, input_labels=input_labels,
input_weights=input_weights, leaf_ids=leaf_ids,
random_seed=random_seed, input_spec=input_spec, params=params,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("random_seed", _op.get_attr("random_seed"), "input_spec",
_op.get_attr("input_spec"), "params", _op.get_attr("params"))
else:
tree_handle = _ops.convert_to_tensor(tree_handle, _dtypes.resource)
stats_handle = _ops.convert_to_tensor(stats_handle, _dtypes.resource)
input_data = _ops.convert_to_tensor(input_data, _dtypes.float32)
sparse_input_indices = _ops.convert_to_tensor(sparse_input_indices, _dtypes.int64)
sparse_input_values = _ops.convert_to_tensor(sparse_input_values, _dtypes.float32)
sparse_input_shape = _ops.convert_to_tensor(sparse_input_shape, _dtypes.int64)
input_labels = _ops.convert_to_tensor(input_labels, _dtypes.float32)
input_weights = _ops.convert_to_tensor(input_weights, _dtypes.float32)
leaf_ids = _ops.convert_to_tensor(leaf_ids, _dtypes.int32)
_inputs_flat = [tree_handle, stats_handle, input_data, sparse_input_indices, sparse_input_values, sparse_input_shape, input_labels, input_weights, leaf_ids]
_attrs = ("random_seed", random_seed, "input_spec", input_spec, "params",
params)
_result = _execute.execute(b"ProcessInputV4", 1, inputs=_inputs_flat,
attrs=_attrs, ctx=_ctx, name=name)
_execute.record_gradient(
"ProcessInputV4", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
def nccl_all_reduce(input, reduction, num_devices, shared_name, name=None):
r"""Outputs a tensor containing the reduction across all input tensors.
Outputs a tensor containing the reduction across all input tensors passed to ops
within the same `shared_name.
The graph should be constructed so if one op runs with shared_name value `c`,
then `num_devices` ops will run with shared_name value `c`. Failure to do so
will cause the graph execution to fail to complete.
input: the input to the reduction
data: the value of the reduction across all `num_devices` devices.
reduction: the reduction operation to perform.
num_devices: The number of devices participating in this reduction.
shared_name: Identifier that shared between ops of the same reduction.
Args:
input: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`.
reduction: A `string` from: `"min", "max", "prod", "sum"`.
num_devices: An `int`.
shared_name: A `string`.
name: A name for the operation (optional).
Returns:
A `Tensor`. Has the same type as `input`.
"""
_ctx = _context._context or _context.context()
if _ctx is not None and _ctx._thread_local_data.is_eager:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._thread_local_data.device_name,
"NcclAllReduce", name, _ctx.post_execution_callbacks, input,
"reduction", reduction, "num_devices", num_devices,
"shared_name", shared_name)
return _result
except _core._FallbackException:
try:
return nccl_all_reduce_eager_fallback(input,
reduction=reduction,
num_devices=num_devices,
shared_name=shared_name,
name=name,
ctx=_ctx)
except _core._SymbolicException:
pass # Add nodes to the TensorFlow graph.
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
# Add nodes to the TensorFlow graph.
reduction = _execute.make_str(reduction, "reduction")
num_devices = _execute.make_int(num_devices, "num_devices")
shared_name = _execute.make_str(shared_name, "shared_name")
_, _, _op = _op_def_lib._apply_op_helper("NcclAllReduce",
input=input,
reduction=reduction,
num_devices=num_devices,
shared_name=shared_name,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("reduction", _op.get_attr("reduction"), "T",
_op._get_attr_type("T"), "num_devices",
_op.get_attr("num_devices"), "shared_name",
_op.get_attr("shared_name"))
_execute.record_gradient("NcclAllReduce", _inputs_flat, _attrs, _result,
name)
_result, = _result
return _result
def audio_spectrogram(input,
window_size,
stride,
magnitude_squared=False,
name=None):
r"""Produces a visualization of audio data over time.
Spectrograms are a standard way of representing audio information as a series of
slices of frequency information, one slice for each window of time. By joining
these together into a sequence, they form a distinctive fingerprint of the sound
over time.
This op expects to receive audio data as an input, stored as floats in the range
-1 to 1, together with a window width in samples, and a stride specifying how
far to move the window between slices. From this it generates a three
dimensional output. The lowest dimension has an amplitude value for each
frequency during that time slice. The next dimension is time, with successive
frequency slices. The final dimension is for the channels in the input, so a
stereo audio input would have two here for example.
This means the layout when converted and saved as an image is rotated 90 degrees
clockwise from a typical spectrogram. Time is descending down the Y axis, and
the frequency decreases from left to right.
Each value in the result represents the square root of the sum of the real and
imaginary parts of an FFT on the current window of samples. In this way, the
lowest dimension represents the power of each frequency in the current window,
and adjacent windows are concatenated in the next dimension.
To get a more intuitive and visual look at what this operation does, you can run
tensorflow/examples/wav_to_spectrogram to read in an audio file and save out the
resulting spectrogram as a PNG image.
Args:
input: A `Tensor` of type `float32`. Float representation of audio data.
window_size: An `int`.
How wide the input window is in samples. For the highest efficiency
this should be a power of two, but other values are accepted.
stride: An `int`.
How widely apart the center of adjacent sample windows should be.
magnitude_squared: An optional `bool`. Defaults to `False`.
Whether to return the squared magnitude or just the
magnitude. Using squared magnitude can avoid extra calculations.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `float32`.
"""
_ctx = _context.context()
if not _ctx.executing_eagerly():
window_size = _execute.make_int(window_size, "window_size")
stride = _execute.make_int(stride, "stride")
if magnitude_squared is None:
magnitude_squared = False
magnitude_squared = _execute.make_bool(magnitude_squared,
"magnitude_squared")
_, _, _op = _op_def_lib._apply_op_helper(
"AudioSpectrogram",
input=input,
window_size=window_size,
stride=stride,
magnitude_squared=magnitude_squared,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("window_size", _op.get_attr("window_size"), "stride",
_op.get_attr("stride"), "magnitude_squared",
_op.get_attr("magnitude_squared"))
_execute.record_gradient("AudioSpectrogram", _inputs_flat, _attrs,
_result, name)
_result, = _result
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._handle, _ctx.device_name, "AudioSpectrogram", name,
_ctx._post_execution_callbacks, input, "window_size",
window_size, "stride", stride, "magnitude_squared",
magnitude_squared)
return _result
except _core._FallbackException:
return audio_spectrogram_eager_fallback(
input,
window_size=window_size,
stride=stride,
magnitude_squared=magnitude_squared,
name=name)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def range_encode(data, cdf, precision, name=None):
r"""Using the provided cumulative distribution functions (CDF) inside `cdf`, returns
a range-code of `data`.
The shape of `cdf` should have one more axis than the shape of `data`, and the
prefix `cdf.shape[:-1]` should be broadcastable to `data.shape`. That is, for
every `i = 0,...,rank(data) - 1`, the op requires that either
`cdf.shape[i] == 1` or `cdf.shape[i] == data.shape[i]`. Note that this
broadcasting is limited in the sense that the number of axes must match, and
broadcasts only `cdf` but not `data`.
`data` should have an upper bound `m > 0` such that each element is an integer
in range `[0, m)`. Then the last dimension size of `cdf` must be `m + 1`. For
each element of `data`, the innermost strip of `cdf` is a vector representing a
CDF. For each k = 0,...,m, `cdf[..., k] / 2^precision` is the probability that
an outcome is less than `k` (not less than or equal to).
```
cdf[..., 0] / 2^precision = Pr(data[...] < 0)
cdf[..., 1] / 2^precision = Pr(data[...] < 1) = Pr(data[...] <= 0)
cdf[..., 2] / 2^precision = Pr(data[...] < 2) = Pr(data[...] <= 1)
...
cdf[..., m] / 2^precision = Pr(data[...] < m) = 1
```
Therefore each element of `cdf` must be in `[0, 2^precision]`.
Ideally `cdf[..., m]` should equal to `2^precision` but this is not a hard
requirement as long as `cdf[..., m] <= 2^precision`.
The encoded string neither contains the shape information of the encoded data
nor a termination symbol. Therefore the shape of the encoded data must be
explicitly provided to the decoder.
Implementation notes:
- Because of potential performance issues, the op does not check whether
elements of `data` is in the correct range `[0, m)`, or if `cdf` satisfies
monotonic increase property.
- For the range coder to decode the encoded string correctly, the decoder should
be able to reproduce the internal states of the encoder precisely. Otherwise,
the decoding would fail and once an error occur, all subsequent decoded values
are incorrect. For this reason, the range coder uses integer arithmetics and
avoids using any floating point operations internally, and `cdf` should contain
integers representing quantized probability mass rather than floating points.
Args:
data: A `Tensor` of type `int16`. An int16 tensor.
cdf: A `Tensor` of type `int32`.
An int32 tensor representing the CDF's of `data`. Each integer is divided
by `2^precision` to represent a fraction.
precision: An `int` that is `>= 1`.
The number of bits for probability quantization. Must be <= 16.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `string`. A range-coded scalar string.
"""
_ctx = _context._context
if _ctx is None or not _ctx._eager_context.is_eager:
precision = _execute.make_int(precision, "precision")
_, _, _op = _op_def_lib._apply_op_helper(
"RangeEncode", data=data, cdf=cdf, precision=precision, name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("precision", _op.get_attr("precision"))
_execute.record_gradient(
"RangeEncode", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name, "RangeEncode",
name, _ctx._post_execution_callbacks, data, cdf, "precision",
precision)
return _result
except _core._FallbackException:
return range_encode_eager_fallback(
data, cdf, precision=precision, name=name, ctx=_ctx)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def collective_bcast_send(input,
group_size,
group_key,
instance_key,
shape,
name=None):
r"""Broadcasts a tensor value to one or more other devices.
Args:
input: A `Tensor`. Must be one of the following types: `float32`, `half`, `float64`, `int32`, `int64`.
group_size: An `int`.
group_key: An `int`.
instance_key: An `int`.
shape: A `tf.TensorShape` or list of `ints`.
name: A name for the operation (optional).
Returns:
A `Tensor`. Has the same type as `input`.
"""
_ctx = _context._context
if _ctx is not None and _ctx._eager_context.is_eager:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name,
"CollectiveBcastSend", name, _ctx._post_execution_callbacks,
input, "group_size", group_size, "group_key", group_key,
"instance_key", instance_key, "shape", shape)
return _result
except _core._FallbackException:
try:
return collective_bcast_send_eager_fallback(
input,
group_size=group_size,
group_key=group_key,
instance_key=instance_key,
shape=shape,
name=name,
ctx=_ctx)
except _core._SymbolicException:
pass # Add nodes to the TensorFlow graph.
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
# Add nodes to the TensorFlow graph.
group_size = _execute.make_int(group_size, "group_size")
group_key = _execute.make_int(group_key, "group_key")
instance_key = _execute.make_int(instance_key, "instance_key")
shape = _execute.make_shape(shape, "shape")
_, _, _op = _op_def_lib._apply_op_helper("CollectiveBcastSend",
input=input,
group_size=group_size,
group_key=group_key,
instance_key=instance_key,
shape=shape,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("T", _op.get_attr("T"), "group_size", _op.get_attr("group_size"),
"group_key", _op.get_attr("group_key"), "instance_key",
_op.get_attr("instance_key"), "shape", _op.get_attr("shape"))
_execute.record_gradient("CollectiveBcastSend", _inputs_flat, _attrs,
_result, name)
_result, = _result
return _result
def fused_conv2d_bias_activation_eager_fallback(conv_input,
filter,
bias,
side_input,
conv_input_scale,
side_input_scale,
strides,
padding,
data_format="NHWC",
filter_format="HWIO",
activation_mode="Relu",
dilations=[1, 1, 1, 1],
name=None,
ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function fused_conv2d_bias_activation
"""
_ctx = ctx if ctx else _context.context()
if not isinstance(strides, (list, tuple)):
raise TypeError("Expected list for 'strides' argument to "
"'fused_conv2d_bias_activation' 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")
if filter_format is None:
filter_format = "HWIO"
filter_format = _execute.make_str(filter_format, "filter_format")
if activation_mode is None:
activation_mode = "Relu"
activation_mode = _execute.make_str(activation_mode, "activation_mode")
if dilations is None:
dilations = [1, 1, 1, 1]
if not isinstance(dilations, (list, tuple)):
raise TypeError("Expected list for 'dilations' argument to "
"'fused_conv2d_bias_activation' Op, not %r." %
dilations)
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
_attr_T, _inputs_T = _execute.args_to_matching_eager(
[conv_input, filter, side_input], _ctx)
(conv_input, filter, side_input) = _inputs_T
_attr_Tbias, (bias, ) = _execute.args_to_matching_eager([bias], _ctx)
conv_input_scale = _ops.convert_to_tensor(conv_input_scale,
_dtypes.float32)
side_input_scale = _ops.convert_to_tensor(side_input_scale,
_dtypes.float32)
_inputs_flat = [
conv_input, filter, bias, side_input, conv_input_scale,
side_input_scale
]
_attrs = ("T", _attr_T, "Tbias", _attr_Tbias, "strides", strides,
"padding", padding, "data_format", data_format, "filter_format",
filter_format, "activation_mode", activation_mode, "dilations",
dilations)
_result = _execute.execute(b"FusedConv2DBiasActivation",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("FusedConv2DBiasActivation", _inputs_flat, _attrs,
_result, name)
_result, = _result
return _result
def collective_bcast_recv(T,
group_size,
group_key,
instance_key,
shape,
name=None):
r"""Receives a tensor value broadcast from another device.
Args:
T: A `tf.DType` from: `tf.float32, tf.half, tf.float64, tf.int32, tf.int64`.
group_size: An `int`.
group_key: An `int`.
instance_key: An `int`.
shape: A `tf.TensorShape` or list of `ints`.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `T`.
"""
_ctx = _context._context
if _ctx is not None and _ctx._eager_context.is_eager:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name,
"CollectiveBcastRecv", name, _ctx._post_execution_callbacks,
"T", T, "group_size", group_size, "group_key", group_key,
"instance_key", instance_key, "shape", shape)
return _result
except _core._FallbackException:
try:
return collective_bcast_recv_eager_fallback(
T=T,
group_size=group_size,
group_key=group_key,
instance_key=instance_key,
shape=shape,
name=name,
ctx=_ctx)
except _core._SymbolicException:
pass # Add nodes to the TensorFlow graph.
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
# Add nodes to the TensorFlow graph.
T = _execute.make_type(T, "T")
group_size = _execute.make_int(group_size, "group_size")
group_key = _execute.make_int(group_key, "group_key")
instance_key = _execute.make_int(instance_key, "instance_key")
shape = _execute.make_shape(shape, "shape")
_, _, _op = _op_def_lib._apply_op_helper("CollectiveBcastRecv",
T=T,
group_size=group_size,
group_key=group_key,
instance_key=instance_key,
shape=shape,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("T", _op.get_attr("T"), "group_size", _op.get_attr("group_size"),
"group_key", _op.get_attr("group_key"), "instance_key",
_op.get_attr("instance_key"), "shape", _op.get_attr("shape"))
_execute.record_gradient("CollectiveBcastRecv", _inputs_flat, _attrs,
_result, name)
_result, = _result
return _result
def fused_conv2d_bias_activation(conv_input,
filter,
bias,
side_input,
conv_input_scale,
side_input_scale,
strides,
padding,
data_format="NHWC",
filter_format="HWIO",
activation_mode="Relu",
dilations=[1, 1, 1, 1],
name=None):
r""" Computes a fused kernel which implements: 2-D convolution, adds side input,
with separate scaling on convolution and side inputs, then adds bias and
applies the RELU activation function to the result. Supports both float and
qint8 data formats. In the case of qint8, the output is clipped to [0..127].
conv_input: A tensor with format as specified by `data_format` (see below).
filter: A tensor with format depending on `data_format` as follows:
"NHWC", "NCHW":
`float [ filter_height, filter_width, in_channels, out_channels ]`
"NCHW_VECT_C":
`qint8 [ out_channels, in_channels, filter_height, filter_width ]`
bias: 1-D float tensor with size matching the `out_channels` dimension of
`filter`.
Note: this tensor is still float, even if other inputs are qint8.
side_input: A tensor with format as specified by `data_format` (see below).
This tensor will be ignored and can be [] if side_input_scale == 0.
Otherwise, the size of each dimension must match the `output` tensor.
conv_input_scale: scalar float value to be multiplied by `conv_input`.
(conceptually.. in reality it is applied after convolution).
side_input_scale: scalar float value to be multiplied by `side_input`.
output: A tensor with format as specified by `data_format` (see below).
The dimension sizes are determined automatically based on other inputs
and attributes.
T: The element data type of `conv_input`, `side_input` and `output` tensors.
Note: must match with the `data_format`.
Tbias: The element data type of `bias`.
strides: 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.
Note: the stride for batch and channel dimensions must be 1.
padding: The type of padding algorithm to use.
data_format: A string specifying the data format of `conv_input`,
`side_input` and `output` tensors with the following options:
"NHWC": `float [ batch, height, width, channels ]`
"NCHW": `float [ batch, channels, height, width ]`
"NCHW_VECT_C":
`qint8 [ batch, channels / 4, height, width, channels % 4 ]`
Note: for "NCHW_VECT_C", `channels` must be a multiple of 4.
filter_format: A string specifying the data format of `filter`,
"HWIO": `float [ kernel_height, kernel_width, input_channels,
output_channels ]`
"OIHW_VECT_I":
`qint8 [ output_channels, input_channels / 4,
kernel_height, kernel_width, input_channels % 4 ]`
activation_mode: The activation applied to the output.
Must be "Relu" or "None".
dilations: 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.
Args:
conv_input: A `Tensor`. Must be one of the following types: `float32`, `half`, `qint8`.
filter: A `Tensor`. Must have the same type as `conv_input`.
bias: A `Tensor`. Must be one of the following types: `float32`, `half`.
side_input: A `Tensor`. Must have the same type as `conv_input`.
conv_input_scale: A `Tensor` of type `float32`.
side_input_scale: A `Tensor` of type `float32`.
strides: A list of `ints`.
padding: A `string` from: `"SAME", "VALID"`.
data_format: An optional `string` from: `"NHWC", "NCHW", "NCHW_VECT_C"`. Defaults to `"NHWC"`.
filter_format: An optional `string` from: `"HWIO", "OIHW", "OIHW_VECT_I"`. Defaults to `"HWIO"`.
activation_mode: An optional `string` from: `"Relu", "None"`. Defaults to `"Relu"`.
dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1]`.
name: A name for the operation (optional).
Returns:
A `Tensor`. Has the same type as `conv_input`.
"""
_ctx = _context._context
if _ctx is None or not _ctx._eager_context.is_eager:
if not isinstance(strides, (list, tuple)):
raise TypeError("Expected list for 'strides' argument to "
"'fused_conv2d_bias_activation' 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")
if filter_format is None:
filter_format = "HWIO"
filter_format = _execute.make_str(filter_format, "filter_format")
if activation_mode is None:
activation_mode = "Relu"
activation_mode = _execute.make_str(activation_mode, "activation_mode")
if dilations is None:
dilations = [1, 1, 1, 1]
if not isinstance(dilations, (list, tuple)):
raise TypeError("Expected list for 'dilations' argument to "
"'fused_conv2d_bias_activation' Op, not %r." %
dilations)
dilations = [_execute.make_int(_i, "dilations") for _i in dilations]
_, _, _op = _op_def_lib._apply_op_helper(
"FusedConv2DBiasActivation",
conv_input=conv_input,
filter=filter,
bias=bias,
side_input=side_input,
conv_input_scale=conv_input_scale,
side_input_scale=side_input_scale,
strides=strides,
padding=padding,
data_format=data_format,
filter_format=filter_format,
activation_mode=activation_mode,
dilations=dilations,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("T", _op.get_attr("T"), "Tbias", _op.get_attr("Tbias"),
"strides", _op.get_attr("strides"), "padding",
_op.get_attr("padding"), "data_format",
_op.get_attr("data_format"), "filter_format",
_op.get_attr("filter_format"), "activation_mode",
_op.get_attr("activation_mode"), "dilations",
_op.get_attr("dilations"))
_execute.record_gradient("FusedConv2DBiasActivation", _inputs_flat,
_attrs, _result, name)
_result, = _result
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name,
"FusedConv2DBiasActivation", name,
_ctx._post_execution_callbacks, conv_input, filter, bias,
side_input, conv_input_scale, side_input_scale, "strides",
strides, "padding", padding, "data_format", data_format,
"filter_format", filter_format, "activation_mode",
activation_mode, "dilations", dilations)
return _result
except _core._FallbackException:
return fused_conv2d_bias_activation_eager_fallback(
conv_input,
filter,
bias,
side_input,
conv_input_scale,
side_input_scale,
strides=strides,
padding=padding,
data_format=data_format,
filter_format=filter_format,
activation_mode=activation_mode,
dilations=dilations,
name=name,
ctx=_ctx)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
def sdca_optimizer_eager_fallback(sparse_example_indices,
sparse_feature_indices,
sparse_feature_values,
dense_features,
example_weights,
example_labels,
sparse_indices,
sparse_weights,
dense_weights,
example_state_data,
loss_type,
l1,
l2,
num_loss_partitions,
num_inner_iterations,
adaptative=True,
name=None,
ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function sdca_optimizer
"""
_ctx = ctx if ctx else _context.context()
if not isinstance(sparse_example_indices, (list, tuple)):
raise TypeError(
"Expected list for 'sparse_example_indices' argument to "
"'sdca_optimizer' Op, not %r." % sparse_example_indices)
_attr_num_sparse_features = len(sparse_example_indices)
if not isinstance(sparse_feature_indices, (list, tuple)):
raise TypeError(
"Expected list for 'sparse_feature_indices' argument to "
"'sdca_optimizer' Op, not %r." % sparse_feature_indices)
if len(sparse_feature_indices) != _attr_num_sparse_features:
raise ValueError(
"List argument 'sparse_feature_indices' to 'sdca_optimizer' Op with length %d "
"must match length %d of argument 'sparse_example_indices'." %
(len(sparse_feature_indices), _attr_num_sparse_features))
if not isinstance(sparse_indices, (list, tuple)):
raise TypeError("Expected list for 'sparse_indices' argument to "
"'sdca_optimizer' Op, not %r." % sparse_indices)
if len(sparse_indices) != _attr_num_sparse_features:
raise ValueError(
"List argument 'sparse_indices' to 'sdca_optimizer' Op with length %d "
"must match length %d of argument 'sparse_example_indices'." %
(len(sparse_indices), _attr_num_sparse_features))
if not isinstance(sparse_weights, (list, tuple)):
raise TypeError("Expected list for 'sparse_weights' argument to "
"'sdca_optimizer' Op, not %r." % sparse_weights)
if len(sparse_weights) != _attr_num_sparse_features:
raise ValueError(
"List argument 'sparse_weights' to 'sdca_optimizer' Op with length %d "
"must match length %d of argument 'sparse_example_indices'." %
(len(sparse_weights), _attr_num_sparse_features))
if not isinstance(sparse_feature_values, (list, tuple)):
raise TypeError(
"Expected list for 'sparse_feature_values' argument to "
"'sdca_optimizer' Op, not %r." % sparse_feature_values)
_attr_num_sparse_features_with_values = len(sparse_feature_values)
if not isinstance(dense_features, (list, tuple)):
raise TypeError("Expected list for 'dense_features' argument to "
"'sdca_optimizer' Op, not %r." % dense_features)
_attr_num_dense_features = len(dense_features)
if not isinstance(dense_weights, (list, tuple)):
raise TypeError("Expected list for 'dense_weights' argument to "
"'sdca_optimizer' Op, not %r." % dense_weights)
if len(dense_weights) != _attr_num_dense_features:
raise ValueError(
"List argument 'dense_weights' to 'sdca_optimizer' Op with length %d "
"must match length %d of argument 'dense_features'." %
(len(dense_weights), _attr_num_dense_features))
loss_type = _execute.make_str(loss_type, "loss_type")
l1 = _execute.make_float(l1, "l1")
l2 = _execute.make_float(l2, "l2")
num_loss_partitions = _execute.make_int(num_loss_partitions,
"num_loss_partitions")
num_inner_iterations = _execute.make_int(num_inner_iterations,
"num_inner_iterations")
if adaptative is None:
adaptative = True
adaptative = _execute.make_bool(adaptative, "adaptative")
sparse_example_indices = _ops.convert_n_to_tensor(sparse_example_indices,
_dtypes.int64)
sparse_feature_indices = _ops.convert_n_to_tensor(sparse_feature_indices,
_dtypes.int64)
sparse_feature_values = _ops.convert_n_to_tensor(sparse_feature_values,
_dtypes.float32)
dense_features = _ops.convert_n_to_tensor(dense_features, _dtypes.float32)
example_weights = _ops.convert_to_tensor(example_weights, _dtypes.float32)
example_labels = _ops.convert_to_tensor(example_labels, _dtypes.float32)
sparse_indices = _ops.convert_n_to_tensor(sparse_indices, _dtypes.int64)
sparse_weights = _ops.convert_n_to_tensor(sparse_weights, _dtypes.float32)
dense_weights = _ops.convert_n_to_tensor(dense_weights, _dtypes.float32)
example_state_data = _ops.convert_to_tensor(example_state_data,
_dtypes.float32)
_inputs_flat = list(sparse_example_indices) + list(
sparse_feature_indices
) + list(sparse_feature_values) + list(dense_features) + [
example_weights, example_labels
] + list(sparse_indices) + list(sparse_weights) + list(dense_weights) + [
example_state_data
]
_attrs = ("loss_type", loss_type, "adaptative", adaptative,
"num_sparse_features", _attr_num_sparse_features,
"num_sparse_features_with_values",
_attr_num_sparse_features_with_values, "num_dense_features",
_attr_num_dense_features, "l1", l1, "l2", l2,
"num_loss_partitions", num_loss_partitions,
"num_inner_iterations", num_inner_iterations)
_result = _execute.execute(b"SdcaOptimizer",
_attr_num_sparse_features +
_attr_num_dense_features + 1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("SdcaOptimizer", _inputs_flat, _attrs, _result,
name)
_result = _result[:1] + [_result[1:1 + _attr_num_sparse_features]
] + _result[1 + _attr_num_sparse_features:]
_result = _result[:2] + [_result[2:]]
_result = _SdcaOptimizerOutput._make(_result)
return _result
def single_image_random_dot_stereograms_eager_fallback(
depth_values,
hidden_surface_removal=True,
convergence_dots_size=8,
dots_per_inch=72,
eye_separation=2.5,
mu=0.3333,
normalize=True,
normalize_max=-100,
normalize_min=100,
border_level=0,
number_colors=256,
output_image_shape=[1024, 768, 1],
output_data_window=[1022, 757],
name=None,
ctx=None):
r"""This is the slowpath function for Eager mode.
This is for function single_image_random_dot_stereograms
"""
_ctx = ctx if ctx else _context.context()
if hidden_surface_removal is None:
hidden_surface_removal = True
hidden_surface_removal = _execute.make_bool(hidden_surface_removal,
"hidden_surface_removal")
if convergence_dots_size is None:
convergence_dots_size = 8
convergence_dots_size = _execute.make_int(convergence_dots_size,
"convergence_dots_size")
if dots_per_inch is None:
dots_per_inch = 72
dots_per_inch = _execute.make_int(dots_per_inch, "dots_per_inch")
if eye_separation is None:
eye_separation = 2.5
eye_separation = _execute.make_float(eye_separation, "eye_separation")
if mu is None:
mu = 0.3333
mu = _execute.make_float(mu, "mu")
if normalize is None:
normalize = True
normalize = _execute.make_bool(normalize, "normalize")
if normalize_max is None:
normalize_max = -100
normalize_max = _execute.make_float(normalize_max, "normalize_max")
if normalize_min is None:
normalize_min = 100
normalize_min = _execute.make_float(normalize_min, "normalize_min")
if border_level is None:
border_level = 0
border_level = _execute.make_float(border_level, "border_level")
if number_colors is None:
number_colors = 256
number_colors = _execute.make_int(number_colors, "number_colors")
if output_image_shape is None:
output_image_shape = [1024, 768, 1]
output_image_shape = _execute.make_shape(output_image_shape,
"output_image_shape")
if output_data_window is None:
output_data_window = [1022, 757]
output_data_window = _execute.make_shape(output_data_window,
"output_data_window")
_attr_T, (depth_values, ) = _execute.args_to_matching_eager([depth_values],
_ctx)
_inputs_flat = [depth_values]
_attrs = ("T", _attr_T, "hidden_surface_removal", hidden_surface_removal,
"convergence_dots_size", convergence_dots_size, "dots_per_inch",
dots_per_inch, "eye_separation", eye_separation, "mu", mu,
"normalize", normalize, "normalize_max", normalize_max,
"normalize_min", normalize_min, "border_level", border_level,
"number_colors", number_colors, "output_image_shape",
output_image_shape, "output_data_window", output_data_window)
_result = _execute.execute(b"SingleImageRandomDotStereograms",
1,
inputs=_inputs_flat,
attrs=_attrs,
ctx=_ctx,
name=name)
_execute.record_gradient("SingleImageRandomDotStereograms", _inputs_flat,
_attrs, _result, name)
_result, = _result
return _result
def tree_ensemble_used_handlers(tree_ensemble_handle, stamp_token, num_all_handlers, name=None):
r"""Returns the mask of used handlers along with the number of non-zero elements in
this mask. Used in feature selection.
Args:
tree_ensemble_handle: A `Tensor` of type `resource`.
Handle to the tree ensemble.
stamp_token: A `Tensor` of type `int64`.
Token to use as the new value of the resource stamp.
num_all_handlers: An `int` that is `>= 0`.
name: A name for the operation (optional).
Returns:
A tuple of `Tensor` objects (num_used_handlers, used_handlers_mask).
num_used_handlers: A `Tensor` of type `int64`. number of feature column handlers used in the model.
used_handlers_mask: A `Tensor` of type `bool`. A boolean vector of showing which handlers are used in the
model.
"""
_ctx = _context._context or _context.context()
if _ctx is not None and _ctx._thread_local_data.is_eager:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._thread_local_data.device_name,
"TreeEnsembleUsedHandlers", name, _ctx.post_execution_callbacks,
tree_ensemble_handle, stamp_token, "num_all_handlers",
num_all_handlers)
_result = _TreeEnsembleUsedHandlersOutput._make(_result)
return _result
except _core._FallbackException:
try:
return tree_ensemble_used_handlers_eager_fallback(
tree_ensemble_handle, stamp_token,
num_all_handlers=num_all_handlers, name=name, ctx=_ctx)
except _core._SymbolicException:
pass # Add nodes to the TensorFlow graph.
except (TypeError, ValueError):
result = _dispatch.dispatch(
tree_ensemble_used_handlers, tree_ensemble_handle=tree_ensemble_handle,
stamp_token=stamp_token,
num_all_handlers=num_all_handlers,
name=name)
if result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
return result
raise
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
# Add nodes to the TensorFlow graph.
num_all_handlers = _execute.make_int(num_all_handlers, "num_all_handlers")
try:
_, _, _op = _op_def_lib._apply_op_helper(
"TreeEnsembleUsedHandlers", tree_ensemble_handle=tree_ensemble_handle,
stamp_token=stamp_token,
num_all_handlers=num_all_handlers,
name=name)
except (TypeError, ValueError):
result = _dispatch.dispatch(
tree_ensemble_used_handlers, tree_ensemble_handle=tree_ensemble_handle,
stamp_token=stamp_token,
num_all_handlers=num_all_handlers,
name=name)
if result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
return result
raise
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("num_all_handlers", _op.get_attr("num_all_handlers"))
_execute.record_gradient(
"TreeEnsembleUsedHandlers", _inputs_flat, _attrs, _result, name)
_result = _TreeEnsembleUsedHandlersOutput._make(_result)
return _result
def single_image_random_dot_stereograms(depth_values,
hidden_surface_removal=True,
convergence_dots_size=8,
dots_per_inch=72,
eye_separation=2.5,
mu=0.3333,
normalize=True,
normalize_max=-100,
normalize_min=100,
border_level=0,
number_colors=256,
output_image_shape=[1024, 768, 1],
output_data_window=[1022, 757],
name=None):
r"""Outputs a single image random dot stereogram for export via encode_PNG/JPG OP.
Given the 2-D tensor 'depth_values' with encoded Z values, this operation will
encode 3-D data into a 2-D image. The output of this Op is suitable for the
encode_PNG/JPG ops. Be careful with image compression as this may corrupt the
encode 3-D data within the image.
This Op is based upon:
'http://www.learningace.com/doc/4331582/b6ab058d1e206d68ab60e4e1ead2fe6e/sirds-paper'
Example use which outputs a SIRDS image as picture_out.png:
```python
img=[[1,2,3,3,2,1],
[1,2,3,4,5,2],
[1,2,3,4,5,3],
[1,2,3,4,5,4],
[6,5,4,4,5,5]]
session = tf.InteractiveSession()
sirds = single_image_random_dot_stereograms(img,convergence_dots_size=8,number_colors=256,normalize=True)
out = sirds.eval()
png = tf.image.encode_png(out).eval()
with open('picture_out.png', 'wb') as f:
f.write(png)
```
Args:
depth_values: A `Tensor`. Must be one of the following types: `float64`, `float32`, `int64`, `int32`.
Z values of data to encode into 'output_data_window' window,
lower values are further away {0.0 floor(far), 1.0 ceiling(near) after normalization}, must be 2-D tensor
hidden_surface_removal: An optional `bool`. Defaults to `True`.
Activate hidden surface removal
convergence_dots_size: An optional `int`. Defaults to `8`.
Black dot size in pixels to help view converge image, drawn on bottom of image
dots_per_inch: An optional `int`. Defaults to `72`.
Output device in dots/inch
eye_separation: An optional `float`. Defaults to `2.5`.
Separation between eyes in inches
mu: An optional `float`. Defaults to `0.3333`.
Depth of field, Fraction of viewing distance (eg. 1/3 = .3333)
normalize: An optional `bool`. Defaults to `True`.
Normalize input data to [0.0, 1.0]
normalize_max: An optional `float`. Defaults to `-100`.
Fix MAX value for Normalization - if < MIN, autoscale
normalize_min: An optional `float`. Defaults to `100`.
Fix MIN value for Normalization - if > MAX, autoscale
border_level: An optional `float`. Defaults to `0`.
Value of border depth 0.0 {far} to 1.0 {near}
number_colors: An optional `int`. Defaults to `256`.
2 (Black & White),256 (grayscale), and Numbers > 256 (Full Color) are all that are supported currently
output_image_shape: An optional `tf.TensorShape` or list of `ints`. Defaults to `[1024, 768, 1]`.
Output size of returned image in X,Y, Channels 1-grayscale, 3 color (1024, 768, 1),
channels will be updated to 3 if 'number_colors' > 256
output_data_window: An optional `tf.TensorShape` or list of `ints`. Defaults to `[1022, 757]`.
Size of "DATA" window, must be equal to or smaller than 'output_image_shape', will be centered
and use 'convergence_dots_size' for best fit to avoid overlap if possible
name: A name for the operation (optional).
Returns:
A tensor of size 'output_image_shape' with the encoded 'depth_values'
"""
_ctx = _context._context or _context.context()
if _ctx is not None and _ctx._thread_local_data.is_eager:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._thread_local_data.device_name,
"SingleImageRandomDotStereograms", name,
_ctx._post_execution_callbacks, depth_values,
"hidden_surface_removal", hidden_surface_removal,
"convergence_dots_size", convergence_dots_size,
"dots_per_inch", dots_per_inch, "eye_separation",
eye_separation, "mu", mu, "normalize", normalize,
"normalize_max", normalize_max, "normalize_min", normalize_min,
"border_level", border_level, "number_colors", number_colors,
"output_image_shape", output_image_shape, "output_data_window",
output_data_window)
return _result
except _core._FallbackException:
try:
return single_image_random_dot_stereograms_eager_fallback(
depth_values,
hidden_surface_removal=hidden_surface_removal,
convergence_dots_size=convergence_dots_size,
dots_per_inch=dots_per_inch,
eye_separation=eye_separation,
mu=mu,
normalize=normalize,
normalize_max=normalize_max,
normalize_min=normalize_min,
border_level=border_level,
number_colors=number_colors,
output_image_shape=output_image_shape,
output_data_window=output_data_window,
name=name,
ctx=_ctx)
except _core._SymbolicException:
pass # Add nodes to the TensorFlow graph.
except (TypeError, ValueError):
result = _dispatch.dispatch(
single_image_random_dot_stereograms,
depth_values=depth_values,
hidden_surface_removal=hidden_surface_removal,
convergence_dots_size=convergence_dots_size,
dots_per_inch=dots_per_inch,
eye_separation=eye_separation,
mu=mu,
normalize=normalize,
normalize_max=normalize_max,
normalize_min=normalize_min,
border_level=border_level,
number_colors=number_colors,
output_image_shape=output_image_shape,
output_data_window=output_data_window,
name=name)
if result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
return result
raise
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
# Add nodes to the TensorFlow graph.
if hidden_surface_removal is None:
hidden_surface_removal = True
hidden_surface_removal = _execute.make_bool(hidden_surface_removal,
"hidden_surface_removal")
if convergence_dots_size is None:
convergence_dots_size = 8
convergence_dots_size = _execute.make_int(convergence_dots_size,
"convergence_dots_size")
if dots_per_inch is None:
dots_per_inch = 72
dots_per_inch = _execute.make_int(dots_per_inch, "dots_per_inch")
if eye_separation is None:
eye_separation = 2.5
eye_separation = _execute.make_float(eye_separation, "eye_separation")
if mu is None:
mu = 0.3333
mu = _execute.make_float(mu, "mu")
if normalize is None:
normalize = True
normalize = _execute.make_bool(normalize, "normalize")
if normalize_max is None:
normalize_max = -100
normalize_max = _execute.make_float(normalize_max, "normalize_max")
if normalize_min is None:
normalize_min = 100
normalize_min = _execute.make_float(normalize_min, "normalize_min")
if border_level is None:
border_level = 0
border_level = _execute.make_float(border_level, "border_level")
if number_colors is None:
number_colors = 256
number_colors = _execute.make_int(number_colors, "number_colors")
if output_image_shape is None:
output_image_shape = [1024, 768, 1]
output_image_shape = _execute.make_shape(output_image_shape,
"output_image_shape")
if output_data_window is None:
output_data_window = [1022, 757]
output_data_window = _execute.make_shape(output_data_window,
"output_data_window")
try:
_, _, _op = _op_def_lib._apply_op_helper(
"SingleImageRandomDotStereograms",
depth_values=depth_values,
hidden_surface_removal=hidden_surface_removal,
convergence_dots_size=convergence_dots_size,
dots_per_inch=dots_per_inch,
eye_separation=eye_separation,
mu=mu,
normalize=normalize,
normalize_max=normalize_max,
normalize_min=normalize_min,
border_level=border_level,
number_colors=number_colors,
output_image_shape=output_image_shape,
output_data_window=output_data_window,
name=name)
except (TypeError, ValueError):
result = _dispatch.dispatch(
single_image_random_dot_stereograms,
depth_values=depth_values,
hidden_surface_removal=hidden_surface_removal,
convergence_dots_size=convergence_dots_size,
dots_per_inch=dots_per_inch,
eye_separation=eye_separation,
mu=mu,
normalize=normalize,
normalize_max=normalize_max,
normalize_min=normalize_min,
border_level=border_level,
number_colors=number_colors,
output_image_shape=output_image_shape,
output_data_window=output_data_window,
name=name)
if result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
return result
raise
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("T", _op.get_attr("T"), "hidden_surface_removal",
_op.get_attr("hidden_surface_removal"), "convergence_dots_size",
_op.get_attr("convergence_dots_size"), "dots_per_inch",
_op.get_attr("dots_per_inch"), "eye_separation",
_op.get_attr("eye_separation"), "mu", _op.get_attr("mu"),
"normalize", _op.get_attr("normalize"), "normalize_max",
_op.get_attr("normalize_max"), "normalize_min",
_op.get_attr("normalize_min"), "border_level",
_op.get_attr("border_level"), "number_colors",
_op.get_attr("number_colors"), "output_image_shape",
_op.get_attr("output_image_shape"), "output_data_window",
_op.get_attr("output_data_window"))
_execute.record_gradient("SingleImageRandomDotStereograms", _inputs_flat,
_attrs, _result, name)
_result, = _result
return _result
def range_encode(data, cdf, precision, name=None):
r"""Using the provided cumulative distribution functions (CDF) inside `cdf`, returns
a range-code of `data`.
The shape of `cdf` should have one more axis than the shape of `data`, and the
prefix `cdf.shape[:-1]` should be broadcastable to `data.shape`. That is, for
every `i = 0,...,rank(data) - 1`, the op requires that either
`cdf.shape[i] == 1` or `cdf.shape[i] == data.shape[i]`. Note that this
broadcasting is limited in the sense that the number of axes must match, and
broadcasts only `cdf` but not `data`.
`data` should have an upper bound `m > 0` such that each element is an integer
in range `[0, m)`. Then the last dimension size of `cdf` must be `m + 1`. For
each element of `data`, the innermost strip of `cdf` is a vector representing a
CDF. For each k = 0,...,m, `cdf[..., k] / 2^precision` is the probability that
an outcome is less than `k` (not less than or equal to).
```
cdf[..., 0] / 2^precision = Pr(data[...] < 0)
cdf[..., 1] / 2^precision = Pr(data[...] < 1) = Pr(data[...] <= 0)
cdf[..., 2] / 2^precision = Pr(data[...] < 2) = Pr(data[...] <= 1)
...
cdf[..., m] / 2^precision = Pr(data[...] < m) = 1
```
Therefore each element of `cdf` must be in `[0, 2^precision]`.
Ideally `cdf[..., m]` should equal to `2^precision` but this is not a hard
requirement as long as `cdf[..., m] <= 2^precision`.
The encoded string neither contains the shape information of the encoded data
nor a termination symbol. Therefore the shape of the encoded data must be
explicitly provided to the decoder.
Implementation notes:
- Because of potential performance issues, the op does not check whether
elements of `data` is in the correct range `[0, m)`, or if `cdf` satisfies
monotonic increase property.
- For the range coder to decode the encoded string correctly, the decoder should
be able to reproduce the internal states of the encoder precisely. Otherwise,
the decoding would fail and once an error occur, all subsequent decoded values
are incorrect. For this reason, the range coder uses integer arithmetics and
avoids using any floating point operations internally, and `cdf` should contain
integers representing quantized probability mass rather than floating points.
Args:
data: A `Tensor` of type `int16`. An int32 tensor.
cdf: A `Tensor` of type `int32`.
An int32 tensor representing the CDF's of `data`. Each integer is divided
by `2^precision` to represent a fraction.
precision: An `int` that is `>= 1`.
The number of bits for probability quantization. Must be <= 16.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `string`. A range-coded scalar string.
"""
precision = _execute.make_int(precision, "precision")
_ctx = _context.context()
if _ctx.in_graph_mode():
_, _, _op = _op_def_lib._apply_op_helper(
"RangeEncode", data=data, cdf=cdf, precision=precision, name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("precision", _op.get_attr("precision"))
else:
data = _ops.convert_to_tensor(data, _dtypes.int16)
cdf = _ops.convert_to_tensor(cdf, _dtypes.int32)
_inputs_flat = [data, cdf]
_attrs = ("precision", precision)
_result = _execute.execute(b"RangeEncode", 1, inputs=_inputs_flat,
attrs=_attrs, ctx=_ctx, name=name)
_execute.record_gradient(
"RangeEncode", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
def sparse_feature_cross(indices, values, shapes, dense, hashed_output, num_buckets, out_type, internal_type, name=None):
r"""Generates sparse cross form a list of sparse tensors.
The op takes two lists, one of 2D `SparseTensor` and one of 2D `Tensor`, each
representing features of one feature column. It outputs a 2D `SparseTensor` with
the batchwise crosses of these features.
For example, if the inputs are
inputs[0]: SparseTensor with shape = [2, 2]
[0, 0]: "a"
[1, 0]: "b"
[1, 1]: "c"
inputs[1]: SparseTensor with shape = [2, 1]
[0, 0]: "d"
[1, 0]: "e"
inputs[2]: Tensor [["f"], ["g"]]
then the output will be
shape = [2, 2]
[0, 0]: "a_X_d_X_f"
[1, 0]: "b_X_e_X_g"
[1, 1]: "c_X_e_X_g"
if hashed_output=true then the output will be
shape = [2, 2]
[0, 0]: HashCombine(
Fingerprint64("f"), HashCombine(
Fingerprint64("d"), Fingerprint64("a")))
[1, 0]: HashCombine(
Fingerprint64("g"), HashCombine(
Fingerprint64("e"), Fingerprint64("b")))
[1, 1]: HashCombine(
Fingerprint64("g"), HashCombine(
Fingerprint64("e"), Fingerprint64("c")))
Args:
indices: A list of `Tensor` objects with type `int64`.
2-D. Indices of each input `SparseTensor`.
values: A list of `Tensor` objects with types from: `int64`, `string`.
1-D. values of each `SparseTensor`.
shapes: A list with the same length as `indices` of `Tensor` objects with type `int64`.
1-D. Shapes of each `SparseTensor`.
dense: A list of `Tensor` objects with types from: `int64`, `string`.
2-D. Columns represented by dense `Tensor`.
hashed_output: A `bool`.
num_buckets: An `int` that is `>= 0`.
out_type: A `tf.DType` from: `tf.int64, tf.string`.
internal_type: A `tf.DType` from: `tf.int64, tf.string`.
name: A name for the operation (optional).
Returns:
A tuple of `Tensor` objects (output_indices, output_values, output_shape).
output_indices: A `Tensor` of type `int64`. 2-D. Indices of the concatenated `SparseTensor`.
output_values: A `Tensor` of type `out_type`. 1-D. Non-empty values of the concatenated or hashed
`SparseTensor`.
output_shape: A `Tensor` of type `int64`. 1-D. Shape of the concatenated `SparseTensor`.
"""
_ctx = _context._context
if _ctx is None or not _ctx._eager_context.is_eager:
if not isinstance(indices, (list, tuple)):
raise TypeError(
"Expected list for 'indices' argument to "
"'sparse_feature_cross' Op, not %r." % indices)
_attr_N = len(indices)
if not isinstance(shapes, (list, tuple)):
raise TypeError(
"Expected list for 'shapes' argument to "
"'sparse_feature_cross' Op, not %r." % shapes)
if len(shapes) != _attr_N:
raise ValueError(
"List argument 'shapes' to 'sparse_feature_cross' Op with length %d "
"must match length %d of argument 'indices'." %
(len(shapes), _attr_N))
hashed_output = _execute.make_bool(hashed_output, "hashed_output")
num_buckets = _execute.make_int(num_buckets, "num_buckets")
out_type = _execute.make_type(out_type, "out_type")
internal_type = _execute.make_type(internal_type, "internal_type")
_, _, _op = _op_def_lib._apply_op_helper(
"SparseFeatureCross", indices=indices, values=values, shapes=shapes,
dense=dense, hashed_output=hashed_output, num_buckets=num_buckets,
out_type=out_type, internal_type=internal_type, name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("N", _op.get_attr("N"), "hashed_output",
_op.get_attr("hashed_output"), "num_buckets",
_op.get_attr("num_buckets"), "sparse_types",
_op.get_attr("sparse_types"), "dense_types",
_op.get_attr("dense_types"), "out_type",
_op.get_attr("out_type"), "internal_type",
_op.get_attr("internal_type"))
_execute.record_gradient(
"SparseFeatureCross", _inputs_flat, _attrs, _result, name)
_result = _SparseFeatureCrossOutput._make(_result)
return _result
else:
try:
_result = _pywrap_tensorflow.TFE_Py_FastPathExecute(
_ctx._context_handle, _ctx._eager_context.device_name,
"SparseFeatureCross", name, _ctx._post_execution_callbacks, indices,
values, shapes, dense, "hashed_output", hashed_output, "num_buckets",
num_buckets, "out_type", out_type, "internal_type", internal_type)
_result = _SparseFeatureCrossOutput._make(_result)
return _result
except _core._FallbackException:
return sparse_feature_cross_eager_fallback(
indices, values, shapes, dense, hashed_output=hashed_output,
num_buckets=num_buckets, out_type=out_type,
internal_type=internal_type, name=name, ctx=_ctx)
except _core._NotOkStatusException as e:
if name is not None:
message = e.message + " name: " + name
else:
message = e.message
_six.raise_from(_core._status_to_exception(e.code, message), None)
