THIS METHOD IS AUTOMATICALLY GENERATED

builder.Assert(*args, **kwargs)

It accepts the same arguments as tensorflow.Assert. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.Assert(x1, *args, **kwargs)

is equivalent to

builder.Assert(*args, **kwargs)(x1)

tensorflow.Assert

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.

Builder Core. Also available as a global function as phi.Context.

Returns the context object of the current dsl.With statemente.

Arguments

• *args: By design Context accepts any number of arguments and completely ignores them.

This is a classmethod and it doesnt return a Builder/Lambda by design so it can be called directly:

from phi import P, Context, Obj

def read_file(z):
    f = Context()
    return f.read()

lines = P.Pipe(
    "text.txt",
    P.With( open,
        read_file,
        Obj.split("\n")
    )
)

Here we called Context with no arguments to get the context back, however, since you can also give this function an argument (which it will ignore) it can be passed to the DSL so we can rewrite the previous as:

from phi import P, Context, Obj

lines = P.Pipe(
    "text.txt",
    P.With( open,
        Context, # f
        Obj.read()
        Obj.split("\n")
    )
)

Context yields an exception when used outside of a With block.

Also see

• phi.builder.Builder.Obj
• dsl

This method enables you to register any function fn that takes an Applicative as its first argument as a method of the Builder class.

Arguments

• fn: a function that atleast takes an Applicative as its first argument.
• library_path: the route of the librar from which this function was taken, used for documentation purposes.
• alias: allows you to specify the name of the method, it will take the name of the function if its None.
• doc: the documentation for the method, if None a predefied documentation will be generated based on the documentation of fn.

Return

None

Examples

The Make method takes an expression from the DSL and compiles it to a function.

Arguments

• *code: any expression from the DSL.code is implicitly a tuple since that is what Python gives you when you declare a Variadic Function, therefore, according to the rules of the DSL, all expressions inside of code will be composed together. See Composition.
• flatten = False: if flatten is True and the argument being returned by the compiled function is a list it will instead return a flattened list.
• _return_type = None: By default Make returns an object of the same class e.g. Builder, however you can pass in a custom class that inherits from Builder as the returned contianer. This is useful if the custom builder has specialized methods.
• create_ref_context = True: determines if a reference manager should be created on compilation. See Compile.
• refs = True: external/default values for references passed during compilation. See Compile.

Examples

from phi import P

def add1(x): return x + 1
def mul3(x): return x * 3

f = P.Make(
    add1,
    mul3
)

assert f(1) == 6

Here f is equivalent to

def f(x): x = add1(x) x = mul3(x) return x

The previous example using lambdas to create the functions

from phi import P

f = P.Make(
    P + 1,
    P * 3
)

assert f(1) == 6

Also see

• dsl
• Compile
• lambdas **

NMake is shortcut for Make(..., create_ref_context=False), its full name should be NoCreateRefContextMake but its impractically long. Normally methods that compile DSL expressions like phi.builder.Builder.Make or phi.builder.Builder.Pipe create a reference context unless especified, these contexts encapsulate references (see read or write) and prevent them from leaking, which is good. There are times however when you consciously want a sub-Make or sub-Pipe expression to read or write references from the main Make or Pipe expression, for this you need to set create_ref_context to False.

Arguments

• Same arguments as phi.builder.Builder.Make but...
• create_ref_context is hardcoded to False

Examples

If you compile a sub expression as a function for another expression e.g.

from phi import P

assert 1 == P.Pipe(
    1, {'s'}, # write s == 1, outer context
    P.Make(
        P + 1, {'s'} # write s == 2, inner context
    ),
    's'  # read s == 1, outer context
)

you find that references are not shared. However if you avoid the creation of a new reference context via a keyword arguments

from phi import P

assert 2 == P.Pipe(
    1, {'s'},   #write s == 1, same context
    P.Make(
        P + 1, {'s'},   #write s == 2, same context
        create_ref_context=False
    ),
    's'   # read s == 2, same context
)

you can achieve what you want. Yet writting create_ref_context=False is a little cumbersome, so to make things nicer we just use a shortcut by appending an N at the beggining of the NMake method

from phi import P

