THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.Assert, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.Assert

def Assert(condition, data, summarize=None, name=None):

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.

NOTE: To ensure that Assert executes, one usually attaches a dependency:

python # Ensure maximum element of x is smaller or equal to 1 assert_op = tf.Assert(tf.less_equal(tf.reduce_max(x), 1.), [x]) x = tf.with_dependencies([assert_op], x)

Args: condition: The condition to evaluate. data: The tensors to print out when condition is false. summarize: Print this many entries of each tensor. name: A name for this operation (optional).

Returns: assert_op: An Operation that, when executed, raises a tf.errors.InvalidArgumentError if condition is not true.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.NoGradient, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.NoGradient

def NotDifferentiable(op_type):

Specifies that ops of type op_type is not differentiable.

This function should not be used for operations that have a well-defined gradient that is not yet implemented.

This function is only used when defining a new op type. It may be used for ops such as tf.size() that are not differentiable. For example:

python tf.NotDifferentiable("Size")

The gradient computed for 'op_type' will then propagate zeros.

For ops that have a well-defined gradient but are not yet implemented, no declaration should be made, and an error must be thrown if an attempt to request its gradient is made.

Args: op_type: The string type of an operation. This corresponds to the OpDef.name field for the proto that defines the operation.

Raises: TypeError: If op_type is not a string.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.NotDifferentiable, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.NotDifferentiable

def NotDifferentiable(op_type):

Specifies that ops of type op_type is not differentiable.

This function should not be used for operations that have a well-defined gradient that is not yet implemented.

This function is only used when defining a new op type. It may be used for ops such as tf.size() that are not differentiable. For example:

python tf.NotDifferentiable("Size")

The gradient computed for 'op_type' will then propagate zeros.

For ops that have a well-defined gradient but are not yet implemented, no declaration should be made, and an error must be thrown if an attempt to request its gradient is made.

Args: op_type: The string type of an operation. This corresponds to the OpDef.name field for the proto that defines the operation.

Raises: TypeError: If op_type is not a string.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.Print, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.Print

def Print(input_, data, message=None, first_n=None, summarize=None, name=None):

Prints a list of tensors.

This is an identity op with the side effect of printing data when evaluating.

Args: input_: A tensor passed through this op. data: A list of tensors to print out when op is evaluated. message: A string, prefix of the error message. first_n: Only log first_n number of times. Negative numbers log always; this is the default. summarize: Only print this many entries of each tensor. If None, then a maximum of 3 elements are printed per input tensor. name: A name for the operation (optional).

Returns: Same tensor as input_.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.abs, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.abs

def abs(x, name=None):

Computes the absolute value of a tensor.

Given a tensor of real numbers 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|\).

See tf.complex_abs() to compute the absolute value of a complex number.

Args: x: A Tensor or SparseTensor of type float32, float64, int32, or int64. name: A name for the operation (optional).

Returns: A Tensor or SparseTensor the same size and type as x with absolute values.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.accumulate_n, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.accumulate_n

def accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):

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

Optionally, pass shape and tensor_dtype for shape and type checking, otherwise, these are inferred.

NOTE: This operation is not differentiable and cannot be used if inputs depend on trainable variables. Please use tf.add_n for such cases.

For example:

```python

tensor 'a' is [[1, 2], [3, 4]]

tensor b is [[5, 0], [0, 6]]

tf.accumulate_n([a, b, a]) ==> [[7, 4], [6, 14]]

Explicitly pass shape and type

tf.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32) ==> [[7, 4], [6, 14]] ```

Args: inputs: A list of Tensor objects, each with same shape and type. shape: Shape of elements of inputs. tensor_dtype: The type of inputs. name: A name for the operation (optional).

Returns: A Tensor of same shape and type as the elements of inputs.

Raises: ValueError: If inputs don't all have same shape and dtype or the shape cannot be inferred.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.acos, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.acos

def acos(x, name=None):

Computes acos of x element-wise.

Args: x: A Tensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as x.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.add_check_numerics_ops, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.add_check_numerics_ops

def add_check_numerics_ops():

Connect a check_numerics to every floating point tensor.

check_numerics operations themselves are added for each half, float, or double tensor in the graph. For all ops in the graph, the check_numerics op for all of its (half, float, or double) inputs is guaranteed to run before the check_numerics op on any of its outputs.

Returns: A group op depending on all check_numerics ops added.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.add, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.add

def add(x, y, name=None):

Returns x + y element-wise.

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

Args: x: A Tensor. Must be one of the following types: half, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128, string. y: A Tensor. Must have the same type as x. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as x.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.add_n, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.add_n

def add_n(inputs, name=None):

Adds all input tensors element-wise.

Args: inputs: A list of Tensor objects, each with same shape and type. name: A name for the operation (optional).

Returns: A Tensor of same shape and type as the elements of inputs.

Raises: ValueError: If inputs don't all have same shape and dtype or the shape cannot be inferred.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.add_to_collection, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.add_to_collection

def add_to_collection(name, value):

Wrapper for Graph.add_to_collection() using the default graph.

See Graph.add_to_collection() for more details.

Args: name: The key for the collection. For example, the GraphKeys class contains many standard names for collections. value: The value to add to the collection.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.all_candidate_sampler, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.all_candidate_sampler

def all_candidate_sampler(true_classes, num_true, num_sampled, unique, seed=None, name=None):

Generate the set of all classes.

Deterministically generates and returns the set of all possible classes. For testing purposes. There is no need to use this, since you might as well use full softmax or full logistic regression.

Args: true_classes: A Tensor of type int64 and shape [batch_size, num_true]. The target classes. num_true: An int. The number of target classes per training example. num_sampled: An int. The number of possible classes. unique: A bool. Ignored. unique. seed: An int. An operation-specific seed. Default is 0. name: A name for the operation (optional).

Returns: sampled_candidates: A tensor of type int64 and shape [num_sampled]. This operation deterministically returns the entire range [0, num_sampled]. true_expected_count: A tensor of type float. Same shape as true_classes. The expected counts under the sampling distribution of each of true_classes. All returned values are 1.0. sampled_expected_count: A tensor of type float. Same shape as sampled_candidates. The expected counts under the sampling distribution of each of sampled_candidates. All returned values are 1.0.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.all_variables, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.all_variables

def all_variables():

Returns all variables that must be saved/restored.

The Variable() constructor automatically adds new variables to the graph collection GraphKeys.VARIABLES. This convenience function returns the contents of that collection.

Returns: A list of Variable objects.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.arg_max, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.arg_max

def arg_max(input, dimension, name=None):

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

Args: input: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. dimension: A Tensor. Must be one of the following types: int32, int64. int32, 0 <= dimension < rank(input). Describes which dimension of the input Tensor to reduce across. For vectors, use dimension = 0. name: A name for the operation (optional).

Returns: A Tensor of type int64.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.arg_min, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.arg_min

def arg_min(input, dimension, name=None):

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

Args: input: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. dimension: A Tensor. Must be one of the following types: int32, int64. int32, 0 <= dimension < rank(input). Describes which dimension of the input Tensor to reduce across. For vectors, use dimension = 0. name: A name for the operation (optional).

Returns: A Tensor of type int64.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.argmax, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.argmax

def arg_max(input, dimension, name=None):

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

Args: input: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. dimension: A Tensor. Must be one of the following types: int32, int64. int32, 0 <= dimension < rank(input). Describes which dimension of the input Tensor to reduce across. For vectors, use dimension = 0. name: A name for the operation (optional).

Returns: A Tensor of type int64.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.argmin, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.argmin

def arg_min(input, dimension, name=None):

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

Args: input: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. dimension: A Tensor. Must be one of the following types: int32, int64. int32, 0 <= dimension < rank(input). Describes which dimension of the input Tensor to reduce across. For vectors, use dimension = 0. name: A name for the operation (optional).

Returns: A Tensor of type int64.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.as_dtype, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.as_dtype

def as_dtype(type_value):

Converts the given type_value to a DType.

Args: type_value: A value that can be converted to a tf.DType object. This may currently be a tf.DType object, a DataType enum, a string type name, or a numpy.dtype.

Returns: A DType corresponding to type_value.

Raises: TypeError: If type_value cannot be converted to a DType.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.as_string, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.as_string

def as_string(input, precision=None, scientific=None, shortest=None, width=None, fill=None, name=None):

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

types and boolean.

Args: input: A Tensor. Must be one of the following types: int32, int64, complex64, float32, float64, bool, int8. precision: An optional int. Defaults to -1. The post-decimal precision to use for floating point numbers. Only used if precision > -1. scientific: An optional bool. Defaults to False. Use scientific notation for floating point numbers. shortest: An optional bool. Defaults to False. Use shortest representation (either scientific or standard) for floating point numbers. width: An optional int. Defaults to -1. Pad pre-decimal numbers to this width. Applies to both floating point and integer numbers. Only used if width > -1. fill: An optional string. Defaults to "". The value to pad if width > -1. If empty, pads with spaces. Another typical value is '0'. String cannot be longer than 1 character. name: A name for the operation (optional).

Returns: A Tensor of type string.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.asin, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.asin

def asin(x, name=None):

Computes asin of x element-wise.

Args: x: A Tensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as x.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_equal, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_equal

