def lstm_block_cell_grad(x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, cs_grad, h_grad, use_peephole, name=None): r"""Computes the LSTM cell backward propagation for 1 timestep. This implementation is to be used in conjunction of LSTMBlockCell. Args: x: A `Tensor`. Must be one of the following types: `half`, `float32`. The input to the LSTM cell, shape (batch_size, num_inputs). cs_prev: A `Tensor`. Must have the same type as `x`. The previous cell state. h_prev: A `Tensor`. Must have the same type as `x`. The previous h state. w: A `Tensor`. Must have the same type as `x`. The weight matrix. wci: A `Tensor`. Must have the same type as `x`. The weight matrix for input gate peephole connection. wcf: A `Tensor`. Must have the same type as `x`. The weight matrix for forget gate peephole connection. wco: A `Tensor`. Must have the same type as `x`. The weight matrix for output gate peephole connection. b: A `Tensor`. Must have the same type as `x`. The bias vector. i: A `Tensor`. Must have the same type as `x`. The input gate. cs: A `Tensor`. Must have the same type as `x`. The cell state before the tanh. f: A `Tensor`. Must have the same type as `x`. The forget gate. o: A `Tensor`. Must have the same type as `x`. The output gate. ci: A `Tensor`. Must have the same type as `x`. The cell input. co: A `Tensor`. Must have the same type as `x`. The cell after the tanh. cs_grad: A `Tensor`. Must have the same type as `x`. The current gradient of cs. h_grad: A `Tensor`. Must have the same type as `x`. The gradient of h vector. use_peephole: A `bool`. Whether the cell uses peephole connections. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (cs_prev_grad, dicfo, wci_grad, wcf_grad, wco_grad). cs_prev_grad: A `Tensor`. Has the same type as `x`. dicfo: A `Tensor`. Has the same type as `x`. wci_grad: A `Tensor`. Has the same type as `x`. wcf_grad: A `Tensor`. Has the same type as `x`. wco_grad: A `Tensor`. Has the same type as `x`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "LSTMBlockCellGrad", name, tld.op_callbacks, x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, cs_grad, h_grad, "use_peephole", use_peephole) _result = _LSTMBlockCellGradOutput._make(_result) return _result except _core._FallbackException: try: return lstm_block_cell_grad_eager_fallback( x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, cs_grad, h_grad, use_peephole=use_peephole, 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. use_peephole = _execute.make_bool(use_peephole, "use_peephole") _, _, _op, _outputs = _op_def_library._apply_op_helper( "LSTMBlockCellGrad", x=x, cs_prev=cs_prev, h_prev=h_prev, w=w, wci=wci, wcf=wcf, wco=wco, b=b, i=i, cs=cs, f=f, o=o, ci=ci, co=co, cs_grad=cs_grad, h_grad=h_grad, use_peephole=use_peephole, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("use_peephole", _op._get_attr_bool("use_peephole"), "T", _op._get_attr_type("T")) _inputs_flat = _op.inputs _execute.record_gradient( "LSTMBlockCellGrad", _inputs_flat, _attrs, _result) _result = _LSTMBlockCellGradOutput._make(_result) return _result
def generate_vocab_remapping(new_vocab_file, old_vocab_file, new_vocab_offset, num_new_vocab, old_vocab_size=-1, name=None): r"""Given a path to new and old vocabulary files, returns a remapping Tensor of length `num_new_vocab`, where `remapping[i]` contains the row number in the old vocabulary that corresponds to row `i` in the new vocabulary (starting at line `new_vocab_offset` and up to `num_new_vocab` entities), or `-1` if entry `i` in the new vocabulary is not in the old vocabulary. The old vocabulary is constrained to the first `old_vocab_size` entries if `old_vocab_size` is not the default value of -1. `num_vocab_offset` enables use in the partitioned variable case, and should generally be set through examining partitioning info. The format of the files should be a text file, with each line containing a single entity within the vocabulary. For example, with `new_vocab_file` a text file containing each of the following elements on a single line: `[f0, f1, f2, f3]`, old_vocab_file = [f1, f0, f3], `num_new_vocab = 3, new_vocab_offset = 1`, the returned remapping would be `[0, -1, 2]`. The op also returns a count of how many entries in the new vocabulary were present in the old vocabulary, which is used to calculate the number of values to initialize in a weight matrix remapping This functionality can be used to remap both row vocabularies (typically, features) and column vocabularies (typically, classes) from TensorFlow checkpoints. Note that the partitioning logic relies on contiguous vocabularies corresponding to div-partitioned variables. Moreover, the underlying remapping uses an IndexTable (as opposed to an inexact CuckooTable), so client code should use the corresponding index_table_from_file() as the FeatureColumn framework does (as opposed to tf.feature_to_id(), which uses a CuckooTable). Args: new_vocab_file: A `Tensor` of type `string`. Path to the new vocab file. old_vocab_file: A `Tensor` of type `string`. Path to the old vocab file. new_vocab_offset: An `int` that is `>= 0`. How many entries into the new vocab file to start reading. num_new_vocab: An `int` that is `>= 0`. Number of entries in the new vocab file to remap. old_vocab_size: An optional `int` that is `>= -1`. Defaults to `-1`. Number of entries in the old vocab file to consider. If -1, use the entire old vocabulary. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (remapping, num_present). remapping: A `Tensor` of type `int64`. num_present: A `Tensor` of type `int32`. """ _ctx = _context._context 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, "GenerateVocabRemapping", name, tld.op_callbacks, new_vocab_file, old_vocab_file, "new_vocab_offset", new_vocab_offset, "num_new_vocab", num_new_vocab, "old_vocab_size", old_vocab_size) _result = _GenerateVocabRemappingOutput._make(_result) return _result except _core._FallbackException: 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. except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # 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 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_tfe.TFE_Py_FastPathExecute( _ctx, "Roll", name, input, shift, axis) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return roll_eager_fallback(input, shift, axis, 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("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 encode_wav(audio, sample_rate, name=None): r"""Encode audio data using the WAV file format. This operation will generate a string suitable to be saved out to create a .wav audio file. It will be encoded in the 16-bit PCM format. It takes in float values in the range -1.0f to 1.0f, and any outside that value will be clamped to that range. `audio` is a 2-D float Tensor of shape `[length, channels]`. `sample_rate` is a scalar Tensor holding the rate to use (e.g. 44100). Args: audio: A `Tensor` of type `float32`. 2-D with shape `[length, channels]`. sample_rate: A `Tensor` of type `int32`. Scalar containing the sample frequency. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. """ _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, "EncodeWav", name, tld.op_callbacks, audio, sample_rate) return _result except _core._FallbackException: try: return encode_wav_eager_fallback(audio, sample_rate, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch(encode_wav, audio=audio, sample_rate=sample_rate, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # Add nodes to the TensorFlow graph. try: _, _, _op, _outputs = _op_def_library._apply_op_helper( "EncodeWav", audio=audio, sample_rate=sample_rate, name=name) except (TypeError, ValueError): result = _dispatch.dispatch(encode_wav, audio=audio, sample_rate=sample_rate, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise _result = _outputs[:] if _execute.must_record_gradient(): _attrs = () _inputs_flat = _op.inputs _execute.record_gradient("EncodeWav", _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_tensorflow.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._FallbackException: try: return enter_eager_fallback( data, frame_name=frame_name, is_constant=is_constant, parallel_iterations=parallel_iterations, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # 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 ragged_tensor_from_variant(encoded_ragged, input_ragged_rank, output_ragged_rank, Tvalues, Tsplits=_dtypes.int64, name=None): r"""Decodes a `variant` Tensor into a `RaggedTensor`. Decodes the given `variant` Tensor and returns a `RaggedTensor`. The input could be a scalar, meaning it encodes a single `RaggedTensor` with ragged_rank `output_ragged_rank`. It could also have an arbitrary rank, in which case each element is decoded into a `RaggedTensor` with ragged_rank `input_ragged_rank` and these are then stacked according to the input shape to output a single `RaggedTensor` with ragged_rank `output_ragged_rank`. Each `variant` element in the input Tensor is decoded by retrieving from the element a 1-D `variant` Tensor with `input_ragged_rank + 1` Tensors, corresponding to the splits and values of the decoded `RaggedTensor`. If `input_ragged_rank` is -1, then it is inferred as `output_ragged_rank` - `rank(encoded_ragged)`. See `RaggedTensorToVariant` for the corresponding encoding logic. Args: encoded_ragged: A `Tensor` of type `variant`. A `variant` Tensor containing encoded `RaggedTensor`s. input_ragged_rank: An `int` that is `>= -1`. The ragged rank of each encoded `RaggedTensor` component in the input. If set to -1, this is inferred as `output_ragged_rank` - `rank(encoded_ragged)` output_ragged_rank: An `int` that is `>= 0`. The expected ragged rank of the output `RaggedTensor`. The following must hold: `output_ragged_rank = rank(encoded_ragged) + input_ragged_rank`. Tvalues: A `tf.DType`. Tsplits: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int64`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_nested_splits, output_dense_values). output_nested_splits: A list of `output_ragged_rank` `Tensor` objects with type `Tsplits`. output_dense_values: A `Tensor` of type `Tvalues`. """ _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, "RaggedTensorFromVariant", name, tld.op_callbacks, encoded_ragged, "input_ragged_rank", input_ragged_rank, "output_ragged_rank", output_ragged_rank, "Tvalues", Tvalues, "Tsplits", Tsplits) _result = _RaggedTensorFromVariantOutput._make(_result) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return ragged_tensor_from_variant_eager_fallback( encoded_ragged, input_ragged_rank=input_ragged_rank, output_ragged_rank=output_ragged_rank, Tvalues=Tvalues, Tsplits=Tsplits, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. input_ragged_rank = _execute.make_int(input_ragged_rank, "input_ragged_rank") output_ragged_rank = _execute.make_int(output_ragged_rank, "output_ragged_rank") Tvalues = _execute.make_type(Tvalues, "Tvalues") if Tsplits is None: Tsplits = _dtypes.int64 Tsplits = _execute.make_type(Tsplits, "Tsplits") _, _, _op, _outputs = _op_def_library._apply_op_helper( "RaggedTensorFromVariant", encoded_ragged=encoded_ragged, input_ragged_rank=input_ragged_rank, output_ragged_rank=output_ragged_rank, Tvalues=Tvalues, Tsplits=Tsplits, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("input_ragged_rank", _op._get_attr_int("input_ragged_rank"), "output_ragged_rank", _op._get_attr_int("output_ragged_rank"), "Tvalues", _op._get_attr_type("Tvalues"), "Tsplits", _op._get_attr_type("Tsplits")) _inputs_flat = _op.inputs _execute.record_gradient( "RaggedTensorFromVariant", _inputs_flat, _attrs, _result) _result = [_result[:output_ragged_rank]] + _result[output_ragged_rank:] _result = _RaggedTensorFromVariantOutput._make(_result) return _result
def decode_wav(contents, desired_channels=-1, desired_samples=-1, name=None): r"""Decode a 16-bit PCM WAV file to a float tensor. The -32768 to 32767 signed 16-bit values will be scaled to -1.0 to 1.0 in float. When desired_channels is set, if the input contains fewer channels than this then the last channel will be duplicated to give the requested number, else if the input has more channels than requested then the additional channels will be ignored. If desired_samples is set, then the audio will be cropped or padded with zeroes to the requested length. The first output contains a Tensor with the content of the audio samples. The lowest dimension will be the number of channels, and the second will be the number of samples. For example, a ten-sample-long stereo WAV file should give an output shape of [10, 2]. Args: contents: A `Tensor` of type `string`. The WAV-encoded audio, usually from a file. desired_channels: An optional `int`. Defaults to `-1`. Number of sample channels wanted. desired_samples: An optional `int`. Defaults to `-1`. Length of audio requested. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (audio, sample_rate). audio: A `Tensor` of type `float32`. sample_rate: A `Tensor` of type `int32`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "DecodeWav", name, tld.op_callbacks, contents, "desired_channels", desired_channels, "desired_samples", desired_samples) _result = _DecodeWavOutput._make(_result) return _result except _core._FallbackException: try: return decode_wav_eager_fallback( contents, desired_channels=desired_channels, desired_samples=desired_samples, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch(decode_wav, contents=contents, desired_channels=desired_channels, desired_samples=desired_samples, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # Add nodes to the TensorFlow graph. if desired_channels is None: desired_channels = -1 desired_channels = _execute.make_int(desired_channels, "desired_channels") if desired_samples is None: desired_samples = -1 desired_samples = _execute.make_int(desired_samples, "desired_samples") try: _, _, _op, _outputs = _op_def_library._apply_op_helper( "DecodeWav", contents=contents, desired_channels=desired_channels, desired_samples=desired_samples, name=name) except (TypeError, ValueError): result = _dispatch.dispatch(decode_wav, contents=contents, desired_channels=desired_channels, desired_samples=desired_samples, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("desired_channels", _op._get_attr_int("desired_channels"), "desired_samples", _op._get_attr_int("desired_samples")) _inputs_flat = _op.inputs _execute.record_gradient("DecodeWav", _inputs_flat, _attrs, _result) _result = _DecodeWavOutput._make(_result) return _result
def stateful_partitioned_call(args, Tout, f, config="", config_proto="", executor_type="", name=None): r"""returns `f(inputs)`, where `f`'s body is placed and partitioned. Args: args: A list of `Tensor` objects. A list of input tensors. Tout: A list of `tf.DTypes`. A list of output types. f: A function decorated with @Defun. A function that takes 'args', a list of tensors, and returns 'output', another list of tensors. Input and output types are specified by 'Tin' and 'Tout'. The function body of f will be placed and partitioned across devices, setting this op apart from the regular Call op. This op is stateful. config: An optional `string`. Defaults to `""`. config_proto: An optional `string`. Defaults to `""`. executor_type: An optional `string`. Defaults to `""`. 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_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "StatefulPartitionedCall", name, tld.op_callbacks, args, "Tout", Tout, "f", f, "config", config, "config_proto", config_proto, "executor_type", executor_type) return _result except _core._FallbackException: try: return stateful_partitioned_call_eager_fallback( args, Tout=Tout, f=f, config=config, config_proto=config_proto, executor_type=executor_type, 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(Tout, (list, tuple)): raise TypeError( "Expected list for 'Tout' argument to " "'stateful_partitioned_call' Op, not %r." % Tout) Tout = [_execute.make_type(_t, "Tout") for _t in Tout] if config is None: config = "" config = _execute.make_str(config, "config") if config_proto is None: config_proto = "" config_proto = _execute.make_str(config_proto, "config_proto") if executor_type is None: executor_type = "" executor_type = _execute.make_str(executor_type, "executor_type") _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatefulPartitionedCall", args=args, Tout=Tout, f=f, config=config, config_proto=config_proto, executor_type=executor_type, name=name) _result = _outputs[:] if not _result: return _op if _execute.must_record_gradient(): _attrs = ("Tin", _op.get_attr("Tin"), "Tout", _op.get_attr("Tout"), "f", _op.get_attr("f"), "config", _op.get_attr("config"), "config_proto", _op.get_attr("config_proto"), "executor_type", _op.get_attr("executor_type")) _inputs_flat = _op.inputs _execute.record_gradient( "StatefulPartitionedCall", _inputs_flat, _attrs, _result) return _result
def stateless_if(cond, input, Tout, then_branch, else_branch, output_shapes=[], name=None): r"""output = cond ? then_branch(input) : else_branch(input) Args: cond: A `Tensor`. A Tensor. If the tensor is a scalar of non-boolean type, the scalar is converted to a boolean according to the following rule: if the scalar is a numerical value, non-zero means `True` and zero means False; if the scalar is a string, non-empty means `True` and empty means `False`. If the tensor is not a scalar, being empty means False and being non-empty means True. This should only be used when the if then/else body functions do not have stateful ops. input: A list of `Tensor` objects. A list of input tensors. Tout: A list of `tf.DTypes`. A list of output types. then_branch: A function decorated with @Defun. A function that takes 'inputs' and returns a list of tensors, whose types are the same as what else_branch returns. else_branch: A function decorated with @Defun. A function that takes 'inputs' and returns a list of tensors, whose types are the same as what then_branch returns. output_shapes: An optional list of shapes (each a `tf.TensorShape` or list of `ints`). Defaults to `[]`. 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_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "StatelessIf", name, tld.op_callbacks, cond, input, "Tout", Tout, "then_branch", then_branch, "else_branch", else_branch, "output_shapes", output_shapes) return _result except _core._FallbackException: try: return stateless_if_eager_fallback( cond, input, Tout=Tout, then_branch=then_branch, else_branch=else_branch, output_shapes=output_shapes, 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(Tout, (list, tuple)): raise TypeError( "Expected list for 'Tout' argument to " "'stateless_if' Op, not %r." % Tout) Tout = [_execute.make_type(_t, "Tout") for _t in Tout] if output_shapes is None: output_shapes = [] if not isinstance(output_shapes, (list, tuple)): raise TypeError( "Expected list for 'output_shapes' argument to " "'stateless_if' Op, not %r." % output_shapes) output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatelessIf", cond=cond, input=input, Tout=Tout, then_branch=then_branch, else_branch=else_branch, output_shapes=output_shapes, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("Tcond", _op._get_attr_type("Tcond"), "Tin", _op.get_attr("Tin"), "Tout", _op.get_attr("Tout"), "then_branch", _op.get_attr("then_branch"), "else_branch", _op.get_attr("else_branch"), "output_shapes", _op.get_attr("output_shapes")) _inputs_flat = _op.inputs _execute.record_gradient( "StatelessIf", _inputs_flat, _attrs, _result) return _result
def nccl_all_reduce(input, reduction, num_devices, shared_name, name=None): r"""Outputs a tensor containing the reduction across all input tensors. Outputs a tensor containing the reduction across all input tensors passed to ops within the same `shared_name. The graph should be constructed so if one op runs with shared_name value `c`, then `num_devices` ops will run with shared_name value `c`. Failure to do so will cause the graph execution to fail to complete. input: the input to the reduction data: the value of the reduction across all `num_devices` devices. reduction: the reduction operation to perform. num_devices: The number of devices participating in this reduction. shared_name: Identifier that shared between ops of the same reduction. Args: input: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`. reduction: A `string` from: `"min", "max", "prod", "sum"`. num_devices: An `int`. shared_name: A `string`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "NcclAllReduce", name, tld.op_callbacks, input, "reduction", reduction, "num_devices", num_devices, "shared_name", shared_name) return _result except _core._FallbackException: try: return nccl_all_reduce_eager_fallback(input, reduction=reduction, num_devices=num_devices, shared_name=shared_name, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # 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 case(branch_index, input, Tout, branches, output_shapes=[], name=None): r"""An n-way switch statement which calls a single branch function. An n-way switch statement, implementing the following: ``` switch (branch_index) { case 0: output = branches[0](input); break; case 1: output = branches[1](input); break; ... case [[nbranches-1]]: default: output = branches[nbranches-1](input); break; } ``` Args: branch_index: A `Tensor` of type `int32`. The branch selector, an int32 Tensor. input: A list of `Tensor` objects. A list of input tensors passed to the branch function. Tout: A list of `tf.DTypes`. A list of output types. branches: A list of functions decorated with @Defun that has length `>= 1`. A list of functions each of which takes 'inputs' and returns a list of tensors, whose types are the same as what every other branch returns. output_shapes: An optional list of shapes (each a `tf.TensorShape` or list of `ints`). Defaults to `[]`. 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_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "Case", name, tld.op_callbacks, branch_index, input, "Tout", Tout, "branches", branches, "output_shapes", output_shapes) return _result except _core._FallbackException: try: return case_eager_fallback( branch_index, input, Tout=Tout, branches=branches, output_shapes=output_shapes, 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(Tout, (list, tuple)): raise TypeError( "Expected list for 'Tout' argument to " "'case' Op, not %r." % Tout) Tout = [_execute.make_type(_t, "Tout") for _t in Tout] if not isinstance(branches, (list, tuple)): raise TypeError( "Expected list for 'branches' argument to " "'case' Op, not %r." % branches) if output_shapes is None: output_shapes = [] if not isinstance(output_shapes, (list, tuple)): raise TypeError( "Expected list for 'output_shapes' argument to " "'case' Op, not %r." % output_shapes) output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] _, _, _op, _outputs = _op_def_library._apply_op_helper( "Case", branch_index=branch_index, input=input, Tout=Tout, branches=branches, output_shapes=output_shapes, name=name) _result = _outputs[:] if not _result: return _op if _execute.must_record_gradient(): _attrs = ("Tin", _op.get_attr("Tin"), "Tout", _op.get_attr("Tout"), "branches", _op.get_attr("branches"), "output_shapes", _op.get_attr("output_shapes")) _inputs_flat = _op.inputs _execute.record_gradient( "Case", _inputs_flat, _attrs, _result) return _result
def decode_proto_v2(bytes, message_type, field_names, output_types, descriptor_source="local://", message_format="binary", sanitize=False, name=None): r"""The op extracts fields from a serialized protocol buffers message into tensors. The `decode_proto` op extracts fields from a serialized protocol buffers message into tensors. The fields in `field_names` are decoded and converted to the corresponding `output_types` if possible. A `message_type` name must be provided to give context for the field names. The actual message descriptor can be looked up either in the linked-in descriptor pool or a filename provided by the caller using the `descriptor_source` attribute. Each output tensor is a dense tensor. This means that it is padded to hold the largest number of repeated elements seen in the input minibatch. (The shape is also padded by one to prevent zero-sized dimensions). The actual repeat counts for each example in the minibatch can be found in the `sizes` output. In many cases the output of `decode_proto` is fed immediately into tf.squeeze if missing values are not a concern. When using tf.squeeze, always pass the squeeze dimension explicitly to avoid surprises. For the most part, the mapping between Proto field types and TensorFlow dtypes is straightforward. However, there are a few special cases: - A proto field that contains a submessage or group can only be converted to `DT_STRING` (the serialized submessage). This is to reduce the complexity of the API. The resulting string can be used as input to another instance of the decode_proto op. - TensorFlow lacks support for unsigned integers. The ops represent uint64 types as a `DT_INT64` with the same twos-complement bit pattern (the obvious way). Unsigned int32 values can be represented exactly by specifying type `DT_INT64`, or using twos-complement if the caller specifies `DT_INT32` in the `output_types` attribute. Both binary and text proto serializations are supported, and can be chosen using the `format` attribute. The `descriptor_source` attribute selects the source of protocol descriptors to consult when looking up `message_type`. This may be: - An empty string or "local://", in which case protocol descriptors are created for C++ (not Python) proto definitions linked to the binary. - A file, in which case protocol descriptors are created from the file, which is expected to contain a `FileDescriptorSet` serialized as a string. NOTE: You can build a `descriptor_source` file using the `--descriptor_set_out` and `--include_imports` options to the protocol compiler `protoc`. - A "bytes://<bytes>", in which protocol descriptors are created from `<bytes>`, which is expected to be a `FileDescriptorSet` serialized as a string. Args: bytes: A `Tensor` of type `string`. Tensor of serialized protos with shape `batch_shape`. message_type: A `string`. Name of the proto message type to decode. field_names: A list of `strings`. List of strings containing proto field names. An extension field can be decoded by using its full name, e.g. EXT_PACKAGE.EXT_FIELD_NAME. output_types: A list of `tf.DTypes`. List of TF types to use for the respective field in field_names. descriptor_source: An optional `string`. Defaults to `"local://"`. Either the special value `local://` or a path to a file containing a serialized `FileDescriptorSet`. message_format: An optional `string`. Defaults to `"binary"`. Either `binary` or `text`. sanitize: An optional `bool`. Defaults to `False`. Whether to sanitize the result or not. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (sizes, values). sizes: A `Tensor` of type `int32`. values: A list of `Tensor` objects of type `output_types`. """ _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, "DecodeProtoV2", name, tld.op_callbacks, bytes, "message_type", message_type, "field_names", field_names, "output_types", output_types, "descriptor_source", descriptor_source, "message_format", message_format, "sanitize", sanitize) _result = _DecodeProtoV2Output._make(_result) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return decode_proto_v2_eager_fallback( bytes, message_type=message_type, field_names=field_names, output_types=output_types, descriptor_source=descriptor_source, message_format=message_format, sanitize=sanitize, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. message_type = _execute.make_str(message_type, "message_type") if not isinstance(field_names, (list, tuple)): raise TypeError("Expected list for 'field_names' argument to " "'decode_proto_v2' Op, not %r." % field_names) field_names = [_execute.make_str(_s, "field_names") for _s in field_names] if not isinstance(output_types, (list, tuple)): raise TypeError("Expected list for 'output_types' argument to " "'decode_proto_v2' Op, not %r." % output_types) output_types = [ _execute.make_type(_t, "output_types") for _t in output_types ] if descriptor_source is None: descriptor_source = "local://" descriptor_source = _execute.make_str(descriptor_source, "descriptor_source") if message_format is None: message_format = "binary" message_format = _execute.make_str(message_format, "message_format") if sanitize is None: sanitize = False sanitize = _execute.make_bool(sanitize, "sanitize") _, _, _op, _outputs = _op_def_library._apply_op_helper( "DecodeProtoV2", bytes=bytes, message_type=message_type, field_names=field_names, output_types=output_types, descriptor_source=descriptor_source, message_format=message_format, sanitize=sanitize, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("message_type", _op.get_attr("message_type"), "field_names", _op.get_attr("field_names"), "output_types", _op.get_attr("output_types"), "descriptor_source", _op.get_attr("descriptor_source"), "message_format", _op.get_attr("message_format"), "sanitize", _op._get_attr_bool("sanitize")) _inputs_flat = _op.inputs _execute.record_gradient("DecodeProtoV2", _inputs_flat, _attrs, _result) _result = _result[:1] + [_result[1:]] _result = _DecodeProtoV2Output._make(_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._FallbackException: 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, 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 except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # 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, 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 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._FallbackException: 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, resource_name=resource_name, filename=filename, delete_resource=delete_resource, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # 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, 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 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._context_handle, tld.device_name, "XlaLaunch", name, tld.op_callbacks, 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 symbolic_gradient(input, Tout, f, name=None): r"""Computes the gradient function for function f via backpropagation. Args: input: A list of `Tensor` objects. a list of input tensors of size N + M; Tout: A list of `tf.DTypes` that has length `>= 1`. the type list for the input list. f: A function decorated with @Defun. The function we want to compute the gradient for. The function 'f' must be a numerical function which takes N inputs and produces M outputs. Its gradient function 'g', which is computed by this SymbolicGradient op is a function taking N + M inputs and produces N outputs. I.e. if we have (y1, y2, ..., y_M) = f(x1, x2, ..., x_N), then, g is (dL/dx1, dL/dx2, ..., dL/dx_N) = g(x1, x2, ..., x_N, dL/dy1, dL/dy2, ..., dL/dy_M), where L is a scalar-value function of (x1, x2, ..., xN) (e.g., the loss function). dL/dx_i is the partial derivative of L with respect to x_i. (Needs some math expert to say the comment above better.) 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_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "SymbolicGradient", name, tld.op_callbacks, input, "Tout", Tout, "f", f) return _result except _core._FallbackException: try: return symbolic_gradient_eager_fallback( input, Tout=Tout, f=f, 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(Tout, (list, tuple)): raise TypeError( "Expected list for 'Tout' argument to " "'symbolic_gradient' Op, not %r." % Tout) Tout = [_execute.make_type(_t, "Tout") for _t in Tout] _, _, _op, _outputs = _op_def_library._apply_op_helper( "SymbolicGradient", input=input, Tout=Tout, f=f, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("Tin", _op.get_attr("Tin"), "Tout", _op.get_attr("Tout"), "f", _op.get_attr("f")) _inputs_flat = _op.inputs _execute.record_gradient( "SymbolicGradient", _inputs_flat, _attrs, _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._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass 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. # 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
def _while(input, cond, body, output_shapes=[], parallel_iterations=10, name=None): r"""output = input; While (Cond(output)) { output = Body(output) } Args: input: A list of `Tensor` objects. A list of input tensors whose types are T. cond: A function decorated with @Defun. A function takes 'input' and returns a tensor. If the tensor is a scalar of non-boolean, the scalar is converted to a boolean according to the following rule: if the scalar is a numerical value, non-zero means True and zero means False; if the scalar is a string, non-empty means True and empty means False. If the tensor is not a scalar, non-emptiness means True and False otherwise. body: A function decorated with @Defun. A function that takes a list of tensors and returns another list of tensors. Both lists have the same types as specified by T. output_shapes: An optional list of shapes (each a `tf.TensorShape` or list of `ints`). Defaults to `[]`. parallel_iterations: An optional `int`. Defaults to `10`. name: A name for the operation (optional). Returns: A list of `Tensor` objects. 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, "While", name, tld.op_callbacks, input, "cond", cond, "body", body, "output_shapes", output_shapes, "parallel_iterations", parallel_iterations) return _result except _core._FallbackException: try: return _while_eager_fallback( input, cond=cond, body=body, output_shapes=output_shapes, parallel_iterations=parallel_iterations, 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 output_shapes is None: output_shapes = [] if not isinstance(output_shapes, (list, tuple)): raise TypeError( "Expected list for 'output_shapes' argument to " "'while' Op, not %r." % output_shapes) output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 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( "While", input=input, cond=cond, body=body, output_shapes=output_shapes, parallel_iterations=parallel_iterations, name=name) _result = _outputs[:] if not _result: return _op if _execute.must_record_gradient(): _attrs = ("T", _op.get_attr("T"), "cond", _op.get_attr("cond"), "body", _op.get_attr("body"), "output_shapes", _op.get_attr("output_shapes"), "parallel_iterations", _op._get_attr_int("parallel_iterations")) _inputs_flat = _op.inputs _execute.record_gradient( "While", _inputs_flat, _attrs, _result) return _result
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._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass 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. # 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 image_summary( tag, tensor, max_images=3, bad_color=_execute. make_tensor( """dtype: DT_UINT8 tensor_shape { dim { size: 4 } } int_val: 255 int_val: 0 int_val: 0 int_val: 255""", "bad_color"), name=None): r"""Outputs a `Summary` protocol buffer with images. The summary has up to `max_images` summary values containing images. The images are built from `tensor` which must be 4-D with shape `[batch_size, height, width, channels]` and where `channels` can be: * 1: `tensor` is interpreted as Grayscale. * 3: `tensor` is interpreted as RGB. * 4: `tensor` is interpreted as RGBA. The images have the same number of channels as the input tensor. For float input, the values are normalized one image at a time to fit in the range `[0, 255]`. `uint8` values are unchanged. The op uses two different normalization algorithms: * If the input values are all positive, they are rescaled so the largest one is 255. * If any input value is negative, the values are shifted so input value 0.0 is at 127. They are then rescaled so that either the smallest value is 0, or the largest one is 255. The `tag` argument is a scalar `Tensor` of type `string`. It is used to build the `tag` of the summary values: * If `max_images` is 1, the summary value tag is '*tag*/image'. * If `max_images` is greater than 1, the summary value tags are generated sequentially as '*tag*/image/0', '*tag*/image/1', etc. The `bad_color` argument is the color to use in the generated images for non-finite input values. It is a `uint8` 1-D tensor of length `channels`. Each element must be in the range `[0, 255]` (It represents the value of a pixel in the output image). Non-finite values in the input tensor are replaced by this tensor in the output image. The default value is the color red. Args: tag: A `Tensor` of type `string`. Scalar. Used to build the `tag` attribute of the summary values. tensor: A `Tensor`. Must be one of the following types: `uint8`, `float32`, `half`, `float64`. 4-D of shape `[batch_size, height, width, channels]` where `channels` is 1, 3, or 4. max_images: An optional `int` that is `>= 1`. Defaults to `3`. Max number of batch elements to generate images for. bad_color: An optional `tf.TensorProto`. Defaults to `dtype: DT_UINT8 tensor_shape { dim { size: 4 } } int_val: 255 int_val: 0 int_val: 0 int_val: 255`. Color to use for pixels with non-finite values. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "ImageSummary", name, tag, tensor, "max_images", max_images, "bad_color", bad_color) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return image_summary_eager_fallback(tag, tensor, max_images=max_images, bad_color=bad_color, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if max_images is None: max_images = 3 max_images = _execute.make_int(max_images, "max_images") if bad_color is None: bad_color = _execute.make_tensor( """dtype: DT_UINT8 tensor_shape { dim { size: 4 } } int_val: 255 int_val: 0 int_val: 0 int_val: 255""", "bad_color") bad_color = _execute.make_tensor(bad_color, "bad_color") _, _, _op, _outputs = _op_def_library._apply_op_helper( "ImageSummary", tag=tag, tensor=tensor, max_images=max_images, bad_color=bad_color, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("max_images", _op._get_attr_int("max_images"), "T", _op._get_attr_type("T"), "bad_color", _op.get_attr("bad_color")) _inputs_flat = _op.inputs _execute.record_gradient("ImageSummary", _inputs_flat, _attrs, _result) _result, = _result return _result
def audio_spectrogram(input, window_size, stride, magnitude_squared=False, name=None): r"""Produces a visualization of audio data over time. Spectrograms are a standard way of representing audio information as a series of slices of frequency information, one slice for each window of time. By joining these together into a sequence, they form a distinctive fingerprint of the sound over time. This op expects to receive audio data as an input, stored as floats in the range -1 to 1, together with a window width in samples, and a stride specifying how far to move the window between slices. From this it generates a three dimensional output. The first dimension is for the channels in the input, so a stereo audio input would have two here for example. The second dimension is time, with successive frequency slices. The third dimension has an amplitude value for each frequency during that time slice. This means the layout when converted and saved as an image is rotated 90 degrees clockwise from a typical spectrogram. Time is descending down the Y axis, and the frequency decreases from left to right. Each value in the result represents the square root of the sum of the real and imaginary parts of an FFT on the current window of samples. In this way, the lowest dimension represents the power of each frequency in the current window, and adjacent windows are concatenated in the next dimension. To get a more intuitive and visual look at what this operation does, you can run tensorflow/examples/wav_to_spectrogram to read in an audio file and save out the resulting spectrogram as a PNG image. Args: input: A `Tensor` of type `float32`. Float representation of audio data. window_size: An `int`. How wide the input window is in samples. For the highest efficiency this should be a power of two, but other values are accepted. stride: An `int`. How widely apart the center of adjacent sample windows should be. magnitude_squared: An optional `bool`. Defaults to `False`. Whether to return the squared magnitude or just the magnitude. Using squared magnitude can avoid extra calculations. name: A name for the operation (optional). Returns: A `Tensor` of type `float32`. """ _ctx = _context._context 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, "AudioSpectrogram", name, tld.op_callbacks, input, "window_size", window_size, "stride", stride, "magnitude_squared", magnitude_squared) return _result except _core._FallbackException: try: return audio_spectrogram_eager_fallback( input, window_size=window_size, stride=stride, magnitude_squared=magnitude_squared, 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. window_size = _execute.make_int(window_size, "window_size") stride = _execute.make_int(stride, "stride") if magnitude_squared is None: magnitude_squared = False magnitude_squared = _execute.make_bool(magnitude_squared, "magnitude_squared") _, _, _op, _outputs = _op_def_library._apply_op_helper( "AudioSpectrogram", input=input, window_size=window_size, stride=stride, magnitude_squared=magnitude_squared, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("window_size", _op._get_attr_int("window_size"), "stride", _op._get_attr_int("stride"), "magnitude_squared", _op._get_attr_bool("magnitude_squared")) _inputs_flat = _op.inputs _execute.record_gradient("AudioSpectrogram", _inputs_flat, _attrs, _result) _result, = _result return _result
def _print(input, data, message="", first_n=-1, summarize=3, name=None): r"""Prints a list of tensors. Passes `input` through to `output` and prints `data` when evaluating. Args: input: A `Tensor`. The tensor passed to `output` data: A list of `Tensor` objects. A list of tensors to print out when op is evaluated. message: An optional `string`. Defaults to `""`. A string, prefix of the error message. first_n: An optional `int`. Defaults to `-1`. Only log `first_n` number of times. -1 disables logging. summarize: An optional `int`. Defaults to `3`. Only print this many entries of each tensor. 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, "Print", name, input, data, "message", message, "first_n", first_n, "summarize", summarize) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return _print_eager_fallback(input, data, message=message, first_n=first_n, summarize=summarize, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if message is None: message = "" message = _execute.make_str(message, "message") if first_n is None: first_n = -1 first_n = _execute.make_int(first_n, "first_n") if summarize is None: summarize = 3 summarize = _execute.make_int(summarize, "summarize") _, _, _op, _outputs = _op_def_library._apply_op_helper("Print", input=input, data=data, message=message, first_n=first_n, summarize=summarize, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("T", _op._get_attr_type("T"), "U", _op.get_attr("U"), "message", _op.get_attr("message"), "first_n", _op._get_attr_int("first_n"), "summarize", _op._get_attr_int("summarize")) _inputs_flat = _op.inputs _execute.record_gradient("Print", _inputs_flat, _attrs, _result) _result, = _result return _result
def mfcc(spectrogram, sample_rate, upper_frequency_limit=4000, lower_frequency_limit=20, filterbank_channel_count=40, dct_coefficient_count=13, name=None): r"""Transforms a spectrogram into a form that's useful for speech recognition. Mel Frequency Cepstral Coefficients are a way of representing audio data that's been effective as an input feature for machine learning. They are created by taking the spectrum of a spectrogram (a 'cepstrum'), and discarding some of the higher frequencies that are less significant to the human ear. They have a long history in the speech recognition world, and https://en.wikipedia.org/wiki/Mel-frequency_cepstrum is a good resource to learn more. Args: spectrogram: A `Tensor` of type `float32`. Typically produced by the Spectrogram op, with magnitude_squared set to true. sample_rate: A `Tensor` of type `int32`. How many samples per second the source audio used. upper_frequency_limit: An optional `float`. Defaults to `4000`. The highest frequency to use when calculating the ceptstrum. lower_frequency_limit: An optional `float`. Defaults to `20`. The lowest frequency to use when calculating the ceptstrum. filterbank_channel_count: An optional `int`. Defaults to `40`. Resolution of the Mel bank used internally. dct_coefficient_count: An optional `int`. Defaults to `13`. How many output channels to produce per time slice. name: A name for the operation (optional). Returns: A `Tensor` of type `float32`. """ _ctx = _context._context 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, "Mfcc", name, tld.op_callbacks, spectrogram, sample_rate, "upper_frequency_limit", upper_frequency_limit, "lower_frequency_limit", lower_frequency_limit, "filterbank_channel_count", filterbank_channel_count, "dct_coefficient_count", dct_coefficient_count) return _result except _core._FallbackException: try: return mfcc_eager_fallback( spectrogram, sample_rate, upper_frequency_limit=upper_frequency_limit, lower_frequency_limit=lower_frequency_limit, filterbank_channel_count=filterbank_channel_count, dct_coefficient_count=dct_coefficient_count, name=name, 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 upper_frequency_limit is None: upper_frequency_limit = 4000 upper_frequency_limit = _execute.make_float(upper_frequency_limit, "upper_frequency_limit") if lower_frequency_limit is None: lower_frequency_limit = 20 lower_frequency_limit = _execute.make_float(lower_frequency_limit, "lower_frequency_limit") if filterbank_channel_count is None: filterbank_channel_count = 40 filterbank_channel_count = _execute.make_int(filterbank_channel_count, "filterbank_channel_count") if dct_coefficient_count is None: dct_coefficient_count = 13 dct_coefficient_count = _execute.make_int(dct_coefficient_count, "dct_coefficient_count") _, _, _op, _outputs = _op_def_library._apply_op_helper( "Mfcc", spectrogram=spectrogram, sample_rate=sample_rate, upper_frequency_limit=upper_frequency_limit, lower_frequency_limit=lower_frequency_limit, filterbank_channel_count=filterbank_channel_count, dct_coefficient_count=dct_coefficient_count, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("upper_frequency_limit", _op.get_attr("upper_frequency_limit"), "lower_frequency_limit", _op.get_attr("lower_frequency_limit"), "filterbank_channel_count", _op._get_attr_int("filterbank_channel_count"), "dct_coefficient_count", _op._get_attr_int("dct_coefficient_count")) _inputs_flat = _op.inputs _execute.record_gradient("Mfcc", _inputs_flat, _attrs, _result) _result, = _result return _result
def tensor_summary(tensor, description="", labels=[], display_name="", name=None): r"""Outputs a `Summary` protocol buffer with a tensor. This op is being phased out in favor of TensorSummaryV2, which lets callers pass a tag as well as a serialized SummaryMetadata proto string that contains plugin-specific data. We will keep this op to maintain backwards compatibility. Args: tensor: A `Tensor`. A tensor to serialize. description: An optional `string`. Defaults to `""`. A json-encoded SummaryDescription proto. labels: An optional list of `strings`. Defaults to `[]`. An unused list of strings. display_name: An optional `string`. Defaults to `""`. An unused string. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "TensorSummary", name, tensor, "description", description, "labels", labels, "display_name", display_name) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return tensor_summary_eager_fallback(tensor, description=description, labels=labels, display_name=display_name, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if description is None: description = "" description = _execute.make_str(description, "description") if labels is None: labels = [] if not isinstance(labels, (list, tuple)): raise TypeError("Expected list for 'labels' argument to " "'tensor_summary' Op, not %r." % labels) labels = [_execute.make_str(_s, "labels") for _s in labels] if display_name is None: display_name = "" display_name = _execute.make_str(display_name, "display_name") _, _, _op, _outputs = _op_def_library._apply_op_helper( "TensorSummary", tensor=tensor, description=description, labels=labels, display_name=display_name, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("T", _op._get_attr_type("T"), "description", _op.get_attr("description"), "labels", _op.get_attr("labels"), "display_name", _op.get_attr("display_name")) _inputs_flat = _op.inputs _execute.record_gradient("TensorSummary", _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_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "LoadAndRemapMatrix", name, tld.op_callbacks, ckpt_path, old_tensor_name, row_remapping, col_remapping, initializing_values, "num_rows", num_rows, "num_cols", num_cols, "max_rows_in_memory", max_rows_in_memory) return _result except _core._FallbackException: 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. except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # 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 audio_summary(tag, tensor, sample_rate, max_outputs=3, name=None): r"""Outputs a `Summary` protocol buffer with audio. The summary has up to `max_outputs` summary values containing audio. The audio is built from `tensor` which must be 3-D with shape `[batch_size, frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`. The `tag` argument is a scalar `Tensor` of type `string`. It is used to build the `tag` of the summary values: * If `max_outputs` is 1, the summary value tag is '*tag*/audio'. * If `max_outputs` is greater than 1, the summary value tags are generated sequentially as '*tag*/audio/0', '*tag*/audio/1', etc. Args: tag: A `Tensor` of type `string`. Scalar. Used to build the `tag` attribute of the summary values. tensor: A `Tensor` of type `float32`. 2-D of shape `[batch_size, frames]`. sample_rate: A `float`. The sample rate of the signal in hertz. max_outputs: An optional `int` that is `>= 1`. Defaults to `3`. Max number of batch elements to generate audio for. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "AudioSummary", name, tag, tensor, "sample_rate", sample_rate, "max_outputs", max_outputs) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return audio_summary_eager_fallback(tag, tensor, sample_rate=sample_rate, max_outputs=max_outputs, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. sample_rate = _execute.make_float(sample_rate, "sample_rate") if max_outputs is None: max_outputs = 3 max_outputs = _execute.make_int(max_outputs, "max_outputs") _, _, _op, _outputs = _op_def_library._apply_op_helper( "AudioSummary", tag=tag, tensor=tensor, sample_rate=sample_rate, max_outputs=max_outputs, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("sample_rate", _op.get_attr("sample_rate"), "max_outputs", _op._get_attr_int("max_outputs")) _inputs_flat = _op.inputs _execute.record_gradient("AudioSummary", _inputs_flat, _attrs, _result) _result, = _result return _result
def ragged_gather(params_nested_splits, params_dense_values, indices, OUTPUT_RAGGED_RANK, name=None): r"""Gather ragged slices from `params` axis `0` according to `indices`. Outputs a `RaggedTensor` output composed from `output_dense_values` and `output_nested_splits`, such that: ```python output.shape = indices.shape + params.shape[1:] output.ragged_rank = indices.shape.ndims + params.ragged_rank output[i...j, d0...dn] = params[indices[i...j], d0...dn] ``` where * `params = ragged.from_nested_row_splits(params_dense_values, params_nested_splits)` provides the values that should be gathered. * `indices` ia a dense tensor with dtype `int32` or `int64`, indicating which values should be gathered. * `output = ragged.from_nested_row_splits(output_dense_values, output_nested_splits)` is the output tensor. (Note: This c++ op is used to implement the higher-level python `tf.ragged.gather` op, which also supports ragged indices.) Args: params_nested_splits: A list of at least 1 `Tensor` objects with the same type in: `int32`, `int64`. The `nested_row_splits` tensors that define the row-partitioning for the `params` RaggedTensor input. params_dense_values: A `Tensor`. The `flat_values` for the `params` RaggedTensor. There was a terminology change at the python level from dense_values to flat_values, so dense_values is the deprecated name. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. Indices in the outermost dimension of `params` of the values that should be gathered. OUTPUT_RAGGED_RANK: An `int` that is `>= 0`. The ragged rank of the output RaggedTensor. `output_nested_splits` will contain this number of `row_splits` tensors. This value should equal `indices.shape.ndims + params.ragged_rank - 1`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_nested_splits, output_dense_values). output_nested_splits: A list of `OUTPUT_RAGGED_RANK` `Tensor` objects with the same type as `params_nested_splits`. output_dense_values: A `Tensor`. Has the same type as `params_dense_values`. """ _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, "RaggedGather", name, tld.op_callbacks, params_nested_splits, params_dense_values, indices, "OUTPUT_RAGGED_RANK", OUTPUT_RAGGED_RANK) _result = _RaggedGatherOutput._make(_result) return _result except _core._FallbackException: try: return ragged_gather_eager_fallback( params_nested_splits, params_dense_values, indices, OUTPUT_RAGGED_RANK=OUTPUT_RAGGED_RANK, 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(params_nested_splits, (list, tuple)): raise TypeError("Expected list for 'params_nested_splits' argument to " "'ragged_gather' Op, not %r." % params_nested_splits) _attr_PARAMS_RAGGED_RANK = len(params_nested_splits) OUTPUT_RAGGED_RANK = _execute.make_int(OUTPUT_RAGGED_RANK, "OUTPUT_RAGGED_RANK") _, _, _op, _outputs = _op_def_library._apply_op_helper( "RaggedGather", params_nested_splits=params_nested_splits, params_dense_values=params_dense_values, indices=indices, OUTPUT_RAGGED_RANK=OUTPUT_RAGGED_RANK, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("Tvalues", _op._get_attr_type("Tvalues"), "Tindices", _op._get_attr_type("Tindices"), "Tsplits", _op._get_attr_type("Tsplits"), "PARAMS_RAGGED_RANK", _op._get_attr_int("PARAMS_RAGGED_RANK"), "OUTPUT_RAGGED_RANK", _op._get_attr_int("OUTPUT_RAGGED_RANK")) _inputs_flat = _op.inputs _execute.record_gradient("RaggedGather", _inputs_flat, _attrs, _result) _result = [_result[:OUTPUT_RAGGED_RANK]] + _result[OUTPUT_RAGGED_RANK:] _result = _RaggedGatherOutput._make(_result) return _result
def dense_table_push_pull(vars, grads, table_handle, name=None): r"""push pull variable from parameter server Args: vars: A list of at least 1 `Tensor` objects with type `resource`. grads: A list with the same length as `vars` of `Tensor` objects with type `float32`. table_handle: An `int`. 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, "DenseTablePushPull", name, tld.op_callbacks, vars, grads, "table_handle", table_handle) return _result except _core._FallbackException: try: return dense_table_push_pull_eager_fallback( vars, grads, table_handle=table_handle, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch( dense_table_push_pull, vars=vars, grads=grads, table_handle=table_handle, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # Add nodes to the TensorFlow graph. if not isinstance(vars, (list, tuple)): raise TypeError( "Expected list for 'vars' argument to " "'dense_table_push_pull' Op, not %r." % vars) _attr_N = len(vars) if not isinstance(grads, (list, tuple)): raise TypeError( "Expected list for 'grads' argument to " "'dense_table_push_pull' Op, not %r." % grads) if len(grads) != _attr_N: raise ValueError( "List argument 'grads' to 'dense_table_push_pull' Op with length %d " "must match length %d of argument 'vars'." % (len(grads), _attr_N)) table_handle = _execute.make_int(table_handle, "table_handle") try: _, _, _op, _outputs = _op_def_library._apply_op_helper( "DenseTablePushPull", vars=vars, grads=grads, table_handle=table_handle, name=name) except (TypeError, ValueError): result = _dispatch.dispatch( dense_table_push_pull, vars=vars, grads=grads, table_handle=table_handle, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise return _op
def balance_dataset(input_dataset, output_types, output_shapes, name=None): r"""balance input data between datasets Args: input_dataset: A `Tensor` of type `variant`. output_types: A list of `tf.DTypes` that has length `>= 1`. output_shapes: A list of shapes (each a `tf.TensorShape` or list of `ints`) that has length `>= 1`. name: A name for the operation (optional). Returns: A `Tensor` of type `variant`. """ _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, "BalanceDataset", name, tld.op_callbacks, input_dataset, "output_types", output_types, "output_shapes", output_shapes) return _result except _core._FallbackException: try: return balance_dataset_eager_fallback( input_dataset, output_types=output_types, output_shapes=output_shapes, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch(balance_dataset, input_dataset=input_dataset, output_types=output_types, output_shapes=output_shapes, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) # Add nodes to the TensorFlow graph. if not isinstance(output_types, (list, tuple)): raise TypeError("Expected list for 'output_types' argument to " "'balance_dataset' Op, not %r." % output_types) output_types = [ _execute.make_type(_t, "output_types") for _t in output_types ] if not isinstance(output_shapes, (list, tuple)): raise TypeError("Expected list for 'output_shapes' argument to " "'balance_dataset' Op, not %r." % output_shapes) output_shapes = [ _execute.make_shape(_s, "output_shapes") for _s in output_shapes ] try: _, _, _op, _outputs = _op_def_library._apply_op_helper( "BalanceDataset", input_dataset=input_dataset, output_types=output_types, output_shapes=output_shapes, name=name) except (TypeError, ValueError): result = _dispatch.dispatch(balance_dataset, input_dataset=input_dataset, output_types=output_types, output_shapes=output_shapes, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("output_types", _op.get_attr("output_types"), "output_shapes", _op.get_attr("output_shapes")) _inputs_flat = _op.inputs _execute.record_gradient("BalanceDataset", _inputs_flat, _attrs, _result) _result, = _result return _result
def lstm_block_cell(x, cs_prev, h_prev, w, wci, wcf, wco, b, forget_bias=1, cell_clip=3, use_peephole=False, name=None): r"""Computes the LSTM cell forward propagation for 1 time step. This implementation uses 1 weight matrix and 1 bias vector, and there's an optional peephole connection. This kernel op implements the following mathematical equations: ```python xh = [x, h_prev] [i, f, ci, o] = xh * w + b f = f + forget_bias if not use_peephole: wci = wcf = wco = 0 i = sigmoid(cs_prev * wci + i) f = sigmoid(cs_prev * wcf + f) ci = tanh(ci) cs = ci .* i + cs_prev .* f cs = clip(cs, cell_clip) o = sigmoid(cs * wco + o) co = tanh(cs) h = co .* o ``` Args: x: A `Tensor`. Must be one of the following types: `half`, `float32`. The input to the LSTM cell, shape (batch_size, num_inputs). cs_prev: A `Tensor`. Must have the same type as `x`. Value of the cell state at previous time step. h_prev: A `Tensor`. Must have the same type as `x`. Output of the previous cell at previous time step. w: A `Tensor`. Must have the same type as `x`. The weight matrix. wci: A `Tensor`. Must have the same type as `x`. The weight matrix for input gate peephole connection. wcf: A `Tensor`. Must have the same type as `x`. The weight matrix for forget gate peephole connection. wco: A `Tensor`. Must have the same type as `x`. The weight matrix for output gate peephole connection. b: A `Tensor`. Must have the same type as `x`. The bias vector. forget_bias: An optional `float`. Defaults to `1`. The forget gate bias. cell_clip: An optional `float`. Defaults to `3`. Value to clip the 'cs' value to. use_peephole: An optional `bool`. Defaults to `False`. Whether to use peephole weights. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (i, cs, f, o, ci, co, h). i: A `Tensor`. Has the same type as `x`. cs: A `Tensor`. Has the same type as `x`. f: A `Tensor`. Has the same type as `x`. o: A `Tensor`. Has the same type as `x`. ci: A `Tensor`. Has the same type as `x`. co: A `Tensor`. Has the same type as `x`. h: A `Tensor`. Has the same type as `x`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, tld.device_name, "LSTMBlockCell", name, tld.op_callbacks, x, cs_prev, h_prev, w, wci, wcf, wco, b, "forget_bias", forget_bias, "cell_clip", cell_clip, "use_peephole", use_peephole) _result = _LSTMBlockCellOutput._make(_result) return _result except _core._FallbackException: try: return lstm_block_cell_eager_fallback( x, cs_prev, h_prev, w, wci, wcf, wco, b, forget_bias=forget_bias, cell_clip=cell_clip, use_peephole=use_peephole, 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 forget_bias is None: forget_bias = 1 forget_bias = _execute.make_float(forget_bias, "forget_bias") if cell_clip is None: cell_clip = 3 cell_clip = _execute.make_float(cell_clip, "cell_clip") if use_peephole is None: use_peephole = False use_peephole = _execute.make_bool(use_peephole, "use_peephole") _, _, _op, _outputs = _op_def_library._apply_op_helper( "LSTMBlockCell", x=x, cs_prev=cs_prev, h_prev=h_prev, w=w, wci=wci, wcf=wcf, wco=wco, b=b, forget_bias=forget_bias, cell_clip=cell_clip, use_peephole=use_peephole, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("forget_bias", _op.get_attr("forget_bias"), "cell_clip", _op.get_attr("cell_clip"), "use_peephole", _op._get_attr_bool("use_peephole"), "T", _op._get_attr_type("T")) _inputs_flat = _op.inputs _execute.record_gradient( "LSTMBlockCell", _inputs_flat, _attrs, _result) _result = _LSTMBlockCellOutput._make(_result) return _result