assert 2 == P.Pipe(
    1, {'s'},   #write s == 1, same context
    P.NMake(
        P + 1, {'s'}   #write s == 2, same context
    ),
    's'   # read s == 2, same context
)

Also see

• phi.builder.Builder.Make
• phi.builder.Builder.NPipe
• phi.builder.Builder.NRun
• dsl
• Compile

NPipe is shortcut for Pipe(..., create_ref_context=False), its full name should be NoCreateRefContextPipe but its impractically long. Normally methods that compile DSL expressions like phi.builder.Builder.Make or phi.builder.Builder.Pipe create a reference context unless especified, these contexts encapsulate references (see read or write) and prevent them from leaking, which is good. There are times however when you consciously want a sub-Make or sub-Pipe expression to read or write references from the main Make or Pipe expression, for this you need to set create_ref_context to False.

Arguments

• Same arguments as phi.builder.Builder.Pipe but...
• create_ref_context is hardcoded to False

Examples

If you compile a sub expression as a function for another expression e.g.

from phi import P

assert 1 == P.Pipe(
    1, {'s'}, # write s == 1, outer context
    lambda x: P.Pipe(
        x,
        P + 1, {'s'} # write s == 2, inner context
    ),
    's'  # read s == 1, outer context
)

you find that references are not shared. However if you avoid the creation of a new reference context via a keyword arguments

from phi import P

assert 2 == P.Pipe(
    1, {'s'},   #write s == 1, same context
    lambda x: P.Pipe(
        x,
        P + 1, {'s'},   #write s == 2, same context
        create_ref_context=False
    ),
    's'   # read s == 2, same context
)

you can achieve what you want. Yet writting create_ref_context=False is a little cumbersome, so to make things nicer we just use a shortcut by appending an N at the beggining of the NPipe method

from phi import P

assert 2 == P.Pipe(
    1, {'s'},   #write s == 1, same context
    lambda x: P.NPipe(
        x,
        P + 1, {'s'}   #write s == 2, same context
    ),
    's'   # read s == 2, same context
)

Also see

• phi.builder.Builder.Pipe
• phi.builder.Builder.NMake
• phi.builder.Builder.NRun
• dsl
• Compile

NRun is shortcut for Run(..., create_ref_context=False), its full name should be NoCreateRefContextRun but its impractically long.

Also see

• phi.builder.Builder.Run
• phi.builder.Builder.NMake
• phi.builder.Builder.NPipe
• dsl
• Compile

THIS METHOD IS AUTOMATICALLY GENERATED

builder.NotDifferentiable(*args, **kwargs)

It accepts the same arguments as tensorflow.NotDifferentiable. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.NotDifferentiable(x1, *args, **kwargs)

is equivalent to

builder.NotDifferentiable(*args, **kwargs)(x1)

tensorflow.NotDifferentiable

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.

Pipe is method that takes an input argument plus an expression from the DSL, it compiles the expression and applies the resulting function to the input. Its highly inspired by Elixir's |> (pipe) operator.

Arguments

• x: any input object
• *code: any expression from the DSL.code is implicitly a tuple since that is what Python gives you when you declare a Variadic Function, therefore, according to the rules of the DSL, all expressions inside of code will be composed together. See Composition.
• **kwargs: Pipe forwards all kwargs to phi.builder.Builder.Make, visit its documentation for more info.

Examples

from phi import P

def add1(x): return x + 1
def mul3(x): return x * 3

x = P.Pipe(
    1,     #input
    add1,  #1 + 1 == 2
    mul3   #2 * 3 == 6
)

assert x == 6

The previous using lambdas to create the functions

from phi import P

x = P.Pipe(
    1,      #input
    P + 1,  #1 + 1 == 2
    P * 3   #2 * 3 == 6
)

assert x == 6

Also see

• phi.builder.Builder.Make
• phi.builder.Builder.Run
• dsl
• Compile
• lambdas

THIS METHOD IS AUTOMATICALLY GENERATED

builder.Print(*args, **kwargs)

It accepts the same arguments as tensorflow.Print. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.Print(x1, *args, **kwargs)

is equivalent to

builder.Print(*args, **kwargs)(x1)

tensorflow.Print

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 enables you to register any function fn that takes an object as its first argument as a method of the Builder and Applicative class.

Arguments