def assert_equal(x, y, data=None, summarize=None, message=None, name=None):

Assert the condition x == y holds element-wise.

Example of adding a dependency to an operation:

python with tf.control_dependencies([tf.assert_equal(x, y)]): output = tf.reduce_sum(x)

Example of adding dependency to the tensor being checked:

python x = tf.with_dependencies([tf.assert_equal(x, y)], x)

This condition holds if for every pair of (possibly broadcast) elements x[i], y[i], we have x[i] == y[i]. If both x and y are empty, this is trivially satisfied.

Args: x: Numeric Tensor. y: Numeric Tensor, same dtype as and broadcastable to x. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of x, y. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_equal".

Returns: Op that raises InvalidArgumentError if x == y is False.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_greater_equal, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_greater_equal

def assert_greater_equal(x, y, data=None, summarize=None, message=None, name=None):

Assert the condition x >= y holds element-wise.

Example of adding a dependency to an operation:

python with tf.control_dependencies([tf.assert_greater_equal(x, y)]): output = tf.reduce_sum(x)

Example of adding dependency to the tensor being checked:

python x = tf.with_dependencies([tf.assert_greater_equal(x, y)], x)

This condition holds if for every pair of (possibly broadcast) elements x[i], y[i], we have x[i] >= y[i]. If both x and y are empty, this is trivially satisfied.

Args: x: Numeric Tensor. y: Numeric Tensor, same dtype as and broadcastable to x. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of x, y. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_greater_equal"

Returns: Op that raises InvalidArgumentError if x >= y is False.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_greater, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_greater

def assert_greater(x, y, data=None, summarize=None, message=None, name=None):

Assert the condition x > y holds element-wise.

Example of adding a dependency to an operation:

python with tf.control_dependencies([tf.assert_greater(x, y)]): output = tf.reduce_sum(x)

Example of adding dependency to the tensor being checked:

python x = tf.with_dependencies([tf.assert_greater(x, y)], x)

This condition holds if for every pair of (possibly broadcast) elements x[i], y[i], we have x[i] > y[i]. If both x and y are empty, this is trivially satisfied.

Args: x: Numeric Tensor. y: Numeric Tensor, same dtype as and broadcastable to x. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of x, y. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_greater".

Returns: Op that raises InvalidArgumentError if x > y is False.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_integer, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_integer

def assert_integer(x, message=None, name=None):

Assert that x is of integer dtype.

Example of adding a dependency to an operation:

python with tf.control_dependencies([tf.assert_integer(x)]): output = tf.reduce_sum(x)

Example of adding dependency to the tensor being checked:

python x = tf.with_dependencies([tf.assert_integer(x)], x)

Args: x: Tensor whose basetype is integer and is not quantized. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_integer".

Raises: TypeError: If x.dtype is anything other than non-quantized integer.

Returns: A no_op that does nothing. Type can be determined statically.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_less_equal, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_less_equal

def assert_less_equal(x, y, data=None, summarize=None, message=None, name=None):

Assert the condition x <= y holds element-wise.

Example of adding a dependency to an operation:

python with tf.control_dependencies([tf.assert_less_equal(x, y)]): output = tf.reduce_sum(x)

Example of adding dependency to the tensor being checked:

python x = tf.with_dependencies([tf.assert_less_equal(x, y)], x)

This condition holds if for every pair of (possibly broadcast) elements x[i], y[i], we have x[i] <= y[i]. If both x and y are empty, this is trivially satisfied.

Args: x: Numeric Tensor. y: Numeric Tensor, same dtype as and broadcastable to x. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of x, y. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_less_equal"

Returns: Op that raises InvalidArgumentError if x <= y is False.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_less, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_less

def assert_less(x, y, data=None, summarize=None, message=None, name=None):

Assert the condition x < y holds element-wise.

Example of adding a dependency to an operation:

python with tf.control_dependencies([tf.assert_less(x, y)]): output = tf.reduce_sum(x)

Example of adding dependency to the tensor being checked:

python x = tf.with_dependencies([tf.assert_less(x, y)], x)

This condition holds if for every pair of (possibly broadcast) elements x[i], y[i], we have x[i] < y[i]. If both x and y are empty, this is trivially satisfied.

Args: x: Numeric Tensor. y: Numeric Tensor, same dtype as and broadcastable to x. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of x, y. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_less".

Returns: Op that raises InvalidArgumentError if x < y is False.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_negative, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_negative

def assert_negative(x, data=None, summarize=None, message=None, name=None):

Assert the condition x < 0 holds element-wise.

Example of adding a dependency to an operation:

python with tf.control_dependencies([tf.assert_negative(x)]): output = tf.reduce_sum(x)

Example of adding dependency to the tensor being checked:

python x = tf.with_dependencies([tf.assert_negative(x)], x)

Negative means, for every element x[i] of x, we have x[i] < 0. If x is empty this is trivially satisfied.

Args: x: Numeric Tensor. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of x. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_negative".

Returns: Op raising InvalidArgumentError unless x is all negative.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_non_negative, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_non_negative

def assert_non_negative(x, data=None, summarize=None, message=None, name=None):

Assert the condition x >= 0 holds element-wise.

Example of adding a dependency to an operation:

python with tf.control_dependencies([tf.assert_non_negative(x)]): output = tf.reduce_sum(x)

Example of adding dependency to the tensor being checked:

python x = tf.with_dependencies([tf.assert_non_negative(x)], x)

Non-negative means, for every element x[i] of x, we have x[i] >= 0. If x is empty this is trivially satisfied.

Args: x: Numeric Tensor. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of x. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_non_negative".

Returns: Op raising InvalidArgumentError unless x is all non-negative.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_non_positive, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_non_positive

def assert_non_positive(x, data=None, summarize=None, message=None, name=None):

Assert the condition x <= 0 holds element-wise.

Example of adding a dependency to an operation:

python with tf.control_dependencies([tf.assert_non_positive(x)]): output = tf.reduce_sum(x)

Example of adding dependency to the tensor being checked:

python x = tf.with_dependencies([tf.assert_non_positive(x)], x)

Non-positive means, for every element x[i] of x, we have x[i] <= 0. If x is empty this is trivially satisfied.

Args: x: Numeric Tensor. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of x. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_non_positive".

Returns: Op raising InvalidArgumentError unless x is all non-positive.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_positive, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_positive

def assert_positive(x, data=None, summarize=None, message=None, name=None):

Assert the condition x > 0 holds element-wise.

Example of adding a dependency to an operation:

python with tf.control_dependencies([tf.assert_positive(x)]): output = tf.reduce_sum(x)

Example of adding dependency to the tensor being checked:

python x = tf.with_dependencies([tf.assert_positive(x)], x)

Positive means, for every element x[i] of x, we have x[i] > 0. If x is empty this is trivially satisfied.

Args: x: Numeric Tensor. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of x. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_positive".

Returns: Op raising InvalidArgumentError unless x is all positive.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_proper_iterable, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_proper_iterable

def assert_proper_iterable(values):

Static assert that values is a "proper" iterable.

Ops that expect iterables of Tensor can call this to validate input. Useful since Tensor, ndarray, byte/text type are all iterables themselves.

Args: values: Object to be checked.

Raises: TypeError: If values is not iterable or is one of Tensor, SparseTensor, np.array, tf.compat.bytes_or_text_types.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_rank_at_least, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_rank_at_least

def assert_rank_at_least(x, rank, data=None, summarize=None, message=None, name=None):

Assert x has rank equal to rank or higher.

Example of adding a dependency to an operation:

python with tf.control_dependencies([tf.assert_rank_at_least(x, 2)]): output = tf.reduce_sum(x)

Example of adding dependency to the tensor being checked:

python x = tf.with_dependencies([tf.assert_rank_at_least(x, 2)], x)

Args: x: Numeric Tensor. rank: Scalar Tensor. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of x. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_rank_at_least".

Returns: Op raising InvalidArgumentError unless x has specified rank or higher. If static checks determine x has correct rank, a no_op is returned.

Raises: ValueError: If static checks determine x has wrong rank.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_rank, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_rank

def assert_rank(x, rank, data=None, summarize=None, message=None, name=None):

Assert x has rank equal to rank.

Example of adding a dependency to an operation:

python with tf.control_dependencies([tf.assert_rank(x, 2)]): output = tf.reduce_sum(x)

Example of adding dependency to the tensor being checked:

python x = tf.with_dependencies([tf.assert_rank(x, 2)], x)

Args: x: Numeric Tensor. rank: Scalar integer Tensor. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of x. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_rank".

Returns: Op raising InvalidArgumentError unless x has specified rank. If static checks determine x has correct rank, a no_op is returned.

Raises: ValueError: If static checks determine x has wrong rank.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_type, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_type

def assert_type(tensor, tf_type, message=None, name=None):

Statically asserts that the given Tensor is of the specified type.

Args: tensor: A tensorflow Tensor. tf_type: A tensorflow type (dtypes.float32, tf.int64, dtypes.bool, etc). message: A string to prefix to the default message. name: A name to give this Op. Defaults to "assert_type"

Raises: TypeError: If the tensors data type doesn't match tf_type.

