, this roughly computes the compositiong
off
.
So the result of this method is compose elu_layer
with f
.
utils of BuilderTree.elu_layer
def elu_layer(builder, size)
def embedding_lookup(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.embedding_lookup
but:
- Forwards all of its arguments to
embedding_lookup
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose embedding_lookup
with f
.
utils of Builder.embedding_lookup
def embedding_lookup(builder)
def embedding_lookup_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.embedding_lookup_layer
but:
- Forwards all of its arguments to
embedding_lookup_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose embedding_lookup_layer
with f
.
utils of BuilderTree.embedding_lookup_layer
def embedding_lookup_layer(builder, size)
def embedding_lookup_sparse(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.embedding_lookup_sparse
but:
- Forwards all of its arguments to
embedding_lookup_sparse
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose embedding_lookup_sparse
with f
.
utils of Builder.embedding_lookup_sparse
def embedding_lookup_sparse(builder)
def embedding_lookup_sparse_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.embedding_lookup_sparse_layer
but:
- Forwards all of its arguments to
embedding_lookup_sparse_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose embedding_lookup_sparse_layer
with f
.
utils of BuilderTree.embedding_lookup_sparse_layer
def embedding_lookup_sparse_layer(builder, size)
def equal(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.equal
but:
- Forwards all of its arguments to
equal
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose equal
with f
.
utils of Builder.equal
def equal(builder)
def equal_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.equal_layer
but:
- Forwards all of its arguments to
equal_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose equal_layer
with f
.
utils of BuilderTree.equal_layer
def equal_layer(builder, size)
def erf(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.erf
but:
- Forwards all of its arguments to
erf
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose erf
with f
.
utils of Builder.erf
def erf(builder)
def erf_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.erf_layer
but:
- Forwards all of its arguments to
erf_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose erf_layer
with f
.
utils of BuilderTree.erf_layer
def erf_layer(builder, size)
def erfc(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.erfc
but:
- Forwards all of its arguments to
erfc
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose erfc
with f
.
utils of Builder.erfc
def erfc(builder)
def erfc_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.erfc_layer
but:
- Forwards all of its arguments to
erfc_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose erfc_layer
with f
.
utils of BuilderTree.erfc_layer
def erfc_layer(builder, size)
def erosion2d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.erosion2d
but:
- Forwards all of its arguments to
erosion2d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose erosion2d
with f
.
utils of Builder.erosion2d
def erosion2d(builder)
def erosion2d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.erosion2d_layer
but:
- Forwards all of its arguments to
erosion2d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose erosion2d_layer
with f
.
utils of BuilderTree.erosion2d_layer
def erosion2d_layer(builder, size)
def exp(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.exp
but:
- Forwards all of its arguments to
exp
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose exp
with f
.
utils of Builder.exp
def exp(builder)
def exp_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.exp_layer
but:
- Forwards all of its arguments to
exp_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose exp_layer
with f
.
utils of BuilderTree.exp_layer
def exp_layer(builder, size)
def expand_dims(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.expand_dims
but:
- Forwards all of its arguments to
expand_dims
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose expand_dims
with f
.
utils of Builder.expand_dims
def expand_dims(builder)
def expand_dims_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.expand_dims_layer
but:
- Forwards all of its arguments to
expand_dims_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose expand_dims_layer
with f
.
utils of BuilderTree.expand_dims_layer
def expand_dims_layer(builder, size)
def extract(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.extract
but:
- Forwards all of its arguments to
extract
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose extract
with f
.
utils of BuilderTree.extract
def extract(tree, fn)
def extract_image_patches(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.extract_image_patches
but:
- Forwards all of its arguments to
extract_image_patches
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose extract_image_patches
with f
.
utils of Builder.extract_image_patches
def extract_image_patches(builder)
def extract_image_patches_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.extract_image_patches_layer
but:
- Forwards all of its arguments to
extract_image_patches_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose extract_image_patches_layer
with f
.
utils of BuilderTree.extract_image_patches_layer
def extract_image_patches_layer(builder, size)
def fft(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.fft
but:
- Forwards all of its arguments to
fft
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose fft
with f
.
utils of Builder.fft
def fft(builder)
def fft2d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.fft2d
but:
- Forwards all of its arguments to
fft2d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose fft2d
with f
.
utils of Builder.fft2d
def fft2d(builder)
def fft2d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.fft2d_layer
but:
- Forwards all of its arguments to
fft2d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose fft2d_layer
with f
.
utils of BuilderTree.fft2d_layer
def fft2d_layer(builder, size)
def fft3d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.fft3d
but:
- Forwards all of its arguments to
fft3d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose fft3d
with f
.
utils of Builder.fft3d
def fft3d(builder)
def fft3d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.fft3d_layer
but:
- Forwards all of its arguments to
fft3d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose fft3d_layer
with f
.
utils of BuilderTree.fft3d_layer
def fft3d_layer(builder, size)
def fft_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.fft_layer
but:
- Forwards all of its arguments to
fft_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose fft_layer
with f
.
utils of BuilderTree.fft_layer
def fft_layer(builder, size)
def fill(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.fill
but:
- Forwards all of its arguments to
fill
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose fill
with f
.
utils of Builder.fill
def fill(builder)
def fill_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.fill_layer
but:
- Forwards all of its arguments to
fill_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose fill_layer
with f
.
utils of BuilderTree.fill_layer
def fill_layer(builder, size)
def fixed_unigram_candidate_sampler(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.fixed_unigram_candidate_sampler
but:
- Forwards all of its arguments to
fixed_unigram_candidate_sampler
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose fixed_unigram_candidate_sampler
with f
.
utils of Builder.fixed_unigram_candidate_sampler
def fixed_unigram_candidate_sampler(builder)
def fixed_unigram_candidate_sampler_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.fixed_unigram_candidate_sampler_layer
but:
- Forwards all of its arguments to
fixed_unigram_candidate_sampler_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose fixed_unigram_candidate_sampler_layer
with f
.
utils of BuilderTree.fixed_unigram_candidate_sampler_layer
def fixed_unigram_candidate_sampler_layer(builder, size)
def floor(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.floor
but:
- Forwards all of its arguments to
floor
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose floor
with f
.
utils of Builder.floor
def floor(builder)
def floor_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.floor_layer
but:
- Forwards all of its arguments to
floor_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose floor_layer
with f
.
utils of BuilderTree.floor_layer
def floor_layer(builder, size)
def floordiv(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.floordiv
but:
- Forwards all of its arguments to
floordiv
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose floordiv
with f
.
utils of Builder.floordiv
def floordiv(builder)
def floordiv_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.floordiv_layer
but:
- Forwards all of its arguments to
floordiv_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose floordiv_layer
with f
.
utils of BuilderTree.floordiv_layer
def floordiv_layer(builder, size)
def foldl(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.foldl
but:
- Forwards all of its arguments to
foldl
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose foldl
with f
.
utils of Builder.foldl
def foldl(builder)
def foldl_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.foldl_layer
but:
- Forwards all of its arguments to
foldl_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose foldl_layer
with f
.
utils of BuilderTree.foldl_layer
def foldl_layer(builder, size)
def foldr(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.foldr
but:
- Forwards all of its arguments to
foldr
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose foldr
with f
.
utils of Builder.foldr
def foldr(builder)
def foldr_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.foldr_layer
but:
- Forwards all of its arguments to
foldr_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose foldr_layer
with f
.
utils of BuilderTree.foldr_layer
def foldr_layer(builder, size)
def fully_connected(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.fully_connected
but:
- Forwards all of its arguments to
fully_connected
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose fully_connected
with f
.
utils of BuilderTree.fully_connected
def fully_connected(tree, size)
def gather(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.gather
but:
- Forwards all of its arguments to
gather
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose gather
with f
.
utils of Builder.gather
def gather(builder)
def gather_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.gather_layer
but:
- Forwards all of its arguments to
gather_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose gather_layer
with f
.
utils of BuilderTree.gather_layer
def gather_layer(builder, size)
def gather_nd(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.gather_nd
but:
- Forwards all of its arguments to
gather_nd
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose gather_nd
with f
.
utils of Builder.gather_nd
def gather_nd(builder)
def gather_nd_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.gather_nd_layer
but:
- Forwards all of its arguments to
gather_nd_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose gather_nd_layer
with f
.
utils of BuilderTree.gather_nd_layer
def gather_nd_layer(builder, size)
def get_collection(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.get_collection
but:
- Forwards all of its arguments to
get_collection
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_collection
with f
.
utils of Builder.get_collection
def get_collection(builder)
def get_collection_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.get_collection_layer
but:
- Forwards all of its arguments to
get_collection_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_collection_layer
with f
.
utils of BuilderTree.get_collection_layer
def get_collection_layer(builder, size)
def get_collection_ref(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.get_collection_ref
but:
- Forwards all of its arguments to
get_collection_ref
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_collection_ref
with f
.
utils of Builder.get_collection_ref
def get_collection_ref(builder)
def get_collection_ref_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.get_collection_ref_layer
but:
- Forwards all of its arguments to
get_collection_ref_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_collection_ref_layer
with f
.
utils of BuilderTree.get_collection_ref_layer
def get_collection_ref_layer(builder, size)
def get_default_graph(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.get_default_graph
but:
- Forwards all of its arguments to
get_default_graph
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_default_graph
with f
.
utils of Builder.get_default_graph
def get_default_graph(builder)
def get_default_graph_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.get_default_graph_layer
but:
- Forwards all of its arguments to
get_default_graph_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_default_graph_layer
with f
.
utils of BuilderTree.get_default_graph_layer
def get_default_graph_layer(builder, size)
def get_default_session(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.get_default_session
but:
- Forwards all of its arguments to
get_default_session
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_default_session
with f
.
utils of Builder.get_default_session
def get_default_session(builder)
def get_default_session_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.get_default_session_layer
but:
- Forwards all of its arguments to
get_default_session_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_default_session_layer
with f
.
utils of BuilderTree.get_default_session_layer
def get_default_session_layer(builder, size)
def get_seed(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.get_seed
but:
- Forwards all of its arguments to
get_seed
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_seed
with f
.
utils of Builder.get_seed
def get_seed(builder)
def get_seed_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.get_seed_layer
but:
- Forwards all of its arguments to
get_seed_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_seed_layer
with f
.
utils of BuilderTree.get_seed_layer
def get_seed_layer(builder, size)
def get_session_handle(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.get_session_handle
but:
- Forwards all of its arguments to
get_session_handle
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_session_handle
with f
.
utils of Builder.get_session_handle
def get_session_handle(builder)
def get_session_handle_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.get_session_handle_layer
but:
- Forwards all of its arguments to
get_session_handle_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_session_handle_layer
with f
.
utils of BuilderTree.get_session_handle_layer
def get_session_handle_layer(builder, size)
def get_session_tensor(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.get_session_tensor
but:
- Forwards all of its arguments to
get_session_tensor
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_session_tensor
with f
.
utils of Builder.get_session_tensor
def get_session_tensor(builder)
def get_session_tensor_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.get_session_tensor_layer
but:
- Forwards all of its arguments to
get_session_tensor_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_session_tensor_layer
with f
.
utils of BuilderTree.get_session_tensor_layer
def get_session_tensor_layer(builder, size)
def get_variable(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.get_variable
but:
- Forwards all of its arguments to
get_variable
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_variable
with f
.
utils of Builder.get_variable
def get_variable(builder)
def get_variable_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.get_variable_layer
but:
- Forwards all of its arguments to
get_variable_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_variable_layer
with f
.
utils of BuilderTree.get_variable_layer
def get_variable_layer(builder, size)
def get_variable_scope(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.get_variable_scope
but:
- Forwards all of its arguments to
get_variable_scope
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_variable_scope
with f
.
utils of Builder.get_variable_scope
def get_variable_scope(builder)
def get_variable_scope_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.get_variable_scope_layer
but:
- Forwards all of its arguments to
get_variable_scope_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose get_variable_scope_layer
with f
.
utils of BuilderTree.get_variable_scope_layer
def get_variable_scope_layer(builder, size)
def global_norm(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.global_norm
but:
- Forwards all of its arguments to
global_norm
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose global_norm
with f
.
utils of Builder.global_norm
def global_norm(builder)
def global_norm_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.global_norm_layer
but:
- Forwards all of its arguments to
global_norm_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose global_norm_layer
with f
.
utils of BuilderTree.global_norm_layer
def global_norm_layer(builder, size)
def gradients(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.gradients
but:
- Forwards all of its arguments to
gradients
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose gradients
with f
.
utils of Builder.gradients
def gradients(builder)
def gradients_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.gradients_layer
but:
- Forwards all of its arguments to
gradients_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose gradients_layer
with f
.
utils of BuilderTree.gradients_layer
def gradients_layer(builder, size)
def greater(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.greater
but:
- Forwards all of its arguments to
greater
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose greater
with f
.
utils of Builder.greater
def greater(builder)
def greater_equal(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.greater_equal
but:
- Forwards all of its arguments to
greater_equal
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose greater_equal
with f
.
utils of Builder.greater_equal
def greater_equal(builder)
def greater_equal_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.greater_equal_layer
but:
- Forwards all of its arguments to
greater_equal_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose greater_equal_layer
with f
.
utils of BuilderTree.greater_equal_layer
def greater_equal_layer(builder, size)
def greater_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.greater_layer
but:
- Forwards all of its arguments to
greater_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose greater_layer
with f
.
utils of BuilderTree.greater_layer
def greater_layer(builder, size)
def group(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.group
but:
- Forwards all of its arguments to
group
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose group
with f
.
utils of Builder.group
def group(builder)
def group_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.group_layer
but:
- Forwards all of its arguments to
group_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose group_layer
with f
.
utils of BuilderTree.group_layer
def group_layer(builder, size)
def histogram_fixed_width(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.histogram_fixed_width
but:
- Forwards all of its arguments to
histogram_fixed_width
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose histogram_fixed_width
with f
.
utils of Builder.histogram_fixed_width
def histogram_fixed_width(builder)
def histogram_fixed_width_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.histogram_fixed_width_layer
but:
- Forwards all of its arguments to
histogram_fixed_width_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose histogram_fixed_width_layer
with f
.
utils of BuilderTree.histogram_fixed_width_layer
def histogram_fixed_width_layer(builder, size)
def histogram_summary(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.histogram_summary
but:
- Forwards all of its arguments to
histogram_summary
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose histogram_summary
with f
.
utils of Builder.histogram_summary
def histogram_summary(builder)
def histogram_summary_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.histogram_summary_layer
but:
- Forwards all of its arguments to
histogram_summary_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose histogram_summary_layer
with f
.
utils of BuilderTree.histogram_summary_layer
def histogram_summary_layer(builder, size)
def identity(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.identity
but:
- Forwards all of its arguments to
identity
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose identity
with f
.
utils of Builder.identity
def identity(builder)
def identity_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.identity_layer
but:
- Forwards all of its arguments to
identity_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose identity_layer
with f
.
utils of BuilderTree.identity_layer
def identity_layer(builder, size)
def ifft(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.ifft
but:
- Forwards all of its arguments to
ifft
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ifft
with f
.
utils of Builder.ifft
def ifft(builder)
def ifft2d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.ifft2d
but:
- Forwards all of its arguments to
ifft2d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ifft2d
with f
.
utils of Builder.ifft2d
def ifft2d(builder)
def ifft2d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.ifft2d_layer
but:
- Forwards all of its arguments to
ifft2d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ifft2d_layer
with f
.
utils of BuilderTree.ifft2d_layer
def ifft2d_layer(builder, size)
def ifft3d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.ifft3d
but:
- Forwards all of its arguments to
ifft3d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ifft3d
with f
.
utils of Builder.ifft3d
def ifft3d(builder)
def ifft3d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.ifft3d_layer
but:
- Forwards all of its arguments to
ifft3d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ifft3d_layer
with f
.
utils of BuilderTree.ifft3d_layer
def ifft3d_layer(builder, size)
def ifft_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.ifft_layer
but:
- Forwards all of its arguments to
ifft_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ifft_layer
with f
.
utils of BuilderTree.ifft_layer
def ifft_layer(builder, size)
def igamma(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.igamma
but:
- Forwards all of its arguments to
igamma
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose igamma
with f
.
utils of Builder.igamma
def igamma(builder)
def igamma_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.igamma_layer
but:
- Forwards all of its arguments to
igamma_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose igamma_layer
with f
.
utils of BuilderTree.igamma_layer
def igamma_layer(builder, size)
def igammac(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.igammac
but:
- Forwards all of its arguments to
igammac
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose igammac
with f
.
utils of Builder.igammac
def igammac(builder)
def igammac_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.igammac_layer
but:
- Forwards all of its arguments to
igammac_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose igammac_layer
with f
.
utils of BuilderTree.igammac_layer
def igammac_layer(builder, size)
def imag(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.imag
but:
- Forwards all of its arguments to
imag
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose imag
with f
.
utils of Builder.imag
def imag(builder)
def imag_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.imag_layer
but:
- Forwards all of its arguments to
imag_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose imag_layer
with f
.
utils of BuilderTree.imag_layer
def imag_layer(builder, size)
def image_summary(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.image_summary
but:
- Forwards all of its arguments to
image_summary
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose image_summary
with f
.
utils of Builder.image_summary
def image_summary(builder)
def image_summary_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.image_summary_layer
but:
- Forwards all of its arguments to
image_summary_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose image_summary_layer
with f
.
utils of BuilderTree.image_summary_layer
def image_summary_layer(builder, size)
def import_graph_def(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.import_graph_def
but:
- Forwards all of its arguments to
import_graph_def
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose import_graph_def
with f
.
utils of Builder.import_graph_def
def import_graph_def(builder)
def import_graph_def_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.import_graph_def_layer
but:
- Forwards all of its arguments to
import_graph_def_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose import_graph_def_layer
with f
.
utils of BuilderTree.import_graph_def_layer
def import_graph_def_layer(builder, size)
def in_top_k(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.in_top_k
but:
- Forwards all of its arguments to
in_top_k
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose in_top_k
with f
.
utils of Builder.in_top_k
def in_top_k(builder)
def in_top_k_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.in_top_k_layer
but:
- Forwards all of its arguments to
in_top_k_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose in_top_k_layer
with f
.
utils of BuilderTree.in_top_k_layer
def in_top_k_layer(builder, size)
def initialize_all_tables(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.initialize_all_tables
but:
- Forwards all of its arguments to
initialize_all_tables
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose initialize_all_tables
with f
.
utils of Builder.initialize_all_tables
def initialize_all_tables(builder)
def initialize_all_tables_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.initialize_all_tables_layer
but:
- Forwards all of its arguments to
initialize_all_tables_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose initialize_all_tables_layer
with f
.
utils of BuilderTree.initialize_all_tables_layer
def initialize_all_tables_layer(builder, size)
def initialize_all_variables(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.initialize_all_variables
but:
- Forwards all of its arguments to
initialize_all_variables
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose initialize_all_variables
with f
.
utils of Builder.initialize_all_variables
def initialize_all_variables(builder)
def initialize_all_variables_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.initialize_all_variables_layer
but:
- Forwards all of its arguments to
initialize_all_variables_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose initialize_all_variables_layer
with f
.
utils of BuilderTree.initialize_all_variables_layer
def initialize_all_variables_layer(builder, size)
def initialize_local_variables(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.initialize_local_variables
but:
- Forwards all of its arguments to
initialize_local_variables
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose initialize_local_variables
with f
.
utils of Builder.initialize_local_variables
def initialize_local_variables(builder)
def initialize_local_variables_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.initialize_local_variables_layer
but:
- Forwards all of its arguments to
initialize_local_variables_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose initialize_local_variables_layer
with f
.
utils of BuilderTree.initialize_local_variables_layer
def initialize_local_variables_layer(builder, size)
def initialize_variables(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.initialize_variables
but:
- Forwards all of its arguments to
initialize_variables
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose initialize_variables
with f
.
utils of Builder.initialize_variables
def initialize_variables(builder)
def initialize_variables_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.initialize_variables_layer
but:
- Forwards all of its arguments to
initialize_variables_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose initialize_variables_layer
with f
.
utils of BuilderTree.initialize_variables_layer
def initialize_variables_layer(builder, size)
def inv(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.inv
but:
- Forwards all of its arguments to
inv
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose inv
with f
.
utils of Builder.inv
def inv(builder)
def inv_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.inv_layer
but:
- Forwards all of its arguments to
inv_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose inv_layer
with f
.
utils of BuilderTree.inv_layer
def inv_layer(builder, size)
def invert_permutation(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.invert_permutation
but:
- Forwards all of its arguments to
invert_permutation
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose invert_permutation
with f
.
utils of Builder.invert_permutation
def invert_permutation(builder)
def invert_permutation_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.invert_permutation_layer
but:
- Forwards all of its arguments to
invert_permutation_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose invert_permutation_layer
with f
.
utils of BuilderTree.invert_permutation_layer
def invert_permutation_layer(builder, size)
def is_finite(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.is_finite
but:
- Forwards all of its arguments to
is_finite
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_finite
with f
.
utils of Builder.is_finite
def is_finite(builder)
def is_finite_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.is_finite_layer
but:
- Forwards all of its arguments to
is_finite_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_finite_layer
with f
.
utils of BuilderTree.is_finite_layer
def is_finite_layer(builder, size)
def is_inf(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.is_inf
but:
- Forwards all of its arguments to
is_inf
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_inf
with f
.
utils of Builder.is_inf
def is_inf(builder)
def is_inf_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.is_inf_layer
but:
- Forwards all of its arguments to
is_inf_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_inf_layer
with f
.
utils of BuilderTree.is_inf_layer
def is_inf_layer(builder, size)
def is_nan(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.is_nan
but:
- Forwards all of its arguments to
is_nan
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_nan
with f
.
utils of Builder.is_nan
def is_nan(builder)
def is_nan_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.is_nan_layer
but:
- Forwards all of its arguments to
is_nan_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_nan_layer
with f
.
utils of BuilderTree.is_nan_layer
def is_nan_layer(builder, size)
def is_non_decreasing(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.is_non_decreasing
but:
- Forwards all of its arguments to
is_non_decreasing
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_non_decreasing
with f
.
utils of Builder.is_non_decreasing
def is_non_decreasing(builder)
def is_non_decreasing_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.is_non_decreasing_layer
but:
- Forwards all of its arguments to
is_non_decreasing_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_non_decreasing_layer
with f
.
utils of BuilderTree.is_non_decreasing_layer
def is_non_decreasing_layer(builder, size)
def is_numeric_tensor(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.is_numeric_tensor
but:
- Forwards all of its arguments to
is_numeric_tensor
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_numeric_tensor
with f
.
utils of Builder.is_numeric_tensor
def is_numeric_tensor(builder)
def is_numeric_tensor_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.is_numeric_tensor_layer
but:
- Forwards all of its arguments to
is_numeric_tensor_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_numeric_tensor_layer
with f
.
utils of BuilderTree.is_numeric_tensor_layer
def is_numeric_tensor_layer(builder, size)
def is_strictly_increasing(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.is_strictly_increasing
but:
- Forwards all of its arguments to
is_strictly_increasing
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_strictly_increasing
with f
.
utils of Builder.is_strictly_increasing
def is_strictly_increasing(builder)
def is_strictly_increasing_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.is_strictly_increasing_layer
but:
- Forwards all of its arguments to
is_strictly_increasing_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_strictly_increasing_layer
with f
.
utils of BuilderTree.is_strictly_increasing_layer
def is_strictly_increasing_layer(builder, size)
def is_variable_initialized(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.is_variable_initialized
but:
- Forwards all of its arguments to
is_variable_initialized
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_variable_initialized
with f
.
utils of Builder.is_variable_initialized
def is_variable_initialized(builder)
def is_variable_initialized_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.is_variable_initialized_layer
but:
- Forwards all of its arguments to
is_variable_initialized_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose is_variable_initialized_layer
with f
.
utils of BuilderTree.is_variable_initialized_layer
def is_variable_initialized_layer(builder, size)
def l2_loss(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.l2_loss
but:
- Forwards all of its arguments to
l2_loss
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose l2_loss
with f
.
utils of Builder.l2_loss
def l2_loss(builder)
def l2_loss_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.l2_loss_layer
but:
- Forwards all of its arguments to
l2_loss_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose l2_loss_layer
with f
.
utils of BuilderTree.l2_loss_layer
def l2_loss_layer(builder, size)
def l2_normalize(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.l2_normalize
but:
- Forwards all of its arguments to
l2_normalize
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose l2_normalize
with f
.
utils of Builder.l2_normalize
def l2_normalize(builder)
def l2_normalize_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.l2_normalize_layer
but:
- Forwards all of its arguments to
l2_normalize_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose l2_normalize_layer
with f
.
utils of BuilderTree.l2_normalize_layer
def l2_normalize_layer(builder, size)
def lbeta(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.lbeta
but:
- Forwards all of its arguments to
lbeta
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose lbeta
with f
.
utils of Builder.lbeta
def lbeta(builder)
def lbeta_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.lbeta_layer
but:
- Forwards all of its arguments to
lbeta_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose lbeta_layer
with f
.
utils of BuilderTree.lbeta_layer
def lbeta_layer(builder, size)
def learned_unigram_candidate_sampler(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.learned_unigram_candidate_sampler
but:
- Forwards all of its arguments to
learned_unigram_candidate_sampler
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose learned_unigram_candidate_sampler
with f
.
utils of Builder.learned_unigram_candidate_sampler
def learned_unigram_candidate_sampler(builder)
def learned_unigram_candidate_sampler_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.learned_unigram_candidate_sampler_layer
but:
- Forwards all of its arguments to
learned_unigram_candidate_sampler_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose learned_unigram_candidate_sampler_layer
with f
.
utils of BuilderTree.learned_unigram_candidate_sampler_layer
def learned_unigram_candidate_sampler_layer(builder, size)
def less(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.less
but:
- Forwards all of its arguments to
less
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose less
with f
.
utils of Builder.less
def less(builder)
def less_equal(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.less_equal
but:
- Forwards all of its arguments to
less_equal
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose less_equal
with f
.
utils of Builder.less_equal
def less_equal(builder)
def less_equal_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.less_equal_layer
but:
- Forwards all of its arguments to
less_equal_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose less_equal_layer
with f
.
utils of BuilderTree.less_equal_layer
def less_equal_layer(builder, size)
def less_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.less_layer
but:
- Forwards all of its arguments to
less_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose less_layer
with f
.
utils of BuilderTree.less_layer
def less_layer(builder, size)
def lgamma(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.lgamma
but:
- Forwards all of its arguments to
lgamma
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose lgamma
with f
.
utils of Builder.lgamma
def lgamma(builder)
def lgamma_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.lgamma_layer
but:
- Forwards all of its arguments to
lgamma_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose lgamma_layer
with f
.
utils of BuilderTree.lgamma_layer
def lgamma_layer(builder, size)
def lin_space(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.lin_space
but:
- Forwards all of its arguments to
lin_space
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose lin_space
with f
.
utils of Builder.lin_space
def lin_space(builder)
def lin_space_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.lin_space_layer
but:
- Forwards all of its arguments to
lin_space_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose lin_space_layer
with f
.
utils of BuilderTree.lin_space_layer
def lin_space_layer(builder, size)
def linspace_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.linspace_layer
but:
- Forwards all of its arguments to
linspace_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose linspace_layer
with f
.
utils of BuilderTree.linspace_layer
def linspace_layer(builder, size)
def list_diff(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.list_diff
but:
- Forwards all of its arguments to
list_diff
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose list_diff
with f
.
utils of Builder.list_diff
def list_diff(builder)
def list_diff_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.list_diff_layer
but:
- Forwards all of its arguments to
list_diff_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose list_diff_layer
with f
.
utils of BuilderTree.list_diff_layer
def list_diff_layer(builder, size)
def listdiff_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.listdiff_layer
but:
- Forwards all of its arguments to
listdiff_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose listdiff_layer
with f
.
utils of BuilderTree.listdiff_layer
def listdiff_layer(builder, size)
def load_file_system_library(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.load_file_system_library
but:
- Forwards all of its arguments to
load_file_system_library
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose load_file_system_library
with f
.
utils of Builder.load_file_system_library
def load_file_system_library(builder)
def load_file_system_library_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.load_file_system_library_layer
but:
- Forwards all of its arguments to
load_file_system_library_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose load_file_system_library_layer
with f
.
utils of BuilderTree.load_file_system_library_layer
def load_file_system_library_layer(builder, size)
def load_op_library(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.load_op_library
but:
- Forwards all of its arguments to
load_op_library
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose load_op_library
with f
.
utils of Builder.load_op_library
def load_op_library(builder)
def load_op_library_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.load_op_library_layer
but:
- Forwards all of its arguments to
load_op_library_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose load_op_library_layer
with f
.
utils of BuilderTree.load_op_library_layer
def load_op_library_layer(builder, size)
def local_response_normalization_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.local_response_normalization_layer
but:
- Forwards all of its arguments to
local_response_normalization_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose local_response_normalization_layer
with f
.
utils of BuilderTree.local_response_normalization_layer
def local_response_normalization_layer(builder, size)
def local_variables(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.local_variables
but:
- Forwards all of its arguments to
local_variables
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose local_variables
with f
.
utils of Builder.local_variables
def local_variables(builder)
def local_variables_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.local_variables_layer
but:
- Forwards all of its arguments to
local_variables_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose local_variables_layer
with f
.
utils of BuilderTree.local_variables_layer
def local_variables_layer(builder, size)
def log(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.log
but:
- Forwards all of its arguments to
log
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose log
with f
.
utils of Builder.log
def log(builder)
def log_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.log_layer
but:
- Forwards all of its arguments to
log_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose log_layer
with f
.
utils of BuilderTree.log_layer
def log_layer(builder, size)
def log_softmax(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.log_softmax
but:
- Forwards all of its arguments to
log_softmax
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose log_softmax
with f
.
utils of Builder.log_softmax
def log_softmax(builder)
def log_softmax_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.log_softmax_layer
but:
- Forwards all of its arguments to
log_softmax_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose log_softmax_layer
with f
.
utils of BuilderTree.log_softmax_layer
def log_softmax_layer(builder, size)
def log_uniform_candidate_sampler(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.log_uniform_candidate_sampler
but:
- Forwards all of its arguments to
log_uniform_candidate_sampler
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose log_uniform_candidate_sampler
with f
.
utils of Builder.log_uniform_candidate_sampler
def log_uniform_candidate_sampler(builder)
def log_uniform_candidate_sampler_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.log_uniform_candidate_sampler_layer
but:
- Forwards all of its arguments to
log_uniform_candidate_sampler_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose log_uniform_candidate_sampler_layer
with f
.
utils of BuilderTree.log_uniform_candidate_sampler_layer
def log_uniform_candidate_sampler_layer(builder, size)
def logical_and(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.logical_and
but:
- Forwards all of its arguments to
logical_and
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose logical_and
with f
.
utils of Builder.logical_and
def logical_and(builder)
def logical_and_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.logical_and_layer
but:
- Forwards all of its arguments to
logical_and_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose logical_and_layer
with f
.
utils of BuilderTree.logical_and_layer
def logical_and_layer(builder, size)
def logical_not(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.logical_not
but:
- Forwards all of its arguments to
logical_not
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose logical_not
with f
.
utils of Builder.logical_not
def logical_not(builder)
def logical_not_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.logical_not_layer
but:
- Forwards all of its arguments to
logical_not_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose logical_not_layer
with f
.
utils of BuilderTree.logical_not_layer
def logical_not_layer(builder, size)
def logical_or(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.logical_or
but:
- Forwards all of its arguments to
logical_or
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose logical_or
with f
.
utils of Builder.logical_or
def logical_or(builder)
def logical_or_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.logical_or_layer
but:
- Forwards all of its arguments to
logical_or_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose logical_or_layer
with f
.
utils of BuilderTree.logical_or_layer
def logical_or_layer(builder, size)
def logical_xor(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.logical_xor
but:
- Forwards all of its arguments to
logical_xor
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose logical_xor
with f
.
utils of Builder.logical_xor
def logical_xor(builder)
def logical_xor_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.logical_xor_layer
but:
- Forwards all of its arguments to
logical_xor_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose logical_xor_layer
with f
.
utils of BuilderTree.logical_xor_layer
def logical_xor_layer(builder, size)
def lrn(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.lrn
but:
- Forwards all of its arguments to
lrn
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose lrn
with f
.
utils of Builder.lrn
def lrn(builder)
def lrn_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.lrn_layer
but:
- Forwards all of its arguments to
lrn_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose lrn_layer
with f
.
utils of BuilderTree.lrn_layer
def lrn_layer(builder, size)
def make_all(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.make_all
but:
- Forwards all of its arguments to
make_all
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose make_all
with f
.
utils of Builder.make_all
def make_all(builder)
def make_all_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.make_all_layer
but:
- Forwards all of its arguments to
make_all_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose make_all_layer
with f
.
utils of BuilderTree.make_all_layer
def make_all_layer(builder, size)
def make_template(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.make_template
but:
- Forwards all of its arguments to
make_template
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose make_template
with f
.
utils of Builder.make_template
def make_template(builder)
def make_template_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.make_template_layer
but:
- Forwards all of its arguments to
make_template_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose make_template_layer
with f
.
utils of BuilderTree.make_template_layer
def make_template_layer(builder, size)
def map(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.map
but:
- Forwards all of its arguments to
map
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose map
with f
.
utils of Builder.map
def map(builder, fn)
def map_each(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.map_each
but:
- Forwards all of its arguments to
map_each
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose map_each
with f
.
utils of BuilderTree.map_each
def map_each(tree, fn)
def map_fn(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.map_fn
but:
- Forwards all of its arguments to
map_fn
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose map_fn
with f
.
utils of Builder.map_fn
def map_fn(builder)
def map_fn_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.map_fn_layer
but:
- Forwards all of its arguments to
map_fn_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose map_fn_layer
with f
.
utils of BuilderTree.map_fn_layer
def map_fn_layer(builder, size)
def matching_files(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.matching_files
but:
- Forwards all of its arguments to
matching_files
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose matching_files
with f
.
utils of Builder.matching_files
def matching_files(builder)
def matching_files_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.matching_files_layer
but:
- Forwards all of its arguments to
matching_files_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose matching_files_layer
with f
.
utils of BuilderTree.matching_files_layer
def matching_files_layer(builder, size)
def matmul(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.matmul
but:
- Forwards all of its arguments to
matmul
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose matmul
with f
.
utils of Builder.matmul
def matmul(builder)
def matmul_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.matmul_layer
but:
- Forwards all of its arguments to
matmul_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose matmul_layer
with f
.
utils of BuilderTree.matmul_layer
def matmul_layer(builder, size)
def matrix_determinant(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.matrix_determinant
but:
- Forwards all of its arguments to
matrix_determinant
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose matrix_determinant
with f
.
utils of Builder.matrix_determinant
def matrix_determinant(builder)
def matrix_determinant_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.matrix_determinant_layer
but:
- Forwards all of its arguments to
matrix_determinant_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose matrix_determinant_layer
with f
.
utils of BuilderTree.matrix_determinant_layer
def matrix_determinant_layer(builder, size)
def matrix_inverse(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.matrix_inverse
but:
- Forwards all of its arguments to
matrix_inverse
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose matrix_inverse
with f
.
utils of Builder.matrix_inverse
def matrix_inverse(builder)
def matrix_inverse_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.matrix_inverse_layer
but:
- Forwards all of its arguments to
matrix_inverse_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose matrix_inverse_layer
with f
.
utils of BuilderTree.matrix_inverse_layer
def matrix_inverse_layer(builder, size)
def matrix_solve(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.matrix_solve
but:
- Forwards all of its arguments to
matrix_solve
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose matrix_solve
with f
.
utils of Builder.matrix_solve
def matrix_solve(builder)
def matrix_solve_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.matrix_solve_layer
but:
- Forwards all of its arguments to
matrix_solve_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose matrix_solve_layer
with f
.
utils of BuilderTree.matrix_solve_layer
def matrix_solve_layer(builder, size)
def matrix_solve_ls(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.matrix_solve_ls
but:
- Forwards all of its arguments to
matrix_solve_ls
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose matrix_solve_ls
with f
.
utils of Builder.matrix_solve_ls
def matrix_solve_ls(builder)
def matrix_solve_ls_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.matrix_solve_ls_layer
but:
- Forwards all of its arguments to
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 matrix_solve_ls_layer
with f
.
utils of BuilderTree.matrix_solve_ls_layer
def matrix_solve_ls_layer(builder, size)
def matrix_triangular_solve(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.matrix_triangular_solve
but:
- Forwards all of its arguments to
matrix_triangular_solve
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose matrix_triangular_solve
with f
.
utils of Builder.matrix_triangular_solve
def matrix_triangular_solve(builder)
def matrix_triangular_solve_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.matrix_triangular_solve_layer
but:
- Forwards all of its arguments to
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 matrix_triangular_solve_layer
with f
.
utils of BuilderTree.matrix_triangular_solve_layer
def matrix_triangular_solve_layer(builder, size)
def max_pool(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.max_pool
but:
- Forwards all of its arguments to
max_pool
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose max_pool
with f
.
utils of Builder.max_pool
def max_pool(builder)
def max_pool3d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.max_pool3d
but:
- Forwards all of its arguments to
max_pool3d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose max_pool3d
with f
.
utils of Builder.max_pool3d
def max_pool3d(builder)
def max_pool3d_grad(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.max_pool3d_grad
but:
- Forwards all of its arguments to
max_pool3d_grad
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose max_pool3d_grad
with f
.
utils of Builder.max_pool3d_grad
def max_pool3d_grad(builder)
def max_pool3d_grad_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.max_pool3d_grad_layer
but:
- Forwards all of its arguments to
max_pool3d_grad_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose max_pool3d_grad_layer
with f
.
utils of BuilderTree.max_pool3d_grad_layer
def max_pool3d_grad_layer(builder, size)
def max_pool3d_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.max_pool3d_layer
but:
- Forwards all of its arguments to
max_pool3d_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose max_pool3d_layer
with f
.
utils of BuilderTree.max_pool3d_layer
def max_pool3d_layer(builder, size)
def max_pool_2d(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.max_pool_2d
but:
- Forwards all of its arguments to
max_pool_2d
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose max_pool_2d
with f
.
utils of Builder.max_pool_2d
def max_pool_2d(builder)
def max_pool_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.max_pool_layer
but:
- Forwards all of its arguments to
max_pool_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose max_pool_layer
with f
.
utils of BuilderTree.max_pool_layer
def max_pool_layer(builder, size)
def max_pool_with_argmax(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.max_pool_with_argmax
but:
- Forwards all of its arguments to
max_pool_with_argmax
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose max_pool_with_argmax
with f
.
utils of Builder.max_pool_with_argmax
def max_pool_with_argmax(builder)
def max_pool_with_argmax_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.max_pool_with_argmax_layer
but:
- Forwards all of its arguments to
max_pool_with_argmax_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose max_pool_with_argmax_layer
with f
.
utils of BuilderTree.max_pool_with_argmax_layer
def max_pool_with_argmax_layer(builder, size)
def maximum(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.maximum
but:
- Forwards all of its arguments to
maximum
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose maximum
with f
.
utils of Builder.maximum
def maximum(builder)
def maximum_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.maximum_layer
but:
- Forwards all of its arguments to
maximum_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose maximum_layer
with f
.
utils of BuilderTree.maximum_layer
def maximum_layer(builder, size)
def merge_all_summaries(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.merge_all_summaries
but:
- Forwards all of its arguments to
merge_all_summaries
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose merge_all_summaries
with f
.
utils of Builder.merge_all_summaries
def merge_all_summaries(builder)
def merge_all_summaries_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.merge_all_summaries_layer
but:
- Forwards all of its arguments to
merge_all_summaries_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose merge_all_summaries_layer
with f
.
utils of BuilderTree.merge_all_summaries_layer
def merge_all_summaries_layer(builder, size)
def merge_summary(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.merge_summary
but:
- Forwards all of its arguments to
merge_summary
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose merge_summary
with f
.
utils of Builder.merge_summary
def merge_summary(builder)
def merge_summary_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.merge_summary_layer
but:
- Forwards all of its arguments to
merge_summary_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose merge_summary_layer
with f
.
utils of BuilderTree.merge_summary_layer
def merge_summary_layer(builder, size)
def minimum(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.minimum
but:
- Forwards all of its arguments to
minimum
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose minimum
with f
.
utils of Builder.minimum
def minimum(builder)
def minimum_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.minimum_layer
but:
- Forwards all of its arguments to
minimum_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose minimum_layer
with f
.
utils of BuilderTree.minimum_layer
def minimum_layer(builder, size)
def mod(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.mod
but:
- Forwards all of its arguments to
mod
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose mod
with f
.
utils of Builder.mod
def mod(builder)
def mod_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.mod_layer
but:
- Forwards all of its arguments to
mod_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose mod_layer
with f
.
utils of BuilderTree.mod_layer
def mod_layer(builder, size)
def moments(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.moments
but:
- Forwards all of its arguments to
moments
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose moments
with f
.
utils of Builder.moments
def moments(builder)
def moments_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.moments_layer
but:
- Forwards all of its arguments to
moments_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose moments_layer
with f
.
utils of BuilderTree.moments_layer
def moments_layer(builder, size)
def moving_average_variables(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.moving_average_variables
but:
- Forwards all of its arguments to
moving_average_variables
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose moving_average_variables
with f
.
utils of Builder.moving_average_variables
def moving_average_variables(builder)
def moving_average_variables_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.moving_average_variables_layer
but:
- Forwards all of its arguments to
moving_average_variables_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose moving_average_variables_layer
with f
.
utils of BuilderTree.moving_average_variables_layer
def moving_average_variables_layer(builder, size)
def mul(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.mul
but:
- Forwards all of its arguments to
mul
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose mul
with f
.
utils of Builder.mul
def mul(builder)
def mul_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.mul_layer
but:
- Forwards all of its arguments to
mul_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose mul_layer
with f
.
utils of BuilderTree.mul_layer
def mul_layer(builder, size)
def multinomial(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.multinomial
but:
- Forwards all of its arguments to
multinomial
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose multinomial
with f
.
utils of Builder.multinomial
def multinomial(builder)
def multinomial_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.multinomial_layer
but:
- Forwards all of its arguments to
multinomial_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose multinomial_layer
with f
.
utils of BuilderTree.multinomial_layer
def multinomial_layer(builder, size)
def name_scope(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.name_scope
but:
- Forwards all of its arguments to
name_scope
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose name_scope
with f
.
utils of Builder.name_scope
def name_scope(builder)
def name_scope_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.name_scope_layer
but:
- Forwards all of its arguments to
name_scope_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose name_scope_layer
with f
.
utils of BuilderTree.name_scope_layer
def name_scope_layer(builder, size)
def nce_loss(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.nce_loss
but:
- Forwards all of its arguments to
nce_loss
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose nce_loss
with f
.
utils of Builder.nce_loss
def nce_loss(builder)
def nce_loss_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.nce_loss_layer
but:
- Forwards all of its arguments to
nce_loss_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose nce_loss_layer
with f
.
utils of BuilderTree.nce_loss_layer
def nce_loss_layer(builder, size)
def neg(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.neg
but:
- Forwards all of its arguments to
neg
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose neg
with f
.
utils of Builder.neg
def neg(builder)
def neg_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.neg_layer
but:
- Forwards all of its arguments to
neg_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose neg_layer
with f
.
utils of BuilderTree.neg_layer
def neg_layer(builder, size)
def no_op(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.no_op
but:
- Forwards all of its arguments to
no_op
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose no_op
with f
.
utils of Builder.no_op
def no_op(builder)
def no_op_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.no_op_layer
but:
- Forwards all of its arguments to
no_op_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose no_op_layer
with f
.
utils of BuilderTree.no_op_layer
def no_op_layer(builder, size)
def no_regularizer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.no_regularizer
but:
- Forwards all of its arguments to
no_regularizer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose no_regularizer
with f
.
utils of Builder.no_regularizer
def no_regularizer(builder)
def no_regularizer_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.no_regularizer_layer
but:
- Forwards all of its arguments to
no_regularizer_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose no_regularizer_layer
with f
.
utils of BuilderTree.no_regularizer_layer
def no_regularizer_layer(builder, size)
def normalize_moments(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.normalize_moments
but:
- Forwards all of its arguments to
normalize_moments
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose normalize_moments
with f
.
utils of Builder.normalize_moments
def normalize_moments(builder)
def normalize_moments_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.normalize_moments_layer
but:
- Forwards all of its arguments to
normalize_moments_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose normalize_moments_layer
with f
.
utils of BuilderTree.normalize_moments_layer
def normalize_moments_layer(builder, size)
def not_equal(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.not_equal
but:
- Forwards all of its arguments to
not_equal
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose not_equal
with f
.
utils of Builder.not_equal
def not_equal(builder)
def not_equal_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.not_equal_layer
but:
- Forwards all of its arguments to
not_equal_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose not_equal_layer
with f
.
utils of BuilderTree.not_equal_layer
def not_equal_layer(builder, size)
def one_hot(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.one_hot
but:
- Forwards all of its arguments to
one_hot
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose one_hot
with f
.
utils of Builder.one_hot
def one_hot(builder)
def one_hot_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.one_hot_layer
but:
- Forwards all of its arguments to
one_hot_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose one_hot_layer
with f
.
utils of BuilderTree.one_hot_layer
def one_hot_layer(builder, size)
def ones(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.ones
but:
- Forwards all of its arguments to
ones
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ones
with f
.
utils of Builder.ones
def ones(builder)
def ones_initializer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.ones_initializer
but:
- Forwards all of its arguments to
ones_initializer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ones_initializer
with f
.
utils of Builder.ones_initializer
def ones_initializer(builder)
def ones_initializer_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.ones_initializer_layer
but:
- Forwards all of its arguments to
ones_initializer_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ones_initializer_layer
with f
.
utils of BuilderTree.ones_initializer_layer
def ones_initializer_layer(builder, size)
def ones_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.ones_layer
but:
- Forwards all of its arguments to
ones_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ones_layer
with f
.
utils of BuilderTree.ones_layer
def ones_layer(builder, size)
def ones_like(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.ones_like
but:
- Forwards all of its arguments to
ones_like
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ones_like
with f
.
utils of Builder.ones_like
def ones_like(builder)
def ones_like_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.ones_like_layer
but:
- Forwards all of its arguments to
ones_like_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose ones_like_layer
with f
.
utils of BuilderTree.ones_like_layer
def ones_like_layer(builder, size)
def op_scope(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.op_scope
but:
- Forwards all of its arguments to
op_scope
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose op_scope
with f
.
utils of Builder.op_scope
def op_scope(builder)
def op_scope_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.op_scope_layer
but:
- Forwards all of its arguments to
op_scope_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose op_scope_layer
with f
.
utils of BuilderTree.op_scope_layer
def op_scope_layer(builder, size)
def pack(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.pack
but:
- Forwards all of its arguments to
pack
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose pack
with f
.
utils of Builder.pack
def pack(builder)
def pack_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.pack_layer
but:
- Forwards all of its arguments to
pack_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose pack_layer
with f
.
utils of BuilderTree.pack_layer
def pack_layer(builder, size)
def pad(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.pad
but:
- Forwards all of its arguments to
pad
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose pad
with f
.
utils of Builder.pad
def pad(builder)
def pad_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.pad_layer
but:
- Forwards all of its arguments to
pad_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose pad_layer
with f
.
utils of BuilderTree.pad_layer
def pad_layer(builder, size)
def parse_example(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.parse_example
but:
- Forwards all of its arguments to
parse_example
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose parse_example
with f
.
utils of Builder.parse_example
def parse_example(builder)
def parse_example_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.parse_example_layer
but:
- Forwards all of its arguments to
parse_example_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose parse_example_layer
with f
.
utils of BuilderTree.parse_example_layer
def parse_example_layer(builder, size)
def parse_single_example(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.parse_single_example
but:
- Forwards all of its arguments to
parse_single_example
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose parse_single_example
with f
.
utils of Builder.parse_single_example
def parse_single_example(builder)
def parse_single_example_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.parse_single_example_layer
but:
- Forwards all of its arguments to
parse_single_example_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose parse_single_example_layer
with f
.
utils of BuilderTree.parse_single_example_layer
def parse_single_example_layer(builder, size)
def parse_single_sequence_example(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.parse_single_sequence_example
but:
- Forwards all of its arguments to
parse_single_sequence_example
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose parse_single_sequence_example
with f
.
utils of Builder.parse_single_sequence_example
def parse_single_sequence_example(builder)
def parse_single_sequence_example_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.parse_single_sequence_example_layer
but:
- Forwards all of its arguments to
parse_single_sequence_example_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose parse_single_sequence_example_layer
with f
.
utils of BuilderTree.parse_single_sequence_example_layer
def parse_single_sequence_example_layer(builder, size)
def placeholder(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.placeholder
but:
- Forwards all of its arguments to
placeholder
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose placeholder
with f
.
utils of Builder.placeholder
def placeholder(builder)
def placeholder_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.placeholder_layer
but:
- Forwards all of its arguments to
placeholder_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose placeholder_layer
with f
.
utils of BuilderTree.placeholder_layer
def placeholder_layer(builder, size)
def placeholder_with_default(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.placeholder_with_default
but:
- Forwards all of its arguments to
placeholder_with_default
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose placeholder_with_default
with f
.
utils of Builder.placeholder_with_default
def placeholder_with_default(builder)
def placeholder_with_default_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.placeholder_with_default_layer
but:
- Forwards all of its arguments to
placeholder_with_default_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose placeholder_with_default_layer
with f
.
utils of BuilderTree.placeholder_with_default_layer
def placeholder_with_default_layer(builder, size)
def polygamma(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.polygamma
but:
- Forwards all of its arguments to
polygamma
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose polygamma
with f
.
utils of Builder.polygamma
def polygamma(builder)
def polygamma_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.polygamma_layer
but:
- Forwards all of its arguments to
polygamma_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose polygamma_layer
with f
.
utils of BuilderTree.polygamma_layer
def polygamma_layer(builder, size)
def pow(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.pow
but:
- Forwards all of its arguments to
pow
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose pow
with f
.
utils of Builder.pow
def pow(builder)
def pow_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.pow_layer
but:
- Forwards all of its arguments to
pow_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose pow_layer
with f
.
utils of BuilderTree.pow_layer
def pow_layer(builder, size)
def py_func(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.py_func
but:
- Forwards all of its arguments to
py_func
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose py_func
with f
.
utils of Builder.py_func
def py_func(builder)
def py_func_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.py_func_layer
but:
- Forwards all of its arguments to
py_func_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose py_func_layer
with f
.
utils of BuilderTree.py_func_layer
def py_func_layer(builder, size)
def random_crop(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.random_crop
but:
- Forwards all of its arguments to
random_crop
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose random_crop
with f
.
utils of Builder.random_crop
def random_crop(builder)
def random_crop_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.random_crop_layer
but:
- Forwards all of its arguments to
random_crop_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose random_crop_layer
with f
.
utils of BuilderTree.random_crop_layer
def random_crop_layer(builder, size)
def random_normal(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.random_normal
but:
- Forwards all of its arguments to
random_normal
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose random_normal
with f
.
utils of Builder.random_normal
def random_normal(builder)
def random_normal_initializer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.random_normal_initializer
but:
- Forwards all of its arguments to
random_normal_initializer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose random_normal_initializer
with f
.
utils of Builder.random_normal_initializer
def random_normal_initializer(builder)
def random_normal_initializer_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.random_normal_initializer_layer
but:
- Forwards all of its arguments to
random_normal_initializer_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose random_normal_initializer_layer
with f
.
utils of BuilderTree.random_normal_initializer_layer
def random_normal_initializer_layer(builder, size)
def random_normal_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.random_normal_layer
but:
- Forwards all of its arguments to
random_normal_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose random_normal_layer
with f
.
utils of BuilderTree.random_normal_layer
def random_normal_layer(builder, size)
def random_shuffle(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.random_shuffle
but:
- Forwards all of its arguments to
random_shuffle
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose random_shuffle
with f
.
utils of Builder.random_shuffle
def random_shuffle(builder)
def random_shuffle_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.random_shuffle_layer
but:
- Forwards all of its arguments to
random_shuffle_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose random_shuffle_layer
with f
.
utils of BuilderTree.random_shuffle_layer
def random_shuffle_layer(builder, size)
def random_uniform(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.random_uniform
but:
- Forwards all of its arguments to
random_uniform
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose random_uniform
with f
.
utils of Builder.random_uniform
def random_uniform(builder)
def random_uniform_initializer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.random_uniform_initializer
but:
- Forwards all of its arguments to
random_uniform_initializer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose random_uniform_initializer
with f
.
utils of Builder.random_uniform_initializer
def random_uniform_initializer(builder)
def random_uniform_initializer_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.random_uniform_initializer_layer
but:
- Forwards all of its arguments to
random_uniform_initializer_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose random_uniform_initializer_layer
with f
.
utils of BuilderTree.random_uniform_initializer_layer
def random_uniform_initializer_layer(builder, size)
def random_uniform_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.random_uniform_layer
but:
- Forwards all of its arguments to
random_uniform_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose random_uniform_layer
with f
.
utils of BuilderTree.random_uniform_layer
def random_uniform_layer(builder, size)
def range(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.range
but:
- Forwards all of its arguments to
range
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose range
with f
.
utils of Builder.range
def range(builder)
def range_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.range_layer
but:
- Forwards all of its arguments to
range_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose range_layer
with f
.
utils of BuilderTree.range_layer
def range_layer(builder, size)
def rank(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.rank
but:
- Forwards all of its arguments to
rank
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose rank
with f
.
utils of Builder.rank
def rank(builder)
def rank_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.rank_layer
but:
- Forwards all of its arguments to
rank_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose rank_layer
with f
.
utils of BuilderTree.rank_layer
def rank_layer(builder, size)
def read_file(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.read_file
but:
- Forwards all of its arguments to
read_file
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose read_file
with f
.
utils of Builder.read_file
def read_file(builder)
def read_file_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.read_file_layer
but:
- Forwards all of its arguments to
read_file_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose read_file_layer
with f
.
utils of BuilderTree.read_file_layer
def read_file_layer(builder, size)
def real(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.real
but:
- Forwards all of its arguments to
real
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose real
with f
.
utils of Builder.real
def real(builder)
def real_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.real_layer
but:
- Forwards all of its arguments to
real_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose real_layer
with f
.
utils of BuilderTree.real_layer
def real_layer(builder, size)
def reduce(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.reduce
but:
- Forwards all of its arguments to
reduce
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce
with f
.
utils of BuilderTree.reduce
def reduce(tree, fn, initializer=None)
def reduce_all(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.reduce_all
but:
- Forwards all of its arguments to
reduce_all
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_all
with f
.
utils of Builder.reduce_all
def reduce_all(builder)
def reduce_all_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.reduce_all_layer
but:
- Forwards all of its arguments to
reduce_all_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_all_layer
with f
.
utils of BuilderTree.reduce_all_layer
def reduce_all_layer(builder, size)
def reduce_any(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.reduce_any
but:
- Forwards all of its arguments to
reduce_any
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_any
with f
.
utils of Builder.reduce_any
def reduce_any(builder)
def reduce_any_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.reduce_any_layer
but:
- Forwards all of its arguments to
reduce_any_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_any_layer
with f
.
utils of BuilderTree.reduce_any_layer
def reduce_any_layer(builder, size)
def reduce_join(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.reduce_join
but:
- Forwards all of its arguments to
reduce_join
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_join
with f
.
utils of Builder.reduce_join
def reduce_join(builder)
def reduce_join_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.reduce_join_layer
but:
- Forwards all of its arguments to
reduce_join_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_join_layer
with f
.
utils of BuilderTree.reduce_join_layer
def reduce_join_layer(builder, size)
def reduce_max(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.reduce_max
but:
- Forwards all of its arguments to
reduce_max
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_max
with f
.
utils of Builder.reduce_max
def reduce_max(builder)
def reduce_max_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.reduce_max_layer
but:
- Forwards all of its arguments to
reduce_max_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_max_layer
with f
.
utils of BuilderTree.reduce_max_layer
def reduce_max_layer(builder, size)
def reduce_mean(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.reduce_mean
but:
- Forwards all of its arguments to
reduce_mean
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_mean
with f
.
utils of Builder.reduce_mean
def reduce_mean(builder)
def reduce_mean_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.reduce_mean_layer
but:
- Forwards all of its arguments to
reduce_mean_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_mean_layer
with f
.
utils of BuilderTree.reduce_mean_layer
def reduce_mean_layer(builder, size)
def reduce_min(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.reduce_min
but:
- Forwards all of its arguments to
reduce_min
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_min
with f
.
utils of Builder.reduce_min
def reduce_min(builder)
def reduce_min_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.reduce_min_layer
but:
- Forwards all of its arguments to
reduce_min_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_min_layer
with f
.
utils of BuilderTree.reduce_min_layer
def reduce_min_layer(builder, size)
def reduce_prod(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.reduce_prod
but:
- Forwards all of its arguments to
reduce_prod
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_prod
with f
.
utils of Builder.reduce_prod
def reduce_prod(builder)
def reduce_prod_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.reduce_prod_layer
but:
- Forwards all of its arguments to
reduce_prod_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_prod_layer
with f
.
utils of BuilderTree.reduce_prod_layer
def reduce_prod_layer(builder, size)
def reduce_sum(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.reduce_sum
but:
- Forwards all of its arguments to
reduce_sum
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_sum
with f
.
utils of Builder.reduce_sum
def reduce_sum(builder)
def reduce_sum_layer(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as BuilderTree.reduce_sum_layer
but:
- Forwards all of its arguments to
reduce_sum_layer
, this returns a functiong
. - Applies
compose
overg
, this roughly computes the compositiong
off
.
So the result of this method is compose reduce_sum_layer
with f
.
utils of BuilderTree.reduce_sum_layer
def reduce_sum_layer(builder, size)
def register_tensor_conversion_function(
app, *args, **kwargs)
THIS METHOD IS AUTOMATICALLY GENERATED
This method accepts the same arguments as Builder.register_tensor_conversion_function
but:
- Forwards all of its arguments to