tensorbuilder.dsl module
""" """ import inspect import utils import functools import itertools import tensorflow as tf import tensorbuilder as tb ####################### ### FUNCTOR ####################### class Applicative(object): """docstring for Applicative""" def __init__(self, f): super(Applicative, self).__init__() self.f = f """ A function of type `a -> b`. """ def copy(self): """Returns a compy of the applicative""" return Applicative(self.f) def __call__(self, x): return self.f(x) @tb.immutable def compose(app, g): return Applicative(_compose2(g, app.f)) def applicative(f): return Applicative(f) ####################### ### FUNCTIONS ####################### def _compose2(f, g): return lambda x: f(g(x)) _identity = lambda x: x def _compose_reversed(functions): functions = functions[:] functions.reverse() return functools.reduce(_compose2, functions, _identity) def _sequence_function(tuple_ast): fs = [ compile(ast) for ast in tuple_ast ] return _compose_reversed(fs) def _branch_function(list_ast): fs = [ compile(ast) for ast in list_ast ] return lambda builder: builder.branch(lambda builder: [ f(builder) for f in fs ]) def compile(ast): #if type(ast) is tuple: if type(ast) is list: return _branch_function(ast) elif hasattr(ast, '__call__'): return ast else: return _sequence_function(ast) #raise Exception("Element has to be either a tuple for sequential operations, a list for branching, or a function from a builder to a builder, got %s, %s" % (type(ast), type(ast) is tuple)) def pipe(builder, *ast): f = compile(ast) return f(builder) ####################### ### CODE GENERATION ####################### _builder_excluded = ["copy"] def _builder_methods(): for _name, f in inspect.getmembers(tb.Builder, inspect.ismethod): if _name[0] != '_' and _name not in _builder_excluded: yield ("Builder", _name, f) _tree_excluded = ["copy", "connect_layer" ] #, "tensors", "builders"] def _builder_tree_methods(): for _name, f in inspect.getmembers(tb.BuilderTree, inspect.ismethod): if _name[0] != '_' and _name not in _tree_excluded: yield ("BuilderTree", _name, f) for _module_name, _name, f in itertools.chain(_builder_methods(), _builder_tree_methods()): _f_signature = utils.get_method_sig(f) _f_docs = inspect.getdoc(f) exec(""" def {0}(*args, **kwargs): \"\"\" THIS FUNCTION IS AUTOMATICALLY GENERATED This function accepts the same arguments as `{3}.{0}` but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all \*args and \*\*kwargs to `{3}.{0}`. The returned function is an `tensorbuilder.dsl.Applicative`, so you can use all the methods defined by this class. ** utils of `{3}.{0}`** def {1} \"\"\" return Applicative(lambda builder: builder.{0}(*args, **kwargs)) @tb.immutable def __{0}(app, *args, **kwargs): \"\"\" THIS METHOD IS AUTOMATICALLY GENERATED This method accepts the same arguments as `{3}.{0}` but: 1. Forwards all of its arguments to `tensorbuilder.dsl.{0}`, this returns a function `g`. 2. Applies `tensorbuilder.dsl.Applicative.compose` over `g`, this roughly computes the composition `g` of `tensorbuilder.dsl.Applicative.f`. So the result of this method is compose `tensorbuilder.dsl.{0}` with `tensorbuilder.dsl.Applicative.f`. ** utils of `{3}.{0}`** def {1} \"\"\" g = {0}(*args, **kwargs) return app.compose(g) Applicative.{0} = __{0} """.format(_name, _f_signature, _f_docs, _module_name)) ####################### ### MONEKY PATCHING ####################### tb.Builder.pipe = pipe if __name__ == "__main__": import tensorflow as tf x = tf.placeholder(tf.float32, shape=[None, 4]) h = x.builder().pipe( connect_layer(10, fn=tf.nn.relu), [ connect_layer(10, fn=tf.nn.relu) .connect_layer(5, fn=tf.nn.relu) , connect_layer(10, fn=tf.nn.sigmoid) ], connect_layer(10, fn=tf.nn.relu), [ connect_layer(1) , connect_layer(1) ], tensors ) print(h)
Functions
def Assert(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.Assert
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.Assert
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.Assert
def Assert(builder)
def Assert_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.Assert_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.Assert_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.Assert_layer
def Assert_layer(builder, size)
def NoGradient(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.NoGradient
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.NoGradient
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.NoGradient
def NoGradient(builder)
def NoGradient_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.NoGradient_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.NoGradient_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.NoGradient_layer
def NoGradient_layer(builder, size)
def Print(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.Print
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.Print
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.Print
def Print(builder)
def Print_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.Print_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.Print_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.Print_layer
def Print_layer(builder, size)
def abs(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.abs
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.abs
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.abs
def abs(builder)
def abs_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.abs_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.abs_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.abs_layer
def abs_layer(builder, size)
def accumulate_n(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.accumulate_n
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.accumulate_n
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.accumulate_n
def accumulate_n(builder)
def accumulate_n_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.accumulate_n_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.accumulate_n_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.accumulate_n_layer
def accumulate_n_layer(builder, size)
def acos(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.acos
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.acos
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.acos
def acos(builder)
def acos_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.acos_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.acos_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.acos_layer
def acos_layer(builder, size)
def add(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.add
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.add
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.add
def add(builder)
def add_check_numerics_ops(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.add_check_numerics_ops
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.add_check_numerics_ops
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.add_check_numerics_ops
def add_check_numerics_ops(builder)
def add_check_numerics_ops_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.add_check_numerics_ops_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.add_check_numerics_ops_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.add_check_numerics_ops_layer
def add_check_numerics_ops_layer(builder, size)
def add_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.add_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.add_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.add_layer
def add_layer(builder, size)
def add_n(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.add_n
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.add_n
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.add_n
def add_n(builder)
def add_n_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.add_n_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.add_n_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.add_n_layer
def add_n_layer(builder, size)
def add_to_collection(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.add_to_collection
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.add_to_collection
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.add_to_collection
def add_to_collection(builder)
def add_to_collection_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.add_to_collection_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.add_to_collection_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.add_to_collection_layer
def add_to_collection_layer(builder, size)
def all_candidate_sampler(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.all_candidate_sampler
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.all_candidate_sampler
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.all_candidate_sampler
def all_candidate_sampler(builder)
def all_candidate_sampler_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.all_candidate_sampler_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.all_candidate_sampler_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.all_candidate_sampler_layer
def all_candidate_sampler_layer(builder, size)
def all_variables(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.all_variables
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.all_variables
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.all_variables
def all_variables(builder)
def all_variables_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.all_variables_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.all_variables_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.all_variables_layer
def all_variables_layer(builder, size)
def applicative(
f)
def applicative(f): return Applicative(f)
def arg_max(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.arg_max
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.arg_max
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.arg_max
def arg_max(builder)
def arg_max_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.arg_max_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.arg_max_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.arg_max_layer
def arg_max_layer(builder, size)
def arg_min(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.arg_min
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.arg_min
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.arg_min
def arg_min(builder)
def arg_min_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.arg_min_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.arg_min_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.arg_min_layer
def arg_min_layer(builder, size)
def argmax_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.argmax_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.argmax_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.argmax_layer
def argmax_layer(builder, size)
def argmin_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.argmin_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.argmin_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.argmin_layer
def argmin_layer(builder, size)
def as_dtype(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.as_dtype
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.as_dtype
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.as_dtype
def as_dtype(builder)
def as_dtype_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.as_dtype_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.as_dtype_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.as_dtype_layer
def as_dtype_layer(builder, size)
def asin(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.asin
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.asin
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.asin
def asin(builder)
def asin_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.asin_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.asin_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.asin_layer
def asin_layer(builder, size)
def assert_equal(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assert_equal
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assert_equal
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assert_equal
def assert_equal(builder)
def assert_equal_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assert_equal_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assert_equal_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assert_equal_layer
def assert_equal_layer(builder, size)
def assert_integer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assert_integer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assert_integer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assert_integer
def assert_integer(builder)
def assert_integer_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assert_integer_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assert_integer_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assert_integer_layer
def assert_integer_layer(builder, size)
def assert_less(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assert_less
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assert_less
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assert_less
def assert_less(builder)
def assert_less_equal(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assert_less_equal
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assert_less_equal
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assert_less_equal
def assert_less_equal(builder)
def assert_less_equal_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assert_less_equal_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assert_less_equal_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assert_less_equal_layer
def assert_less_equal_layer(builder, size)
def assert_less_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assert_less_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assert_less_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assert_less_layer
def assert_less_layer(builder, size)
def assert_negative(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assert_negative
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assert_negative
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assert_negative
def assert_negative(builder)
def assert_negative_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assert_negative_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assert_negative_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assert_negative_layer
def assert_negative_layer(builder, size)
def assert_non_negative(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assert_non_negative
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assert_non_negative
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assert_non_negative
def assert_non_negative(builder)
def assert_non_negative_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assert_non_negative_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assert_non_negative_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assert_non_negative_layer
def assert_non_negative_layer(builder, size)
def assert_non_positive(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assert_non_positive
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assert_non_positive
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assert_non_positive
def assert_non_positive(builder)
def assert_non_positive_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assert_non_positive_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assert_non_positive_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assert_non_positive_layer
def assert_non_positive_layer(builder, size)
def assert_positive(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assert_positive
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assert_positive
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assert_positive
def assert_positive(builder)
def assert_positive_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assert_positive_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assert_positive_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assert_positive_layer
def assert_positive_layer(builder, size)
def assert_proper_iterable(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assert_proper_iterable
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assert_proper_iterable
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assert_proper_iterable
def assert_proper_iterable(builder)
def assert_proper_iterable_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assert_proper_iterable_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assert_proper_iterable_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assert_proper_iterable_layer
def assert_proper_iterable_layer(builder, size)
def assert_rank(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assert_rank
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assert_rank
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assert_rank
def assert_rank(builder)
def assert_rank_at_least(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assert_rank_at_least
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assert_rank_at_least
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assert_rank_at_least
def assert_rank_at_least(builder)
def assert_rank_at_least_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assert_rank_at_least_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assert_rank_at_least_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assert_rank_at_least_layer
def assert_rank_at_least_layer(builder, size)
def assert_rank_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assert_rank_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assert_rank_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assert_rank_layer
def assert_rank_layer(builder, size)
def assert_type(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assert_type
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assert_type
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assert_type
def assert_type(builder)
def assert_type_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assert_type_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assert_type_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assert_type_layer
def assert_type_layer(builder, size)
def assert_variables_initialized(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assert_variables_initialized
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assert_variables_initialized
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assert_variables_initialized
def assert_variables_initialized(builder)
def assert_variables_initialized_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assert_variables_initialized_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assert_variables_initialized_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assert_variables_initialized_layer
def assert_variables_initialized_layer(builder, size)
def assign(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assign
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assign
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assign
def assign(builder)
def assign_add(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assign_add
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assign_add
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assign_add
def assign_add(builder)
def assign_add_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assign_add_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assign_add_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assign_add_layer
def assign_add_layer(builder, size)
def assign_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assign_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assign_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assign_layer
def assign_layer(builder, size)
def assign_sub(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.assign_sub
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.assign_sub
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.assign_sub
def assign_sub(builder)
def assign_sub_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.assign_sub_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.assign_sub_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.assign_sub_layer
def assign_sub_layer(builder, size)
def atan(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.atan
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.atan
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.atan
def atan(builder)
def atan_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.atan_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.atan_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.atan_layer
def atan_layer(builder, size)
def atrous_conv2d(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.atrous_conv2d
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.atrous_conv2d
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.atrous_conv2d
def atrous_conv2d(builder)
def atrous_conv2d_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.atrous_conv2d_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.atrous_conv2d_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.atrous_conv2d_layer
def atrous_conv2d_layer(builder, size)
def audio_summary(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.audio_summary
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.audio_summary
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.audio_summary
def audio_summary(builder)
def audio_summary_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.audio_summary_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.audio_summary_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.audio_summary_layer
def audio_summary_layer(builder, size)
def avg_pool(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.avg_pool
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.avg_pool
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.avg_pool
def avg_pool(builder)
def avg_pool3d(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.avg_pool3d
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.avg_pool3d
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.avg_pool3d
def avg_pool3d(builder)
def avg_pool3d_grad(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.avg_pool3d_grad
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.avg_pool3d_grad
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.avg_pool3d_grad
def avg_pool3d_grad(builder)
def avg_pool3d_grad_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.avg_pool3d_grad_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.avg_pool3d_grad_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.avg_pool3d_grad_layer
def avg_pool3d_grad_layer(builder, size)
def avg_pool3d_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.avg_pool3d_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.avg_pool3d_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.avg_pool3d_layer
def avg_pool3d_layer(builder, size)
def avg_pool_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.avg_pool_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.avg_pool_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.avg_pool_layer
def avg_pool_layer(builder, size)
def batch_cholesky(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_cholesky
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_cholesky
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_cholesky
def batch_cholesky(builder)
def batch_cholesky_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_cholesky_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_cholesky_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_cholesky_layer
def batch_cholesky_layer(builder, size)
def batch_cholesky_solve(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_cholesky_solve
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_cholesky_solve
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_cholesky_solve
def batch_cholesky_solve(builder)
def batch_cholesky_solve_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_cholesky_solve_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_cholesky_solve_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_cholesky_solve_layer
def batch_cholesky_solve_layer(builder, size)
def batch_fft(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_fft
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_fft
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_fft
def batch_fft(builder)
def batch_fft2d(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_fft2d
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_fft2d
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_fft2d
def batch_fft2d(builder)
def batch_fft2d_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_fft2d_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_fft2d_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_fft2d_layer
def batch_fft2d_layer(builder, size)
def batch_fft3d(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_fft3d
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_fft3d
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_fft3d
def batch_fft3d(builder)
def batch_fft3d_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_fft3d_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_fft3d_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_fft3d_layer
def batch_fft3d_layer(builder, size)
def batch_fft_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_fft_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_fft_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_fft_layer
def batch_fft_layer(builder, size)
def batch_ifft(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_ifft
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_ifft
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_ifft
def batch_ifft(builder)
def batch_ifft2d(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_ifft2d
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_ifft2d
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_ifft2d
def batch_ifft2d(builder)
def batch_ifft2d_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_ifft2d_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_ifft2d_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_ifft2d_layer
def batch_ifft2d_layer(builder, size)
def batch_ifft3d(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_ifft3d
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_ifft3d
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_ifft3d
def batch_ifft3d(builder)
def batch_ifft3d_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_ifft3d_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_ifft3d_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_ifft3d_layer
def batch_ifft3d_layer(builder, size)
def batch_ifft_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_ifft_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_ifft_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_ifft_layer
def batch_ifft_layer(builder, size)
def batch_matmul_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_matmul_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_matmul_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_matmul_layer
def batch_matmul_layer(builder, size)
def batch_matrix_band_part(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_matrix_band_part
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_matrix_band_part
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_matrix_band_part
def batch_matrix_band_part(builder)
def batch_matrix_band_part_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_matrix_band_part_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_matrix_band_part_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_matrix_band_part_layer
def batch_matrix_band_part_layer(builder, size)
def batch_matrix_determinant(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_matrix_determinant
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_matrix_determinant
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_matrix_determinant
def batch_matrix_determinant(builder)
def batch_matrix_determinant_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_matrix_determinant_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_matrix_determinant_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_matrix_determinant_layer
def batch_matrix_determinant_layer(builder, size)
def batch_matrix_diag(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_matrix_diag
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_matrix_diag
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_matrix_diag
def batch_matrix_diag(builder)
def batch_matrix_diag_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_matrix_diag_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_matrix_diag_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_matrix_diag_layer
def batch_matrix_diag_layer(builder, size)
def batch_matrix_diag_part(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_matrix_diag_part
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_matrix_diag_part
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_matrix_diag_part
def batch_matrix_diag_part(builder)
def batch_matrix_diag_part_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_matrix_diag_part_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_matrix_diag_part_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_matrix_diag_part_layer
def batch_matrix_diag_part_layer(builder, size)
def batch_matrix_inverse(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_matrix_inverse
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_matrix_inverse
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_matrix_inverse
def batch_matrix_inverse(builder)
def batch_matrix_inverse_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_matrix_inverse_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_matrix_inverse_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_matrix_inverse_layer
def batch_matrix_inverse_layer(builder, size)
def batch_matrix_solve(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_matrix_solve
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_matrix_solve
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_matrix_solve
def batch_matrix_solve(builder)
def batch_matrix_solve_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_matrix_solve_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_matrix_solve_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_matrix_solve_layer
def batch_matrix_solve_layer(builder, size)
def batch_matrix_solve_ls(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_matrix_solve_ls
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_matrix_solve_ls
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_matrix_solve_ls
def batch_matrix_solve_ls(builder)
def batch_matrix_solve_ls_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_matrix_solve_ls_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_matrix_solve_ls_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_matrix_solve_ls_layer
def batch_matrix_solve_ls_layer(builder, size)
def batch_matrix_triangular_solve(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_matrix_triangular_solve
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_matrix_triangular_solve
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_matrix_triangular_solve
def batch_matrix_triangular_solve(builder)
def batch_matrix_triangular_solve_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_matrix_triangular_solve_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_matrix_triangular_solve_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_matrix_triangular_solve_layer
def batch_matrix_triangular_solve_layer(builder, size)
def batch_norm_with_global_normalization(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_norm_with_global_normalization
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_norm_with_global_normalization
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_norm_with_global_normalization
def batch_norm_with_global_normalization(builder)
def batch_norm_with_global_normalization_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_norm_with_global_normalization_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_norm_with_global_normalization_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_norm_with_global_normalization_layer
def batch_norm_with_global_normalization_layer(builder, size)
def batch_normalization(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_normalization
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_normalization
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_normalization
def batch_normalization(builder)
def batch_normalization_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_normalization_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_normalization_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_normalization_layer
def batch_normalization_layer(builder, size)
def batch_self_adjoint_eig(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_self_adjoint_eig
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_self_adjoint_eig
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_self_adjoint_eig
def batch_self_adjoint_eig(builder)
def batch_self_adjoint_eig_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_self_adjoint_eig_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_self_adjoint_eig_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_self_adjoint_eig_layer
def batch_self_adjoint_eig_layer(builder, size)
def batch_to_space(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.batch_to_space
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.batch_to_space
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.batch_to_space
def batch_to_space(builder)
def batch_to_space_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.batch_to_space_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.batch_to_space_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.batch_to_space_layer
def batch_to_space_layer(builder, size)
def bias_add(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.bias_add
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.bias_add
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.bias_add
def bias_add(builder)
def bias_add_grad(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.bias_add_grad
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.bias_add_grad
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.bias_add_grad
def bias_add_grad(builder)
def bias_add_grad_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.bias_add_grad_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.bias_add_grad_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.bias_add_grad_layer
def bias_add_grad_layer(builder, size)
def bias_add_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.bias_add_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.bias_add_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.bias_add_layer
def bias_add_layer(builder, size)
def bias_add_v1(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.bias_add_v1
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.bias_add_v1
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.bias_add_v1
def bias_add_v1(builder)
def bias_add_v1_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.bias_add_v1_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.bias_add_v1_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.bias_add_v1_layer
def bias_add_v1_layer(builder, size)
def bidirectional_rnn(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.bidirectional_rnn
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.bidirectional_rnn
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.bidirectional_rnn
def bidirectional_rnn(builder)
def bidirectional_rnn_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.bidirectional_rnn_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.bidirectional_rnn_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.bidirectional_rnn_layer
def bidirectional_rnn_layer(builder, size)
def bitcast(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.bitcast
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.bitcast
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.bitcast
def bitcast(builder)
def bitcast_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.bitcast_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.bitcast_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.bitcast_layer
def bitcast_layer(builder, size)
def boolean_mask(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.boolean_mask
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.boolean_mask
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.boolean_mask
def boolean_mask(builder)
def boolean_mask_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.boolean_mask_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.boolean_mask_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.boolean_mask_layer
def boolean_mask_layer(builder, size)
def branch(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.branch
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.branch
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.branch
def branch(builder, fn)
def builders(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.builders
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.builders
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.builders
def builders(self)
def case(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.case
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.case
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.case
def case(builder)
def case_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.case_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.case_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.case_layer
def case_layer(builder, size)
def cast(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.cast
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.cast
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.cast
def cast(builder)
def cast_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.cast_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.cast_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.cast_layer
def cast_layer(builder, size)
def ceil(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.ceil
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.ceil
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.ceil
def ceil(builder)
def ceil_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.ceil_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.ceil_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.ceil_layer
def ceil_layer(builder, size)
def check_numerics(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.check_numerics
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.check_numerics
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.check_numerics
def check_numerics(builder)
def check_numerics_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.check_numerics_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.check_numerics_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.check_numerics_layer
def check_numerics_layer(builder, size)
def cholesky(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.cholesky
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.cholesky
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.cholesky
def cholesky(builder)
def cholesky_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.cholesky_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.cholesky_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.cholesky_layer
def cholesky_layer(builder, size)
def cholesky_solve(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.cholesky_solve
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.cholesky_solve
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.cholesky_solve
def cholesky_solve(builder)
def cholesky_solve_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.cholesky_solve_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.cholesky_solve_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.cholesky_solve_layer
def cholesky_solve_layer(builder, size)
def clip_by_average_norm(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.clip_by_average_norm
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.clip_by_average_norm
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.clip_by_average_norm
def clip_by_average_norm(builder)
def clip_by_average_norm_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.clip_by_average_norm_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.clip_by_average_norm_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.clip_by_average_norm_layer
def clip_by_average_norm_layer(builder, size)
def clip_by_global_norm(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.clip_by_global_norm
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.clip_by_global_norm
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.clip_by_global_norm
def clip_by_global_norm(builder)
def clip_by_global_norm_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.clip_by_global_norm_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.clip_by_global_norm_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.clip_by_global_norm_layer
def clip_by_global_norm_layer(builder, size)
def clip_by_norm(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.clip_by_norm
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.clip_by_norm
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.clip_by_norm
def clip_by_norm(builder)
def clip_by_norm_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.clip_by_norm_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.clip_by_norm_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.clip_by_norm_layer
def clip_by_norm_layer(builder, size)
def clip_by_value(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.clip_by_value
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.clip_by_value
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.clip_by_value
def clip_by_value(builder)
def clip_by_value_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.clip_by_value_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.clip_by_value_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.clip_by_value_layer
def clip_by_value_layer(builder, size)
def compile(
ast)
def compile(ast): #if type(ast) is tuple: if type(ast) is list: return _branch_function(ast) elif hasattr(ast, '__call__'): return ast else: return _sequence_function(ast)
def complex(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.complex
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.complex
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.complex
def complex(builder)
def complex_abs(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.complex_abs
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.complex_abs
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.complex_abs
def complex_abs(builder)
def complex_abs_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.complex_abs_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.complex_abs_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.complex_abs_layer
def complex_abs_layer(builder, size)
def complex_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.complex_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.complex_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.complex_layer
def complex_layer(builder, size)
def compute_accidental_hits(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.compute_accidental_hits
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.compute_accidental_hits
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.compute_accidental_hits
def compute_accidental_hits(builder)
def compute_accidental_hits_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.compute_accidental_hits_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.compute_accidental_hits_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.compute_accidental_hits_layer
def compute_accidental_hits_layer(builder, size)
def concat(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.concat
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.concat
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.concat
def concat(builder)
def concat_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.concat_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.concat_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.concat_layer
def concat_layer(builder, size)
def cond(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.cond
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.cond
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.cond
def cond(builder)
def cond_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.cond_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.cond_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.cond_layer
def cond_layer(builder, size)
def conj(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.conj
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.conj
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.conj
def conj(builder)
def conj_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.conj_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.conj_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.conj_layer
def conj_layer(builder, size)
def constant(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.constant
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.constant
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.constant
def constant(builder)
def constant_initializer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.constant_initializer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.constant_initializer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.constant_initializer
def constant_initializer(builder)
def constant_initializer_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.constant_initializer_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.constant_initializer_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.constant_initializer_layer
def constant_initializer_layer(builder, size)
def constant_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.constant_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.constant_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.constant_layer
def constant_layer(builder, size)
def control_dependencies(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.control_dependencies
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.control_dependencies
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.control_dependencies
def control_dependencies(builder)
def control_dependencies_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.control_dependencies_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.control_dependencies_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.control_dependencies_layer
def control_dependencies_layer(builder, size)
def conv1d(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.conv1d
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.conv1d
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.conv1d
def conv1d(builder)
def conv1d_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.conv1d_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.conv1d_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.conv1d_layer
def conv1d_layer(builder, size)
def conv2d(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.conv2d
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.conv2d
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.conv2d
def conv2d(builder)
def conv2d_backprop_filter(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.conv2d_backprop_filter
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.conv2d_backprop_filter
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.conv2d_backprop_filter
def conv2d_backprop_filter(builder)
def conv2d_backprop_filter_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.conv2d_backprop_filter_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.conv2d_backprop_filter_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.conv2d_backprop_filter_layer
def conv2d_backprop_filter_layer(builder, size)
def conv2d_backprop_input(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.conv2d_backprop_input
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.conv2d_backprop_input
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.conv2d_backprop_input
def conv2d_backprop_input(builder)
def conv2d_backprop_input_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.conv2d_backprop_input_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.conv2d_backprop_input_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.conv2d_backprop_input_layer
def conv2d_backprop_input_layer(builder, size)
def conv2d_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.conv2d_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.conv2d_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.conv2d_layer
def conv2d_layer(builder, size)
def conv2d_transpose(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.conv2d_transpose
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.conv2d_transpose
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.conv2d_transpose
def conv2d_transpose(builder)
def conv2d_transpose_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.conv2d_transpose_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.conv2d_transpose_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.conv2d_transpose_layer
def conv2d_transpose_layer(builder, size)
def conv3d(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.conv3d
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.conv3d
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.conv3d
def conv3d(builder)
def conv3d_backprop_filter(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.conv3d_backprop_filter
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.conv3d_backprop_filter
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.conv3d_backprop_filter
def conv3d_backprop_filter(builder)
def conv3d_backprop_filter_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.conv3d_backprop_filter_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.conv3d_backprop_filter_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.conv3d_backprop_filter_layer
def conv3d_backprop_filter_layer(builder, size)
def conv3d_backprop_input(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.conv3d_backprop_input
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.conv3d_backprop_input
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.conv3d_backprop_input
def conv3d_backprop_input(builder)
def conv3d_backprop_input_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.conv3d_backprop_input_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.conv3d_backprop_input_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.conv3d_backprop_input_layer
def conv3d_backprop_input_layer(builder, size)
def conv3d_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.conv3d_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.conv3d_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.conv3d_layer
def conv3d_layer(builder, size)
def convert_to_tensor(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.convert_to_tensor
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.convert_to_tensor
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.convert_to_tensor
def convert_to_tensor(builder)
def convert_to_tensor_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.convert_to_tensor_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.convert_to_tensor_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.convert_to_tensor_layer
def convert_to_tensor_layer(builder, size)
def convert_to_tensor_or_indexed_slices(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.convert_to_tensor_or_indexed_slices
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.convert_to_tensor_or_indexed_slices
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.convert_to_tensor_or_indexed_slices
def convert_to_tensor_or_indexed_slices(builder)
def convert_to_tensor_or_indexed_slices_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.convert_to_tensor_or_indexed_slices_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.convert_to_tensor_or_indexed_slices_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.convert_to_tensor_or_indexed_slices_layer
def convert_to_tensor_or_indexed_slices_layer(builder, size)
def convolution2d(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.convolution2d
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.convolution2d
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.convolution2d
def convolution2d(builder)
def cos(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.cos
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.cos
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.cos
def cos(builder)
def cos_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.cos_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.cos_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.cos_layer
def cos_layer(builder, size)
def count_up_to(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.count_up_to
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.count_up_to
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.count_up_to
def count_up_to(builder)
def count_up_to_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.count_up_to_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.count_up_to_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.count_up_to_layer
def count_up_to_layer(builder, size)
def create_partitioned_variables(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.create_partitioned_variables
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.create_partitioned_variables
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.create_partitioned_variables
def create_partitioned_variables(builder)
def create_partitioned_variables_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.create_partitioned_variables_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.create_partitioned_variables_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.create_partitioned_variables_layer
def create_partitioned_variables_layer(builder, size)
def cross(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.cross
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.cross
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.cross
def cross(builder)
def cross_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.cross_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.cross_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.cross_layer
def cross_layer(builder, size)
def decode_csv(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.decode_csv
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.decode_csv
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.decode_csv
def decode_csv(builder)
def decode_csv_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.decode_csv_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.decode_csv_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.decode_csv_layer
def decode_csv_layer(builder, size)
def decode_json_example(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.decode_json_example
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.decode_json_example
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.decode_json_example
def decode_json_example(builder)
def decode_json_example_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.decode_json_example_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.decode_json_example_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.decode_json_example_layer
def decode_json_example_layer(builder, size)
def decode_raw(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.decode_raw
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.decode_raw
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.decode_raw
def decode_raw(builder)
def decode_raw_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.decode_raw_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.decode_raw_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.decode_raw_layer
def decode_raw_layer(builder, size)
def delete_session_tensor(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.delete_session_tensor
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.delete_session_tensor
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.delete_session_tensor
def delete_session_tensor(builder)
def delete_session_tensor_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.delete_session_tensor_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.delete_session_tensor_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.delete_session_tensor_layer
def delete_session_tensor_layer(builder, size)
def depth_to_space(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.depth_to_space
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.depth_to_space
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.depth_to_space
def depth_to_space(builder)
def depth_to_space_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.depth_to_space_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.depth_to_space_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.depth_to_space_layer
def depth_to_space_layer(builder, size)
def depthwise_conv2d(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.depthwise_conv2d
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.depthwise_conv2d
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.depthwise_conv2d
def depthwise_conv2d(builder)
def depthwise_conv2d_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.depthwise_conv2d_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.depthwise_conv2d_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.depthwise_conv2d_layer
def depthwise_conv2d_layer(builder, size)
def depthwise_conv2d_native(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.depthwise_conv2d_native
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.depthwise_conv2d_native
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.depthwise_conv2d_native
def depthwise_conv2d_native(builder)
def depthwise_conv2d_native_backprop_filter(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.depthwise_conv2d_native_backprop_filter
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.depthwise_conv2d_native_backprop_filter
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.depthwise_conv2d_native_backprop_filter
def depthwise_conv2d_native_backprop_filter(builder)
def depthwise_conv2d_native_backprop_filter_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.depthwise_conv2d_native_backprop_filter_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.depthwise_conv2d_native_backprop_filter_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.depthwise_conv2d_native_backprop_filter_layer
def depthwise_conv2d_native_backprop_filter_layer(builder, size)
def depthwise_conv2d_native_backprop_input(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.depthwise_conv2d_native_backprop_input
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.depthwise_conv2d_native_backprop_input
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.depthwise_conv2d_native_backprop_input
def depthwise_conv2d_native_backprop_input(builder)
def depthwise_conv2d_native_backprop_input_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.depthwise_conv2d_native_backprop_input_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.depthwise_conv2d_native_backprop_input_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.depthwise_conv2d_native_backprop_input_layer
def depthwise_conv2d_native_backprop_input_layer(builder, size)
def depthwise_conv2d_native_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.depthwise_conv2d_native_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.depthwise_conv2d_native_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.depthwise_conv2d_native_layer
def depthwise_conv2d_native_layer(builder, size)
def deserialize_many_sparse(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.deserialize_many_sparse
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.deserialize_many_sparse
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.deserialize_many_sparse
def deserialize_many_sparse(builder)
def deserialize_many_sparse_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.deserialize_many_sparse_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.deserialize_many_sparse_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.deserialize_many_sparse_layer
def deserialize_many_sparse_layer(builder, size)
def device(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.device
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.device
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.device
def device(builder)
def device_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.device_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.device_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.device_layer
def device_layer(builder, size)
def diag(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.diag
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.diag
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.diag
def diag(builder)
def diag_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.diag_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.diag_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.diag_layer
def diag_layer(builder, size)
def diag_part(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.diag_part
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.diag_part
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.diag_part
def diag_part(builder)
def diag_part_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.diag_part_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.diag_part_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.diag_part_layer
def diag_part_layer(builder, size)
def digamma(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.digamma
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.digamma
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.digamma
def digamma(builder)
def digamma_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.digamma_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.digamma_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.digamma_layer
def digamma_layer(builder, size)
def dilation2d(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.dilation2d
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.dilation2d
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.dilation2d
def dilation2d(builder)
def dilation2d_backprop_filter(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.dilation2d_backprop_filter
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.dilation2d_backprop_filter
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.dilation2d_backprop_filter
def dilation2d_backprop_filter(builder)
def dilation2d_backprop_filter_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.dilation2d_backprop_filter_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.dilation2d_backprop_filter_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.dilation2d_backprop_filter_layer
def dilation2d_backprop_filter_layer(builder, size)
def dilation2d_backprop_input(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.dilation2d_backprop_input
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.dilation2d_backprop_input
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.dilation2d_backprop_input
def dilation2d_backprop_input(builder)
def dilation2d_backprop_input_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.dilation2d_backprop_input_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.dilation2d_backprop_input_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.dilation2d_backprop_input_layer
def dilation2d_backprop_input_layer(builder, size)
def dilation2d_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.dilation2d_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.dilation2d_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.dilation2d_layer
def dilation2d_layer(builder, size)
def div(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.div
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.div
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.div
def div(builder)
def div_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.div_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.div_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.div_layer
def div_layer(builder, size)
def dropout(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.dropout
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.dropout
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.dropout
def dropout(builder)
def dropout_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.dropout_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.dropout_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.dropout_layer
def dropout_layer(builder, size)
def dynamic_partition(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.dynamic_partition
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to Builder.dynamic_partition
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.dynamic_partition
def dynamic_partition(builder)
def dynamic_partition_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.dynamic_partition_layer
but instead of getting the class instance as its first arguments, it returns a function that expects a builder and applies the builder plus all *args and **kwargs to BuilderTree.dynamic_partition_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.dynamic_partition_layer
def dynamic_partition_layer(builder, size)
def dynamic_rnn(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED