5085 lines
180 KiB
Python
Executable File
5085 lines
180 KiB
Python
Executable File
# Copyright 2020 DeepMind Technologies Limited. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
# ==============================================================================
|
|
"""TensorFlow stubs.
|
|
|
|
NOTE: This file is generated from templates/tensorflow.pyi
|
|
using a Google-internal tool.
|
|
"""
|
|
|
|
# BEGIN: tensor_annotations annotations
|
|
from typing import Any, TypeVar, Tuple, overload
|
|
from typing_extensions import Literal
|
|
|
|
from tensor_annotations.axes import Axis
|
|
from tensor_annotations.tensorflow import Tensor0, Tensor1, Tensor2, Tensor3, Tensor4, Tensor5
|
|
|
|
|
|
A1 = TypeVar('A1', bound=Axis)
|
|
A2 = TypeVar('A2', bound=Axis)
|
|
A3 = TypeVar('A3', bound=Axis)
|
|
A4 = TypeVar('A4', bound=Axis)
|
|
A5 = TypeVar('A5', bound=Axis)
|
|
# This alias makes the meaning clearer in code.
|
|
# Unfortunately, it still shows up as 'Any' in pytype output.
|
|
AnyDType = Any
|
|
DT = TypeVar('DT')
|
|
|
|
TRUE = Literal[True]
|
|
FALSE = Literal[False]
|
|
|
|
LN1 = Literal[-1]
|
|
L0 = Literal[0]
|
|
L1 = Literal[1]
|
|
L2 = Literal[2]
|
|
L3 = Literal[3]
|
|
L4 = Literal[4]
|
|
|
|
Shape1 = Tuple[int]
|
|
Shape2 = Tuple[int, int]
|
|
Shape3 = Tuple[int, int, int]
|
|
Shape4 = Tuple[int, int, int, int]
|
|
Shape5 = Tuple[int, int, int, int, int]
|
|
# END: tensor_annotations annotations
|
|
|
|
import enum
|
|
from typing import Any
|
|
|
|
def __getattr__(name) -> Any: ...
|
|
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
|
|
class AggregationMethod(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
ADD_N: Any
|
|
DEFAULT: Any
|
|
EXPERIMENTAL_ACCUMULATE_N: Any
|
|
EXPERIMENTAL_TREE: Any
|
|
def __init__(*args, **kwargs) -> None: ...
|
|
|
|
class CriticalSection(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
name: Any
|
|
def __init__(self, name=..., shared_name=..., critical_section_def=..., import_scope=...) -> None: ...
|
|
def execute(self, fn, exclusive_resource_access=..., name=...) -> Any: ...
|
|
|
|
class DType():
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
as_datatype_enum: Any
|
|
as_numpy_dtype: Any
|
|
base_dtype: Any
|
|
is_bool: Any
|
|
is_complex: Any
|
|
is_floating: Any
|
|
is_integer: Any
|
|
is_numpy_compatible: Any
|
|
is_quantized: Any
|
|
is_unsigned: Any
|
|
limits: Any
|
|
max: Any
|
|
min: Any
|
|
name: Any
|
|
real_dtype: Any
|
|
size: Any
|
|
def __init__(*args, **kwargs) -> None: ...
|
|
def experimental_as_proto(self) -> Any: ...
|
|
@classmethod
|
|
def experimental_from_proto(cls, proto) -> Any: ...
|
|
@classmethod
|
|
def experimental_type_proto(cls) -> Any: ...
|
|
def is_compatible_with(self, other) -> Any: ...
|
|
def is_subtype_of(self, other) -> Any: ...
|
|
def most_specific_common_supertype(self, types) -> Any: ...
|
|
|
|
class DeviceSpec(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
device_index: Any
|
|
device_type: Any
|
|
job: Any
|
|
replica: Any
|
|
task: Any
|
|
def __init__(self, job=..., replica=..., task=..., device_type=..., device_index=...) -> None: ...
|
|
@classmethod
|
|
def from_string(cls, spec) -> Any: ...
|
|
def make_merged_spec(self, dev) -> Any: ...
|
|
def parse_from_string(self, spec) -> Any: ...
|
|
def replace(self, **kwargs) -> Any: ...
|
|
def to_string(self) -> Any: ...
|
|
|
|
class GradientTape(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
def __init__(self, persistent=..., watch_accessed_variables=...) -> None: ...
|
|
def batch_jacobian(self, target, source, unconnected_gradients=..., parallel_iterations=..., experimental_use_pfor=...) -> Any: ...
|
|
def gradient(self, target, sources, output_gradients=..., unconnected_gradients=...) -> Any: ...
|
|
def jacobian(self, target, sources, unconnected_gradients=..., parallel_iterations=..., experimental_use_pfor=...) -> Any: ...
|
|
def reset(self) -> Any: ...
|
|
def stop_recording(self) -> Any: ...
|
|
def watch(self, tensor) -> Any: ...
|
|
def watched_variables(self) -> Any: ...
|
|
|
|
class Graph(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
building_function: Any
|
|
collections: Any
|
|
finalized: Any
|
|
graph_def_versions: Any
|
|
seed: Any
|
|
version: Any
|
|
def __init__(self) -> None: ...
|
|
def add_to_collection(self, name, value) -> Any: ...
|
|
def add_to_collections(self, names, value) -> Any: ...
|
|
def as_default(self) -> Any: ...
|
|
def as_graph_def(self, from_version=..., add_shapes=...) -> Any: ...
|
|
def as_graph_element(self, obj, allow_tensor=..., allow_operation=...) -> Any: ...
|
|
def clear_collection(self, name) -> Any: ...
|
|
def colocate_with(self, op, ignore_existing=...) -> Any: ...
|
|
def container(self, container_name) -> Any: ...
|
|
def control_dependencies(self, control_inputs) -> Any: ...
|
|
def create_op(self, op_type, inputs, dtypes=..., input_types=..., name=..., attrs=..., op_def=..., compute_shapes=..., compute_device=...) -> Any: ...
|
|
def device(self, device_name_or_function) -> Any: ...
|
|
def finalize(self) -> Any: ...
|
|
def get_all_collection_keys(self) -> Any: ...
|
|
def get_collection(self, name, scope=...) -> Any: ...
|
|
def get_collection_ref(self, name) -> Any: ...
|
|
def get_name_scope(self) -> Any: ...
|
|
def get_operation_by_name(self, name) -> Any: ...
|
|
def get_operations(self) -> Any: ...
|
|
def get_tensor_by_name(self, name) -> Any: ...
|
|
def gradient_override_map(self, op_type_map) -> Any: ...
|
|
def is_feedable(self, tensor) -> Any: ...
|
|
def is_fetchable(self, tensor_or_op) -> Any: ...
|
|
def name_scope(self, name) -> Any: ...
|
|
def prevent_feeding(self, tensor) -> Any: ...
|
|
def prevent_fetching(self, op) -> Any: ...
|
|
def switch_to_thread_local(self) -> Any: ...
|
|
def unique_name(self, name, mark_as_used=...) -> Any: ...
|
|
|
|
class IndexedSlices(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
dense_shape: Any
|
|
device: Any
|
|
dtype: Any
|
|
graph: Any
|
|
indices: Any
|
|
name: Any
|
|
op: Any
|
|
shape: Any
|
|
values: Any
|
|
def __init__(self, values, indices, dense_shape=...) -> None: ...
|
|
def consumers(self) -> Any: ...
|
|
|
|
class IndexedSlicesSpec(TypeSpec, object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
value_type: Any
|
|
def __init__(self, shape=..., dtype=..., indices_dtype=..., dense_shape_dtype=..., indices_shape=...) -> None: ...
|
|
def experimental_as_proto(self) -> Any: ...
|
|
@classmethod
|
|
def experimental_from_proto(cls, proto) -> Any: ...
|
|
@classmethod
|
|
def experimental_type_proto(cls) -> Any: ...
|
|
def is_compatible_with(self, spec_or_value) -> Any: ...
|
|
def is_subtype_of(self, other) -> Any: ...
|
|
def most_specific_common_supertype(self, others) -> Any: ...
|
|
def most_specific_compatible_type(self, other) -> Any: ...
|
|
|
|
class Module(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
name: Any
|
|
name_scope: Any
|
|
non_trainable_variables: Any
|
|
submodules: Any
|
|
trainable_variables: Any
|
|
variables: Any
|
|
def __init__(self, name=...) -> None: ...
|
|
@classmethod
|
|
def with_name_scope(cls, method) -> Any: ...
|
|
|
|
class Operation(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
control_inputs: Any
|
|
device: Any
|
|
graph: Any
|
|
inputs: Any
|
|
name: Any
|
|
node_def: Any
|
|
op_def: Any
|
|
outputs: Any
|
|
traceback: Any
|
|
type: Any
|
|
def __init__(self, node_def, g, inputs=..., output_types=..., control_inputs=..., input_types=..., original_op=..., op_def=...) -> None: ...
|
|
def colocation_groups(self) -> Any: ...
|
|
def experimental_set_type(self, type_proto) -> Any: ...
|
|
def get_attr(self, name) -> Any: ...
|
|
def run(self, feed_dict=..., session=...) -> Any: ...
|
|
def values(self) -> Any: ...
|
|
|
|
class OptionalSpec(TypeSpec, object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
value_type: Any
|
|
def __init__(self, element_spec) -> None: ...
|
|
def experimental_as_proto(self) -> Any: ...
|
|
@classmethod
|
|
def experimental_from_proto(cls, proto) -> Any: ...
|
|
@classmethod
|
|
def experimental_type_proto(cls) -> Any: ...
|
|
def from_value(value) -> Any: ...
|
|
def is_compatible_with(self, spec_or_value) -> Any: ...
|
|
def is_subtype_of(self, other) -> Any: ...
|
|
def most_specific_common_supertype(self, others) -> Any: ...
|
|
def most_specific_compatible_type(self, other) -> Any: ...
|
|
|
|
class RaggedTensor(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
dtype: Any
|
|
flat_values: Any
|
|
nested_row_splits: Any
|
|
ragged_rank: Any
|
|
row_splits: Any
|
|
shape: Any
|
|
uniform_row_length: Any
|
|
values: Any
|
|
def __init__(self, values, row_partition, internal=...) -> None: ...
|
|
def bounding_shape(self, axis=..., name=..., out_type=...) -> Any: ...
|
|
def consumers(self) -> Any: ...
|
|
@classmethod
|
|
def from_nested_row_lengths(cls, flat_values, nested_row_lengths, name=..., validate=...) -> Any: ...
|
|
@classmethod
|
|
def from_nested_row_splits(cls, flat_values, nested_row_splits, name=..., validate=...) -> Any: ...
|
|
@classmethod
|
|
def from_nested_value_rowids(cls, flat_values, nested_value_rowids, nested_nrows=..., name=..., validate=...) -> Any: ...
|
|
@classmethod
|
|
def from_row_lengths(cls, values, row_lengths, name=..., validate=...) -> Any: ...
|
|
@classmethod
|
|
def from_row_limits(cls, values, row_limits, name=..., validate=...) -> Any: ...
|
|
@classmethod
|
|
def from_row_splits(cls, values, row_splits, name=..., validate=...) -> Any: ...
|
|
@classmethod
|
|
def from_row_starts(cls, values, row_starts, name=..., validate=...) -> Any: ...
|
|
@classmethod
|
|
def from_sparse(cls, st_input, name=..., row_splits_dtype=...) -> Any: ...
|
|
@classmethod
|
|
def from_tensor(cls, tensor, lengths=..., padding=..., ragged_rank=..., name=..., row_splits_dtype=...) -> Any: ...
|
|
@classmethod
|
|
def from_uniform_row_length(cls, values, uniform_row_length, nrows=..., validate=..., name=...) -> Any: ...
|
|
@classmethod
|
|
def from_value_rowids(cls, values, value_rowids, nrows=..., name=..., validate=...) -> Any: ...
|
|
def get_shape(self) -> Any: ...
|
|
def merge_dims(self, outer_axis, inner_axis) -> Any: ...
|
|
def nested_row_lengths(self, name=...) -> Any: ...
|
|
def nested_value_rowids(self, name=...) -> Any: ...
|
|
def nrows(self, out_type=..., name=...) -> Any: ...
|
|
def numpy(self) -> Any: ...
|
|
def row_lengths(self, axis=..., name=...) -> Any: ...
|
|
def row_limits(self, name=...) -> Any: ...
|
|
def row_starts(self, name=...) -> Any: ...
|
|
def to_list(self) -> Any: ...
|
|
def to_sparse(self, name=...) -> Any: ...
|
|
def to_tensor(self, default_value=..., name=..., shape=...) -> Any: ...
|
|
def value_rowids(self, name=...) -> Any: ...
|
|
def with_flat_values(self, new_values) -> Any: ...
|
|
def with_row_splits_dtype(self, dtype) -> Any: ...
|
|
def with_values(self, new_values) -> Any: ...
|
|
|
|
class RaggedTensorSpec(TypeSpec, object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
dtype: Any
|
|
flat_values_spec: Any
|
|
ragged_rank: Any
|
|
row_splits_dtype: Any
|
|
shape: Any
|
|
value_type: Any
|
|
def __init__(self, shape=..., dtype=..., ragged_rank=..., row_splits_dtype=..., flat_values_spec=...) -> None: ...
|
|
def experimental_as_proto(self) -> Any: ...
|
|
@classmethod
|
|
def experimental_from_proto(cls, proto) -> Any: ...
|
|
@classmethod
|
|
def experimental_type_proto(cls) -> Any: ...
|
|
@classmethod
|
|
def from_value(cls, value) -> Any: ...
|
|
def is_compatible_with(self, spec_or_value) -> Any: ...
|
|
def is_subtype_of(self, other) -> Any: ...
|
|
def most_specific_common_supertype(self, others) -> Any: ...
|
|
def most_specific_compatible_type(self, other) -> Any: ...
|
|
|
|
class RegisterGradient(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
def __init__(self, op_type) -> None: ...
|
|
|
|
class SparseTensor(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
dense_shape: Any
|
|
dtype: Any
|
|
graph: Any
|
|
indices: Any
|
|
op: Any
|
|
shape: Any
|
|
values: Any
|
|
def __init__(self, indices, values, dense_shape) -> None: ...
|
|
def consumers(self) -> Any: ...
|
|
def eval(self, feed_dict=..., session=...) -> Any: ...
|
|
@classmethod
|
|
def from_value(cls, sparse_tensor_value) -> Any: ...
|
|
def get_shape(self) -> Any: ...
|
|
def with_values(self, new_values) -> Any: ...
|
|
|
|
class SparseTensorSpec(TypeSpec, object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
dtype: Any
|
|
shape: Any
|
|
value_type: Any
|
|
def __init__(self, shape=..., dtype=...) -> None: ...
|
|
def experimental_as_proto(self) -> Any: ...
|
|
@classmethod
|
|
def experimental_from_proto(cls, proto) -> Any: ...
|
|
@classmethod
|
|
def experimental_type_proto(cls) -> Any: ...
|
|
@classmethod
|
|
def from_value(cls, value) -> Any: ...
|
|
def is_compatible_with(self, spec_or_value) -> Any: ...
|
|
def is_subtype_of(self, other) -> Any: ...
|
|
def most_specific_common_supertype(self, others) -> Any: ...
|
|
def most_specific_compatible_type(self, other) -> Any: ...
|
|
|
|
class Summary(object):
|
|
def __init__(self, value=...) -> None: ...
|
|
def Value(**kwargs) -> Any: ...
|
|
|
|
class Tensor(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
OVERLOADABLE_OPERATORS: Any
|
|
device: Any
|
|
dtype: Any
|
|
graph: Any
|
|
name: Any
|
|
op: Any
|
|
shape: Any
|
|
value_index: Any
|
|
def __init__(self, op, value_index, dtype) -> None: ...
|
|
def consumers(self) -> Any: ...
|
|
def eval(self, feed_dict=..., session=...) -> Any: ...
|
|
def experimental_ref(self) -> Any: ...
|
|
def get_shape(self) -> Any: ...
|
|
def ref(self) -> Any: ...
|
|
def set_shape(self, shape) -> Any: ...
|
|
|
|
class TensorArray(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
dtype: Any
|
|
dynamic_size: Any
|
|
element_shape: Any
|
|
flow: Any
|
|
handle: Any
|
|
def __init__(self, dtype, size=..., dynamic_size=..., clear_after_read=..., tensor_array_name=..., handle=..., flow=..., infer_shape=..., element_shape=..., colocate_with_first_write_call=..., name=...) -> None: ...
|
|
def close(self, name=...) -> Any: ...
|
|
def concat(self, name=...) -> Any: ...
|
|
def gather(self, indices, name=...) -> Any: ...
|
|
def grad(self, source, flow=..., name=...) -> Any: ...
|
|
def identity(self) -> Any: ...
|
|
def read(self, index, name=...) -> Any: ...
|
|
def scatter(self, indices, value, name=...) -> Any: ...
|
|
def size(self, name=...) -> Any: ...
|
|
def split(self, value, lengths, name=...) -> Any: ...
|
|
def stack(self, name=...) -> Any: ...
|
|
def unstack(self, value, name=...) -> Any: ...
|
|
def write(self, index, value, name=...) -> Any: ...
|
|
|
|
class TensorArraySpec(TypeSpec, object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
value_type: Any
|
|
def __init__(self, element_shape=..., dtype=..., dynamic_size=..., infer_shape=...) -> None: ...
|
|
def experimental_as_proto(self) -> Any: ...
|
|
@classmethod
|
|
def experimental_from_proto(cls, proto) -> Any: ...
|
|
@classmethod
|
|
def experimental_type_proto(cls) -> Any: ...
|
|
def from_value(value) -> Any: ...
|
|
def is_compatible_with(self, other) -> Any: ...
|
|
def is_subtype_of(self, other) -> Any: ...
|
|
def most_specific_common_supertype(self, others) -> Any: ...
|
|
def most_specific_compatible_type(self, other) -> Any: ...
|
|
|
|
class TensorShape(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
dims: Any
|
|
ndims: Any
|
|
rank: Any
|
|
def __init__(self, dims) -> None: ...
|
|
def as_list(self) -> list[int]: ...
|
|
def as_proto(self) -> Any: ...
|
|
def assert_has_rank(self, rank) -> Any: ...
|
|
def assert_is_compatible_with(self, other) -> Any: ...
|
|
def assert_is_fully_defined(self) -> Any: ...
|
|
def assert_same_rank(self, other) -> Any: ...
|
|
def concatenate(self, other) -> Any: ...
|
|
def experimental_as_proto(self) -> Any: ...
|
|
@classmethod
|
|
def experimental_from_proto(cls, proto) -> Any: ...
|
|
@classmethod
|
|
def experimental_type_proto(cls) -> Any: ...
|
|
def is_compatible_with(self, other) -> Any: ...
|
|
def is_fully_defined(self) -> Any: ...
|
|
def is_subtype_of(self, other) -> Any: ...
|
|
def merge_with(self, other) -> Any: ...
|
|
def most_specific_common_supertype(self, others) -> Any: ...
|
|
def most_specific_compatible_shape(self, other) -> Any: ...
|
|
def num_elements(self) -> Any: ...
|
|
def with_rank(self, rank) -> Any: ...
|
|
def with_rank_at_least(self, rank) -> Any: ...
|
|
def with_rank_at_most(self, rank) -> Any: ...
|
|
|
|
@overload
|
|
def __getitem__(self, key: int) -> int: ...
|
|
|
|
@overload
|
|
def __getitem__(self, key: slice) -> TensorShape: ...
|
|
|
|
class TensorSpec(TypeSpec, object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
dtype: Any
|
|
name: Any
|
|
shape: Any
|
|
value_type: Any
|
|
def __init__(self, shape, dtype=..., name=...) -> None: ...
|
|
def experimental_as_proto(self) -> Any: ...
|
|
@classmethod
|
|
def experimental_from_proto(cls, proto) -> Any: ...
|
|
@classmethod
|
|
def experimental_type_proto(cls) -> Any: ...
|
|
@classmethod
|
|
def from_spec(cls, spec, name=...) -> Any: ...
|
|
@classmethod
|
|
def from_tensor(cls, tensor, name=...) -> Any: ...
|
|
def is_compatible_with(self, spec_or_tensor) -> Any: ...
|
|
def is_subtype_of(self, other) -> Any: ...
|
|
def most_specific_common_supertype(self, others) -> Any: ...
|
|
def most_specific_compatible_type(self, other) -> Any: ...
|
|
|
|
class TypeSpec(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
value_type: Any
|
|
def __init__(*args, **kwargs) -> None: ...
|
|
def experimental_as_proto(self) -> Any: ...
|
|
@classmethod
|
|
def experimental_from_proto(cls, proto) -> Any: ...
|
|
@classmethod
|
|
def experimental_type_proto(cls) -> Any: ...
|
|
def is_compatible_with(self, spec_or_value) -> Any: ...
|
|
def is_subtype_of(self, other) -> Any: ...
|
|
def most_specific_common_supertype(self, others) -> Any: ...
|
|
def most_specific_compatible_type(self, other) -> Any: ...
|
|
|
|
class UnconnectedGradients(enum.Enum):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
NONE: Any
|
|
ZERO: Any
|
|
|
|
class Variable(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
aggregation: Any
|
|
constraint: Any
|
|
device: Any
|
|
dtype: Any
|
|
graph: Any
|
|
initial_value: Any
|
|
initializer: Any
|
|
name: Any
|
|
op: Any
|
|
shape: Any
|
|
synchronization: Any
|
|
trainable: Any
|
|
def __init__(self, initial_value=..., trainable=..., validate_shape=..., caching_device=..., name=..., variable_def=..., dtype=..., import_scope=..., constraint=..., synchronization=..., aggregation=..., shape=..., experimental_enable_variable_lifting=...) -> None: ...
|
|
def assign(self, value, use_locking=..., name=..., read_value=...) -> Any: ...
|
|
def assign_add(self, delta, use_locking=..., name=..., read_value=...) -> Any: ...
|
|
def assign_sub(self, delta, use_locking=..., name=..., read_value=...) -> Any: ...
|
|
def batch_scatter_update(self, sparse_delta, use_locking=..., name=...) -> Any: ...
|
|
def count_up_to(self, limit) -> Any: ...
|
|
def eval(self, session=...) -> Any: ...
|
|
def experimental_ref(self) -> Any: ...
|
|
def from_proto(variable_def, import_scope=...) -> Any: ...
|
|
def gather_nd(self, indices, name=...) -> Any: ...
|
|
def get_shape(self) -> Any: ...
|
|
def initialized_value(self) -> Any: ...
|
|
def load(self, value, session=...) -> Any: ...
|
|
def read_value(self) -> Any: ...
|
|
def ref(self) -> Any: ...
|
|
def scatter_add(self, sparse_delta, use_locking=..., name=...) -> Any: ...
|
|
def scatter_div(self, sparse_delta, use_locking=..., name=...) -> Any: ...
|
|
def scatter_max(self, sparse_delta, use_locking=..., name=...) -> Any: ...
|
|
def scatter_min(self, sparse_delta, use_locking=..., name=...) -> Any: ...
|
|
def scatter_mul(self, sparse_delta, use_locking=..., name=...) -> Any: ...
|
|
def scatter_nd_add(self, indices, updates, name=...) -> Any: ...
|
|
def scatter_nd_sub(self, indices, updates, name=...) -> Any: ...
|
|
def scatter_nd_update(self, indices, updates, name=...) -> Any: ...
|
|
def scatter_sub(self, sparse_delta, use_locking=..., name=...) -> Any: ...
|
|
def scatter_update(self, sparse_delta, use_locking=..., name=...) -> Any: ...
|
|
def set_shape(self, shape) -> Any: ...
|
|
def sparse_read(self, indices, name=...) -> Any: ...
|
|
def to_proto(self, export_scope=...) -> Any: ...
|
|
def value(self) -> Any: ...
|
|
|
|
class VariableAggregation(enum.Enum):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
MEAN: Any
|
|
NONE: Any
|
|
ONLY_FIRST_REPLICA: Any
|
|
SUM: Any
|
|
|
|
class VariableSynchronization(enum.Enum):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
AUTO: Any
|
|
NONE: Any
|
|
ON_READ: Any
|
|
ON_WRITE: Any
|
|
|
|
bfloat16: Any
|
|
bool: Any
|
|
complex128: Any
|
|
complex64: Any
|
|
class constant_initializer(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
def __init__(self, value=...) -> None: ...
|
|
@classmethod
|
|
def from_config(cls, config) -> Any: ...
|
|
def get_config(self) -> Any: ...
|
|
|
|
double: Any
|
|
float16: Any
|
|
float32: Any
|
|
float64: Any
|
|
half: Any
|
|
int16: Any
|
|
int32: Any
|
|
int64: Any
|
|
int8: Any
|
|
class name_scope(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
name: Any
|
|
def __init__(self, name) -> None: ...
|
|
|
|
newaxis: Any
|
|
class ones_initializer(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
def __init__(*args, **kwargs) -> None: ...
|
|
@classmethod
|
|
def from_config(cls, config) -> Any: ...
|
|
def get_config(self) -> Any: ...
|
|
|
|
qint16: Any
|
|
qint32: Any
|
|
qint8: Any
|
|
quint16: Any
|
|
quint8: Any
|
|
class random_normal_initializer(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
def __init__(self, mean=..., stddev=..., seed=...) -> None: ...
|
|
@classmethod
|
|
def from_config(cls, config) -> Any: ...
|
|
def get_config(self) -> Any: ...
|
|
|
|
class random_uniform_initializer(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
def __init__(self, minval=..., maxval=..., seed=...) -> None: ...
|
|
@classmethod
|
|
def from_config(cls, config) -> Any: ...
|
|
def get_config(self) -> Any: ...
|
|
|
|
resource: Any
|
|
string: Any
|
|
uint16: Any
|
|
uint32: Any
|
|
uint64: Any
|
|
uint8: Any
|
|
variant: Any
|
|
class zeros_initializer(object):
|
|
_HAS_DYNAMIC_ATTRIBUTES = True
|
|
def __init__(*args, **kwargs) -> None: ...
|
|
@classmethod
|
|
def from_config(cls, config) -> Any: ...
|
|
def get_config(self) -> Any: ...
|
|
|
|
def Assert(condition, data, summarize=..., name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for abs(...)
|
|
@overload
|
|
def abs(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def abs(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def abs(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def abs(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def abs(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def abs(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def abs(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for abs(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for acos(...)
|
|
@overload
|
|
def acos(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def acos(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def acos(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def acos(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def acos(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def acos(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def acos(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for acos(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for acosh(...)
|
|
@overload
|
|
def acosh(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def acosh(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def acosh(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def acosh(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def acosh(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def acosh(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def acosh(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for acosh(...)
|
|
|
|
def add(x, y, name=...) -> Any: ...
|
|
def add_n(inputs, name=...) -> Any: ...
|
|
def approx_top_k(input, k, reduction_dimension=..., recall_target=..., is_max_k=..., reduction_input_size_override=..., aggregate_to_topk=..., name=...) -> Any: ...
|
|
def argmax(input, axis=..., output_type=..., name=...) -> Any: ...
|
|
def argmin(input, axis=..., output_type=..., name=...) -> Any: ...
|
|
def argsort(values, axis=..., direction=..., stable=..., name=...) -> Any: ...
|
|
def as_dtype(type_value) -> Any: ...
|
|
def as_string(input, precision=..., scientific=..., shortest=..., width=..., fill=..., name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for asin(...)
|
|
@overload
|
|
def asin(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def asin(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def asin(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def asin(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def asin(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def asin(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def asin(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for asin(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for asinh(...)
|
|
@overload
|
|
def asinh(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def asinh(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def asinh(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def asinh(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def asinh(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def asinh(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def asinh(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for asinh(...)
|
|
|
|
def assert_equal(x, y, message=..., summarize=..., name=...) -> Any: ...
|
|
def assert_greater(x, y, message=..., summarize=..., name=...) -> Any: ...
|
|
def assert_less(x, y, message=..., summarize=..., name=...) -> Any: ...
|
|
def assert_rank(x, rank, message=..., name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for atan(...)
|
|
@overload
|
|
def atan(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def atan(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def atan(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def atan(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def atan(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def atan(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def atan(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for atan(...)
|
|
|
|
def atan2(y, x, name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for atanh(...)
|
|
@overload
|
|
def atanh(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def atanh(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def atanh(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def atanh(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def atanh(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def atanh(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def atanh(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for atanh(...)
|
|
|
|
def batch_to_space(input, block_shape, crops, name=...) -> Any: ...
|
|
def bitcast(input, type, name=...) -> Any: ...
|
|
def boolean_mask(tensor, mask, axis=..., name=...) -> Any: ...
|
|
def broadcast_dynamic_shape(shape_x, shape_y) -> Any: ...
|
|
def broadcast_static_shape(shape_x, shape_y) -> Any: ...
|
|
def broadcast_to(input, shape, name=...) -> Any: ...
|
|
def case(pred_fn_pairs, default=..., exclusive=..., strict=..., name=...) -> Any: ...
|
|
def cast(x, dtype, name=...) -> Any: ...
|
|
def clip_by_global_norm(t_list, clip_norm, use_norm=..., name=...) -> Any: ...
|
|
def clip_by_norm(t, clip_norm, axes=..., name=...) -> Any: ...
|
|
def clip_by_value(t, clip_value_min, clip_value_max, name=...) -> Any: ...
|
|
def complex(real, imag, name=...) -> Any: ...
|
|
def concat(values, axis, name=...) -> Any: ...
|
|
def cond(pred, true_fn=..., false_fn=..., name=...) -> Any: ...
|
|
def constant(value, dtype=..., shape=..., name=...) -> Any: ...
|
|
def control_dependencies(control_inputs) -> Any: ...
|
|
def convert_to_tensor(value, dtype=..., dtype_hint=..., name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for cos(...)
|
|
@overload
|
|
def cos(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def cos(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def cos(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def cos(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def cos(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def cos(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def cos(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for cos(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for cosh(...)
|
|
@overload
|
|
def cosh(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def cosh(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def cosh(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def cosh(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def cosh(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def cosh(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def cosh(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for cosh(...)
|
|
|
|
def cumsum(x, axis=..., exclusive=..., reverse=..., name=...) -> Any: ...
|
|
def custom_gradient(f=...) -> Any: ...
|
|
def device(device_name) -> Any: ...
|
|
def divide(x, y, name=...) -> Any: ...
|
|
def dynamic_partition(data, partitions, num_partitions, name=...) -> Any: ...
|
|
def dynamic_stitch(indices, data, name=...) -> Any: ...
|
|
def edit_distance(hypothesis, truth, normalize=..., name=...) -> Any: ...
|
|
def eig(tensor, name=...) -> Any: ...
|
|
def eigvals(tensor, name=...) -> Any: ...
|
|
def einsum(equation, *inputs, **kwargs) -> Any: ...
|
|
def ensure_shape(x, shape, name=...) -> Any: ...
|
|
def equal(x, y, name=...) -> Any: ...
|
|
def executing_eagerly() -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for exp(...)
|
|
@overload
|
|
def exp(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def exp(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def exp(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def exp(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def exp(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def exp(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def exp(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for exp(...)
|
|
|
|
def expand_dims(input, axis, name=...) -> Any: ...
|
|
def extract_volume_patches(input, ksizes, strides, padding, name=...) -> Any: ...
|
|
def eye(num_rows, num_columns=..., batch_shape=..., dtype=..., name=...) -> Any: ...
|
|
def fill(dims, value, name=...) -> Any: ...
|
|
def fingerprint(data, method=..., name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for floor(...)
|
|
@overload
|
|
def floor(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def floor(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def floor(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def floor(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def floor(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def floor(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def floor(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for floor(...)
|
|
|
|
def foldl(fn, elems, initializer=..., parallel_iterations=..., back_prop=..., swap_memory=..., name=...) -> Any: ...
|
|
def foldr(fn, elems, initializer=..., parallel_iterations=..., back_prop=..., swap_memory=..., name=...) -> Any: ...
|
|
def function(func=..., input_signature=..., autograph=..., jit_compile=..., reduce_retracing=..., experimental_implements=..., experimental_autograph_options=..., experimental_relax_shapes=..., experimental_compile=..., experimental_follow_type_hints=...) -> Any: ...
|
|
def gather(params, indices, validate_indices=..., axis=..., batch_dims=..., name=...) -> Any: ...
|
|
def gather_nd(params, indices, batch_dims=..., name=...) -> Any: ...
|
|
def get_current_name_scope() -> Any: ...
|
|
def get_logger() -> Any: ...
|
|
def get_static_value(tensor, partial=...) -> Any: ...
|
|
def get_variable(name, shape=..., dtype=..., initializer=..., regularizer=..., trainable=..., collections=..., caching_device=..., partitioner=..., validate_shape=..., use_resource=..., custom_getter=..., constraint=..., synchronization=..., aggregation=...) -> Any: ...
|
|
def grad_pass_through(f) -> Any: ...
|
|
def gradients(ys, xs, grad_ys=..., name=..., gate_gradients=..., aggregation_method=..., stop_gradients=..., unconnected_gradients=...) -> Any: ...
|
|
def greater(x, y, name=...) -> Any: ...
|
|
def greater_equal(x, y, name=...) -> Any: ...
|
|
def group(*inputs, **kwargs) -> Any: ...
|
|
def guarantee_const(input, name=...) -> Any: ...
|
|
def hessians(ys, xs, gate_gradients=..., aggregation_method=..., name=...) -> Any: ...
|
|
def histogram_fixed_width(values, value_range, nbins=..., dtype=..., name=...) -> Any: ...
|
|
def histogram_fixed_width_bins(values, value_range, nbins=..., dtype=..., name=...) -> Any: ...
|
|
def identity(input, name=...) -> Any: ...
|
|
def identity_n(input, name=...) -> Any: ...
|
|
def import_graph_def(graph_def, input_map=..., return_elements=..., name=..., op_dict=..., producer_op_list=...) -> Any: ...
|
|
def init_scope() -> Any: ...
|
|
def inside_function() -> Any: ...
|
|
def is_tensor(x) -> Any: ...
|
|
def less(x, y, name=...) -> Any: ...
|
|
def less_equal(x, y, name=...) -> Any: ...
|
|
def linspace(start, stop, num, name=..., axis=...) -> Any: ...
|
|
def load_library(library_location) -> Any: ...
|
|
def load_op_library(library_filename) -> Any: ...
|
|
def logical_and(x, y, name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for logical_not(...)
|
|
@overload
|
|
def logical_not(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def logical_not(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def logical_not(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def logical_not(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def logical_not(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def logical_not(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def logical_not(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for logical_not(...)
|
|
|
|
def logical_or(x, y, name=...) -> Any: ...
|
|
def make_ndarray(tensor) -> Any: ...
|
|
def make_tensor_proto(values, dtype=..., shape=..., verify_shape=..., allow_broadcast=...) -> Any: ...
|
|
def map_fn(fn, elems, dtype=..., parallel_iterations=..., back_prop=..., swap_memory=..., infer_shape=..., name=..., fn_output_signature=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for matmul(...)
|
|
@overload
|
|
def matmul(
|
|
a: Tensor2[AnyDType, A1, A2],
|
|
b: Tensor2[AnyDType, A2, A3],
|
|
name=...,
|
|
) -> Tensor2[AnyDType, A1, A3]: ...
|
|
|
|
@overload
|
|
def matmul(
|
|
a: Tensor2[AnyDType, A1, A2],
|
|
b: Tensor2[AnyDType, A1, A3],
|
|
transpose_a: TRUE,
|
|
name=...
|
|
) -> Tensor2[AnyDType, A2, A3]: ...
|
|
|
|
@overload
|
|
def matmul(
|
|
a: Tensor2[AnyDType, A1, A2],
|
|
b: Tensor2[AnyDType, A3, A2],
|
|
transpose_b: TRUE,
|
|
name=...
|
|
) -> Tensor2[AnyDType, A1, A3]: ...
|
|
|
|
@overload
|
|
def matmul(
|
|
a: Tensor3[AnyDType, A1, A2, A3],
|
|
b: Tensor2[AnyDType, A3, A4],
|
|
name=...
|
|
) -> Tensor3[AnyDType, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def matmul(
|
|
a: Tensor3[AnyDType, A1, A2, A3],
|
|
b: Tensor2[AnyDType, A4, A3],
|
|
transpose_b: TRUE,
|
|
name=...
|
|
) -> Tensor3[AnyDType, A4, A2, A3]: ...
|
|
|
|
@overload
|
|
def matmul(
|
|
a, b,
|
|
transpose_a=..., transpose_b=...,
|
|
adjoint_a=..., adjoint_b=...,
|
|
a_is_sparse=..., b_is_sparse=...,
|
|
name=...
|
|
) -> Any: ...
|
|
# END: tensor_annotations annotations for matmul(...)
|
|
|
|
def matrix_square_root(input, name=...) -> Any: ...
|
|
def maximum(x, y, name=...) -> Any: ...
|
|
def meshgrid(*args, **kwargs) -> Any: ...
|
|
def minimum(x, y, name=...) -> Any: ...
|
|
def multiply(x, y, name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for negative(...)
|
|
@overload
|
|
def negative(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def negative(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def negative(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def negative(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def negative(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def negative(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def negative(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for negative(...)
|
|
|
|
def no_gradient(op_type) -> Any: ...
|
|
def no_op(name=...) -> Any: ...
|
|
def nondifferentiable_batch_function(num_batch_threads, max_batch_size, batch_timeout_micros, allowed_batch_sizes=..., max_enqueued_batches=..., autograph=..., enable_large_batch_splitting=...) -> Any: ...
|
|
def norm(tensor, ord=..., axis=..., keepdims=..., name=...) -> Any: ...
|
|
def not_equal(x, y, name=...) -> Any: ...
|
|
def numpy_function(func, inp, Tout, stateful=..., name=...) -> Any: ...
|
|
def one_hot(indices, depth, on_value=..., off_value=..., axis=..., dtype=..., name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for ones(...)
|
|
@overload
|
|
def ones(shape: Shape1, dtype=..., name=...) -> Tensor1[AnyDType, Any]: ...
|
|
|
|
@overload
|
|
def ones(shape: Shape2, dtype=..., name=...) -> Tensor2[AnyDType, Any, Any]: ...
|
|
|
|
@overload
|
|
def ones(shape: Shape3, dtype=..., name=...) -> Tensor3[AnyDType, Any, Any, Any]: ...
|
|
|
|
@overload
|
|
def ones(shape: Shape4, dtype=..., name=...) -> Tensor4[AnyDType, Any, Any, Any, Any]: ...
|
|
|
|
@overload
|
|
def ones(shape: Shape5, dtype=..., name=...) -> Tensor5[AnyDType, Any, Any, Any, Any, Any]: ...
|
|
|
|
# See note about Tensor0 in `zeros`
|
|
@overload
|
|
def ones(shape: Tuple[()], dtype=..., name=...) -> Tensor0[AnyDType]: ...
|
|
|
|
@overload
|
|
def ones(shape, dtype=..., name=...) -> AnyDType: ...
|
|
# END: tensor_annotations annotations for ones(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for ones_like(...)
|
|
@overload
|
|
def ones_like(input: Tensor1[AnyDType, A1], dtype=..., name=...) -> Tensor1[AnyDType, A1]: ...
|
|
|
|
@overload
|
|
def ones_like(input: Tensor2[AnyDType, A1, A2], dtype=..., name=...) -> Tensor2[AnyDType, A1, A2]: ...
|
|
|
|
@overload
|
|
def ones_like(input: Tensor3[AnyDType, A1, A2, A3], dtype=..., name=...) -> Tensor3[AnyDType, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def ones_like(input: Tensor4[AnyDType, A1, A2, A3, A4], dtype=..., name=...) -> Tensor4[AnyDType, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def ones_like(input: Tensor5[AnyDType, A1, A2, A3, A4, A5], dtype=..., name=...) -> Tensor5[AnyDType, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def ones_like(input, dtype=..., name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for ones_like(...)
|
|
|
|
def pad(tensor, paddings, mode=..., constant_values=..., name=...) -> Any: ...
|
|
def parallel_stack(values, name=...) -> Any: ...
|
|
def placeholder(dtype, shape=..., name=...) -> Any: ...
|
|
def pow(x, y, name=...) -> Any: ...
|
|
def print(*inputs, **kwargs) -> Any: ...
|
|
def py_function(func, inp, Tout, name=...) -> Any: ...
|
|
def random_index_shuffle(index, seed, max_index, rounds=..., name=...) -> Any: ...
|
|
def range(start, limit=..., delta=..., dtype=..., name=...) -> Any: ...
|
|
def rank(input, name=...) -> Any: ...
|
|
def realdiv(x, y, name=...) -> Any: ...
|
|
def recompute_grad(f) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for reduce_all(...)
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor1[DT, A1],
|
|
axis: L0, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor1[DT, A1],
|
|
axis: LN1, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L0, name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: LN1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L0, name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L1, name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L2, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: LN1, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L0, name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L1, name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L2, name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L3, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: LN1, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L0, name=...) -> Tensor4[DT, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L1, name=...) -> Tensor4[DT, A1, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L2, name=...) -> Tensor4[DT, A1, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L3, name=...) -> Tensor4[DT, A1, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L4, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: LN1, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor3[DT, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor3[DT, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor3[DT, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L4], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor3[DT, A1, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor3[DT, A1, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L4], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor3[DT, A1, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L4], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, L4], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, LN1], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor2[DT, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor2[DT, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L4], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor2[DT, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L4], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, L4], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor2[DT, A1, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L4], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, L4], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, L4], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor1[DT, A5]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L4], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, L4], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, L4], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, L4], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, L4], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor1[DT, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor2[DT, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor2[DT, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor3[DT, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor3[DT, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor4[DT, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor4[DT, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor: Tensor5[DT, A5, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor5[DT, A5, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_all(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for reduce_all(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for reduce_any(...)
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor1[DT, A1],
|
|
axis: L0, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor1[DT, A1],
|
|
axis: LN1, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L0, name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: LN1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L0, name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L1, name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L2, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: LN1, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L0, name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L1, name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L2, name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L3, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: LN1, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L0, name=...) -> Tensor4[DT, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L1, name=...) -> Tensor4[DT, A1, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L2, name=...) -> Tensor4[DT, A1, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L3, name=...) -> Tensor4[DT, A1, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L4, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: LN1, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor3[DT, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor3[DT, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor3[DT, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L4], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor3[DT, A1, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor3[DT, A1, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L4], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor3[DT, A1, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L4], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, L4], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, LN1], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor2[DT, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor2[DT, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L4], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor2[DT, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L4], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, L4], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor2[DT, A1, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L4], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, L4], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, L4], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor1[DT, A5]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L4], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, L4], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, L4], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, L4], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, L4], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor1[DT, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor2[DT, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor2[DT, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor3[DT, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor3[DT, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor4[DT, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor4[DT, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor: Tensor5[DT, A5, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor5[DT, A5, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_any(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for reduce_any(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for reduce_logsumexp(...)
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor1[DT, A1],
|
|
axis: L0, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor1[DT, A1],
|
|
axis: LN1, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L0, name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: LN1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L0, name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L1, name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L2, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: LN1, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L0, name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L1, name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L2, name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L3, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: LN1, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L0, name=...) -> Tensor4[DT, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L1, name=...) -> Tensor4[DT, A1, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L2, name=...) -> Tensor4[DT, A1, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L3, name=...) -> Tensor4[DT, A1, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L4, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: LN1, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor3[DT, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor3[DT, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor3[DT, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L4], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor3[DT, A1, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor3[DT, A1, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L4], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor3[DT, A1, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L4], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, L4], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, LN1], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor2[DT, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor2[DT, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L4], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor2[DT, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L4], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, L4], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor2[DT, A1, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L4], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, L4], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, L4], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor1[DT, A5]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L4], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, L4], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, L4], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, L4], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, L4], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor1[DT, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor2[DT, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor2[DT, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor3[DT, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor3[DT, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor4[DT, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor4[DT, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor: Tensor5[DT, A5, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor5[DT, A5, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_logsumexp(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for reduce_logsumexp(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for reduce_max(...)
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor1[DT, A1],
|
|
axis: L0, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor1[DT, A1],
|
|
axis: LN1, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L0, name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: LN1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L0, name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L1, name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L2, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: LN1, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L0, name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L1, name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L2, name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L3, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: LN1, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L0, name=...) -> Tensor4[DT, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L1, name=...) -> Tensor4[DT, A1, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L2, name=...) -> Tensor4[DT, A1, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L3, name=...) -> Tensor4[DT, A1, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L4, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: LN1, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor3[DT, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor3[DT, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor3[DT, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L4], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor3[DT, A1, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor3[DT, A1, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L4], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor3[DT, A1, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L4], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, L4], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, LN1], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor2[DT, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor2[DT, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L4], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor2[DT, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L4], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, L4], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor2[DT, A1, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L4], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, L4], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, L4], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor1[DT, A5]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L4], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, L4], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, L4], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, L4], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, L4], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor1[DT, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor2[DT, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor2[DT, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor3[DT, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor3[DT, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor4[DT, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor4[DT, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor: Tensor5[DT, A5, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor5[DT, A5, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_max(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for reduce_max(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for reduce_mean(...)
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor1[DT, A1],
|
|
axis: L0, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor1[DT, A1],
|
|
axis: LN1, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L0, name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: LN1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L0, name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L1, name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L2, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: LN1, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L0, name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L1, name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L2, name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L3, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: LN1, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L0, name=...) -> Tensor4[DT, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L1, name=...) -> Tensor4[DT, A1, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L2, name=...) -> Tensor4[DT, A1, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L3, name=...) -> Tensor4[DT, A1, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L4, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: LN1, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor3[DT, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor3[DT, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor3[DT, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L4], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor3[DT, A1, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor3[DT, A1, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L4], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor3[DT, A1, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L4], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, L4], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, LN1], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor2[DT, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor2[DT, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L4], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor2[DT, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L4], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, L4], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor2[DT, A1, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L4], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, L4], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, L4], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor1[DT, A5]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L4], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, L4], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, L4], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, L4], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, L4], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor1[DT, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor2[DT, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor2[DT, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor3[DT, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor3[DT, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor4[DT, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor4[DT, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor: Tensor5[DT, A5, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor5[DT, A5, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_mean(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for reduce_mean(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for reduce_min(...)
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor1[DT, A1],
|
|
axis: L0, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor1[DT, A1],
|
|
axis: LN1, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L0, name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: LN1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L0, name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L1, name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L2, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: LN1, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L0, name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L1, name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L2, name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L3, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: LN1, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L0, name=...) -> Tensor4[DT, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L1, name=...) -> Tensor4[DT, A1, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L2, name=...) -> Tensor4[DT, A1, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L3, name=...) -> Tensor4[DT, A1, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L4, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: LN1, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor3[DT, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor3[DT, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor3[DT, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L4], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor3[DT, A1, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor3[DT, A1, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L4], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor3[DT, A1, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L4], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, L4], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, LN1], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor2[DT, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor2[DT, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L4], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor2[DT, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L4], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, L4], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor2[DT, A1, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L4], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, L4], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, L4], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor1[DT, A5]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L4], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, L4], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, L4], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, L4], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, L4], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor1[DT, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor2[DT, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor2[DT, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor3[DT, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor3[DT, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor4[DT, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor4[DT, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor: Tensor5[DT, A5, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor5[DT, A5, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_min(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for reduce_min(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for reduce_prod(...)
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor1[DT, A1],
|
|
axis: L0, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor1[DT, A1],
|
|
axis: LN1, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L0, name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: LN1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L0, name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L1, name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L2, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: LN1, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L0, name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L1, name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L2, name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L3, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: LN1, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L0, name=...) -> Tensor4[DT, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L1, name=...) -> Tensor4[DT, A1, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L2, name=...) -> Tensor4[DT, A1, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L3, name=...) -> Tensor4[DT, A1, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L4, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: LN1, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor3[DT, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor3[DT, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor3[DT, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L4], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor3[DT, A1, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor3[DT, A1, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L4], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor3[DT, A1, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L4], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, L4], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, LN1], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor2[DT, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor2[DT, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L4], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor2[DT, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L4], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, L4], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor2[DT, A1, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L4], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, L4], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, L4], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor1[DT, A5]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L4], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, L4], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, L4], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, L4], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, L4], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor1[DT, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor2[DT, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor2[DT, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor3[DT, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor3[DT, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor4[DT, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor4[DT, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor: Tensor5[DT, A5, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor5[DT, A5, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_prod(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for reduce_prod(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for reduce_sum(...)
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor1[DT, A1],
|
|
axis: L0, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor1[DT, A1],
|
|
axis: LN1, name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L0, name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: L1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: LN1, name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor2[DT, A1, A2],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L0, name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L1, name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: L2, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: LN1, name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor3[DT, A1, A2, A3],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L0, name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L1, name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L2, name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: L3, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: LN1, name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A1, A2, A3, A4],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L0, name=...) -> Tensor4[DT, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L1, name=...) -> Tensor4[DT, A1, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L2, name=...) -> Tensor4[DT, A1, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L3, name=...) -> Tensor4[DT, A1, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: L4, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: LN1, name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1], name=...) -> Tensor3[DT, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2], name=...) -> Tensor3[DT, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3], name=...) -> Tensor3[DT, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L4], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, LN1], name=...) -> Tensor3[DT, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2], name=...) -> Tensor3[DT, A1, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3], name=...) -> Tensor3[DT, A1, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L4], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, LN1], name=...) -> Tensor3[DT, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3], name=...) -> Tensor3[DT, A1, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L4], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, LN1], name=...) -> Tensor3[DT, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, L4], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L3, LN1], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2], name=...) -> Tensor2[DT, A4, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3], name=...) -> Tensor2[DT, A3, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L4], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, LN1], name=...) -> Tensor2[DT, A3, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3], name=...) -> Tensor2[DT, A2, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L4], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, LN1], name=...) -> Tensor2[DT, A2, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, L4], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L3, LN1], name=...) -> Tensor2[DT, A2, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3], name=...) -> Tensor2[DT, A1, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L4], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, LN1], name=...) -> Tensor2[DT, A1, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, L4], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L3, LN1], name=...) -> Tensor2[DT, A1, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, L4], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L2, L3, LN1], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3], name=...) -> Tensor1[DT, A5]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L4], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, LN1], name=...) -> Tensor1[DT, A4]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, L4], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L3, LN1], name=...) -> Tensor1[DT, A3]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, L4], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L2, L3, LN1], name=...) -> Tensor1[DT, A2]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, L4], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L1, L2, L3, LN1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, L4], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A1, A2, A3, A4, A5],
|
|
axis: Tuple[L0, L1, L2, L3, LN1], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor1[DT, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor2[DT, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor2[DT, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor3[DT, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor3[DT, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor4[DT, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor4[DT, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor: Tensor5[DT, A5, A4, A3, A2, A1],
|
|
axis=..., keepdims: TRUE = ..., name=...) -> Tensor5[DT, A5, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def reduce_sum(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for reduce_sum(...)
|
|
|
|
def register_tensor_conversion_function(base_type, conversion_func, priority=...) -> Any: ...
|
|
def repeat(input, repeats, axis=..., name=...) -> Any: ...
|
|
def required_space_to_batch_paddings(input_shape, block_shape, base_paddings=..., name=...) -> Any: ...
|
|
def reshape(tensor, shape, name=...) -> Any: ...
|
|
def reverse(tensor, axis, name=...) -> Any: ...
|
|
def reverse_sequence(input, seq_lengths, seq_axis=..., batch_axis=..., name=...) -> Any: ...
|
|
def roll(input, shift, axis, name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for round(...)
|
|
@overload
|
|
def round(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def round(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def round(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def round(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def round(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def round(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def round(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for round(...)
|
|
|
|
def saturate_cast(value, dtype, name=...) -> Any: ...
|
|
def scalar_mul(scalar, x, name=...) -> Any: ...
|
|
def scan(fn, elems, initializer=..., parallel_iterations=..., back_prop=..., swap_memory=..., infer_shape=..., reverse=..., name=...) -> Any: ...
|
|
def scatter_nd(indices, updates, shape, name=...) -> Any: ...
|
|
def searchsorted(sorted_sequence, values, side=..., out_type=..., name=...) -> Any: ...
|
|
def sequence_mask(lengths, maxlen=..., dtype=..., name=...) -> Any: ...
|
|
def shape(input, out_type=..., name=...) -> Any: ...
|
|
def shape_n(input, out_type=..., name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for sigmoid(...)
|
|
@overload
|
|
def sigmoid(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def sigmoid(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def sigmoid(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def sigmoid(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def sigmoid(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def sigmoid(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def sigmoid(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for sigmoid(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for sign(...)
|
|
@overload
|
|
def sign(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def sign(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def sign(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def sign(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def sign(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def sign(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def sign(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for sign(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for sin(...)
|
|
@overload
|
|
def sin(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def sin(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def sin(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def sin(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def sin(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def sin(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def sin(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for sin(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for sinh(...)
|
|
@overload
|
|
def sinh(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def sinh(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def sinh(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def sinh(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def sinh(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def sinh(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def sinh(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for sinh(...)
|
|
|
|
def size(input, out_type=..., name=...) -> Any: ...
|
|
def slice(input_, begin, size, name=...) -> Any: ...
|
|
def sort(values, axis=..., direction=..., name=...) -> Any: ...
|
|
def space_to_batch(input, block_shape, paddings, name=...) -> Any: ...
|
|
def space_to_batch_nd(input, block_shape, paddings, name=...) -> Any: ...
|
|
def split(value, num_or_size_splits, axis=..., num=..., name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for sqrt(...)
|
|
@overload
|
|
def sqrt(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def sqrt(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def sqrt(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def sqrt(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def sqrt(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def sqrt(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def sqrt(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for sqrt(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for square(...)
|
|
@overload
|
|
def square(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def square(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def square(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def square(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def square(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def square(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def square(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for square(...)
|
|
|
|
def squeeze(input, axis=..., name=...) -> Any: ...
|
|
def stack(values, axis=..., name=...) -> Any: ...
|
|
def stop_gradient(input, name=...) -> Any: ...
|
|
def strided_slice(input_, begin, end, strides=..., begin_mask=..., end_mask=..., ellipsis_mask=..., new_axis_mask=..., shrink_axis_mask=..., var=..., name=...) -> Any: ...
|
|
def subtract(x, y, name=...) -> Any: ...
|
|
def switch_case(branch_index, branch_fns, default=..., name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for tan(...)
|
|
@overload
|
|
def tan(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def tan(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def tan(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def tan(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def tan(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def tan(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def tan(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for tan(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for tanh(...)
|
|
@overload
|
|
def tanh(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...
|
|
|
|
@overload
|
|
def tanh(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...
|
|
|
|
@overload
|
|
def tanh(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def tanh(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def tanh(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def tanh(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def tanh(x, name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for tanh(...)
|
|
|
|
def tensor_scatter_nd_add(tensor, indices, updates, name=...) -> Any: ...
|
|
def tensor_scatter_nd_max(tensor, indices, updates, name=...) -> Any: ...
|
|
def tensor_scatter_nd_min(tensor, indices, updates, name=...) -> Any: ...
|
|
def tensor_scatter_nd_sub(tensor, indices, updates, name=...) -> Any: ...
|
|
def tensor_scatter_nd_update(tensor, indices, updates, name=...) -> Any: ...
|
|
def tensordot(a, b, axes, name=...) -> Any: ...
|
|
def tile(input, multiples, name=...) -> Any: ...
|
|
def timestamp(name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for transpose(...)
|
|
@overload
|
|
def transpose(a: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A5, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor2[DT, A1, A2], perm: Tuple[L0, L1],
|
|
name=...) -> Tensor2[DT, A1, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor2[DT, A1, A2], perm: Tuple[L1, L0],
|
|
name=...) -> Tensor2[DT, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor3[DT, A1, A2, A3], perm: Tuple[L0, L1, L2],
|
|
name=...) -> Tensor3[DT, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor3[DT, A1, A2, A3], perm: Tuple[L0, L2, L1],
|
|
name=...) -> Tensor3[DT, A1, A3, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor3[DT, A1, A2, A3], perm: Tuple[L1, L0, L2],
|
|
name=...) -> Tensor3[DT, A2, A1, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor3[DT, A1, A2, A3], perm: Tuple[L1, L2, L0],
|
|
name=...) -> Tensor3[DT, A2, A3, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor3[DT, A1, A2, A3], perm: Tuple[L2, L0, L1],
|
|
name=...) -> Tensor3[DT, A3, A1, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor3[DT, A1, A2, A3], perm: Tuple[L2, L1, L0],
|
|
name=...) -> Tensor3[DT, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L0, L1, L2, L3],
|
|
name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L0, L1, L3, L2],
|
|
name=...) -> Tensor4[DT, A1, A2, A4, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L0, L2, L1, L3],
|
|
name=...) -> Tensor4[DT, A1, A3, A2, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L0, L2, L3, L1],
|
|
name=...) -> Tensor4[DT, A1, A3, A4, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L0, L3, L1, L2],
|
|
name=...) -> Tensor4[DT, A1, A4, A2, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L0, L3, L2, L1],
|
|
name=...) -> Tensor4[DT, A1, A4, A3, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L1, L0, L2, L3],
|
|
name=...) -> Tensor4[DT, A2, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L1, L0, L3, L2],
|
|
name=...) -> Tensor4[DT, A2, A1, A4, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L1, L2, L0, L3],
|
|
name=...) -> Tensor4[DT, A2, A3, A1, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L1, L2, L3, L0],
|
|
name=...) -> Tensor4[DT, A2, A3, A4, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L1, L3, L0, L2],
|
|
name=...) -> Tensor4[DT, A2, A4, A1, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L1, L3, L2, L0],
|
|
name=...) -> Tensor4[DT, A2, A4, A3, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L2, L0, L1, L3],
|
|
name=...) -> Tensor4[DT, A3, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L2, L0, L3, L1],
|
|
name=...) -> Tensor4[DT, A3, A1, A4, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L2, L1, L0, L3],
|
|
name=...) -> Tensor4[DT, A3, A2, A1, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L2, L1, L3, L0],
|
|
name=...) -> Tensor4[DT, A3, A2, A4, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L2, L3, L0, L1],
|
|
name=...) -> Tensor4[DT, A3, A4, A1, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L2, L3, L1, L0],
|
|
name=...) -> Tensor4[DT, A3, A4, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L3, L0, L1, L2],
|
|
name=...) -> Tensor4[DT, A4, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L3, L0, L2, L1],
|
|
name=...) -> Tensor4[DT, A4, A1, A3, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L3, L1, L0, L2],
|
|
name=...) -> Tensor4[DT, A4, A2, A1, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L3, L1, L2, L0],
|
|
name=...) -> Tensor4[DT, A4, A2, A3, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L3, L2, L0, L1],
|
|
name=...) -> Tensor4[DT, A4, A3, A1, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor4[DT, A1, A2, A3, A4], perm: Tuple[L3, L2, L1, L0],
|
|
name=...) -> Tensor4[DT, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L1, L2, L3, L4],
|
|
name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L1, L2, L4, L3],
|
|
name=...) -> Tensor5[DT, A1, A2, A3, A5, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L1, L3, L2, L4],
|
|
name=...) -> Tensor5[DT, A1, A2, A4, A3, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L1, L3, L4, L2],
|
|
name=...) -> Tensor5[DT, A1, A2, A4, A5, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L1, L4, L2, L3],
|
|
name=...) -> Tensor5[DT, A1, A2, A5, A3, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L1, L4, L3, L2],
|
|
name=...) -> Tensor5[DT, A1, A2, A5, A4, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L2, L1, L3, L4],
|
|
name=...) -> Tensor5[DT, A1, A3, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L2, L1, L4, L3],
|
|
name=...) -> Tensor5[DT, A1, A3, A2, A5, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L2, L3, L1, L4],
|
|
name=...) -> Tensor5[DT, A1, A3, A4, A2, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L2, L3, L4, L1],
|
|
name=...) -> Tensor5[DT, A1, A3, A4, A5, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L2, L4, L1, L3],
|
|
name=...) -> Tensor5[DT, A1, A3, A5, A2, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L2, L4, L3, L1],
|
|
name=...) -> Tensor5[DT, A1, A3, A5, A4, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L3, L1, L2, L4],
|
|
name=...) -> Tensor5[DT, A1, A4, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L3, L1, L4, L2],
|
|
name=...) -> Tensor5[DT, A1, A4, A2, A5, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L3, L2, L1, L4],
|
|
name=...) -> Tensor5[DT, A1, A4, A3, A2, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L3, L2, L4, L1],
|
|
name=...) -> Tensor5[DT, A1, A4, A3, A5, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L3, L4, L1, L2],
|
|
name=...) -> Tensor5[DT, A1, A4, A5, A2, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L3, L4, L2, L1],
|
|
name=...) -> Tensor5[DT, A1, A4, A5, A3, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L4, L1, L2, L3],
|
|
name=...) -> Tensor5[DT, A1, A5, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L4, L1, L3, L2],
|
|
name=...) -> Tensor5[DT, A1, A5, A2, A4, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L4, L2, L1, L3],
|
|
name=...) -> Tensor5[DT, A1, A5, A3, A2, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L4, L2, L3, L1],
|
|
name=...) -> Tensor5[DT, A1, A5, A3, A4, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L4, L3, L1, L2],
|
|
name=...) -> Tensor5[DT, A1, A5, A4, A2, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L0, L4, L3, L2, L1],
|
|
name=...) -> Tensor5[DT, A1, A5, A4, A3, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L0, L2, L3, L4],
|
|
name=...) -> Tensor5[DT, A2, A1, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L0, L2, L4, L3],
|
|
name=...) -> Tensor5[DT, A2, A1, A3, A5, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L0, L3, L2, L4],
|
|
name=...) -> Tensor5[DT, A2, A1, A4, A3, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L0, L3, L4, L2],
|
|
name=...) -> Tensor5[DT, A2, A1, A4, A5, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L0, L4, L2, L3],
|
|
name=...) -> Tensor5[DT, A2, A1, A5, A3, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L0, L4, L3, L2],
|
|
name=...) -> Tensor5[DT, A2, A1, A5, A4, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L2, L0, L3, L4],
|
|
name=...) -> Tensor5[DT, A2, A3, A1, A4, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L2, L0, L4, L3],
|
|
name=...) -> Tensor5[DT, A2, A3, A1, A5, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L2, L3, L0, L4],
|
|
name=...) -> Tensor5[DT, A2, A3, A4, A1, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L2, L3, L4, L0],
|
|
name=...) -> Tensor5[DT, A2, A3, A4, A5, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L2, L4, L0, L3],
|
|
name=...) -> Tensor5[DT, A2, A3, A5, A1, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L2, L4, L3, L0],
|
|
name=...) -> Tensor5[DT, A2, A3, A5, A4, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L3, L0, L2, L4],
|
|
name=...) -> Tensor5[DT, A2, A4, A1, A3, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L3, L0, L4, L2],
|
|
name=...) -> Tensor5[DT, A2, A4, A1, A5, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L3, L2, L0, L4],
|
|
name=...) -> Tensor5[DT, A2, A4, A3, A1, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L3, L2, L4, L0],
|
|
name=...) -> Tensor5[DT, A2, A4, A3, A5, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L3, L4, L0, L2],
|
|
name=...) -> Tensor5[DT, A2, A4, A5, A1, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L3, L4, L2, L0],
|
|
name=...) -> Tensor5[DT, A2, A4, A5, A3, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L4, L0, L2, L3],
|
|
name=...) -> Tensor5[DT, A2, A5, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L4, L0, L3, L2],
|
|
name=...) -> Tensor5[DT, A2, A5, A1, A4, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L4, L2, L0, L3],
|
|
name=...) -> Tensor5[DT, A2, A5, A3, A1, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L4, L2, L3, L0],
|
|
name=...) -> Tensor5[DT, A2, A5, A3, A4, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L4, L3, L0, L2],
|
|
name=...) -> Tensor5[DT, A2, A5, A4, A1, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L1, L4, L3, L2, L0],
|
|
name=...) -> Tensor5[DT, A2, A5, A4, A3, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L0, L1, L3, L4],
|
|
name=...) -> Tensor5[DT, A3, A1, A2, A4, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L0, L1, L4, L3],
|
|
name=...) -> Tensor5[DT, A3, A1, A2, A5, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L0, L3, L1, L4],
|
|
name=...) -> Tensor5[DT, A3, A1, A4, A2, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L0, L3, L4, L1],
|
|
name=...) -> Tensor5[DT, A3, A1, A4, A5, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L0, L4, L1, L3],
|
|
name=...) -> Tensor5[DT, A3, A1, A5, A2, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L0, L4, L3, L1],
|
|
name=...) -> Tensor5[DT, A3, A1, A5, A4, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L1, L0, L3, L4],
|
|
name=...) -> Tensor5[DT, A3, A2, A1, A4, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L1, L0, L4, L3],
|
|
name=...) -> Tensor5[DT, A3, A2, A1, A5, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L1, L3, L0, L4],
|
|
name=...) -> Tensor5[DT, A3, A2, A4, A1, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L1, L3, L4, L0],
|
|
name=...) -> Tensor5[DT, A3, A2, A4, A5, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L1, L4, L0, L3],
|
|
name=...) -> Tensor5[DT, A3, A2, A5, A1, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L1, L4, L3, L0],
|
|
name=...) -> Tensor5[DT, A3, A2, A5, A4, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L3, L0, L1, L4],
|
|
name=...) -> Tensor5[DT, A3, A4, A1, A2, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L3, L0, L4, L1],
|
|
name=...) -> Tensor5[DT, A3, A4, A1, A5, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L3, L1, L0, L4],
|
|
name=...) -> Tensor5[DT, A3, A4, A2, A1, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L3, L1, L4, L0],
|
|
name=...) -> Tensor5[DT, A3, A4, A2, A5, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L3, L4, L0, L1],
|
|
name=...) -> Tensor5[DT, A3, A4, A5, A1, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L3, L4, L1, L0],
|
|
name=...) -> Tensor5[DT, A3, A4, A5, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L4, L0, L1, L3],
|
|
name=...) -> Tensor5[DT, A3, A5, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L4, L0, L3, L1],
|
|
name=...) -> Tensor5[DT, A3, A5, A1, A4, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L4, L1, L0, L3],
|
|
name=...) -> Tensor5[DT, A3, A5, A2, A1, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L4, L1, L3, L0],
|
|
name=...) -> Tensor5[DT, A3, A5, A2, A4, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L4, L3, L0, L1],
|
|
name=...) -> Tensor5[DT, A3, A5, A4, A1, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L2, L4, L3, L1, L0],
|
|
name=...) -> Tensor5[DT, A3, A5, A4, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L0, L1, L2, L4],
|
|
name=...) -> Tensor5[DT, A4, A1, A2, A3, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L0, L1, L4, L2],
|
|
name=...) -> Tensor5[DT, A4, A1, A2, A5, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L0, L2, L1, L4],
|
|
name=...) -> Tensor5[DT, A4, A1, A3, A2, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L0, L2, L4, L1],
|
|
name=...) -> Tensor5[DT, A4, A1, A3, A5, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L0, L4, L1, L2],
|
|
name=...) -> Tensor5[DT, A4, A1, A5, A2, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L0, L4, L2, L1],
|
|
name=...) -> Tensor5[DT, A4, A1, A5, A3, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L1, L0, L2, L4],
|
|
name=...) -> Tensor5[DT, A4, A2, A1, A3, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L1, L0, L4, L2],
|
|
name=...) -> Tensor5[DT, A4, A2, A1, A5, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L1, L2, L0, L4],
|
|
name=...) -> Tensor5[DT, A4, A2, A3, A1, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L1, L2, L4, L0],
|
|
name=...) -> Tensor5[DT, A4, A2, A3, A5, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L1, L4, L0, L2],
|
|
name=...) -> Tensor5[DT, A4, A2, A5, A1, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L1, L4, L2, L0],
|
|
name=...) -> Tensor5[DT, A4, A2, A5, A3, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L2, L0, L1, L4],
|
|
name=...) -> Tensor5[DT, A4, A3, A1, A2, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L2, L0, L4, L1],
|
|
name=...) -> Tensor5[DT, A4, A3, A1, A5, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L2, L1, L0, L4],
|
|
name=...) -> Tensor5[DT, A4, A3, A2, A1, A5]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L2, L1, L4, L0],
|
|
name=...) -> Tensor5[DT, A4, A3, A2, A5, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L2, L4, L0, L1],
|
|
name=...) -> Tensor5[DT, A4, A3, A5, A1, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L2, L4, L1, L0],
|
|
name=...) -> Tensor5[DT, A4, A3, A5, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L4, L0, L1, L2],
|
|
name=...) -> Tensor5[DT, A4, A5, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L4, L0, L2, L1],
|
|
name=...) -> Tensor5[DT, A4, A5, A1, A3, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L4, L1, L0, L2],
|
|
name=...) -> Tensor5[DT, A4, A5, A2, A1, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L4, L1, L2, L0],
|
|
name=...) -> Tensor5[DT, A4, A5, A2, A3, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L4, L2, L0, L1],
|
|
name=...) -> Tensor5[DT, A4, A5, A3, A1, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L3, L4, L2, L1, L0],
|
|
name=...) -> Tensor5[DT, A4, A5, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L0, L1, L2, L3],
|
|
name=...) -> Tensor5[DT, A5, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L0, L1, L3, L2],
|
|
name=...) -> Tensor5[DT, A5, A1, A2, A4, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L0, L2, L1, L3],
|
|
name=...) -> Tensor5[DT, A5, A1, A3, A2, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L0, L2, L3, L1],
|
|
name=...) -> Tensor5[DT, A5, A1, A3, A4, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L0, L3, L1, L2],
|
|
name=...) -> Tensor5[DT, A5, A1, A4, A2, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L0, L3, L2, L1],
|
|
name=...) -> Tensor5[DT, A5, A1, A4, A3, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L1, L0, L2, L3],
|
|
name=...) -> Tensor5[DT, A5, A2, A1, A3, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L1, L0, L3, L2],
|
|
name=...) -> Tensor5[DT, A5, A2, A1, A4, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L1, L2, L0, L3],
|
|
name=...) -> Tensor5[DT, A5, A2, A3, A1, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L1, L2, L3, L0],
|
|
name=...) -> Tensor5[DT, A5, A2, A3, A4, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L1, L3, L0, L2],
|
|
name=...) -> Tensor5[DT, A5, A2, A4, A1, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L1, L3, L2, L0],
|
|
name=...) -> Tensor5[DT, A5, A2, A4, A3, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L2, L0, L1, L3],
|
|
name=...) -> Tensor5[DT, A5, A3, A1, A2, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L2, L0, L3, L1],
|
|
name=...) -> Tensor5[DT, A5, A3, A1, A4, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L2, L1, L0, L3],
|
|
name=...) -> Tensor5[DT, A5, A3, A2, A1, A4]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L2, L1, L3, L0],
|
|
name=...) -> Tensor5[DT, A5, A3, A2, A4, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L2, L3, L0, L1],
|
|
name=...) -> Tensor5[DT, A5, A3, A4, A1, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L2, L3, L1, L0],
|
|
name=...) -> Tensor5[DT, A5, A3, A4, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L3, L0, L1, L2],
|
|
name=...) -> Tensor5[DT, A5, A4, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L3, L0, L2, L1],
|
|
name=...) -> Tensor5[DT, A5, A4, A1, A3, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L3, L1, L0, L2],
|
|
name=...) -> Tensor5[DT, A5, A4, A2, A1, A3]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L3, L1, L2, L0],
|
|
name=...) -> Tensor5[DT, A5, A4, A2, A3, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L3, L2, L0, L1],
|
|
name=...) -> Tensor5[DT, A5, A4, A3, A1, A2]: ...
|
|
|
|
@overload
|
|
def transpose(a: Tensor5[DT, A1, A2, A3, A4, A5], perm: Tuple[L4, L3, L2, L1, L0],
|
|
name=...) -> Tensor5[DT, A5, A4, A3, A2, A1]: ...
|
|
|
|
@overload
|
|
def transpose(a, perm=..., conjugate=..., name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for transpose(...)
|
|
|
|
def truediv(x, y, name=...) -> Any: ...
|
|
def truncatediv(x, y, name=...) -> Any: ...
|
|
def truncatemod(x, y, name=...) -> Any: ...
|
|
def tuple(tensors, control_inputs=..., name=...) -> Any: ...
|
|
def type_spec_from_value(value) -> Any: ...
|
|
def unique(x, out_idx=..., name=...) -> Any: ...
|
|
def unique_with_counts(x, out_idx=..., name=...) -> Any: ...
|
|
def unravel_index(indices, dims, name=...) -> Any: ...
|
|
def unstack(value, num=..., axis=..., name=...) -> Any: ...
|
|
def variable_creator_scope(variable_creator) -> Any: ...
|
|
def vectorized_map(fn, elems, fallback_to_while_loop=..., warn=...) -> Any: ...
|
|
def where(condition, x=..., y=..., name=...) -> Any: ...
|
|
def while_loop(cond, body, loop_vars, shape_invariants=..., parallel_iterations=..., back_prop=..., swap_memory=..., maximum_iterations=..., name=...) -> Any: ...
|
|
|
|
# BEGIN: tensor_annotations annotations for zeros(...)
|
|
@overload
|
|
def zeros(shape: Shape1, dtype=..., name=...) -> Tensor1[AnyDType, Any]: ...
|
|
|
|
@overload
|
|
def zeros(shape: Shape2, dtype=..., name=...) -> Tensor2[AnyDType, Any, Any]: ...
|
|
|
|
@overload
|
|
def zeros(shape: Shape3, dtype=..., name=...) -> Tensor3[AnyDType, Any, Any, Any]: ...
|
|
|
|
@overload
|
|
def zeros(shape: Shape4, dtype=..., name=...) -> Tensor4[AnyDType, Any, Any, Any, Any]: ...
|
|
|
|
@overload
|
|
def zeros(shape: Shape5, dtype=..., name=...) -> Tensor5[AnyDType, Any, Any, Any, Any, Any]: ...
|
|
|
|
# Tensor0 is down here because otherwise it'd match shape e.g. Tuple[Any, Any]
|
|
# https://github.com/google/pytype/issues/767
|
|
# (e.g. `dim = tf.shape_as_list(x); tf.zeros((dim, dim))` would be Tensor0)
|
|
@overload
|
|
def zeros(shape: Tuple[()], dtype=..., name=...) -> Tensor0[AnyDType]: ...
|
|
|
|
@overload
|
|
def zeros(shape, dtype=..., name=...) -> AnyDType: ...
|
|
# END: tensor_annotations annotations for zeros(...)
|
|
|
|
|
|
# BEGIN: tensor_annotations annotations for zeros_like(...)
|
|
@overload
|
|
def zeros_like(input: Tensor1[AnyDType, A1], dtype=..., name=...) -> Tensor1[AnyDType, A1]: ...
|
|
|
|
@overload
|
|
def zeros_like(input: Tensor2[AnyDType, A1, A2], dtype=..., name=...) -> Tensor2[AnyDType, A1, A2]: ...
|
|
|
|
@overload
|
|
def zeros_like(input: Tensor3[AnyDType, A1, A2, A3], dtype=..., name=...) -> Tensor3[AnyDType, A1, A2, A3]: ...
|
|
|
|
@overload
|
|
def zeros_like(input: Tensor4[AnyDType, A1, A2, A3, A4], dtype=..., name=...) -> Tensor4[AnyDType, A1, A2, A3, A4]: ...
|
|
|
|
@overload
|
|
def zeros_like(input: Tensor5[AnyDType, A1, A2, A3, A4, A5], dtype=..., name=...) -> Tensor5[AnyDType, A1, A2, A3, A4, A5]: ...
|
|
|
|
@overload
|
|
def zeros_like(input, dtype=..., name=...) -> Any: ...
|
|
# END: tensor_annotations annotations for zeros_like(...) |