Returns: A no_op that does nothing. Type can be determined statically.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assert_variables_initialized, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assert_variables_initialized

def assert_variables_initialized(var_list=None):

Returns an Op to check if variables are initialized.

NOTE: This function is obsolete and will be removed in 6 months. Please change your implementation to use report_uninitialized_variables().

When run, the returned Op will raise the exception FailedPreconditionError if any of the variables has not yet been initialized.

Note: This function is implemented by trying to fetch the values of the variables. If one of the variables is not initialized a message may be logged by the C++ runtime. This is expected.

Args: var_list: List of Variable objects to check. Defaults to the value of all_variables().

Returns: An Op, or None if there are no variables.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assign_add, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assign_add

def assign_add(ref, value, use_locking=None, name=None):

Update 'ref' by adding 'value' to it.

This operation outputs "ref" after the update is done. This makes it easier to chain operations that need to use the reset value.

Args: ref: A mutable Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. Should be from a Variable node. value: A Tensor. Must have the same type as ref. The value to be added to the variable. use_locking: An optional bool. Defaults to False. If True, the addition will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional).

Returns: Same as "ref". Returned as a convenience for operations that want to use the new value after the variable has been updated.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assign, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assign

def assign(ref, value, validate_shape=None, use_locking=None, name=None):

Update 'ref' by assigning 'value' to it.

This operation outputs "ref" after the assignment is done. This makes it easier to chain operations that need to use the reset value.

Args: ref: A mutable Tensor. Should be from a Variable node. May be uninitialized. value: A Tensor. Must have the same type as ref. The value to be assigned to the variable. validate_shape: An optional bool. Defaults to True. If true, the operation will validate that the shape of 'value' matches the shape of the Tensor being assigned to. If false, 'ref' will take on the shape of 'value'. use_locking: An optional bool. Defaults to True. If True, the assignment will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional).

Returns: Same as "ref". Returned as a convenience for operations that want to use the new value after the variable has been reset.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.assign_sub, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.assign_sub

def assign_sub(ref, value, use_locking=None, name=None):

Update 'ref' by subtracting 'value' from it.

This operation outputs "ref" after the update is done. This makes it easier to chain operations that need to use the reset value.

Args: ref: A mutable Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. Should be from a Variable node. value: A Tensor. Must have the same type as ref. The value to be subtracted to the variable. use_locking: An optional bool. Defaults to False. If True, the subtraction will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional).

Returns: Same as "ref". Returned as a convenience for operations that want to use the new value after the variable has been updated.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.atan, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.atan

def atan(x, name=None):

Computes atan of x element-wise.

Args: x: A Tensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as x.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.atrous_conv2d, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.atrous_conv2d

def atrous_conv2d(value, filters, rate, padding, name=None):

Atrous convolution (a.k.a. convolution with holes or dilated convolution).

Computes a 2-D atrous convolution, also known as convolution with holes or dilated convolution, given 4-D value and filters tensors. If the rate parameter is equal to one, it performs regular 2-D convolution. If the rate parameter is greater than one, it performs convolution with holes, sampling the input values every rate pixels in the height and width dimensions. This is equivalent to convolving the input with a set of upsampled filters, produced by inserting rate - 1 zeros between two consecutive values of the filters along the height and width dimensions, hence the name atrous convolution or convolution with holes (the French word trous means holes in English).

More specifically:

output[b, i, j, k] = sum_{di, dj, q} filters[di, dj, q, k] *
      value[b, i + rate * di, j + rate * dj, q]

Atrous convolution allows us to explicitly control how densely to compute feature responses in fully convolutional networks. Used in conjunction with bilinear interpolation, it offers an alternative to conv2d_transpose in dense prediction tasks such as semantic image segmentation, optical flow computation, or depth estimation. It also allows us to effectively enlarge the field of view of filters without increasing the number of parameters or the amount of computation.

For a description of atrous convolution and how it can be used for dense feature extraction, please see: Semantic Image Segmentation with Deep Convolutional Nets and Fully Connected CRFs. The same operation is investigated further in Multi-Scale Context Aggregation by Dilated Convolutions. Previous works that effectively use atrous convolution in different ways are, among others, OverFeat: Integrated Recognition, Localization and Detection using Convolutional Networks and [Fast Image Scanning with Deep Max-Pooling Convolutional Neural Networks] (http://arxiv.org/abs/1302.1700). Atrous convolution is also closely related to the so-called noble identities in multi-rate signal processing.

There are many different ways to implement atrous convolution (see the refs above). The implementation here reduces

atrous_conv2d(value, filters, rate, padding=padding)

to the following three operations:

paddings = ...
net = space_to_batch(value, paddings, block_size=rate)
net = conv2d(net, filters, strides=[1, 1, 1, 1], padding="VALID")
crops = ...
net = batch_to_space(net, crops, block_size=rate)

Advanced usage. Note the following optimization: A sequence of atrous_conv2d operations with identical rate parameters, 'SAME' padding, and filters with odd heights/ widths:

net = atrous_conv2d(net, filters1, rate, padding="SAME")
net = atrous_conv2d(net, filters2, rate, padding="SAME")
...
net = atrous_conv2d(net, filtersK, rate, padding="SAME")

can be equivalently performed cheaper in terms of computation and memory as:

pad = ...  # padding so that the input dims are multiples of rate
net = space_to_batch(net, paddings=pad, block_size=rate)
net = conv2d(net, filters1, strides=[1, 1, 1, 1], padding="SAME")
net = conv2d(net, filters2, strides=[1, 1, 1, 1], padding="SAME")
...
net = conv2d(net, filtersK, strides=[1, 1, 1, 1], padding="SAME")
net = batch_to_space(net, crops=pad, block_size=rate)

because a pair of consecutive space_to_batch and batch_to_space ops with the same block_size cancel out when their respective paddings and crops inputs are identical.

Args: value: A 4-D Tensor of type float. It needs to be in the default "NHWC" format. Its shape is [batch, in_height, in_width, in_channels]. filters: A 4-D Tensor with the same type as value and shape [filter_height, filter_width, in_channels, out_channels]. filters' in_channels dimension must match that of value. Atrous convolution is equivalent to standard convolution with upsampled filters with effective height filter_height + (filter_height - 1) * (rate - 1) and effective width filter_width + (filter_width - 1) * (rate - 1), produced by inserting rate - 1 zeros along consecutive elements across the filters' spatial dimensions. rate: A positive int32. The stride with which we sample input values across the height and width dimensions. Equivalently, the rate by which we upsample the filter values by inserting zeros across the height and width dimensions. In the literature, the same parameter is sometimes called input stride or dilation. padding: A string, either 'VALID' or 'SAME'. The padding algorithm. name: Optional name for the returned tensor.

Returns: A Tensor with the same type as value.

Raises: ValueError: If input/output depth does not match filters' shape, or if padding is other than 'VALID' or 'SAME'.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.avg_pool3d_grad, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.avg_pool3d_grad

def avg_pool3d_grad(orig_input_shape, grad, ksize, strides, padding, name=None):

Computes gradients of average pooling function.

Args: orig_input_shape: A Tensor of type int32. The original input dimensions. grad: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. Output backprop of shape [batch, depth, rows, cols, channels]. ksize: A list of ints that has length >= 5. 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: A list of ints that has length >= 5. 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: A string from: "SAME", "VALID". The type of padding algorithm to use. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as grad. The backprop for input.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.avg_pool3d, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.avg_pool3d

def avg_pool3d(input, ksize, strides, padding, name=None):

Performs 3D average pooling on the input.

Args: input: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. Shape [batch, depth, rows, cols, channels] tensor to pool over. ksize: A list of ints that has length >= 5. 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: A list of ints that has length >= 5. 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: A string from: "SAME", "VALID". The type of padding algorithm to use. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as input. The average pooled output tensor.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.avg_pool, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.avg_pool

def avg_pool(value, ksize, strides, padding, data_format="NHWC", name=None):

Performs the average pooling on the input.

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

Args: value: A 4-D Tensor of shape [batch, height, width, channels] and type float32, float64, qint8, quint8, or qint32. ksize: A list of ints that has length >= 4. The size of the window for each dimension of the input tensor. strides: A list of ints that has length >= 4. The stride of the sliding window for each dimension of the input tensor. padding: A string, either 'VALID' or 'SAME'. The padding algorithm. See the comment here data_format: A string. 'NHWC' and 'NCHW' are supported. name: Optional name for the operation.

Returns: A Tensor with the same type as value. The average pooled output tensor.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.batch_matmul, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.batch_matmul

def _batch_mat_mul(x, y, adj_x=None, adj_y=None, name=None):

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 3-D or higher with shape [..., r_x, c_x] and [..., r_y, c_y].

The output tensor is 3-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[..., :, :])

Args: x: A Tensor. Must be one of the following types: half, float32, float64, int32, complex64, complex128. 3-D or higher with shape [..., r_x, c_x]. y: A Tensor. Must have the same type as x. 3-D or higher with shape [..., r_y, c_y]. adj_x: An optional bool. Defaults to False. If True, adjoint the slices of x. Defaults to False. adj_y: An optional bool. Defaults to False. If True, adjoint the slices of y. Defaults to False. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as x. 3-D or higher with shape [..., r_o, c_o]

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.batch_norm_with_global_normalization, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.batch_norm_with_global_normalization

