Raw

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.

• Attr error_msg: A string which is the message associated with the exception.

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|\).

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.

• Attr shape: Shape of elements of inputs.

Computes acos of x element-wise.

Computes inverse hyperbolic cosine of x element-wise.

Returns x + y element-wise.

NOTE: Add supports broadcasting. AddN does not. More about broadcasting here

Returns x + y element-wise.

NOTE: Add supports broadcasting. AddN does not. More about broadcasting here

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.

• Attrs:

  • container: The container name for the SparseTensorsMap created by this op.
  • shared_name: The shared name for the SparseTensorsMap created by this op. If blank, the new Operation’s unique name is used.

• Output sparse_handles: 1-D. The handles of the SparseTensor now stored in the SparseTensorsMap. Shape: [N].

Add all input tensors element wise.

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.

• Attrs:

  • container: The container name for the SparseTensorsMap created by this op.
  • shared_name: The shared name for the SparseTensorsMap created by this op. If blank, the new Operation’s unique name is used.

• Output sparse_handle: 0-D. The handle of the SparseTensor now stored in the SparseTensorsMap.

Returns x + y element-wise.

NOTE: Add supports broadcasting. AddN does not. More about broadcasting here

Deprecated. Disallowed in GraphDef version >= 2.

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.

• Output output: The contrast-adjusted image or images.

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.

• Output output: The hue-adjusted image or images.

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.

• Output output: The hue-adjusted image or images.

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.

• Attr keep_dims: If true, retain reduced dimensions with length 1.

• Output output: The reduced tensor.

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.

• Attrs:

  • 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.
  • seed: If either seed or seed2 are set to be non-zero, the random number generator is seeded by the given seed. Otherwise, it is seeded by a random seed.
  • seed2: An second seed to avoid seed collision.

• Outputs:

  • sampled_candidates: A vector of length num_sampled, in which each element is the ID of a sampled candidate.
  • true_expected_count: A batch_size * num_true matrix, representing the number of times each candidate is expected to occur in a batch of sampled candidates. If unique=true, then this is a probability.
  • sampled_expected_count: A 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.

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]]

• Attrs:

  • T: The type of elements to be exchanged.
  • 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])

• Output output: The exchanged result.

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

A container for an iterator resource.

• Output handle: 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 container for an iterator resource.

• Outputs:
  • handle: 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.
  • deleter: A variant deleter that should be passed into the op that deletes the iterator.

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.

• Attr keep_dims: If true, retain reduced dimensions with length 1.

• Output output: The reduced tensor.

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

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:

  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

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:

  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

Converts each entry in the given tensor to strings. Supports many numeric

types and boolean.

• Attrs:
  • precision: The post-decimal precision to use for floating point numbers. Only used if precision > -1.
  • scientific: Use scientific notation for floating point numbers.
  • shortest: Use shortest representation (either scientific or standard) for floating point numbers.
  • width: Pad pre-decimal numbers to this width. Applies to both floating point and integer numbers. Only used if width > -1.
  • fill: The value to pad if width > -1. If empty, pads with spaces. Another typical value is ‘0’. String cannot be longer than 1 character.

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:

# 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

Computes inverse hyperbolic sine of x element-wise.

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.

• Attr summarize: Print this many entries of each tensor.

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.

• Attr dtype: the dtype of the value.

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.

• Attr dtype: the dtype of the value.

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.

• Attr dtype: the dtype of the value.

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:

# 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

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) ).

Computes inverse hyperbolic tangent of x element-wise.

Produces a visualization of audio data over time.

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

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

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

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

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

• Attrs:

  • 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.
  • magnitude_squared: Whether to return the squared magnitude or just the magnitude. Using squared magnitude can avoid extra calculations.

• Output spectrogram: 3D representation of the audio frequencies as an image.

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.

• Attrs:

  • sample_rate: The sample rate of the signal in hertz.
  • max_outputs: Max number of batch elements to generate audio for.

• Output summary: Scalar. Serialized Summary protocol buffer.

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.

• Attr max_outputs: Max number of batch elements to generate audio for.

• Output summary: Scalar. Serialized Summary protocol buffer.

Performs average pooling on the input.

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

• Attrs:

  • 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.
  • data_format: Specify the data format of the input and output data. With the default format NHWC, the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be NCHW, the data storage order of: [batch, in_channels, in_height, in_width].

• Output output: The average pooled output tensor.

Performs 3D average pooling on the input.

• Attrs:

  • 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.
  • data_format: The data format of the input and output data. With the default format NDHWC, the data is stored in the order of: [batch, in_depth, in_height, in_width, in_channels]. Alternatively, the format could be NCDHW, the data storage order is: [batch, in_channels, in_depth, in_height, in_width].

• Output output: The average pooled output tensor.

Computes gradients of average pooling function.

• Attrs:

  • 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.
  • data_format: The data format of the input and output data. With the default format NDHWC, the data is stored in the order of: [batch, in_depth, in_height, in_width, in_channels]. Alternatively, the format could be NCDHW, the data storage order is: [batch, in_channels, in_depth, in_height, in_width].

• Output output: The backprop for input.

Computes gradients of the average pooling function.

• Attrs:

  • 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.
  • data_format: Specify the data format of the input and output data. With the default format NHWC, the data is stored in the order of: [batch, in_height, in_width, in_channels]. Alternatively, the format could be NCHW, the data storage order of: [batch, in_channels, in_height, in_width].

• Output output: 4-D. Gradients w.r.t. the input of avg_pool.

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.

Creates a dataset that batches batch_size elements from input_dataset.

Creates a dataset that batches batch_size elements from input_dataset.

Batches all the inputs tensors to the computation done by the function.

So, for example, in the following code

  # 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.

- Parameters:
    - in_tensors: The tensors to be batched.
    - captured_tensors: The tensors which are captured in the function, and don't need
        to be batched.

- Attrs:
    - 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.
    - max_enqueued_batches: Maximum number of batches enqueued. Default: 10.
    - 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.
    - container: Controls the scope of sharing of this 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.
    - Tin: the types of tensors to be batched.
    - Tcaptured: the types of the captured tensors.
    - Tout: the types of the output tensors.

- Output out_tensors: The output tensors.

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[..., :, :])

• Attrs:

  • adj_x: If True, adjoint the slices of x. Defaults to False.
  • adj_y: If True, adjoint the slices of y. Defaults to False.

• Output output: 3-D or higher with shape [..., r_o, c_o]

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.

• Attrs:

  • adj_x: If True, adjoint the slices of x. Defaults to False.
  • adj_y: If True, adjoint the slices of y. Defaults to False.

• Output output: 3-D or higher with shape [..., r_o, c_o]

Batch normalization.

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

• Attrs:

  • 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.

Gradients for batch normalization.

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

• Attrs:

  • 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.

• Outputs:

  • dx: 4D backprop tensor for input.
  • dm: 1D backprop tensor for mean.
  • dv: 1D backprop tensor for variance.
  • db: 1D backprop tensor for beta.
  • dg: 1D backprop tensor for gamma.

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.

• Output output: 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]]]]
  

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.

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).

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).

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.

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.

• Attr data_format: Specify the data format of the input and output data. With the default format NHWC, the bias tensor will be added to the last dimension of the value tensor. Alternatively, the format could be NCHW, the data storage order of: [batch, in_channels, in_height, in_width]. The tensor will be added to in_channels, the third-to-the-last dimension.

• Output output: Broadcasted sum of value and bias.

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.

• Attr data_format: Specify the data format of the input and output data. With the default format NHWC, the bias tensor will be added to the last dimension of the value tensor. Alternatively, the format could be NCHW, the data storage order of: [batch, in_channels, in_height, in_width]. The tensor will be added to in_channels, the third-to-the-last dimension.

• Output output: 1-D with size the feature dimension of out_backprop.

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.

• Output output: Broadcasted sum of value and bias.

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.

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

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:

>>> 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:

>>> 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:

>>> 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)