def ragged_tensor_to_variant(rt_nested_splits, rt_dense_values, batched_input, name=None): r"""Encodes a `RaggedTensor` into a `variant` Tensor. Encodes the given `RaggedTensor` and returns a `variant` Tensor. If `batched_input` is True, then input `RaggedTensor` is unbatched along the zero-th dimension, each component `RaggedTensor` is encoded into a scalar `variant` Tensor, and these are stacked to return a 1-D `variant` Tensor. If `batched_input` is False, then the input `RaggedTensor` is encoded as is and a scalar `variant` Tensor is returned. A `RaggedTensor` is encoded by first creating a 1-D `variant` Tensor with `ragged_rank + 1` elements, containing the splits and values Tensors of the `RaggedTensor`. Then the 1-D `variant` Tensor is wrapped in a scalar `variant` Tensor. See `RaggedTensorFromVariant` for the corresponding decoding logic. Args: rt_nested_splits: A list of `Tensor` objects with the same type in: `int32`, `int64`. A list of one or more Tensors representing the splits of the input `RaggedTensor`. rt_dense_values: A `Tensor`. A Tensor representing the values of the input `RaggedTensor`. batched_input: A `bool`. A `bool` denoting whether the input is a batched `RaggedTensor`. name: A name for the operation (optional). Returns: A `Tensor` of type `variant`. """ _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, "RaggedTensorToVariant", name, tld.op_callbacks, rt_nested_splits, rt_dense_values, "batched_input", batched_input) return _result except _core._FallbackException: try: return ragged_tensor_to_variant_eager_fallback( rt_nested_splits, rt_dense_values, batched_input=batched_input, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # Add nodes to the TensorFlow graph. if not isinstance(rt_nested_splits, (list, tuple)): raise TypeError("Expected list for 'rt_nested_splits' argument to " "'ragged_tensor_to_variant' Op, not %r." % rt_nested_splits) _attr_RAGGED_RANK = len(rt_nested_splits) batched_input = _execute.make_bool(batched_input, "batched_input") _, _, _op, _outputs = _op_def_library._apply_op_helper( "RaggedTensorToVariant", rt_nested_splits=rt_nested_splits, rt_dense_values=rt_dense_values, batched_input=batched_input, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("RAGGED_RANK", _op._get_attr_int("RAGGED_RANK"), "Tvalues", _op._get_attr_type("Tvalues"), "Tsplits", _op._get_attr_type("Tsplits"), "batched_input", _op._get_attr_bool("batched_input")) _inputs_flat = _op.inputs _execute.record_gradient("RaggedTensorToVariant", _inputs_flat, _attrs, _result) _result, = _result return _result
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() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "Enter", name, tld.op_callbacks, data, "frame_name", frame_name, "is_constant", is_constant, "parallel_iterations", parallel_iterations) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass 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. # 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, _outputs = _op_def_library._apply_op_helper( "Enter", data=data, frame_name=frame_name, is_constant=is_constant, parallel_iterations=parallel_iterations, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("T", _op._get_attr_type("T"), "frame_name", _op.get_attr("frame_name"), "is_constant", _op._get_attr_bool("is_constant"), "parallel_iterations", _op._get_attr_int("parallel_iterations")) _inputs_flat = _op.inputs _execute.record_gradient("Enter", _inputs_flat, _attrs, _result) _result, = _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 or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "GenerateVocabRemapping", name, 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._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: 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._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. 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, _outputs = _op_def_library._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 = _outputs[:] if _execute.must_record_gradient(): _attrs = ("new_vocab_offset", _op._get_attr_int("new_vocab_offset"), "num_new_vocab", _op._get_attr_int("num_new_vocab"), "old_vocab_size", _op._get_attr_int("old_vocab_size")) _inputs_flat = _op.inputs _execute.record_gradient("GenerateVocabRemapping", _inputs_flat, _attrs, _result) _result = _GenerateVocabRemappingOutput._make(_result) return _result
def ragged_range(starts, limits, deltas, Tsplits=_dtypes.int64, name=None): r"""Returns a `RaggedTensor` containing the specified sequences of numbers. Returns a `RaggedTensor` `result` composed from `rt_dense_values` and `rt_nested_splits`, such that `result[i] = range(starts[i], limits[i], deltas[i])`. ```python (rt_nested_splits, rt_dense_values) = ragged_range( starts=[2, 5, 8], limits=[3, 5, 12], deltas=1) result = tf.ragged.from_row_splits(rt_dense_values, rt_nested_splits) print(result) <tf.RaggedTensor [[2], [], [8, 9, 10, 11]] > ``` The input tensors `starts`, `limits`, and `deltas` may be scalars or vectors. The vector inputs must all have the same size. Scalar inputs are broadcast to match the size of the vector inputs. Args: starts: A `Tensor`. Must be one of the following types: `bfloat16`, `float32`, `float64`, `int32`, `int64`. The starts of each range. limits: A `Tensor`. Must have the same type as `starts`. The limits of each range. deltas: A `Tensor`. Must have the same type as `starts`. The deltas of each range. Tsplits: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int64`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (rt_nested_splits, rt_dense_values). rt_nested_splits: A `Tensor` of type `Tsplits`. rt_dense_values: A `Tensor`. Has the same type as `starts`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "RaggedRange", name, tld.op_callbacks, starts, limits, deltas, "Tsplits", Tsplits) _result = _RaggedRangeOutput._make(_result) return _result except _core._FallbackException: try: return ragged_range_eager_fallback(starts, limits, deltas, Tsplits=Tsplits, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # Add nodes to the TensorFlow graph. if Tsplits is None: Tsplits = _dtypes.int64 Tsplits = _execute.make_type(Tsplits, "Tsplits") _, _, _op, _outputs = _op_def_library._apply_op_helper("RaggedRange", starts=starts, limits=limits, deltas=deltas, Tsplits=Tsplits, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("T", _op._get_attr_type("T"), "Tsplits", _op._get_attr_type("Tsplits")) _inputs_flat = _op.inputs _execute.record_gradient("RaggedRange", _inputs_flat, _attrs, _result) _result = _RaggedRangeOutput._make(_result) return _result
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`. true_expected_count: A `Tensor` of type `float32`. sampled_expected_count: A `Tensor` of type `float32`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "FixedUnigramCandidateSampler", name, 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) _result = _FixedUnigramCandidateSamplerOutput._make(_result) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return fixed_unigram_candidate_sampler_eager_fallback( 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, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. 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") _, _, _op, _outputs = _op_def_library._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 = _outputs[:] if _execute.must_record_gradient(): _attrs = ("num_true", _op._get_attr_int("num_true"), "num_sampled", _op._get_attr_int("num_sampled"), "unique", _op._get_attr_bool("unique"), "range_max", _op._get_attr_int("range_max"), "vocab_file", _op.get_attr("vocab_file"), "distortion", _op.get_attr("distortion"), "num_reserved_ids", _op._get_attr_int("num_reserved_ids"), "num_shards", _op._get_attr_int("num_shards"), "shard", _op._get_attr_int("shard"), "unigrams", _op.get_attr("unigrams"), "seed", _op._get_attr_int("seed"), "seed2", _op._get_attr_int("seed2")) _inputs_flat = _op.inputs _execute.record_gradient("FixedUnigramCandidateSampler", _inputs_flat, _attrs, _result) _result = _FixedUnigramCandidateSamplerOutput._make(_result) return _result
def debug_nan_count(input, device_name="", tensor_name="", debug_urls=[], gated_grpc=False, name=None): r"""Debug NaN Value Counter Op. Counts number of NaNs in the input tensor, for debugging. Args: input: A `Tensor`. Input tensor, non-Reference type. device_name: An optional `string`. Defaults to `""`. tensor_name: An optional `string`. Defaults to `""`. Name of the input tensor. debug_urls: An optional list of `strings`. Defaults to `[]`. List of URLs to debug targets, e.g., file:///foo/tfdbg_dump, grpc:://localhost:11011. gated_grpc: An optional `bool`. Defaults to `False`. Whether this op will be gated. If any of the debug_urls of this debug node is of the grpc:// scheme, when the value of this attribute is set to True, the data will not actually be sent via the grpc stream unless this debug op has been enabled at the debug_url. If all of the debug_urls of this debug node are of the grpc:// scheme and the debug op is enabled at none of them, the output will be an empty Tensor. name: A name for the operation (optional). Returns: A `Tensor` of type `int64`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "DebugNanCount", name, input, "device_name", device_name, "tensor_name", tensor_name, "debug_urls", debug_urls, "gated_grpc", gated_grpc) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return debug_nan_count_eager_fallback( input, device_name=device_name, tensor_name=tensor_name, debug_urls=debug_urls, gated_grpc=gated_grpc, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if device_name is None: device_name = "" device_name = _execute.make_str(device_name, "device_name") if tensor_name is None: tensor_name = "" tensor_name = _execute.make_str(tensor_name, "tensor_name") if debug_urls is None: debug_urls = [] if not isinstance(debug_urls, (list, tuple)): raise TypeError( "Expected list for 'debug_urls' argument to " "'debug_nan_count' Op, not %r." % debug_urls) debug_urls = [_execute.make_str(_s, "debug_urls") for _s in debug_urls] if gated_grpc is None: gated_grpc = False gated_grpc = _execute.make_bool(gated_grpc, "gated_grpc") _, _, _op, _outputs = _op_def_library._apply_op_helper( "DebugNanCount", input=input, device_name=device_name, tensor_name=tensor_name, debug_urls=debug_urls, gated_grpc=gated_grpc, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("T", _op._get_attr_type("T"), "device_name", _op.get_attr("device_name"), "tensor_name", _op.get_attr("tensor_name"), "debug_urls", _op.get_attr("debug_urls"), "gated_grpc", _op._get_attr_bool("gated_grpc")) _inputs_flat = _op.inputs _execute.record_gradient( "DebugNanCount", _inputs_flat, _attrs, _result) _result, = _result return _result
def debug_numeric_summary_v2(input, output_dtype=_dtypes.float32, tensor_debug_mode=-1, tensor_id=-1, name=None): r"""Debug Numeric Summary V2 Op. Computes a numeric summary of the input tensor. The shape of the output depends on the tensor_debug_mode attribute. This op is used internally by TensorFlow Debugger (tfdbg) v2. Args: input: A `Tensor`. Input tensor, to be summarized by the op. output_dtype: An optional `tf.DType` from: `tf.float32, tf.float64`. Defaults to `tf.float32`. Optional. The type of the output. Can be float32 or float64 (default: float32). tensor_debug_mode: An optional `int`. Defaults to `-1`. Tensor debug mode: the mode in which the input tensor is summarized by the op. See the TensorDebugMode enum in tensorflow/core/protobuf/debug_event.proto for details. Supported values: 2 (CURT_HEALTH): Output a float32/64 tensor of shape [2]. The 1st element is the tensor_id, if provided, and -1 otherwise. The 2nd element is a bit which is set to 1 if the input tensor has an infinity or nan value, or zero otherwise. 3 (CONCISE_HEALTH): Output a float32/64 tensor of shape [5]. The 1st element is the tensor_id, if provided, and -1 otherwise. The remaining four slots are the total number of elements, -infs, +infs, and nans in the input tensor respectively. 4 (FULL_HEALTH): Output a float32/64 tensor of shape [11]. The 1st element is the tensor_id, if provided, and -1 otherwise. The 2nd element is the device_id, if provided, and -1 otherwise. The 3rd element holds the datatype value of the input tensor as according to the enumerated type in tensorflow/core/framework/types.proto. The remaining elements hold the total number of elements, -infs, +infs, nans, negative finite numbers, zeros, and positive finite numbers in the input tensor respectively. 5 (SHAPE): Output a float32/64 tensor of shape [10]. The 1st element is the tensor_id, if provided, and -1 otherwise. The 2nd element holds the datatype value of the input tensor as according to the enumerated type in tensorflow/core/framework/types.proto. The 3rd element holds the rank of the tensor. The 4th element holds the number of elements within the tensor. Finally the remaining 6 elements hold the shape of the tensor. If the rank of the tensor is lower than 6, the shape is right padded with zeros. If the rank is greater than 6, the head of the shape is truncated. 6 (FULL_NUMERICS): Output a float32/64 tensor of shape [22]. The 1st element is the tensor_id, if provided, and -1 otherwise. The 2nd element is the device_id, if provided, and -1 otherwise. The 3rd element holds the datatype value of the input tensor as according to the enumerated type in tensorflow/core/framework/types.proto. The 4th element holds the rank of the tensor. The 5th to 11th elements hold the shape of the tensor. If the rank of the tensor is lower than 6, the shape is right padded with zeros. If the rank is greater than 6, the head of the shape is truncated. The 12th to 18th elements hold the number of elements, -infs, +infs, nans, denormal floats, negative finite numbers, zeros, and positive finite numbers in the input tensor respectively. The final four elements hold the min value, max value, mean, and variance of the input tensor. 8 (REDUCE_INF_NAN_THREE_SLOTS): Output a float32/64 tensor of shape [3]. The 1st element is -inf if any elements of the input tensor is -inf, or zero otherwise. The 2nd element is +inf if any elements of the input tensor is +inf, or zero otherwise. The 3rd element is nan if any element of the input tensor is nan, or zero otherwise. tensor_id: An optional `int`. Defaults to `-1`. Optional. An integer identifier for the tensor being summarized by this op. name: A name for the operation (optional). Returns: A `Tensor` of type `output_dtype`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "DebugNumericSummaryV2", name, input, "output_dtype", output_dtype, "tensor_debug_mode", tensor_debug_mode, "tensor_id", tensor_id) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return debug_numeric_summary_v2_eager_fallback( input, output_dtype=output_dtype, tensor_debug_mode=tensor_debug_mode, tensor_id=tensor_id, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if output_dtype is None: output_dtype = _dtypes.float32 output_dtype = _execute.make_type(output_dtype, "output_dtype") if tensor_debug_mode is None: tensor_debug_mode = -1 tensor_debug_mode = _execute.make_int(tensor_debug_mode, "tensor_debug_mode") if tensor_id is None: tensor_id = -1 tensor_id = _execute.make_int(tensor_id, "tensor_id") _, _, _op, _outputs = _op_def_library._apply_op_helper( "DebugNumericSummaryV2", input=input, output_dtype=output_dtype, tensor_debug_mode=tensor_debug_mode, tensor_id=tensor_id, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("output_dtype", _op._get_attr_type("output_dtype"), "T", _op._get_attr_type("T"), "tensor_debug_mode", _op._get_attr_int("tensor_debug_mode"), "tensor_id", _op._get_attr_int("tensor_id")) _inputs_flat = _op.inputs _execute.record_gradient( "DebugNumericSummaryV2", _inputs_flat, _attrs, _result) _result, = _result return _result
def set_size(set_indices, set_values, set_shape, validate_indices=True, name=None): r"""Number of unique elements along last dimension of input `set`. Input `set` is a `SparseTensor` represented by `set_indices`, `set_values`, and `set_shape`. The last dimension contains values in a set, duplicates are allowed but ignored. If `validate_indices` is `True`, this op validates the order and range of `set` indices. Args: set_indices: A `Tensor` of type `int64`. 2D `Tensor`, indices of a `SparseTensor`. set_values: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `string`. 1D `Tensor`, values of a `SparseTensor`. set_shape: A `Tensor` of type `int64`. 1D `Tensor`, shape of a `SparseTensor`. validate_indices: An optional `bool`. Defaults to `True`. name: A name for the operation (optional). Returns: 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, "SetSize", name, set_indices, set_values, set_shape, "validate_indices", validate_indices) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return set_size_eager_fallback(set_indices, set_values, set_shape, validate_indices=validate_indices, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if validate_indices is None: validate_indices = True validate_indices = _execute.make_bool(validate_indices, "validate_indices") _, _, _op, _outputs = _op_def_library._apply_op_helper( "SetSize", set_indices=set_indices, set_values=set_values, set_shape=set_shape, validate_indices=validate_indices, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("validate_indices", _op._get_attr_bool("validate_indices"), "T", _op._get_attr_type("T")) _inputs_flat = _op.inputs _execute.record_gradient("SetSize", _inputs_flat, _attrs, _result) _result, = _result return _result
def audio_microfrontend(audio, sample_rate=16000, window_size=25, window_step=10, num_channels=32, upper_band_limit=7500, lower_band_limit=125, smoothing_bits=10, even_smoothing=0.025, odd_smoothing=0.06, min_signal_remaining=0.05, enable_pcan=False, pcan_strength=0.95, pcan_offset=80, gain_bits=21, enable_log=True, scale_shift=6, left_context=0, right_context=0, frame_stride=1, zero_padding=False, out_scale=1, out_type=_dtypes.uint16, name=None): r"""Audio Microfrontend Op. This Op converts a sequence of audio data into one or more feature vectors containing filterbanks of the input. The conversion process uses a lightweight library to perform: 1. A slicing window function 2. Short-time FFTs 3. Filterbank calculations 4. Noise reduction 5. PCAN Auto Gain Control 6. Logarithmic scaling Arguments audio: 1D Tensor, int16 audio data in temporal ordering. sample_rate: Integer, the sample rate of the audio in Hz. window_size: Integer, length of desired time frames in ms. window_step: Integer, length of step size for the next frame in ms. num_channels: Integer, the number of filterbank channels to use. upper_band_limit: Float, the highest frequency included in the filterbanks. lower_band_limit: Float, the lowest frequency included in the filterbanks. smoothing_bits: Int, scale up signal by 2^(smoothing_bits) before reduction. even_smoothing: Float, smoothing coefficient for even-numbered channels. odd_smoothing: Float, smoothing coefficient for odd-numbered channels. min_signal_remaining: Float, fraction of signal to preserve in smoothing. enable_pcan: Bool, enable PCAN auto gain control. pcan_strength: Float, gain normalization exponent. pcan_offset: Float, positive value added in the normalization denominator. gain_bits: Int, number of fractional bits in the gain. enable_log: Bool, enable logarithmic scaling of filterbanks. scale_shift: Integer, scale filterbanks by 2^(scale_shift). left_context: Integer, number of preceding frames to attach to each frame. right_context: Integer, number of preceding frames to attach to each frame. frame_stride: Integer, M frames to skip over, where output[n] = frame[n*M]. zero_padding: Bool, if left/right context is out-of-bounds, attach frame of zeroes. Otherwise, frame[0] or frame[size-1] will be copied. out_scale: Integer, divide all filterbanks by this number. out_type: DType, type of the output Tensor, defaults to UINT16. Returns filterbanks: 2D Tensor, each row is a time frame, each column is a channel. Args: audio: A `Tensor` of type `int16`. sample_rate: An optional `int`. Defaults to `16000`. window_size: An optional `int`. Defaults to `25`. window_step: An optional `int`. Defaults to `10`. num_channels: An optional `int`. Defaults to `32`. upper_band_limit: An optional `float`. Defaults to `7500`. lower_band_limit: An optional `float`. Defaults to `125`. smoothing_bits: An optional `int`. Defaults to `10`. even_smoothing: An optional `float`. Defaults to `0.025`. odd_smoothing: An optional `float`. Defaults to `0.06`. min_signal_remaining: An optional `float`. Defaults to `0.05`. enable_pcan: An optional `bool`. Defaults to `False`. pcan_strength: An optional `float`. Defaults to `0.95`. pcan_offset: An optional `float`. Defaults to `80`. gain_bits: An optional `int`. Defaults to `21`. enable_log: An optional `bool`. Defaults to `True`. scale_shift: An optional `int`. Defaults to `6`. left_context: An optional `int`. Defaults to `0`. right_context: An optional `int`. Defaults to `0`. frame_stride: An optional `int`. Defaults to `1`. zero_padding: An optional `bool`. Defaults to `False`. out_scale: An optional `int`. Defaults to `1`. out_type: An optional `tf.DType` from: `tf.uint16, tf.float32`. Defaults to `tf.uint16`. name: A name for the operation (optional). Returns: A `Tensor` of type `out_type`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "AudioMicrofrontend", name, audio, "sample_rate", sample_rate, "window_size", window_size, "window_step", window_step, "num_channels", num_channels, "upper_band_limit", upper_band_limit, "lower_band_limit", lower_band_limit, "smoothing_bits", smoothing_bits, "even_smoothing", even_smoothing, "odd_smoothing", odd_smoothing, "min_signal_remaining", min_signal_remaining, "enable_pcan", enable_pcan, "pcan_strength", pcan_strength, "pcan_offset", pcan_offset, "gain_bits", gain_bits, "enable_log", enable_log, "scale_shift", scale_shift, "left_context", left_context, "right_context", right_context, "frame_stride", frame_stride, "zero_padding", zero_padding, "out_scale", out_scale, "out_type", out_type) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return audio_microfrontend_eager_fallback( audio, sample_rate=sample_rate, window_size=window_size, window_step=window_step, num_channels=num_channels, upper_band_limit=upper_band_limit, lower_band_limit=lower_band_limit, smoothing_bits=smoothing_bits, even_smoothing=even_smoothing, odd_smoothing=odd_smoothing, min_signal_remaining=min_signal_remaining, enable_pcan=enable_pcan, pcan_strength=pcan_strength, pcan_offset=pcan_offset, gain_bits=gain_bits, enable_log=enable_log, scale_shift=scale_shift, left_context=left_context, right_context=right_context, frame_stride=frame_stride, zero_padding=zero_padding, out_scale=out_scale, out_type=out_type, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch( audio_microfrontend, (), dict(audio=audio, sample_rate=sample_rate, window_size=window_size, window_step=window_step, num_channels=num_channels, upper_band_limit=upper_band_limit, lower_band_limit=lower_band_limit, smoothing_bits=smoothing_bits, even_smoothing=even_smoothing, odd_smoothing=odd_smoothing, min_signal_remaining=min_signal_remaining, enable_pcan=enable_pcan, pcan_strength=pcan_strength, pcan_offset=pcan_offset, gain_bits=gain_bits, enable_log=enable_log, scale_shift=scale_shift, left_context=left_context, right_context=right_context, frame_stride=frame_stride, zero_padding=zero_padding, out_scale=out_scale, out_type=out_type, name=name)) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise # Add nodes to the TensorFlow graph. if sample_rate is None: sample_rate = 16000 sample_rate = _execute.make_int(sample_rate, "sample_rate") if window_size is None: window_size = 25 window_size = _execute.make_int(window_size, "window_size") if window_step is None: window_step = 10 window_step = _execute.make_int(window_step, "window_step") if num_channels is None: num_channels = 32 num_channels = _execute.make_int(num_channels, "num_channels") if upper_band_limit is None: upper_band_limit = 7500 upper_band_limit = _execute.make_float(upper_band_limit, "upper_band_limit") if lower_band_limit is None: lower_band_limit = 125 lower_band_limit = _execute.make_float(lower_band_limit, "lower_band_limit") if smoothing_bits is None: smoothing_bits = 10 smoothing_bits = _execute.make_int(smoothing_bits, "smoothing_bits") if even_smoothing is None: even_smoothing = 0.025 even_smoothing = _execute.make_float(even_smoothing, "even_smoothing") if odd_smoothing is None: odd_smoothing = 0.06 odd_smoothing = _execute.make_float(odd_smoothing, "odd_smoothing") if min_signal_remaining is None: min_signal_remaining = 0.05 min_signal_remaining = _execute.make_float(min_signal_remaining, "min_signal_remaining") if enable_pcan is None: enable_pcan = False enable_pcan = _execute.make_bool(enable_pcan, "enable_pcan") if pcan_strength is None: pcan_strength = 0.95 pcan_strength = _execute.make_float(pcan_strength, "pcan_strength") if pcan_offset is None: pcan_offset = 80 pcan_offset = _execute.make_float(pcan_offset, "pcan_offset") if gain_bits is None: gain_bits = 21 gain_bits = _execute.make_int(gain_bits, "gain_bits") if enable_log is None: enable_log = True enable_log = _execute.make_bool(enable_log, "enable_log") if scale_shift is None: scale_shift = 6 scale_shift = _execute.make_int(scale_shift, "scale_shift") if left_context is None: left_context = 0 left_context = _execute.make_int(left_context, "left_context") if right_context is None: right_context = 0 right_context = _execute.make_int(right_context, "right_context") if frame_stride is None: frame_stride = 1 frame_stride = _execute.make_int(frame_stride, "frame_stride") if zero_padding is None: zero_padding = False zero_padding = _execute.make_bool(zero_padding, "zero_padding") if out_scale is None: out_scale = 1 out_scale = _execute.make_int(out_scale, "out_scale") if out_type is None: out_type = _dtypes.uint16 out_type = _execute.make_type(out_type, "out_type") try: _, _, _op, _outputs = _op_def_library._apply_op_helper( "AudioMicrofrontend", audio=audio, sample_rate=sample_rate, window_size=window_size, window_step=window_step, num_channels=num_channels, upper_band_limit=upper_band_limit, lower_band_limit=lower_band_limit, smoothing_bits=smoothing_bits, even_smoothing=even_smoothing, odd_smoothing=odd_smoothing, min_signal_remaining=min_signal_remaining, enable_pcan=enable_pcan, pcan_strength=pcan_strength, pcan_offset=pcan_offset, gain_bits=gain_bits, enable_log=enable_log, scale_shift=scale_shift, left_context=left_context, right_context=right_context, frame_stride=frame_stride, zero_padding=zero_padding, out_scale=out_scale, out_type=out_type, name=name) except (TypeError, ValueError): result = _dispatch.dispatch( audio_microfrontend, (), dict(audio=audio, sample_rate=sample_rate, window_size=window_size, window_step=window_step, num_channels=num_channels, upper_band_limit=upper_band_limit, lower_band_limit=lower_band_limit, smoothing_bits=smoothing_bits, even_smoothing=even_smoothing, odd_smoothing=odd_smoothing, min_signal_remaining=min_signal_remaining, enable_pcan=enable_pcan, pcan_strength=pcan_strength, pcan_offset=pcan_offset, gain_bits=gain_bits, enable_log=enable_log, scale_shift=scale_shift, left_context=left_context, right_context=right_context, frame_stride=frame_stride, zero_padding=zero_padding, out_scale=out_scale, out_type=out_type, name=name)) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("sample_rate", _op._get_attr_int("sample_rate"), "window_size", _op._get_attr_int("window_size"), "window_step", _op._get_attr_int("window_step"), "num_channels", _op._get_attr_int("num_channels"), "upper_band_limit", _op.get_attr("upper_band_limit"), "lower_band_limit", _op.get_attr("lower_band_limit"), "smoothing_bits", _op._get_attr_int("smoothing_bits"), "even_smoothing", _op.get_attr("even_smoothing"), "odd_smoothing", _op.get_attr("odd_smoothing"), "min_signal_remaining", _op.get_attr("min_signal_remaining"), "enable_pcan", _op._get_attr_bool("enable_pcan"), "pcan_strength", _op.get_attr("pcan_strength"), "pcan_offset", _op.get_attr("pcan_offset"), "gain_bits", _op._get_attr_int("gain_bits"), "enable_log", _op._get_attr_bool("enable_log"), "scale_shift", _op._get_attr_int("scale_shift"), "left_context", _op._get_attr_int("left_context"), "right_context", _op._get_attr_int("right_context"), "frame_stride", _op._get_attr_int("frame_stride"), "zero_padding", _op._get_attr_bool("zero_padding"), "out_scale", _op._get_attr_int("out_scale"), "out_type", _op._get_attr_type("out_type")) _inputs_flat = _op.inputs _execute.record_gradient("AudioMicrofrontend", _inputs_flat, _attrs, _result) _result, = _result return _result
def trt_engine_op(in_tensor, serialized_segment, OutT, workspace_size_bytes, precision_mode, segment_func="", input_shapes=[], max_cached_engines_count=1, calibration_data="", use_calibration=True, segment_funcdef_name="", cached_engine_batches=[], fixed_input_size=True, output_shapes=[], static_engine=True, name=None): r"""TODO: add doc. Args: in_tensor: A list of `Tensor` objects with types from: `int8`, `half`, `float32`, `int32`. serialized_segment: A `string`. OutT: A list of `tf.DTypes` from: `tf.int8, tf.half, tf.float32, tf.int32` that has length `>= 1`. workspace_size_bytes: An `int`. precision_mode: A `string` from: `"FP32", "FP16", "INT8"`. segment_func: An optional function decorated with @Defun. Defaults to `""`. input_shapes: An optional list of shapes (each a `tf.TensorShape` or list of `ints`). Defaults to `[]`. max_cached_engines_count: An optional `int`. Defaults to `1`. calibration_data: An optional `string`. Defaults to `""`. use_calibration: An optional `bool`. Defaults to `True`. segment_funcdef_name: An optional `string`. Defaults to `""`. cached_engine_batches: An optional list of `ints`. Defaults to `[]`. fixed_input_size: An optional `bool`. Defaults to `True`. output_shapes: An optional list of shapes (each a `tf.TensorShape` or list of `ints`). Defaults to `[]`. static_engine: An optional `bool`. Defaults to `True`. name: A name for the operation (optional). Returns: A list of `Tensor` objects of type `OutT`. """ _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, "TRTEngineOp", name, tld.op_callbacks, in_tensor, "serialized_segment", serialized_segment, "segment_func", segment_func, "OutT", OutT, "input_shapes", input_shapes, "max_cached_engines_count", max_cached_engines_count, "workspace_size_bytes", workspace_size_bytes, "precision_mode", precision_mode, "calibration_data", calibration_data, "use_calibration", use_calibration, "segment_funcdef_name", segment_funcdef_name, "cached_engine_batches", cached_engine_batches, "fixed_input_size", fixed_input_size, "output_shapes", output_shapes, "static_engine", static_engine) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return trt_engine_op_eager_fallback( in_tensor, serialized_segment=serialized_segment, segment_func=segment_func, OutT=OutT, input_shapes=input_shapes, max_cached_engines_count=max_cached_engines_count, workspace_size_bytes=workspace_size_bytes, precision_mode=precision_mode, calibration_data=calibration_data, use_calibration=use_calibration, segment_funcdef_name=segment_funcdef_name, cached_engine_batches=cached_engine_batches, fixed_input_size=fixed_input_size, output_shapes=output_shapes, static_engine=static_engine, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch( trt_engine_op, (), dict(in_tensor=in_tensor, serialized_segment=serialized_segment, OutT=OutT, workspace_size_bytes=workspace_size_bytes, precision_mode=precision_mode, segment_func=segment_func, input_shapes=input_shapes, max_cached_engines_count=max_cached_engines_count, calibration_data=calibration_data, use_calibration=use_calibration, segment_funcdef_name=segment_funcdef_name, cached_engine_batches=cached_engine_batches, fixed_input_size=fixed_input_size, output_shapes=output_shapes, static_engine=static_engine, name=name)) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise # Add nodes to the TensorFlow graph. serialized_segment = _execute.make_str(serialized_segment, "serialized_segment") if not isinstance(OutT, (list, tuple)): raise TypeError("Expected list for 'OutT' argument to " "'trt_engine_op' Op, not %r." % OutT) OutT = [_execute.make_type(_t, "OutT") for _t in OutT] workspace_size_bytes = _execute.make_int(workspace_size_bytes, "workspace_size_bytes") precision_mode = _execute.make_str(precision_mode, "precision_mode") if segment_func is None: segment_func = "" if input_shapes is None: input_shapes = [] if not isinstance(input_shapes, (list, tuple)): raise TypeError("Expected list for 'input_shapes' argument to " "'trt_engine_op' Op, not %r." % input_shapes) input_shapes = [ _execute.make_shape(_s, "input_shapes") for _s in input_shapes ] if max_cached_engines_count is None: max_cached_engines_count = 1 max_cached_engines_count = _execute.make_int(max_cached_engines_count, "max_cached_engines_count") if calibration_data is None: calibration_data = "" calibration_data = _execute.make_str(calibration_data, "calibration_data") if use_calibration is None: use_calibration = True use_calibration = _execute.make_bool(use_calibration, "use_calibration") if segment_funcdef_name is None: segment_funcdef_name = "" segment_funcdef_name = _execute.make_str(segment_funcdef_name, "segment_funcdef_name") if cached_engine_batches is None: cached_engine_batches = [] if not isinstance(cached_engine_batches, (list, tuple)): raise TypeError( "Expected list for 'cached_engine_batches' argument to " "'trt_engine_op' Op, not %r." % cached_engine_batches) cached_engine_batches = [ _execute.make_int(_i, "cached_engine_batches") for _i in cached_engine_batches ] if fixed_input_size is None: fixed_input_size = True fixed_input_size = _execute.make_bool(fixed_input_size, "fixed_input_size") if output_shapes is None: output_shapes = [] if not isinstance(output_shapes, (list, tuple)): raise TypeError("Expected list for 'output_shapes' argument to " "'trt_engine_op' Op, not %r." % output_shapes) output_shapes = [ _execute.make_shape(_s, "output_shapes") for _s in output_shapes ] if static_engine is None: static_engine = True static_engine = _execute.make_bool(static_engine, "static_engine") try: _, _, _op, _outputs = _op_def_library._apply_op_helper( "TRTEngineOp", in_tensor=in_tensor, serialized_segment=serialized_segment, OutT=OutT, workspace_size_bytes=workspace_size_bytes, precision_mode=precision_mode, segment_func=segment_func, input_shapes=input_shapes, max_cached_engines_count=max_cached_engines_count, calibration_data=calibration_data, use_calibration=use_calibration, segment_funcdef_name=segment_funcdef_name, cached_engine_batches=cached_engine_batches, fixed_input_size=fixed_input_size, output_shapes=output_shapes, static_engine=static_engine, name=name) except (TypeError, ValueError): result = _dispatch.dispatch( trt_engine_op, (), dict(in_tensor=in_tensor, serialized_segment=serialized_segment, OutT=OutT, workspace_size_bytes=workspace_size_bytes, precision_mode=precision_mode, segment_func=segment_func, input_shapes=input_shapes, max_cached_engines_count=max_cached_engines_count, calibration_data=calibration_data, use_calibration=use_calibration, segment_funcdef_name=segment_funcdef_name, cached_engine_batches=cached_engine_batches, fixed_input_size=fixed_input_size, output_shapes=output_shapes, static_engine=static_engine, name=name)) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("serialized_segment", _op.get_attr("serialized_segment"), "segment_func", _op.get_attr("segment_func"), "InT", _op.get_attr("InT"), "OutT", _op.get_attr("OutT"), "input_shapes", _op.get_attr("input_shapes"), "max_cached_engines_count", _op._get_attr_int("max_cached_engines_count"), "workspace_size_bytes", _op._get_attr_int("workspace_size_bytes"), "precision_mode", _op.get_attr("precision_mode"), "calibration_data", _op.get_attr("calibration_data"), "use_calibration", _op._get_attr_bool("use_calibration"), "segment_funcdef_name", _op.get_attr("segment_funcdef_name"), "cached_engine_batches", _op.get_attr("cached_engine_batches"), "fixed_input_size", _op._get_attr_bool("fixed_input_size"), "output_shapes", _op.get_attr("output_shapes"), "static_engine", _op._get_attr_bool("static_engine")) _inputs_flat = _op.inputs _execute.record_gradient("TRTEngineOp", _inputs_flat, _attrs, _result) return _result
def debug_numeric_summary_v2(input, tensor_debug_mode=-1, tensor_id=-1, name=None): r"""Debug Numeric Summary V2 Op. Computes a numeric summary of the input tensor. The shape of the output depends on the tensor_debug_mode attribute. This op is used internally by TensorFlow Debugger (tfdbg) v2. Args: input: A `Tensor`. Input tensor, to be summarized by the op. tensor_debug_mode: An optional `int`. Defaults to `-1`. Tensor debug mode: the mode in which the input tensor is summarized by the op. See the TensorDebugMode enum in tensorflow/core/protobuf/debug_event.proto for details. Supported values: 8 (REDUCE_INF_NAN_THREE_SLOTS): Output a float32 tensor of shape [3]. The 1st element is -inf if any elements of the input tensor is -inf, or zero otherwise. The 2nd element is +inf if any elements of the input tensor is +inf, or zero otherwise. The 3rd element is nan if any element of the input tensor is nan, or zero otherwise tensor_id: An optional `int`. Defaults to `-1`. Optional. An integer identifier for the tensor being summarized by this op. name: A name for the operation (optional). Returns: A `Tensor` of type `float32`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "DebugNumericSummaryV2", name, tld.op_callbacks, input, "tensor_debug_mode", tensor_debug_mode, "tensor_id", tensor_id) return _result except _core._FallbackException: try: return debug_numeric_summary_v2_eager_fallback( input, tensor_debug_mode=tensor_debug_mode, tensor_id=tensor_id, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # Add nodes to the TensorFlow graph. if tensor_debug_mode is None: tensor_debug_mode = -1 tensor_debug_mode = _execute.make_int(tensor_debug_mode, "tensor_debug_mode") if tensor_id is None: tensor_id = -1 tensor_id = _execute.make_int(tensor_id, "tensor_id") _, _, _op, _outputs = _op_def_library._apply_op_helper( "DebugNumericSummaryV2", input=input, tensor_debug_mode=tensor_debug_mode, tensor_id=tensor_id, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("T", _op._get_attr_type("T"), "tensor_debug_mode", _op._get_attr_int("tensor_debug_mode"), "tensor_id", _op._get_attr_int("tensor_id")) _inputs_flat = _op.inputs _execute.record_gradient("DebugNumericSummaryV2", _inputs_flat, _attrs, _result) _result, = _result return _result
def serialize_trt_resource(resource_name, filename, delete_resource=False, name=None): r"""TODO: add doc. Args: resource_name: A `Tensor` of type `string`. filename: A `Tensor` of type `string`. delete_resource: An optional `bool`. Defaults to `False`. name: A name for the operation (optional). Returns: The created Operation. """ _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, "SerializeTRTResource", name, tld.op_callbacks, resource_name, filename, "delete_resource", delete_resource) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return serialize_trt_resource_eager_fallback( resource_name, filename, delete_resource=delete_resource, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch( serialize_trt_resource, (), dict(resource_name=resource_name, filename=filename, delete_resource=delete_resource, name=name)) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise # Add nodes to the TensorFlow graph. if delete_resource is None: delete_resource = False delete_resource = _execute.make_bool(delete_resource, "delete_resource") try: _, _, _op, _outputs = _op_def_library._apply_op_helper( "SerializeTRTResource", resource_name=resource_name, filename=filename, delete_resource=delete_resource, name=name) except (TypeError, ValueError): result = _dispatch.dispatch( serialize_trt_resource, (), dict(resource_name=resource_name, filename=filename, delete_resource=delete_resource, name=name)) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise return _op
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() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "NcclAllReduce", name, input, "reduction", reduction, "num_devices", num_devices, "shared_name", shared_name) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass 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. # 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, _outputs = _op_def_library._apply_op_helper( "NcclAllReduce", input=input, reduction=reduction, num_devices=num_devices, shared_name=shared_name, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("reduction", _op.get_attr("reduction"), "T", _op._get_attr_type("T"), "num_devices", _op._get_attr_int("num_devices"), "shared_name", _op.get_attr("shared_name")) _inputs_flat = _op.inputs _execute.record_gradient( "NcclAllReduce", _inputs_flat, _attrs, _result) _result, = _result return _result
def send(tensor, tensor_name, send_device, send_device_incarnation, recv_device, client_terminated=False, name=None): r"""Sends the named tensor from send_device to recv_device. Args: tensor: A `Tensor`. The tensor to send. tensor_name: A `string`. The name of the tensor to send. send_device: A `string`. The name of the device sending the tensor. send_device_incarnation: An `int`. The current incarnation of send_device. recv_device: A `string`. The name of the device receiving the tensor. client_terminated: An optional `bool`. Defaults to `False`. If set to true, this indicates that the node was added to the graph as a result of a client-side feed or fetch of Tensor data, in which case the corresponding send or recv is expected to be managed locally by the caller. name: A name for the operation (optional). Returns: The created Operation. """ _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, "Send", name, tld.op_callbacks, tensor, "tensor_name", tensor_name, "send_device", send_device, "send_device_incarnation", send_device_incarnation, "recv_device", recv_device, "client_terminated", client_terminated) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return send_eager_fallback( tensor, tensor_name=tensor_name, send_device=send_device, send_device_incarnation=send_device_incarnation, recv_device=recv_device, client_terminated=client_terminated, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. tensor_name = _execute.make_str(tensor_name, "tensor_name") send_device = _execute.make_str(send_device, "send_device") send_device_incarnation = _execute.make_int(send_device_incarnation, "send_device_incarnation") recv_device = _execute.make_str(recv_device, "recv_device") if client_terminated is None: client_terminated = False client_terminated = _execute.make_bool(client_terminated, "client_terminated") _, _, _op, _outputs = _op_def_library._apply_op_helper( "Send", tensor=tensor, tensor_name=tensor_name, send_device=send_device, send_device_incarnation=send_device_incarnation, recv_device=recv_device, client_terminated=client_terminated, name=name) return _op
def copy(input, tensor_name="", debug_ops_spec=[], name=None): r"""Copy a tensor from CPU-to-CPU or GPU-to-GPU. Performs CPU-to-CPU or GPU-to-GPU deep-copying of tensor, depending on the device on which the tensor is allocated. N.B.: If the all downstream attached debug ops are disabled given the current gRPC gating status, the output will simply forward the input tensor without deep-copying. See the documentation of Debug* ops for more details. Unlike the CopyHost Op, this op does not have HostMemory constraint on its input or output. Args: input: A `Tensor`. Input tensor. tensor_name: An optional `string`. Defaults to `""`. The name of the input tensor. debug_ops_spec: An optional list of `strings`. Defaults to `[]`. A list of debug op spec (op, url, gated_grpc) for attached debug ops. Each element of the list has the format <debug_op>;<grpc_url>;<gated_grpc>, wherein gated_grpc is boolean represented as 0/1. E.g., "DebugIdentity;grpc://foo:3333;1", "DebugIdentity;file:///tmp/tfdbg_1;0". name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "Copy", name, input, "tensor_name", tensor_name, "debug_ops_spec", debug_ops_spec) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return copy_eager_fallback( input, tensor_name=tensor_name, debug_ops_spec=debug_ops_spec, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if tensor_name is None: tensor_name = "" tensor_name = _execute.make_str(tensor_name, "tensor_name") if debug_ops_spec is None: debug_ops_spec = [] if not isinstance(debug_ops_spec, (list, tuple)): raise TypeError( "Expected list for 'debug_ops_spec' argument to " "'copy' Op, not %r." % debug_ops_spec) debug_ops_spec = [_execute.make_str(_s, "debug_ops_spec") for _s in debug_ops_spec] _, _, _op, _outputs = _op_def_library._apply_op_helper( "Copy", input=input, tensor_name=tensor_name, debug_ops_spec=debug_ops_spec, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("T", _op._get_attr_type("T"), "tensor_name", _op.get_attr("tensor_name"), "debug_ops_spec", _op.get_attr("debug_ops_spec")) _inputs_flat = _op.inputs _execute.record_gradient( "Copy", _inputs_flat, _attrs, _result) _result, = _result return _result
def sparse_to_sparse_set_operation(set1_indices, set1_values, set1_shape, set2_indices, set2_values, set2_shape, set_operation, validate_indices=True, name=None): r"""Applies set operation along last dimension of 2 `SparseTensor` inputs. See SetOperationOp::SetOperationFromContext for values of `set_operation`. If `validate_indices` is `True`, `SparseToSparseSetOperation` validates the order and range of `set1` and `set2` indices. Input `set1` is a `SparseTensor` represented by `set1_indices`, `set1_values`, and `set1_shape`. For `set1` ranked `n`, 1st `n-1` dimensions must be the same as `set2`. Dimension `n` contains values in a set, duplicates are allowed but ignored. Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`, and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same as `set1`. Dimension `n` contains values in a set, duplicates are allowed but ignored. If `validate_indices` is `True`, this op validates the order and range of `set1` and `set2` indices. Output `result` is a `SparseTensor` represented by `result_indices`, `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth` dimension contains the result of `set_operation` applied to the corresponding `[0...n-1]` dimension of `set`. Args: set1_indices: A `Tensor` of type `int64`. 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major order. set1_values: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `string`. 1D `Tensor`, values of a `SparseTensor`. Must be in row-major order. set1_shape: A `Tensor` of type `int64`. 1D `Tensor`, shape of a `SparseTensor`. `set1_shape[0...n-1]` must be the same as `set2_shape[0...n-1]`, `set1_shape[n]` is the max set size across `0...n-1` dimensions. set2_indices: A `Tensor` of type `int64`. 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major order. set2_values: A `Tensor`. Must have the same type as `set1_values`. 1D `Tensor`, values of a `SparseTensor`. Must be in row-major order. set2_shape: A `Tensor` of type `int64`. 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must be the same as `set1_shape[0...n-1]`, `set2_shape[n]` is the max set size across `0...n-1` dimensions. set_operation: A `string`. validate_indices: An optional `bool`. Defaults to `True`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (result_indices, result_values, result_shape). result_indices: A `Tensor` of type `int64`. result_values: A `Tensor`. Has the same type as `set1_values`. result_shape: A `Tensor` of type `int64`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "SparseToSparseSetOperation", name, tld.op_callbacks, set1_indices, set1_values, set1_shape, set2_indices, set2_values, set2_shape, "set_operation", set_operation, "validate_indices", validate_indices) _result = _SparseToSparseSetOperationOutput._make(_result) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return sparse_to_sparse_set_operation_eager_fallback( set1_indices, set1_values, set1_shape, set2_indices, set2_values, set2_shape, set_operation=set_operation, validate_indices=validate_indices, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. set_operation = _execute.make_str(set_operation, "set_operation") if validate_indices is None: validate_indices = True validate_indices = _execute.make_bool(validate_indices, "validate_indices") _, _, _op, _outputs = _op_def_library._apply_op_helper( "SparseToSparseSetOperation", set1_indices=set1_indices, set1_values=set1_values, set1_shape=set1_shape, set2_indices=set2_indices, set2_values=set2_values, set2_shape=set2_shape, set_operation=set_operation, validate_indices=validate_indices, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("set_operation", _op.get_attr("set_operation"), "validate_indices", _op._get_attr_bool("validate_indices"), "T", _op._get_attr_type("T")) _inputs_flat = _op.inputs _execute.record_gradient( "SparseToSparseSetOperation", _inputs_flat, _attrs, _result) _result = _SparseToSparseSetOperationOutput._make(_result) return _result
def debug_identity_v2(input, tfdbg_context_id="", op_name="", output_slot=-1, tensor_debug_mode=-1, debug_urls=[], circular_buffer_size=1000, tfdbg_run_id="", name=None): r"""Debug Identity V2 Op. Provides an identity mapping from input to output, while writing the content of the input tensor by calling DebugEventsWriter. The semantics of the input tensor depends on tensor_debug_mode. In typical usage, the input tensor comes directly from the user computation only when graph_debug_mode is FULL_TENSOR (see protobuf/debug_event.proto for a list of all the possible values of graph_debug_mode). For the other debug modes, the input tensor should be produced by an additional op or subgraph that computes summary information about one or more tensors. Args: input: A `Tensor`. Input tensor, non-Reference type tfdbg_context_id: An optional `string`. Defaults to `""`. A tfdbg-generated ID for the context that the op belongs to, e.g., a concrete compiled tf.function. op_name: An optional `string`. Defaults to `""`. Optional. Name of the op that the debug op is concerned with. Used only for single-tensor trace. output_slot: An optional `int`. Defaults to `-1`. Optional. Output slot index of the tensor that the debug op is concerned with. Used only for single-tensor trace. tensor_debug_mode: An optional `int`. Defaults to `-1`. TensorDebugMode enum value. See debug_event.proto for details. debug_urls: An optional list of `strings`. Defaults to `[]`. List of URLs to debug targets, e.g., file:///foo/tfdbg_dump. circular_buffer_size: An optional `int`. Defaults to `1000`. tfdbg_run_id: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "DebugIdentityV2", name, input, "tfdbg_context_id", tfdbg_context_id, "op_name", op_name, "output_slot", output_slot, "tensor_debug_mode", tensor_debug_mode, "debug_urls", debug_urls, "circular_buffer_size", circular_buffer_size, "tfdbg_run_id", tfdbg_run_id) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return debug_identity_v2_eager_fallback( input, tfdbg_context_id=tfdbg_context_id, op_name=op_name, output_slot=output_slot, tensor_debug_mode=tensor_debug_mode, debug_urls=debug_urls, circular_buffer_size=circular_buffer_size, tfdbg_run_id=tfdbg_run_id, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if tfdbg_context_id is None: tfdbg_context_id = "" tfdbg_context_id = _execute.make_str(tfdbg_context_id, "tfdbg_context_id") if op_name is None: op_name = "" op_name = _execute.make_str(op_name, "op_name") if output_slot is None: output_slot = -1 output_slot = _execute.make_int(output_slot, "output_slot") if tensor_debug_mode is None: tensor_debug_mode = -1 tensor_debug_mode = _execute.make_int(tensor_debug_mode, "tensor_debug_mode") if debug_urls is None: debug_urls = [] if not isinstance(debug_urls, (list, tuple)): raise TypeError( "Expected list for 'debug_urls' argument to " "'debug_identity_v2' Op, not %r." % debug_urls) debug_urls = [_execute.make_str(_s, "debug_urls") for _s in debug_urls] if circular_buffer_size is None: circular_buffer_size = 1000 circular_buffer_size = _execute.make_int(circular_buffer_size, "circular_buffer_size") if tfdbg_run_id is None: tfdbg_run_id = "" tfdbg_run_id = _execute.make_str(tfdbg_run_id, "tfdbg_run_id") _, _, _op, _outputs = _op_def_library._apply_op_helper( "DebugIdentityV2", input=input, tfdbg_context_id=tfdbg_context_id, op_name=op_name, output_slot=output_slot, tensor_debug_mode=tensor_debug_mode, debug_urls=debug_urls, circular_buffer_size=circular_buffer_size, tfdbg_run_id=tfdbg_run_id, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("T", _op._get_attr_type("T"), "tfdbg_context_id", _op.get_attr("tfdbg_context_id"), "op_name", _op.get_attr("op_name"), "output_slot", _op._get_attr_int("output_slot"), "tensor_debug_mode", _op._get_attr_int("tensor_debug_mode"), "debug_urls", _op.get_attr("debug_urls"), "circular_buffer_size", _op._get_attr_int("circular_buffer_size"), "tfdbg_run_id", _op.get_attr("tfdbg_run_id")) _inputs_flat = _op.inputs _execute.record_gradient( "DebugIdentityV2", _inputs_flat, _attrs, _result) _result, = _result return _result
def recv(tensor_type, tensor_name, send_device, send_device_incarnation, recv_device, client_terminated=False, name=None): r"""Receives the named tensor from send_device on recv_device. Args: tensor_type: A `tf.DType`. tensor_name: A `string`. The name of the tensor to receive. send_device: A `string`. The name of the device sending the tensor. send_device_incarnation: An `int`. The current incarnation of send_device. recv_device: A `string`. The name of the device receiving the tensor. client_terminated: An optional `bool`. Defaults to `False`. If set to true, this indicates that the node was added to the graph as a result of a client-side feed or fetch of Tensor data, in which case the corresponding send or recv is expected to be managed locally by the caller. name: A name for the operation (optional). Returns: A `Tensor` of type `tensor_type`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "Recv", name, tld.op_callbacks, "tensor_type", tensor_type, "tensor_name", tensor_name, "send_device", send_device, "send_device_incarnation", send_device_incarnation, "recv_device", recv_device, "client_terminated", client_terminated) return _result except _core._FallbackException: try: return recv_eager_fallback( tensor_type=tensor_type, tensor_name=tensor_name, send_device=send_device, send_device_incarnation=send_device_incarnation, recv_device=recv_device, client_terminated=client_terminated, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # Add nodes to the TensorFlow graph. tensor_type = _execute.make_type(tensor_type, "tensor_type") tensor_name = _execute.make_str(tensor_name, "tensor_name") send_device = _execute.make_str(send_device, "send_device") send_device_incarnation = _execute.make_int(send_device_incarnation, "send_device_incarnation") recv_device = _execute.make_str(recv_device, "recv_device") if client_terminated is None: client_terminated = False client_terminated = _execute.make_bool(client_terminated, "client_terminated") _, _, _op, _outputs = _op_def_library._apply_op_helper( "Recv", tensor_type=tensor_type, tensor_name=tensor_name, send_device=send_device, send_device_incarnation=send_device_incarnation, recv_device=recv_device, client_terminated=client_terminated, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("tensor_type", _op._get_attr_type("tensor_type"), "tensor_name", _op.get_attr("tensor_name"), "send_device", _op.get_attr("send_device"), "send_device_incarnation", _op._get_attr_int("send_device_incarnation"), "recv_device", _op.get_attr("recv_device"), "client_terminated", _op._get_attr_bool("client_terminated")) _inputs_flat = _op.inputs _execute.record_gradient("Recv", _inputs_flat, _attrs, _result) _result, = _result return _result
def debug_numeric_summary(input, device_name="", tensor_name="", debug_urls=[], lower_bound=float('-inf'), upper_bound=float('inf'), mute_if_healthy=False, gated_grpc=False, name=None): r"""Debug Numeric Summary Op. Provide a basic summary of numeric value types, range and distribution. output: A double tensor of shape [14 + nDimensions], where nDimensions is the number of dimensions of the tensor's shape. The elements of output are: [0]: is initialized (1.0) or not (0.0). [1]: total number of elements [2]: NaN element count [3]: generalized -inf count: elements <= lower_bound. lower_bound is -inf by default. [4]: negative element count (excluding -inf), if lower_bound is the default -inf. Otherwise, this is the count of elements > lower_bound and < 0. [5]: zero element count [6]: positive element count (excluding +inf), if upper_bound is the default +inf. Otherwise, this is the count of elements < upper_bound and > 0. [7]: generalized +inf count, elements >= upper_bound. upper_bound is +inf by default. Output elements [1:8] are all zero, if the tensor is uninitialized. [8]: minimum of all non-inf and non-NaN elements. If uninitialized or no such element exists: +inf. [9]: maximum of all non-inf and non-NaN elements. If uninitialized or no such element exists: -inf. [10]: mean of all non-inf and non-NaN elements. If uninitialized or no such element exists: NaN. [11]: variance of all non-inf and non-NaN elements. If uninitialized or no such element exists: NaN. [12]: Data type of the tensor encoded as an enum integer. See the DataType proto for more details. [13]: Number of dimensions of the tensor (ndims). [14+]: Sizes of the dimensions. Args: input: A `Tensor`. Input tensor, non-Reference type. device_name: An optional `string`. Defaults to `""`. tensor_name: An optional `string`. Defaults to `""`. Name of the input tensor. debug_urls: An optional list of `strings`. Defaults to `[]`. List of URLs to debug targets, e.g., file:///foo/tfdbg_dump, grpc:://localhost:11011. lower_bound: An optional `float`. Defaults to `float('-inf')`. (float) The lower bound <= which values will be included in the generalized -inf count. Default: -inf. upper_bound: An optional `float`. Defaults to `float('inf')`. (float) The upper bound >= which values will be included in the generalized +inf count. Default: +inf. mute_if_healthy: An optional `bool`. Defaults to `False`. (bool) Do not send data to the debug URLs unless at least one of elements [2], [3] and [7] (i.e., the nan count and the generalized -inf and inf counts) is non-zero. gated_grpc: An optional `bool`. Defaults to `False`. Whether this op will be gated. If any of the debug_urls of this debug node is of the grpc:// scheme, when the value of this attribute is set to True, the data will not actually be sent via the grpc stream unless this debug op has been enabled at the debug_url. If all of the debug_urls of this debug node are of the grpc:// scheme and the debug op is enabled at none of them, the output will be an empty Tensor. name: A name for the operation (optional). Returns: A `Tensor` of type `float64`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "DebugNumericSummary", name, input, "device_name", device_name, "tensor_name", tensor_name, "debug_urls", debug_urls, "lower_bound", lower_bound, "upper_bound", upper_bound, "mute_if_healthy", mute_if_healthy, "gated_grpc", gated_grpc) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return debug_numeric_summary_eager_fallback( input, device_name=device_name, tensor_name=tensor_name, debug_urls=debug_urls, lower_bound=lower_bound, upper_bound=upper_bound, mute_if_healthy=mute_if_healthy, gated_grpc=gated_grpc, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if device_name is None: device_name = "" device_name = _execute.make_str(device_name, "device_name") if tensor_name is None: tensor_name = "" tensor_name = _execute.make_str(tensor_name, "tensor_name") if debug_urls is None: debug_urls = [] if not isinstance(debug_urls, (list, tuple)): raise TypeError( "Expected list for 'debug_urls' argument to " "'debug_numeric_summary' Op, not %r." % debug_urls) debug_urls = [_execute.make_str(_s, "debug_urls") for _s in debug_urls] if lower_bound is None: lower_bound = float('-inf') lower_bound = _execute.make_float(lower_bound, "lower_bound") if upper_bound is None: upper_bound = float('inf') upper_bound = _execute.make_float(upper_bound, "upper_bound") if mute_if_healthy is None: mute_if_healthy = False mute_if_healthy = _execute.make_bool(mute_if_healthy, "mute_if_healthy") if gated_grpc is None: gated_grpc = False gated_grpc = _execute.make_bool(gated_grpc, "gated_grpc") _, _, _op, _outputs = _op_def_library._apply_op_helper( "DebugNumericSummary", input=input, device_name=device_name, tensor_name=tensor_name, debug_urls=debug_urls, lower_bound=lower_bound, upper_bound=upper_bound, mute_if_healthy=mute_if_healthy, gated_grpc=gated_grpc, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("T", _op._get_attr_type("T"), "device_name", _op.get_attr("device_name"), "tensor_name", _op.get_attr("tensor_name"), "debug_urls", _op.get_attr("debug_urls"), "lower_bound", _op.get_attr("lower_bound"), "upper_bound", _op.get_attr("upper_bound"), "mute_if_healthy", _op._get_attr_bool("mute_if_healthy"), "gated_grpc", _op._get_attr_bool("gated_grpc")) _inputs_flat = _op.inputs _execute.record_gradient( "DebugNumericSummary", _inputs_flat, _attrs, _result) _result, = _result return _result
def stateful_random_binomial(resource, algorithm, shape, counts, probs, dtype=_dtypes.int64, name=None): r"""TODO: add doc. Args: resource: A `Tensor` of type `resource`. algorithm: A `Tensor` of type `int64`. shape: A `Tensor`. Must be one of the following types: `int32`, `int64`. counts: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`. probs: A `Tensor`. Must have the same type as `counts`. 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 or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatefulRandomBinomial", name, resource, algorithm, shape, counts, probs, "dtype", dtype) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateful_random_binomial_eager_fallback(resource, algorithm, shape, counts, probs, dtype=dtype, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if dtype is None: dtype = _dtypes.int64 dtype = _execute.make_type(dtype, "dtype") _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatefulRandomBinomial", resource=resource, algorithm=algorithm, shape=shape, counts=counts, probs=probs, dtype=dtype, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("S", _op._get_attr_type("S"), "T", _op._get_attr_type("T"), "dtype", _op._get_attr_type("dtype")) _inputs_flat = _op.inputs _execute.record_gradient("StatefulRandomBinomial", _inputs_flat, _attrs, _result) _result, = _result return _result
def xla_launch(constants, args, resources, Tresults, function, name=None): r"""XLA Launch Op. For use by the XLA JIT only. Args: constants: A list of `Tensor` objects. args: A list of `Tensor` objects. resources: A list of `Tensor` objects with type `resource`. Tresults: A list of `tf.DTypes`. function: A function decorated with @Defun. name: A name for the operation (optional). Returns: A list of `Tensor` objects of type `Tresults`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "XlaLaunch", name, constants, args, resources, "Tresults", Tresults, "function", function) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return xla_launch_eager_fallback(constants, args, resources, Tresults=Tresults, function=function, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch( xla_launch, (), dict(constants=constants, args=args, resources=resources, Tresults=Tresults, function=function, name=name)) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise # Add nodes to the TensorFlow graph. if not isinstance(resources, (list, tuple)): raise TypeError("Expected list for 'resources' argument to " "'xla_launch' Op, not %r." % resources) _attr_Nresources = len(resources) if not isinstance(Tresults, (list, tuple)): raise TypeError("Expected list for 'Tresults' argument to " "'xla_launch' Op, not %r." % Tresults) Tresults = [_execute.make_type(_t, "Tresults") for _t in Tresults] try: _, _, _op, _outputs = _op_def_library._apply_op_helper( "XlaLaunch", constants=constants, args=args, resources=resources, Tresults=Tresults, function=function, name=name) except (TypeError, ValueError): result = _dispatch.dispatch( xla_launch, (), dict(constants=constants, args=args, resources=resources, Tresults=Tresults, function=function, name=name)) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise _result = _outputs[:] if not _result: return _op if _execute.must_record_gradient(): _attrs = ("Tconstants", _op.get_attr("Tconstants"), "Targs", _op.get_attr("Targs"), "Nresources", _op._get_attr_int("Nresources"), "Tresults", _op.get_attr("Tresults"), "function", _op.get_attr("function")) _inputs_flat = _op.inputs _execute.record_gradient("XlaLaunch", _inputs_flat, _attrs, _result) return _result
def stateful_truncated_normal(resource, algorithm, shape, dtype=_dtypes.float32, name=None): r"""Outputs random values from a truncated normal distribution. The generated values follow a normal distribution with mean 0 and standard deviation 1, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked. Args: resource: A `Tensor` of type `resource`. The handle of the resource variable that stores the state of the RNG. algorithm: A `Tensor` of type `int64`. The RNG algorithm. shape: A `Tensor`. The shape of the output tensor. dtype: An optional `tf.DType`. Defaults to `tf.float32`. The type of the output. name: A name for the operation (optional). Returns: A `Tensor` of type `dtype`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatefulTruncatedNormal", name, resource, algorithm, shape, "dtype", dtype) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateful_truncated_normal_eager_fallback(resource, algorithm, shape, dtype=dtype, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if dtype is None: dtype = _dtypes.float32 dtype = _execute.make_type(dtype, "dtype") _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatefulTruncatedNormal", resource=resource, algorithm=algorithm, shape=shape, dtype=dtype, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("dtype", _op._get_attr_type("dtype"), "shape_dtype", _op._get_attr_type("shape_dtype")) _inputs_flat = _op.inputs _execute.record_gradient("StatefulTruncatedNormal", _inputs_flat, _attrs, _result) _result, = _result return _result
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`. ids: A `Tensor` of type `int64`. weights: A `Tensor` of type `float32`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "ComputeAccidentalHits", name, true_classes, sampled_candidates, "num_true", num_true, "seed", seed, "seed2", seed2) _result = _ComputeAccidentalHitsOutput._make(_result) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return compute_accidental_hits_eager_fallback(true_classes, sampled_candidates, num_true=num_true, seed=seed, seed2=seed2, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. 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") _, _, _op, _outputs = _op_def_library._apply_op_helper( "ComputeAccidentalHits", true_classes=true_classes, sampled_candidates=sampled_candidates, num_true=num_true, seed=seed, seed2=seed2, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("num_true", _op._get_attr_int("num_true"), "seed", _op._get_attr_int("seed"), "seed2", _op._get_attr_int("seed2")) _inputs_flat = _op.inputs _execute.record_gradient("ComputeAccidentalHits", _inputs_flat, _attrs, _result) _result = _ComputeAccidentalHitsOutput._make(_result) return _result
def stateful_uniform_full_int(resource, algorithm, shape, dtype=_dtypes.uint64, name=None): r"""Outputs random integers from a uniform distribution. The generated values are uniform integers covering the whole range of `dtype`. Args: resource: A `Tensor` of type `resource`. The handle of the resource variable that stores the state of the RNG. algorithm: A `Tensor` of type `int64`. The RNG algorithm. shape: A `Tensor`. The shape of the output tensor. dtype: An optional `tf.DType`. Defaults to `tf.uint64`. The type of the output. name: A name for the operation (optional). Returns: A `Tensor` of type `dtype`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatefulUniformFullInt", name, resource, algorithm, shape, "dtype", dtype) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateful_uniform_full_int_eager_fallback(resource, algorithm, shape, dtype=dtype, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if dtype is None: dtype = _dtypes.uint64 dtype = _execute.make_type(dtype, "dtype") _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatefulUniformFullInt", resource=resource, algorithm=algorithm, shape=shape, dtype=dtype, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("dtype", _op._get_attr_type("dtype"), "shape_dtype", _op._get_attr_type("shape_dtype")) _inputs_flat = _op.inputs _execute.record_gradient("StatefulUniformFullInt", _inputs_flat, _attrs, _result) _result, = _result return _result
def thread_unsafe_unigram_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 learned unigram 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`. true_expected_count: A `Tensor` of type `float32`. sampled_expected_count: A `Tensor` of type `float32`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "ThreadUnsafeUnigramCandidateSampler", name, true_classes, "num_true", num_true, "num_sampled", num_sampled, "unique", unique, "range_max", range_max, "seed", seed, "seed2", seed2) _result = _ThreadUnsafeUnigramCandidateSamplerOutput._make(_result) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return thread_unsafe_unigram_candidate_sampler_eager_fallback( true_classes, num_true=num_true, num_sampled=num_sampled, unique=unique, range_max=range_max, seed=seed, seed2=seed2, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. 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") _, _, _op, _outputs = _op_def_library._apply_op_helper( "ThreadUnsafeUnigramCandidateSampler", 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 = _outputs[:] if _execute.must_record_gradient(): _attrs = ("num_true", _op._get_attr_int("num_true"), "num_sampled", _op._get_attr_int("num_sampled"), "unique", _op._get_attr_bool("unique"), "range_max", _op._get_attr_int("range_max"), "seed", _op._get_attr_int("seed"), "seed2", _op._get_attr_int("seed2")) _inputs_flat = _op.inputs _execute.record_gradient("ThreadUnsafeUnigramCandidateSampler", _inputs_flat, _attrs, _result) _result = _ThreadUnsafeUnigramCandidateSamplerOutput._make(_result) return _result
def stateful_uniform_int(resource, algorithm, shape, minval, maxval, 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: resource: A `Tensor` of type `resource`. The handle of the resource variable that stores the state of the RNG. algorithm: A `Tensor` of type `int64`. The RNG algorithm. shape: A `Tensor`. The shape of the output tensor. minval: A `Tensor`. Minimum value (inclusive, scalar). maxval: A `Tensor`. Must have the same type as `minval`. Maximum value (exclusive, scalar). name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `minval`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatefulUniformInt", name, resource, algorithm, shape, minval, maxval) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateful_uniform_int_eager_fallback(resource, algorithm, shape, minval, maxval, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatefulUniformInt", resource=resource, algorithm=algorithm, shape=shape, minval=minval, maxval=maxval, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("dtype", _op._get_attr_type("dtype"), "shape_dtype", _op._get_attr_type("shape_dtype")) _inputs_flat = _op.inputs _execute.record_gradient("StatefulUniformInt", _inputs_flat, _attrs, _result) _result, = _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 or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "LoadAndRemapMatrix", name, 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._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: 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._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. 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, _outputs = _op_def_library._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 = _outputs[:] if _execute.must_record_gradient(): _attrs = ("num_rows", _op._get_attr_int("num_rows"), "num_cols", _op._get_attr_int("num_cols"), "max_rows_in_memory", _op._get_attr_int("max_rows_in_memory")) _inputs_flat = _op.inputs _execute.record_gradient("LoadAndRemapMatrix", _inputs_flat, _attrs, _result) _result, = _result return _result
def eager_py_func(input, token, Tout, is_async=False, name=None): r"""Eagerly executes a python function to compute func(input)->output. The semantics of the input, output, and attributes are the same as those for PyFunc. Args: input: A list of `Tensor` objects. token: A `string`. Tout: A list of `tf.DTypes`. is_async: An optional `bool`. Defaults to `False`. name: A name for the operation (optional). Returns: A list of `Tensor` objects of type `Tout`. """ _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, "EagerPyFunc", name, tld.op_callbacks, input, "token", token, "is_async", is_async, "Tout", Tout) return _result except _core._FallbackException: try: return eager_py_func_eager_fallback(input, token=token, is_async=is_async, Tout=Tout, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # Add nodes to the TensorFlow graph. token = _execute.make_str(token, "token") if not isinstance(Tout, (list, tuple)): raise TypeError("Expected list for 'Tout' argument to " "'eager_py_func' Op, not %r." % Tout) Tout = [_execute.make_type(_t, "Tout") for _t in Tout] if is_async is None: is_async = False is_async = _execute.make_bool(is_async, "is_async") _, _, _op, _outputs = _op_def_library._apply_op_helper("EagerPyFunc", input=input, token=token, Tout=Tout, is_async=is_async, name=name) _result = _outputs[:] if not _result: return _op if _execute.must_record_gradient(): _attrs = ("token", _op.get_attr("token"), "is_async", _op._get_attr_bool("is_async"), "Tin", _op.get_attr("Tin"), "Tout", _op.get_attr("Tout")) _inputs_flat = _op.inputs _execute.record_gradient("EagerPyFunc", _inputs_flat, _attrs, _result) return _result
def roll(input, shift, axis, name=None): r"""Rolls the elements of a tensor along an axis. The elements are shifted positively (towards larger indices) by the offset of `shift` along the dimension of `axis`. Negative `shift` values will shift elements in the opposite direction. Elements that roll passed the last position will wrap around to the first and vice versa. Multiple shifts along multiple axes may be specified. For example: ``` # 't' is [0, 1, 2, 3, 4] roll(t, shift=2, axis=0) ==> [3, 4, 0, 1, 2] # shifting along multiple dimensions # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]] roll(t, shift=[1, -2], axis=[0, 1]) ==> [[7, 8, 9, 5, 6], [2, 3, 4, 0, 1]] # shifting along the same axis multiple times # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]] roll(t, shift=[2, -3], axis=[1, 1]) ==> [[1, 2, 3, 4, 0], [6, 7, 8, 9, 5]] ``` Args: input: A `Tensor`. shift: A `Tensor`. Must be one of the following types: `int32`, `int64`. Dimension must be 0-D or 1-D. `shift[i]` specifies the number of places by which elements are shifted positively (towards larger indices) along the dimension specified by `axis[i]`. Negative shifts will roll the elements in the opposite direction. axis: A `Tensor`. Must be one of the following types: `int32`, `int64`. Dimension must be 0-D or 1-D. `axis[i]` specifies the dimension that the shift `shift[i]` should occur. If the same axis is referenced more than once, the total shift for that axis will be the sum of all the shifts that belong to that axis. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "Roll", name, tld.op_callbacks, input, shift, axis) return _result except _core._FallbackException: try: return roll_eager_fallback(input, shift, axis, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # Add nodes to the TensorFlow graph. _, _, _op, _outputs = _op_def_library._apply_op_helper("Roll", input=input, shift=shift, axis=axis, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("T", _op._get_attr_type("T"), "Tshift", _op._get_attr_type("Tshift"), "Taxis", _op._get_attr_type("Taxis")) _inputs_flat = _op.inputs _execute.record_gradient("Roll", _inputs_flat, _attrs, _result) _result, = _result return _result
def ragged_tensor_to_tensor(shape, values, default_value, row_partition_tensors, row_partition_types, name=None): r"""Create a dense tensor from a ragged tensor, possibly altering its shape. The `ragged_to_dense` op creates a dense tensor from a list of row partition tensors, a value vector, and default values. If the shape is unspecified, the minimal shape required to contain all the elements in the ragged tensor (the natural shape) will be used. If some dimensions are left unspecified, then the size of the natural shape is used in that dimension. The default_value will be broadcast to the output shape. After that, the values from the ragged tensor overwrite the default values. Note that the default_value must have less dimensions than the value. The row partition tensors are in the order of the dimensions. At present, the types can be: * "ROW_SPLITS": the row_splits tensor from the ragged tensor. * "VALUE_ROWIDS": the value_rowids tensor from the ragged tensor. * "FIRST_DIM_SIZE": if value_rowids is used for the first dimension, then it is preceded by "FIRST_DIM_SIZE". Args: shape: A `Tensor`. Must be one of the following types: `int64`, `int32`. The desired shape of the the output tensor. If left unspecified (empty), the minimal shape required to contain all the elements in the ragged tensor (the natural shape) will be used. If some dimensions are left unspecified, then the size of the natural shape is used in that dimension. Note that dense dimensions cannot be modified by the shape argument. Trying to change the size of a dense dimension will cause the op to fail. Examples: natural shape: [4, 5, 6] shape: -1 output shape: [4, 5, 6] natural shape: [4, 5, 6] shape: [3, -1, 2] output shape: [3, 5, 2] natural shape: [4, 5, 6] shape: [3, 7, 2] output shape: [3, 7, 2] values: A `Tensor`. A 1D tensor representing the values of the ragged tensor. default_value: A `Tensor`. Must have the same type as `values`. The default_value when the shape is larger than the ragged tensor. The default_value is broadcast until it is the shape of the output tensor, and then overwritten by values in the ragged tensor. The default value must be compatible with this broadcast operation, and must have fewer dimensions than the value tensor. row_partition_tensors: A list of at least 1 `Tensor` objects with the same type in: `int64`, `int32`. row_partition_types: A list of `strings`. The types of the row partition tensors. At present, these can be: * "ROW_SPLITS": the row_splits tensor from the ragged tensor. * "VALUE_ROWIDS": the value_rowids tensor from the ragged tensor. * "FIRST_DIM_SIZE": if value_rowids is used for the first dimension, then it is preceeded by "FIRST_DIM_SIZE". The tensors are in the order of the dimensions. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `values`. """ _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, "RaggedTensorToTensor", name, tld.op_callbacks, shape, values, default_value, row_partition_tensors, "row_partition_types", row_partition_types) return _result except _core._FallbackException: try: return ragged_tensor_to_tensor_eager_fallback( shape, values, default_value, row_partition_tensors, row_partition_types=row_partition_types, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # Add nodes to the TensorFlow graph. if not isinstance(row_partition_tensors, (list, tuple)): raise TypeError( "Expected list for 'row_partition_tensors' argument to " "'ragged_tensor_to_tensor' Op, not %r." % row_partition_tensors) _attr_num_row_partition_tensors = len(row_partition_tensors) if not isinstance(row_partition_types, (list, tuple)): raise TypeError("Expected list for 'row_partition_types' argument to " "'ragged_tensor_to_tensor' Op, not %r." % row_partition_types) row_partition_types = [ _execute.make_str(_s, "row_partition_types") for _s in row_partition_types ] _, _, _op, _outputs = _op_def_library._apply_op_helper( "RaggedTensorToTensor", shape=shape, values=values, default_value=default_value, row_partition_tensors=row_partition_tensors, row_partition_types=row_partition_types, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("T", _op._get_attr_type("T"), "Tindex", _op._get_attr_type("Tindex"), "Tshape", _op._get_attr_type("Tshape"), "num_row_partition_tensors", _op._get_attr_int("num_row_partition_tensors"), "row_partition_types", _op.get_attr("row_partition_types")) _inputs_flat = _op.inputs _execute.record_gradient("RaggedTensorToTensor", _inputs_flat, _attrs, _result) _result, = _result return _result