# PyTorchTensor

PyTorchTensor(self, raw:'torch.Tensor')

# TensorFlowTensor

TensorFlowTensor(self, raw:'tf.Tensor')

# JAXTensor

JAXTensor(self, raw:'np.ndarray')

# NumPyTensor

NumPyTensor(self, raw:'np.ndarray')

# Tensor

Tensor(self, raw:Any)

Base class defining the common interface of all EagerPy Tensors

# sign

Tensor.sign(self:~TensorType) -> ~TensorType

# sqrt

Tensor.sqrt(self:~TensorType) -> ~TensorType

# inv

Tensor.inv(self:~TensorType) -> ~TensorType

# float32

Tensor.float32(self:~TensorType) -> ~TensorType

# where

Tensor.where(self:~TensorType, x:Union[_ForwardRef('Tensor'), int, float], y:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# matmul

Tensor.matmul(self:~TensorType, other:~TensorType) -> ~TensorType

# ndim

# numpy

Tensor.numpy(self:~TensorType) -> Any

# item

Tensor.item(self:~TensorType) -> Union[int, float]

# shape

# reshape

Tensor.reshape(self:~TensorType, shape:Union[Tuple[int, ...], int]) -> ~TensorType

# take_along_axis

Tensor.take_along_axis(self:~TensorType, index:~TensorType, axis:int) -> ~TensorType

# astype

Tensor.astype(self:~TensorType, dtype:Any) -> ~TensorType

# clip

Tensor.clip(self:~TensorType, min_:float, max_:float) -> ~TensorType

# square

Tensor.square(self:~TensorType) -> ~TensorType

# sin

Tensor.sin(self:~TensorType) -> ~TensorType

# cos

Tensor.cos(self:~TensorType) -> ~TensorType

# tan

Tensor.tan(self:~TensorType) -> ~TensorType

# sinh

Tensor.sinh(self:~TensorType) -> ~TensorType

# cosh

Tensor.cosh(self:~TensorType) -> ~TensorType

# tanh

Tensor.tanh(self:~TensorType) -> ~TensorType

# arcsin

Tensor.arcsin(self:~TensorType) -> ~TensorType

# arccos

Tensor.arccos(self:~TensorType) -> ~TensorType

# arctan

Tensor.arctan(self:~TensorType) -> ~TensorType

# arcsinh

Tensor.arcsinh(self:~TensorType) -> ~TensorType

# arccosh

Tensor.arccosh(self:~TensorType) -> ~TensorType

# arctanh

Tensor.arctanh(self:~TensorType) -> ~TensorType

# sum

Tensor.sum(self:~TensorType, axis:Union[int, Tuple[int, ...], NoneType]=None, keepdims:bool=False) -> ~TensorType

# prod

Tensor.prod(self:~TensorType, axis:Union[int, Tuple[int, ...], NoneType]=None, keepdims:bool=False) -> ~TensorType

# mean

Tensor.mean(self:~TensorType, axis:Union[int, Tuple[int, ...], NoneType]=None, keepdims:bool=False) -> ~TensorType

# min

Tensor.min(self:~TensorType, axis:Union[int, Tuple[int, ...], NoneType]=None, keepdims:bool=False) -> ~TensorType

# max

Tensor.max(self:~TensorType, axis:Union[int, Tuple[int, ...], NoneType]=None, keepdims:bool=False) -> ~TensorType

# minimum

Tensor.minimum(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# maximum

Tensor.maximum(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# argmin

Tensor.argmin(self:~TensorType, axis:Union[int, NoneType]=None) -> ~TensorType

# argmax

Tensor.argmax(self:~TensorType, axis:Union[int, NoneType]=None) -> ~TensorType

# argsort

Tensor.argsort(self:~TensorType, axis:int=-1) -> ~TensorType

# topk

Tensor.topk(self:~TensorType, k:int, sorted:bool=True) -> Tuple[~TensorType, ~TensorType]

# uniform

Tensor.uniform(self:~TensorType, shape:Union[Tuple[int, ...], int], low:float=0.0, high:float=1.0) -> ~TensorType

# normal

Tensor.normal(self:~TensorType, shape:Union[Tuple[int, ...], int], mean:float=0.0, stddev:float=1.0) -> ~TensorType

# ones

Tensor.ones(self:~TensorType, shape:Union[Tuple[int, ...], int]) -> ~TensorType

# zeros

Tensor.zeros(self:~TensorType, shape:Union[Tuple[int, ...], int]) -> ~TensorType

# ones_like

Tensor.ones_like(self:~TensorType) -> ~TensorType

# zeros_like

Tensor.zeros_like(self:~TensorType) -> ~TensorType

# full_like

Tensor.full_like(self:~TensorType, fill_value:float) -> ~TensorType

# onehot_like

Tensor.onehot_like(self:~TensorType, indices:~TensorType, *, value:float=1) -> ~TensorType

# from_numpy

Tensor.from_numpy(self:~TensorType, a:Any) -> ~TensorType

# transpose

Tensor.transpose(self:~TensorType, axes:Union[Tuple[int, ...], NoneType]=None) -> ~TensorType

# bool

Tensor.bool(self:~TensorType) -> ~TensorType

# all

Tensor.all(self:~TensorType, axis:Union[int, Tuple[int, ...], NoneType]=None, keepdims:bool=False) -> ~TensorType

# any

Tensor.any(self:~TensorType, axis:Union[int, Tuple[int, ...], NoneType]=None, keepdims:bool=False) -> ~TensorType

# logical_and

Tensor.logical_and(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# logical_or

Tensor.logical_or(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# logical_not

Tensor.logical_not(self:~TensorType) -> ~TensorType

# exp

Tensor.exp(self:~TensorType) -> ~TensorType

# log

Tensor.log(self:~TensorType) -> ~TensorType

# log2

Tensor.log2(self:~TensorType) -> ~TensorType

# log10

Tensor.log10(self:~TensorType) -> ~TensorType

# log1p

Tensor.log1p(self:~TensorType) -> ~TensorType

# tile

Tensor.tile(self:~TensorType, multiples:Tuple[int, ...]) -> ~TensorType

# softmax

Tensor.softmax(self:~TensorType, axis:int=-1) -> ~TensorType

# log_softmax

Tensor.log_softmax(self:~TensorType, axis:int=-1) -> ~TensorType

# squeeze

Tensor.squeeze(self:~TensorType, axis:Union[int, Tuple[int, ...], NoneType]=None) -> ~TensorType

# expand_dims

Tensor.expand_dims(self:~TensorType, axis:int) -> ~TensorType

# full

Tensor.full(self:~TensorType, shape:Union[Tuple[int, ...], int], value:float) -> ~TensorType

# index_update

Tensor.index_update(self:~TensorType, indices:Any, values:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# arange

Tensor.arange(self:~TensorType, start:int, stop:Union[int, NoneType]=None, step:Union[int, NoneType]=None) -> ~TensorType

# cumsum

Tensor.cumsum(self:~TensorType, axis:Union[int, NoneType]=None) -> ~TensorType

# flip

Tensor.flip(self:~TensorType, axis:Union[int, Tuple[int, ...], NoneType]=None) -> ~TensorType

# meshgrid

Tensor.meshgrid(self:~TensorType, *tensors:~TensorType, indexing:str='xy') -> Tuple[~TensorType, ...]

# pad

Tensor.pad(self:~TensorType, paddings:Tuple[Tuple[int, int], ...], mode:str='constant', value:float=0) -> ~TensorType

# isnan

Tensor.isnan(self:~TensorType) -> ~TensorType

# isinf

Tensor.isinf(self:~TensorType) -> ~TensorType

# crossentropy

Tensor.crossentropy(self:~TensorType, labels:~TensorType) -> ~TensorType

# T

# abs

Tensor.abs(self:~TensorType) -> ~TensorType

# pow

Tensor.pow(self:~TensorType, exponent:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# value_and_grad

Tensor.value_and_grad(self:~TensorType, f:Callable[..., ~TensorType], *args:Any, **kwargs:Any) -> Tuple[~TensorType, ~TensorType]

# value_aux_and_grad

Tensor.value_aux_and_grad(self:~TensorType, f:Callable[..., Tuple[~TensorType, Any]], *args:Any, **kwargs:Any) -> Tuple[~TensorType, Any, ~TensorType]

# flatten

Tensor.flatten(self:~TensorType, start:int=0, end:int=-1) -> ~TensorType

# l0

NormsMethods.l0(x:~TensorType, axis:Union[int, Tuple[int, ...], NoneType]=None, keepdims:bool=False) -> ~TensorType

# l1

NormsMethods.l1(x:~TensorType, axis:Union[int, Tuple[int, ...], NoneType]=None, keepdims:bool=False) -> ~TensorType

# l2

NormsMethods.l2(x:~TensorType, axis:Union[int, Tuple[int, ...], NoneType]=None, keepdims:bool=False) -> ~TensorType

# linf

NormsMethods.linf(x:~TensorType, axis:Union[int, Tuple[int, ...], NoneType]=None, keepdims:bool=False) -> ~TensorType

# lp

NormsMethods.lp(x:~TensorType, p:Union[int, float], axis:Union[int, Tuple[int, ...], NoneType]=None, keepdims:bool=False) -> ~TensorType

# raw

# dtype

# init

Tensor.__init__(self, raw:Any)

# repr

Tensor.__repr__(self:~TensorType) -> str

# format

Tensor.__format__(self:~TensorType, format_spec:str) -> str

# getitem

Tensor.__getitem__(self:~TensorType, index:Any) -> ~TensorType

# iter

Tensor.__iter__(self:~TensorType) -> Iterator[~TensorType]

# bool

Tensor.__bool__(self:~TensorType) -> bool

# len

Tensor.__len__(self:~TensorType) -> int

# abs

Tensor.__abs__(self:~TensorType) -> ~TensorType

# neg

Tensor.__neg__(self:~TensorType) -> ~TensorType

# add

Tensor.__add__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# radd

Tensor.__radd__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# sub

Tensor.__sub__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# rsub

Tensor.__rsub__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# mul

Tensor.__mul__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# rmul

Tensor.__rmul__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# truediv

Tensor.__truediv__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# rtruediv

Tensor.__rtruediv__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# floordiv

Tensor.__floordiv__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# rfloordiv

Tensor.__rfloordiv__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# mod

Tensor.__mod__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# lt

Tensor.__lt__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# le

Tensor.__le__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# eq

Tensor.__eq__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# ne

Tensor.__ne__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# gt

Tensor.__gt__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# ge

Tensor.__ge__(self:~TensorType, other:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

# pow

Tensor.__pow__(self:~TensorType, exponent:Union[_ForwardRef('Tensor'), int, float]) -> ~TensorType

← Overview eagerpy.* →