• fn: a function that atleast takes an Object as its first argument.
• library_path: the route of the librar from which this function was taken, used for documentation purposes.
• alias: allows you to specify the name of the method, it will take the name of the function if its None.
• doc: the documentation for the method, if None a predefied documentation will be generated based on the documentation of fn.

Return

None

Examples

Run(*code, **kwargs) is equivalent to Pipe(None, *code, **kwargs), that is, it compiles the code and applies in a None value.

Arguments

• Same as phi.builder.Builder.Make.

Examples

You might create code that totally ignores its input argument e.g.

from phi import P

result = P.Pipe(
    None,
    dict(
        x = (
            Val(10),
            P + 1
        ),
        y = (
            Val(5),
            P * 5
        )
    )
)

assert result.x == 9
assert result.y == 25

Here the Val statemente drops the None and introduces its own constants. Given this its more suitable to use Run

from phi import P

result = P.Run(
    dict(
        x = (
            Val(10),
            P + 1
        ),
        y = (
            Val(5),
            P * 5
        )
    )
)

assert result.x == 9
assert result.y == 25

Also see

• phi.builder.Builder.Make
• phi.builder.Builder.Pipe
• dsl
• Compile

With

def With(context_manager, *body):

Arguments

• context_manager: a context manager object or valid expression from the DSL that returns a context manager.
• *body: any valid expression of the DSL to be evaluated inside the context. *body is interpreted as a tuple so all expression contained are composed.

As with normal python programs you sometimes might want to create a context for a block of code. You normally give a context manager to the with statemente, in Phi you use P.With or phi.With

Context

Python's with statemente returns a context object through as keyword, in the DSL this object can be obtained using the P.Context method or the phi.Context function.

Examples

from phi import P, Obj, Context, With, Pipe

text = Pipe(
    "text.txt",
    With( open, Context,
        Obj.read()
    )
)

The previous is equivalent to

with open("text.txt") as f:
    text = f.read()

THIS METHOD IS AUTOMATICALLY GENERATED

builder.abs(*args, **kwargs)

It accepts the same arguments as tensorflow.abs. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.abs(x1, *args, **kwargs)

is equivalent to

builder.abs(*args, **kwargs)(x1)

tensorflow.abs

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

builder.accumulate_n(*args, **kwargs)

It accepts the same arguments as tensorflow.accumulate_n. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.accumulate_n(x1, *args, **kwargs)

is equivalent to

builder.accumulate_n(*args, **kwargs)(x1)

tensorflow.accumulate_n

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

builder.acos(*args, **kwargs)

It accepts the same arguments as tensorflow.acos. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.acos(x1, *args, **kwargs)

is equivalent to

builder.acos(*args, **kwargs)(x1)

tensorflow.acos

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

builder.add(*args, **kwargs)

It accepts the same arguments as tensorflow.add. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.add(x1, *args, **kwargs)

is equivalent to

builder.add(*args, **kwargs)(x1)

tensorflow.add

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

builder.add_check_numerics_ops(*args, **kwargs)

It accepts the same arguments as tensorflow.add_check_numerics_ops. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.add_check_numerics_ops(x1, *args, **kwargs)

is equivalent to

builder.add_check_numerics_ops(*args, **kwargs)(x1)

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

builder.add_n(*args, **kwargs)

It accepts the same arguments as tensorflow.add_n. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.add_n(x1, *args, **kwargs)

is equivalent to

builder.add_n(*args, **kwargs)(x1)

tensorflow.add_n

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

builder.add_regularization_loss(*args, **kwargs)

It accepts the same arguments as tb.add_regularization_loss. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tb.add_regularization_loss(x1, *args, **kwargs)

is equivalent to

builder.add_regularization_loss(*args, **kwargs)(x1)

tb.add_regularization_loss

None

THIS METHOD IS AUTOMATICALLY GENERATED

builder.add_to_collection(*args, **kwargs)

It accepts the same arguments as tensorflow.add_to_collection. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.add_to_collection(x1, *args, **kwargs)

is equivalent to

builder.add_to_collection(*args, **kwargs)(x1)

tensorflow.add_to_collection

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

builder.all_candidate_sampler(*args, **kwargs)

It accepts the same arguments as tf.nn.all_candidate_sampler. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tf.nn.all_candidate_sampler(x1, *args, **kwargs)

