def decision_tree_ensemble_resource_handle_op(container="", shared_name="", name=None): r"""TODO: add doc. Args: container: An optional `string`. Defaults to `""`. shared_name: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A `Tensor` of type `resource`. """ _ctx = _context._context if _ctx is None or not _ctx._eager_context.is_eager: if container is None: container = "" container = _execute.make_str(container, "container") if shared_name is None: shared_name = "" shared_name = _execute.make_str(shared_name, "shared_name") _, _, _op = _op_def_lib._apply_op_helper( "DecisionTreeEnsembleResourceHandleOp", container=container, shared_name=shared_name, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("container", _op.get_attr("container"), "shared_name", _op.get_attr("shared_name")) _execute.record_gradient( "DecisionTreeEnsembleResourceHandleOp", _inputs_flat, _attrs, _result, name) _result, = _result return _result else: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._eager_context.device_name, "DecisionTreeEnsembleResourceHandleOp", name, _ctx._post_execution_callbacks, "container", container, "shared_name", shared_name) return _result except _core._FallbackException: return decision_tree_ensemble_resource_handle_op_eager_fallback( container=container, shared_name=shared_name, name=name, ctx=_ctx) except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None)
def image_projective_transform(images, transforms, interpolation, name=None): r"""Applies the given transform to each of the images. Input `image` is a `Tensor` in NHWC format (where the axes are image in batch, rows, columns, and channels. Input `transforms` is a num_images x 8 or 1 x 8 matrix, where each row corresponds to a 3 x 3 projective transformation matrix, with the last entry assumed to be 1. If there is one row, the same transformation will be applied to all images. If one row of `transforms` is `[a0, a1, a2, b0, b1, b2, c0, c1]`, then it maps the *output* point `(x, y)` to a transformed *input* point `(x', y') = ((a0 x + a1 y + a2) / k, (b0 x + b1 y + b2) / k)`, where `k = c0 x + c1 y + 1`. If the transformed point lays outside of the input image, the output pixel is set to 0. Args: images: A `Tensor`. Must be one of the following types: `uint8`, `int32`, `int64`, `half`, `float32`, `float64`. 4D `Tensor`, input image(s) in NHWC format. transforms: A `Tensor` of type `float32`. 2D `Tensor`, projective transform(s) to apply to the image(s). interpolation: A `string`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `images`. 4D `Tensor`, image(s) in NHWC format, generated by applying the `transforms` to the `images`. Satisfies the description above. """ _ctx = _context._context if _ctx is None or not _ctx._eager_context.is_eager: interpolation = _execute.make_str(interpolation, "interpolation") _, _, _op = _op_def_lib._apply_op_helper( "ImageProjectiveTransform", images=images, transforms=transforms, interpolation=interpolation, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("dtype", _op.get_attr("dtype"), "interpolation", _op.get_attr("interpolation")) _execute.record_gradient( "ImageProjectiveTransform", _inputs_flat, _attrs, _result, name) _result, = _result return _result else: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._eager_context.device_name, "ImageProjectiveTransform", name, _ctx._post_execution_callbacks, images, transforms, "interpolation", interpolation) return _result except _core._FallbackException: return image_projective_transform_eager_fallback( images, transforms, interpolation=interpolation, name=name, ctx=_ctx) except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None)
def decision_tree_ensemble_resource_handle_op_eager_fallback(container="", shared_name="", name=None, ctx=None): r"""This is the slowpath function for Eager mode. This is for function decision_tree_ensemble_resource_handle_op """ _ctx = ctx if ctx else _context.context() if container is None: container = "" container = _execute.make_str(container, "container") if shared_name is None: shared_name = "" shared_name = _execute.make_str(shared_name, "shared_name") _inputs_flat = [] _attrs = ("container", container, "shared_name", shared_name) _result = _execute.execute(b"DecisionTreeEnsembleResourceHandleOp", 1, inputs=_inputs_flat, attrs=_attrs, ctx=_ctx, name=name) _execute.record_gradient( "DecisionTreeEnsembleResourceHandleOp", _inputs_flat, _attrs, _result, name) _result, = _result return _result
def grow_tree_ensemble_eager_fallback(tree_ensemble_handle, stamp_token, next_stamp_token, learning_rate, dropout_seed, max_tree_depth, weak_learner_type, partition_ids, gains, splits, learner_config, center_bias, name=None, ctx=None): r"""This is the slowpath function for Eager mode. This is for function grow_tree_ensemble """ _ctx = ctx if ctx else _context.context() if not isinstance(partition_ids, (list, tuple)): raise TypeError( "Expected list for 'partition_ids' argument to " "'grow_tree_ensemble' Op, not %r." % partition_ids) _attr_num_handlers = len(partition_ids) if not isinstance(gains, (list, tuple)): raise TypeError( "Expected list for 'gains' argument to " "'grow_tree_ensemble' Op, not %r." % gains) if len(gains) != _attr_num_handlers: raise ValueError( "List argument 'gains' to 'grow_tree_ensemble' Op with length %d " "must match length %d of argument 'partition_ids'." % (len(gains), _attr_num_handlers)) if not isinstance(splits, (list, tuple)): raise TypeError( "Expected list for 'splits' argument to " "'grow_tree_ensemble' Op, not %r." % splits) if len(splits) != _attr_num_handlers: raise ValueError( "List argument 'splits' to 'grow_tree_ensemble' Op with length %d " "must match length %d of argument 'partition_ids'." % (len(splits), _attr_num_handlers)) learner_config = _execute.make_str(learner_config, "learner_config") center_bias = _execute.make_bool(center_bias, "center_bias") tree_ensemble_handle = _ops.convert_to_tensor(tree_ensemble_handle, _dtypes.resource) stamp_token = _ops.convert_to_tensor(stamp_token, _dtypes.int64) next_stamp_token = _ops.convert_to_tensor(next_stamp_token, _dtypes.int64) learning_rate = _ops.convert_to_tensor(learning_rate, _dtypes.float32) dropout_seed = _ops.convert_to_tensor(dropout_seed, _dtypes.int64) max_tree_depth = _ops.convert_to_tensor(max_tree_depth, _dtypes.int32) weak_learner_type = _ops.convert_to_tensor(weak_learner_type, _dtypes.int32) partition_ids = _ops.convert_n_to_tensor(partition_ids, _dtypes.int32) gains = _ops.convert_n_to_tensor(gains, _dtypes.float32) splits = _ops.convert_n_to_tensor(splits, _dtypes.string) _inputs_flat = [tree_ensemble_handle, stamp_token, next_stamp_token, learning_rate, dropout_seed, max_tree_depth, weak_learner_type] + list(partition_ids) + list(gains) + list(splits) _attrs = ("learner_config", learner_config, "num_handlers", _attr_num_handlers, "center_bias", center_bias) _result = _execute.execute(b"GrowTreeEnsemble", 0, inputs=_inputs_flat, attrs=_attrs, ctx=_ctx, name=name) _result = None return _result
def image_projective_transform_eager_fallback(images, transforms, interpolation, name=None, ctx=None): r"""This is the slowpath function for Eager mode. This is for function image_projective_transform """ _ctx = ctx if ctx else _context.context() interpolation = _execute.make_str(interpolation, "interpolation") _attr_dtype, (images,) = _execute.args_to_matching_eager([images], _ctx) transforms = _ops.convert_to_tensor(transforms, _dtypes.float32) _inputs_flat = [images, transforms] _attrs = ("dtype", _attr_dtype, "interpolation", interpolation) _result = _execute.execute(b"ImageProjectiveTransform", 1, inputs=_inputs_flat, attrs=_attrs, ctx=_ctx, name=name) _execute.record_gradient( "ImageProjectiveTransform", _inputs_flat, _attrs, _result, name) _result, = _result return _result
def center_tree_ensemble_bias_eager_fallback(tree_ensemble_handle, stamp_token, next_stamp_token, delta_updates, learner_config, centering_epsilon=0.01, name=None, ctx=None): r"""This is the slowpath function for Eager mode. This is for function center_tree_ensemble_bias """ _ctx = ctx if ctx else _context.context() learner_config = _execute.make_str(learner_config, "learner_config") if centering_epsilon is None: centering_epsilon = 0.01 centering_epsilon = _execute.make_float(centering_epsilon, "centering_epsilon") tree_ensemble_handle = _ops.convert_to_tensor(tree_ensemble_handle, _dtypes.resource) stamp_token = _ops.convert_to_tensor(stamp_token, _dtypes.int64) next_stamp_token = _ops.convert_to_tensor(next_stamp_token, _dtypes.int64) delta_updates = _ops.convert_to_tensor(delta_updates, _dtypes.float32) _inputs_flat = [tree_ensemble_handle, stamp_token, next_stamp_token, delta_updates] _attrs = ("learner_config", learner_config, "centering_epsilon", centering_epsilon) _result = _execute.execute(b"CenterTreeEnsembleBias", 1, inputs=_inputs_flat, attrs=_attrs, ctx=_ctx, name=name) _execute.record_gradient( "CenterTreeEnsembleBias", _inputs_flat, _attrs, _result, name) _result, = _result return _result
def rpc(address, method, request, protocol="", fail_fast=True, timeout_in_ms=0, name=None): r"""Perform batches of RPC requests. This op asynchronously performs either a single RPC request, or a batch of requests. RPC requests are defined by three main parameters: - `address` (the host+port or BNS address of the request) - `method` (the RPC method name for the request) - `request` (the serialized proto string, or vector of strings, of the RPC request argument). For example, if you have an RPC service running on port localhost:2345, and its interface is configured with the following proto declaration: ``` service MyService { rpc MyMethod(MyRequestProto) returns (MyResponseProto) { } }; ``` then call this op with arguments: ``` address = "localhost:2345" method = "MyService/MyMethod" ``` The `request` tensor is a string tensor representing serialized `MyRequestProto` strings; and the output string tensor `response` will have the same shape and contain (upon successful completion) corresponding serialized `MyResponseProto` strings. For example, to send a single, empty, `MyRequestProto`, call this op with `request = ""`. To send 5 **parallel** empty requests, call this op with `request = ["", "", "", "", ""]`. More generally, one can create a batch of `MyRequestProto` serialized protos from regular batched tensors using the `encode_proto` op, and convert the response `MyResponseProto` serialized protos to batched tensors using the `decode_proto` op. **NOTE** Working with serialized proto strings is faster than instantiating actual proto objects in memory, so no performance degradation is expected compared to writing custom kernels for this workflow. If the connection fails or the remote worker returns an error status, the op reraises this exception locally. See the `TryRpc` op if you prefer to handle RPC failures manually in the graph. Args: address: A `Tensor` of type `string`. `0-D` or `1-D`. The address (i.e. host_name:port) of the RPC server. If this tensor has more than 1 element, then multiple parallel rpc requests are sent. This argument broadcasts with `method` and `request`. method: A `Tensor` of type `string`. `0-D` or `1-D`. The method address on the RPC server. If this tensor has more than 1 element, then multiple parallel rpc requests are sent. This argument broadcasts with `address` and `request`. request: A `Tensor` of type `string`. `0-D` or `1-D`. Serialized proto strings: the rpc request argument. If this tensor has more than 1 element, then multiple parallel rpc requests are sent. This argument broadcasts with `address` and `method`. protocol: An optional `string`. Defaults to `""`. RPC protocol to use. Empty string means use the default protocol. Options include 'grpc'. fail_fast: An optional `bool`. Defaults to `True`. `boolean`. If `true` (default), then failures to connect (i.e., the server does not immediately respond) cause an RPC failure. timeout_in_ms: An optional `int`. Defaults to `0`. `int`. If `0` (default), then the kernel will run the RPC request and only time out if the RPC deadline passes or the session times out. If this value is greater than `0`, then the op will raise an exception if the RPC takes longer than `timeout_in_ms`. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. """ _ctx = _context._context if _ctx is None or not _ctx._eager_context.is_eager: if protocol is None: protocol = "" protocol = _execute.make_str(protocol, "protocol") if fail_fast is None: fail_fast = True fail_fast = _execute.make_bool(fail_fast, "fail_fast") if timeout_in_ms is None: timeout_in_ms = 0 timeout_in_ms = _execute.make_int(timeout_in_ms, "timeout_in_ms") _, _, _op = _op_def_lib._apply_op_helper( "Rpc", address=address, method=method, request=request, protocol=protocol, fail_fast=fail_fast, timeout_in_ms=timeout_in_ms, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("protocol", _op.get_attr("protocol"), "fail_fast", _op.get_attr("fail_fast"), "timeout_in_ms", _op.get_attr("timeout_in_ms")) _execute.record_gradient( "Rpc", _inputs_flat, _attrs, _result, name) _result, = _result return _result else: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._eager_context.device_name, "Rpc", name, _ctx._post_execution_callbacks, address, method, request, "protocol", protocol, "fail_fast", fail_fast, "timeout_in_ms", timeout_in_ms) return _result except _core._FallbackException: return rpc_eager_fallback( address, method, request, protocol=protocol, fail_fast=fail_fast, timeout_in_ms=timeout_in_ms, name=name, ctx=_ctx) except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None)
def grow_tree_ensemble(tree_ensemble_handle, stamp_token, next_stamp_token, learning_rate, dropout_seed, max_tree_depth, weak_learner_type, partition_ids, gains, splits, learner_config, center_bias, name=None): r"""Grows the tree ensemble by either adding a layer to the last tree being grown or by starting a new tree. Args: tree_ensemble_handle: A `Tensor` of type `resource`. Handle to the ensemble variable. stamp_token: A `Tensor` of type `int64`. Stamp token for validating operation consistency. next_stamp_token: A `Tensor` of type `int64`. Stamp token to be used for the next iteration. learning_rate: A `Tensor` of type `float32`. Scalar learning rate. dropout_seed: A `Tensor` of type `int64`. max_tree_depth: A `Tensor` of type `int32`. weak_learner_type: A `Tensor` of type `int32`. The type of weak learner to use. partition_ids: A list of `Tensor` objects with type `int32`. List of Rank 1 Tensors containing partition Id per candidate. gains: A list with the same length as `partition_ids` of `Tensor` objects with type `float32`. List of Rank 1 Tensors containing gains per candidate. splits: A list with the same length as `partition_ids` of `Tensor` objects with type `string`. List of Rank 1 Tensors containing serialized SplitInfo protos per candidate. learner_config: A `string`. Config for the learner of type LearnerConfig proto. center_bias: A `bool`. name: A name for the operation (optional). Returns: The created Operation. """ _ctx = _context._context or _context.context() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "GrowTreeEnsemble", name, _ctx._post_execution_callbacks, tree_ensemble_handle, stamp_token, next_stamp_token, learning_rate, dropout_seed, max_tree_depth, weak_learner_type, partition_ids, gains, splits, "learner_config", learner_config, "center_bias", center_bias) return _result except _core._FallbackException: try: return grow_tree_ensemble_eager_fallback( tree_ensemble_handle, stamp_token, next_stamp_token, learning_rate, dropout_seed, max_tree_depth, weak_learner_type, partition_ids, gains, splits, learner_config=learner_config, center_bias=center_bias, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch( grow_tree_ensemble, tree_ensemble_handle=tree_ensemble_handle, stamp_token=stamp_token, next_stamp_token=next_stamp_token, learning_rate=learning_rate, dropout_seed=dropout_seed, max_tree_depth=max_tree_depth, weak_learner_type=weak_learner_type, partition_ids=partition_ids, gains=gains, splits=splits, learner_config=learner_config, center_bias=center_bias, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. if not isinstance(partition_ids, (list, tuple)): raise TypeError("Expected list for 'partition_ids' argument to " "'grow_tree_ensemble' Op, not %r." % partition_ids) _attr_num_handlers = len(partition_ids) if not isinstance(gains, (list, tuple)): raise TypeError("Expected list for 'gains' argument to " "'grow_tree_ensemble' Op, not %r." % gains) if len(gains) != _attr_num_handlers: raise ValueError( "List argument 'gains' to 'grow_tree_ensemble' Op with length %d " "must match length %d of argument 'partition_ids'." % (len(gains), _attr_num_handlers)) if not isinstance(splits, (list, tuple)): raise TypeError("Expected list for 'splits' argument to " "'grow_tree_ensemble' Op, not %r." % splits) if len(splits) != _attr_num_handlers: raise ValueError( "List argument 'splits' to 'grow_tree_ensemble' Op with length %d " "must match length %d of argument 'partition_ids'." % (len(splits), _attr_num_handlers)) learner_config = _execute.make_str(learner_config, "learner_config") center_bias = _execute.make_bool(center_bias, "center_bias") try: _, _, _op = _op_def_lib._apply_op_helper( "GrowTreeEnsemble", tree_ensemble_handle=tree_ensemble_handle, stamp_token=stamp_token, next_stamp_token=next_stamp_token, learning_rate=learning_rate, dropout_seed=dropout_seed, max_tree_depth=max_tree_depth, weak_learner_type=weak_learner_type, partition_ids=partition_ids, gains=gains, splits=splits, learner_config=learner_config, center_bias=center_bias, name=name) except (TypeError, ValueError): result = _dispatch.dispatch(grow_tree_ensemble, tree_ensemble_handle=tree_ensemble_handle, stamp_token=stamp_token, next_stamp_token=next_stamp_token, learning_rate=learning_rate, dropout_seed=dropout_seed, max_tree_depth=max_tree_depth, weak_learner_type=weak_learner_type, partition_ids=partition_ids, gains=gains, splits=splits, learner_config=learner_config, center_bias=center_bias, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise return _op _result = None return _result
def unbatch_grad(original_input, batch_index, grad, id, container="", shared_name="", name=None): r"""Gradient of Unbatch. Acts like Batch but using the given batch_index index of batching things as they become available. This ensures that the gradients are propagated back in the same session which did the forward pass. Args: original_input: A `Tensor`. The input to the Unbatch operation this is the gradient of. batch_index: A `Tensor` of type `int64`. The batch_index given to the Unbatch operation this is the gradient of. grad: A `Tensor`. Must have the same type as `original_input`. The downstream gradient. id: A `Tensor` of type `int64`. The id scalar emitted by Batch. container: An optional `string`. Defaults to `""`. Container to control resource sharing. shared_name: An optional `string`. Defaults to `""`. Instances of UnbatchGrad with the same container and shared_name are assumed to possibly belong to the same batch. If left empty, the op name will be used as the shared name. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `original_input`. The return value, either an empty tensor or the batched gradient. """ if container is None: container = "" container = _execute.make_str(container, "container") if shared_name is None: shared_name = "" shared_name = _execute.make_str(shared_name, "shared_name") _ctx = _context.context() if _ctx.in_graph_mode(): _, _, _op = _op_def_lib._apply_op_helper("UnbatchGrad", original_input=original_input, batch_index=batch_index, grad=grad, id=id, container=container, shared_name=shared_name, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("container", _op.get_attr("container"), "shared_name", _op.get_attr("shared_name"), "T", _op.get_attr("T")) else: _attr_T, _inputs_T = _execute.args_to_matching_eager( [original_input, grad], _ctx) (original_input, grad) = _inputs_T _attr_T = _attr_T.as_datatype_enum batch_index = _ops.convert_to_tensor(batch_index, _dtypes.int64) id = _ops.convert_to_tensor(id, _dtypes.int64) _inputs_flat = [original_input, batch_index, grad, id] _attrs = ("container", container, "shared_name", shared_name, "T", _attr_T) _result = _execute.execute(b"UnbatchGrad", 1, inputs=_inputs_flat, attrs=_attrs, ctx=_ctx, name=name) _execute.record_gradient("UnbatchGrad", _inputs_flat, _attrs, _result, name) _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 sparse_to_sparse_set_operation(set1_indices, set1_values, set1_shape, set2_indices, set2_values, set2_shape, set_operation, validate_indices=True, name=None): r"""Applies set operation along last dimension of 2 `SparseTensor` inputs. See SetOperationOp::SetOperationFromContext for values of `set_operation`. If `validate_indices` is `True`, `SparseToSparseSetOperation` validates the order and range of `set1` and `set2` indices. Input `set1` is a `SparseTensor` represented by `set1_indices`, `set1_values`, and `set1_shape`. For `set1` ranked `n`, 1st `n-1` dimensions must be the same as `set2`. Dimension `n` contains values in a set, duplicates are allowed but ignored. Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`, and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same as `set1`. Dimension `n` contains values in a set, duplicates are allowed but ignored. If `validate_indices` is `True`, this op validates the order and range of `set1` and `set2` indices. Output `result` is a `SparseTensor` represented by `result_indices`, `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth` dimension contains the result of `set_operation` applied to the corresponding `[0...n-1]` dimension of `set`. Args: set1_indices: A `Tensor` of type `int64`. 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major order. set1_values: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `string`. 1D `Tensor`, values of a `SparseTensor`. Must be in row-major order. set1_shape: A `Tensor` of type `int64`. 1D `Tensor`, shape of a `SparseTensor`. `set1_shape[0...n-1]` must be the same as `set2_shape[0...n-1]`, `set1_shape[n]` is the max set size across `0...n-1` dimensions. set2_indices: A `Tensor` of type `int64`. 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major order. set2_values: A `Tensor`. Must have the same type as `set1_values`. 1D `Tensor`, values of a `SparseTensor`. Must be in row-major order. set2_shape: A `Tensor` of type `int64`. 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must be the same as `set1_shape[0...n-1]`, `set2_shape[n]` is the max set size across `0...n-1` dimensions. set_operation: A `string`. validate_indices: An optional `bool`. Defaults to `True`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (result_indices, result_values, result_shape). result_indices: A `Tensor` of type `int64`. result_values: A `Tensor`. Has the same type as `set1_values`. result_shape: A `Tensor` of type `int64`. """ _ctx = _context._context or _context.context() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "SparseToSparseSetOperation", name, _ctx._post_execution_callbacks, set1_indices, set1_values, set1_shape, set2_indices, set2_values, set2_shape, "set_operation", set_operation, "validate_indices", validate_indices) _result = _SparseToSparseSetOperationOutput._make(_result) return _result except _core._FallbackException: try: return sparse_to_sparse_set_operation_eager_fallback( set1_indices, set1_values, set1_shape, set2_indices, set2_values, set2_shape, set_operation=set_operation, validate_indices=validate_indices, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. set_operation = _execute.make_str(set_operation, "set_operation") if validate_indices is None: validate_indices = True validate_indices = _execute.make_bool(validate_indices, "validate_indices") _, _, _op = _op_def_lib._apply_op_helper("SparseToSparseSetOperation", set1_indices=set1_indices, set1_values=set1_values, set1_shape=set1_shape, set2_indices=set2_indices, set2_values=set2_values, set2_shape=set2_shape, set_operation=set_operation, validate_indices=validate_indices, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("set_operation", _op.get_attr("set_operation"), "validate_indices", _op.get_attr("validate_indices"), "T", _op._get_attr_type("T")) _execute.record_gradient("SparseToSparseSetOperation", _inputs_flat, _attrs, _result, name) _result = _SparseToSparseSetOperationOutput._make(_result) return _result
def fused_conv2d_bias_activation(conv_input, filter, bias, side_input, conv_input_scale, side_input_scale, strides, padding, data_format="NHWC", filter_format="HWIO", activation_mode="Relu", dilations=[1, 1, 1, 1], name=None): r""" Computes a fused kernel which implements: 2-D convolution, adds side input, with separate scaling on convolution and side inputs, then adds bias and applies the RELU activation function to the result. Supports both float and qint8 data formats. In the case of qint8, the output is clipped to [0..127]. conv_input: A tensor with format as specified by `data_format` (see below). filter: A tensor with format depending on `data_format` as follows: "NHWC", "NCHW": `float [ filter_height, filter_width, in_channels, out_channels ]` "NCHW_VECT_C": `qint8 [ out_channels, in_channels, filter_height, filter_width ]` bias: 1-D float tensor with size matching the `out_channels` dimension of `filter`. Note: this tensor is still float, even if other inputs are qint8. side_input: A tensor with format as specified by `data_format` (see below). This tensor will be ignored and can be [] if side_input_scale == 0. Otherwise, the size of each dimension must match the `output` tensor. conv_input_scale: scalar float value to be multiplied by `conv_input`. (conceptually.. in reality it is applied after convolution). side_input_scale: scalar float value to be multiplied by `side_input`. output: A tensor with format as specified by `data_format` (see below). The dimension sizes are determined automatically based on other inputs and attributes. T: The element data type of `conv_input`, `side_input` and `output` tensors. Note: must match with the `data_format`. Tbias: The element data type of `bias`. strides: 1-D tensor of length 4. The stride of the sliding window for each dimension of `input`. The dimension order is determined by the value of `data_format`, see below for details. Note: the stride for batch and channel dimensions must be 1. padding: The type of padding algorithm to use. data_format: A string specifying the data format of `conv_input`, `side_input` and `output` tensors with the following options: "NHWC": `float [ batch, height, width, channels ]` "NCHW": `float [ batch, channels, height, width ]` "NCHW_VECT_C": `qint8 [ batch, channels / 4, height, width, channels % 4 ]` Note: for "NCHW_VECT_C", `channels` must be a multiple of 4. filter_format: A string specifying the data format of `filter`, "HWIO": `float [ kernel_height, kernel_width, input_channels, output_channels ]` "OIHW_VECT_I": `qint8 [ output_channels, input_channels / 4, kernel_height, kernel_width, input_channels % 4 ]` activation_mode: The activation applied to the output. Must be "Relu" or "None". dilations: 1-D tensor of length 4. The dilation factor for each dimension of `input`. If set to k > 1, there will be k-1 skipped cells between each filter element on that dimension. The dimension order is determined by the value of `data_format`, see above for details. Dilations in the batch and depth dimensions must be 1. Args: conv_input: A `Tensor`. Must be one of the following types: `float32`, `half`, `qint8`. filter: A `Tensor`. Must have the same type as `conv_input`. bias: A `Tensor`. Must be one of the following types: `float32`, `half`. side_input: A `Tensor`. Must have the same type as `conv_input`. conv_input_scale: A `Tensor` of type `float32`. side_input_scale: A `Tensor` of type `float32`. strides: A list of `ints`. padding: A `string` from: `"SAME", "VALID"`. data_format: An optional `string` from: `"NHWC", "NCHW", "NCHW_VECT_C"`. Defaults to `"NHWC"`. filter_format: An optional `string` from: `"HWIO", "OIHW", "OIHW_VECT_I"`. Defaults to `"HWIO"`. activation_mode: An optional `string` from: `"Relu", "None"`. Defaults to `"Relu"`. dilations: An optional list of `ints`. Defaults to `[1, 1, 1, 1]`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `conv_input`. """ _ctx = _context._context or _context.context() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "FusedConv2DBiasActivation", name, _ctx.post_execution_callbacks, conv_input, filter, bias, side_input, conv_input_scale, side_input_scale, "strides", strides, "padding", padding, "data_format", data_format, "filter_format", filter_format, "activation_mode", activation_mode, "dilations", dilations) return _result except _core._FallbackException: try: return fused_conv2d_bias_activation_eager_fallback( conv_input, filter, bias, side_input, conv_input_scale, side_input_scale, strides=strides, padding=padding, data_format=data_format, filter_format=filter_format, activation_mode=activation_mode, dilations=dilations, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch(fused_conv2d_bias_activation, conv_input=conv_input, filter=filter, bias=bias, side_input=side_input, conv_input_scale=conv_input_scale, side_input_scale=side_input_scale, strides=strides, padding=padding, data_format=data_format, filter_format=filter_format, activation_mode=activation_mode, dilations=dilations, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. if not isinstance(strides, (list, tuple)): raise TypeError("Expected list for 'strides' argument to " "'fused_conv2d_bias_activation' Op, not %r." % strides) strides = [_execute.make_int(_i, "strides") for _i in strides] padding = _execute.make_str(padding, "padding") if data_format is None: data_format = "NHWC" data_format = _execute.make_str(data_format, "data_format") if filter_format is None: filter_format = "HWIO" filter_format = _execute.make_str(filter_format, "filter_format") if activation_mode is None: activation_mode = "Relu" activation_mode = _execute.make_str(activation_mode, "activation_mode") if dilations is None: dilations = [1, 1, 1, 1] if not isinstance(dilations, (list, tuple)): raise TypeError("Expected list for 'dilations' argument to " "'fused_conv2d_bias_activation' Op, not %r." % dilations) dilations = [_execute.make_int(_i, "dilations") for _i in dilations] try: _, _, _op = _op_def_lib._apply_op_helper( "FusedConv2DBiasActivation", conv_input=conv_input, filter=filter, bias=bias, side_input=side_input, conv_input_scale=conv_input_scale, side_input_scale=side_input_scale, strides=strides, padding=padding, data_format=data_format, filter_format=filter_format, activation_mode=activation_mode, dilations=dilations, name=name) except (TypeError, ValueError): result = _dispatch.dispatch(fused_conv2d_bias_activation, conv_input=conv_input, filter=filter, bias=bias, side_input=side_input, conv_input_scale=conv_input_scale, side_input_scale=side_input_scale, strides=strides, padding=padding, data_format=data_format, filter_format=filter_format, activation_mode=activation_mode, dilations=dilations, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("T", _op._get_attr_type("T"), "Tbias", _op._get_attr_type("Tbias"), "strides", _op.get_attr("strides"), "padding", _op.get_attr("padding"), "data_format", _op.get_attr("data_format"), "filter_format", _op.get_attr("filter_format"), "activation_mode", _op.get_attr("activation_mode"), "dilations", _op.get_attr("dilations")) _execute.record_gradient("FusedConv2DBiasActivation", _inputs_flat, _attrs, _result, name) _result, = _result return _result
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 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 gradient_trees_prediction(tree_ensemble_handle, seed, dense_float_features, sparse_float_feature_indices, sparse_float_feature_values, sparse_float_feature_shapes, sparse_int_feature_indices, sparse_int_feature_values, sparse_int_feature_shapes, learner_config, apply_dropout, apply_averaging, center_bias, reduce_dim, use_locking=False, name=None): r"""Runs multiple additive regression forests predictors on input instances and computes the final prediction for each class. Args: tree_ensemble_handle: A `Tensor` of type `resource`. The handle to the tree ensemble. seed: A `Tensor` of type `int64`. random seed to be used for dropout. dense_float_features: A list of `Tensor` objects with type `float32`. Rank 2 Tensors containing dense float feature values. sparse_float_feature_indices: A list of `Tensor` objects with type `int64`. Rank 2 Tensors containing sparse float indices. sparse_float_feature_values: A list with the same length as `sparse_float_feature_indices` of `Tensor` objects with type `float32`. Rank 1 Tensors containing sparse float values. sparse_float_feature_shapes: A list with the same length as `sparse_float_feature_indices` of `Tensor` objects with type `int64`. Rank 1 Tensors containing sparse float shapes. sparse_int_feature_indices: A list of `Tensor` objects with type `int64`. Rank 2 Tensors containing sparse int indices. sparse_int_feature_values: A list with the same length as `sparse_int_feature_indices` of `Tensor` objects with type `int64`. Rank 1 Tensors containing sparse int values. sparse_int_feature_shapes: A list with the same length as `sparse_int_feature_indices` of `Tensor` objects with type `int64`. Rank 1 Tensors containing sparse int shapes. learner_config: A `string`. Config for the learner of type LearnerConfig proto. Prediction ops for now uses only LearningRateDropoutDrivenConfig config from the learner. apply_dropout: A `bool`. whether to apply dropout during prediction. apply_averaging: A `bool`. whether averaging of tree ensembles should take place. If set to true, will be based on AveragingConfig from learner_config. center_bias: A `bool`. reduce_dim: A `bool`. whether to reduce the dimension (legacy impl) or not. use_locking: An optional `bool`. Defaults to `False`. Whether to use locking. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (predictions, drop_out_tree_indices_weights). predictions: A `Tensor` of type `float32`. Rank 2 Tensor containing predictions per example per class. drop_out_tree_indices_weights: A `Tensor` of type `float32`. Tensor of Rank 2 containing dropped trees indices and original weights of those trees during prediction. """ if not isinstance(dense_float_features, (list, tuple)): raise TypeError("Expected list for 'dense_float_features' argument to " "'gradient_trees_prediction' Op, not %r." % dense_float_features) _attr_num_dense_float_features = len(dense_float_features) if not isinstance(sparse_float_feature_indices, (list, tuple)): raise TypeError( "Expected list for 'sparse_float_feature_indices' argument to " "'gradient_trees_prediction' Op, not %r." % sparse_float_feature_indices) _attr_num_sparse_float_features = len(sparse_float_feature_indices) if not isinstance(sparse_float_feature_values, (list, tuple)): raise TypeError( "Expected list for 'sparse_float_feature_values' argument to " "'gradient_trees_prediction' Op, not %r." % sparse_float_feature_values) if len(sparse_float_feature_values) != _attr_num_sparse_float_features: raise ValueError( "List argument 'sparse_float_feature_values' to 'gradient_trees_prediction' Op with length %d " "must match length %d of argument 'sparse_float_feature_indices'." % (len(sparse_float_feature_values), _attr_num_sparse_float_features)) if not isinstance(sparse_float_feature_shapes, (list, tuple)): raise TypeError( "Expected list for 'sparse_float_feature_shapes' argument to " "'gradient_trees_prediction' Op, not %r." % sparse_float_feature_shapes) if len(sparse_float_feature_shapes) != _attr_num_sparse_float_features: raise ValueError( "List argument 'sparse_float_feature_shapes' to 'gradient_trees_prediction' Op with length %d " "must match length %d of argument 'sparse_float_feature_indices'." % (len(sparse_float_feature_shapes), _attr_num_sparse_float_features)) if not isinstance(sparse_int_feature_indices, (list, tuple)): raise TypeError( "Expected list for 'sparse_int_feature_indices' argument to " "'gradient_trees_prediction' Op, not %r." % sparse_int_feature_indices) _attr_num_sparse_int_features = len(sparse_int_feature_indices) if not isinstance(sparse_int_feature_values, (list, tuple)): raise TypeError( "Expected list for 'sparse_int_feature_values' argument to " "'gradient_trees_prediction' Op, not %r." % sparse_int_feature_values) if len(sparse_int_feature_values) != _attr_num_sparse_int_features: raise ValueError( "List argument 'sparse_int_feature_values' to 'gradient_trees_prediction' Op with length %d " "must match length %d of argument 'sparse_int_feature_indices'." % (len(sparse_int_feature_values), _attr_num_sparse_int_features)) if not isinstance(sparse_int_feature_shapes, (list, tuple)): raise TypeError( "Expected list for 'sparse_int_feature_shapes' argument to " "'gradient_trees_prediction' Op, not %r." % sparse_int_feature_shapes) if len(sparse_int_feature_shapes) != _attr_num_sparse_int_features: raise ValueError( "List argument 'sparse_int_feature_shapes' to 'gradient_trees_prediction' Op with length %d " "must match length %d of argument 'sparse_int_feature_indices'." % (len(sparse_int_feature_shapes), _attr_num_sparse_int_features)) learner_config = _execute.make_str(learner_config, "learner_config") apply_dropout = _execute.make_bool(apply_dropout, "apply_dropout") apply_averaging = _execute.make_bool(apply_averaging, "apply_averaging") center_bias = _execute.make_bool(center_bias, "center_bias") reduce_dim = _execute.make_bool(reduce_dim, "reduce_dim") if use_locking is None: use_locking = False use_locking = _execute.make_bool(use_locking, "use_locking") _ctx = _context.context() if _ctx.in_graph_mode(): _, _, _op = _op_def_lib._apply_op_helper( "GradientTreesPrediction", tree_ensemble_handle=tree_ensemble_handle, seed=seed, dense_float_features=dense_float_features, sparse_float_feature_indices=sparse_float_feature_indices, sparse_float_feature_values=sparse_float_feature_values, sparse_float_feature_shapes=sparse_float_feature_shapes, sparse_int_feature_indices=sparse_int_feature_indices, sparse_int_feature_values=sparse_int_feature_values, sparse_int_feature_shapes=sparse_int_feature_shapes, learner_config=learner_config, apply_dropout=apply_dropout, apply_averaging=apply_averaging, center_bias=center_bias, reduce_dim=reduce_dim, use_locking=use_locking, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("learner_config", _op.get_attr("learner_config"), "num_dense_float_features", _op.get_attr("num_dense_float_features"), "num_sparse_float_features", _op.get_attr("num_sparse_float_features"), "num_sparse_int_features", _op.get_attr("num_sparse_int_features"), "use_locking", _op.get_attr("use_locking"), "apply_dropout", _op.get_attr("apply_dropout"), "apply_averaging", _op.get_attr("apply_averaging"), "center_bias", _op.get_attr("center_bias"), "reduce_dim", _op.get_attr("reduce_dim")) else: tree_ensemble_handle = _ops.convert_to_tensor(tree_ensemble_handle, _dtypes.resource) seed = _ops.convert_to_tensor(seed, _dtypes.int64) dense_float_features = _ops.convert_n_to_tensor( dense_float_features, _dtypes.float32) sparse_float_feature_indices = _ops.convert_n_to_tensor( sparse_float_feature_indices, _dtypes.int64) sparse_float_feature_values = _ops.convert_n_to_tensor( sparse_float_feature_values, _dtypes.float32) sparse_float_feature_shapes = _ops.convert_n_to_tensor( sparse_float_feature_shapes, _dtypes.int64) sparse_int_feature_indices = _ops.convert_n_to_tensor( sparse_int_feature_indices, _dtypes.int64) sparse_int_feature_values = _ops.convert_n_to_tensor( sparse_int_feature_values, _dtypes.int64) sparse_int_feature_shapes = _ops.convert_n_to_tensor( sparse_int_feature_shapes, _dtypes.int64) _inputs_flat = [ tree_ensemble_handle, seed ] + list(dense_float_features) + list( sparse_float_feature_indices ) + list(sparse_float_feature_values) + list( sparse_float_feature_shapes ) + list(sparse_int_feature_indices) + list( sparse_int_feature_values) + list(sparse_int_feature_shapes) _attrs = ("learner_config", learner_config, "num_dense_float_features", _attr_num_dense_float_features, "num_sparse_float_features", _attr_num_sparse_float_features, "num_sparse_int_features", _attr_num_sparse_int_features, "use_locking", use_locking, "apply_dropout", apply_dropout, "apply_averaging", apply_averaging, "center_bias", center_bias, "reduce_dim", reduce_dim) _result = _execute.execute(b"GradientTreesPrediction", 2, inputs=_inputs_flat, attrs=_attrs, ctx=_ctx, name=name) _execute.record_gradient("GradientTreesPrediction", _inputs_flat, _attrs, _result, name) _result = _GradientTreesPredictionOutput._make(_result) return _result
def unbatch(batched_tensor, batch_index, id, timeout_micros, container="", shared_name="", name=None): r"""Reverses the operation of Batch for a single output Tensor. An instance of Unbatch either receives an empty batched_tensor, in which case it asynchronously waits until the values become available from a concurrently running instance of Unbatch with the same container and shared_name, or receives a non-empty batched_tensor in which case it finalizes all other concurrently running instances and outputs its own element from the batch. batched_tensor: The possibly transformed output of Batch. The size of the first dimension should remain unchanged by the transformations for the operation to work. batch_index: The matching batch_index obtained from Batch. id: The id scalar emitted by Batch. unbatched_tensor: The Tensor corresponding to this execution. timeout_micros: Maximum amount of time (in microseconds) to wait to receive the batched input tensor associated with a given invocation of the op. container: Container to control resource sharing. shared_name: Instances of Unbatch with the same container and shared_name are assumed to possibly belong to the same batch. If left empty, the op name will be used as the shared name. Args: batched_tensor: A `Tensor`. batch_index: A `Tensor` of type `int64`. id: A `Tensor` of type `int64`. timeout_micros: An `int`. container: An optional `string`. Defaults to `""`. shared_name: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `batched_tensor`. """ _ctx = _context._context or _context.context() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "Unbatch", name, _ctx.post_execution_callbacks, batched_tensor, batch_index, id, "timeout_micros", timeout_micros, "container", container, "shared_name", shared_name) return _result except _core._FallbackException: try: return unbatch_eager_fallback( batched_tensor, batch_index, id, timeout_micros=timeout_micros, container=container, shared_name=shared_name, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. timeout_micros = _execute.make_int(timeout_micros, "timeout_micros") if container is None: container = "" container = _execute.make_str(container, "container") if shared_name is None: shared_name = "" shared_name = _execute.make_str(shared_name, "shared_name") _, _, _op = _op_def_lib._apply_op_helper( "Unbatch", batched_tensor=batched_tensor, batch_index=batch_index, id=id, timeout_micros=timeout_micros, container=container, shared_name=shared_name, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("timeout_micros", _op.get_attr("timeout_micros"), "container", _op.get_attr("container"), "shared_name", _op.get_attr("shared_name"), "T", _op._get_attr_type("T")) _execute.record_gradient( "Unbatch", _inputs_flat, _attrs, _result, name) _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`. """ 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") _ctx = _context.context() if _ctx.in_graph_mode(): _, _, _op = _op_def_lib._apply_op_helper( "Enter", data=data, frame_name=frame_name, is_constant=is_constant, parallel_iterations=parallel_iterations, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("T", _op.get_attr("T"), "frame_name", _op.get_attr("frame_name"), "is_constant", _op.get_attr("is_constant"), "parallel_iterations", _op.get_attr("parallel_iterations")) else: _attr_T, (data, ) = _execute.args_to_matching_eager([data], _ctx) _inputs_flat = [data] _attrs = ("T", _attr_T, "frame_name", frame_name, "is_constant", is_constant, "parallel_iterations", parallel_iterations) _result = _execute.execute(b"Enter", 1, inputs=_inputs_flat, attrs=_attrs, ctx=_ctx, name=name) _execute.record_gradient("Enter", _inputs_flat, _attrs, _result, name) _result, = _result return _result
def big_query_reader(project_id, dataset_id, table_id, columns, timestamp_millis, container="", shared_name="", test_end_point="", name=None): r"""A Reader that outputs rows from a BigQuery table as tensorflow Examples. Args: project_id: A `string`. GCP project ID. dataset_id: A `string`. BigQuery Dataset ID. table_id: A `string`. Table to read. columns: A list of `strings`. List of columns to read. Leave empty to read all columns. timestamp_millis: An `int`. Table snapshot timestamp in millis since epoch. Relative (negative or zero) snapshot times are not allowed. For more details, see 'Table Decorators' in BigQuery docs. container: An optional `string`. Defaults to `""`. If non-empty, this reader is placed in the given container. Otherwise, a default container is used. shared_name: An optional `string`. Defaults to `""`. If non-empty, this reader is named in the given bucket with this shared_name. Otherwise, the node name is used instead. test_end_point: An optional `string`. Defaults to `""`. Do not use. For testing purposes only. name: A name for the operation (optional). Returns: A `Tensor` of type mutable `string`. The handle to reference the Reader. """ _ctx = _context._context if _ctx is not None and _ctx._eager_context.is_eager: raise RuntimeError( "big_query_reader op does not support eager execution. Arg 'reader_handle' is a ref." ) # Add nodes to the TensorFlow graph. project_id = _execute.make_str(project_id, "project_id") dataset_id = _execute.make_str(dataset_id, "dataset_id") table_id = _execute.make_str(table_id, "table_id") if not isinstance(columns, (list, tuple)): raise TypeError("Expected list for 'columns' argument to " "'big_query_reader' Op, not %r." % columns) columns = [_execute.make_str(_s, "columns") for _s in columns] timestamp_millis = _execute.make_int(timestamp_millis, "timestamp_millis") if container is None: container = "" container = _execute.make_str(container, "container") if shared_name is None: shared_name = "" shared_name = _execute.make_str(shared_name, "shared_name") if test_end_point is None: test_end_point = "" test_end_point = _execute.make_str(test_end_point, "test_end_point") try: _, _, _op = _op_def_lib._apply_op_helper( "BigQueryReader", project_id=project_id, dataset_id=dataset_id, table_id=table_id, columns=columns, timestamp_millis=timestamp_millis, container=container, shared_name=shared_name, test_end_point=test_end_point, name=name) except (TypeError, ValueError): result = _dispatch.dispatch(big_query_reader, project_id=project_id, dataset_id=dataset_id, table_id=table_id, columns=columns, timestamp_millis=timestamp_millis, container=container, shared_name=shared_name, test_end_point=test_end_point, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("container", _op.get_attr("container"), "shared_name", _op.get_attr("shared_name"), "project_id", _op.get_attr("project_id"), "dataset_id", _op.get_attr("dataset_id"), "table_id", _op.get_attr("table_id"), "columns", _op.get_attr("columns"), "timestamp_millis", _op.get_attr("timestamp_millis"), "test_end_point", _op.get_attr("test_end_point")) _execute.record_gradient("BigQueryReader", _inputs_flat, _attrs, _result, name) _result, = _result return _result
def grow_tree_ensemble(tree_ensemble_handle, stamp_token, next_stamp_token, learning_rate, dropout_seed, max_tree_depth, weak_learner_type, partition_ids, gains, splits, learner_config, center_bias, name=None): r"""Grows the tree ensemble by either adding a layer to the last tree being grown or by starting a new tree. Args: tree_ensemble_handle: A `Tensor` of type `resource`. Handle to the ensemble variable. stamp_token: A `Tensor` of type `int64`. Stamp token for validating operation consistency. next_stamp_token: A `Tensor` of type `int64`. Stamp token to be used for the next iteration. learning_rate: A `Tensor` of type `float32`. Scalar learning rate. dropout_seed: A `Tensor` of type `int64`. max_tree_depth: A `Tensor` of type `int32`. weak_learner_type: A `Tensor` of type `int32`. The type of weak learner to use. partition_ids: A list of `Tensor` objects with type `int32`. List of Rank 1 Tensors containing partition Id per candidate. gains: A list with the same length as `partition_ids` of `Tensor` objects with type `float32`. List of Rank 1 Tensors containing gains per candidate. splits: A list with the same length as `partition_ids` of `Tensor` objects with type `string`. List of Rank 1 Tensors containing serialized SplitInfo protos per candidate. learner_config: A `string`. Config for the learner of type LearnerConfig proto. center_bias: A `bool`. name: A name for the operation (optional). Returns: The created Operation. """ _ctx = _context._context if _ctx is None or not _ctx._eager_context.is_eager: if not isinstance(partition_ids, (list, tuple)): raise TypeError( "Expected list for 'partition_ids' argument to " "'grow_tree_ensemble' Op, not %r." % partition_ids) _attr_num_handlers = len(partition_ids) if not isinstance(gains, (list, tuple)): raise TypeError( "Expected list for 'gains' argument to " "'grow_tree_ensemble' Op, not %r." % gains) if len(gains) != _attr_num_handlers: raise ValueError( "List argument 'gains' to 'grow_tree_ensemble' Op with length %d " "must match length %d of argument 'partition_ids'." % (len(gains), _attr_num_handlers)) if not isinstance(splits, (list, tuple)): raise TypeError( "Expected list for 'splits' argument to " "'grow_tree_ensemble' Op, not %r." % splits) if len(splits) != _attr_num_handlers: raise ValueError( "List argument 'splits' to 'grow_tree_ensemble' Op with length %d " "must match length %d of argument 'partition_ids'." % (len(splits), _attr_num_handlers)) learner_config = _execute.make_str(learner_config, "learner_config") center_bias = _execute.make_bool(center_bias, "center_bias") _, _, _op = _op_def_lib._apply_op_helper( "GrowTreeEnsemble", tree_ensemble_handle=tree_ensemble_handle, stamp_token=stamp_token, next_stamp_token=next_stamp_token, learning_rate=learning_rate, dropout_seed=dropout_seed, max_tree_depth=max_tree_depth, weak_learner_type=weak_learner_type, partition_ids=partition_ids, gains=gains, splits=splits, learner_config=learner_config, center_bias=center_bias, name=name) return _op _result = None return _result else: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._eager_context.device_name, "GrowTreeEnsemble", name, _ctx._post_execution_callbacks, tree_ensemble_handle, stamp_token, next_stamp_token, learning_rate, dropout_seed, max_tree_depth, weak_learner_type, partition_ids, gains, splits, "learner_config", learner_config, "center_bias", center_bias) return _result except _core._FallbackException: return grow_tree_ensemble_eager_fallback( tree_ensemble_handle, stamp_token, next_stamp_token, learning_rate, dropout_seed, max_tree_depth, weak_learner_type, partition_ids, gains, splits, learner_config=learner_config, center_bias=center_bias, name=name, ctx=_ctx) except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None)
def center_tree_ensemble_bias(tree_ensemble_handle, stamp_token, next_stamp_token, delta_updates, learner_config, centering_epsilon=0.01, name=None): r"""Centers the tree ensemble bias before adding trees based on feature splits. Args: tree_ensemble_handle: A `Tensor` of type `resource`. Handle to the ensemble variable. stamp_token: A `Tensor` of type `int64`. Stamp token for validating operation consistency. next_stamp_token: A `Tensor` of type `int64`. Stamp token to be used for the next iteration. delta_updates: A `Tensor` of type `float32`. Rank 1 Tensor containing delta updates per bias dimension. learner_config: A `string`. Config for the learner of type LearnerConfig proto. centering_epsilon: An optional `float`. Defaults to `0.01`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. Scalar indicating whether more centering is needed. """ _ctx = _context._context if _ctx is None or not _ctx._eager_context.is_eager: learner_config = _execute.make_str(learner_config, "learner_config") if centering_epsilon is None: centering_epsilon = 0.01 centering_epsilon = _execute.make_float(centering_epsilon, "centering_epsilon") _, _, _op = _op_def_lib._apply_op_helper( "CenterTreeEnsembleBias", tree_ensemble_handle=tree_ensemble_handle, stamp_token=stamp_token, next_stamp_token=next_stamp_token, delta_updates=delta_updates, learner_config=learner_config, centering_epsilon=centering_epsilon, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("learner_config", _op.get_attr("learner_config"), "centering_epsilon", _op.get_attr("centering_epsilon")) _execute.record_gradient( "CenterTreeEnsembleBias", _inputs_flat, _attrs, _result, name) _result, = _result return _result else: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._eager_context.device_name, "CenterTreeEnsembleBias", name, _ctx._post_execution_callbacks, tree_ensemble_handle, stamp_token, next_stamp_token, delta_updates, "learner_config", learner_config, "centering_epsilon", centering_epsilon) return _result except _core._FallbackException: return center_tree_ensemble_bias_eager_fallback( tree_ensemble_handle, stamp_token, next_stamp_token, delta_updates, learner_config=learner_config, centering_epsilon=centering_epsilon, name=name, ctx=_ctx) except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None)
def unbatch_grad(original_input, batch_index, grad, id, container="", shared_name="", name=None): r"""Gradient of Unbatch. Acts like Batch but using the given batch_index index of batching things as they become available. This ensures that the gradients are propagated back in the same session which did the forward pass. original_input: The input to the Unbatch operation this is the gradient of. batch_index: The batch_index given to the Unbatch operation this is the gradient of. grad: The downstream gradient. id: The id scalar emitted by Batch. batched_grad: The return value, either an empty tensor or the batched gradient. container: Container to control resource sharing. shared_name: Instances of UnbatchGrad with the same container and shared_name are assumed to possibly belong to the same batch. If left empty, the op name will be used as the shared name. Args: original_input: A `Tensor`. batch_index: A `Tensor` of type `int64`. grad: A `Tensor`. Must have the same type as `original_input`. id: A `Tensor` of type `int64`. container: An optional `string`. Defaults to `""`. shared_name: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `original_input`. """ _ctx = _context._context or _context.context() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "UnbatchGrad", name, _ctx.post_execution_callbacks, original_input, batch_index, grad, id, "container", container, "shared_name", shared_name) return _result except _core._FallbackException: try: return unbatch_grad_eager_fallback( original_input, batch_index, grad, id, container=container, shared_name=shared_name, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. if container is None: container = "" container = _execute.make_str(container, "container") if shared_name is None: shared_name = "" shared_name = _execute.make_str(shared_name, "shared_name") _, _, _op = _op_def_lib._apply_op_helper( "UnbatchGrad", original_input=original_input, batch_index=batch_index, grad=grad, id=id, container=container, shared_name=shared_name, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("container", _op.get_attr("container"), "shared_name", _op.get_attr("shared_name"), "T", _op._get_attr_type("T")) _execute.record_gradient( "UnbatchGrad", _inputs_flat, _attrs, _result, name) _result, = _result return _result
def tree_predictions_v4(tree_handle, input_data, sparse_input_indices, sparse_input_values, sparse_input_shape, input_spec, params, name=None): r"""Outputs the predictions for the given input data. Args: tree_handle: A `Tensor` of type `resource`. The handle to the tree. input_data: A `Tensor` of type `float32`. The training batch's features as a 2-d tensor; `input_data[i][j]` gives the j-th feature of the i-th input. sparse_input_indices: A `Tensor` of type `int64`. The indices tensor from the SparseTensor input. sparse_input_values: A `Tensor` of type `float32`. The values tensor from the SparseTensor input. sparse_input_shape: A `Tensor` of type `int64`. The shape tensor from the SparseTensor input. input_spec: A `string`. params: A `string`. A serialized TensorForestParams proto. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (predictions, tree_paths). predictions: A `Tensor` of type `float32`. `predictions[i][j]` is the probability that input i is class j. tree_paths: A `Tensor` of type `string`. `tree_paths[i]` is a serialized TreePath proto for example i. """ _ctx = _context._context if _ctx is None or not _ctx._eager_context.is_eager: input_spec = _execute.make_str(input_spec, "input_spec") params = _execute.make_str(params, "params") _, _, _op = _op_def_lib._apply_op_helper( "TreePredictionsV4", tree_handle=tree_handle, input_data=input_data, sparse_input_indices=sparse_input_indices, sparse_input_values=sparse_input_values, sparse_input_shape=sparse_input_shape, input_spec=input_spec, params=params, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("input_spec", _op.get_attr("input_spec"), "params", _op.get_attr("params")) _execute.record_gradient("TreePredictionsV4", _inputs_flat, _attrs, _result, name) _result = _TreePredictionsV4Output._make(_result) return _result else: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._eager_context.device_name, "TreePredictionsV4", name, _ctx._post_execution_callbacks, tree_handle, input_data, sparse_input_indices, sparse_input_values, sparse_input_shape, "input_spec", input_spec, "params", params) _result = _TreePredictionsV4Output._make(_result) return _result except _core._FallbackException: return tree_predictions_v4_eager_fallback(tree_handle, input_data, sparse_input_indices, sparse_input_values, sparse_input_shape, input_spec=input_spec, params=params, name=name, ctx=_ctx) except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None)
def _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 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 image_projective_transform(images, transforms, interpolation, name=None): r"""Applies the given transform to each of the images. Input `image` is a `Tensor` in NHWC format (where the axes are image in batch, rows, columns, and channels. Input `transforms` is a num_images x 8 or 1 x 8 matrix, where each row corresponds to a 3 x 3 projective transformation matrix, with the last entry assumed to be 1. If there is one row, the same transformation will be applied to all images. If one row of `transforms` is `[a0, a1, a2, b0, b1, b2, c0, c1]`, then it maps the *output* point `(x, y)` to a transformed *input* point `(x', y') = ((a0 x + a1 y + a2) / k, (b0 x + b1 y + b2) / k)`, where `k = c0 x + c1 y + 1`. If the transformed point lays outside of the input image, the output pixel is set to 0. The output is the same size as the input, Args: images: A `Tensor`. Must be one of the following types: `uint8`, `int32`, `int64`, `half`, `float32`, `float64`. 4D `Tensor`, input image(s) in NHWC format. transforms: A `Tensor` of type `float32`. 2D `Tensor`, projective transform(s) to apply to the image(s). interpolation: A `string`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `images`. 4D `Tensor`, image(s) in NHWC format, generated by applying the `transforms` to the `images`. Satisfies the description above. """ _ctx = _context._context if _ctx is None or not _ctx._eager_context.is_eager: interpolation = _execute.make_str(interpolation, "interpolation") _, _, _op = _op_def_lib._apply_op_helper("ImageProjectiveTransform", images=images, transforms=transforms, interpolation=interpolation, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("dtype", _op.get_attr("dtype"), "interpolation", _op.get_attr("interpolation")) _execute.record_gradient("ImageProjectiveTransform", _inputs_flat, _attrs, _result, name) _result, = _result return _result else: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._eager_context.device_name, "ImageProjectiveTransform", name, _ctx._post_execution_callbacks, images, transforms, "interpolation", interpolation) return _result except _core._FallbackException: return image_projective_transform_eager_fallback( images, transforms, interpolation=interpolation, name=name, ctx=_ctx) except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None)
def grow_tree_v4(tree_handle, stats_handle, finished_nodes, params, name=None): r"""Grows the tree for finished nodes and allocates waiting nodes. Args: tree_handle: A `Tensor` of type `resource`. The handle to the tree. stats_handle: A `Tensor` of type `resource`. The handle to the stats. finished_nodes: A `Tensor` of type `int32`. A 1-d Tensor of finished node ids from ProcessInput. params: A `string`. A serialized TensorForestParams proto. name: A name for the operation (optional). Returns: The created Operation. """ _ctx = _context._context or _context.context() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "GrowTreeV4", name, _ctx._post_execution_callbacks, tree_handle, stats_handle, finished_nodes, "params", params) return _result except _core._FallbackException: try: return grow_tree_v4_eager_fallback( tree_handle, stats_handle, finished_nodes, params=params, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch( grow_tree_v4, tree_handle=tree_handle, stats_handle=stats_handle, finished_nodes=finished_nodes, params=params, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. params = _execute.make_str(params, "params") try: _, _, _op = _op_def_lib._apply_op_helper( "GrowTreeV4", tree_handle=tree_handle, stats_handle=stats_handle, finished_nodes=finished_nodes, params=params, name=name) except (TypeError, ValueError): result = _dispatch.dispatch( grow_tree_v4, tree_handle=tree_handle, stats_handle=stats_handle, finished_nodes=finished_nodes, params=params, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise return _op _result = None return _result
def fused_conv2d_bias_activation_eager_fallback(conv_input, filter, bias, side_input, conv_input_scale, side_input_scale, strides, padding, data_format="NHWC", filter_format="HWIO", activation_mode="Relu", dilations=[1, 1, 1, 1], name=None, ctx=None): r"""This is the slowpath function for Eager mode. This is for function fused_conv2d_bias_activation """ _ctx = ctx if ctx else _context.context() if not isinstance(strides, (list, tuple)): raise TypeError("Expected list for 'strides' argument to " "'fused_conv2d_bias_activation' Op, not %r." % strides) strides = [_execute.make_int(_i, "strides") for _i in strides] padding = _execute.make_str(padding, "padding") if data_format is None: data_format = "NHWC" data_format = _execute.make_str(data_format, "data_format") if filter_format is None: filter_format = "HWIO" filter_format = _execute.make_str(filter_format, "filter_format") if activation_mode is None: activation_mode = "Relu" activation_mode = _execute.make_str(activation_mode, "activation_mode") if dilations is None: dilations = [1, 1, 1, 1] if not isinstance(dilations, (list, tuple)): raise TypeError("Expected list for 'dilations' argument to " "'fused_conv2d_bias_activation' Op, not %r." % dilations) dilations = [_execute.make_int(_i, "dilations") for _i in dilations] _attr_T, _inputs_T = _execute.args_to_matching_eager( [conv_input, filter, side_input], _ctx) (conv_input, filter, side_input) = _inputs_T _attr_Tbias, (bias, ) = _execute.args_to_matching_eager([bias], _ctx) conv_input_scale = _ops.convert_to_tensor(conv_input_scale, _dtypes.float32) side_input_scale = _ops.convert_to_tensor(side_input_scale, _dtypes.float32) _inputs_flat = [ conv_input, filter, bias, side_input, conv_input_scale, side_input_scale ] _attrs = ("T", _attr_T, "Tbias", _attr_Tbias, "strides", strides, "padding", padding, "data_format", data_format, "filter_format", filter_format, "activation_mode", activation_mode, "dilations", dilations) _result = _execute.execute(b"FusedConv2DBiasActivation", 1, inputs=_inputs_flat, attrs=_attrs, ctx=_ctx, name=name) _execute.record_gradient("FusedConv2DBiasActivation", _inputs_flat, _attrs, _result, name) _result, = _result return _result
def process_input_v4(tree_handle, stats_handle, input_data, sparse_input_indices, sparse_input_values, sparse_input_shape, input_labels, input_weights, leaf_ids, random_seed, input_spec, params, name=None): r"""Add labels to stats after traversing the tree for each example. Outputs node ids that are finished. Args: tree_handle: A `Tensor` of type `resource`. The handle to the tree. stats_handle: A `Tensor` of type `resource`. The handle to the stats. input_data: A `Tensor` of type `float32`. The training batch's features as a 2-d tensor; `input_data[i][j]` gives the j-th feature of the i-th input. sparse_input_indices: A `Tensor` of type `int64`. The indices tensor from the SparseTensor input. sparse_input_values: A `Tensor` of type `float32`. The values tensor from the SparseTensor input. sparse_input_shape: A `Tensor` of type `int64`. The shape tensor from the SparseTensor input. input_labels: A `Tensor` of type `float32`. The training batch's labels as a 1 or 2-d tensor. 'input_labels[i][j]' gives the j-th label/target for the i-th input. input_weights: A `Tensor` of type `float32`. The training batch's weights as a 1-d tensor. 'input_weights[i]' gives the weight for the i-th input. leaf_ids: A `Tensor` of type `int32`. `leaf_ids[i]` is the leaf id for input i. random_seed: An `int`. input_spec: A `string`. params: A `string`. A serialized TensorForestParams proto. name: A name for the operation (optional). Returns: A `Tensor` of type `int32`. A 1-d tensor of node ids that have finished and are ready to grow. """ _ctx = _context._context or _context.context() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "ProcessInputV4", name, _ctx._post_execution_callbacks, tree_handle, stats_handle, input_data, sparse_input_indices, sparse_input_values, sparse_input_shape, input_labels, input_weights, leaf_ids, "random_seed", random_seed, "input_spec", input_spec, "params", params) return _result except _core._FallbackException: try: return process_input_v4_eager_fallback( tree_handle, stats_handle, input_data, sparse_input_indices, sparse_input_values, sparse_input_shape, input_labels, input_weights, leaf_ids, random_seed=random_seed, input_spec=input_spec, params=params, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch( process_input_v4, tree_handle=tree_handle, stats_handle=stats_handle, input_data=input_data, sparse_input_indices=sparse_input_indices, sparse_input_values=sparse_input_values, sparse_input_shape=sparse_input_shape, input_labels=input_labels, input_weights=input_weights, leaf_ids=leaf_ids, random_seed=random_seed, input_spec=input_spec, params=params, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. random_seed = _execute.make_int(random_seed, "random_seed") input_spec = _execute.make_str(input_spec, "input_spec") params = _execute.make_str(params, "params") try: _, _, _op = _op_def_lib._apply_op_helper( "ProcessInputV4", tree_handle=tree_handle, stats_handle=stats_handle, input_data=input_data, sparse_input_indices=sparse_input_indices, sparse_input_values=sparse_input_values, sparse_input_shape=sparse_input_shape, input_labels=input_labels, input_weights=input_weights, leaf_ids=leaf_ids, random_seed=random_seed, input_spec=input_spec, params=params, name=name) except (TypeError, ValueError): result = _dispatch.dispatch( process_input_v4, tree_handle=tree_handle, stats_handle=stats_handle, input_data=input_data, sparse_input_indices=sparse_input_indices, sparse_input_values=sparse_input_values, sparse_input_shape=sparse_input_shape, input_labels=input_labels, input_weights=input_weights, leaf_ids=leaf_ids, random_seed=random_seed, input_spec=input_spec, params=params, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("random_seed", _op.get_attr("random_seed"), "input_spec", _op.get_attr("input_spec"), "params", _op.get_attr("params")) _execute.record_gradient( "ProcessInputV4", _inputs_flat, _attrs, _result, name) _result, = _result return _result
def bigtable_client(project_id, instance_id, connection_pool_size, max_receive_message_size=-1, container="", shared_name="", name=None): r"""TODO: add doc. Args: project_id: A `string`. instance_id: A `string`. connection_pool_size: An `int`. max_receive_message_size: An optional `int`. Defaults to `-1`. container: An optional `string`. Defaults to `""`. shared_name: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A `Tensor` of type `resource`. """ _ctx = _context._context if _ctx is not None and _ctx._eager_context.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._eager_context.device_name, "BigtableClient", name, _ctx._post_execution_callbacks, "project_id", project_id, "instance_id", instance_id, "connection_pool_size", connection_pool_size, "max_receive_message_size", max_receive_message_size, "container", container, "shared_name", shared_name) return _result except _core._FallbackException: try: return bigtable_client_eager_fallback( project_id=project_id, instance_id=instance_id, connection_pool_size=connection_pool_size, max_receive_message_size=max_receive_message_size, container=container, shared_name=shared_name, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch( bigtable_client, project_id=project_id, instance_id=instance_id, connection_pool_size=connection_pool_size, max_receive_message_size=max_receive_message_size, container=container, shared_name=shared_name, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. project_id = _execute.make_str(project_id, "project_id") instance_id = _execute.make_str(instance_id, "instance_id") connection_pool_size = _execute.make_int(connection_pool_size, "connection_pool_size") if max_receive_message_size is None: max_receive_message_size = -1 max_receive_message_size = _execute.make_int(max_receive_message_size, "max_receive_message_size") if container is None: container = "" container = _execute.make_str(container, "container") if shared_name is None: shared_name = "" shared_name = _execute.make_str(shared_name, "shared_name") try: _, _, _op = _op_def_lib._apply_op_helper( "BigtableClient", project_id=project_id, instance_id=instance_id, connection_pool_size=connection_pool_size, max_receive_message_size=max_receive_message_size, container=container, shared_name=shared_name, name=name) except (TypeError, ValueError): result = _dispatch.dispatch( bigtable_client, project_id=project_id, instance_id=instance_id, connection_pool_size=connection_pool_size, max_receive_message_size=max_receive_message_size, container=container, shared_name=shared_name, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("project_id", _op.get_attr("project_id"), "instance_id", _op.get_attr("instance_id"), "connection_pool_size", _op.get_attr("connection_pool_size"), "max_receive_message_size", _op.get_attr("max_receive_message_size"), "container", _op.get_attr("container"), "shared_name", _op.get_attr("shared_name")) _execute.record_gradient("BigtableClient", _inputs_flat, _attrs, _result, name) _result, = _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. The `descriptor_source` attribute selects a source of protocol descriptors to consult when looking up `message_type`. This may be a filename containing a serialized `FileDescriptorSet` message, or the special value `local://`, in which case only descriptors linked into the code will be searched; the filename can be on any filesystem accessible to TensorFlow. You can build a `descriptor_source` file using the `--descriptor_set_out` and `--include_imports` options to the protocol compiler `protoc`. The `local://` database only covers descriptors linked into the code via C++ libraries, not Python imports. You can link in a proto descriptor by creating a cc_library target with alwayslink=1. Both binary and text proto serializations are supported, and can be chosen using the `format` attribute. 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() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "DecodeProtoV2", name, _ctx._post_execution_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._FallbackException: 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. except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. 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 = _op_def_lib._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 = _op.outputs[:] _inputs_flat = _op.inputs _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("sanitize")) _execute.record_gradient( "DecodeProtoV2", _inputs_flat, _attrs, _result, name) _result = _result[:1] + [_result[1:]] _result = _DecodeProtoV2Output._make(_result) return _result
def decision_tree_ensemble_resource_handle_op(container="", shared_name="", name=None): r"""TODO: add doc. Args: container: An optional `string`. Defaults to `""`. shared_name: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A `Tensor` of type `resource`. """ _ctx = _context._context or _context.context() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "DecisionTreeEnsembleResourceHandleOp", name, _ctx._post_execution_callbacks, "container", container, "shared_name", shared_name) return _result except _core._FallbackException: try: return decision_tree_ensemble_resource_handle_op_eager_fallback( container=container, shared_name=shared_name, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch( decision_tree_ensemble_resource_handle_op, container=container, shared_name=shared_name, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. if container is None: container = "" container = _execute.make_str(container, "container") if shared_name is None: shared_name = "" shared_name = _execute.make_str(shared_name, "shared_name") try: _, _, _op = _op_def_lib._apply_op_helper( "DecisionTreeEnsembleResourceHandleOp", container=container, shared_name=shared_name, name=name) except (TypeError, ValueError): result = _dispatch.dispatch( decision_tree_ensemble_resource_handle_op, container=container, shared_name=shared_name, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("container", _op.get_attr("container"), "shared_name", _op.get_attr("shared_name")) _execute.record_gradient( "DecisionTreeEnsembleResourceHandleOp", _inputs_flat, _attrs, _result, name) _result, = _result return _result
def encode_proto(sizes, values, field_names, message_type, descriptor_source="local://", name=None): r"""The op serializes protobuf messages provided in the input tensors. The types of the tensors in `values` must match the schema for the fields specified in `field_names`. All the tensors in `values` must have a common shape prefix, *batch_shape*. The `sizes` tensor specifies repeat counts for each field. The repeat count (last dimension) of a each tensor in `values` must be greater than or equal to corresponding repeat count in `sizes`. 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. The `descriptor_source` attribute selects a source of protocol descriptors to consult when looking up `message_type`. This may be a filename containing a serialized `FileDescriptorSet` message, or the special value `local://`, in which case only descriptors linked into the code will be searched; the filename can be on any filesystem accessible to TensorFlow. You can build a `descriptor_source` file using the `--descriptor_set_out` and `--include_imports` options to the protocol compiler `protoc`. The `local://` database only covers descriptors linked into the code via C++ libraries, not Python imports. You can link in a proto descriptor by creating a cc_library target with alwayslink=1. There are a few special cases in the value mapping: Submessage and group fields must be pre-serialized as TensorFlow strings. TensorFlow lacks support for unsigned int64s, so they must be represented as `tf.int64` with the same twos-complement bit pattern (the obvious way). Unsigned int32 values can be represented exactly with `tf.int64`, or with sign wrapping if the input is of type `tf.int32`. Args: sizes: A `Tensor` of type `int32`. Tensor of int32 with shape `[batch_shape, len(field_names)]`. values: A list of `Tensor` objects. List of tensors containing values for the corresponding field. field_names: A list of `strings`. List of strings containing proto field names. message_type: A `string`. Name of the proto message type to decode. descriptor_source: An optional `string`. Defaults to `"local://"`. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. """ _ctx = _context._context or _context.context() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "EncodeProto", name, _ctx._post_execution_callbacks, sizes, values, "field_names", field_names, "message_type", message_type, "descriptor_source", descriptor_source) return _result except _core._FallbackException: try: return encode_proto_eager_fallback( sizes, values, field_names=field_names, message_type=message_type, descriptor_source=descriptor_source, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. if not isinstance(field_names, (list, tuple)): raise TypeError("Expected list for 'field_names' argument to " "'encode_proto' Op, not %r." % field_names) field_names = [_execute.make_str(_s, "field_names") for _s in field_names] message_type = _execute.make_str(message_type, "message_type") if descriptor_source is None: descriptor_source = "local://" descriptor_source = _execute.make_str(descriptor_source, "descriptor_source") _, _, _op = _op_def_lib._apply_op_helper( "EncodeProto", sizes=sizes, values=values, field_names=field_names, message_type=message_type, descriptor_source=descriptor_source, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("field_names", _op.get_attr("field_names"), "message_type", _op.get_attr("message_type"), "descriptor_source", _op.get_attr("descriptor_source"), "Tinput_types", _op.get_attr("Tinput_types")) _execute.record_gradient("EncodeProto", _inputs_flat, _attrs, _result, name) _result, = _result return _result
def unbatch(batched_tensor, batch_index, id, timeout_micros, container="", shared_name="", name=None): r"""Reverses the operation of Batch for a single output Tensor. An instance of Unbatch either receives an empty batched_tensor, in which case it asynchronously waits until the values become available from a concurrently running instance of Unbatch with the same container and shared_name, or receives a non-empty batched_tensor in which case it finalizes all other concurrently running instances and outputs its own element from the batch. Args: batched_tensor: A `Tensor`. The possibly transformed output of Batch. The size of the first dimension should remain unchanged by the transformations for the operation to work. batch_index: A `Tensor` of type `int64`. The matching batch_index obtained from Batch. id: A `Tensor` of type `int64`. The id scalar emitted by Batch. timeout_micros: An `int`. Maximum amount of time (in microseconds) to wait to receive the batched input tensor associated with a given invocation of the op. container: An optional `string`. Defaults to `""`. Container to control resource sharing. shared_name: An optional `string`. Defaults to `""`. Instances of Unbatch with the same container and shared_name are assumed to possibly belong to the same batch. If left empty, the op name will be used as the shared name. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `batched_tensor`. The Tensor corresponding to this execution. """ timeout_micros = _execute.make_int(timeout_micros, "timeout_micros") if container is None: container = "" container = _execute.make_str(container, "container") if shared_name is None: shared_name = "" shared_name = _execute.make_str(shared_name, "shared_name") _ctx = _context.context() if _ctx.in_graph_mode(): _, _, _op = _op_def_lib._apply_op_helper("Unbatch", batched_tensor=batched_tensor, batch_index=batch_index, id=id, timeout_micros=timeout_micros, container=container, shared_name=shared_name, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("timeout_micros", _op.get_attr("timeout_micros"), "container", _op.get_attr("container"), "shared_name", _op.get_attr("shared_name"), "T", _op.get_attr("T")) else: _attr_T, (batched_tensor, ) = _execute.args_to_matching_eager( [batched_tensor], _ctx) _attr_T = _attr_T.as_datatype_enum batch_index = _ops.convert_to_tensor(batch_index, _dtypes.int64) id = _ops.convert_to_tensor(id, _dtypes.int64) _inputs_flat = [batched_tensor, batch_index, id] _attrs = ("timeout_micros", timeout_micros, "container", container, "shared_name", shared_name, "T", _attr_T) _result = _execute.execute(b"Unbatch", 1, inputs=_inputs_flat, attrs=_attrs, ctx=_ctx, name=name) _execute.record_gradient("Unbatch", _inputs_flat, _attrs, _result, name) _result, = _result return _result
def nccl_all_reduce(input, reduction, num_devices, shared_name, name=None): r"""Outputs a tensor containing the reduction across all input tensors. Outputs a tensor containing the reduction across all input tensors passed to ops within the same `shared_name. The graph should be constructed so if one op runs with shared_name value `c`, then `num_devices` ops will run with shared_name value `c`. Failure to do so will cause the graph execution to fail to complete. input: the input to the reduction data: the value of the reduction across all `num_devices` devices. reduction: the reduction operation to perform. num_devices: The number of devices participating in this reduction. shared_name: Identifier that shared between ops of the same reduction. Args: input: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`. reduction: A `string` from: `"min", "max", "prod", "sum"`. num_devices: An `int`. shared_name: A `string`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. """ _ctx = _context._context or _context.context() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "NcclAllReduce", name, _ctx._post_execution_callbacks, input, "reduction", reduction, "num_devices", num_devices, "shared_name", shared_name) return _result except _core._FallbackException: try: return nccl_all_reduce_eager_fallback(input, reduction=reduction, num_devices=num_devices, shared_name=shared_name, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. reduction = _execute.make_str(reduction, "reduction") num_devices = _execute.make_int(num_devices, "num_devices") shared_name = _execute.make_str(shared_name, "shared_name") _, _, _op = _op_def_lib._apply_op_helper("NcclAllReduce", input=input, reduction=reduction, num_devices=num_devices, shared_name=shared_name, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("reduction", _op.get_attr("reduction"), "T", _op.get_attr("T"), "num_devices", _op.get_attr("num_devices"), "shared_name", _op.get_attr("shared_name")) _execute.record_gradient("NcclAllReduce", _inputs_flat, _attrs, _result, name) _result, = _result return _result
def batch(in_tensors, num_batch_threads, max_batch_size, batch_timeout_micros, grad_timeout_micros, allowed_batch_sizes=[], container="", shared_name="", batching_queue="", name=None): r"""Batches all input tensors nondeterministically. When many instances of this Op are being run concurrently with the same container/shared_name in the same device, some will output zero-shaped Tensors and others will output Tensors of size up to max_batch_size. All Tensors in in_tensors are batched together (so, for example, labels and features should be batched with a single instance of this operation. Each invocation of batch emits an `id` scalar which will be used to identify this particular invocation when doing unbatch or its gradient. Each op which emits a non-empty batch will also emit a non-empty batch_index Tensor, which, is a [K, 3] matrix where each row contains the invocation's id, start, and length of elements of each set of Tensors present in batched_tensors. Batched tensors are concatenated along the first dimension, and all tensors in in_tensors must have the first dimension of the same size. Args: in_tensors: A list of `Tensor` objects. The tensors to be batched. num_batch_threads: An `int`. Number of scheduling threads for processing batches of work. Determines the number of batches processed in parallel. max_batch_size: An `int`. Batch sizes will never be bigger than this. batch_timeout_micros: An `int`. Maximum number of microseconds to wait before outputting an incomplete batch. grad_timeout_micros: An `int`. The timeout to use for the gradient. See Unbatch. allowed_batch_sizes: An optional list of `ints`. Defaults to `[]`. Optional list of allowed batch sizes. If left empty, does nothing. Otherwise, supplies a list of batch sizes, causing the op to pad batches up to one of those sizes. The entries must increase monotonically, and the final entry must equal max_batch_size. container: An optional `string`. Defaults to `""`. Controls the scope of sharing of this batch. shared_name: An optional `string`. Defaults to `""`. Concurrently running instances of batch in the same device with the same container and shared_name will batch their elements together. If left empty, the op name will be used as the shared name. batching_queue: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (batched_tensors, batch_index, id). batched_tensors: A list of `Tensor` objects. Has the same type as `in_tensors`. Either empty tensors or a batch of concatenated Tensors. batch_index: A `Tensor` of type `int64`. If out_tensors is non-empty, has information to invert it. id: A `Tensor` of type `int64`. always contains a scalar with a unique ID for this invocation of Batch. """ num_batch_threads = _execute.make_int(num_batch_threads, "num_batch_threads") max_batch_size = _execute.make_int(max_batch_size, "max_batch_size") batch_timeout_micros = _execute.make_int(batch_timeout_micros, "batch_timeout_micros") grad_timeout_micros = _execute.make_int(grad_timeout_micros, "grad_timeout_micros") if allowed_batch_sizes is None: allowed_batch_sizes = [] if not isinstance(allowed_batch_sizes, (list, tuple)): raise TypeError("Expected list for 'allowed_batch_sizes' argument to " "'batch' Op, not %r." % allowed_batch_sizes) allowed_batch_sizes = [ _execute.make_int(_i, "allowed_batch_sizes") for _i in allowed_batch_sizes ] if container is None: container = "" container = _execute.make_str(container, "container") if shared_name is None: shared_name = "" shared_name = _execute.make_str(shared_name, "shared_name") if batching_queue is None: batching_queue = "" batching_queue = _execute.make_str(batching_queue, "batching_queue") _ctx = _context.context() if _ctx.in_graph_mode(): _, _, _op = _op_def_lib._apply_op_helper( "Batch", in_tensors=in_tensors, num_batch_threads=num_batch_threads, max_batch_size=max_batch_size, batch_timeout_micros=batch_timeout_micros, grad_timeout_micros=grad_timeout_micros, allowed_batch_sizes=allowed_batch_sizes, container=container, shared_name=shared_name, batching_queue=batching_queue, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("num_batch_threads", _op.get_attr("num_batch_threads"), "max_batch_size", _op.get_attr("max_batch_size"), "batch_timeout_micros", _op.get_attr("batch_timeout_micros"), "allowed_batch_sizes", _op.get_attr("allowed_batch_sizes"), "grad_timeout_micros", _op.get_attr("grad_timeout_micros"), "container", _op.get_attr("container"), "shared_name", _op.get_attr("shared_name"), "batching_queue", _op.get_attr("batching_queue"), "T", _op.get_attr("T")) else: _attr_T, in_tensors = _execute.convert_to_mixed_eager_tensors( in_tensors, _ctx) _attr_T = [_t.as_datatype_enum for _t in _attr_T] _inputs_flat = list(in_tensors) _attrs = ("num_batch_threads", num_batch_threads, "max_batch_size", max_batch_size, "batch_timeout_micros", batch_timeout_micros, "allowed_batch_sizes", allowed_batch_sizes, "grad_timeout_micros", grad_timeout_micros, "container", container, "shared_name", shared_name, "batching_queue", batching_queue, "T", _attr_T) _result = _execute.execute(b"Batch", len(in_tensors) + 2, inputs=_inputs_flat, attrs=_attrs, ctx=_ctx, name=name) _execute.record_gradient("Batch", _inputs_flat, _attrs, _result, name) _result = [_result[:len(in_tensors)]] + _result[len(in_tensors):] _result = _BatchOutput._make(_result) return _result
def batch_function(in_tensors, captured_tensors, f, num_batch_threads, max_batch_size, batch_timeout_micros, Tout, max_enqueued_batches=10, allowed_batch_sizes=[], container="", shared_name="", batching_queue="", name=None): r"""Batches all the inputs tensors to the computation done by the function. So, for example, in the following code ```python # This input will be captured. y = tf.placeholder_with_default(1.0, shape=[]) @tf.Defun(tf.float32) def computation(a): return tf.matmul(a, a) + y b = gen_batch_ops.batch_function( f=computation in_tensors=[a], captured_tensors=computation.captured_inputs, Tout=[o.type for o in computation.definition.signature.output_arg], num_batch_threads=1, max_batch_size=10, batch_timeout_micros=100000, # 100ms allowed_batch_sizes=[3, 10], batching_queue="") If more than one session.run call is simultaneously trying to compute `b` the values of `a` will be gathered, non-deterministically concatenated along the first axis, and only one thread will run the computation. Assumes that all arguments of the function are Tensors which will be batched along their first dimension. Arguments that are captured, are not batched. The session.run call which does the concatenation, will use the values of the captured tensors available to it. Therefore, typical uses of captured tensors should involve values which remain unchanged across session.run calls. Inference is a good example of this. SparseTensor is not supported. The return value of the decorated function must be a Tensor or a list/tuple of Tensors. Args: in_tensors: A list of `Tensor` objects. The tensors to be batched. captured_tensors: A list of `Tensor` objects. The tensors which are captured in the function, and don't need to be batched. f: A function decorated with @Defun. num_batch_threads: An `int`. Number of scheduling threads for processing batches of work. Determines the number of batches processed in parallel. max_batch_size: An `int`. Batch sizes will never be bigger than this. batch_timeout_micros: An `int`. Maximum number of microseconds to wait before outputting an incomplete batch. Tout: A list of `tf.DTypes` that has length `>= 1`. the types of the output tensors. max_enqueued_batches: An optional `int`. Defaults to `10`. Maximum number of batches enqueued. Default: 10. allowed_batch_sizes: An optional list of `ints`. Defaults to `[]`. Optional list of allowed batch sizes. If left empty, does nothing. Otherwise, supplies a list of batch sizes, causing the op to pad batches up to one of those sizes. The entries must increase monotonically, and the final entry must equal max_batch_size. container: An optional `string`. Defaults to `""`. Controls the scope of sharing of this batch. shared_name: An optional `string`. Defaults to `""`. Concurrently running instances of batch in the same device with the same container and shared_name will batch their elements together. If left empty, the op name will be used as the shared name. batching_queue: 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() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "BatchFunction", name, _ctx.post_execution_callbacks, in_tensors, captured_tensors, "f", f, "num_batch_threads", num_batch_threads, "max_batch_size", max_batch_size, "batch_timeout_micros", batch_timeout_micros, "max_enqueued_batches", max_enqueued_batches, "allowed_batch_sizes", allowed_batch_sizes, "container", container, "shared_name", shared_name, "batching_queue", batching_queue, "Tout", Tout) return _result except _core._FallbackException: try: return batch_function_eager_fallback( in_tensors, captured_tensors, f=f, num_batch_threads=num_batch_threads, max_batch_size=max_batch_size, batch_timeout_micros=batch_timeout_micros, max_enqueued_batches=max_enqueued_batches, allowed_batch_sizes=allowed_batch_sizes, container=container, shared_name=shared_name, batching_queue=batching_queue, Tout=Tout, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. num_batch_threads = _execute.make_int(num_batch_threads, "num_batch_threads") max_batch_size = _execute.make_int(max_batch_size, "max_batch_size") batch_timeout_micros = _execute.make_int(batch_timeout_micros, "batch_timeout_micros") if not isinstance(Tout, (list, tuple)): raise TypeError( "Expected list for 'Tout' argument to " "'batch_function' Op, not %r." % Tout) Tout = [_execute.make_type(_t, "Tout") for _t in Tout] if max_enqueued_batches is None: max_enqueued_batches = 10 max_enqueued_batches = _execute.make_int(max_enqueued_batches, "max_enqueued_batches") if allowed_batch_sizes is None: allowed_batch_sizes = [] if not isinstance(allowed_batch_sizes, (list, tuple)): raise TypeError( "Expected list for 'allowed_batch_sizes' argument to " "'batch_function' Op, not %r." % allowed_batch_sizes) allowed_batch_sizes = [_execute.make_int(_i, "allowed_batch_sizes") for _i in allowed_batch_sizes] if container is None: container = "" container = _execute.make_str(container, "container") if shared_name is None: shared_name = "" shared_name = _execute.make_str(shared_name, "shared_name") if batching_queue is None: batching_queue = "" batching_queue = _execute.make_str(batching_queue, "batching_queue") _, _, _op = _op_def_lib._apply_op_helper( "BatchFunction", in_tensors=in_tensors, captured_tensors=captured_tensors, f=f, num_batch_threads=num_batch_threads, max_batch_size=max_batch_size, batch_timeout_micros=batch_timeout_micros, Tout=Tout, max_enqueued_batches=max_enqueued_batches, allowed_batch_sizes=allowed_batch_sizes, container=container, shared_name=shared_name, batching_queue=batching_queue, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("f", _op.get_attr("f"), "num_batch_threads", _op.get_attr("num_batch_threads"), "max_batch_size", _op.get_attr("max_batch_size"), "batch_timeout_micros", _op.get_attr("batch_timeout_micros"), "max_enqueued_batches", _op.get_attr("max_enqueued_batches"), "allowed_batch_sizes", _op.get_attr("allowed_batch_sizes"), "container", _op.get_attr("container"), "shared_name", _op.get_attr("shared_name"), "batching_queue", _op.get_attr("batching_queue"), "Tin", _op.get_attr("Tin"), "Tcaptured", _op.get_attr("Tcaptured"), "Tout", _op.get_attr("Tout")) _execute.record_gradient( "BatchFunction", _inputs_flat, _attrs, _result, name) return _result
def center_tree_ensemble_bias(tree_ensemble_handle, stamp_token, next_stamp_token, delta_updates, learner_config, centering_epsilon=0.01, name=None): r"""Centers the tree ensemble bias before adding trees based on feature splits. Args: tree_ensemble_handle: A `Tensor` of type `resource`. Handle to the ensemble variable. stamp_token: A `Tensor` of type `int64`. Stamp token for validating operation consistency. next_stamp_token: A `Tensor` of type `int64`. Stamp token to be used for the next iteration. delta_updates: A `Tensor` of type `float32`. Rank 1 Tensor containing delta updates per bias dimension. learner_config: A `string`. Config for the learner of type LearnerConfig proto. centering_epsilon: An optional `float`. Defaults to `0.01`. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. Scalar indicating whether more centering is needed. """ _ctx = _context._context or _context.context() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "CenterTreeEnsembleBias", name, _ctx._post_execution_callbacks, tree_ensemble_handle, stamp_token, next_stamp_token, delta_updates, "learner_config", learner_config, "centering_epsilon", centering_epsilon) return _result except _core._FallbackException: try: return center_tree_ensemble_bias_eager_fallback( tree_ensemble_handle, stamp_token, next_stamp_token, delta_updates, learner_config=learner_config, centering_epsilon=centering_epsilon, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except (TypeError, ValueError): result = _dispatch.dispatch( center_tree_ensemble_bias, tree_ensemble_handle=tree_ensemble_handle, stamp_token=stamp_token, next_stamp_token=next_stamp_token, delta_updates=delta_updates, learner_config=learner_config, centering_epsilon=centering_epsilon, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. learner_config = _execute.make_str(learner_config, "learner_config") if centering_epsilon is None: centering_epsilon = 0.01 centering_epsilon = _execute.make_float(centering_epsilon, "centering_epsilon") try: _, _, _op = _op_def_lib._apply_op_helper( "CenterTreeEnsembleBias", tree_ensemble_handle=tree_ensemble_handle, stamp_token=stamp_token, next_stamp_token=next_stamp_token, delta_updates=delta_updates, learner_config=learner_config, centering_epsilon=centering_epsilon, name=name) except (TypeError, ValueError): result = _dispatch.dispatch(center_tree_ensemble_bias, tree_ensemble_handle=tree_ensemble_handle, stamp_token=stamp_token, next_stamp_token=next_stamp_token, delta_updates=delta_updates, learner_config=learner_config, centering_epsilon=centering_epsilon, name=name) if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: return result raise _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("learner_config", _op.get_attr("learner_config"), "centering_epsilon", _op.get_attr("centering_epsilon")) _execute.record_gradient("CenterTreeEnsembleBias", _inputs_flat, _attrs, _result, name) _result, = _result return _result
def batch(in_tensors, num_batch_threads, max_batch_size, batch_timeout_micros, grad_timeout_micros, max_enqueued_batches=10, allowed_batch_sizes=[], container="", shared_name="", batching_queue="", name=None): r"""Batches all input tensors nondeterministically. When many instances of this Op are being run concurrently with the same container/shared_name in the same device, some will output zero-shaped Tensors and others will output Tensors of size up to max_batch_size. All Tensors in in_tensors are batched together (so, for example, labels and features should be batched with a single instance of this operation. Each invocation of batch emits an `id` scalar which will be used to identify this particular invocation when doing unbatch or its gradient. Each op which emits a non-empty batch will also emit a non-empty batch_index Tensor, which, is a [K, 3] matrix where each row contains the invocation's id, start, and length of elements of each set of Tensors present in batched_tensors. Batched tensors are concatenated along the first dimension, and all tensors in in_tensors must have the first dimension of the same size. in_tensors: The tensors to be batched. num_batch_threads: Number of scheduling threads for processing batches of work. Determines the number of batches processed in parallel. max_batch_size: Batch sizes will never be bigger than this. batch_timeout_micros: Maximum number of microseconds to wait before outputting an incomplete batch. allowed_batch_sizes: Optional list of allowed batch sizes. If left empty, does nothing. Otherwise, supplies a list of batch sizes, causing the op to pad batches up to one of those sizes. The entries must increase monotonically, and the final entry must equal max_batch_size. grad_timeout_micros: The timeout to use for the gradient. See Unbatch. batched_tensors: Either empty tensors or a batch of concatenated Tensors. batch_index: If out_tensors is non-empty, has information to invert it. container: Controls the scope of sharing of this batch. id: always contains a scalar with a unique ID for this invocation of Batch. shared_name: Concurrently running instances of batch in the same device with the same container and shared_name will batch their elements together. If left empty, the op name will be used as the shared name. T: the types of tensors to be batched. Args: in_tensors: A list of `Tensor` objects. num_batch_threads: An `int`. max_batch_size: An `int`. batch_timeout_micros: An `int`. grad_timeout_micros: An `int`. max_enqueued_batches: An optional `int`. Defaults to `10`. allowed_batch_sizes: An optional list of `ints`. Defaults to `[]`. container: An optional `string`. Defaults to `""`. shared_name: An optional `string`. Defaults to `""`. batching_queue: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (batched_tensors, batch_index, id). batched_tensors: A list of `Tensor` objects. Has the same type as `in_tensors`. batch_index: A `Tensor` of type `int64`. id: A `Tensor` of type `int64`. """ _ctx = _context._context or _context.context() if _ctx is not None and _ctx._thread_local_data.is_eager: try: _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( _ctx._context_handle, _ctx._thread_local_data.device_name, "Batch", name, _ctx.post_execution_callbacks, in_tensors, "num_batch_threads", num_batch_threads, "max_batch_size", max_batch_size, "max_enqueued_batches", max_enqueued_batches, "batch_timeout_micros", batch_timeout_micros, "allowed_batch_sizes", allowed_batch_sizes, "grad_timeout_micros", grad_timeout_micros, "container", container, "shared_name", shared_name, "batching_queue", batching_queue) _result = _BatchOutput._make(_result) return _result except _core._FallbackException: try: return batch_eager_fallback( in_tensors, num_batch_threads=num_batch_threads, max_batch_size=max_batch_size, max_enqueued_batches=max_enqueued_batches, batch_timeout_micros=batch_timeout_micros, allowed_batch_sizes=allowed_batch_sizes, grad_timeout_micros=grad_timeout_micros, container=container, shared_name=shared_name, batching_queue=batching_queue, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. except _core._NotOkStatusException as e: if name is not None: message = e.message + " name: " + name else: message = e.message _six.raise_from(_core._status_to_exception(e.code, message), None) # Add nodes to the TensorFlow graph. num_batch_threads = _execute.make_int(num_batch_threads, "num_batch_threads") max_batch_size = _execute.make_int(max_batch_size, "max_batch_size") batch_timeout_micros = _execute.make_int(batch_timeout_micros, "batch_timeout_micros") grad_timeout_micros = _execute.make_int(grad_timeout_micros, "grad_timeout_micros") if max_enqueued_batches is None: max_enqueued_batches = 10 max_enqueued_batches = _execute.make_int(max_enqueued_batches, "max_enqueued_batches") if allowed_batch_sizes is None: allowed_batch_sizes = [] if not isinstance(allowed_batch_sizes, (list, tuple)): raise TypeError( "Expected list for 'allowed_batch_sizes' argument to " "'batch' Op, not %r." % allowed_batch_sizes) allowed_batch_sizes = [_execute.make_int(_i, "allowed_batch_sizes") for _i in allowed_batch_sizes] if container is None: container = "" container = _execute.make_str(container, "container") if shared_name is None: shared_name = "" shared_name = _execute.make_str(shared_name, "shared_name") if batching_queue is None: batching_queue = "" batching_queue = _execute.make_str(batching_queue, "batching_queue") _, _, _op = _op_def_lib._apply_op_helper( "Batch", in_tensors=in_tensors, num_batch_threads=num_batch_threads, max_batch_size=max_batch_size, batch_timeout_micros=batch_timeout_micros, grad_timeout_micros=grad_timeout_micros, max_enqueued_batches=max_enqueued_batches, allowed_batch_sizes=allowed_batch_sizes, container=container, shared_name=shared_name, batching_queue=batching_queue, name=name) _result = _op.outputs[:] _inputs_flat = _op.inputs _attrs = ("num_batch_threads", _op.get_attr("num_batch_threads"), "max_batch_size", _op.get_attr("max_batch_size"), "max_enqueued_batches", _op.get_attr("max_enqueued_batches"), "batch_timeout_micros", _op.get_attr("batch_timeout_micros"), "allowed_batch_sizes", _op.get_attr("allowed_batch_sizes"), "grad_timeout_micros", _op.get_attr("grad_timeout_micros"), "container", _op.get_attr("container"), "shared_name", _op.get_attr("shared_name"), "batching_queue", _op.get_attr("batching_queue"), "T", _op.get_attr("T")) _execute.record_gradient( "Batch", _inputs_flat, _attrs, _result, name) _result = [_result[:len(in_tensors)]] + _result[len(in_tensors):] _result = _BatchOutput._make(_result) return _result