def batch_norm_with_global_normalization(t, m, v, beta, gamma, variance_epsilon, scale_after_normalization, name=None):

Batch normalization.

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

Args: 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. name: A name for this operation (optional).

Returns: A batch-normalized t.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.batch_normalization, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.batch_normalization

def batch_normalization(x, mean, variance, offset, scale, variance_epsilon, name=None):

Batch normalization.

As described in http://arxiv.org/abs/1502.03167. Normalizes a tensor by mean and variance, and applies (optionally) a scale \\(\gamma\\) to it, as well as an offset \\(\beta\\):

\\(\frac{\gamma(x-\mu)}{\sigma}+\beta\\)

mean, variance, offset and scale are all expected to be of one of two shapes: * In all generality, they can have the same number of dimensions as the input x, with identical sizes as x for the dimensions that are not normalized over (the 'depth' dimension(s)), and dimension 1 for the others which are being normalized over. mean and variance in this case would typically be the outputs of tf.nn.moments(..., keep_dims=True) during training, or running averages thereof during inference. * In the common case where the 'depth' dimension is the last dimension in the input tensor x, they may be one dimensional tensors of the same size as the 'depth' dimension. This is the case for example for the common [batch, depth] layout of fully-connected layers, and [batch, height, width, depth] for convolutions. mean and variance in this case would typically be the outputs of tf.nn.moments(..., keep_dims=False) during training, or running averages thereof during inference.

Args: x: Input Tensor of arbitrary dimensionality. mean: A mean Tensor. variance: A variance Tensor. offset: An offset Tensor, often denoted \\(\beta\\) in equations, or None. If present, will be added to the normalized tensor. scale: A scale Tensor, often denoted \\(\gamma\\) in equations, or None. If present, the scale is applied to the normalized tensor. variance_epsilon: A small float number to avoid dividing by 0. name: A name for this operation (optional).

Returns: the normalized, scaled, offset tensor.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.batch_to_space, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.batch_to_space

def batch_to_space(input, crops, block_size, name=None):

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.

Args: input: A Tensor. 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: A Tensor. Must be one of the following types: int32, int64. 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]]

block_size: An int that is >= 2. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as input. 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:

prettyprint [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]

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

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

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

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

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

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

prettyprint x = [[[[1], [3]], [[5], [7]]], [[[2], [4]], [[10], [12]]], [[[5], [7]], [[13], [15]]], [[[6], [8]], [[14], [16]]]]

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

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

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

prettyprint x = [[[[1], [3]], [[5], [7]]], [[[2], [4]], [[10], [12]]], [[[5], [7]], [[13], [15]]], [[[6], [8]], [[14], [16]]]]

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.batch_to_space_nd, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.batch_to_space_nd

def batch_to_space_nd(input, block_shape, crops, name=None):

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.

Args: input: A Tensor. N-D with shape input_shape = [batch] + spatial_shape + remaining_shape, where spatial_shape has M dimensions. block_shape: A Tensor. Must be one of the following types: int32, int64. 1-D with shape [M], all values must be >= 1. crops: A Tensor. Must be one of the following types: int32, int64. 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]]`:

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

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

```prettyprint
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]]`:

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

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

```prettyprint
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]]`:

```prettyprint
x = [[[[1], [3]], [[5], [7]]],
     [[[2], [4]], [[10], [12]]],
     [[[5], [7]], [[13], [15]]],
     [[[6], [8]], [[14], [16]]]]
```

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

```prettyprint
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]]`:

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

```prettyprint
x = [[[[1],   [2],  [3],  [4]],
      [[5],   [6],  [7],  [8]]],
     [[[9],  [10], [11],  [12]],
      [[13], [14], [15],  [16]]]]
```

name: A name for the operation (optional).

Returns: A Tensor. Has the same type as input.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.betainc, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.betainc

def betainc(a, b, x, name=None):

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.

Args: a: A Tensor. Must be one of the following types: float32, float64. b: A Tensor. Must have the same type as a. x: A Tensor. Must have the same type as a. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as a.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.bias_add_grad, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.bias_add_grad

def bias_add_grad(out_backprop, data_format=None, name=None):

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.

Args: out_backprop: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. Any number of dimensions. data_format: An optional string from: "NHWC", "NCHW". Defaults to "NHWC". 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. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as out_backprop. 1-D with size the feature dimension of out_backprop.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.bias_add, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.bias_add

def bias_add(value, bias, data_format=None, name=None):

Adds bias to value.

This is (mostly) a special case of tf.add where bias is restricted to 1-D. Broadcasting is supported, so value may have any number of dimensions. Unlike tf.add, the type of bias is allowed to differ from value in the case where both types are quantized.

Args: value: A Tensor with type float, double, int64, int32, uint8, int16, int8, complex64, or complex128. bias: A 1-D Tensor with size matching the last dimension of value. Must be the same type as value unless value is a quantized type, in which case a different quantized type may be used. data_format: A string. 'NHWC' and 'NCHW' are supported. name: A name for the operation (optional).

Returns: A Tensor with the same type as value.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.bias_add_v1, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.bias_add_v1

def bias_add_v1(value, bias, name=None):

Adds bias to value.

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

This is (mostly) a special case of tf.add where bias is restricted to 1-D. Broadcasting is supported, so value may have any number of dimensions. Unlike tf.add, the type of bias is allowed to differ from value in the case where both types are quantized.

Args: value: A Tensor with type float, double, int64, int32, uint8, int16, int8, complex64, or complex128. bias: A 1-D Tensor with size matching the last dimension of value. Must be the same type as value unless value is a quantized type, in which case a different quantized type may be used. name: A name for the operation (optional).

Returns: A Tensor with the same type as value.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.bidirectional_dynamic_rnn, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.bidirectional_dynamic_rnn

def bidirectional_dynamic_rnn(cell_fw, cell_bw, inputs, sequence_length=None, initial_state_fw=None, initial_state_bw=None, dtype=None, parallel_iterations=None, swap_memory=False, time_major=False, scope=None):

Creates a dynamic version of bidirectional recurrent neural network.

Similar to the unidirectional case above (rnn) but takes input and builds independent forward and backward RNNs. The input_size of forward and backward cell must match. The initial state for both directions is zero by default (but can be set optionally) and no intermediate states are ever returned -- the network is fully unrolled for the given (passed in) length(s) of the sequence(s) or completely unrolled if length(s) is not given.

Args: cell_fw: An instance of RNNCell, to be used for forward direction. cell_bw: An instance of RNNCell, to be used for backward direction. inputs: The RNN inputs. If time_major == False (default), this must be a tensor of shape: [batch_size, max_time, input_size]. If time_major == True, this must be a tensor of shape: [max_time, batch_size, input_size]. [batch_size, input_size]. sequence_length: An int32/int64 vector, size [batch_size], containing the actual lengths for each of the sequences. initial_state_fw: (optional) An initial state for the forward RNN. This must be a tensor of appropriate type and shape [batch_size, cell_fw.state_size]. If cell_fw.state_size is a tuple, this should be a tuple of tensors having shapes [batch_size, s] for s in cell_fw.state_size. initial_state_bw: (optional) Same as for initial_state_fw, but using the corresponding properties of cell_bw. dtype: (optional) The data type for the initial states and expected output. Required if initial_states are not provided or RNN states have a heterogeneous dtype. parallel_iterations: (Default: 32). The number of iterations to run in parallel. Those operations which do not have any temporal dependency and can be run in parallel, will be. This parameter trades off time for space. Values >> 1 use more memory but take less time, while smaller values use less memory but computations take longer. swap_memory: Transparently swap the tensors produced in forward inference but needed for back prop from GPU to CPU. This allows training RNNs which would typically not fit on a single GPU, with very minimal (or no) performance penalty. time_major: The shape format of the inputs and outputs Tensors. If true, these Tensors must be shaped [max_time, batch_size, depth]. If false, these Tensors must be shaped [batch_size, max_time, depth]. Using time_major = True is a bit more efficient because it avoids transposes at the beginning and end of the RNN calculation. However, most TensorFlow data is batch-major, so by default this function accepts input and emits output in batch-major form. dtype: (optional) The data type for the initial state. Required if initial_state is not provided. sequence_length: An int32/int64 vector, size [batch_size], containing the actual lengths for each of the sequences. either of the initial states are not provided. scope: VariableScope for the created subgraph; defaults to "BiRNN"

Returns: A tuple (outputs, output_states) where: outputs: A tuple (output_fw, output_bw) containing the forward and the backward rnn output Tensor. If time_major == False (default), output_fw will be a Tensor shaped: [batch_size, max_time, cell_fw.output_size] and output_bw will be a Tensor shaped: [batch_size, max_time, cell_bw.output_size]. If time_major == True, output_fw will be a Tensor shaped: [max_time, batch_size, cell_fw.output_size] and output_bw will be a Tensor shaped: [max_time, batch_size, cell_bw.output_size]. It returns a tuple instead of a single concatenated Tensor, unlike in the bidirectional_rnn. If the concatenated one is preferred, the forward and backward outputs can be concatenated as tf.concat(2, outputs). output_states: A tuple (output_state_fw, output_state_bw) containing the forward and the backward final states of bidirectional rnn.

Raises: TypeError: If cell_fw or cell_bw is not an instance of RNNCell.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.bidirectional_rnn, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.bidirectional_rnn

def bidirectional_rnn(cell_fw, cell_bw, inputs, initial_state_fw=None, initial_state_bw=None, dtype=None, sequence_length=None, scope=None):

Creates a bidirectional recurrent neural network.

Similar to the unidirectional case above (rnn) but takes input and builds independent forward and backward RNNs with the final forward and backward outputs depth-concatenated, such that the output will have the format [time][batch][cell_fw.output_size + cell_bw.output_size]. The input_size of forward and backward cell must match. The initial state for both directions is zero by default (but can be set optionally) and no intermediate states are ever returned -- the network is fully unrolled for the given (passed in) length(s) of the sequence(s) or completely unrolled if length(s) is not given.

Args: cell_fw: An instance of RNNCell, to be used for forward direction. cell_bw: An instance of RNNCell, to be used for backward direction. inputs: A length T list of inputs, each a tensor of shape [batch_size, input_size], or a nested tuple of such elements. initial_state_fw: (optional) An initial state for the forward RNN. This must be a tensor of appropriate type and shape [batch_size, cell_fw.state_size]. If cell_fw.state_size is a tuple, this should be a tuple of tensors having shapes [batch_size, s] for s in cell_fw.state_size. initial_state_bw: (optional) Same as for initial_state_fw, but using the corresponding properties of cell_bw. dtype: (optional) The data type for the initial state. Required if either of the initial states are not provided. sequence_length: (optional) An int32/int64 vector, size [batch_size], containing the actual lengths for each of the sequences. scope: VariableScope for the created subgraph; defaults to "BiRNN"

Returns: A tuple (outputs, output_state_fw, output_state_bw) where: outputs is a length T list of outputs (one for each input), which are depth-concatenated forward and backward outputs. output_state_fw is the final state of the forward rnn. output_state_bw is the final state of the backward rnn.

Raises: TypeError: If cell_fw or cell_bw is not an instance of RNNCell. ValueError: If inputs is None or an empty list.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.bitcast, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.bitcast

def bitcast(input, type, name=None):

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

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

Args: input: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. type: A tf.DType from: tf.float32, tf.float64, tf.int64, tf.int32, tf.uint8, tf.uint16, tf.int16, tf.int8, tf.complex64, tf.complex128, tf.qint8, tf.quint8, tf.qint32, tf.half. name: A name for the operation (optional).

Returns: A Tensor of type type.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.boolean_mask, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.boolean_mask

def boolean_mask(tensor, mask, name="boolean_mask"):

Apply boolean mask to tensor. Numpy equivalent is tensor[mask].

```python

