op

func Abort ¶

func Abort(scope *Scope, optional ...AbortAttr) (o *tf.Operation)

Raise a exception to abort the process when called.

If exit_without_error is true, the process will exit normally, otherwise it will exit with a SIGABORT signal.

Returns nothing but an exception.

Returns the created operation.

func Abs ¶

func Abs(scope *Scope, x tf.Output) (y tf.Output)

Computes the absolute value of a tensor.

Given a tensor `x`, this operation returns a tensor containing the absolute value of each element in `x`. For example, if x is an input element and y is an output element, this operation computes \\(y = |x|\\).

func AccumulateNV2 ¶

func AccumulateNV2(scope *Scope, inputs []tf.Output, shape tf.Shape) (sum tf.Output)

Returns the element-wise sum of a list of tensors.

`tf.accumulate_n_v2` performs the same operation as `tf.add_n`, but does not wait for all of its inputs to be ready before beginning to sum. This can save memory if inputs are ready at different times, since minimum temporary storage is proportional to the output size rather than the inputs size.

Unlike the original `accumulate_n`, `accumulate_n_v2` is differentiable.

Returns a `Tensor` of same shape and type as the elements of `inputs`.

Arguments:

inputs: A list of `Tensor` objects, each with same shape and type.
shape: Shape of elements of `inputs`.

func Acos ¶

func Acos(scope *Scope, x tf.Output) (y tf.Output)

Computes acos of x element-wise.

func Acosh ¶

func Acosh(scope *Scope, x tf.Output) (y tf.Output)

Computes inverse hyperbolic cosine of x element-wise.

Given an input tensor, the function computes inverse hyperbolic cosine of every element. Input range is `[1, inf]`. It returns `nan` if the input lies outside the range.

```python x = tf.constant([-2, -0.5, 1, 1.2, 200, 10000, float("inf")]) tf.math.acosh(x) ==> [nan nan 0. 0.62236255 5.9914584 9.903487 inf] ```

func Add ¶

func Add(scope *Scope, x tf.Output, y tf.Output) (z tf.Output)

Returns x + y element-wise.

*NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)

func AddManySparseToTensorsMap ¶

func AddManySparseToTensorsMap(scope *Scope, sparse_indices tf.Output, sparse_values tf.Output, sparse_shape tf.Output, optional ...AddManySparseToTensorsMapAttr) (sparse_handles tf.Output)

Add an `N`-minibatch `SparseTensor` to a `SparseTensorsMap`, return `N` handles.

A `SparseTensor` of rank `R` is represented by three tensors: `sparse_indices`, `sparse_values`, and `sparse_shape`, where

```sparse_indices.shape[1] == sparse_shape.shape[0] == R```

An `N`-minibatch of `SparseTensor` objects is represented as a `SparseTensor` having a first `sparse_indices` column taking values between `[0, N)`, where the minibatch size `N == sparse_shape[0]`.

The input `SparseTensor` must have rank `R` greater than 1, and the first dimension is treated as the minibatch dimension. Elements of the `SparseTensor` must be sorted in increasing order of this first dimension. The stored `SparseTensor` objects pointed to by each row of the output `sparse_handles` will have rank `R-1`.

The `SparseTensor` values can then be read out as part of a minibatch by passing the given keys as vector elements to `TakeManySparseFromTensorsMap`. To ensure the correct `SparseTensorsMap` is accessed, ensure that the same `container` and `shared_name` are passed to that Op. If no `shared_name` is provided here, instead use the *name* of the Operation created by calling `AddManySparseToTensorsMap` as the `shared_name` passed to `TakeManySparseFromTensorsMap`. Ensure the Operations are colocated.

Arguments:

sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.

`sparse_indices[:, 0]` must be ordered values in `[0, N)`.

sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.

The minibatch size `N == sparse_shape[0]`.

Returns 1-D. The handles of the `SparseTensor` now stored in the `SparseTensorsMap`. Shape: `[N]`.

func AddN ¶

func AddN(scope *Scope, inputs []tf.Output) (sum tf.Output)

Add all input tensors element wise.

Inputs must be of same size and shape.

```python
x = [9, 7, 10]
tf.math.add_n(x) ==> 26
```

func AddSparseToTensorsMap ¶

func AddSparseToTensorsMap(scope *Scope, sparse_indices tf.Output, sparse_values tf.Output, sparse_shape tf.Output, optional ...AddSparseToTensorsMapAttr) (sparse_handle tf.Output)

Add a `SparseTensor` to a `SparseTensorsMap` return its handle.

A `SparseTensor` is represented by three tensors: `sparse_indices`, `sparse_values`, and `sparse_shape`.

This operator takes the given `SparseTensor` and adds it to a container object (a `SparseTensorsMap`). A unique key within this container is generated in the form of an `int64`, and this is the value that is returned.

The `SparseTensor` can then be read out as part of a minibatch by passing the key as a vector element to `TakeManySparseFromTensorsMap`. To ensure the correct `SparseTensorsMap` is accessed, ensure that the same `container` and `shared_name` are passed to that Op. If no `shared_name` is provided here, instead use the *name* of the Operation created by calling `AddSparseToTensorsMap` as the `shared_name` passed to `TakeManySparseFromTensorsMap`. Ensure the Operations are colocated.

Arguments:

sparse_indices: 2-D.  The `indices` of the `SparseTensor`.
sparse_values: 1-D.  The `values` of the `SparseTensor`.
sparse_shape: 1-D.  The `shape` of the `SparseTensor`.

Returns 0-D. The handle of the `SparseTensor` now stored in the `SparseTensorsMap`.

func AddV2 ¶

func AddV2(scope *Scope, x tf.Output, y tf.Output) (z tf.Output)

Returns x + y element-wise.

*NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)

func AdjustContrast ¶

func AdjustContrast(scope *Scope, images tf.Output, contrast_factor tf.Output, min_value tf.Output, max_value tf.Output) (output tf.Output)

Deprecated. Disallowed in GraphDef version >= 2.

DEPRECATED at GraphDef version 2: Use AdjustContrastv2 instead

func AdjustContrastv2 ¶

func AdjustContrastv2(scope *Scope, images tf.Output, contrast_factor tf.Output) (output tf.Output)

Adjust the contrast of one or more images.

`images` is a tensor of at least 3 dimensions. The last 3 dimensions are interpreted as `[height, width, channels]`. The other dimensions only represent a collection of images, such as `[batch, height, width, channels].`

Contrast is adjusted independently for each channel of each image.

For each channel, the Op first computes the mean of the image pixels in the channel and then adjusts each component of each pixel to `(x - mean) * contrast_factor + mean`.

Arguments:

images: Images to adjust.  At least 3-D.
contrast_factor: A float multiplier for adjusting contrast.

Returns The contrast-adjusted image or images.

func AdjustHue ¶

func AdjustHue(scope *Scope, images tf.Output, delta tf.Output) (output tf.Output)

Adjust the hue of one or more images.

`images` is a tensor of at least 3 dimensions. The last dimension is interpretted as channels, and must be three.

The input image is considered in the RGB colorspace. Conceptually, the RGB colors are first mapped into HSV. A delta is then applied all the hue values, and then remapped back to RGB colorspace.

Arguments:

images: Images to adjust.  At least 3-D.
delta: A float delta to add to the hue.

Returns The hue-adjusted image or images.

func AdjustSaturation ¶

func AdjustSaturation(scope *Scope, images tf.Output, scale tf.Output) (output tf.Output)

Adjust the saturation of one or more images.

`images` is a tensor of at least 3 dimensions. The last dimension is interpretted as channels, and must be three.

The input image is considered in the RGB colorspace. Conceptually, the RGB colors are first mapped into HSV. A scale is then applied all the saturation values, and then remapped back to RGB colorspace.

Arguments:

images: Images to adjust.  At least 3-D.
scale: A float scale to add to the saturation.

Returns The hue-adjusted image or images.

func All ¶

func All(scope *Scope, input tf.Output, axis tf.Output, optional ...AllAttr) (output tf.Output)

Computes the "logical and" of elements across dimensions of a tensor.

Reduces `input` along the dimensions given in `axis`. Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keep_dims` is true, the reduced dimensions are retained with length 1.

Arguments:

input: The tensor to reduce.
axis: The dimensions to reduce. Must be in the range

`[-rank(input), rank(input))`.

Returns The reduced tensor.

func AllCandidateSampler ¶

func AllCandidateSampler(scope *Scope, true_classes tf.Output, num_true int64, num_sampled int64, unique bool, optional ...AllCandidateSamplerAttr) (sampled_candidates tf.Output, true_expected_count tf.Output, sampled_expected_count tf.Output)

Generates labels for candidate sampling with a learned unigram distribution.

See explanations of candidate sampling and the data formats at go/candidate-sampling.

For each batch, this op picks a single set of sampled candidate labels.

The advantages of sampling candidates per-batch are simplicity and the possibility of efficient dense matrix multiplication. The disadvantage is that the sampled candidates must be chosen independently of the context and of the true labels.

Arguments:

true_classes: A batch_size * num_true matrix, in which each row contains the

IDs of the num_true target_classes in the corresponding original label.

num_true: Number of true labels per context.
num_sampled: Number of candidates to produce.
unique: If unique is true, we sample with rejection, so that all sampled

candidates in a batch are unique. This requires some approximation to estimate the post-rejection sampling probabilities.

Returns A vector of length num_sampled, in which each element is the ID of a sampled candidate.A batch_size * num_true matrix, representing the number of times each candidate is expected to occur in a batch of sampled candidates. If unique=true, then this is a probability.A vector of length num_sampled, for each sampled candidate representing the number of times the candidate is expected to occur in a batch of sampled candidates. If unique=true, then this is a probability.

func AllToAll ¶

func AllToAll(scope *Scope, input tf.Output, group_assignment tf.Output, concat_dimension int64, split_dimension int64, split_count int64) (output tf.Output)

An Op to exchange data across TPU replicas.

On each replica, the input is split into `split_count` blocks along `split_dimension` and send to the other replicas given group_assignment. After receiving `split_count` - 1 blocks from other replicas, we concatenate the blocks along `concat_dimension` as the output.

For example, suppose there are 2 TPU replicas: replica 0 receives input: `[[A, B]]` replica 1 receives input: `[[C, D]]`

group_assignment=`[[0, 1]]` concat_dimension=0 split_dimension=1 split_count=2

replica 0's output: `[[A], [C]]` replica 1's output: `[[B], [D]]`

Arguments:

input: The local input to the sum.
group_assignment: An int32 tensor with shape

[num_groups, num_replicas_per_group]. `group_assignment[i]` represents the replica ids in the ith subgroup.

concat_dimension: The dimension number to concatenate.
split_dimension: The dimension number to split.
split_count: The number of splits, this number must equal to the sub-group

size(group_assignment.get_shape()[1])

Returns The exchanged result.

func Angle ¶

func Angle(scope *Scope, input tf.Output, optional ...AngleAttr) (output tf.Output)

Returns the argument of a complex number.

Given a tensor `input` of complex numbers, this operation returns a tensor of type `float` that is the argument of each element in `input`. All elements in `input` must be complex numbers of the form \\(a + bj\\), where *a* is the real part and *b* is the imaginary part.

The argument returned by this operation is of the form \\(atan2(b, a)\\).

For example:

``` # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j] tf.angle(input) ==> [2.0132, 1.056] ```