is equivalent to

builder.all_candidate_sampler(*args, **kwargs)(x1)

tf.nn.all_candidate_sampler

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

builder.all_candidate_sampler_conv2d_layer(*args, **kwargs)

It accepts the same arguments as tf.contrib.layers.convolution2d. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tf.contrib.layers.convolution2d(x1, *args, **kwargs)

is equivalent to

builder.all_candidate_sampler_conv2d_layer(*args, **kwargs)(x1)

    and the keyword argument `activation_fn` is set to `tf.nn.all_candidate_sampler`.

tf.contrib.layers.convolution2d

Adds a 2D convolution followed by an optional batch_norm layer.

convolution2d creates a variable called weights, representing the convolutional kernel, that is convolved with the inputs to produce a Tensor of activations. If a normalizer_fn is provided (such as batch_norm), it is then applied. Otherwise, if normalizer_fn is None and a biases_initializer is provided then a biases variable would be created and added the activations. Finally, if activation_fn is not None, it is applied to the activations as well.

Performs a'trous convolution with input stride equal to rate if rate is greater than one.

Args: inputs: a 4-D tensor [batch_size, height, width, channels]. num_outputs: integer, the number of output filters. kernel_size: a list of length 2 [kernel_height, kernel_width] of of the filters. Can be an int if both values are the same. stride: a list of length 2 [stride_height, stride_width]. Can be an int if both strides are the same. Note that presently both strides must have the same value. padding: one of VALID or SAME. rate: integer. If less than or equal to 1, a standard convolution is used. If greater than 1, than the a'trous convolution is applied and stride must be set to 1. activation_fn: activation function, set to None to skip it and maintain a linear activation. normalizer_fn: normalization function to use instead of biases. If normalizer_fn is provided then biases_initializer and biases_regularizer are ignored and biases are not created nor added. default set to None for no normalizer function normalizer_params: normalization function parameters. weights_initializer: An initializer for the weights. weights_regularizer: Optional regularizer for the weights. biases_initializer: An initializer for the biases. If None skip biases. biases_regularizer: Optional regularizer for the biases. reuse: whether or not the layer and its variables should be reused. To be able to reuse the layer scope must be given. variables_collections: optional list of collections for all the variables or a dictionay containing a different list of collection per variable. outputs_collections: collection to add the outputs. trainable: If True also add variables to the graph collection GraphKeys.TRAINABLE_VARIABLES (see tf.Variable). scope: Optional scope for variable_scope.

Returns: a tensor representing the output of the operation.

Raises: ValueError: if both 'rate' and stride are larger than one.

THIS METHOD IS AUTOMATICALLY GENERATED

builder.all_candidate_sampler_layer(*args, **kwargs)

It accepts the same arguments as tf.contrib.layers.fully_connected. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tf.contrib.layers.fully_connected(x1, *args, **kwargs)

is equivalent to

builder.all_candidate_sampler_layer(*args, **kwargs)(x1)

    and the keyword argument `activation_fn` is set to `tf.nn.all_candidate_sampler`.

tf.contrib.layers.fully_connected

Adds a fully connected layer.

fully_connected creates a variable called weights, representing a fully connected weight matrix, which is multiplied by the inputs to produce a Tensor of hidden units. If a normalizer_fn is provided (such as batch_norm), it is then applied. Otherwise, if normalizer_fn is None and a biases_initializer is provided then a biases variable would be created and added the hidden units. Finally, if activation_fn is not None, it is applied to the hidden units as well.

Note: that if inputs have a rank greater than 2, then inputs is flattened prior to the initial matrix multiply by weights.

Args: inputs: A tensor of with at least rank 2 and value for the last dimension, i.e. [batch_size, depth], [None, None, None, channels]. num_outputs: Integer or long, the number of output units in the layer. activation_fn: activation function, set to None to skip it and maintain a linear activation. normalizer_fn: normalization function to use instead of biases. If normalizer_fn is provided then biases_initializer and biases_regularizer are ignored and biases are not created nor added. default set to None for no normalizer function normalizer_params: normalization function parameters. weights_initializer: An initializer for the weights. weights_regularizer: Optional regularizer for the weights. biases_initializer: An initializer for the biases. If None skip biases. biases_regularizer: Optional regularizer for the biases. reuse: whether or not the layer and its variables should be reused. To be able to reuse the layer scope must be given. variables_collections: Optional list of collections for all the variables or a dictionary containing a different list of collections per variable. outputs_collections: collection to add the outputs. trainable: If True also add variables to the graph collection GraphKeys.TRAINABLE_VARIABLES (see tf.Variable). scope: Optional scope for variable_scope.