1-D example

tensor = [0, 1, 2, 3] mask = [True, False, True, False] boolean_mask(tensor, mask) ==> [0, 2] ```

In general, 0 < dim(mask) = K <= dim(tensor), and mask's shape must match the first K dimensions of tensor's shape. We then have: boolean_mask(tensor, mask)[i, j1,...,jd] = tensor[i1,...,iK,j1,...,jd] where (i1,...,iK) is the ith True entry of mask (row-major order).

Args: tensor: N-D tensor. mask: K-D boolean tensor, K <= N and K must be known statically. name: A name for this operation (optional).

Returns: Tensor populated by entries in tensor corresponding to True values in mask.

Raises: ValueError: If shapes do not conform.

Examples:

```python

2-D example

tensor = [[1, 2], [3, 4], [5, 6]] mask = [True, False, True] boolean_mask(tensor, mask) ==> [[1, 2], [5, 6]] ```

Returns a flattened list tensorbuilder.core.builders.Builders contained by this tree. The whole result is flattened in case of sub-elements are also tensorbuilder.core.builders.BuilderTrees.

Return

• list( tensorbuilder.core.builders.Builder )

Examples

This examples creates a network to that solves the XOR problem using sigmoid units

import tensorflow as tf
from tensorbuilder import tb

x = tf.placeholder(tf.float32, shape=[None, 2])
y = tf.placeholder(tf.float32, shape=[None, 1])


#Network
[activation_builder, trainer_builder] = (
    tb.build(x)

    .sigmoid_layer(2)
    .linear_layer(1)

    .branch(lambda logit:
    [
        logit.sigmoid() # activation
    ,
        logit
        .sigmoid_cross_entropy_with_logits(y) # loss
        .map(tf.train.AdamOptimizer(0.01).minimize) # trainer
    ])
    .builders()
)

Same example using the DSL

import tensorflow as tf
from tensorbuilder import tb

x = tf.placeholder(tf.float32, shape=[None, 2])
y = tf.placeholder(tf.float32, shape=[None, 1])


#Network
[activation_builder, trainer_builder] = tb.pipe(
    x,
    tb.sigmoid_layer(2)
    .linear_layer(1),
    [
        tb.sigmoid() # activation
    ,
        tb
        .sigmoid_cross_entropy_with_logits(y) # loss
        .map(tf.train.AdamOptimizer(0.01).minimize) # trainer
    ],
    tb.builders()
)

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.case, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.case

def case(pred_fn_pairs, default, exclusive=False, name="case"):

Create a case operation.

The pred_fn_pairs parameter is a dict or list of pairs of size N. Each pair contains a boolean scalar tensor and a python callable that creates the tensors to be returned if the boolean evaluates to True. default is a callable generating a list of tensors. All the callables in pred_fn_pairs as well as default should return the same number and types of tensors.

If exclusive==True, all predicates are evaluated, and a logging operation with an error is returned if more than one of the predicates evaluates to True. If exclusive==False, execution stops are the first predicate which evaluates to True, and the tensors generated by the corresponding function are returned immediately. If none of the predicates evaluate to True, this operation returns the tensors generated by default.

Example 1: Pseudocode: if (x < y) return 17; else return 23;

Expressions: f1 = lambda: tf.constant(17) f2 = lambda: tf.constant(23) r = case([(tf.less(x, y), f1)], default=f2)

Example 2: Pseudocode: if (x < y && x > z) raise OpError("Only one predicate may evaluate true"); if (x < y) return 17; else if (x > z) return 23; else return -1;

Expressions: x = tf.constant(0) y = tf.constant(1) z = tf.constant(2) def f1(): return tf.constant(17) def f2(): return tf.constant(23) def f3(): return tf.constant(-1) r = case({tf.less(x, y): f1, tf.greater(x, z): f2}, default=f3, exclusive=True)

Args: pred_fn_pairs: Dict or list of pairs of a boolean scalar tensor and a callable which returns a list of tensors. default: A callable that returns a list of tensors. exclusive: True iff more than one predicate is allowed to evaluate to True. name: A name for this operation (optional).

Returns: The tensors returned by the first pair whose predicate evaluated to True, or those returned by default if none does.

Raises: TypeError: If pred_fn_pairs is not a list/dictionary. TypeError: If pred_fn_pairs is a list but does not contain 2-tuples. TypeError: If fns[i] is not callable for any i, or default is not callable.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.cast, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.cast

def cast(x, dtype, name=None):

Casts a tensor to a new type.

The operation casts x (in case of Tensor) or x.values (in case of SparseTensor) to dtype.

For example:

```python

tensor a is [1.8, 2.2], dtype=tf.float

tf.cast(a, tf.int32) ==> [1, 2] # dtype=tf.int32 ```

Args: x: A Tensor or SparseTensor. dtype: The destination type. name: A name for the operation (optional).

Returns: A Tensor or SparseTensor with same shape as x.

Raises: TypeError: If x cannot be cast to the dtype.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.ceil, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.ceil

def ceil(x, name=None):

Returns element-wise smallest integer in not less than x.

Args: x: A Tensor. Must be one of the following types: half, float32, float64. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as x.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.check_numerics, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.check_numerics

def check_numerics(tensor, message, name=None):

Checks a tensor for NaN and Inf values.

When run, reports an InvalidArgument error if tensor has any values that are not a number (NaN) or infinity (Inf). Otherwise, passes tensor as-is.

Args: tensor: A Tensor. Must be one of the following types: half, float32, float64. message: A string. Prefix of the error message. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as tensor.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.cholesky, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.cholesky

def cholesky(input, name=None):

Computes the Cholesky decomposition of one or more square matrices.

The input is a tensor of shape [..., M, M] whose inner-most 2 dimensions form square matrices, with the same constraints as the single matrix Cholesky decomposition above. The output is a tensor of the same shape as the input containing the Cholesky decompositions for all input submatrices [..., :, :].

Args: input: A Tensor. Must be one of the following types: float64, float32. Shape is [..., M, M]. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as input. Shape is [..., M, M].

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.cholesky_solve, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.cholesky_solve

def cholesky_solve(chol, rhs, name=None):

Solves systems of linear eqns A X = RHS, given Cholesky factorizations.

