robocar-training/tensorflow-stubs/math/__init__.pyi

# 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

from typing import Any

def __getattr__(name) -> Any: ...

_HAS_DYNAMIC_ATTRIBUTES = True


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

def accumulate_n(inputs, shape=..., tensor_dtype=..., name=...) -> Any: ...

# 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 angle(input, name=...) -> Any: ...
def approx_max_k(operand, k, reduction_dimension=..., recall_target=..., reduction_input_size_override=..., aggregate_to_topk=..., name=...) -> Any: ...
def approx_min_k(operand, k, reduction_dimension=..., recall_target=..., 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: ...

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


# 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 bessel_i0(x, name=...) -> Any: ...
def bessel_i0e(x, name=...) -> Any: ...
def bessel_i1(x, name=...) -> Any: ...
def bessel_i1e(x, name=...) -> Any: ...
def betainc(a, b, x, name=...) -> Any: ...
def bincount(arr, weights=..., minlength=..., maxlength=..., dtype=..., name=..., axis=..., binary_output=...) -> Any: ...
def ceil(x, name=...) -> Any: ...
def confusion_matrix(labels, predictions, num_classes=..., weights=..., dtype=..., name=...) -> Any: ...
def conj(x, 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 count_nonzero(input, axis=..., keepdims=..., dtype=..., name=...) -> Any: ...
def cumprod(x, axis=..., exclusive=..., reverse=..., name=...) -> Any: ...
def cumsum(x, axis=..., exclusive=..., reverse=..., name=...) -> Any: ...
def cumulative_logsumexp(x, axis=..., exclusive=..., reverse=..., name=...) -> Any: ...
def digamma(x, name=...) -> Any: ...
def divide(x, y, name=...) -> Any: ...
def divide_no_nan(x, y, name=...) -> Any: ...
def equal(x, y, name=...) -> Any: ...

# BEGIN: tensor_annotations annotations for erf(...)
@overload
def erf(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def erf(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def erf(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def erf(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def erf(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def erf(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def erf(x, name=...) -> Any: ...
# END: tensor_annotations annotations for erf(...)


# BEGIN: tensor_annotations annotations for erfc(...)
@overload
def erfc(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def erfc(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def erfc(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def erfc(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def erfc(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def erfc(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def erfc(x, name=...) -> Any: ...
# END: tensor_annotations annotations for erfc(...)

def erfcinv(x, name=...) -> Any: ...

# BEGIN: tensor_annotations annotations for erfinv(...)
@overload
def erfinv(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def erfinv(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def erfinv(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def erfinv(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def erfinv(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def erfinv(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def erfinv(x, name=...) -> Any: ...
# END: tensor_annotations annotations for erfinv(...)


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


# BEGIN: tensor_annotations annotations for expm1(...)
@overload
def expm1(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def expm1(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def expm1(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def expm1(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def expm1(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def expm1(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def expm1(x, name=...) -> Any: ...
# END: tensor_annotations annotations for expm1(...)


# 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 floordiv(x, y, name=...) -> Any: ...
def floormod(x, y, name=...) -> Any: ...
def greater(x, y, name=...) -> Any: ...
def greater_equal(x, y, name=...) -> Any: ...
def igamma(a, x, name=...) -> Any: ...
def igammac(a, x, name=...) -> Any: ...
def imag(input, name=...) -> Any: ...
def in_top_k(targets, predictions, k, name=...) -> Any: ...
def invert_permutation(x, name=...) -> Any: ...

# BEGIN: tensor_annotations annotations for is_finite(...)
@overload
def is_finite(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def is_finite(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def is_finite(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def is_finite(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def is_finite(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def is_finite(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def is_finite(x, name=...) -> Any: ...
# END: tensor_annotations annotations for is_finite(...)


# BEGIN: tensor_annotations annotations for is_inf(...)
@overload
def is_inf(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def is_inf(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def is_inf(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def is_inf(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def is_inf(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def is_inf(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def is_inf(x, name=...) -> Any: ...
# END: tensor_annotations annotations for is_inf(...)


# BEGIN: tensor_annotations annotations for is_nan(...)
@overload
def is_nan(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def is_nan(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def is_nan(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def is_nan(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def is_nan(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def is_nan(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def is_nan(x, name=...) -> Any: ...
# END: tensor_annotations annotations for is_nan(...)

def is_non_decreasing(x, name=...) -> Any: ...
def is_strictly_increasing(x, name=...) -> Any: ...
def l2_normalize(x, axis=..., epsilon=..., name=..., dim=...) -> Any: ...

# BEGIN: tensor_annotations annotations for lbeta(...)
@overload
def lbeta(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def lbeta(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def lbeta(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def lbeta(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def lbeta(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def lbeta(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def lbeta(x, name=...) -> Any: ...
# END: tensor_annotations annotations for lbeta(...)

def less(x, y, name=...) -> Any: ...
def less_equal(x, y, name=...) -> Any: ...

# BEGIN: tensor_annotations annotations for lgamma(...)
@overload
def lgamma(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def lgamma(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def lgamma(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def lgamma(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def lgamma(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def lgamma(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def lgamma(x, name=...) -> Any: ...
# END: tensor_annotations annotations for lgamma(...)


# BEGIN: tensor_annotations annotations for log(...)
@overload
def log(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def log(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def log(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def log(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def log(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def log(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def log(x, name=...) -> Any: ...
# END: tensor_annotations annotations for log(...)


# BEGIN: tensor_annotations annotations for log1p(...)
@overload
def log1p(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def log1p(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def log1p(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def log1p(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def log1p(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def log1p(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def log1p(x, name=...) -> Any: ...
# END: tensor_annotations annotations for log1p(...)


# BEGIN: tensor_annotations annotations for log_sigmoid(...)
@overload
def log_sigmoid(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def log_sigmoid(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def log_sigmoid(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def log_sigmoid(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def log_sigmoid(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def log_sigmoid(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def log_sigmoid(x, name=...) -> Any: ...
# END: tensor_annotations annotations for log_sigmoid(...)

def log_softmax(logits, axis=..., name=...) -> 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 logical_xor(x, y, name=...) -> Any: ...
def maximum(x, y, name=...) -> Any: ...
def minimum(x, y, name=...) -> Any: ...
def mod(x, y, name=...) -> Any: ...
def multiply(x, y, name=...) -> Any: ...
def multiply_no_nan(x, y, name=...) -> Any: ...

# BEGIN: tensor_annotations annotations for ndtri(...)
@overload
def ndtri(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def ndtri(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def ndtri(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def ndtri(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def ndtri(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def ndtri(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def ndtri(x, name=...) -> Any: ...
# END: tensor_annotations annotations for ndtri(...)


# 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 nextafter(x1, x2, name=...) -> Any: ...
def not_equal(x, y, name=...) -> Any: ...
def polygamma(a, x, name=...) -> Any: ...
def polyval(coeffs, x, name=...) -> Any: ...
def pow(x, y, name=...) -> Any: ...
def real(input, name=...) -> Any: ...

# BEGIN: tensor_annotations annotations for reciprocal(...)
@overload
def reciprocal(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def reciprocal(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def reciprocal(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def reciprocal(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def reciprocal(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def reciprocal(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def reciprocal(x, name=...) -> Any: ...
# END: tensor_annotations annotations for reciprocal(...)


# BEGIN: tensor_annotations annotations for reciprocal_no_nan(...)
@overload
def reciprocal_no_nan(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def reciprocal_no_nan(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def reciprocal_no_nan(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def reciprocal_no_nan(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def reciprocal_no_nan(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def reciprocal_no_nan(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def reciprocal_no_nan(x, name=...) -> Any: ...
# END: tensor_annotations annotations for reciprocal_no_nan(...)

def reduce_all(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
def reduce_any(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
def reduce_euclidean_norm(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
def reduce_logsumexp(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
def reduce_max(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
def reduce_mean(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
def reduce_min(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
def reduce_prod(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
def reduce_std(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
def reduce_sum(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...
def reduce_variance(input_tensor, axis=..., keepdims=..., name=...) -> Any: ...

# BEGIN: tensor_annotations annotations for rint(...)
@overload
def rint(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def rint(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def rint(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def rint(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def rint(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def rint(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def rint(x, name=...) -> Any: ...
# END: tensor_annotations annotations for rint(...)


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


# BEGIN: tensor_annotations annotations for rsqrt(...)
@overload
def rsqrt(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def rsqrt(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def rsqrt(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def rsqrt(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def rsqrt(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def rsqrt(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def rsqrt(x, name=...) -> Any: ...
# END: tensor_annotations annotations for rsqrt(...)

def scalar_mul(scalar, x, name=...) -> Any: ...
def segment_max(data, segment_ids, name=...) -> Any: ...
def segment_mean(data, segment_ids, name=...) -> Any: ...
def segment_min(data, segment_ids, name=...) -> Any: ...
def segment_prod(data, segment_ids, name=...) -> Any: ...
def segment_sum(data, segment_ids, 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 sobol_sample(dim, num_results, skip=..., dtype=..., name=...) -> Any: ...
def softmax(logits, axis=..., name=...) -> Any: ...

# BEGIN: tensor_annotations annotations for softplus(...)
@overload
def softplus(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def softplus(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def softplus(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def softplus(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def softplus(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def softplus(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def softplus(x, name=...) -> Any: ...
# END: tensor_annotations annotations for softplus(...)


# BEGIN: tensor_annotations annotations for softsign(...)
@overload
def softsign(x: Tensor0[DT], name=...) -> Tensor0[DT]: ...

@overload
def softsign(x: Tensor1[DT, A1], name=...) -> Tensor1[DT, A1]: ...

@overload
def softsign(x: Tensor2[DT, A1, A2], name=...) -> Tensor2[DT, A1, A2]: ...

@overload
def softsign(x: Tensor3[DT, A1, A2, A3], name=...) -> Tensor3[DT, A1, A2, A3]: ...

@overload
def softsign(x: Tensor4[DT, A1, A2, A3, A4], name=...) -> Tensor4[DT, A1, A2, A3, A4]: ...

@overload
def softsign(x: Tensor5[DT, A1, A2, A3, A4, A5], name=...) -> Tensor5[DT, A1, A2, A3, A4, A5]: ...

@overload
def softsign(x, name=...) -> Any: ...
# END: tensor_annotations annotations for softsign(...)


# 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 squared_difference(x, y, name=...) -> Any: ...
def subtract(x, y, 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 top_k(input, k=..., sorted=..., name=...) -> Any: ...
def truediv(x, y, name=...) -> Any: ...
def unsorted_segment_max(data, segment_ids, num_segments, name=...) -> Any: ...
def unsorted_segment_mean(data, segment_ids, num_segments, name=...) -> Any: ...
def unsorted_segment_min(data, segment_ids, num_segments, name=...) -> Any: ...
def unsorted_segment_prod(data, segment_ids, num_segments, name=...) -> Any: ...
def unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=...) -> Any: ...
def unsorted_segment_sum(data, segment_ids, num_segments, name=...) -> Any: ...
def xdivy(x, y, name=...) -> Any: ...
def xlog1py(x, y, name=...) -> Any: ...
def xlogy(x, y, name=...) -> Any: ...
def zero_fraction(value, name=...) -> Any: ...
def zeta(x, q, name=...) -> Any: ...