@compatibility(numpy) Equivalent to np.angle. @end_compatibility

func AnonymousIterator ¶

func AnonymousIterator(scope *Scope, output_types []tf.DataType, output_shapes []tf.Shape) (handle tf.Output)

A container for an iterator resource.

Returns A handle to the iterator that can be passed to a "MakeIterator" or "IteratorGetNext" op. In contrast to Iterator, AnonymousIterator prevents resource sharing by name, and does not keep a reference to the resource container.

func AnonymousIteratorV2 ¶

func AnonymousIteratorV2(scope *Scope, output_types []tf.DataType, output_shapes []tf.Shape) (handle tf.Output, deleter tf.Output)

A container for an iterator resource.

Returns A handle to the iterator that can be passed to a "MakeIterator" or "IteratorGetNext" op. In contrast to Iterator, AnonymousIterator prevents resource sharing by name, and does not keep a reference to the resource container.A variant deleter that should be passed into the op that deletes the iterator.

func Any ¶

func Any(scope *Scope, input tf.Output, axis tf.Output, optional ...AnyAttr) (output tf.Output)

Computes the "logical or" of elements across dimensions of a tensor.

Reduces `input` along the dimensions given in `axis`. Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keep_dims` is true, the reduced dimensions are retained with length 1.

Arguments:

input: The tensor to reduce.
axis: The dimensions to reduce. Must be in the range

`[-rank(input), rank(input))`.

Returns The reduced tensor.

func ApproximateEqual ¶

func ApproximateEqual(scope *Scope, x tf.Output, y tf.Output, optional ...ApproximateEqualAttr) (z tf.Output)

Returns the truth value of abs(x-y) < tolerance element-wise.

func ArgMax ¶

func ArgMax(scope *Scope, input tf.Output, dimension tf.Output, optional ...ArgMaxAttr) (output tf.Output)

Returns the index with the largest value across dimensions of a tensor.

Note that in case of ties the identity of the return value is not guaranteed.

Usage:

```python
import tensorflow as tf
a = [1, 10, 26.9, 2.8, 166.32, 62.3]
b = tf.math.argmax(input = a)
c = tf.keras.backend.eval(b)
# c = 4
# here a[4] = 166.32 which is the largest element of a across axis 0
```

Arguments:

dimension: int32 or int64, must be in the range `[-rank(input), rank(input))`.

Describes which dimension of the input Tensor to reduce across. For vectors, use dimension = 0.

func ArgMin ¶

func ArgMin(scope *Scope, input tf.Output, dimension tf.Output, optional ...ArgMinAttr) (output tf.Output)

Returns the index with the smallest value across dimensions of a tensor.

Note that in case of ties the identity of the return value is not guaranteed.

Usage:

```python
import tensorflow as tf
a = [1, 10, 26.9, 2.8, 166.32, 62.3]
b = tf.math.argmin(input = a)
c = tf.keras.backend.eval(b)
# c = 0
# here a[0] = 1 which is the smallest element of a across axis 0
```

Arguments:

dimension: int32 or int64, must be in the range `[-rank(input), rank(input))`.

Describes which dimension of the input Tensor to reduce across. For vectors, use dimension = 0.

func AsString ¶

func AsString(scope *Scope, input tf.Output, optional ...AsStringAttr) (output tf.Output)

Converts each entry in the given tensor to strings.

Supports many numeric types and boolean.

For Unicode, see the [https://www.tensorflow.org/tutorials/representation/unicode](Working with Unicode text) tutorial.

func Asin ¶

func Asin(scope *Scope, x tf.Output) (y tf.Output)

Computes the trignometric inverse sine of x element-wise.

The `tf.math.asin` operation returns the inverse of `tf.math.sin`, such that if `y = tf.math.sin(x)` then, `x = tf.math.asin(y)`.

**Note**: The output of `tf.math.asin` will lie within the invertible range of sine, i.e [-pi/2, pi/2].

For example:

```python # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)] x = tf.constant([1.047, 0.785]) y = tf.math.sin(x) # [0.8659266, 0.7068252]

tf.math.asin(y) # [1.047, 0.785] = x ```

func Asinh ¶

func Asinh(scope *Scope, x tf.Output) (y tf.Output)

Computes inverse hyperbolic sine of x element-wise.

Given an input tensor, this function computes inverse hyperbolic sine
for every element in the tensor. Both input and output has a range of
`[-inf, inf]`.

```python
x = tf.constant([-float("inf"), -2, -0.5, 1, 1.2, 200, 10000, float("inf")])
tf.math.asinh(x) ==> [-inf -1.4436355 -0.4812118 0.8813736 1.0159732 5.991471 9.903487 inf]
```

func Assert ¶

func Assert(scope *Scope, condition tf.Output, data []tf.Output, optional ...AssertAttr) (o *tf.Operation)

Asserts that the given condition is true.

If `condition` evaluates to false, print the list of tensors in `data`. `summarize` determines how many entries of the tensors to print.

Arguments:

condition: The condition to evaluate.
data: The tensors to print out when condition is false.

Returns the created operation.

func AssignAddVariableOp ¶

func AssignAddVariableOp(scope *Scope, resource tf.Output, value tf.Output) (o *tf.Operation)

Adds a value to the current value of a variable.

Any ReadVariableOp with a control dependency on this op is guaranteed to see the incremented value or a subsequent newer one.

Arguments:

resource: handle to the resource in which to store the variable.
value: the value by which the variable will be incremented.

Returns the created operation.

func AssignSubVariableOp ¶

func AssignSubVariableOp(scope *Scope, resource tf.Output, value tf.Output) (o *tf.Operation)

Subtracts a value from the current value of a variable.

Any ReadVariableOp with a control dependency on this op is guaranteed to see the decremented value or a subsequent newer one.

Arguments:

resource: handle to the resource in which to store the variable.
value: the value by which the variable will be incremented.

Returns the created operation.

func AssignVariableOp ¶

func AssignVariableOp(scope *Scope, resource tf.Output, value tf.Output) (o *tf.Operation)

Assigns a new value to a variable.

Any ReadVariableOp with a control dependency on this op is guaranteed to return this value or a subsequent newer value of the variable.

Arguments:

resource: handle to the resource in which to store the variable.
value: the value to set the new tensor to use.

Returns the created operation.

func Atan ¶

func Atan(scope *Scope, x tf.Output) (y tf.Output)

Computes the trignometric inverse tangent of x element-wise.

The `tf.math.atan` operation returns the inverse of `tf.math.tan`, such that if `y = tf.math.tan(x)` then, `x = tf.math.atan(y)`.

**Note**: The output of `tf.math.atan` will lie within the invertible range of tan, i.e (-pi/2, pi/2).

For example:

```python # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)] x = tf.constant([1.047, 0.785]) y = tf.math.tan(x) # [1.731261, 0.99920404]

tf.math.atan(y) # [1.047, 0.785] = x ```

func Atan2 ¶

func Atan2(scope *Scope, y tf.Output, x tf.Output) (z tf.Output)

Computes arctangent of `y/x` element-wise, respecting signs of the arguments.

This is the angle \( \theta \in [-\pi, \pi] \) such that \[ x = r \cos(\theta) \] and \[ y = r \sin(\theta) \] where \(r = \sqrt(x^2 + y^2) \).

func Atanh ¶

func Atanh(scope *Scope, x tf.Output) (y tf.Output)

Computes inverse hyperbolic tangent of x element-wise.

Given an input tensor, this function computes inverse hyperbolic tangent
for every element in the tensor. Input range is `[-1,1]` and output range is
`[-inf, inf]`. If input is `-1`, output will be `-inf` and if the
input is `1`, output will be `inf`. Values outside the range will have
`nan` as output.

```python
x = tf.constant([-float("inf"), -1, -0.5, 1, 0, 0.5, 10, float("inf")])
tf.math.atanh(x) ==> [nan -inf -0.54930615 inf  0. 0.54930615 nan nan]
```

func AudioSpectrogram ¶

func AudioSpectrogram(scope *Scope, input tf.Output, window_size int64, stride int64, optional ...AudioSpectrogramAttr) (spectrogram tf.Output)

Produces a visualization of audio data over time.

Spectrograms are a standard way of representing audio information as a series of slices of frequency information, one slice for each window of time. By joining these together into a sequence, they form a distinctive fingerprint of the sound over time.

This op expects to receive audio data as an input, stored as floats in the range -1 to 1, together with a window width in samples, and a stride specifying how far to move the window between slices. From this it generates a three dimensional output. The first dimension is for the channels in the input, so a stereo audio input would have two here for example. The second dimension is time, with successive frequency slices. The third dimension has an amplitude value for each frequency during that time slice.

This means the layout when converted and saved as an image is rotated 90 degrees clockwise from a typical spectrogram. Time is descending down the Y axis, and the frequency decreases from left to right.

Each value in the result represents the square root of the sum of the real and imaginary parts of an FFT on the current window of samples. In this way, the lowest dimension represents the power of each frequency in the current window, and adjacent windows are concatenated in the next dimension.

To get a more intuitive and visual look at what this operation does, you can run tensorflow/examples/wav_to_spectrogram to read in an audio file and save out the resulting spectrogram as a PNG image.

Arguments:

input: Float representation of audio data.
window_size: How wide the input window is in samples. For the highest efficiency

this should be a power of two, but other values are accepted.

stride: How widely apart the center of adjacent sample windows should be.

Returns 3D representation of the audio frequencies as an image.

func AudioSummary ¶

func AudioSummary(scope *Scope, tag tf.Output, tensor tf.Output, sample_rate float32, optional ...AudioSummaryAttr) (summary tf.Output)

Outputs a `Summary` protocol buffer with audio.

DEPRECATED at GraphDef version 15: Use AudioSummaryV2.

The summary has up to `max_outputs` summary values containing audio. The audio is built from `tensor` which must be 3-D with shape `[batch_size, frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`.

The `tag` argument is a scalar `Tensor` of type `string`. It is used to build the `tag` of the summary values:

• If `max_outputs` is 1, the summary value tag is '*tag*/audio'.
• If `max_outputs` is greater than 1, the summary value tags are generated sequentially as '*tag*/audio/0', '*tag*/audio/1', etc.

Arguments:

tag: Scalar. Used to build the `tag` attribute of the summary values.
tensor: 2-D of shape `[batch_size, frames]`.
sample_rate: The sample rate of the signal in hertz.

Returns Scalar. Serialized `Summary` protocol buffer.

func AudioSummaryV2 ¶

func AudioSummaryV2(scope *Scope, tag tf.Output, tensor tf.Output, sample_rate tf.Output, optional ...AudioSummaryV2Attr) (summary tf.Output)

Outputs a `Summary` protocol buffer with audio.

The summary has up to `max_outputs` summary values containing audio. The audio is built from `tensor` which must be 3-D with shape `[batch_size, frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`.

The `tag` argument is a scalar `Tensor` of type `string`. It is used to build the `tag` of the summary values:

• If `max_outputs` is 1, the summary value tag is '*tag*/audio'.
• If `max_outputs` is greater than 1, the summary value tags are generated sequentially as '*tag*/audio/0', '*tag*/audio/1', etc.

Arguments:

tag: Scalar. Used to build the `tag` attribute of the summary values.
tensor: 2-D of shape `[batch_size, frames]`.
sample_rate: The sample rate of the signal in hertz.

Returns Scalar. Serialized `Summary` protocol buffer.

func AutoShardDataset ¶

func AutoShardDataset(scope *Scope, input_dataset tf.Output, num_workers tf.Output, index tf.Output, output_types []tf.DataType, output_shapes []tf.Shape) (handle tf.Output)

Creates a dataset that shards the input dataset.

Creates a dataset that shards the input dataset by num_workers, returning a sharded dataset for the index-th worker. This attempts to automatically shard a dataset by examining the Dataset graph and inserting a shard op before the inputs to a reader Dataset (e.g. CSVDataset, TFRecordDataset).

This dataset will throw a NotFound error if we cannot shard the dataset automatically.

Arguments:

input_dataset: A variant tensor representing the input dataset.
num_workers: A scalar representing the number of workers to distribute this dataset across.
index: A scalar representing the index of the current worker out of num_workers.

func AvgPool ¶

func AvgPool(scope *Scope, value tf.Output, ksize []int64, strides []int64, padding string, optional ...AvgPoolAttr) (output tf.Output)

Performs average pooling on the input.

Each entry in `output` is the mean of the corresponding size `ksize` window in `value`.

Arguments:

value: 4-D with shape `[batch, height, width, channels]`.
ksize: The size of the sliding window for each dimension of `value`.
strides: The stride of the sliding window for each dimension of `value`.
padding: The type of padding algorithm to use.

Returns The average pooled output tensor.

func AvgPool3D ¶

func AvgPool3D(scope *Scope, input tf.Output, ksize []int64, strides []int64, padding string, optional ...AvgPool3DAttr) (output tf.Output)

Performs 3D average pooling on the input.

Arguments:

input: Shape `[batch, depth, rows, cols, channels]` tensor to pool over.
ksize: 1-D tensor of length 5. The size of the window for each dimension of

the input tensor. Must have `ksize[0] = ksize[4] = 1`.

strides: 1-D tensor of length 5. The stride of the sliding window for each

dimension of `input`. Must have `strides[0] = strides[4] = 1`.

padding: The type of padding algorithm to use.

Returns The average pooled output tensor.

func AvgPool3DGrad ¶

func AvgPool3DGrad(scope *Scope, orig_input_shape tf.Output, grad tf.Output, ksize []int64, strides []int64, padding string, optional ...AvgPool3DGradAttr) (output tf.Output)

Computes gradients of average pooling function.

Arguments:

orig_input_shape: The original input dimensions.
grad: Output backprop of shape `[batch, depth, rows, cols, channels]`.
ksize: 1-D tensor of length 5. The size of the window for each dimension of

the input tensor. Must have `ksize[0] = ksize[4] = 1`.

strides: 1-D tensor of length 5. The stride of the sliding window for each

dimension of `input`. Must have `strides[0] = strides[4] = 1`.

padding: The type of padding algorithm to use.

Returns The backprop for input.

func AvgPoolGrad ¶

func AvgPoolGrad(scope *Scope, orig_input_shape tf.Output, grad tf.Output, ksize []int64, strides []int64, padding string, optional ...AvgPoolGradAttr) (output tf.Output)

Computes gradients of the average pooling function.

Arguments:

orig_input_shape: 1-D.  Shape of the original input to `avg_pool`.
grad: 4-D with shape `[batch, height, width, channels]`.  Gradients w.r.t.

the output of `avg_pool`.

ksize: The size of the sliding window for each dimension of the input.
strides: The stride of the sliding window for each dimension of the input.
padding: The type of padding algorithm to use.

Returns 4-D. Gradients w.r.t. the input of `avg_pool`.

func Batch ¶

func Batch(scope *Scope, in_tensors []tf.Output, num_batch_threads int64, max_batch_size int64, batch_timeout_micros int64, grad_timeout_micros int64, optional ...BatchAttr) (batched_tensors []tf.Output, batch_index tf.Output, id tf.Output)

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.

func BatchDataset ¶

func BatchDataset(scope *Scope, input_dataset tf.Output, batch_size tf.Output, output_types []tf.DataType, output_shapes []tf.Shape) (handle tf.Output)

Creates a dataset that batches `batch_size` elements from `input_dataset`.

Arguments:

batch_size: A scalar representing the number of elements to accumulate in a

batch.

func BatchDatasetV2 ¶

func BatchDatasetV2(scope *Scope, input_dataset tf.Output, batch_size tf.Output, drop_remainder tf.Output, output_types []tf.DataType, output_shapes []tf.Shape, optional ...BatchDatasetV2Attr) (handle tf.Output)

Creates a dataset that batches `batch_size` elements from `input_dataset`.

Arguments:

batch_size: A scalar representing the number of elements to accumulate in a batch.
drop_remainder: A scalar representing whether the last batch should be dropped in case its size

is smaller than desired.

func BatchMatMul ¶

func BatchMatMul(scope *Scope, x tf.Output, y tf.Output, optional ...BatchMatMulAttr) (output tf.Output)

Multiplies slices of two tensors in batches.

Multiplies all slices of `Tensor` `x` and `y` (each slice can be viewed as an element of a batch), and arranges the individual results in a single output tensor of the same batch size. Each of the individual slices can optionally be adjointed (to adjoint a matrix means to transpose and conjugate it) before multiplication by setting the `adj_x` or `adj_y` flag to `True`, which are by default `False`.

The input tensors `x` and `y` are 2-D or higher with shape `[..., r_x, c_x]` and `[..., r_y, c_y]`.

The output tensor is 2-D or higher with shape `[..., r_o, c_o]`, where:

r_o = c_x if adj_x else r_x
c_o = r_y if adj_y else c_y

It is computed as:

output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])

Arguments:

x: 2-D or higher with shape `[..., r_x, c_x]`.
y: 2-D or higher with shape `[..., r_y, c_y]`.

Returns 3-D or higher with shape `[..., r_o, c_o]`

func BatchMatMulV2 ¶

func BatchMatMulV2(scope *Scope, x tf.Output, y tf.Output, optional ...BatchMatMulV2Attr) (output tf.Output)

Multiplies slices of two tensors in batches.

Multiplies all slices of `Tensor` `x` and `y` (each slice can be viewed as an element of a batch), and arranges the individual results in a single output tensor of the same batch size. Each of the individual slices can optionally be adjointed (to adjoint a matrix means to transpose and conjugate it) before multiplication by setting the `adj_x` or `adj_y` flag to `True`, which are by default `False`.

The input tensors `x` and `y` are 2-D or higher with shape `[..., r_x, c_x]` and `[..., r_y, c_y]`.

The output tensor is 2-D or higher with shape `[..., r_o, c_o]`, where:

r_o = c_x if adj_x else r_x
c_o = r_y if adj_y else c_y

It is computed as:

output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])

*NOTE*: `BatchMatMulV2` supports broadcasting in the batch dimensions. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html).

Arguments:

x: 2-D or higher with shape `[..., r_x, c_x]`.
y: 2-D or higher with shape `[..., r_y, c_y]`.

Returns 3-D or higher with shape `[..., r_o, c_o]`

func BatchNormWithGlobalNormalization ¶

func BatchNormWithGlobalNormalization(scope *Scope, t tf.Output, m tf.Output, v tf.Output, beta tf.Output, gamma tf.Output, variance_epsilon float32, scale_after_normalization bool) (result tf.Output)

Batch normalization.

DEPRECATED at GraphDef version 9: Use tf.nn.batch_normalization()

This op is deprecated. Prefer `tf.nn.batch_normalization`.

Arguments:

t: A 4D input Tensor.
m: A 1D mean Tensor with size matching the last dimension of t.

This is the first output from tf.nn.moments, or a saved moving average thereof.

v: A 1D variance Tensor with size matching the last dimension of t.

This is the second output from tf.nn.moments, or a saved moving average thereof.

beta: A 1D beta Tensor with size matching the last dimension of t.

An offset to be added to the normalized tensor.

gamma: A 1D gamma Tensor with size matching the last dimension of t.

If "scale_after_normalization" is true, this tensor will be multiplied with the normalized tensor.

variance_epsilon: A small float number to avoid dividing by 0.
scale_after_normalization: A bool indicating whether the resulted tensor

needs to be multiplied with gamma.

func BatchNormWithGlobalNormalizationGrad ¶

func BatchNormWithGlobalNormalizationGrad(scope *Scope, t tf.Output, m tf.Output, v tf.Output, gamma tf.Output, backprop tf.Output, variance_epsilon float32, scale_after_normalization bool) (dx tf.Output, dm tf.Output, dv tf.Output, db tf.Output, dg tf.Output)

Gradients for batch normalization.

DEPRECATED at GraphDef version 9: Use tf.nn.batch_normalization()

This op is deprecated. See `tf.nn.batch_normalization`.

Arguments:

t: A 4D input Tensor.
m: A 1D mean Tensor with size matching the last dimension of t.

This is the first output from tf.nn.moments, or a saved moving average thereof.

v: A 1D variance Tensor with size matching the last dimension of t.

This is the second output from tf.nn.moments, or a saved moving average thereof.

gamma: A 1D gamma Tensor with size matching the last dimension of t.

If "scale_after_normalization" is true, this Tensor will be multiplied with the normalized Tensor.

backprop: 4D backprop Tensor.
variance_epsilon: A small float number to avoid dividing by 0.
scale_after_normalization: A bool indicating whether the resulted tensor

needs to be multiplied with gamma.

Returns 4D backprop tensor for input.1D backprop tensor for mean.1D backprop tensor for variance.1D backprop tensor for beta.1D backprop tensor for gamma.

func BatchToSpace ¶

func BatchToSpace(scope *Scope, input tf.Output, crops tf.Output, block_size int64) (output tf.Output)

BatchToSpace for 4-D tensors of type T.

This is a legacy version of the more general BatchToSpaceND.

Rearranges (permutes) data from batch into blocks of spatial data, followed by cropping. This is the reverse transformation of SpaceToBatch. More specifically, this op outputs a copy of the input tensor where values from the `batch` dimension are moved in spatial blocks to the `height` and `width` dimensions, followed by cropping along the `height` and `width` dimensions.

Arguments:

input: 4-D tensor with shape

`[batch*block_size*block_size, height_pad/block_size, width_pad/block_size,

depth]`. Note that the batch size of the input tensor must be divisible by

`block_size * block_size`.

crops: 2-D tensor of non-negative integers with shape `[2, 2]`. It specifies

how many elements to crop from the intermediate result across the spatial dimensions as follows:

crops = [[crop_top, crop_bottom], [crop_left, crop_right]]

Returns 4-D with shape `[batch, height, width, depth]`, where:

height = height_pad - crop_top - crop_bottom
width = width_pad - crop_left - crop_right

The attr `block_size` must be greater than one. It indicates the block size.

Some examples:

(1) For the following input of shape `[4, 1, 1, 1]` and block_size of 2:

``` [[[[1]]], [[[2]]], [[[3]]], [[[4]]]] ```

The output tensor has shape `[1, 2, 2, 1]` and value:

``` x = [[[[1], [2]], [[3], [4]]]] ```

(2) For the following input of shape `[4, 1, 1, 3]` and block_size of 2:

``` [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]] ```

The output tensor has shape `[1, 2, 2, 3]` and value:

``` x = [[[[1, 2, 3], [4, 5, 6]],

[[7, 8, 9], [10, 11, 12]]]]

```

(3) For the following input of shape `[4, 2, 2, 1]` and block_size of 2:

``` x = [[[[1], [3]], [[9], [11]]],

[[[2], [4]], [[10], [12]]],
[[[5], [7]], [[13], [15]]],
[[[6], [8]], [[14], [16]]]]

```

The output tensor has shape `[1, 4, 4, 1]` and value:

``` x = [[[[1], [2], [3], [4]],

[[5],   [6],  [7],  [8]],
[[9],  [10], [11],  [12]],
[[13], [14], [15],  [16]]]]

```

(4) For the following input of shape `[8, 1, 2, 1]` and block_size of 2:

``` x = [[[[1], [3]]], [[[9], [11]]], [[[2], [4]]], [[[10], [12]]],

[[[5], [7]]], [[[13], [15]]], [[[6], [8]]], [[[14], [16]]]]

```

The output tensor has shape `[2, 2, 4, 1]` and value:

``` x = [[[[1], [3]], [[5], [7]]],

[[[2], [4]], [[10], [12]]],
[[[5], [7]], [[13], [15]]],
[[[6], [8]], [[14], [16]]]]

```

func BatchToSpaceND ¶

func BatchToSpaceND(scope *Scope, input tf.Output, block_shape tf.Output, crops tf.Output) (output tf.Output)

BatchToSpace for N-D tensors of type T.

This operation reshapes the "batch" dimension 0 into `M + 1` dimensions of shape `block_shape + [batch]`, interleaves these blocks back into the grid defined by the spatial dimensions `[1, ..., M]`, to obtain a result with the same rank as the input. The spatial dimensions of this intermediate result are then optionally cropped according to `crops` to produce the output. This is the reverse of SpaceToBatch. See below for a precise description.

Arguments:

input: N-D with shape `input_shape = [batch] + spatial_shape + remaining_shape`,

where spatial_shape has M dimensions.

	block_shape: 1-D with shape `[M]`, all values must be >= 1.
	crops: 2-D with shape `[M, 2]`, all values must be >= 0.
  `crops[i] = [crop_start, crop_end]` specifies the amount to crop from input
  dimension `i + 1`, which corresponds to spatial dimension `i`.  It is
  required that
  `crop_start[i] + crop_end[i] <= block_shape[i] * input_shape[i + 1]`.

This operation is equivalent to the following steps:

1. Reshape `input` to `reshaped` of shape: [block_shape[0], ..., block_shape[M-1], batch / prod(block_shape), input_shape[1], ..., input_shape[N-1]]

2. Permute dimensions of `reshaped` to produce `permuted` of shape [batch / prod(block_shape),

   input_shape[1], block_shape[0], ..., input_shape[M], block_shape[M-1],

   input_shape[M+1], ..., input_shape[N-1]]

3. Reshape `permuted` to produce `reshaped_permuted` of shape [batch / prod(block_shape),

   input_shape[1] * block_shape[0], ..., input_shape[M] * block_shape[M-1],

   input_shape[M+1], ..., input_shape[N-1]]

4. Crop the start and end of dimensions `[1, ..., M]` of `reshaped_permuted` according to `crops` to produce the output of shape: [batch / prod(block_shape),

   input_shape[1] * block_shape[0] - crops[0,0] - crops[0,1], ..., input_shape[M] * block_shape[M-1] - crops[M-1,0] - crops[M-1,1],

   input_shape[M+1], ..., input_shape[N-1]]

Some examples:

(1) For the following input of shape `[4, 1, 1, 1]`, `block_shape = [2, 2]`, and

`crops = [[0, 0], [0, 0]]`:

``` [[[[1]]], [[[2]]], [[[3]]], [[[4]]]] ```

The output tensor has shape `[1, 2, 2, 1]` and value:

``` x = [[[[1], [2]], [[3], [4]]]] ```

(2) For the following input of shape `[4, 1, 1, 3]`, `block_shape = [2, 2]`, and

`crops = [[0, 0], [0, 0]]`:

``` [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]] ```

The output tensor has shape `[1, 2, 2, 3]` and value:

``` x = [[[[1, 2, 3], [4, 5, 6]],

[[7, 8, 9], [10, 11, 12]]]]

```

(3) For the following input of shape `[4, 2, 2, 1]`, `block_shape = [2, 2]`, and

`crops = [[0, 0], [0, 0]]`:

``` x = [[[[1], [3]], [[9], [11]]],

[[[2], [4]], [[10], [12]]],
[[[5], [7]], [[13], [15]]],
[[[6], [8]], [[14], [16]]]]

```

The output tensor has shape `[1, 4, 4, 1]` and value:

``` x = [[[[1], [2], [3], [4]],

[[5],   [6],  [7],  [8]],
[[9],  [10], [11],  [12]],
[[13], [14], [15],  [16]]]]

```

(4) For the following input of shape `[8, 1, 3, 1]`, `block_shape = [2, 2]`, and

`crops = [[0, 0], [2, 0]]`:

``` x = [[[[0], [1], [3]]], [[[0], [9], [11]]],

[[[0], [2], [4]]], [[[0], [10], [12]]],
[[[0], [5], [7]]], [[[0], [13], [15]]],
[[[0], [6], [8]]], [[[0], [14], [16]]]]

```

The output tensor has shape `[2, 2, 4, 1]` and value:

``` x = [[[[1], [2], [3], [4]],

 [[5],   [6],  [7],  [8]]],
[[[9],  [10], [11],  [12]],
 [[13], [14], [15],  [16]]]]

```

func BesselI0e ¶

func BesselI0e(scope *Scope, x tf.Output) (y tf.Output)

Computes the Bessel i0e function of `x` element-wise.

Exponentially scaled modified Bessel function of order 0 defined as `bessel_i0e(x) = exp(-abs(x)) bessel_i0(x)`.

This function is faster and numerically stabler than `bessel_i0(x)`.

func BesselI1e ¶

func BesselI1e(scope *Scope, x tf.Output) (y tf.Output)

Computes the Bessel i1e function of `x` element-wise.

Exponentially scaled modified Bessel function of order 0 defined as `bessel_i1e(x) = exp(-abs(x)) bessel_i1(x)`.

This function is faster and numerically stabler than `bessel_i1(x)`.

func Betainc ¶

func Betainc(scope *Scope, a tf.Output, b tf.Output, x tf.Output) (z tf.Output)

Compute the regularized incomplete beta integral \\(I_x(a, b)\\).

The regularized incomplete beta integral is defined as:

\\(I_x(a, b) = \frac{B(x; a, b)}{B(a, b)}\\)

where

\\(B(x; a, b) = \int_0^x t^{a-1} (1 - t)^{b-1} dt\\)

is the incomplete beta function and \\(B(a, b)\\) is the *complete* beta function.

func BiasAdd ¶

func BiasAdd(scope *Scope, value tf.Output, bias tf.Output, optional ...BiasAddAttr) (output tf.Output)

Adds `bias` to `value`.

This is a special case of `tf.add` where `bias` is restricted to be 1-D. Broadcasting is supported, so `value` may have any number of dimensions.

Arguments:

value: Any number of dimensions.
bias: 1-D with size the last dimension of `value`.

Returns Broadcasted sum of `value` and `bias`.

func BiasAddGrad ¶

func BiasAddGrad(scope *Scope, out_backprop tf.Output, optional ...BiasAddGradAttr) (output tf.Output)

The backward operation for "BiasAdd" on the "bias" tensor.

It accumulates all the values from out_backprop into the feature dimension. For NHWC data format, the feature dimension is the last. For NCHW data format, the feature dimension is the third-to-last.

Arguments:

out_backprop: Any number of dimensions.

Returns 1-D with size the feature dimension of `out_backprop`.

func BiasAddV1 ¶

func BiasAddV1(scope *Scope, value tf.Output, bias tf.Output) (output tf.Output)

Adds `bias` to `value`.

This is a deprecated version of BiasAdd and will be soon removed.

This is a special case of `tf.add` where `bias` is restricted to be 1-D. Broadcasting is supported, so `value` may have any number of dimensions.

Arguments:

value: Any number of dimensions.
bias: 1-D with size the last dimension of `value`.

Returns Broadcasted sum of `value` and `bias`.

func Bincount ¶

func Bincount(scope *Scope, arr tf.Output, size tf.Output, weights tf.Output) (bins tf.Output)

Counts the number of occurrences of each value in an integer array.

Outputs a vector with length `size` and the same dtype as `weights`. If `weights` are empty, then index `i` stores the number of times the value `i` is counted in `arr`. If `weights` are non-empty, then index `i` stores the sum of the value in `weights` at each index where the corresponding value in `arr` is `i`.

Values in `arr` outside of the range [0, size) are ignored.

Arguments:

arr: int32 `Tensor`.
size: non-negative int32 scalar `Tensor`.
weights: is an int32, int64, float32, or float64 `Tensor` with the same

shape as `arr`, or a length-0 `Tensor`, in which case it acts as all weights equal to 1.

Returns 1D `Tensor` with length equal to `size`. The counts or summed weights for each value in the range [0, size).

func Bitcast ¶

func Bitcast(scope *Scope, input tf.Output, type_ tf.DataType) (output tf.Output)

Bitcasts a tensor from one type to another without copying data.

Given a tensor `input`, this operation returns a tensor that has the same buffer data as `input` with datatype `type`.

If the input datatype `T` is larger than the output datatype `type` then the shape changes from [...] to [..., sizeof(`T`)/sizeof(`type`)].

If `T` is smaller than `type`, the operator requires that the rightmost dimension be equal to sizeof(`type`)/sizeof(`T`). The shape then goes from [..., sizeof(`type`)/sizeof(`T`)] to [...].

tf.bitcast() and tf.cast() work differently when real dtype is casted as a complex dtype (e.g. tf.complex64 or tf.complex128) as tf.cast() make imaginary part 0 while tf.bitcast() gives module error. For example,

Example 1: ```python >>> a = [1., 2., 3.] >>> equality_bitcast = tf.bitcast(a,tf.complex128) tensorflow.python.framework.errors_impl.InvalidArgumentError: Cannot bitcast from float to complex128: shape [3] [Op:Bitcast] >>> equality_cast = tf.cast(a,tf.complex128) >>> print(equality_cast) tf.Tensor([1.+0.j 2.+0.j 3.+0.j], shape=(3,), dtype=complex128) ``` Example 2: ```python >>> tf.bitcast(tf.constant(0xffffffff, dtype=tf.uint32), tf.uint8) <tf.Tensor: ... shape=(4,), dtype=uint8, numpy=array([255, 255, 255, 255], dtype=uint8)> ``` Example 3: ```python >>> x = [1., 2., 3.] >>> y = [0., 2., 3.] >>> equality= tf.equal(x,y) >>> equality_cast = tf.cast(equality,tf.float32) >>> equality_bitcast = tf.bitcast(equality_cast,tf.uint8) >>> print(equality) tf.Tensor([False True True], shape=(3,), dtype=bool) >>> print(equality_cast) tf.Tensor([0. 1. 1.], shape=(3,), dtype=float32) >>> print(equality_bitcast) tf.Tensor( [[ 0 0 0 0]

[ 0 0 128 63]
[ 0 0 128 63]], shape=(3, 4), dtype=uint8)

```

*NOTE*: Bitcast is implemented as a low-level cast, so machines with different endian orderings will give different results.

func BitwiseAnd ¶

func BitwiseAnd(scope *Scope, x tf.Output, y tf.Output) (z tf.Output)

Elementwise computes the bitwise AND of `x` and `y`.

The result will have those bits set, that are set in both `x` and `y`. The computation is performed on the underlying representations of `x` and `y`.

For example:

```python import tensorflow as tf from tensorflow.python.ops import bitwise_ops dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,

tf.uint8, tf.uint16, tf.uint32, tf.uint64]

for dtype in dtype_list:

lhs = tf.constant([0, 5, 3, 14], dtype=dtype)
rhs = tf.constant([5, 0, 7, 11], dtype=dtype)
exp = tf.constant([0, 0, 3, 10], dtype=tf.float32)

res = bitwise_ops.bitwise_and(lhs, rhs)
tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE

```

func BitwiseOr ¶

func BitwiseOr(scope *Scope, x tf.Output, y tf.Output) (z tf.Output)

Elementwise computes the bitwise OR of `x` and `y`.

The result will have those bits set, that are set in `x`, `y` or both. The computation is performed on the underlying representations of `x` and `y`.

For example:

```python import tensorflow as tf from tensorflow.python.ops import bitwise_ops dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,

tf.uint8, tf.uint16, tf.uint32, tf.uint64]

for dtype in dtype_list:

lhs = tf.constant([0, 5, 3, 14], dtype=dtype)
rhs = tf.constant([5, 0, 7, 11], dtype=dtype)
exp = tf.constant([5, 5, 7, 15], dtype=tf.float32)

res = bitwise_ops.bitwise_or(lhs, rhs)
tf.assert_equal(tf.cast(res,  tf.float32), exp)  # TRUE

```

func BitwiseXor ¶

func BitwiseXor(scope *Scope, x tf.Output, y tf.Output) (z tf.Output)

Elementwise computes the bitwise XOR of `x` and `y`.

The result will have those bits set, that are different in `x` and `y`. The computation is performed on the underlying representations of `x` and `y`.

For example:

```python import tensorflow as tf from tensorflow.python.ops import bitwise_ops dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,

tf.uint8, tf.uint16, tf.uint32, tf.uint64]

for dtype in dtype_list:

lhs = tf.constant([0, 5, 3, 14], dtype=dtype)
rhs = tf.constant([5, 0, 7, 11], dtype=dtype)
exp = tf.constant([5, 5, 4, 5],  dtype=tf.float32)

res = bitwise_ops.bitwise_xor(lhs, rhs)
tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE

```

func BlockLSTM ¶

func BlockLSTM(scope *Scope, seq_len_max tf.Output, x tf.Output, cs_prev tf.Output, h_prev tf.Output, w tf.Output, wci tf.Output, wcf tf.Output, wco tf.Output, b tf.Output, optional ...BlockLSTMAttr) (i tf.Output, cs tf.Output, f tf.Output, o tf.Output, ci tf.Output, co tf.Output, h tf.Output)

Computes the LSTM cell forward propagation for all the time steps.

This is equivalent to applying LSTMBlockCell in a loop, like so:

```python for x1 in unpack(x):

i1, cs1, f1, o1, ci1, co1, h1 = LSTMBlock(
  x1, cs_prev, h_prev, w, wci, wcf, wco, b)
cs_prev = cs1
h_prev = h1
i.append(i1)
cs.append(cs1)
f.append(f1)
o.append(o1)
ci.append(ci1)
co.append(co1)
h.append(h1)

return pack(i), pack(cs), pack(f), pack(o), pack(ci), pack(ch), pack(h) ```

Arguments:

seq_len_max: Maximum time length actually used by this input. Outputs are padded

with zeros beyond this length.

x: The sequence input to the LSTM, shape (timelen, batch_size, num_inputs).
cs_prev: Value of the initial cell state.
h_prev: Initial output of cell (to be used for peephole).
w: The weight matrix.
wci: The weight matrix for input gate peephole connection.
wcf: The weight matrix for forget gate peephole connection.
wco: The weight matrix for output gate peephole connection.
b: The bias vector.

Returns The input gate over the whole time sequence.The cell state before the tanh over the whole time sequence.The forget gate over the whole time sequence.The output gate over the whole time sequence.The cell input over the whole time sequence.The cell after the tanh over the whole time sequence.The output h vector over the whole time sequence.

func BlockLSTMGrad ¶

func BlockLSTMGrad(scope *Scope, seq_len_max tf.Output, x tf.Output, cs_prev tf.Output, h_prev tf.Output, w tf.Output, wci tf.Output, wcf tf.Output, wco tf.Output, b tf.Output, i tf.Output, cs tf.Output, f tf.Output, o tf.Output, ci tf.Output, co tf.Output, h tf.Output, cs_grad tf.Output, h_grad tf.Output, use_peephole bool) (x_grad tf.Output, cs_prev_grad tf.Output, h_prev_grad tf.Output, w_grad tf.Output, wci_grad tf.Output, wcf_grad tf.Output, wco_grad tf.Output, b_grad tf.Output)

Computes the LSTM cell backward propagation for the entire time sequence.

This implementation is to be used in conjunction of LSTMBlock.

Arguments:

seq_len_max: Maximum time length actually used by this input. Outputs are padded

with zeros beyond this length.

x: The sequence input to the LSTM, shape (timelen, batch_size, num_inputs).
cs_prev: Value of the initial cell state.
h_prev: Initial output of cell (to be used for peephole).
w: The weight matrix.
wci: The weight matrix for input gate peephole connection.
wcf: The weight matrix for forget gate peephole connection.
wco: The weight matrix for output gate peephole connection.
b: The bias vector.
i: The input gate over the whole time sequence.
cs: The cell state before the tanh over the whole time sequence.
f: The forget gate over the whole time sequence.
o: The output gate over the whole time sequence.
ci: The cell input over the whole time sequence.
co: The cell after the tanh over the whole time sequence.
h: The output h vector over the whole time sequence.
cs_grad: The current gradient of cs.
h_grad: The gradient of h vector.
use_peephole: Whether to use peephole weights.