Returns: the tensor variable representing the result of the series of operations.

Raises: ValueError: if x has rank less than 2 or if its last dimension is not set.

THIS METHOD IS AUTOMATICALLY GENERATED

builder.all_variables(*args, **kwargs)

It accepts the same arguments as tensorflow.all_variables. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.all_variables(x1, *args, **kwargs)

is equivalent to

builder.all_variables(*args, **kwargs)(x1)

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

builder.arg_max(*args, **kwargs)

It accepts the same arguments as tensorflow.arg_max. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.arg_max(x1, *args, **kwargs)

is equivalent to

builder.arg_max(*args, **kwargs)(x1)

tensorflow.arg_max

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

builder.arg_min(*args, **kwargs)

It accepts the same arguments as tensorflow.arg_min. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.arg_min(x1, *args, **kwargs)

is equivalent to

builder.arg_min(*args, **kwargs)(x1)

tensorflow.arg_min

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

builder.as_dtype(*args, **kwargs)

It accepts the same arguments as tensorflow.as_dtype. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.as_dtype(x1, *args, **kwargs)

is equivalent to

builder.as_dtype(*args, **kwargs)(x1)

tensorflow.as_dtype

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

builder.as_string(*args, **kwargs)

It accepts the same arguments as tensorflow.as_string. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.as_string(x1, *args, **kwargs)

is equivalent to

builder.as_string(*args, **kwargs)(x1)

tensorflow.as_string

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

builder.asin(*args, **kwargs)

It accepts the same arguments as tensorflow.asin. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.asin(x1, *args, **kwargs)

is equivalent to

builder.asin(*args, **kwargs)(x1)

tensorflow.asin

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