```python

Solve 10 separate 2x2 linear systems:

A = ... # shape 10 x 2 x 2 RHS = ... # shape 10 x 2 x 1 chol = tf.cholesky(A) # shape 10 x 2 x 2 X = tf.cholesky_solve(chol, RHS) # shape 10 x 2 x 1

tf.matmul(A, X) ~ RHS

X[3, :, 0] # Solution to the linear system A[3, :, :] x = RHS[3, :, 0]

Solve five linear systems (K = 5) for every member of the length 10 batch.

A = ... # shape 10 x 2 x 2 RHS = ... # shape 10 x 2 x 5 ... X[3, :, 2] # Solution to the linear system A[3, :, :] x = RHS[3, :, 2] ```

Args: chol: A Tensor. Must be float32 or float64, shape is [..., M, M]. Cholesky factorization of A, e.g. chol = tf.cholesky(A). For that reason, only the lower triangular parts (including the diagonal) of the last two dimensions of chol are used. The strictly upper part is assumed to be zero and not accessed. rhs: A Tensor, same type as chol, shape is [..., M, K]. name: A name to give this Op. Defaults to cholesky_solve.

Returns: Solution to A x = rhs, shape [..., M, K].

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.clip_by_average_norm, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.clip_by_average_norm

def clip_by_average_norm(t, clip_norm, name=None):

Clips tensor values to a maximum average L2-norm.

Given a tensor t, and a maximum clip value clip_norm, this operation normalizes t so that its average L2-norm is less than or equal to clip_norm. Specifically, if the average L2-norm is already less than or equal to clip_norm, then t is not modified. If the average L2-norm is greater than clip_norm, then this operation returns a tensor of the same type and shape as t with its values set to:

t * clip_norm / l2norm_avg(t)

In this case, the average L2-norm of the output tensor is clip_norm.

This operation is typically used to clip gradients before applying them with an optimizer.

Args: t: A Tensor. clip_norm: A 0-D (scalar) Tensor > 0. A maximum clipping value. name: A name for the operation (optional).

Returns: A clipped Tensor.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.clip_by_global_norm, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.clip_by_global_norm

def clip_by_global_norm(t_list, clip_norm, use_norm=None, name=None):

Clips values of multiple tensors by the ratio of the sum of their norms.

Given a tuple or list of tensors t_list, and a clipping ratio clip_norm, this operation returns a list of clipped tensors list_clipped and the global norm (global_norm) of all tensors in t_list. Optionally, if you've already computed the global norm for t_list, you can specify the global norm with use_norm.

To perform the clipping, the values t_list[i] are set to:

t_list[i] * clip_norm / max(global_norm, clip_norm)

where:

global_norm = sqrt(sum([l2norm(t)**2 for t in t_list]))

If clip_norm > global_norm then the entries in t_list remain as they are, otherwise they're all shrunk by the global ratio.

Any of the entries of t_list that are of type None are ignored.

This is the correct way to perform gradient clipping (for example, see Pascanu et al., 2012 (pdf)).

However, it is slower than clip_by_norm() because all the parameters must be ready before the clipping operation can be performed.

Args: t_list: A tuple or list of mixed Tensors, IndexedSlices, or None. clip_norm: A 0-D (scalar) Tensor > 0. The clipping ratio. use_norm: A 0-D (scalar) Tensor of type float (optional). The global norm to use. If not provided, global_norm() is used to compute the norm. name: A name for the operation (optional).

Returns: list_clipped: A list of Tensors of the same type as list_t. global_norm: A 0-D (scalar) Tensor representing the global norm.

Raises: TypeError: If t_list is not a sequence.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.clip_by_norm, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.clip_by_norm

def clip_by_norm(t, clip_norm, axes=None, name=None):

Clips tensor values to a maximum L2-norm.

Given a tensor t, and a maximum clip value clip_norm, this operation normalizes t so that its L2-norm is less than or equal to clip_norm, along the dimensions given in axes. Specifically, in the default case where all dimensions are used for calculation, if the L2-norm of t is already less than or equal to clip_norm, then t is not modified. If the L2-norm is greater than clip_norm, then this operation returns a tensor of the same type and shape as t with its values set to:

t * clip_norm / l2norm(t)

In this case, the L2-norm of the output tensor is clip_norm.

As another example, if t is a matrix and axes == [1], then each row of the output will have L2-norm equal to clip_norm. If axes == [0] instead, each column of the output will be clipped.

This operation is typically used to clip gradients before applying them with an optimizer.

Args: t: A Tensor. clip_norm: A 0-D (scalar) Tensor > 0. A maximum clipping value. axes: A 1-D (vector) Tensor of type int32 containing the dimensions to use for computing the L2-norm. If None (the default), uses all dimensions. name: A name for the operation (optional).

Returns: A clipped Tensor.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.clip_by_value, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.clip_by_value

def clip_by_value(t, clip_value_min, clip_value_max, name=None):

Clips tensor values to a specified min and max.

Given a tensor t, this operation returns a tensor of the same type and shape as t with its values clipped to clip_value_min and clip_value_max. Any values less than clip_value_min are set to clip_value_min. Any values greater than clip_value_max are set to clip_value_max.

Args: t: A Tensor. clip_value_min: A 0-D (scalar) Tensor. The minimum value to clip by. clip_value_max: A 0-D (scalar) Tensor. The maximum value to clip by. name: A name for the operation (optional).

Returns: A clipped Tensor.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.complex_abs, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.complex_abs

def complex_abs(x, name=None):

Computes the complex absolute value of a tensor.

Given a tensor x of complex numbers, this operation returns a tensor of type float32 or float64 that is the absolute value of each element in x. All elements in x must be complex numbers of the form \(a + bj\). The absolute value is computed as \( \sqrt{a^2 + b^2}\).

For example:

```

tensor 'x' is [[-2.25 + 4.75j], [-3.25 + 5.75j]]

tf.complex_abs(x) ==> [5.25594902, 6.60492229] ```

Args: x: A Tensor of type complex64 or complex128. name: A name for the operation (optional).

Returns: A Tensor of type float32 or float64.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.complex, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.complex

def complex(real, imag, name=None):

Converts two real numbers to a complex number.

Given a tensor real representing the real part of a complex number, and a tensor imag representing the imaginary part of a complex number, this operation returns complex numbers elementwise of the form (a + bj), where a represents the real part and b represents the imag part.

The input tensors real and imag must have the same shape.

For example:

```

tensor 'real' is [2.25, 3.25]

tensor imag is [4.75, 5.75]

tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]] ```

Args: real: A Tensor. Must be one of the following types: float32, float64. imag: A Tensor. Must have the same type as real. name: A name for the operation (optional).

Returns: A Tensor of type complex64 or complex128.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.compute_accidental_hits, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.compute_accidental_hits

def compute_accidental_hits(true_classes, sampled_candidates, num_true, seed=None, name=None):

Compute the position ids in sampled_candidates matching true_classes.

In Candidate Sampling, this operation facilitates virtually removing sampled classes which happen to match target classes. This is done in Sampled Softmax and Sampled Logistic.

See our Candidate Sampling Algorithms Reference.

We presuppose that the sampled_candidates are unique.

We call it an 'accidental hit' when one of the target classes matches one of the sampled classes. This operation reports accidental hits as triples (index, id, weight), where index represents the row number in true_classes, id represents the position in sampled_candidates, and weight is -FLOAT_MAX.

The result of this op should be passed through a sparse_to_dense operation, then added to the logits of the sampled classes. This removes the contradictory effect of accidentally sampling the true target classes as noise classes for the same example.

Args: true_classes: A Tensor of type int64 and shape [batch_size, num_true]. The target classes. sampled_candidates: A tensor of type int64 and shape [num_sampled]. The sampled_candidates output of CandidateSampler. num_true: An int. The number of target classes per training example. seed: An int. An operation-specific seed. Default is 0. name: A name for the operation (optional).

Returns: indices: A Tensor of type int32 and shape [num_accidental_hits]. Values indicate rows in true_classes. ids: A Tensor of type int64 and shape [num_accidental_hits]. Values indicate positions in sampled_candidates. weights: A Tensor of type float and shape [num_accidental_hits]. Each value is -FLOAT_MAX.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.concat, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.concat

def concat(concat_dim, values, name="concat"):

Concatenates tensors along one dimension.

Concatenates the list of tensors values along dimension concat_dim. If values[i].shape = [D0, D1, ... Dconcat_dim(i), ...Dn], the concatenated result has shape

[D0, D1, ... Rconcat_dim, ...Dn]

where

Rconcat_dim = sum(Dconcat_dim(i))

That is, the data from the input tensors is joined along the concat_dim dimension.

The number of dimensions of the input tensors must match, and all dimensions except concat_dim must be equal.

For example:

```python t1 = [[1, 2, 3], [4, 5, 6]] t2 = [[7, 8, 9], [10, 11, 12]] tf.concat(0, [t1, t2]) ==> [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]] tf.concat(1, [t1, t2]) ==> [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]

tensor t3 with shape [2, 3]

tensor t4 with shape [2, 3]

tf.shape(tf.concat(0, [t3, t4])) ==> [4, 3] tf.shape(tf.concat(1, [t3, t4])) ==> [2, 6] ```

Note: If you are concatenating along a new axis consider using pack. E.g.

python tf.concat(axis, [tf.expand_dims(t, axis) for t in tensors])

can be rewritten as

python tf.pack(tensors, axis=axis)

Args: concat_dim: 0-D int32 Tensor. Dimension along which to concatenate. values: A list of Tensor objects or a single Tensor. name: A name for the operation (optional).

