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.unpack_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.unpack_layer
def unpack_layer(builder, size)
def unsorted_segment_sum(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.unsorted_segment_sum
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.unsorted_segment_sum
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.unsorted_segment_sum
def unsorted_segment_sum(builder)
def unsorted_segment_sum_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.unsorted_segment_sum_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.unsorted_segment_sum_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.unsorted_segment_sum_layer
def unsorted_segment_sum_layer(builder, size)
def variable_axis_size_partitioner(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.variable_axis_size_partitioner
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.variable_axis_size_partitioner
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.variable_axis_size_partitioner
def variable_axis_size_partitioner(builder)
def variable_axis_size_partitioner_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.variable_axis_size_partitioner_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.variable_axis_size_partitioner_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.variable_axis_size_partitioner_layer
def variable_axis_size_partitioner_layer(builder, size)
def variable_op_scope(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.variable_op_scope
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.variable_op_scope
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.variable_op_scope
def variable_op_scope(builder)
def variable_op_scope_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.variable_op_scope_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.variable_op_scope_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.variable_op_scope_layer
def variable_op_scope_layer(builder, size)
def variable_scope(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.variable_scope
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.variable_scope
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.variable_scope
def variable_scope(builder)
def variable_scope_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.variable_scope_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.variable_scope_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.variable_scope_layer
def variable_scope_layer(builder, size)
def verify_tensor_all_finite(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.verify_tensor_all_finite
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.verify_tensor_all_finite
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.verify_tensor_all_finite
def verify_tensor_all_finite(builder)
def verify_tensor_all_finite_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.verify_tensor_all_finite_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.verify_tensor_all_finite_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.verify_tensor_all_finite_layer
def verify_tensor_all_finite_layer(builder, size)
def weighted_cross_entropy_with_logits(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.weighted_cross_entropy_with_logits
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.weighted_cross_entropy_with_logits
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.weighted_cross_entropy_with_logits
def weighted_cross_entropy_with_logits(builder)
def weighted_cross_entropy_with_logits_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.weighted_cross_entropy_with_logits_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.weighted_cross_entropy_with_logits_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.weighted_cross_entropy_with_logits_layer
def weighted_cross_entropy_with_logits_layer(builder, size)
def where(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.where
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.where
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.where
def where(builder)
def where_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.where_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.where_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.where_layer
def where_layer(builder, size)
def while_loop(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.while_loop
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.while_loop
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.while_loop
def while_loop(builder)
def while_loop_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.while_loop_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.while_loop_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.while_loop_layer
def while_loop_layer(builder, size)
def xw_plus_b(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.xw_plus_b
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.xw_plus_b
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.xw_plus_b
def xw_plus_b(builder)
def xw_plus_b_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.xw_plus_b_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.xw_plus_b_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.xw_plus_b_layer
def xw_plus_b_layer(builder, size)
def xw_plus_b_v1(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.xw_plus_b_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.xw_plus_b_v1
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.xw_plus_b_v1
def xw_plus_b_v1(builder)
def xw_plus_b_v1_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.xw_plus_b_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.xw_plus_b_v1_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.xw_plus_b_v1_layer
def xw_plus_b_v1_layer(builder, size)
def zero_fraction(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.zero_fraction
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.zero_fraction
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.zero_fraction
def zero_fraction(builder)
def zero_fraction_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.zero_fraction_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.zero_fraction_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.zero_fraction_layer
def zero_fraction_layer(builder, size)
def zeros(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.zeros
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.zeros
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.zeros
def zeros(builder)
def zeros_initializer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.zeros_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.zeros_initializer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.zeros_initializer
def zeros_initializer(builder)
def zeros_initializer_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.zeros_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.zeros_initializer_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.zeros_initializer_layer
def zeros_initializer_layer(builder, size)
def zeros_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.zeros_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.zeros_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.zeros_layer
def zeros_layer(builder, size)
def zeros_like(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.zeros_like
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.zeros_like
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.zeros_like
def zeros_like(builder)
def zeros_like_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.zeros_like_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.zeros_like_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.zeros_like_layer
def zeros_like_layer(builder, size)
def zeta(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as Builder.zeta
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.zeta
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of Builder.zeta
def zeta(builder)
def zeta_layer(
*args, **kwargs)
THIS FUNCTION IS AUTOMATICALLY GENERATED
This function accepts the same arguments as BuilderTree.zeta_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.zeta_layer
. The returned function is an Applicative
, so you can use all the methods defined by this class.
utils of BuilderTree.zeta_layer
def zeta_layer(builder, size)
Classes
class Applicative
docstring for Applicative
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))
Ancestors (in MRO)
- Applicative
- __builtin__.object
Instance variables
var f
A function of type a -> b
.
Methods
def __init__(
self, f)
def __init__(self, f): super(Applicative, self).__init__() self.f = f """ A function of type `a -> b`. """
def Assert(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.Assert
but:
- Forwards all of its arguments to
Assert
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose Assert
with f
.
utils of Builder.Assert
def Assert(builder)
def Assert_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.Assert_layer
but:
- Forwards all of its arguments to
Assert_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose Assert_layer
with f
.
utils of BuilderTree.Assert_layer
def Assert_layer(builder, size)
def NoGradient(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.NoGradient
but:
- Forwards all of its arguments to
NoGradient
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose NoGradient
with f
.
utils of Builder.NoGradient
def NoGradient(builder)
def NoGradient_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.NoGradient_layer
but:
- Forwards all of its arguments to
NoGradient_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose NoGradient_layer
with f
.
utils of BuilderTree.NoGradient_layer
def NoGradient_layer(builder, size)
def Print(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.Print
but:
- Forwards all of its arguments to
Print
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose Print
with f
.
utils of Builder.Print
def Print(builder)
def Print_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.Print_layer
but:
- Forwards all of its arguments to
Print_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose Print_layer
with f
.
utils of BuilderTree.Print_layer
def Print_layer(builder, size)
def abs(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.abs
but:
- Forwards all of its arguments to
abs
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose abs
with f
.
utils of Builder.abs
def abs(builder)
def abs_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.abs_layer
but:
- Forwards all of its arguments to
abs_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose abs_layer
with f
.
utils of BuilderTree.abs_layer
def abs_layer(builder, size)
def accumulate_n(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.accumulate_n
but:
- Forwards all of its arguments to
accumulate_n
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose accumulate_n
with f
.
utils of Builder.accumulate_n
def accumulate_n(builder)
def accumulate_n_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.accumulate_n_layer
but:
- Forwards all of its arguments to
accumulate_n_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose accumulate_n_layer
with f
.
utils of BuilderTree.accumulate_n_layer
def accumulate_n_layer(builder, size)
def acos(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.acos
but:
- Forwards all of its arguments to
acos
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose acos
with f
.
utils of Builder.acos
def acos(builder)
def acos_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.acos_layer
but:
- Forwards all of its arguments to
acos_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose acos_layer
with f
.
utils of BuilderTree.acos_layer
def acos_layer(builder, size)
def add(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.add
but:
- Forwards all of its arguments to
add
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose add
with f
.
utils of Builder.add
def add(builder)
def add_check_numerics_ops(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.add_check_numerics_ops
but:
- Forwards all of its arguments to
add_check_numerics_ops
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose add_check_numerics_ops
with f
.
utils of Builder.add_check_numerics_ops
def add_check_numerics_ops(builder)
def add_check_numerics_ops_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.add_check_numerics_ops_layer
but:
- Forwards all of its arguments to
add_check_numerics_ops_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose add_check_numerics_ops_layer
with f
.
utils of BuilderTree.add_check_numerics_ops_layer
def add_check_numerics_ops_layer(builder, size)
def add_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.add_layer
but:
- Forwards all of its arguments to
add_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose add_layer
with f
.
utils of BuilderTree.add_layer
def add_layer(builder, size)
def add_n(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.add_n
but:
- Forwards all of its arguments to
add_n
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose add_n
with f
.
utils of Builder.add_n
def add_n(builder)
def add_n_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.add_n_layer
but:
- Forwards all of its arguments to
add_n_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose add_n_layer
with f
.
utils of BuilderTree.add_n_layer
def add_n_layer(builder, size)
def add_to_collection(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.add_to_collection
but:
- Forwards all of its arguments to
add_to_collection
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose add_to_collection
with f
.
utils of Builder.add_to_collection
def add_to_collection(builder)
def add_to_collection_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.add_to_collection_layer
but:
- Forwards all of its arguments to
add_to_collection_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose add_to_collection_layer
with f
.
utils of BuilderTree.add_to_collection_layer
def add_to_collection_layer(builder, size)
def all_candidate_sampler(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.all_candidate_sampler
but:
- Forwards all of its arguments to
all_candidate_sampler
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose all_candidate_sampler
with f
.
utils of Builder.all_candidate_sampler
def all_candidate_sampler(builder)
def all_candidate_sampler_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.all_candidate_sampler_layer
but:
- Forwards all of its arguments to
all_candidate_sampler_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose all_candidate_sampler_layer
with f
.
utils of BuilderTree.all_candidate_sampler_layer
def all_candidate_sampler_layer(builder, size)
def all_variables(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.all_variables
but:
- Forwards all of its arguments to
all_variables
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose all_variables
with f
.
utils of Builder.all_variables
def all_variables(builder)
def all_variables_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.all_variables_layer
but:
- Forwards all of its arguments to
all_variables_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose all_variables_layer
with f
.
utils of BuilderTree.all_variables_layer
def all_variables_layer(builder, size)
def arg_max(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.arg_max
but:
- Forwards all of its arguments to
arg_max
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose arg_max
with f
.
utils of Builder.arg_max
def arg_max(builder)
def arg_max_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.arg_max_layer
but:
- Forwards all of its arguments to
arg_max_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose arg_max_layer
with f
.
utils of BuilderTree.arg_max_layer
def arg_max_layer(builder, size)
def arg_min(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.arg_min
but:
- Forwards all of its arguments to
arg_min
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose arg_min
with f
.
utils of Builder.arg_min
def arg_min(builder)
def arg_min_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.arg_min_layer
but:
- Forwards all of its arguments to
arg_min_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose arg_min_layer
with f
.
utils of BuilderTree.arg_min_layer
def arg_min_layer(builder, size)
def argmax_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.argmax_layer
but:
- Forwards all of its arguments to
argmax_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose argmax_layer
with f
.
utils of BuilderTree.argmax_layer
def argmax_layer(builder, size)
def argmin_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.argmin_layer
but:
- Forwards all of its arguments to
argmin_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose argmin_layer
with f
.
utils of BuilderTree.argmin_layer
def argmin_layer(builder, size)
def as_dtype(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.as_dtype
but:
- Forwards all of its arguments to
as_dtype
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose as_dtype
with f
.
utils of Builder.as_dtype
def as_dtype(builder)
def as_dtype_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.as_dtype_layer
but:
- Forwards all of its arguments to
as_dtype_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose as_dtype_layer
with f
.
utils of BuilderTree.as_dtype_layer
def as_dtype_layer(builder, size)
def asin(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.asin
but:
- Forwards all of its arguments to
asin
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose asin
with f
.
utils of Builder.asin
def asin(builder)
def asin_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.asin_layer
but:
- Forwards all of its arguments to
asin_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose asin_layer
with f
.
utils of BuilderTree.asin_layer
def asin_layer(builder, size)
def assert_equal(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assert_equal
but:
- Forwards all of its arguments to
assert_equal
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_equal
with f
.
utils of Builder.assert_equal
def assert_equal(builder)
def assert_equal_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assert_equal_layer
but:
- Forwards all of its arguments to
assert_equal_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_equal_layer
with f
.
utils of BuilderTree.assert_equal_layer
def assert_equal_layer(builder, size)
def assert_integer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assert_integer
but:
- Forwards all of its arguments to
assert_integer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_integer
with f
.
utils of Builder.assert_integer
def assert_integer(builder)
def assert_integer_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assert_integer_layer
but:
- Forwards all of its arguments to
assert_integer_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_integer_layer
with f
.
utils of BuilderTree.assert_integer_layer
def assert_integer_layer(builder, size)
def assert_less(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assert_less
but:
- Forwards all of its arguments to
assert_less
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_less
with f
.
utils of Builder.assert_less
def assert_less(builder)
def assert_less_equal(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assert_less_equal
but:
- Forwards all of its arguments to
assert_less_equal
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_less_equal
with f
.
utils of Builder.assert_less_equal
def assert_less_equal(builder)
def assert_less_equal_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assert_less_equal_layer
but:
- Forwards all of its arguments to
assert_less_equal_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_less_equal_layer
with f
.
utils of BuilderTree.assert_less_equal_layer
def assert_less_equal_layer(builder, size)
def assert_less_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assert_less_layer
but:
- Forwards all of its arguments to
assert_less_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_less_layer
with f
.
utils of BuilderTree.assert_less_layer
def assert_less_layer(builder, size)
def assert_negative(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assert_negative
but:
- Forwards all of its arguments to
assert_negative
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_negative
with f
.
utils of Builder.assert_negative
def assert_negative(builder)
def assert_negative_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assert_negative_layer
but:
- Forwards all of its arguments to
assert_negative_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_negative_layer
with f
.
utils of BuilderTree.assert_negative_layer
def assert_negative_layer(builder, size)
def assert_non_negative(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assert_non_negative
but:
- Forwards all of its arguments to
assert_non_negative
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_non_negative
with f
.
utils of Builder.assert_non_negative
def assert_non_negative(builder)
def assert_non_negative_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assert_non_negative_layer
but:
- Forwards all of its arguments to
assert_non_negative_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_non_negative_layer
with f
.
utils of BuilderTree.assert_non_negative_layer
def assert_non_negative_layer(builder, size)
def assert_non_positive(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assert_non_positive
but:
- Forwards all of its arguments to
assert_non_positive
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_non_positive
with f
.
utils of Builder.assert_non_positive
def assert_non_positive(builder)
def assert_non_positive_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assert_non_positive_layer
but:
- Forwards all of its arguments to
assert_non_positive_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_non_positive_layer
with f
.
utils of BuilderTree.assert_non_positive_layer
def assert_non_positive_layer(builder, size)
def assert_positive(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assert_positive
but:
- Forwards all of its arguments to
assert_positive
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_positive
with f
.
utils of Builder.assert_positive
def assert_positive(builder)
def assert_positive_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assert_positive_layer
but:
- Forwards all of its arguments to
assert_positive_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_positive_layer
with f
.
utils of BuilderTree.assert_positive_layer
def assert_positive_layer(builder, size)
def assert_proper_iterable(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assert_proper_iterable
but:
- Forwards all of its arguments to
assert_proper_iterable
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_proper_iterable
with f
.
utils of Builder.assert_proper_iterable
def assert_proper_iterable(builder)
def assert_proper_iterable_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assert_proper_iterable_layer
but:
- Forwards all of its arguments to
assert_proper_iterable_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_proper_iterable_layer
with f
.
utils of BuilderTree.assert_proper_iterable_layer
def assert_proper_iterable_layer(builder, size)
def assert_rank(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assert_rank
but:
- Forwards all of its arguments to
assert_rank
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_rank
with f
.
utils of Builder.assert_rank
def assert_rank(builder)
def assert_rank_at_least(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assert_rank_at_least
but:
- Forwards all of its arguments to
assert_rank_at_least
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_rank_at_least
with f
.
utils of Builder.assert_rank_at_least
def assert_rank_at_least(builder)
def assert_rank_at_least_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assert_rank_at_least_layer
but:
- Forwards all of its arguments to
assert_rank_at_least_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_rank_at_least_layer
with f
.
utils of BuilderTree.assert_rank_at_least_layer
def assert_rank_at_least_layer(builder, size)
def assert_rank_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assert_rank_layer
but:
- Forwards all of its arguments to
assert_rank_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_rank_layer
with f
.
utils of BuilderTree.assert_rank_layer
def assert_rank_layer(builder, size)
def assert_type(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assert_type
but:
- Forwards all of its arguments to
assert_type
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_type
with f
.
utils of Builder.assert_type
def assert_type(builder)
def assert_type_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assert_type_layer
but:
- Forwards all of its arguments to
assert_type_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_type_layer
with f
.
utils of BuilderTree.assert_type_layer
def assert_type_layer(builder, size)
def assert_variables_initialized(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assert_variables_initialized
but:
- Forwards all of its arguments to
assert_variables_initialized
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_variables_initialized
with f
.
utils of Builder.assert_variables_initialized
def assert_variables_initialized(builder)
def assert_variables_initialized_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assert_variables_initialized_layer
but:
- Forwards all of its arguments to
assert_variables_initialized_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assert_variables_initialized_layer
with f
.
utils of BuilderTree.assert_variables_initialized_layer
def assert_variables_initialized_layer(builder, size)
def assign(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assign
but:
- Forwards all of its arguments to
assign
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assign
with f
.
utils of Builder.assign
def assign(builder)
def assign_add(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assign_add
but:
- Forwards all of its arguments to
assign_add
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assign_add
with f
.
utils of Builder.assign_add
def assign_add(builder)
def assign_add_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assign_add_layer
but:
- Forwards all of its arguments to
assign_add_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assign_add_layer
with f
.
utils of BuilderTree.assign_add_layer
def assign_add_layer(builder, size)
def assign_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assign_layer
but:
- Forwards all of its arguments to
assign_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assign_layer
with f
.
utils of BuilderTree.assign_layer
def assign_layer(builder, size)
def assign_sub(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.assign_sub
but:
- Forwards all of its arguments to
assign_sub
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assign_sub
with f
.
utils of Builder.assign_sub
def assign_sub(builder)
def assign_sub_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.assign_sub_layer
but:
- Forwards all of its arguments to
assign_sub_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose assign_sub_layer
with f
.
utils of BuilderTree.assign_sub_layer
def assign_sub_layer(builder, size)
def atan(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.atan
but:
- Forwards all of its arguments to
atan
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose atan
with f
.
utils of Builder.atan
def atan(builder)
def atan_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.atan_layer
but:
- Forwards all of its arguments to
atan_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose atan_layer
with f
.
utils of BuilderTree.atan_layer
def atan_layer(builder, size)
def atrous_conv2d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.atrous_conv2d
but:
- Forwards all of its arguments to
atrous_conv2d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose atrous_conv2d
with f
.
utils of Builder.atrous_conv2d
def atrous_conv2d(builder)
def atrous_conv2d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.atrous_conv2d_layer
but:
- Forwards all of its arguments to
atrous_conv2d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose atrous_conv2d_layer
with f
.
utils of BuilderTree.atrous_conv2d_layer
def atrous_conv2d_layer(builder, size)
def audio_summary(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.audio_summary
but:
- Forwards all of its arguments to
audio_summary
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose audio_summary
with f
.
utils of Builder.audio_summary
def audio_summary(builder)
def audio_summary_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.audio_summary_layer
but:
- Forwards all of its arguments to
audio_summary_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose audio_summary_layer
with f
.
utils of BuilderTree.audio_summary_layer
def audio_summary_layer(builder, size)
def avg_pool(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.avg_pool
but:
- Forwards all of its arguments to
avg_pool
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose avg_pool
with f
.
utils of Builder.avg_pool
def avg_pool(builder)
def avg_pool3d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.avg_pool3d
but:
- Forwards all of its arguments to
avg_pool3d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose avg_pool3d
with f
.
utils of Builder.avg_pool3d
def avg_pool3d(builder)
def avg_pool3d_grad(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.avg_pool3d_grad
but:
- Forwards all of its arguments to
avg_pool3d_grad
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose avg_pool3d_grad
with f
.
utils of Builder.avg_pool3d_grad
def avg_pool3d_grad(builder)
def avg_pool3d_grad_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.avg_pool3d_grad_layer
but:
- Forwards all of its arguments to
avg_pool3d_grad_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose avg_pool3d_grad_layer
with f
.
utils of BuilderTree.avg_pool3d_grad_layer
def avg_pool3d_grad_layer(builder, size)
def avg_pool3d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.avg_pool3d_layer
but:
- Forwards all of its arguments to
avg_pool3d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose avg_pool3d_layer
with f
.
utils of BuilderTree.avg_pool3d_layer
def avg_pool3d_layer(builder, size)
def avg_pool_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.avg_pool_layer
but:
- Forwards all of its arguments to
avg_pool_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose avg_pool_layer
with f
.
utils of BuilderTree.avg_pool_layer
def avg_pool_layer(builder, size)
def batch_cholesky(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_cholesky
but:
- Forwards all of its arguments to
batch_cholesky
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_cholesky
with f
.
utils of Builder.batch_cholesky
def batch_cholesky(builder)
def batch_cholesky_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_cholesky_layer
but:
- Forwards all of its arguments to
batch_cholesky_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_cholesky_layer
with f
.
utils of BuilderTree.batch_cholesky_layer
def batch_cholesky_layer(builder, size)
def batch_cholesky_solve(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_cholesky_solve
but:
- Forwards all of its arguments to
batch_cholesky_solve
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_cholesky_solve
with f
.
utils of Builder.batch_cholesky_solve
def batch_cholesky_solve(builder)
def batch_cholesky_solve_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_cholesky_solve_layer
but:
- Forwards all of its arguments to
batch_cholesky_solve_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_cholesky_solve_layer
with f
.
utils of BuilderTree.batch_cholesky_solve_layer
def batch_cholesky_solve_layer(builder, size)
def batch_fft(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_fft
but:
- Forwards all of its arguments to
batch_fft
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_fft
with f
.
utils of Builder.batch_fft
def batch_fft(builder)
def batch_fft2d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_fft2d
but:
- Forwards all of its arguments to
batch_fft2d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_fft2d
with f
.
utils of Builder.batch_fft2d
def batch_fft2d(builder)
def batch_fft2d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_fft2d_layer
but:
- Forwards all of its arguments to
batch_fft2d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_fft2d_layer
with f
.
utils of BuilderTree.batch_fft2d_layer
def batch_fft2d_layer(builder, size)
def batch_fft3d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_fft3d
but:
- Forwards all of its arguments to
batch_fft3d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_fft3d
with f
.
utils of Builder.batch_fft3d
def batch_fft3d(builder)
def batch_fft3d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_fft3d_layer
but:
- Forwards all of its arguments to
batch_fft3d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_fft3d_layer
with f
.
utils of BuilderTree.batch_fft3d_layer
def batch_fft3d_layer(builder, size)
def batch_fft_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_fft_layer
but:
- Forwards all of its arguments to
batch_fft_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_fft_layer
with f
.
utils of BuilderTree.batch_fft_layer
def batch_fft_layer(builder, size)
def batch_ifft(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_ifft
but:
- Forwards all of its arguments to
batch_ifft
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_ifft
with f
.
utils of Builder.batch_ifft
def batch_ifft(builder)
def batch_ifft2d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_ifft2d
but:
- Forwards all of its arguments to
batch_ifft2d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_ifft2d
with f
.
utils of Builder.batch_ifft2d
def batch_ifft2d(builder)
def batch_ifft2d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_ifft2d_layer
but:
- Forwards all of its arguments to
batch_ifft2d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_ifft2d_layer
with f
.
utils of BuilderTree.batch_ifft2d_layer
def batch_ifft2d_layer(builder, size)
def batch_ifft3d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_ifft3d
but:
- Forwards all of its arguments to
batch_ifft3d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_ifft3d
with f
.
utils of Builder.batch_ifft3d
def batch_ifft3d(builder)
def batch_ifft3d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_ifft3d_layer
but:
- Forwards all of its arguments to
batch_ifft3d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_ifft3d_layer
with f
.
utils of BuilderTree.batch_ifft3d_layer
def batch_ifft3d_layer(builder, size)
def batch_ifft_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_ifft_layer
but:
- Forwards all of its arguments to
batch_ifft_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_ifft_layer
with f
.
utils of BuilderTree.batch_ifft_layer
def batch_ifft_layer(builder, size)
def batch_matmul_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_matmul_layer
but:
- Forwards all of its arguments to
batch_matmul_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matmul_layer
with f
.
utils of BuilderTree.batch_matmul_layer
def batch_matmul_layer(builder, size)
def batch_matrix_band_part(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_matrix_band_part
but:
- Forwards all of its arguments to
batch_matrix_band_part
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_band_part
with f
.
utils of Builder.batch_matrix_band_part
def batch_matrix_band_part(builder)
def batch_matrix_band_part_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_matrix_band_part_layer
but:
- Forwards all of its arguments to
batch_matrix_band_part_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_band_part_layer
with f
.
utils of BuilderTree.batch_matrix_band_part_layer
def batch_matrix_band_part_layer(builder, size)
def batch_matrix_determinant(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_matrix_determinant
but:
- Forwards all of its arguments to
batch_matrix_determinant
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_determinant
with f
.
utils of Builder.batch_matrix_determinant
def batch_matrix_determinant(builder)
def batch_matrix_determinant_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_matrix_determinant_layer
but:
- Forwards all of its arguments to
batch_matrix_determinant_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_determinant_layer
with f
.
utils of BuilderTree.batch_matrix_determinant_layer
def batch_matrix_determinant_layer(builder, size)
def batch_matrix_diag(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_matrix_diag
but:
- Forwards all of its arguments to
batch_matrix_diag
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_diag
with f
.
utils of Builder.batch_matrix_diag
def batch_matrix_diag(builder)
def batch_matrix_diag_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_matrix_diag_layer
but:
- Forwards all of its arguments to
batch_matrix_diag_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_diag_layer
with f
.
utils of BuilderTree.batch_matrix_diag_layer
def batch_matrix_diag_layer(builder, size)
def batch_matrix_diag_part(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_matrix_diag_part
but:
- Forwards all of its arguments to
batch_matrix_diag_part
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_diag_part
with f
.
utils of Builder.batch_matrix_diag_part
def batch_matrix_diag_part(builder)
def batch_matrix_diag_part_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_matrix_diag_part_layer
but:
- Forwards all of its arguments to
batch_matrix_diag_part_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_diag_part_layer
with f
.
utils of BuilderTree.batch_matrix_diag_part_layer
def batch_matrix_diag_part_layer(builder, size)
def batch_matrix_inverse(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_matrix_inverse
but:
- Forwards all of its arguments to
batch_matrix_inverse
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_inverse
with f
.
utils of Builder.batch_matrix_inverse
def batch_matrix_inverse(builder)
def batch_matrix_inverse_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_matrix_inverse_layer
but:
- Forwards all of its arguments to
batch_matrix_inverse_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_inverse_layer
with f
.
utils of BuilderTree.batch_matrix_inverse_layer
def batch_matrix_inverse_layer(builder, size)
def batch_matrix_solve(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_matrix_solve
but:
- Forwards all of its arguments to
batch_matrix_solve
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_solve
with f
.
utils of Builder.batch_matrix_solve
def batch_matrix_solve(builder)
def batch_matrix_solve_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_matrix_solve_layer
but:
- Forwards all of its arguments to
batch_matrix_solve_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_solve_layer
with f
.
utils of BuilderTree.batch_matrix_solve_layer
def batch_matrix_solve_layer(builder, size)
def batch_matrix_solve_ls(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_matrix_solve_ls
but:
- Forwards all of its arguments to
batch_matrix_solve_ls
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_solve_ls
with f
.
utils of Builder.batch_matrix_solve_ls
def batch_matrix_solve_ls(builder)
def batch_matrix_solve_ls_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_matrix_solve_ls_layer
but:
- Forwards all of its arguments to
batch_matrix_solve_ls_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_solve_ls_layer
with f
.
utils of BuilderTree.batch_matrix_solve_ls_layer
def batch_matrix_solve_ls_layer(builder, size)
def batch_matrix_triangular_solve(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_matrix_triangular_solve
but:
- Forwards all of its arguments to
batch_matrix_triangular_solve
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_triangular_solve
with f
.
utils of Builder.batch_matrix_triangular_solve
def batch_matrix_triangular_solve(builder)
def batch_matrix_triangular_solve_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_matrix_triangular_solve_layer
but:
- Forwards all of its arguments to
batch_matrix_triangular_solve_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_matrix_triangular_solve_layer
with f
.
utils of BuilderTree.batch_matrix_triangular_solve_layer
def batch_matrix_triangular_solve_layer(builder, size)
def batch_norm_with_global_normalization(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_norm_with_global_normalization
but:
- Forwards all of its arguments to
batch_norm_with_global_normalization
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_norm_with_global_normalization
with f
.
utils of Builder.batch_norm_with_global_normalization
def batch_norm_with_global_normalization(builder)
def batch_norm_with_global_normalization_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_norm_with_global_normalization_layer
but:
- Forwards all of its arguments to
batch_norm_with_global_normalization_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_norm_with_global_normalization_layer
with f
.
utils of BuilderTree.batch_norm_with_global_normalization_layer
def batch_norm_with_global_normalization_layer(builder, size)
def batch_normalization(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_normalization
but:
- Forwards all of its arguments to
batch_normalization
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_normalization
with f
.
utils of Builder.batch_normalization
def batch_normalization(builder)
def batch_normalization_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_normalization_layer
but:
- Forwards all of its arguments to
batch_normalization_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_normalization_layer
with f
.
utils of BuilderTree.batch_normalization_layer
def batch_normalization_layer(builder, size)
def batch_self_adjoint_eig(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_self_adjoint_eig
but:
- Forwards all of its arguments to
batch_self_adjoint_eig
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_self_adjoint_eig
with f
.
utils of Builder.batch_self_adjoint_eig
def batch_self_adjoint_eig(builder)
def batch_self_adjoint_eig_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_self_adjoint_eig_layer
but:
- Forwards all of its arguments to
batch_self_adjoint_eig_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_self_adjoint_eig_layer
with f
.
utils of BuilderTree.batch_self_adjoint_eig_layer
def batch_self_adjoint_eig_layer(builder, size)
def batch_to_space(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.batch_to_space
but:
- Forwards all of its arguments to
batch_to_space
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_to_space
with f
.
utils of Builder.batch_to_space
def batch_to_space(builder)
def batch_to_space_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.batch_to_space_layer
but:
- Forwards all of its arguments to
batch_to_space_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose batch_to_space_layer
with f
.
utils of BuilderTree.batch_to_space_layer
def batch_to_space_layer(builder, size)
def bias_add(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.bias_add
but:
- Forwards all of its arguments to
bias_add
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose bias_add
with f
.
utils of Builder.bias_add
def bias_add(builder)
def bias_add_grad(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.bias_add_grad
but:
- Forwards all of its arguments to
bias_add_grad
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose bias_add_grad
with f
.
utils of Builder.bias_add_grad
def bias_add_grad(builder)
def bias_add_grad_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.bias_add_grad_layer
but:
- Forwards all of its arguments to
bias_add_grad_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose bias_add_grad_layer
with f
.
utils of BuilderTree.bias_add_grad_layer
def bias_add_grad_layer(builder, size)
def bias_add_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.bias_add_layer
but:
- Forwards all of its arguments to
bias_add_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose bias_add_layer
with f
.
utils of BuilderTree.bias_add_layer
def bias_add_layer(builder, size)
def bias_add_v1(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.bias_add_v1
but:
- Forwards all of its arguments to
bias_add_v1
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose bias_add_v1
with f
.
utils of Builder.bias_add_v1
def bias_add_v1(builder)
def bias_add_v1_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.bias_add_v1_layer
but:
- Forwards all of its arguments to
bias_add_v1_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose bias_add_v1_layer
with f
.
utils of BuilderTree.bias_add_v1_layer
def bias_add_v1_layer(builder, size)
def bidirectional_rnn(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.bidirectional_rnn
but:
- Forwards all of its arguments to
bidirectional_rnn
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose bidirectional_rnn
with f
.
utils of Builder.bidirectional_rnn
def bidirectional_rnn(builder)
def bidirectional_rnn_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.bidirectional_rnn_layer
but:
- Forwards all of its arguments to
bidirectional_rnn_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose bidirectional_rnn_layer
with f
.
utils of BuilderTree.bidirectional_rnn_layer
def bidirectional_rnn_layer(builder, size)
def bitcast(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.bitcast
but:
- Forwards all of its arguments to
bitcast
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose bitcast
with f
.
utils of Builder.bitcast
def bitcast(builder)
def bitcast_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.bitcast_layer
but:
- Forwards all of its arguments to
bitcast_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose bitcast_layer
with f
.
utils of BuilderTree.bitcast_layer
def bitcast_layer(builder, size)
def boolean_mask(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.boolean_mask
but:
- Forwards all of its arguments to
boolean_mask
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose boolean_mask
with f
.
utils of Builder.boolean_mask
def boolean_mask(builder)
def boolean_mask_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.boolean_mask_layer
but:
- Forwards all of its arguments to
boolean_mask_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose boolean_mask_layer
with f
.
utils of BuilderTree.boolean_mask_layer
def boolean_mask_layer(builder, size)
def branch(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.branch
but:
- Forwards all of its arguments to
branch
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose branch
with f
.
utils of Builder.branch
def branch(builder, fn)
def builders(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.builders
but:
- Forwards all of its arguments to
builders
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose builders
with f
.
utils of BuilderTree.builders
def builders(self)
def case(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.case
but:
- Forwards all of its arguments to
case
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose case
with f
.
utils of Builder.case
def case(builder)
def case_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.case_layer
but:
- Forwards all of its arguments to
case_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose case_layer
with f
.
utils of BuilderTree.case_layer
def case_layer(builder, size)
def cast(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.cast
but:
- Forwards all of its arguments to
cast
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose cast
with f
.
utils of Builder.cast
def cast(builder)
def cast_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.cast_layer
but:
- Forwards all of its arguments to
cast_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose cast_layer
with f
.
utils of BuilderTree.cast_layer
def cast_layer(builder, size)
def ceil(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.ceil
but:
- Forwards all of its arguments to
ceil
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ceil
with f
.
utils of Builder.ceil
def ceil(builder)
def ceil_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.ceil_layer
but:
- Forwards all of its arguments to
ceil_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ceil_layer
with f
.
utils of BuilderTree.ceil_layer
def ceil_layer(builder, size)
def check_numerics(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.check_numerics
but:
- Forwards all of its arguments to
check_numerics
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose check_numerics
with f
.
utils of Builder.check_numerics
def check_numerics(builder)
def check_numerics_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.check_numerics_layer
but:
- Forwards all of its arguments to
check_numerics_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose check_numerics_layer
with f
.
utils of BuilderTree.check_numerics_layer
def check_numerics_layer(builder, size)
def cholesky(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.cholesky
but:
- Forwards all of its arguments to
cholesky
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose cholesky
with f
.
utils of Builder.cholesky
def cholesky(builder)
def cholesky_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.cholesky_layer
but:
- Forwards all of its arguments to
cholesky_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose cholesky_layer
with f
.
utils of BuilderTree.cholesky_layer
def cholesky_layer(builder, size)
def cholesky_solve(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.cholesky_solve
but:
- Forwards all of its arguments to
cholesky_solve
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose cholesky_solve
with f
.
utils of Builder.cholesky_solve
def cholesky_solve(builder)
def cholesky_solve_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.cholesky_solve_layer
but:
- Forwards all of its arguments to
cholesky_solve_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose cholesky_solve_layer
with f
.
utils of BuilderTree.cholesky_solve_layer
def cholesky_solve_layer(builder, size)
def clip_by_average_norm(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.clip_by_average_norm
but:
- Forwards all of its arguments to
clip_by_average_norm
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose clip_by_average_norm
with f
.
utils of Builder.clip_by_average_norm
def clip_by_average_norm(builder)
def clip_by_average_norm_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.clip_by_average_norm_layer
but:
- Forwards all of its arguments to
clip_by_average_norm_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose clip_by_average_norm_layer
with f
.
utils of BuilderTree.clip_by_average_norm_layer
def clip_by_average_norm_layer(builder, size)
def clip_by_global_norm(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.clip_by_global_norm
but:
- Forwards all of its arguments to
clip_by_global_norm
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose clip_by_global_norm
with f
.
utils of Builder.clip_by_global_norm
def clip_by_global_norm(builder)
def clip_by_global_norm_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.clip_by_global_norm_layer
but:
- Forwards all of its arguments to
clip_by_global_norm_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose clip_by_global_norm_layer
with f
.
utils of BuilderTree.clip_by_global_norm_layer
def clip_by_global_norm_layer(builder, size)
def clip_by_norm(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.clip_by_norm
but:
- Forwards all of its arguments to
clip_by_norm
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose clip_by_norm
with f
.
utils of Builder.clip_by_norm
def clip_by_norm(builder)
def clip_by_norm_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.clip_by_norm_layer
but:
- Forwards all of its arguments to
clip_by_norm_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose clip_by_norm_layer
with f
.
utils of BuilderTree.clip_by_norm_layer
def clip_by_norm_layer(builder, size)
def clip_by_value(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.clip_by_value
but:
- Forwards all of its arguments to
clip_by_value
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose clip_by_value
with f
.
utils of Builder.clip_by_value
def clip_by_value(builder)
def clip_by_value_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.clip_by_value_layer
but:
- Forwards all of its arguments to
clip_by_value_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose clip_by_value_layer
with f
.
utils of BuilderTree.clip_by_value_layer
def clip_by_value_layer(builder, size)
def complex(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.complex
but:
- Forwards all of its arguments to
complex
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose complex
with f
.
utils of Builder.complex
def complex(builder)
def complex_abs(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.complex_abs
but:
- Forwards all of its arguments to
complex_abs
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose complex_abs
with f
.
utils of Builder.complex_abs
def complex_abs(builder)
def complex_abs_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.complex_abs_layer
but:
- Forwards all of its arguments to
complex_abs_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose complex_abs_layer
with f
.
utils of BuilderTree.complex_abs_layer
def complex_abs_layer(builder, size)
def complex_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.complex_layer
but:
- Forwards all of its arguments to
complex_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose complex_layer
with f
.
utils of BuilderTree.complex_layer
def complex_layer(builder, size)
def compose(
app, g)
@tb.immutable def compose(app, g): return Applicative(_compose2(g, app.f))
def compute_accidental_hits(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.compute_accidental_hits
but:
- Forwards all of its arguments to
compute_accidental_hits
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose compute_accidental_hits
with f
.
utils of Builder.compute_accidental_hits
def compute_accidental_hits(builder)
def compute_accidental_hits_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.compute_accidental_hits_layer
but:
- Forwards all of its arguments to
compute_accidental_hits_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose compute_accidental_hits_layer
with f
.
utils of BuilderTree.compute_accidental_hits_layer
def compute_accidental_hits_layer(builder, size)
def concat(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.concat
but:
- Forwards all of its arguments to
concat
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose concat
with f
.
utils of Builder.concat
def concat(builder)
def concat_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.concat_layer
but:
- Forwards all of its arguments to
concat_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose concat_layer
with f
.
utils of BuilderTree.concat_layer
def concat_layer(builder, size)
def cond(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.cond
but:
- Forwards all of its arguments to
cond
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose cond
with f
.
utils of Builder.cond
def cond(builder)
def cond_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.cond_layer
but:
- Forwards all of its arguments to
cond_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose cond_layer
with f
.
utils of BuilderTree.cond_layer
def cond_layer(builder, size)
def conj(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.conj
but:
- Forwards all of its arguments to
conj
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conj
with f
.
utils of Builder.conj
def conj(builder)
def conj_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.conj_layer
but:
- Forwards all of its arguments to
conj_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conj_layer
with f
.
utils of BuilderTree.conj_layer
def conj_layer(builder, size)
def constant(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.constant
but:
- Forwards all of its arguments to
constant
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose constant
with f
.
utils of Builder.constant
def constant(builder)
def constant_initializer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.constant_initializer
but:
- Forwards all of its arguments to
constant_initializer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose constant_initializer
with f
.
utils of Builder.constant_initializer
def constant_initializer(builder)
def constant_initializer_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.constant_initializer_layer
but:
- Forwards all of its arguments to
constant_initializer_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose constant_initializer_layer
with f
.
utils of BuilderTree.constant_initializer_layer
def constant_initializer_layer(builder, size)
def constant_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.constant_layer
but:
- Forwards all of its arguments to
constant_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose constant_layer
with f
.
utils of BuilderTree.constant_layer
def constant_layer(builder, size)
def control_dependencies(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.control_dependencies
but:
- Forwards all of its arguments to
control_dependencies
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose control_dependencies
with f
.
utils of Builder.control_dependencies
def control_dependencies(builder)
def control_dependencies_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.control_dependencies_layer
but:
- Forwards all of its arguments to
control_dependencies_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose control_dependencies_layer
with f
.
utils of BuilderTree.control_dependencies_layer
def control_dependencies_layer(builder, size)
def conv1d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.conv1d
but:
- Forwards all of its arguments to
conv1d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv1d
with f
.
utils of Builder.conv1d
def conv1d(builder)
def conv1d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.conv1d_layer
but:
- Forwards all of its arguments to
conv1d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv1d_layer
with f
.
utils of BuilderTree.conv1d_layer
def conv1d_layer(builder, size)
def conv2d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.conv2d
but:
- Forwards all of its arguments to
conv2d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv2d
with f
.
utils of Builder.conv2d
def conv2d(builder)
def conv2d_backprop_filter(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.conv2d_backprop_filter
but:
- Forwards all of its arguments to
conv2d_backprop_filter
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv2d_backprop_filter
with f
.
utils of Builder.conv2d_backprop_filter
def conv2d_backprop_filter(builder)
def conv2d_backprop_filter_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.conv2d_backprop_filter_layer
but:
- Forwards all of its arguments to
conv2d_backprop_filter_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv2d_backprop_filter_layer
with f
.
utils of BuilderTree.conv2d_backprop_filter_layer
def conv2d_backprop_filter_layer(builder, size)
def conv2d_backprop_input(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.conv2d_backprop_input
but:
- Forwards all of its arguments to
conv2d_backprop_input
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv2d_backprop_input
with f
.
utils of Builder.conv2d_backprop_input
def conv2d_backprop_input(builder)
def conv2d_backprop_input_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.conv2d_backprop_input_layer
but:
- Forwards all of its arguments to
conv2d_backprop_input_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv2d_backprop_input_layer
with f
.
utils of BuilderTree.conv2d_backprop_input_layer
def conv2d_backprop_input_layer(builder, size)
def conv2d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.conv2d_layer
but:
- Forwards all of its arguments to
conv2d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv2d_layer
with f
.
utils of BuilderTree.conv2d_layer
def conv2d_layer(builder, size)
def conv2d_transpose(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.conv2d_transpose
but:
- Forwards all of its arguments to
conv2d_transpose
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv2d_transpose
with f
.
utils of Builder.conv2d_transpose
def conv2d_transpose(builder)
def conv2d_transpose_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.conv2d_transpose_layer
but:
- Forwards all of its arguments to
conv2d_transpose_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv2d_transpose_layer
with f
.
utils of BuilderTree.conv2d_transpose_layer
def conv2d_transpose_layer(builder, size)
def conv3d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.conv3d
but:
- Forwards all of its arguments to
conv3d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv3d
with f
.
utils of Builder.conv3d
def conv3d(builder)
def conv3d_backprop_filter(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.conv3d_backprop_filter
but:
- Forwards all of its arguments to
conv3d_backprop_filter
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv3d_backprop_filter
with f
.
utils of Builder.conv3d_backprop_filter
def conv3d_backprop_filter(builder)
def conv3d_backprop_filter_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.conv3d_backprop_filter_layer
but:
- Forwards all of its arguments to
conv3d_backprop_filter_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv3d_backprop_filter_layer
with f
.
utils of BuilderTree.conv3d_backprop_filter_layer
def conv3d_backprop_filter_layer(builder, size)
def conv3d_backprop_input(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.conv3d_backprop_input
but:
- Forwards all of its arguments to
conv3d_backprop_input
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv3d_backprop_input
with f
.
utils of Builder.conv3d_backprop_input
def conv3d_backprop_input(builder)
def conv3d_backprop_input_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.conv3d_backprop_input_layer
but:
- Forwards all of its arguments to
conv3d_backprop_input_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv3d_backprop_input_layer
with f
.
utils of BuilderTree.conv3d_backprop_input_layer
def conv3d_backprop_input_layer(builder, size)
def conv3d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.conv3d_layer
but:
- Forwards all of its arguments to
conv3d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose conv3d_layer
with f
.
utils of BuilderTree.conv3d_layer
def conv3d_layer(builder, size)
def convert_to_tensor(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.convert_to_tensor
but:
- Forwards all of its arguments to
convert_to_tensor
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose convert_to_tensor
with f
.
utils of Builder.convert_to_tensor
def convert_to_tensor(builder)
def convert_to_tensor_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.convert_to_tensor_layer
but:
- Forwards all of its arguments to
convert_to_tensor_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose convert_to_tensor_layer
with f
.
utils of BuilderTree.convert_to_tensor_layer
def convert_to_tensor_layer(builder, size)
def convert_to_tensor_or_indexed_slices(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.convert_to_tensor_or_indexed_slices
but:
- Forwards all of its arguments to
convert_to_tensor_or_indexed_slices
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose convert_to_tensor_or_indexed_slices
with f
.
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(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.convert_to_tensor_or_indexed_slices_layer
but:
- Forwards all of its arguments to
convert_to_tensor_or_indexed_slices_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose convert_to_tensor_or_indexed_slices_layer
with f
.
utils of BuilderTree.convert_to_tensor_or_indexed_slices_layer
def convert_to_tensor_or_indexed_slices_layer(builder, size)
def convolution2d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.convolution2d
but:
- Forwards all of its arguments to
convolution2d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose convolution2d
with f
.
utils of Builder.convolution2d
def convolution2d(builder)
def copy(
self)
Returns a compy of the applicative
def copy(self): """Returns a compy of the applicative""" return Applicative(self.f)
def cos(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.cos
but:
- Forwards all of its arguments to
cos
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose cos
with f
.
utils of Builder.cos
def cos(builder)
def cos_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.cos_layer
but:
- Forwards all of its arguments to
cos_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose cos_layer
with f
.
utils of BuilderTree.cos_layer
def cos_layer(builder, size)
def count_up_to(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.count_up_to
but:
- Forwards all of its arguments to
count_up_to
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose count_up_to
with f
.
utils of Builder.count_up_to
def count_up_to(builder)
def count_up_to_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.count_up_to_layer
but:
- Forwards all of its arguments to
count_up_to_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose count_up_to_layer
with f
.
utils of BuilderTree.count_up_to_layer
def count_up_to_layer(builder, size)
def create_partitioned_variables(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.create_partitioned_variables
but:
- Forwards all of its arguments to
create_partitioned_variables
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose create_partitioned_variables
with f
.
utils of Builder.create_partitioned_variables
def create_partitioned_variables(builder)
def create_partitioned_variables_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.create_partitioned_variables_layer
but:
- Forwards all of its arguments to
create_partitioned_variables_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose create_partitioned_variables_layer
with f
.
utils of BuilderTree.create_partitioned_variables_layer
def create_partitioned_variables_layer(builder, size)
def cross(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.cross
but:
- Forwards all of its arguments to
cross
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose cross
with f
.
utils of Builder.cross
def cross(builder)
def cross_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.cross_layer
but:
- Forwards all of its arguments to
cross_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose cross_layer
with f
.
utils of BuilderTree.cross_layer
def cross_layer(builder, size)
def decode_csv(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.decode_csv
but:
- Forwards all of its arguments to
decode_csv
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose decode_csv
with f
.
utils of Builder.decode_csv
def decode_csv(builder)
def decode_csv_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.decode_csv_layer
but:
- Forwards all of its arguments to
decode_csv_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose decode_csv_layer
with f
.
utils of BuilderTree.decode_csv_layer
def decode_csv_layer(builder, size)
def decode_json_example(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.decode_json_example
but:
- Forwards all of its arguments to
decode_json_example
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose decode_json_example
with f
.
utils of Builder.decode_json_example
def decode_json_example(builder)
def decode_json_example_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.decode_json_example_layer
but:
- Forwards all of its arguments to
decode_json_example_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose decode_json_example_layer
with f
.
utils of BuilderTree.decode_json_example_layer
def decode_json_example_layer(builder, size)
def decode_raw(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.decode_raw
but:
- Forwards all of its arguments to
decode_raw
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose decode_raw
with f
.
utils of Builder.decode_raw
def decode_raw(builder)
def decode_raw_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.decode_raw_layer
but:
- Forwards all of its arguments to
decode_raw_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose decode_raw_layer
with f
.
utils of BuilderTree.decode_raw_layer
def decode_raw_layer(builder, size)
def delete_session_tensor(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.delete_session_tensor
but:
- Forwards all of its arguments to
delete_session_tensor
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose delete_session_tensor
with f
.
utils of Builder.delete_session_tensor
def delete_session_tensor(builder)
def delete_session_tensor_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.delete_session_tensor_layer
but:
- Forwards all of its arguments to
delete_session_tensor_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose delete_session_tensor_layer
with f
.
utils of BuilderTree.delete_session_tensor_layer
def delete_session_tensor_layer(builder, size)
def depth_to_space(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.depth_to_space
but:
- Forwards all of its arguments to
depth_to_space
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose depth_to_space
with f
.
utils of Builder.depth_to_space
def depth_to_space(builder)
def depth_to_space_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.depth_to_space_layer
but:
- Forwards all of its arguments to
depth_to_space_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose depth_to_space_layer
with f
.
utils of BuilderTree.depth_to_space_layer
def depth_to_space_layer(builder, size)
def depthwise_conv2d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.depthwise_conv2d
but:
- Forwards all of its arguments to
depthwise_conv2d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose depthwise_conv2d
with f
.
utils of Builder.depthwise_conv2d
def depthwise_conv2d(builder)
def depthwise_conv2d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.depthwise_conv2d_layer
but:
- Forwards all of its arguments to
depthwise_conv2d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose depthwise_conv2d_layer
with f
.
utils of BuilderTree.depthwise_conv2d_layer
def depthwise_conv2d_layer(builder, size)
def depthwise_conv2d_native(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.depthwise_conv2d_native
but:
- Forwards all of its arguments to
depthwise_conv2d_native
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose depthwise_conv2d_native
with f
.
utils of Builder.depthwise_conv2d_native
def depthwise_conv2d_native(builder)
def depthwise_conv2d_native_backprop_filter(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.depthwise_conv2d_native_backprop_filter
but:
- Forwards all of its arguments to
depthwise_conv2d_native_backprop_filter
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose depthwise_conv2d_native_backprop_filter
with f
.
utils of Builder.depthwise_conv2d_native_backprop_filter
def depthwise_conv2d_native_backprop_filter(builder)
def depthwise_conv2d_native_backprop_filter_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.depthwise_conv2d_native_backprop_filter_layer
but:
- Forwards all of its arguments to
depthwise_conv2d_native_backprop_filter_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose depthwise_conv2d_native_backprop_filter_layer
with f
.
utils of BuilderTree.depthwise_conv2d_native_backprop_filter_layer
def depthwise_conv2d_native_backprop_filter_layer(builder, size)
def depthwise_conv2d_native_backprop_input(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.depthwise_conv2d_native_backprop_input
but:
- Forwards all of its arguments to
depthwise_conv2d_native_backprop_input
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose depthwise_conv2d_native_backprop_input
with f
.
utils of Builder.depthwise_conv2d_native_backprop_input
def depthwise_conv2d_native_backprop_input(builder)
def depthwise_conv2d_native_backprop_input_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.depthwise_conv2d_native_backprop_input_layer
but:
- Forwards all of its arguments to
depthwise_conv2d_native_backprop_input_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose depthwise_conv2d_native_backprop_input_layer
with f
.
utils of BuilderTree.depthwise_conv2d_native_backprop_input_layer
def depthwise_conv2d_native_backprop_input_layer(builder, size)
def depthwise_conv2d_native_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.depthwise_conv2d_native_layer
but:
- Forwards all of its arguments to
depthwise_conv2d_native_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose depthwise_conv2d_native_layer
with f
.
utils of BuilderTree.depthwise_conv2d_native_layer
def depthwise_conv2d_native_layer(builder, size)
def deserialize_many_sparse(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.deserialize_many_sparse
but:
- Forwards all of its arguments to
deserialize_many_sparse
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose deserialize_many_sparse
with f
.
utils of Builder.deserialize_many_sparse
def deserialize_many_sparse(builder)
def deserialize_many_sparse_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.deserialize_many_sparse_layer
but:
- Forwards all of its arguments to
deserialize_many_sparse_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose deserialize_many_sparse_layer
with f
.
utils of BuilderTree.deserialize_many_sparse_layer
def deserialize_many_sparse_layer(builder, size)
def device(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.device
but:
- Forwards all of its arguments to
device
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose device
with f
.
utils of Builder.device
def device(builder)
def device_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.device_layer
but:
- Forwards all of its arguments to
device_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose device_layer
with f
.
utils of BuilderTree.device_layer
def device_layer(builder, size)
def diag(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.diag
but:
- Forwards all of its arguments to
diag
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose diag
with f
.
utils of Builder.diag
def diag(builder)
def diag_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.diag_layer
but:
- Forwards all of its arguments to
diag_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose diag_layer
with f
.
utils of BuilderTree.diag_layer
def diag_layer(builder, size)
def diag_part(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.diag_part
but:
- Forwards all of its arguments to
diag_part
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose diag_part
with f
.
utils of Builder.diag_part
def diag_part(builder)
def diag_part_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.diag_part_layer
but:
- Forwards all of its arguments to
diag_part_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose diag_part_layer
with f
.
utils of BuilderTree.diag_part_layer
def diag_part_layer(builder, size)
def digamma(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.digamma
but:
- Forwards all of its arguments to
digamma
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose digamma
with f
.
utils of Builder.digamma
def digamma(builder)
def digamma_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.digamma_layer
but:
- Forwards all of its arguments to
digamma_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose digamma_layer
with f
.
utils of BuilderTree.digamma_layer
def digamma_layer(builder, size)
def dilation2d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.dilation2d
but:
- Forwards all of its arguments to
dilation2d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dilation2d
with f
.
utils of Builder.dilation2d
def dilation2d(builder)
def dilation2d_backprop_filter(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.dilation2d_backprop_filter
but:
- Forwards all of its arguments to
dilation2d_backprop_filter
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dilation2d_backprop_filter
with f
.
utils of Builder.dilation2d_backprop_filter
def dilation2d_backprop_filter(builder)
def dilation2d_backprop_filter_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.dilation2d_backprop_filter_layer
but:
- Forwards all of its arguments to
dilation2d_backprop_filter_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dilation2d_backprop_filter_layer
with f
.
utils of BuilderTree.dilation2d_backprop_filter_layer
def dilation2d_backprop_filter_layer(builder, size)
def dilation2d_backprop_input(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.dilation2d_backprop_input
but:
- Forwards all of its arguments to
dilation2d_backprop_input
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dilation2d_backprop_input
with f
.
utils of Builder.dilation2d_backprop_input
def dilation2d_backprop_input(builder)
def dilation2d_backprop_input_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.dilation2d_backprop_input_layer
but:
- Forwards all of its arguments to
dilation2d_backprop_input_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dilation2d_backprop_input_layer
with f
.
utils of BuilderTree.dilation2d_backprop_input_layer
def dilation2d_backprop_input_layer(builder, size)
def dilation2d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.dilation2d_layer
but:
- Forwards all of its arguments to
dilation2d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dilation2d_layer
with f
.
utils of BuilderTree.dilation2d_layer
def dilation2d_layer(builder, size)
def div(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.div
but:
- Forwards all of its arguments to
div
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose div
with f
.
utils of Builder.div
def div(builder)
def div_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.div_layer
but:
- Forwards all of its arguments to
div_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose div_layer
with f
.
utils of BuilderTree.div_layer
def div_layer(builder, size)
def dropout(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.dropout
but:
- Forwards all of its arguments to
dropout
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dropout
with f
.
utils of Builder.dropout
def dropout(builder)
def dropout_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.dropout_layer
but:
- Forwards all of its arguments to
dropout_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dropout_layer
with f
.
utils of BuilderTree.dropout_layer
def dropout_layer(builder, size)
def dynamic_partition(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.dynamic_partition
but:
- Forwards all of its arguments to
dynamic_partition
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dynamic_partition
with f
.
utils of Builder.dynamic_partition
def dynamic_partition(builder)
def dynamic_partition_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.dynamic_partition_layer
but:
- Forwards all of its arguments to
dynamic_partition_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dynamic_partition_layer
with f
.
utils of BuilderTree.dynamic_partition_layer
def dynamic_partition_layer(builder, size)
def dynamic_rnn(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.dynamic_rnn
but:
- Forwards all of its arguments to
dynamic_rnn
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dynamic_rnn
with f
.
utils of Builder.dynamic_rnn
def dynamic_rnn(builder)
def dynamic_rnn_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.dynamic_rnn_layer
but:
- Forwards all of its arguments to
dynamic_rnn_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dynamic_rnn_layer
with f
.
utils of BuilderTree.dynamic_rnn_layer
def dynamic_rnn_layer(builder, size)
def dynamic_stitch(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.dynamic_stitch
but:
- Forwards all of its arguments to
dynamic_stitch
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dynamic_stitch
with f
.
utils of Builder.dynamic_stitch
def dynamic_stitch(builder)
def dynamic_stitch_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.dynamic_stitch_layer
but:
- Forwards all of its arguments to
dynamic_stitch_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose dynamic_stitch_layer
with f
.
utils of BuilderTree.dynamic_stitch_layer
def dynamic_stitch_layer(builder, size)
def edit_distance(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.edit_distance
but:
- Forwards all of its arguments to
edit_distance
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose edit_distance
with f
.
utils of Builder.edit_distance
def edit_distance(builder)
def edit_distance_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.edit_distance_layer
but:
- Forwards all of its arguments to
edit_distance_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose edit_distance_layer
with f
.
utils of BuilderTree.edit_distance_layer
def edit_distance_layer(builder, size)
def elu(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.elu
but:
- Forwards all of its arguments to
elu
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose elu
with f
.
utils of Builder.elu
def elu(builder)
def elu_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.elu_layer
but:
- Forwards all of its arguments to
elu_layer
, this returns a functiong
. - Applies
compose
overg