builder.assert_equal(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_equal. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_equal(x1, *args, **kwargs)

is equivalent to

builder.assert_equal(*args, **kwargs)(x1)

tensorflow.assert_equal

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

builder.assert_greater(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_greater. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_greater(x1, *args, **kwargs)

is equivalent to

builder.assert_greater(*args, **kwargs)(x1)

tensorflow.assert_greater

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

builder.assert_greater_equal(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_greater_equal. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_greater_equal(x1, *args, **kwargs)

is equivalent to

builder.assert_greater_equal(*args, **kwargs)(x1)

tensorflow.assert_greater_equal

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

builder.assert_integer(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_integer. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_integer(x1, *args, **kwargs)

is equivalent to

builder.assert_integer(*args, **kwargs)(x1)

tensorflow.assert_integer

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

builder.assert_less(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_less. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_less(x1, *args, **kwargs)

is equivalent to

builder.assert_less(*args, **kwargs)(x1)

tensorflow.assert_less

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

builder.assert_less_equal(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_less_equal. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_less_equal(x1, *args, **kwargs)

is equivalent to

builder.assert_less_equal(*args, **kwargs)(x1)

tensorflow.assert_less_equal

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

builder.assert_negative(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_negative. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_negative(x1, *args, **kwargs)

is equivalent to

builder.assert_negative(*args, **kwargs)(x1)

tensorflow.assert_negative

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

builder.assert_non_negative(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_non_negative. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_non_negative(x1, *args, **kwargs)

is equivalent to

builder.assert_non_negative(*args, **kwargs)(x1)

tensorflow.assert_non_negative

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

builder.assert_non_positive(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_non_positive. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_non_positive(x1, *args, **kwargs)

is equivalent to

builder.assert_non_positive(*args, **kwargs)(x1)

tensorflow.assert_non_positive

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

builder.assert_positive(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_positive. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_positive(x1, *args, **kwargs)

is equivalent to

builder.assert_positive(*args, **kwargs)(x1)

tensorflow.assert_positive

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

builder.assert_proper_iterable(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_proper_iterable. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_proper_iterable(x1, *args, **kwargs)

is equivalent to

builder.assert_proper_iterable(*args, **kwargs)(x1)

tensorflow.assert_proper_iterable

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

builder.assert_rank(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_rank. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_rank(x1, *args, **kwargs)

is equivalent to

builder.assert_rank(*args, **kwargs)(x1)

tensorflow.assert_rank

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

builder.assert_rank_at_least(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_rank_at_least. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_rank_at_least(x1, *args, **kwargs)

is equivalent to

builder.assert_rank_at_least(*args, **kwargs)(x1)

tensorflow.assert_rank_at_least

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

builder.assert_type(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_type. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_type(x1, *args, **kwargs)

is equivalent to

builder.assert_type(*args, **kwargs)(x1)

tensorflow.assert_type

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

builder.assert_variables_initialized(*args, **kwargs)

It accepts the same arguments as tensorflow.assert_variables_initialized. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assert_variables_initialized(x1, *args, **kwargs)

is equivalent to

builder.assert_variables_initialized(*args, **kwargs)(x1)

tensorflow.assert_variables_initialized

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

builder.assign(*args, **kwargs)

It accepts the same arguments as tensorflow.assign. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assign(x1, *args, **kwargs)

is equivalent to

builder.assign(*args, **kwargs)(x1)

tensorflow.assign

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

builder.assign_add(*args, **kwargs)

It accepts the same arguments as tensorflow.assign_add. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assign_add(x1, *args, **kwargs)

is equivalent to

builder.assign_add(*args, **kwargs)(x1)

tensorflow.assign_add

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

builder.assign_sub(*args, **kwargs)

It accepts the same arguments as tensorflow.assign_sub. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.assign_sub(x1, *args, **kwargs)

is equivalent to

builder.assign_sub(*args, **kwargs)(x1)

tensorflow.assign_sub

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

builder.atan(*args, **kwargs)

It accepts the same arguments as tensorflow.atan. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tensorflow.atan(x1, *args, **kwargs)

is equivalent to

builder.atan(*args, **kwargs)(x1)

tensorflow.atan

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

builder.atrous_conv2d(*args, **kwargs)

It accepts the same arguments as tf.nn.atrous_conv2d. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tf.nn.atrous_conv2d(x1, *args, **kwargs)

is equivalent to

builder.atrous_conv2d(*args, **kwargs)(x1)

tf.nn.atrous_conv2d

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

builder.atrous_conv2d_conv2d_layer(*args, **kwargs)

It accepts the same arguments as tf.contrib.layers.convolution2d. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tf.contrib.layers.convolution2d(x1, *args, **kwargs)

is equivalent to

builder.atrous_conv2d_conv2d_layer(*args, **kwargs)(x1)

    and the keyword argument `activation_fn` is set to `tf.nn.atrous_conv2d`.

tf.contrib.layers.convolution2d

Adds a 2D convolution followed by an optional batch_norm layer.

convolution2d creates a variable called weights, representing the convolutional kernel, that is convolved with the inputs to produce a Tensor of activations. If a normalizer_fn is provided (such as batch_norm), it is then applied. Otherwise, if normalizer_fn is None and a biases_initializer is provided then a biases variable would be created and added the activations. Finally, if activation_fn is not None, it is applied to the activations as well.

Performs a'trous convolution with input stride equal to rate if rate is greater than one.

Args: inputs: a 4-D tensor [batch_size, height, width, channels]. num_outputs: integer, the number of output filters. kernel_size: a list of length 2 [kernel_height, kernel_width] of of the filters. Can be an int if both values are the same. stride: a list of length 2 [stride_height, stride_width]. Can be an int if both strides are the same. Note that presently both strides must have the same value. padding: one of VALID or SAME. rate: integer. If less than or equal to 1, a standard convolution is used. If greater than 1, than the a'trous convolution is applied and stride must be set to 1. activation_fn: activation function, set to None to skip it and maintain a linear activation. normalizer_fn: normalization function to use instead of biases. If normalizer_fn is provided then biases_initializer and biases_regularizer are ignored and biases are not created nor added. default set to None for no normalizer function normalizer_params: normalization function parameters. weights_initializer: An initializer for the weights. weights_regularizer: Optional regularizer for the weights. biases_initializer: An initializer for the biases. If None skip biases. biases_regularizer: Optional regularizer for the biases. reuse: whether or not the layer and its variables should be reused. To be able to reuse the layer scope must be given. variables_collections: optional list of collections for all the variables or a dictionay containing a different list of collection per variable. outputs_collections: collection to add the outputs. trainable: If True also add variables to the graph collection GraphKeys.TRAINABLE_VARIABLES (see tf.Variable). scope: Optional scope for variable_scope.

Returns: a tensor representing the output of the operation.

Raises: ValueError: if both 'rate' and stride are larger than one.

THIS METHOD IS AUTOMATICALLY GENERATED

builder.atrous_conv2d_layer(*args, **kwargs)

It accepts the same arguments as tf.contrib.layers.fully_connected. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tf.contrib.layers.fully_connected(x1, *args, **kwargs)

is equivalent to

builder.atrous_conv2d_layer(*args, **kwargs)(x1)

    and the keyword argument `activation_fn` is set to `tf.nn.atrous_conv2d`.

tf.contrib.layers.fully_connected

Adds a fully connected layer.

fully_connected creates a variable called weights, representing a fully connected weight matrix, which is multiplied by the inputs to produce a Tensor of hidden units. If a normalizer_fn is provided (such as batch_norm), it is then applied. Otherwise, if normalizer_fn is None and a biases_initializer is provided then a biases variable would be created and added the hidden units. Finally, if activation_fn is not None, it is applied to the hidden units as well.

Note: that if inputs have a rank greater than 2, then inputs is flattened prior to the initial matrix multiply by weights.

Args: inputs: A tensor of with at least rank 2 and value for the last dimension, i.e. [batch_size, depth], [None, None, None, channels]. num_outputs: Integer or long, the number of output units in the layer. activation_fn: activation function, set to None to skip it and maintain a linear activation. normalizer_fn: normalization function to use instead of biases. If normalizer_fn is provided then biases_initializer and biases_regularizer are ignored and biases are not created nor added. default set to None for no normalizer function normalizer_params: normalization function parameters. weights_initializer: An initializer for the weights. weights_regularizer: Optional regularizer for the weights. biases_initializer: An initializer for the biases. If None skip biases. biases_regularizer: Optional regularizer for the biases. reuse: whether or not the layer and its variables should be reused. To be able to reuse the layer scope must be given. variables_collections: Optional list of collections for all the variables or a dictionary containing a different list of collections per variable. outputs_collections: collection to add the outputs. trainable: If True also add variables to the graph collection GraphKeys.TRAINABLE_VARIABLES (see tf.Variable). scope: Optional scope for variable_scope.

Returns: the tensor variable representing the result of the series of operations.

Raises: ValueError: if x has rank less than 2 or if its last dimension is not set.

THIS METHOD IS AUTOMATICALLY GENERATED

builder.audio_summary(*args, **kwargs)

It accepts the same arguments as tensorflow.audio_summary. However, the 2nd argument is omitted, a partial with the rest of the arguments is returned which expects the 2nd argument such that

tensorflow.audio_summary(x1, x2, *args, **kwargs)

is equivalent to

builder.audio_summary(x1, *args, **kwargs)(x2)

tensorflow.audio_summary

Outputs a `Summary` protocol buffer with audio.

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

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

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

Args: tag: A scalar Tensor of type string. Used to build the tag of the summary values. tensor: A 3-D float32 Tensor of shape [batch_size, frames, channels] or a 2-D float32 Tensor of shape [batch_size, frames]. sample_rate: The sample rate of the signal in hertz. max_outputs: Max number of batch elements to generate audio for. collections: Optional list of ops.GraphKeys. The collections to add the summary to. Defaults to [ops.GraphKeys.SUMMARIES] name: A name for the operation (optional).

Returns: A scalar Tensor of type string. The serialized Summary protocol buffer.

THIS METHOD IS AUTOMATICALLY GENERATED

builder.avg_pool(*args, **kwargs)

It accepts the same arguments as tf.nn.avg_pool. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tf.nn.avg_pool(x1, *args, **kwargs)

is equivalent to

builder.avg_pool(*args, **kwargs)(x1)

tf.nn.avg_pool

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

builder.avg_pool2d(*args, **kwargs)

It accepts the same arguments as tf.contrib.layers.avg_pool2d. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tf.contrib.layers.avg_pool2d(x1, *args, **kwargs)

is equivalent to

builder.avg_pool2d(*args, **kwargs)(x1)

tf.contrib.layers.avg_pool2d

Adds a 2D average pooling op.

It is assumed that the pooling is done per image but not in batch or channels.

Args: inputs: A Tensor of size [batch_size, height, width, channels]. kernel_size: A list of length 2: [kernel_height, kernel_width] of the pooling kernel over which the op is computed. Can be an int if both values are the same. stride: A list of length 2: [stride_height, stride_width]. Can be an int if both strides are the same. Note that presently both strides must have the same value. padding: The padding method, either 'VALID' or 'SAME'. outputs_collections: The collections to which the outputs are added. scope: Optional scope for name_scope.

Returns: A Tensor representing the results of the pooling operation.

THIS METHOD IS AUTOMATICALLY GENERATED

builder.avg_pool3d(*args, **kwargs)

It accepts the same arguments as tf.nn.avg_pool3d. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tf.nn.avg_pool3d(x1, *args, **kwargs)

is equivalent to

builder.avg_pool3d(*args, **kwargs)(x1)

tf.nn.avg_pool3d

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

builder.avg_pool3d_conv2d_layer(*args, **kwargs)

It accepts the same arguments as tf.contrib.layers.convolution2d. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tf.contrib.layers.convolution2d(x1, *args, **kwargs)

is equivalent to

builder.avg_pool3d_conv2d_layer(*args, **kwargs)(x1)

    and the keyword argument `activation_fn` is set to `tf.nn.avg_pool3d`.

tf.contrib.layers.convolution2d

Adds a 2D convolution followed by an optional batch_norm layer.

convolution2d creates a variable called weights, representing the convolutional kernel, that is convolved with the inputs to produce a Tensor of activations. If a normalizer_fn is provided (such as batch_norm), it is then applied. Otherwise, if normalizer_fn is None and a biases_initializer is provided then a biases variable would be created and added the activations. Finally, if activation_fn is not None, it is applied to the activations as well.

Performs a'trous convolution with input stride equal to rate if rate is greater than one.

Args: inputs: a 4-D tensor [batch_size, height, width, channels]. num_outputs: integer, the number of output filters. kernel_size: a list of length 2 [kernel_height, kernel_width] of of the filters. Can be an int if both values are the same. stride: a list of length 2 [stride_height, stride_width]. Can be an int if both strides are the same. Note that presently both strides must have the same value. padding: one of VALID or SAME. rate: integer. If less than or equal to 1, a standard convolution is used. If greater than 1, than the a'trous convolution is applied and stride must be set to 1. activation_fn: activation function, set to None to skip it and maintain a linear activation. normalizer_fn: normalization function to use instead of biases. If normalizer_fn is provided then biases_initializer and biases_regularizer are ignored and biases are not created nor added. default set to None for no normalizer function normalizer_params: normalization function parameters. weights_initializer: An initializer for the weights. weights_regularizer: Optional regularizer for the weights. biases_initializer: An initializer for the biases. If None skip biases. biases_regularizer: Optional regularizer for the biases. reuse: whether or not the layer and its variables should be reused. To be able to reuse the layer scope must be given. variables_collections: optional list of collections for all the variables or a dictionay containing a different list of collection per variable. outputs_collections: collection to add the outputs. trainable: If True also add variables to the graph collection GraphKeys.TRAINABLE_VARIABLES (see tf.Variable). scope: Optional scope for variable_scope.

Returns: a tensor representing the output of the operation.

Raises: ValueError: if both 'rate' and stride are larger than one.

THIS METHOD IS AUTOMATICALLY GENERATED

builder.avg_pool3d_grad(*args, **kwargs)

It accepts the same arguments as tf.nn.avg_pool3d_grad. However, the 1st argument is omitted, a partial with the rest of the arguments is returned which expects the 1st argument such that

tf.nn.avg_pool3d_grad(x1, *args, **kwargs)

is equivalent to

builder.avg_pool3d_grad(*args, **kwargs)(x1)

tf.nn.avg_pool3d_grad

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