Returns: A Tensor resulting from concatenation of the input tensors.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.cond, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.cond

def cond(pred, fn1, fn2, name=None):

Return either fn1() or fn2() based on the boolean predicate pred.

fn1 and fn2 both return lists of output tensors. fn1 and fn2 must have the same non-zero number and type of outputs.

Note that the conditional execution applies only to the operations defined in fn1 and fn2. Consider the following simple program:

python z = tf.mul(a, b) result = tf.cond(x < y, lambda: tf.add(x, z), lambda: tf.square(y))

If x < y, the tf.add operation will be executed and tf.square operation will not be executed. Since z is needed for at least one branch of the cond, the tf.mul operation is always executed, unconditionally. Although this behavior is consistent with the dataflow model of TensorFlow, it has occasionally surprised some users who expected a lazier semantics.

Args: pred: A scalar determining whether to return the result of fn1 or fn2. fn1: The callable to be performed if pred is true. fn2: The callable to be performed if pref is false. name: Optional name prefix for the returned tensors.

Returns: Tensors returned by the call to either fn1 or fn2. If the callables return a singleton list, the element is extracted from the list.

Raises: TypeError: if fn1 or fn2 is not callable. ValueError: if fn1 and fn2 do not return the same number of tensors, or return tensors of different types.

Example:

python x = tf.constant(2) y = tf.constant(5) def f1(): return tf.mul(x, 17) def f2(): return tf.add(y, 23) r = cond(tf.less(x, y), f1, f2) # r is set to f1(). # Operations in f2 (e.g., tf.add) are not executed.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.conj, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.conj

def conj(x, name=None):

Returns the complex conjugate of a complex number.

Given a tensor input of complex numbers, this operation returns a tensor of complex numbers that are the complex conjugate of each element in input. The complex numbers in input must be of the form \(a + bj\), where a is the real part and b is the imaginary part.

The complex conjugate returned by this operation is of the form \(a - bj\).

For example:

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

If x is real, it is returned unchanged.

Args: x: Tensor to conjugate. Must have numeric type. name: A name for the operation (optional).

Returns: A Tensor that is the conjugate of x (with the same type).

Raises: TypeError: If x is not a numeric tensor.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.constant_initializer, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.constant_initializer

def constant_initializer(value=0, dtype=<dtype: 'float32'>):

Returns an initializer that generates tensors with constant values.

The resulting tensor is populated with values of type dtype, as specified by arguments value following the desired shape of the new tensor (see examples below).

The argument value can be a constant value, or a list of values of type dtype. If value is a list, then the length of the list must be less than or equal to the number of elements implied by the desired shape of the tensor. In the case where the total number of elements in value is less than the number of elements required by the tensor shape, the last element in value will be used to fill the remaining entries. If the total number of elements in value is greater than the number of elements required by the tensor shape, the initializer will raise a ValueError.

Args: value: A Python scalar, list of values, or a N-dimensional numpy array. All elements of the initialized variable will be set to the corresponding value in the value argument. dtype: The data type.

Returns: An initializer that generates tensors with constant values.

Examples: The following example can be rewritten using a numpy.ndarray instead of the value list, even reshaped, as shown in the two commented lines below the value list initialization.

```python

import numpy as np import tensorflow as tf

value = [0, 1, 2, 3, 4, 5, 6, 7]

value = np.array(value)

value = value.reshape([2, 4])

init = tf.constant_initializer(value)

print('fitting shape:') tf.reset_default_graph() with tf.Session(): x = tf.get_variable('x', shape=[2, 4], initializer=init) x.initializer.run() print(x.eval())

fitting shape: [[ 0. 1. 2. 3.] [ 4. 5. 6. 7.]]

print('larger shape:') tf.reset_default_graph() with tf.Session(): x = tf.get_variable('x', shape=[3, 4], initializer=init) x.initializer.run() print(x.eval())

larger shape: [[ 0. 1. 2. 3.] [ 4. 5. 6. 7.] [ 7. 7. 7. 7.]]

print('smaller shape:') tf.reset_default_graph() with tf.Session(): x = tf.get_variable('x', shape=[2, 3], initializer=init)

ValueError: Too many elements provided. Needed at most 6, but received 8 ```

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.constant, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.constant

def constant(value, dtype=None, shape=None, name="Const"):

Creates a constant tensor.

The resulting tensor is populated with values of type dtype, as specified by arguments value and (optionally) shape (see examples below).

The argument value can be a constant value, or a list of values of type dtype. If value is a list, then the length of the list must be less than or equal to the number of elements implied by the shape argument (if specified). In the case where the list length is less than the number of elements specified by shape, the last element in the list will be used to fill the remaining entries.

The argument shape is optional. If present, it specifies the dimensions of the resulting tensor. If not present, the shape of value is used.

If the argument dtype is not specified, then the type is inferred from the type of value.

For example:

```python # Constant 1-D Tensor populated with value list. tensor = tf.constant([1, 2, 3, 4, 5, 6, 7]) => [1 2 3 4 5 6 7]

# Constant 2-D tensor populated with scalar value -1. tensor = tf.constant(-1.0, shape=[2, 3]) => [[-1. -1. -1.] [-1. -1. -1.]] ```

Args: value: A constant value (or list) of output type dtype.

dtype: The type of the elements of the resulting tensor.

shape: Optional dimensions of resulting tensor.

name: Optional name for the tensor.

Returns: A Constant Tensor.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.container, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.container

def container(container_name):

Wrapper for Graph.container() using the default graph.

Args: container_name: The container string to use in the context.

Returns: A context manager that specifies the default container to use for newly created stateful ops.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.control_dependencies, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.control_dependencies

def control_dependencies(control_inputs):

Wrapper for Graph.control_dependencies() using the default graph.

See Graph.control_dependencies() for more details.

Args: control_inputs: A list of Operation or Tensor objects which must be executed or computed before running the operations defined in the context. Can also be None to clear the control dependencies.

Returns: A context manager that specifies control dependencies for all operations constructed within the context.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.conv1d, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.conv1d

def conv1d(value, filters, stride, padding, use_cudnn_on_gpu=None, data_format=None, name=None):

Computes a 1-D convolution given 3-D input and filter tensors.

Given an input tensor of shape [batch, in_width, in_channels] and a filter / kernel tensor of shape [filter_width, in_channels, out_channels], this op reshapes the arguments to pass them to conv2d to perform the equivalent convolution operation.

Internally, this op reshapes the input tensors and invokes tf.nn.conv2d. A tensor of shape [batch, in_width, in_channels] is reshaped to [batch, 1, in_width, in_channels], and the filter is reshaped to [1, filter_width, in_channels, out_channels]. The result is then reshaped back to [batch, out_width, out_channels] (where out_width is a function of the stride and padding as in conv2d) and returned to the caller.

Args: value: A 3D Tensor. Must be of type float32 or float64. filters: A 3D Tensor. Must have the same type as input. stride: An integer. The number of entries by which the filter is moved right at each step. padding: 'SAME' or 'VALID' use_cudnn_on_gpu: An optional bool. Defaults to True. data_format: An optional string from "NHWC", "NCHW". Defaults to "NHWC", the data is stored in the order of [batch, in_width, in_channels]. The "NCHW" format stores data as [batch, in_channels, in_width]. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as input.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.conv2d_backprop_filter, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.conv2d_backprop_filter

def conv2d_backprop_filter(input, filter_sizes, out_backprop, strides, padding, use_cudnn_on_gpu=None, data_format=None, name=None):

Computes the gradients of convolution with respect to the filter.

Args: input: A Tensor. Must be one of the following types: half, float32, float64. 4-D with shape [batch, in_height, in_width, in_channels]. filter_sizes: A Tensor of type int32. An integer vector representing the tensor shape of filter, where filter is a 4-D [filter_height, filter_width, in_channels, out_channels] tensor. out_backprop: A Tensor. Must have the same type as input. 4-D with shape [batch, out_height, out_width, out_channels]. Gradients w.r.t. the output of the convolution. strides: A list of ints. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format. padding: A string from: "SAME", "VALID". The type of padding algorithm to use. use_cudnn_on_gpu: An optional bool. Defaults to True. data_format: An optional string from: "NHWC", "NCHW". Defaults to "NHWC". 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]. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as input. 4-D with shape [filter_height, filter_width, in_channels, out_channels]. Gradient w.r.t. the filter input of the convolution.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.conv2d_backprop_input, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.conv2d_backprop_input

def conv2d_backprop_input(input_sizes, filter, out_backprop, strides, padding, use_cudnn_on_gpu=None, data_format=None, name=None):

Computes the gradients of convolution with respect to the input.

Args: input_sizes: A Tensor of type int32. An integer vector representing the shape of input, where input is a 4-D [batch, height, width, channels] tensor. filter: A Tensor. Must be one of the following types: half, float32, float64. 4-D with shape [filter_height, filter_width, in_channels, out_channels]. out_backprop: A Tensor. Must have the same type as filter. 4-D with shape [batch, out_height, out_width, out_channels]. Gradients w.r.t. the output of the convolution. strides: A list of ints. The stride of the sliding window for each dimension of the input of the convolution. Must be in the same order as the dimension specified with format. padding: A string from: "SAME", "VALID". The type of padding algorithm to use. use_cudnn_on_gpu: An optional bool. Defaults to True. data_format: An optional string from: "NHWC", "NCHW". Defaults to "NHWC". 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]. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as filter. 4-D with shape [batch, in_height, in_width, in_channels]. Gradient w.r.t. the input of the convolution.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.conv2d, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.conv2d

def conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, data_format=None, name=None):

Computes a 2-D convolution given 4-D input and filter tensors.

Given an input tensor of shape [batch, in_height, in_width, in_channels] and a filter / kernel tensor of shape [filter_height, filter_width, in_channels, out_channels], this op performs the following:

1. Flattens the filter to a 2-D matrix with shape [filter_height * filter_width * in_channels, output_channels].
2. Extracts image patches from the input tensor to form a virtual tensor of shape [batch, out_height, out_width, filter_height * filter_width * in_channels].
3. For each patch, right-multiplies the filter matrix and the image patch vector.

In detail, with the default NHWC format,

output[b, i, j, k] =
    sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] *
                    filter[di, dj, q, k]

Must have strides[0] = strides[3] = 1. For the most common case of the same horizontal and vertices strides, strides = [1, stride, stride, 1].

Args: input: A Tensor. Must be one of the following types: half, float32, float64. filter: A Tensor. Must have the same type as input. strides: A list of ints. 1-D of length 4. The stride of the sliding window for each dimension of input. Must be in the same order as the dimension specified with format. padding: A string from: "SAME", "VALID". The type of padding algorithm to use. use_cudnn_on_gpu: An optional bool. Defaults to True. data_format: An optional string from: "NHWC", "NCHW". Defaults to "NHWC". 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]. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as input.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.conv2d_transpose, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.conv2d_transpose

def conv2d_transpose(value, filter, output_shape, strides, padding="SAME", name=None):

The transpose of conv2d.

This operation is sometimes called "deconvolution" after Deconvolutional Networks, but is actually the transpose (gradient) of conv2d rather than an actual deconvolution.

Args: value: A 4-D Tensor of type float and shape [batch, height, width, in_channels]. filter: A 4-D Tensor with the same type as value and shape [height, width, output_channels, in_channels]. filter's in_channels dimension must match that of value. output_shape: A 1-D Tensor representing the output shape of the deconvolution op. strides: A list of ints. The stride of the sliding window for each dimension of the input tensor. padding: A string, either 'VALID' or 'SAME'. The padding algorithm. See the comment here name: Optional name for the returned tensor.

Returns: A Tensor with the same type as value.

Raises: ValueError: If input/output depth does not match filter's shape, or if padding is other than 'VALID' or 'SAME'.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.conv3d_backprop_filter, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.conv3d_backprop_filter

def conv3d_backprop_filter(input, filter, out_backprop, strides, padding, name=None):

Computes the gradients of 3-D convolution with respect to the filter.

Args: input: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. Shape [batch, depth, rows, cols, in_channels]. filter: A Tensor. Must have the same type as input. Shape [depth, rows, cols, in_channels, out_channels]. in_channels must match between input and filter. out_backprop: A Tensor. Must have the same type as input. Backprop signal of shape [batch, out_depth, out_rows, out_cols, out_channels]. strides: A list of ints that has length >= 5. 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: A string from: "SAME", "VALID". The type of padding algorithm to use. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as input.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.conv3d_backprop_filter_v2, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.conv3d_backprop_filter_v2

def conv3d_backprop_filter_v2(input, filter_sizes, out_backprop, strides, padding, name=None):

Computes the gradients of 3-D convolution with respect to the filter.

Args: input: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. Shape [batch, depth, rows, cols, in_channels]. filter_sizes: A Tensor of type int32. An integer vector representing the tensor shape of filter, where filter is a 5-D [filter_depth, filter_height, filter_width, in_channels, out_channels] tensor. out_backprop: A Tensor. Must have the same type as input. Backprop signal of shape [batch, out_depth, out_rows, out_cols, out_channels]. strides: A list of ints that has length >= 5. 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: A string from: "SAME", "VALID". The type of padding algorithm to use. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as input.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.conv3d_backprop_input, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.conv3d_backprop_input

def conv3d_backprop_input(input, filter, out_backprop, strides, padding, name=None):

Computes the gradients of 3-D convolution with respect to the input.

Args: input: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. Shape [batch, depth, rows, cols, in_channels]. filter: A Tensor. Must have the same type as input. Shape [depth, rows, cols, in_channels, out_channels]. in_channels must match between input and filter. out_backprop: A Tensor. Must have the same type as input. Backprop signal of shape [batch, out_depth, out_rows, out_cols, out_channels]. strides: A list of ints that has length >= 5. 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: A string from: "SAME", "VALID". The type of padding algorithm to use. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as input.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.conv3d_backprop_input_v2, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.conv3d_backprop_input_v2

def conv3d_backprop_input_v2(input_sizes, filter, out_backprop, strides, padding, name=None):

Computes the gradients of 3-D convolution with respect to the input.

Args: input_sizes: A Tensor of type int32. An integer vector representing the tensor shape of input, where input is a 5-D [batch, depth, rows, cols, in_channels] tensor. filter: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. Shape [depth, rows, cols, in_channels, out_channels]. in_channels must match between input and filter. out_backprop: A Tensor. Must have the same type as filter. Backprop signal of shape [batch, out_depth, out_rows, out_cols, out_channels]. strides: A list of ints that has length >= 5. 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: A string from: "SAME", "VALID". The type of padding algorithm to use. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as filter.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.conv3d, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.conv3d

def conv3d(input, filter, strides, padding, name=None):

Computes a 3-D convolution given 5-D input and filter tensors.

In signal processing, cross-correlation is a measure of similarity of two waveforms as a function of a time-lag applied to one of them. This is also known as a sliding dot product or sliding inner-product.

Our Conv3D implements a form of cross-correlation.

Args: input: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half. Shape [batch, in_depth, in_height, in_width, in_channels]. filter: A Tensor. Must have the same type as input. Shape [filter_depth, filter_height, filter_width, in_channels, out_channels]. in_channels must match between input and filter. strides: A list of ints that has length >= 5. 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: A string from: "SAME", "VALID". The type of padding algorithm to use. name: A name for the operation (optional).

Returns: A Tensor. Has the same type as input.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.nn.conv3d_transpose, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.nn.conv3d_transpose

def conv3d_transpose(value, filter, output_shape, strides, padding="SAME", name=None):

The transpose of conv3d.

This operation is sometimes called "deconvolution" after Deconvolutional Networks, but is actually the transpose (gradient) of conv3d rather than an actual deconvolution.

Args: value: A 5-D Tensor of type float and shape [batch, depth, height, width, in_channels]. filter: A 5-D Tensor with the same type as value and shape [depth, height, width, output_channels, in_channels]. filter's in_channels dimension must match that of value. output_shape: A 1-D Tensor representing the output shape of the deconvolution op. strides: A list of ints. The stride of the sliding window for each dimension of the input tensor. padding: A string, either 'VALID' or 'SAME'. The padding algorithm. See the comment here name: Optional name for the returned tensor.

Returns: A Tensor with the same type as value.

Raises: ValueError: If input/output depth does not match filter's shape, or if padding is other than 'VALID' or 'SAME'.

THIS METHOD IS AUTOMATICALLY GENERATED

Alias for .fully_connected(size, activation_fn = tf.convert_to_tensor, ...)

Arguments

• size: the size of the resulting layer
• All other *args and **kwargs are forwarded to tf.contrib.layers.fully_connected

Return

Builder

Origial documentation for tf.convert_to_tensor

def convert_to_tensor(value, dtype=None, name=None, as_ref=False, preferred_dtype=None):

Converts the given value to a Tensor.

This function converts Python objects of various types to Tensor objects. It accepts Tensor objects, numpy arrays, Python lists, and Python scalars. For example:

```python import numpy as np

def my_func(arg): arg = tf.convert_to_tensor(arg, dtype=tf.float32) return tf.matmul(arg, arg) + arg

The following calls are equivalent.

value_1 = my_func(tf.constant([[1.0, 2.0], [3.0, 4.0]])) value_2 = my_func([[1.0, 2.0], [3.0, 4.0]]) value_3 = my_func(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)) ```

This function can be useful when composing a new operation in Python (such as my_func in the example above). All standard Python op constructors apply this function to each of their Tensor-valued inputs, which allows those ops to accept numpy arrays, Python lists, and scalars in addition to Tensor objects.

Args: value: An object whose type has a registered Tensor conversion function. dtype: Optional element type for the returned tensor. If missing, the type is inferred from the type of value. name: Optional name to use if a new Tensor is created. as_ref: True if we want the result as a ref tensor. Only used if a new Tensor is created. preferred_dtype: Optional element type for the returned tensor, used when dtype is None. In some cases, a caller may not have a dtype in mind when converting to a tensor, so preferred_dtype can be used as a soft preference. If the conversion to preferred_dtype is not possible, this argument has no effect.

Returns: A Tensor based on value.

Raises: TypeError: If no conversion function is registered for value. RuntimeError: If a registered conversion function returns an invalid value.