Returns The gradient of x to be back-propped.The gradient of cs_prev to be back-propped.The gradient of h_prev to be back-propped.The gradient for w to be back-propped.The gradient for wci to be back-propped.The gradient for wcf to be back-propped.The gradient for wco to be back-propped.The gradient for w to be back-propped.

func BoostedTreesAggregateStats ¶

func BoostedTreesAggregateStats(scope *Scope, node_ids tf.Output, gradients tf.Output, hessians tf.Output, feature tf.Output, max_splits int64, num_buckets int64) (stats_summary tf.Output)

Aggregates the summary of accumulated stats for the batch.

The summary stats contains gradients and hessians accumulated for each node, feature dimension id and bucket.

Arguments:

node_ids: int32; Rank 1 Tensor containing node ids for each example, shape [batch_size].
gradients: float32; Rank 2 Tensor (shape=[batch_size, logits_dimension]) with gradients for each example.
hessians: float32; Rank 2 Tensor (shape=[batch_size, hessian_dimension]) with hessians for each example.
feature: int32; Rank 2 feature Tensors (shape=[batch_size, feature_dimension]).
max_splits: int; the maximum number of splits possible in the whole tree.
num_buckets: int; equals to the maximum possible value of bucketized feature.

Returns output Rank 4 Tensor (shape=[splits, feature_dimension, buckets, logits_dimension + hessian_dimension]) containing accumulated stats for each node, feature dimension and bucket.

func BoostedTreesBucketize ¶

func BoostedTreesBucketize(scope *Scope, float_values []tf.Output, bucket_boundaries []tf.Output) (buckets []tf.Output)

Bucketize each feature based on bucket boundaries.

An op that returns a list of float tensors, where each tensor represents the bucketized values for a single feature.

Arguments:

float_values: float; List of Rank 1 Tensor each containing float values for a single feature.
bucket_boundaries: float; List of Rank 1 Tensors each containing the bucket boundaries for a single

feature.

Returns int; List of Rank 1 Tensors each containing the bucketized values for a single feature.

func BoostedTreesCalculateBestFeatureSplit ¶

func BoostedTreesCalculateBestFeatureSplit(scope *Scope, node_id_range tf.Output, stats_summary tf.Output, l1 tf.Output, l2 tf.Output, tree_complexity tf.Output, min_node_weight tf.Output, logits_dimension int64, optional ...BoostedTreesCalculateBestFeatureSplitAttr) (node_ids tf.Output, gains tf.Output, feature_dimensions tf.Output, thresholds tf.Output, left_node_contribs tf.Output, right_node_contribs tf.Output, split_with_default_directions tf.Output)

Calculates gains for each feature and returns the best possible split information for the feature.

The split information is the best threshold (bucket id), gains and left/right node contributions per node for each feature.

It is possible that not all nodes can be split on each feature. Hence, the list of possible nodes can differ between the features. Therefore, we return `node_ids_list` for each feature, containing the list of nodes that this feature can be used to split.

In this manner, the output is the best split per features and per node, so that it needs to be combined later to produce the best split for each node (among all possible features).

The output shapes are compatible in a way that the first dimension of all tensors are the same and equal to the number of possible split nodes for each feature.

Arguments:

node_id_range: A Rank 1 tensor (shape=[2]) to specify the range [first, last) of node ids to process within `stats_summary_list`. The nodes are iterated between the two nodes specified by the tensor, as like `for node_id in range(node_id_range[0], node_id_range[1])` (Note that the last index node_id_range[1] is exclusive).
stats_summary: A Rank 4 tensor (#shape=[max_splits, feature_dims, bucket, stats_dims]) for accumulated stats summary (gradient/hessian) per node, per dimension, per buckets for each feature.

The first dimension of the tensor is the maximum number of splits, and thus not all elements of it will be used, but only the indexes specified by node_ids will be used.

l1: l1 regularization factor on leaf weights, per instance based.
l2: l2 regularization factor on leaf weights, per instance based.
tree_complexity: adjustment to the gain, per leaf based.
min_node_weight: mininum avg of hessians in a node before required for the node to be considered for splitting.
logits_dimension: The dimension of logit, i.e., number of classes.

Returns A Rank 1 tensors indicating possible split node ids for each feature. The length of the list is num_features, but each tensor has different size as each feature provides different possible nodes. See above for details like shapes and sizes.A Rank 1 tensors indicating the best gains for each feature to split for certain nodes. See above for details like shapes and sizes.A Rank 1 tensors indicating the best feature dimension for each feature to split for certain nodes if the feature is multi-dimension. See above for details like shapes and sizes.A Rank 1 tensors indicating the bucket id to compare with (as a threshold) for split in each node. See above for details like shapes and sizes.A Rank 2 tensors indicating the contribution of the left nodes when branching from parent nodes (given by the tensor element in the output node_ids_list) to the left direction by the given threshold for each feature. This value will be used to make the left node value by adding to the parent node value. Second dimension size is 1 for 1-dimensional logits, but would be larger for multi-class problems. See above for details like shapes and sizes.A Rank 2 tensors, with the same shape/conditions as left_node_contribs_list, but just that the value is for the right node.A Rank 1 tensors indicating the which direction to go if data is missing. See above for details like shapes and sizes.

func BoostedTreesCalculateBestGainsPerFeature ¶

func BoostedTreesCalculateBestGainsPerFeature(scope *Scope, node_id_range tf.Output, stats_summary_list []tf.Output, l1 tf.Output, l2 tf.Output, tree_complexity tf.Output, min_node_weight tf.Output, max_splits int64) (node_ids_list []tf.Output, gains_list []tf.Output, thresholds_list []tf.Output, left_node_contribs_list []tf.Output, right_node_contribs_list []tf.Output)

Calculates gains for each feature and returns the best possible split information for the feature.

The split information is the best threshold (bucket id), gains and left/right node contributions per node for each feature.

It is possible that not all nodes can be split on each feature. Hence, the list of possible nodes can differ between the features. Therefore, we return `node_ids_list` for each feature, containing the list of nodes that this feature can be used to split.

In this manner, the output is the best split per features and per node, so that it needs to be combined later to produce the best split for each node (among all possible features).

The length of output lists are all of the same length, `num_features`. The output shapes are compatible in a way that the first dimension of all tensors of all lists are the same and equal to the number of possible split nodes for each feature.

Arguments:

node_id_range: A Rank 1 tensor (shape=[2]) to specify the range [first, last) of node ids to process within `stats_summary_list`. The nodes are iterated between the two nodes specified by the tensor, as like `for node_id in range(node_id_range[0], node_id_range[1])` (Note that the last index node_id_range[1] is exclusive).
stats_summary_list: A list of Rank 3 tensor (#shape=[max_splits, bucket, 2]) for accumulated stats summary (gradient/hessian) per node per buckets for each feature. The first dimension of the tensor is the maximum number of splits, and thus not all elements of it will be used, but only the indexes specified by node_ids will be used.
l1: l1 regularization factor on leaf weights, per instance based.
l2: l2 regularization factor on leaf weights, per instance based.
tree_complexity: adjustment to the gain, per leaf based.
min_node_weight: mininum avg of hessians in a node before required for the node to be considered for splitting.
max_splits: the number of nodes that can be split in the whole tree. Used as a dimension of output tensors.

Returns An output list of Rank 1 tensors indicating possible split node ids for each feature. The length of the list is num_features, but each tensor has different size as each feature provides different possible nodes. See above for details like shapes and sizes.An output list of Rank 1 tensors indicating the best gains for each feature to split for certain nodes. See above for details like shapes and sizes.An output list of Rank 1 tensors indicating the bucket id to compare with (as a threshold) for split in each node. See above for details like shapes and sizes.A list of Rank 2 tensors indicating the contribution of the left nodes when branching from parent nodes (given by the tensor element in the output node_ids_list) to the left direction by the given threshold for each feature. This value will be used to make the left node value by adding to the parent node value. Second dimension size is 1 for 1-dimensional logits, but would be larger for multi-class problems. See above for details like shapes and sizes.A list of Rank 2 tensors, with the same shape/conditions as left_node_contribs_list, but just that the value is for the right node.

func BoostedTreesCenterBias ¶

func BoostedTreesCenterBias(scope *Scope, tree_ensemble_handle tf.Output, mean_gradients tf.Output, mean_hessians tf.Output, l1 tf.Output, l2 tf.Output) (continue_centering tf.Output)

Calculates the prior from the training data (the bias) and fills in the first node with the logits' prior. Returns a boolean indicating whether to continue centering.

Arguments:

tree_ensemble_handle: Handle to the tree ensemble.
mean_gradients: A tensor with shape=[logits_dimension] with mean of gradients for a first node.
mean_hessians: A tensor with shape=[logits_dimension] mean of hessians for a first node.
l1: l1 regularization factor on leaf weights, per instance based.
l2: l2 regularization factor on leaf weights, per instance based.

Returns Bool, whether to continue bias centering.

func BoostedTreesCreateEnsemble ¶

func BoostedTreesCreateEnsemble(scope *Scope, tree_ensemble_handle tf.Output, stamp_token tf.Output, tree_ensemble_serialized tf.Output) (o *tf.Operation)

Creates a tree ensemble model and returns a handle to it.

Arguments:

tree_ensemble_handle: Handle to the tree ensemble resource to be created.
stamp_token: Token to use as the initial value of the resource stamp.
tree_ensemble_serialized: Serialized proto of the tree ensemble.

Returns the created operation.

func BoostedTreesCreateQuantileStreamResource ¶

func BoostedTreesCreateQuantileStreamResource(scope *Scope, quantile_stream_resource_handle tf.Output, epsilon tf.Output, num_streams tf.Output, optional ...BoostedTreesCreateQuantileStreamResourceAttr) (o *tf.Operation)

Create the Resource for Quantile Streams.

Arguments:

quantile_stream_resource_handle: resource; Handle to quantile stream resource.
epsilon: float; The required approximation error of the stream resource.
num_streams: int; The number of streams managed by the resource that shares the same epsilon.

Returns the created operation.

func BoostedTreesDeserializeEnsemble ¶

func BoostedTreesDeserializeEnsemble(scope *Scope, tree_ensemble_handle tf.Output, stamp_token tf.Output, tree_ensemble_serialized tf.Output) (o *tf.Operation)

Deserializes a serialized tree ensemble config and replaces current tree

ensemble.

Arguments:

tree_ensemble_handle: Handle to the tree ensemble.
stamp_token: Token to use as the new value of the resource stamp.
tree_ensemble_serialized: Serialized proto of the ensemble.

Returns the created operation.

func BoostedTreesEnsembleResourceHandleOp ¶

func BoostedTreesEnsembleResourceHandleOp(scope *Scope, optional ...BoostedTreesEnsembleResourceHandleOpAttr) (resource tf.Output)

Creates a handle to a BoostedTreesEnsembleResource

func BoostedTreesExampleDebugOutputs ¶

func BoostedTreesExampleDebugOutputs(scope *Scope, tree_ensemble_handle tf.Output, bucketized_features []tf.Output, logits_dimension int64) (examples_debug_outputs_serialized tf.Output)

Debugging/model interpretability outputs for each example.

It traverses all the trees and computes debug metrics for individual examples, such as getting split feature ids and logits after each split along the decision path used to compute directional feature contributions.

Arguments:

bucketized_features: A list of rank 1 Tensors containing bucket id for each

feature.

logits_dimension: scalar, dimension of the logits, to be used for constructing the protos in

examples_debug_outputs_serialized.

Returns Output rank 1 Tensor containing a proto serialized as a string for each example.

func BoostedTreesGetEnsembleStates ¶

func BoostedTreesGetEnsembleStates(scope *Scope, tree_ensemble_handle tf.Output) (stamp_token tf.Output, num_trees tf.Output, num_finalized_trees tf.Output, num_attempted_layers tf.Output, last_layer_nodes_range tf.Output)

Retrieves the tree ensemble resource stamp token, number of trees and growing statistics.

Arguments:

tree_ensemble_handle: Handle to the tree ensemble.

Returns Stamp token of the tree ensemble resource.The number of trees in the tree ensemble resource.The number of trees that were finished successfully.The number of layers we attempted to build (but not necessarily succeeded).Rank size 2 tensor that contains start and end ids of the nodes in the latest layer.

func BoostedTreesMakeQuantileSummaries ¶

func BoostedTreesMakeQuantileSummaries(scope *Scope, float_values []tf.Output, example_weights tf.Output, epsilon tf.Output) (summaries []tf.Output)

Makes the summary of quantiles for the batch.

An op that takes a list of tensors (one tensor per feature) and outputs the quantile summaries for each tensor.

Arguments:

float_values: float; List of Rank 1 Tensors each containing values for a single feature.
example_weights: float; Rank 1 Tensor with weights per instance.
epsilon: float; The required maximum approximation error.

Returns float; List of Rank 2 Tensors each containing the quantile summary (value, weight, min_rank, max_rank) of a single feature.

func BoostedTreesMakeStatsSummary ¶

func BoostedTreesMakeStatsSummary(scope *Scope, node_ids tf.Output, gradients tf.Output, hessians tf.Output, bucketized_features_list []tf.Output, max_splits int64, num_buckets int64) (stats_summary tf.Output)

Makes the summary of accumulated stats for the batch.

The summary stats contains gradients and hessians accumulated into the corresponding node and bucket for each example.

Arguments:

node_ids: int32 Rank 1 Tensor containing node ids, which each example falls into for the requested layer.
gradients: float32; Rank 2 Tensor (shape=[#examples, 1]) for gradients.
hessians: float32; Rank 2 Tensor (shape=[#examples, 1]) for hessians.
bucketized_features_list: int32 list of Rank 1 Tensors, each containing the bucketized feature (for each feature column).
max_splits: int; the maximum number of splits possible in the whole tree.
num_buckets: int; equals to the maximum possible value of bucketized feature.

Returns output Rank 4 Tensor (shape=[#features, #splits, #buckets, 2]) containing accumulated stats put into the corresponding node and bucket. The first index of 4th dimension refers to gradients, and the second to hessians.

func BoostedTreesPredict ¶

func BoostedTreesPredict(scope *Scope, tree_ensemble_handle tf.Output, bucketized_features []tf.Output, logits_dimension int64) (logits tf.Output)

Runs multiple additive regression ensemble predictors on input instances and

computes the logits. It is designed to be used during prediction. It traverses all the trees and calculates the final score for each instance.

Arguments:

bucketized_features: A list of rank 1 Tensors containing bucket id for each

feature.

logits_dimension: scalar, dimension of the logits, to be used for partial logits

shape.

Returns Output rank 2 Tensor containing logits for each example.

func BoostedTreesQuantileStreamResourceAddSummaries ¶

func BoostedTreesQuantileStreamResourceAddSummaries(scope *Scope, quantile_stream_resource_handle tf.Output, summaries []tf.Output) (o *tf.Operation)

Add the quantile summaries to each quantile stream resource.

An op that adds a list of quantile summaries to a quantile stream resource. Each summary Tensor is rank 2, containing summaries (value, weight, min_rank, max_rank) for a single feature.

Arguments:

quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
summaries: string; List of Rank 2 Tensor each containing the summaries for a single feature.

Returns the created operation.

func BoostedTreesQuantileStreamResourceDeserialize ¶

func BoostedTreesQuantileStreamResourceDeserialize(scope *Scope, quantile_stream_resource_handle tf.Output, bucket_boundaries []tf.Output) (o *tf.Operation)

Deserialize bucket boundaries and ready flag into current QuantileAccumulator.

An op that deserializes bucket boundaries and are boundaries ready flag into current QuantileAccumulator.

Arguments:

quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
bucket_boundaries: float; List of Rank 1 Tensors each containing the bucket boundaries for a feature.

Returns the created operation.

func BoostedTreesQuantileStreamResourceFlush ¶

func BoostedTreesQuantileStreamResourceFlush(scope *Scope, quantile_stream_resource_handle tf.Output, num_buckets tf.Output, optional ...BoostedTreesQuantileStreamResourceFlushAttr) (o *tf.Operation)

Flush the summaries for a quantile stream resource.

An op that flushes the summaries for a quantile stream resource.

Arguments:

quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
num_buckets: int; approximate number of buckets unless using generate_quantiles.

Returns the created operation.

func BoostedTreesQuantileStreamResourceGetBucketBoundaries ¶

func BoostedTreesQuantileStreamResourceGetBucketBoundaries(scope *Scope, quantile_stream_resource_handle tf.Output, num_features int64) (bucket_boundaries []tf.Output)

Generate the bucket boundaries for each feature based on accumulated summaries.

An op that returns a list of float tensors for a quantile stream resource. Each tensor is Rank 1 containing bucket boundaries for a single feature.

Arguments:

quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
num_features: inferred int; number of features to get bucket boundaries for.

Returns float; List of Rank 1 Tensors each containing the bucket boundaries for a feature.

func BoostedTreesQuantileStreamResourceHandleOp ¶

func BoostedTreesQuantileStreamResourceHandleOp(scope *Scope, optional ...BoostedTreesQuantileStreamResourceHandleOpAttr) (resource tf.Output)

Creates a handle to a BoostedTreesQuantileStreamResource.

func BoostedTreesSerializeEnsemble ¶

func BoostedTreesSerializeEnsemble(scope *Scope, tree_ensemble_handle tf.Output) (stamp_token tf.Output, tree_ensemble_serialized tf.Output)

Serializes the tree ensemble to a proto.

Arguments:

tree_ensemble_handle: Handle to the tree ensemble.

Returns Stamp token of the tree ensemble resource.Serialized proto of the ensemble.

func BoostedTreesSparseAggregateStats ¶

func BoostedTreesSparseAggregateStats(scope *Scope, node_ids tf.Output, gradients tf.Output, hessians tf.Output, feature_indices tf.Output, feature_values tf.Output, feature_shape tf.Output, max_splits int64, num_buckets int64) (stats_summary_indices tf.Output, stats_summary_values tf.Output, stats_summary_shape tf.Output)

Aggregates the summary of accumulated stats for the batch.

The summary stats contains gradients and hessians accumulated for each node, bucket and dimension id.

Arguments:

node_ids: int32; Rank 1 Tensor containing node ids for each example, shape [batch_size].
gradients: float32; Rank 2 Tensor (shape=[batch_size, logits_dimension]) with gradients for each example.
hessians: float32; Rank 2 Tensor (shape=[batch_size, hessian_dimension]) with hessians for each example.
feature_indices: int32; Rank 2 indices of feature sparse Tensors (shape=[number of sparse entries, 2]).

Number of sparse entries across all instances from the batch. The first value is the index of the instance, the second is dimension of the feature. The second axis can only have 2 values, i.e., the input dense version of Tensor can only be matrix.

feature_values: int32; Rank 1 values of feature sparse Tensors (shape=[number of sparse entries]).

Number of sparse entries across all instances from the batch. The first value is the index of the instance, the second is dimension of the feature.

feature_shape: int32; Rank 1 dense shape of feature sparse Tensors (shape=[2]).

The first axis can only have 2 values, [batch_size, feature_dimension].

max_splits: int; the maximum number of splits possible in the whole tree.
num_buckets: int; equals to the maximum possible value of bucketized feature + 1.

Returns int32; Rank 2 indices of summary sparse Tensors (shape=[number of non zero statistics, 4]) The second axis can only be 4 including node id, feature dimension, bucket id, and statistics_dimension. statistics_dimension = logits_dimension + hessian_dimension.output Rank 1 Tensor (shape=[number of non zero statistics])output Rank 1 Tensor (shape=[4]) The tensor has following 4 values: [max_splits, feature_dimension, num_buckets, statistics_dimension], where statistics_dimension = gradient_dimension + hessian_dimension. gradient_dimension is the same as label_dimension, i.e., the output space. hessian_dimension can be the same as logits dimension when diagonal hessian is used, or label_dimension^2 when full hessian is used.

func BoostedTreesSparseCalculateBestFeatureSplit ¶

func BoostedTreesSparseCalculateBestFeatureSplit(scope *Scope, node_id_range tf.Output, stats_summary_indices tf.Output, stats_summary_values tf.Output, stats_summary_shape tf.Output, l1 tf.Output, l2 tf.Output, tree_complexity tf.Output, min_node_weight tf.Output, logits_dimension int64, optional ...BoostedTreesSparseCalculateBestFeatureSplitAttr) (node_ids tf.Output, gains tf.Output, feature_dimensions tf.Output, thresholds tf.Output, left_node_contribs tf.Output, right_node_contribs tf.Output, split_with_default_directions tf.Output)

Calculates gains for each feature and returns the best possible split information for the feature.

The split information is the best threshold (bucket id), gains and left/right node contributions per node for each feature.

It is possible that not all nodes can be split on each feature. Hence, the list of possible nodes can differ between the features. Therefore, we return `node_ids_list` for each feature, containing the list of nodes that this feature can be used to split.

In this manner, the output is the best split per features and per node, so that it needs to be combined later to produce the best split for each node (among all possible features).

The output shapes are compatible in a way that the first dimension of all tensors are the same and equal to the number of possible split nodes for each feature.

Arguments:

node_id_range: A Rank 1 tensor (shape=[2]) to specify the range [first, last) of node ids to process within `stats_summary_list`. The nodes are iterated between the two nodes specified by the tensor, as like `for node_id in range(node_id_range[0], node_id_range[1])` (Note that the last index node_id_range[1] is exclusive).
stats_summary_indices: A Rank 2 int64 tensor of dense shape [N, 4] (N specifies the number of non-zero values) for accumulated stats summary (gradient/hessian) per node per bucket for each feature. The second dimension contains node id, feature dimension, bucket id, and stats dim.

stats dim is the sum of logits dimension and hessian dimension, hessian dimension can either be logits dimension if diagonal hessian is used, or logits dimension^2 if full hessian is used.

stats_summary_values: A Rank 1 float tensor of dense shape [N] (N specifies the number of non-zero values), which supplies the values for each element in summary_indices.
stats_summary_shape: A Rank 1 float tensor of dense shape [4], which specifies the dense shape of the sparse tensor, which is [num tree nodes, feature dimensions, num buckets, stats dim].
l1: l1 regularization factor on leaf weights, per instance based.
l2: l2 regularization factor on leaf weights, per instance based.
tree_complexity: adjustment to the gain, per leaf based.
min_node_weight: mininum avg of hessians in a node before required for the node to be considered for splitting.
logits_dimension: The dimension of logit, i.e., number of classes.

Returns A Rank 1 tensor indicating possible node ids that can be split.A Rank 1 tensor indicating the best gains to split each node.A Rank 1 tensor indicating the best feature dimension for each feature to split for each node.A Rank 1 tensor indicating the bucket id to compare with (as a threshold) for split in each node.A Rank 2 tensor indicating the contribution of the left nodes when branching from parent nodes to the left direction by the given threshold for each feature. This value will be used to make the left node value by adding to the parent node value. Second dimension size is logits dimension.A Rank 2 tensor, with the same shape/conditions as left_node_contribs_list, but just that the value is for the right node.A Rank 1 tensor indicating which direction to go if data is missing.

func BoostedTreesTrainingPredict ¶

func BoostedTreesTrainingPredict(scope *Scope, tree_ensemble_handle tf.Output, cached_tree_ids tf.Output, cached_node_ids tf.Output, bucketized_features []tf.Output, logits_dimension int64) (partial_logits tf.Output, tree_ids tf.Output, node_ids tf.Output)

Runs multiple additive regression ensemble predictors on input instances and

computes the update to cached logits. It is designed to be used during training. It traverses the trees starting from cached tree id and cached node id and calculates the updates to be pushed to the cache.

Arguments:

cached_tree_ids: Rank 1 Tensor containing cached tree ids which is the starting

tree of prediction.

cached_node_ids: Rank 1 Tensor containing cached node id which is the starting

node of prediction.

bucketized_features: A list of rank 1 Tensors containing bucket id for each

feature.

logits_dimension: scalar, dimension of the logits, to be used for partial logits

shape.

Returns Rank 2 Tensor containing logits update (with respect to cached values stored) for each example.Rank 1 Tensor containing new tree ids for each example.Rank 1 Tensor containing new node ids in the new tree_ids.

func BoostedTreesUpdateEnsemble ¶

func BoostedTreesUpdateEnsemble(scope *Scope, tree_ensemble_handle tf.Output, feature_ids tf.Output, node_ids []tf.Output, gains []tf.Output, thresholds []tf.Output, left_node_contribs []tf.Output, right_node_contribs []tf.Output, max_depth tf.Output, learning_rate tf.Output, pruning_mode int64) (o *tf.Operation)

Updates the tree ensemble by either adding a layer to the last tree being grown

or by starting a new tree.

Arguments:

tree_ensemble_handle: Handle to the ensemble variable.
feature_ids: Rank 1 tensor with ids for each feature. This is the real id of

the feature that will be used in the split.

node_ids: List of rank 1 tensors representing the nodes for which this feature

has a split.

gains: List of rank 1 tensors representing the gains for each of the feature's

split.

thresholds: List of rank 1 tensors representing the thesholds for each of the

feature's split.

left_node_contribs: List of rank 2 tensors with left leaf contribs for each of

the feature's splits. Will be added to the previous node values to constitute the values of the left nodes.

right_node_contribs: List of rank 2 tensors with right leaf contribs for each

of the feature's splits. Will be added to the previous node values to constitute the values of the right nodes.

max_depth: Max depth of the tree to build.
learning_rate: shrinkage const for each new tree.
pruning_mode: 0-No pruning, 1-Pre-pruning, 2-Post-pruning.

Returns the created operation.

func BroadcastArgs ¶

func BroadcastArgs(scope *Scope, s0 tf.Output, s1 tf.Output) (r0 tf.Output)

Return the shape of s0 op s1 with broadcast.

Given `s0` and `s1`, tensors that represent shapes, compute `r0`, the broadcasted shape. `s0`, `s1` and `r0` are all integer vectors.

func BroadcastGradientArgs ¶

func BroadcastGradientArgs(scope *Scope, s0 tf.Output, s1 tf.Output) (r0 tf.Output, r1 tf.Output)

Return the reduction indices for computing gradients of s0 op s1 with broadcast.

This is typically used by gradient computations for a broadcasting operation.

func BroadcastTo ¶

func BroadcastTo(scope *Scope, input tf.Output, shape tf.Output) (output tf.Output)

Broadcast an array for a compatible shape.

Broadcasting is the process of making arrays to have compatible shapes for arithmetic operations. Two shapes are compatible if for each dimension pair they are either equal or one of them is one. When trying to broadcast a Tensor to a shape, it starts with the trailing dimensions, and works its way forward.

For example,

```python >>> x = tf.constant([1, 2, 3]) >>> y = tf.broadcast_to(x, [3, 3]) >>> sess.run(y) array([[1, 2, 3],

[1, 2, 3],
[1, 2, 3]], dtype=int32)

```

In the above example, the input Tensor with the shape of `[1, 3]` is broadcasted to output Tensor with shape of `[3, 3]`.

Arguments:

input: A Tensor to broadcast.
shape: An 1-D `int` Tensor. The shape of the desired output.

Returns A Tensor.

func Bucketize ¶

func Bucketize(scope *Scope, input tf.Output, boundaries []float32) (output tf.Output)

Bucketizes 'input' based on 'boundaries'.

For example, if the inputs are

boundaries = [0, 10, 100]
input = [[-5, 10000]
         [150,   10]
         [5,    100]]

then the output will be

output = [[0, 3]
          [3, 2]
          [1, 3]]

Arguments:

input: Any shape of Tensor contains with int or float type.
boundaries: A sorted list of floats gives the boundary of the buckets.

Returns Same shape with 'input', each value of input replaced with bucket index.

@compatibility(numpy) Equivalent to np.digitize. @end_compatibility

func BytesProducedStatsDataset ¶

func BytesProducedStatsDataset(scope *Scope, input_dataset tf.Output, tag tf.Output, output_types []tf.DataType, output_shapes []tf.Shape) (handle tf.Output)

Records the bytes size of each element of `input_dataset` in a StatsAggregator.

func CTCBeamSearchDecoder ¶

func CTCBeamSearchDecoder(scope *Scope, inputs tf.Output, sequence_length tf.Output, beam_width int64, top_paths int64, optional ...CTCBeamSearchDecoderAttr) (decoded_indices []tf.Output, decoded_values []tf.Output, decoded_shape []tf.Output, log_probability tf.Output)

Performs beam search decoding on the logits given in input.

A note about the attribute merge_repeated: For the beam search decoder, this means that if consecutive entries in a beam are the same, only the first of these is emitted. That is, when the top path is "A B B B B", "A B" is returned if merge_repeated = True but "A B B B B" is returned if merge_repeated = False.

Arguments:

inputs: 3-D, shape: `(max_time x batch_size x num_classes)`, the logits.
sequence_length: A vector containing sequence lengths, size `(batch)`.
beam_width: A scalar >= 0 (beam search beam width).
top_paths: A scalar >= 0, <= beam_width (controls output size).

Returns A list (length: top_paths) of indices matrices. Matrix j, size `(total_decoded_outputs[j] x 2)`, has indices of a `SparseTensor<int64, 2>`. The rows store: [batch, time].A list (length: top_paths) of values vectors. Vector j, size `(length total_decoded_outputs[j])`, has the values of a `SparseTensor<int64, 2>`. The vector stores the decoded classes for beam j.A list (length: top_paths) of shape vector. Vector j, size `(2)`, stores the shape of the decoded `SparseTensor[j]`. Its values are: `[batch_size, max_decoded_length[j]]`.A matrix, shaped: `(batch_size x top_paths)`. The sequence log-probabilities.

func CTCGreedyDecoder ¶

func CTCGreedyDecoder(scope *Scope, inputs tf.Output, sequence_length tf.Output, optional ...CTCGreedyDecoderAttr) (decoded_indices tf.Output, decoded_values tf.Output, decoded_shape tf.Output, log_probability tf.Output)