TorchScript Builtins¶
This is a full reference of functions and Tensor methods accessible in TorchScript
Supported Functions¶
torch.nn.functional.adaptive_avg_pool2d(input : Tensor,
output_size : List[int]) -> Tensor
torch.nn.functional.adaptive_avg_pool3d(input : Tensor,
output_size : List[int]) -> Tensor
torch.nn.functional.adaptive_max_pool1d_with_indices(input : Tensor,
output_size : List[int],
return_indices : bool=False) -> Tuple[Tensor, Tensor]
torch.nn.functional.adaptive_max_pool2d_with_indices(input : Tensor,
output_size : List[int],
return_indices : bool=False) -> Tuple[Tensor, Tensor]
torch.nn.functional.adaptive_max_pool3d_with_indices(input : Tensor,
output_size : List[int],
return_indices : bool=False) -> Tuple[Tensor, Tensor]
torch.nn.functional.affine_grid(theta : Tensor,
size : List[int],
align_corners : Optional[bool]) -> Tensor
torch.nn.functional.alpha_dropout(input : Tensor,
p : float=0.5,
training : bool=False,
inplace : bool=False) -> Tensor
torch.nn.functional.batch_norm(input : Tensor,
running_mean : Optional[Tensor],
running_var : Optional[Tensor],
weight : Optional[Tensor],
bias : Optional[Tensor],
training : bool=False,
momentum : float=0.1,
eps : float=1e-05) -> Tensor
torch.nn.functional.bilinear(input1 : Tensor,
input2 : Tensor,
weight : Tensor,
bias : Optional[Tensor]) -> Tensor
torch.nn.functional.binary_cross_entropy(input : Tensor,
target : Tensor,
weight : Optional[Tensor],
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.binary_cross_entropy_with_logits(input : Tensor,
target : Tensor,
weight : Optional[Tensor],
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean,
pos_weight : Optional[Tensor]) -> Tensor
torch.nn.functional.celu(input : Tensor,
alpha : float=1.0,
inplace : bool=False) -> Tensor
torch.nn.functional.cosine_embedding_loss(input1 : Tensor,
input2 : Tensor,
target : Tensor,
margin : float=0.0,
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.cross_entropy(input : Tensor,
target : Tensor,
weight : Optional[Tensor],
size_average : Optional[bool],
ignore_index : int=-100,
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.ctc_loss(log_probs : Tensor,
targets : Tensor,
input_lengths : Tensor,
target_lengths : Tensor,
blank : int=0,
reduction : str=mean,
zero_infinity : bool=False) -> Tensor
torch.nn.functional.dropout(input : Tensor,
p : float=0.5,
training : bool=True,
inplace : bool=False) -> Tensor
torch.nn.functional.dropout2d(input : Tensor,
p : float=0.5,
training : bool=True,
inplace : bool=False) -> Tensor
torch.nn.functional.dropout3d(input : Tensor,
p : float=0.5,
training : bool=True,
inplace : bool=False) -> Tensor
torch.nn.functional.elu(input : Tensor,
alpha : float=1.0,
inplace : bool=False) -> Tensor
torch.nn.functional.embedding(input : Tensor,
weight : Tensor,
padding_idx : Optional[int],
max_norm : Optional[float],
norm_type : float=2.0,
scale_grad_by_freq : bool=False,
sparse : bool=False) -> Tensor
torch.nn.functional.embedding_bag(input : Tensor,
weight : Tensor,
offsets : Optional[Tensor],
max_norm : Optional[float],
norm_type : float=2.0,
scale_grad_by_freq : bool=False,
mode : str=mean,
sparse : bool=False,
per_sample_weights : Optional[Tensor]) -> Tensor
torch.nn.functional.feature_alpha_dropout(input : Tensor,
p : float=0.5,
training : bool=False,
inplace : bool=False) -> Tensor
torch.nn.functional.fold(input : Tensor,
output_size : List[int],
kernel_size : List[int],
dilation : List[int]=1,
padding : List[int]=0,
stride : List[int]=1) -> Tensor
torch.nn.functional.fractional_max_pool2d_with_indices(input : Tensor,
kernel_size : List[int],
output_size : Optional[List[int]],
output_ratio : Optional[List[float]],
return_indices : bool=False,
_random_samples : Optional[Tensor]) -> Tuple[Tensor, Tensor]
torch.nn.functional.fractional_max_pool3d_with_indices(input : Tensor,
kernel_size : List[int],
output_size : Optional[List[int]],
output_ratio : Optional[List[float]],
return_indices : bool=False,
_random_samples : Optional[Tensor]) -> Tuple[Tensor, Tensor]
torch.nn.functional.gelu(input : Tensor) -> Tensor
torch.nn.functional.glu(input : Tensor,
dim : int=-1) -> Tensor
torch.nn.functional.grid_sample(input : Tensor,
grid : Tensor,
mode : str=bilinear,
padding_mode : str=zeros,
align_corners : Optional[bool]) -> Tensor
torch.nn.functional.group_norm(input : Tensor,
num_groups : int,
weight : Optional[Tensor],
bias : Optional[Tensor],
eps : float=1e-05) -> Tensor
torch.nn.functional.gumbel_softmax(logits : Tensor,
tau : float=1.0,
hard : bool=False,
eps : float=1e-10,
dim : int=-1) -> Tensor
torch.nn.functional.hardshrink(input : Tensor,
lambd : float=0.5) -> Tensor
torch.nn.functional.hardtanh(input : Tensor,
min_val : float=-1.0,
max_val : float=1.0,
inplace : bool=False) -> Tensor
torch.nn.functional.hinge_embedding_loss(input : Tensor,
target : Tensor,
margin : float=1.0,
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.instance_norm(input : Tensor,
running_mean : Optional[Tensor],
running_var : Optional[Tensor],
weight : Optional[Tensor],
bias : Optional[Tensor],
use_input_stats : bool=True,
momentum : float=0.1,
eps : float=1e-05) -> Tensor
torch.nn.functional.kl_div(input : Tensor,
target : Tensor,
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.l1_loss(input : Tensor,
target : Tensor,
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.layer_norm(input : Tensor,
normalized_shape : List[int],
weight : Optional[Tensor],
bias : Optional[Tensor],
eps : float=1e-05) -> Tensor
torch.nn.functional.leaky_relu(input : Tensor,
negative_slope : float=0.01,
inplace : bool=False) -> Tensor
torch.nn.functional.linear(input : Tensor,
weight : Tensor,
bias : Optional[Tensor]) -> Tensor
torch.nn.functional.local_response_norm(input : Tensor,
size : int,
alpha : float=0.0001,
beta : float=0.75,
k : float=1.0) -> Tensor
torch.nn.functional.log_softmax(input : Tensor,
dim : Optional[int],
_stacklevel : int=3,
dtype : Optional[int]) -> Tensor
torch.nn.functional.lp_pool1d(input : Tensor,
norm_type : float,
kernel_size : int,
stride : Optional[List[int]],
ceil_mode : bool=False) -> Tensor
torch.nn.functional.lp_pool2d(input : Tensor,
norm_type : float,
kernel_size : int,
stride : Optional[List[int]],
ceil_mode : bool=False) -> Tensor
torch.nn.functional.margin_ranking_loss(input1 : Tensor,
input2 : Tensor,
target : Tensor,
margin : float=0.0,
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.max_pool1d_with_indices(input : Tensor,
kernel_size : List[int],
stride : Optional[List[int]],
padding : List[int]=0,
dilation : List[int]=1,
ceil_mode : bool=False,
return_indices : bool=False) -> Tuple[Tensor, Tensor]
torch.nn.functional.max_pool2d_with_indices(input : Tensor,
kernel_size : List[int],
stride : Optional[List[int]],
padding : List[int]=0,
dilation : List[int]=1,
ceil_mode : bool=False,
return_indices : bool=False) -> Tuple[Tensor, Tensor]
torch.nn.functional.max_pool3d_with_indices(input : Tensor,
kernel_size : List[int],
stride : Optional[List[int]],
padding : List[int]=0,
dilation : List[int]=1,
ceil_mode : bool=False,
return_indices : bool=False) -> Tuple[Tensor, Tensor]
torch.nn.functional.max_unpool1d(input : Tensor,
indices : Tensor,
kernel_size : List[int],
stride : Optional[List[int]],
padding : List[int]=0,
output_size : Optional[List[int]]) -> Tensor
torch.nn.functional.max_unpool2d(input : Tensor,
indices : Tensor,
kernel_size : List[int],
stride : Optional[List[int]],
padding : List[int]=0,
output_size : Optional[List[int]]) -> Tensor
torch.nn.functional.max_unpool3d(input : Tensor,
indices : Tensor,
kernel_size : List[int],
stride : Optional[List[int]],
padding : List[int]=0,
output_size : Optional[List[int]]) -> Tensor
torch.nn.functional.mse_loss(input : Tensor,
target : Tensor,
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.multi_head_attention_forward(query : Tensor,
key : Tensor,
value : Tensor,
embed_dim_to_check : int,
num_heads : int,
in_proj_weight : Tensor,
in_proj_bias : Tensor,
bias_k : Optional[Tensor],
bias_v : Optional[Tensor],
add_zero_attn : bool,
dropout_p : float,
out_proj_weight : Tensor,
out_proj_bias : Tensor,
training : bool=True,
key_padding_mask : Optional[Tensor],
need_weights : bool=True,
attn_mask : Optional[Tensor],
use_separate_proj_weight : bool=False,
q_proj_weight : Optional[Tensor],
k_proj_weight : Optional[Tensor],
v_proj_weight : Optional[Tensor],
static_k : Optional[Tensor],
static_v : Optional[Tensor]) -> Tuple[Tensor, Optional[Tensor]]
torch.nn.functional.multi_margin_loss(input : Tensor,
target : Tensor,
p : int=1,
margin : float=1.0,
weight : Optional[Tensor],
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.multilabel_margin_loss(input : Tensor,
target : Tensor,
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.multilabel_soft_margin_loss(input : Tensor,
target : Tensor,
weight : Optional[Tensor],
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.nll_loss(input : Tensor,
target : Tensor,
weight : Optional[Tensor],
size_average : Optional[bool],
ignore_index : int=-100,
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.normalize(input : Tensor,
p : float=2.0,
dim : int=1,
eps : float=1e-12,
out : Optional[Tensor]) -> Tensor
torch.nn.functional.pad(input : Tensor,
pad : List[int],
mode : str=constant,
value : float=0.0) -> Tensor
torch.nn.functional.pairwise_distance(x1 : Tensor,
x2 : Tensor,
p : float=2.0,
eps : float=1e-06,
keepdim : bool=False) -> Tensor
torch.nn.functional.poisson_nll_loss(input : Tensor,
target : Tensor,
log_input : bool=True,
full : bool=False,
size_average : Optional[bool],
eps : float=1e-08,
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.prelu(input : Tensor,
weight : Tensor) -> Tensor
torch.nn.functional.relu(input : Tensor,
inplace : bool=False) -> Tensor
torch.nn.functional.relu6(input : Tensor,
inplace : bool=False) -> Tensor
torch.nn.functional.rrelu(input : Tensor,
lower : float=0.125,
upper : float=0.3333333333333333,
training : bool=False,
inplace : bool=False) -> Tensor
torch.nn.functional.selu(input : Tensor,
inplace : bool=False) -> Tensor
torch.nn.functional.sigmoid(input : Tensor) -> Tensor
torch.nn.functional.smooth_l1_loss(input : Tensor,
target : Tensor,
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.soft_margin_loss(input : Tensor,
target : Tensor,
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.softmax(input : Tensor,
dim : Optional[int],
_stacklevel : int=3,
dtype : Optional[int]) -> Tensor
torch.nn.functional.softmin(input : Tensor,
dim : Optional[int],
_stacklevel : int=3,
dtype : Optional[int]) -> Tensor
torch.nn.functional.softsign(input : Tensor) -> Tensor
torch.nn.functional.tanh(input : Tensor) -> Tensor
torch.nn.functional.tanhshrink(input : Tensor) -> Tensor
torch.nn.functional.threshold(input : Tensor,
threshold : float,
value : float,
inplace : bool=False) -> Tensor
torch.nn.functional.triplet_margin_loss(anchor : Tensor,
positive : Tensor,
negative : Tensor,
margin : float=1.0,
p : float=2.0,
eps : float=1e-06,
swap : bool=False,
size_average : Optional[bool],
reduce : Optional[bool],
reduction : str=mean) -> Tensor
torch.nn.functional.unfold(input : Tensor,
kernel_size : List[int],
dilation : List[int]=1,
padding : List[int]=0,
stride : List[int]=1) -> Tensor
torch.jit.is_scripting() -> bool
collections.OrderedDict() -> Dict[str, Tensor]
collections.OrderedDict(inputs : List[Tuple[str, tVal]]) -> Dict[str, tVal]
collections.OrderedDict(inputs : List[Tuple[int, tVal]]) -> Dict[int, tVal]
collections.OrderedDict(inputs : List[Tuple[float, tVal]]) -> Dict[float, tVal]
collections.OrderedDict(inputs : List[Tuple[Tensor, tVal]]) -> Dict[Tensor, tVal]
builtins.dict() -> Dict[str, Tensor]
builtins.dict(inputs : List[Tuple[str, tVal]]) -> Dict[str, tVal]
builtins.dict(inputs : List[Tuple[int, tVal]]) -> Dict[int, tVal]
builtins.dict(inputs : List[Tuple[float, tVal]]) -> Dict[float, tVal]
builtins.dict(inputs : List[Tuple[Tensor, tVal]]) -> Dict[Tensor, tVal]
torch.backends.cudnn.is_acceptable(self : Tensor) -> bool
math.ceil(self : Tensor,
out : Tensor) -> Tensor
math.ceil(self : Tensor) -> Tensor
math.ceil(a : int) -> int
math.ceil(a : float) -> int
math.ceil(a : number) -> number
math.copysign(a : int,
b : int) -> float
math.copysign(a : float,
b : float) -> float
math.copysign(a : int,
b : float) -> float
math.copysign(a : float,
b : int) -> float
math.copysign(a : number,
b : number) -> float
math.erf(self : Tensor,
out : Tensor) -> Tensor
math.erf(self : Tensor) -> Tensor
math.erf(a : int) -> float
math.erf(a : float) -> float
math.erf(a : number) -> number
math.erfc(self : Tensor,
out : Tensor) -> Tensor
math.erfc(self : Tensor) -> Tensor
math.erfc(a : int) -> float
math.erfc(a : float) -> float
math.erfc(a : number) -> number
math.exp(self : Tensor) -> Tensor
math.exp(self : Tensor,
out : Tensor) -> Tensor
math.exp(a : int) -> float
math.exp(a : float) -> float
math.exp(a : number) -> number
math.expm1(self : Tensor,
out : Tensor) -> Tensor
math.expm1(self : Tensor) -> Tensor
math.expm1(a : int) -> float
math.expm1(a : float) -> float
math.expm1(a : number) -> number
math.fabs(a : int) -> float
math.fabs(a : float) -> float
math.fabs(a : number) -> number
math.floor(self : Tensor) -> Tensor
math.floor(self : Tensor,
out : Tensor) -> Tensor
math.floor(a : int) -> int
math.floor(a : float) -> int
math.floor(a : number) -> number
math.gamma(a : int) -> float
math.gamma(a : float) -> float
math.gamma(a : number) -> number
math.lgamma(self : Tensor,
out : Tensor) -> Tensor
math.lgamma(self : Tensor) -> Tensor
math.lgamma(a : int) -> float
math.lgamma(a : float) -> float
math.lgamma(a : number) -> number
math.log(self : Tensor) -> Tensor
math.log(self : Tensor,
out : Tensor) -> Tensor
math.log(a : int) -> float
math.log(a : float) -> float
math.log(a : number) -> number
math.log(a : int,
b : int) -> float
math.log(a : float,
b : float) -> float
math.log(a : int,
b : float) -> float
math.log(a : float,
b : int) -> float
math.log(a : number,
b : number) -> float
math.log10(self : Tensor,
out : Tensor) -> Tensor
math.log10(self : Tensor) -> Tensor
math.log10(a : int) -> float
math.log10(a : float) -> float
math.log10(a : number) -> number
math.log1p(self : Tensor) -> Tensor
math.log1p(self : Tensor,
out : Tensor) -> Tensor
math.log1p(a : int) -> float
math.log1p(a : float) -> float
math.log1p(a : number) -> number
math.pow(self : Tensor,
exponent : Tensor) -> Tensor
math.pow(self : number,
exponent : Tensor) -> Tensor
math.pow(self : Tensor,
exponent : number) -> Tensor
math.pow(self : Tensor,
exponent : Tensor,
out : Tensor) -> Tensor
math.pow(self : number,
exponent : Tensor,
out : Tensor) -> Tensor
math.pow(self : Tensor,
exponent : number,
out : Tensor) -> Tensor
math.pow(a : int,
b : int) -> float
math.pow(a : float,
b : float) -> float
math.pow(a : int,
b : float) -> float
math.pow(a : float,
b : int) -> float
math.pow(a : number,
b : number) -> float
math.pow(a : int,
b : int) -> int
math.pow(a : float,
b : float) -> float
math.pow(a : int,
b : float) -> float
math.pow(a : float,
b : int) -> float
math.pow(a : number,
b : number) -> number
math.sqrt(self : Tensor,
out : Tensor) -> Tensor
math.sqrt(self : Tensor) -> Tensor
math.sqrt(a : int) -> float
math.sqrt(a : float) -> float
math.sqrt(a : number) -> number
math.isnan(self : Tensor) -> Tensor
math.isnan(a : float) -> bool
math.isnan(a : float) -> bool
math.asinh(a : int) -> float
math.asinh(a : float) -> float
math.asinh(a : number) -> number
math.asinh(a : int) -> float
math.asinh(a : float) -> float
math.asinh(a : number) -> number
math.atanh(a : int) -> float
math.atanh(a : float) -> float
math.atanh(a : number) -> number
math.atanh(a : int) -> float
math.atanh(a : float) -> float
math.atanh(a : number) -> number
math.cosh(self : Tensor) -> Tensor
math.cosh(self : Tensor,
out : Tensor) -> Tensor
math.cosh(a : int) -> float
math.cosh(a : float) -> float
math.cosh(a : number) -> number
math.cosh(a : int) -> float
math.cosh(a : float) -> float
math.cosh(a : number) -> number
math.sinh(self : Tensor,
out : Tensor) -> Tensor
math.sinh(self : Tensor) -> Tensor
math.sinh(a : int) -> float
math.sinh(a : float) -> float
math.sinh(a : number) -> number
math.sinh(a : int) -> float
math.sinh(a : float) -> float
math.sinh(a : number) -> number
math.tanh(self : Tensor) -> Tensor
math.tanh(self : Tensor,
out : Tensor) -> Tensor
math.tanh(a : int) -> float
math.tanh(a : float) -> float
math.tanh(a : number) -> number
math.tanh(a : int) -> float
math.tanh(a : float) -> float
math.tanh(a : number) -> number
math.acos(self : Tensor,
out : Tensor) -> Tensor
math.acos(self : Tensor) -> Tensor
math.acos(a : int) -> float
math.acos(a : float) -> float
math.acos(a : number) -> number
math.asin(self : Tensor) -> Tensor
math.asin(self : Tensor,
out : Tensor) -> Tensor
math.asin(a : int) -> float
math.asin(a : float) -> float
math.asin(a : number) -> number
math.atan(self : Tensor) -> Tensor
math.atan(self : Tensor,
out : Tensor) -> Tensor
math.atan(a : int) -> float
math.atan(a : float) -> float
math.atan(a : number) -> number
math.atan2(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
math.atan2(self : Tensor,
other : Tensor) -> Tensor
math.atan2(a : int,
b : int) -> float
math.atan2(a : float,
b : float) -> float
math.atan2(a : int,
b : float) -> float
math.atan2(a : float,
b : int) -> float
math.atan2(a : number,
b : number) -> float
math.cos(self : Tensor) -> Tensor
math.cos(self : Tensor,
out : Tensor) -> Tensor
math.cos(a : int) -> float
math.cos(a : float) -> float
math.cos(a : number) -> number
math.sin(self : Tensor) -> Tensor
math.sin(self : Tensor,
out : Tensor) -> Tensor
math.sin(a : int) -> float
math.sin(a : float) -> float
math.sin(a : number) -> number
math.tan(self : Tensor,
out : Tensor) -> Tensor
math.tan(self : Tensor) -> Tensor
math.tan(a : int) -> float
math.tan(a : float) -> float
math.tan(a : number) -> number
math.asinh(a : int) -> float
math.asinh(a : float) -> float
math.asinh(a : number) -> number
math.asinh(a : int) -> float
math.asinh(a : float) -> float
math.asinh(a : number) -> number
math.atanh(a : int) -> float
math.atanh(a : float) -> float
math.atanh(a : number) -> number
math.atanh(a : int) -> float
math.atanh(a : float) -> float
math.atanh(a : number) -> number
math.acosh(a : int) -> float
math.acosh(a : float) -> float
math.acosh(a : number) -> number
math.sinh(self : Tensor,
out : Tensor) -> Tensor
math.sinh(self : Tensor) -> Tensor
math.sinh(a : int) -> float
math.sinh(a : float) -> float
math.sinh(a : number) -> number
math.sinh(a : int) -> float
math.sinh(a : float) -> float
math.sinh(a : number) -> number
math.cosh(self : Tensor) -> Tensor
math.cosh(self : Tensor,
out : Tensor) -> Tensor
math.cosh(a : int) -> float
math.cosh(a : float) -> float
math.cosh(a : number) -> number
math.cosh(a : int) -> float
math.cosh(a : float) -> float
math.cosh(a : number) -> number
math.tanh(self : Tensor) -> Tensor
math.tanh(self : Tensor,
out : Tensor) -> Tensor
math.tanh(a : int) -> float
math.tanh(a : float) -> float
math.tanh(a : number) -> number
math.tanh(a : int) -> float
math.tanh(a : float) -> float
math.tanh(a : number) -> number
math.fmod(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
math.fmod(self : Tensor,
other : number,
out : Tensor) -> Tensor
math.fmod(self : Tensor,
other : Tensor) -> Tensor
math.fmod(self : Tensor,
other : number) -> Tensor
math.fmod(a : int,
b : int) -> float
math.fmod(a : float,
b : float) -> float
math.fmod(a : int,
b : float) -> float
math.fmod(a : float,
b : int) -> float
math.fmod(a : number,
b : number) -> float
math.modf(a : float) -> Tuple[float, float]
math.factorial(a : int) -> int
math.frexp(a : float) -> Tuple[float, int]
math.isnan(self : Tensor) -> Tensor
math.isnan(a : float) -> bool
math.isnan(a : float) -> bool
math.isinf(a : float) -> bool
math.degrees(a : int) -> float
math.degrees(a : float) -> float
math.degrees(a : number) -> number
math.radians(a : int) -> float
math.radians(a : float) -> float
math.radians(a : number) -> number
math.ldexp(x : float,
i : int) -> float
torch.autograd.grad(outputs : List[Tensor],
inputs : List[Tensor],
grad_outputs : Optional[List[Optional[Tensor]]],
retain_graph : Optional[bool],
create_graph : bool=False,
allow_unused : bool=False) -> List[Optional[Tensor]]
torch.autograd.backward(tensors : List[Tensor],
grad_tensors : Optional[List[Optional[Tensor]]],
retain_graph : Optional[bool],
create_graph : bool=False) -> Tuple[]
torch.autograd.backward(self : Tensor,
gradient : Optional[Tensor],
retain_graph : Optional[bool],
create_graph : bool=False) -> Tuple[]
torch.nn.functional.assert_int_or_pair(vals : List[int],
name : str,
message : str) -> Tensor
torch.nn.functional.interpolate(input : Tensor,
size : Optional[int],
scale_factor : Optional[List[float]],
mode : str=nearest,
align_corners : Optional[bool]) -> Tensor
torch.nn.functional.interpolate(input : Tensor,
size : Optional[List[int]],
scale_factor : Optional[List[float]],
mode : str=nearest,
align_corners : Optional[bool]) -> Tensor
torch.nn.functional.interpolate(input : Tensor,
size : Optional[int],
scale_factor : Optional[float],
mode : str=nearest,
align_corners : Optional[bool]) -> Tensor
torch.nn.functional.interpolate(input : Tensor,
size : Optional[List[int]],
scale_factor : Optional[float],
mode : str=nearest,
align_corners : Optional[bool]) -> Tensor
torch.nn.functional.upsample_bilinear(input : Tensor,
size : Optional[int],
scale_factor : Optional[int]) -> Tensor
torch.nn.functional.upsample_bilinear(input : Tensor,
size : Optional[List[int]],
scale_factor : Optional[int]) -> Tensor
torch.nn.functional.upsample_bilinear(input : Tensor,
size : Optional[int],
scale_factor : Optional[List[int]]) -> Tensor
torch.nn.functional.upsample_bilinear(input : Tensor,
size : Optional[List[int]],
scale_factor : Optional[List[int]]) -> Tensor
torch.nn.functional.upsample_nearest(input : Tensor,
size : Optional[int],
scale_factor : Optional[int]) -> Tensor
torch.nn.functional.upsample_nearest(input : Tensor,
size : Optional[List[int]],
scale_factor : Optional[int]) -> Tensor
torch.nn.functional.upsample(input : Tensor,
size : Optional[int],
scale_factor : Optional[int],
mode : str=nearest,
align_corners : Optional[bool]) -> Tensor
torch.nn.functional.upsample(input : Tensor,
size : Optional[List[int]],
scale_factor : Optional[int],
mode : str=nearest,
align_corners : Optional[bool]) -> Tensor
torch.Size(sizes : List[int]) -> List[int]
torch.abs(self : Tensor) -> Tensor
torch.abs(self : Tensor,
out : Tensor) -> Tensor
torch.abs_(self : Tensor) -> Tensor
torch.acos(self : Tensor,
out : Tensor) -> Tensor
torch.acos(self : Tensor) -> Tensor
torch.acos(a : int) -> float
torch.acos(a : float) -> float
torch.acos(a : number) -> number
torch.acos_(self : Tensor) -> Tensor
torch.adaptive_avg_pool1d(self : Tensor,
output_size : List[int]) -> Tensor
torch.adaptive_max_pool1d(self : Tensor,
output_size : List[int]) -> Tuple[Tensor, Tensor]
torch.add(self : Tensor,
other : Tensor,
alpha : number=1) -> Tensor
torch.add(self : Tensor,
other : number,
alpha : number=1) -> Tensor
torch.add(self : Tensor,
other : Tensor,
alpha : number=1,
out : Tensor) -> Tensor
torch.add(a : str,
b : str) -> str
torch.add(a : List[int],
b : List[int]) -> List[int]
torch.add(a : List[float],
b : List[float]) -> List[float]
torch.add(a : List[bool],
b : List[bool]) -> List[bool]
torch.add(a : List[Tensor],
b : List[Tensor]) -> List[Tensor]
torch.add(a : List[t],
b : List[t]) -> List[t]
torch.add(a : int,
b : int) -> int
torch.add(a : float,
b : float) -> float
torch.add(a : int,
b : float) -> float
torch.add(a : float,
b : int) -> float
torch.add(a : number,
b : number) -> number
torch.addbmm(self : Tensor,
batch1 : Tensor,
batch2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
torch.addbmm(self : Tensor,
batch1 : Tensor,
batch2 : Tensor,
beta : number=1,
alpha : number=1,
out : Tensor) -> Tensor
torch.addcdiv(self : Tensor,
tensor1 : Tensor,
tensor2 : Tensor,
value : number=1,
out : Tensor) -> Tensor
torch.addcdiv(self : Tensor,
tensor1 : Tensor,
tensor2 : Tensor,
value : number=1) -> Tensor
torch.addcmul(self : Tensor,
tensor1 : Tensor,
tensor2 : Tensor,
value : number=1) -> Tensor
torch.addcmul(self : Tensor,
tensor1 : Tensor,
tensor2 : Tensor,
value : number=1,
out : Tensor) -> Tensor
torch.addmm(self : Tensor,
mat1 : Tensor,
mat2 : Tensor,
beta : number=1,
alpha : number=1,
out : Tensor) -> Tensor
torch.addmm(self : Tensor,
mat1 : Tensor,
mat2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
torch.addmv(self : Tensor,
mat : Tensor,
vec : Tensor,
beta : number=1,
alpha : number=1,
out : Tensor) -> Tensor
torch.addmv(self : Tensor,
mat : Tensor,
vec : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
torch.addmv_(self : Tensor,
mat : Tensor,
vec : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
torch.addr(self : Tensor,
vec1 : Tensor,
vec2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
torch.addr(self : Tensor,
vec1 : Tensor,
vec2 : Tensor,
beta : number=1,
alpha : number=1,
out : Tensor) -> Tensor
torch.affine_grid_generator(theta : Tensor,
size : List[int],
align_corners : bool) -> Tensor
torch.align_tensors(tensors : List[Tensor]) -> List[Tensor]
torch.all(self : Tensor) -> Tensor
torch.all(self : Tensor,
dim : int,
keepdim : bool=False) -> Tensor
torch.all(self : Tensor,
dim : int,
keepdim : bool=False,
out : Tensor) -> Tensor
torch.allclose(self : Tensor,
other : Tensor,
rtol : float=1e-05,
atol : float=1e-08,
equal_nan : bool=False) -> bool
torch.alpha_dropout(input : Tensor,
p : float,
train : bool) -> Tensor
torch.alpha_dropout_(self : Tensor,
p : float,
train : bool) -> Tensor
torch.angle(self : Tensor) -> Tensor
torch.angle(self : Tensor,
out : Tensor) -> Tensor
torch.any(self : Tensor) -> Tensor
torch.any(self : Tensor,
dim : int,
keepdim : bool=False) -> Tensor
torch.any(self : Tensor,
dim : int,
keepdim : bool=False,
out : Tensor) -> Tensor
torch.arange(end : number,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.arange(start : number,
end : number,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.arange(start : number,
end : number,
step : number,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.arange(end : number,
out : Tensor) -> Tensor
torch.arange(start : number,
end : number,
step : number=1,
out : Tensor) -> Tensor
torch.argmax(self : Tensor,
dim : Optional[int],
keepdim : bool=False) -> Tensor
torch.argmin(self : Tensor,
dim : Optional[int],
keepdim : bool=False) -> Tensor
torch.argsort(self : Tensor,
dim : int=-1,
descending : bool=False) -> Tensor
torch.as_strided(self : Tensor,
size : List[int],
stride : List[int],
storage_offset : Optional[int]) -> Tensor
torch.as_strided_(self : Tensor,
size : List[int],
stride : List[int],
storage_offset : Optional[int]) -> Tensor
torch.as_tensor(t : float,
dtype : Optional[int],
device : Optional[Device]) -> Tensor
torch.as_tensor(t : int,
dtype : Optional[int],
device : Optional[Device]) -> Tensor
torch.as_tensor(t : bool,
dtype : Optional[int],
device : Optional[Device]) -> Tensor
torch.as_tensor(data : Tensor,
dtype : Optional[int],
device : Optional[Device]) -> Tensor
torch.as_tensor(data : List[t],
dtype : Optional[int],
device : Optional[Device]) -> Tensor
torch.asin(self : Tensor) -> Tensor
torch.asin(self : Tensor,
out : Tensor) -> Tensor
torch.asin(a : int) -> float
torch.asin(a : float) -> float
torch.asin(a : number) -> number
torch.asin_(self : Tensor) -> Tensor
torch.atan(self : Tensor) -> Tensor
torch.atan(self : Tensor,
out : Tensor) -> Tensor
torch.atan(a : int) -> float
torch.atan(a : float) -> float
torch.atan(a : number) -> number
torch.atan2(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.atan2(self : Tensor,
other : Tensor) -> Tensor
torch.atan2(a : int,
b : int) -> float
torch.atan2(a : float,
b : float) -> float
torch.atan2(a : int,
b : float) -> float
torch.atan2(a : float,
b : int) -> float
torch.atan2(a : number,
b : number) -> float
torch.atan_(self : Tensor) -> Tensor
torch.avg_pool1d(self : Tensor,
kernel_size : List[int],
stride : List[int]=[],
padding : List[int]=[0],
ceil_mode : bool=False,
count_include_pad : bool=True) -> Tensor
torch.baddbmm(self : Tensor,
batch1 : Tensor,
batch2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
torch.baddbmm(self : Tensor,
batch1 : Tensor,
batch2 : Tensor,
beta : number=1,
alpha : number=1,
out : Tensor) -> Tensor
torch.bartlett_window(window_length : int,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.bartlett_window(window_length : int,
periodic : bool,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.batch_norm(input : Tensor,
weight : Optional[Tensor],
bias : Optional[Tensor],
running_mean : Optional[Tensor],
running_var : Optional[Tensor],
training : bool,
momentum : float,
eps : float,
cudnn_enabled : bool) -> Tensor
torch.batch_norm_backward_elemt(grad_out : Tensor,
input : Tensor,
mean : Tensor,
invstd : Tensor,
weight : Optional[Tensor],
mean_dy : Tensor,
mean_dy_xmu : Tensor) -> Tensor
torch.batch_norm_backward_reduce(grad_out : Tensor,
input : Tensor,
mean : Tensor,
invstd : Tensor,
weight : Optional[Tensor],
input_g : bool,
weight_g : bool,
bias_g : bool) -> Tuple[Tensor, Tensor, Tensor, Tensor]
torch.batch_norm_elemt(input : Tensor,
weight : Optional[Tensor],
bias : Optional[Tensor],
mean : Tensor,
invstd : Tensor,
eps : float) -> Tensor
torch.batch_norm_elemt(input : Tensor,
weight : Optional[Tensor],
bias : Optional[Tensor],
mean : Tensor,
invstd : Tensor,
eps : float,
out : Tensor) -> Tensor
torch.batch_norm_gather_stats(input : Tensor,
mean : Tensor,
invstd : Tensor,
running_mean : Optional[Tensor],
running_var : Optional[Tensor],
momentum : float,
eps : float,
count : int) -> Tuple[Tensor, Tensor]
torch.batch_norm_gather_stats_with_counts(input : Tensor,
mean : Tensor,
invstd : Tensor,
running_mean : Optional[Tensor],
running_var : Optional[Tensor],
momentum : float,
eps : float,
counts : List[int]) -> Tuple[Tensor, Tensor]
torch.batch_norm_stats(input : Tensor,
eps : float) -> Tuple[Tensor, Tensor]
torch.batch_norm_update_stats(input : Tensor,
running_mean : Optional[Tensor],
running_var : Optional[Tensor],
momentum : float) -> Tuple[Tensor, Tensor]
torch.bernoulli(self : Tensor,
generator : Optional[Generator]) -> Tensor
torch.bernoulli(self : Tensor,
p : float,
generator : Optional[Generator]) -> Tensor
torch.bernoulli(self : Tensor,
generator : Optional[Generator],
out : Tensor) -> Tensor
torch.bilinear(input1 : Tensor,
input2 : Tensor,
weight : Tensor,
bias : Optional[Tensor]) -> Tensor
torch.binary_cross_entropy_with_logits(self : Tensor,
target : Tensor,
weight : Optional[Tensor],
pos_weight : Optional[Tensor],
reduction : int=1) -> Tensor
torch.bincount(self : Tensor,
weights : Optional[Tensor],
minlength : int=0) -> Tensor
torch.bitwise_not(self : Tensor) -> Tensor
torch.bitwise_not(self : Tensor,
out : Tensor) -> Tensor
torch.bitwise_xor(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.bitwise_xor(self : Tensor,
other : number,
out : Tensor) -> Tensor
torch.bitwise_xor(self : Tensor,
other : Tensor) -> Tensor
torch.bitwise_xor(self : Tensor,
other : number) -> Tensor
torch.blackman_window(window_length : int,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.blackman_window(window_length : int,
periodic : bool,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.bmm(self : Tensor,
mat2 : Tensor) -> Tensor
torch.bmm(self : Tensor,
mat2 : Tensor,
out : Tensor) -> Tensor
torch.broadcast_tensors(tensors : List[Tensor]) -> List[Tensor]
torch.can_cast(from : int,
to : int) -> bool
torch.cartesian_prod(tensors : List[Tensor]) -> Tensor
torch.cat(tensors : List[Tensor],
dim : int=0) -> Tensor
torch.cat(tensors : List[Tensor],
dim : int=0,
out : Tensor) -> Tensor
torch.cdist(x1 : Tensor,
x2 : Tensor,
p : float=2.0,
compute_mode : Optional[int]) -> Tensor
torch.ceil(self : Tensor,
out : Tensor) -> Tensor
torch.ceil(self : Tensor) -> Tensor
torch.ceil(a : int) -> int
torch.ceil(a : float) -> int
torch.ceil(a : number) -> number
torch.ceil_(self : Tensor) -> Tensor
torch.celu(self : Tensor,
alpha : number=1.0) -> Tensor
torch.celu_(self : Tensor,
alpha : number=1.0) -> Tensor
torch.chain_matmul(matrices : List[Tensor]) -> Tensor
torch.cholesky(self : Tensor,
upper : bool=False,
out : Tensor) -> Tensor
torch.cholesky(self : Tensor,
upper : bool=False) -> Tensor
torch.cholesky_inverse(self : Tensor,
upper : bool=False) -> Tensor
torch.cholesky_inverse(self : Tensor,
upper : bool=False,
out : Tensor) -> Tensor
torch.cholesky_solve(self : Tensor,
input2 : Tensor,
upper : bool=False,
out : Tensor) -> Tensor
torch.cholesky_solve(self : Tensor,
input2 : Tensor,
upper : bool=False) -> Tensor
torch.chunk(self : Tensor,
chunks : int,
dim : int=0) -> List[Tensor]
torch.clamp(self : Tensor,
min : Optional[number],
max : Optional[number]) -> Tensor
torch.clamp(self : Tensor,
min : Optional[number],
max : Optional[number],
out : Tensor) -> Tensor
torch.clamp_(self : Tensor,
min : Optional[number],
max : Optional[number]) -> Tensor
torch.clamp_max(self : Tensor,
max : number) -> Tensor
torch.clamp_max(self : Tensor,
max : number,
out : Tensor) -> Tensor
torch.clamp_max_(self : Tensor,
max : number) -> Tensor
torch.clamp_min(self : Tensor,
min : number,
out : Tensor) -> Tensor
torch.clamp_min(self : Tensor,
min : number) -> Tensor
torch.clamp_min_(self : Tensor,
min : number) -> Tensor
torch.clone(self : Tensor,
memory_format : Optional[int]) -> Tensor
torch.combinations(self : Tensor,
r : int=2,
with_replacement : bool=False) -> Tensor
torch.conj(self : Tensor) -> Tensor
torch.conj(self : Tensor,
out : Tensor) -> Tensor
torch.constant_pad_nd(self : Tensor,
pad : List[int],
value : number=0) -> Tensor
torch.conv1d(input : Tensor,
weight : Tensor,
bias : Optional[Tensor],
stride : List[int]=[1],
padding : List[int]=[0],
dilation : List[int]=[1],
groups : int=1) -> Tensor
torch.conv2d(input : Tensor,
weight : Tensor,
bias : Optional[Tensor],
stride : List[int]=[1, 1],
padding : List[int]=[0, 0],
dilation : List[int]=[1, 1],
groups : int=1) -> Tensor
torch.conv3d(input : Tensor,
weight : Tensor,
bias : Optional[Tensor],
stride : List[int]=[1, 1, 1],
padding : List[int]=[0, 0, 0],
dilation : List[int]=[1, 1, 1],
groups : int=1) -> Tensor
torch.conv_tbc(self : Tensor,
weight : Tensor,
bias : Tensor,
pad : int=0) -> Tensor
torch.conv_transpose1d(input : Tensor,
weight : Tensor,
bias : Optional[Tensor],
stride : List[int]=[1],
padding : List[int]=[0],
output_padding : List[int]=[0],
groups : int=1,
dilation : List[int]=[1]) -> Tensor
torch.conv_transpose2d(input : Tensor,
weight : Tensor,
bias : Optional[Tensor],
stride : List[int]=[1, 1],
padding : List[int]=[0, 0],
output_padding : List[int]=[0, 0],
groups : int=1,
dilation : List[int]=[1, 1]) -> Tensor
torch.conv_transpose3d(input : Tensor,
weight : Tensor,
bias : Optional[Tensor],
stride : List[int]=[1, 1, 1],
padding : List[int]=[0, 0, 0],
output_padding : List[int]=[0, 0, 0],
groups : int=1,
dilation : List[int]=[1, 1, 1]) -> Tensor
torch.convolution(input : Tensor,
weight : Tensor,
bias : Optional[Tensor],
stride : List[int],
padding : List[int],
dilation : List[int],
transposed : bool,
output_padding : List[int],
groups : int) -> Tensor
torch.cos(self : Tensor) -> Tensor
torch.cos(self : Tensor,
out : Tensor) -> Tensor
torch.cos(a : int) -> float
torch.cos(a : float) -> float
torch.cos(a : number) -> number
torch.cos_(self : Tensor) -> Tensor
torch.cosh(self : Tensor) -> Tensor
torch.cosh(self : Tensor,
out : Tensor) -> Tensor
torch.cosh(a : int) -> float
torch.cosh(a : float) -> float
torch.cosh(a : number) -> number
torch.cosh(a : int) -> float
torch.cosh(a : float) -> float
torch.cosh(a : number) -> number
torch.cosh_(self : Tensor) -> Tensor
torch.cosine_embedding_loss(input1 : Tensor,
input2 : Tensor,
target : Tensor,
margin : float=0.0,
reduction : int=1) -> Tensor
torch.cosine_similarity(x1 : Tensor,
x2 : Tensor,
dim : int=1,
eps : float=1e-08) -> Tensor
torch.cross(self : Tensor,
other : Tensor,
dim : Optional[int],
out : Tensor) -> Tensor
torch.cross(self : Tensor,
other : Tensor,
dim : Optional[int]) -> Tensor
torch.ctc_loss(log_probs : Tensor,
targets : Tensor,
input_lengths : Tensor,
target_lengths : Tensor,
blank : int=0,
reduction : int=1,
zero_infinity : bool=False) -> Tensor
torch.ctc_loss(log_probs : Tensor,
targets : Tensor,
input_lengths : List[int],
target_lengths : List[int],
blank : int=0,
reduction : int=1,
zero_infinity : bool=False) -> Tensor
torch.cudnn_affine_grid_generator(theta : Tensor,
N : int,
C : int,
H : int,
W : int) -> Tensor
torch.cudnn_batch_norm(input : Tensor,
weight : Tensor,
bias : Optional[Tensor],
running_mean : Optional[Tensor],
running_var : Optional[Tensor],
training : bool,
exponential_average_factor : float,
epsilon : float) -> Tuple[Tensor, Tensor, Tensor, Tensor]
torch.cudnn_convolution(self : Tensor,
weight : Tensor,
bias : Optional[Tensor],
padding : List[int],
stride : List[int],
dilation : List[int],
groups : int,
benchmark : bool,
deterministic : bool) -> Tensor
torch.cudnn_convolution_transpose(self : Tensor,
weight : Tensor,
bias : Optional[Tensor],
padding : List[int],
output_padding : List[int],
stride : List[int],
dilation : List[int],
groups : int,
benchmark : bool,
deterministic : bool) -> Tensor
torch.cudnn_grid_sampler(self : Tensor,
grid : Tensor) -> Tensor
torch.cudnn_is_acceptable(self : Tensor) -> bool
torch.cumprod(self : Tensor,
dim : int,
dtype : Optional[int]) -> Tensor
torch.cumprod(self : Tensor,
dim : int,
dtype : Optional[int],
out : Tensor) -> Tensor
torch.cumsum(self : Tensor,
dim : int,
dtype : Optional[int]) -> Tensor
torch.cumsum(self : Tensor,
dim : int,
dtype : Optional[int],
out : Tensor) -> Tensor
torch.dequantize(self : Tensor) -> Tensor
torch.det(self : Tensor) -> Tensor
torch.detach(self : Tensor) -> Tensor
torch.detach_(self : Tensor) -> Tensor
torch.device(a : str) -> Device
torch.diag(self : Tensor,
diagonal : int=0) -> Tensor
torch.diag(self : Tensor,
diagonal : int=0,
out : Tensor) -> Tensor
torch.diag_embed(self : Tensor,
offset : int=0,
dim1 : int=-2,
dim2 : int=-1) -> Tensor
torch.diagflat(self : Tensor,
offset : int=0) -> Tensor
torch.diagonal(self : Tensor,
offset : int=0,
dim1 : int=0,
dim2 : int=1) -> Tensor
torch.digamma(self : Tensor) -> Tensor
torch.digamma(self : Tensor,
out : Tensor) -> Tensor
torch.dist(self : Tensor,
other : Tensor,
p : number=2) -> Tensor
torch.div(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.div(self : Tensor,
other : Tensor) -> Tensor
torch.div(self : Tensor,
other : number) -> Tensor
torch.div(a : int,
b : int) -> float
torch.div(a : float,
b : float) -> float
torch.div(a : number,
b : number) -> float
torch.dot(self : Tensor,
tensor : Tensor) -> Tensor
torch.dot(self : Tensor,
tensor : Tensor,
out : Tensor) -> Tensor
torch.dropout(input : Tensor,
p : float,
train : bool) -> Tensor
torch.dropout_(self : Tensor,
p : float,
train : bool) -> Tensor
torch.eig(self : Tensor,
eigenvectors : bool=False) -> Tuple[Tensor, Tensor]
torch.einsum(equation : str,
tensors : List[Tensor]) -> Tensor
torch.embedding(weight : Tensor,
indices : Tensor,
padding_idx : int=-1,
scale_grad_by_freq : bool=False,
sparse : bool=False) -> Tensor
torch.embedding_bag(weight : Tensor,
indices : Tensor,
offsets : Tensor,
scale_grad_by_freq : bool=False,
mode : int=0,
sparse : bool=False,
per_sample_weights : Optional[Tensor]) -> Tuple[Tensor, Tensor, Tensor, Tensor]
torch.embedding_renorm_(self : Tensor,
indices : Tensor,
max_norm : float,
norm_type : float) -> Tensor
torch.empty(size : List[int],
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool],
memory_format : Optional[int]) -> Tensor
torch.empty(size : List[int],
memory_format : Optional[int],
out : Tensor) -> Tensor
torch.empty_like(self : Tensor,
memory_format : Optional[int]) -> Tensor
torch.empty_like(self : Tensor,
dtype : int,
layout : int,
device : Device,
pin_memory : bool=False,
memory_format : Optional[int]) -> Tensor
torch.empty_strided(size : List[int],
stride : List[int],
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.eq(self : Tensor,
other : Tensor) -> Tensor
torch.eq(self : Tensor,
other : number) -> Tensor
torch.eq(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.eq(self : Tensor,
other : number,
out : Tensor) -> Tensor
torch.eq(a : Device,
b : Device) -> bool
torch.eq(a : str,
b : str) -> bool
torch.eq(a : List[int],
b : List[int]) -> bool
torch.eq(a : List[float],
b : List[float]) -> bool
torch.eq(a : List[Tensor],
b : List[Tensor]) -> bool
torch.eq(a : List[bool],
b : List[bool]) -> bool
torch.eq(a : int,
b : int) -> bool
torch.eq(a : float,
b : float) -> bool
torch.eq(a : int,
b : float) -> bool
torch.eq(a : float,
b : int) -> bool
torch.eq(a : number,
b : number) -> bool
torch.eq(a : str,
b : str) -> bool
torch.equal(self : Tensor,
other : Tensor) -> bool
torch.erf(self : Tensor,
out : Tensor) -> Tensor
torch.erf(self : Tensor) -> Tensor
torch.erf(a : int) -> float
torch.erf(a : float) -> float
torch.erf(a : number) -> number
torch.erf_(self : Tensor) -> Tensor
torch.erfc(self : Tensor,
out : Tensor) -> Tensor
torch.erfc(self : Tensor) -> Tensor
torch.erfc(a : int) -> float
torch.erfc(a : float) -> float
torch.erfc(a : number) -> number
torch.erfc_(self : Tensor) -> Tensor
torch.erfinv(self : Tensor,
out : Tensor) -> Tensor
torch.erfinv(self : Tensor) -> Tensor
torch.exp(self : Tensor) -> Tensor
torch.exp(self : Tensor,
out : Tensor) -> Tensor
torch.exp(a : int) -> float
torch.exp(a : float) -> float
torch.exp(a : number) -> number
torch.exp_(self : Tensor) -> Tensor
torch.expm1(self : Tensor,
out : Tensor) -> Tensor
torch.expm1(self : Tensor) -> Tensor
torch.expm1(a : int) -> float
torch.expm1(a : float) -> float
torch.expm1(a : number) -> number
torch.expm1_(self : Tensor) -> Tensor
torch.eye(n : int,
out : Tensor) -> Tensor
torch.eye(n : int,
m : int,
out : Tensor) -> Tensor
torch.eye(n : int,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.eye(n : int,
m : int,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.fake_quantize_per_channel_affine(self : Tensor,
scale : Tensor,
zero_point : Tensor,
axis : int,
quant_min : int,
quant_max : int) -> Tensor
torch.fake_quantize_per_tensor_affine(self : Tensor,
scale : float,
zero_point : int,
quant_min : int,
quant_max : int) -> Tensor
torch.fbgemm_linear_fp16_weight(input : Tensor,
packed_weight : Tensor,
bias : Tensor) -> Tensor
torch.fbgemm_linear_fp16_weight_fp32_activation(input : Tensor,
packed_weight : Tensor,
bias : Tensor) -> Tensor
torch.fbgemm_linear_int8_weight(input : Tensor,
weight : Tensor,
packed : Tensor,
col_offsets : Tensor,
weight_scale : number,
weight_zero_point : number,
bias : Tensor) -> Tensor
torch.fbgemm_linear_int8_weight_fp32_activation(input : Tensor,
weight : Tensor,
packed : Tensor,
col_offsets : Tensor,
weight_scale : number,
weight_zero_point : number,
bias : Tensor) -> Tensor
torch.fbgemm_linear_quantize_weight(input : Tensor) -> Tuple[Tensor, Tensor, float, int]
torch.fbgemm_pack_gemm_matrix_fp16(input : Tensor) -> Tensor
torch.fbgemm_pack_quantized_matrix(input : Tensor) -> Tensor
torch.fbgemm_pack_quantized_matrix(input : Tensor,
K : int,
N : int) -> Tensor
torch.feature_alpha_dropout(input : Tensor,
p : float,
train : bool) -> Tensor
torch.feature_alpha_dropout_(self : Tensor,
p : float,
train : bool) -> Tensor
torch.feature_dropout(input : Tensor,
p : float,
train : bool) -> Tensor
torch.feature_dropout_(self : Tensor,
p : float,
train : bool) -> Tensor
torch.fft(self : Tensor,
signal_ndim : int,
normalized : bool=False) -> Tensor
torch.fill_(self : Tensor,
value : Tensor) -> Tensor
torch.fill_(self : Tensor,
value : number) -> Tensor
torch.flatten(self : Tensor,
start_dim : int=0,
end_dim : int=-1) -> Tensor
torch.flip(self : Tensor,
dims : List[int]) -> Tensor
torch.floor(self : Tensor) -> Tensor
torch.floor(self : Tensor,
out : Tensor) -> Tensor
torch.floor(a : int) -> int
torch.floor(a : float) -> int
torch.floor(a : number) -> number
torch.floor_(self : Tensor) -> Tensor
torch.fmod(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.fmod(self : Tensor,
other : number,
out : Tensor) -> Tensor
torch.fmod(self : Tensor,
other : Tensor) -> Tensor
torch.fmod(self : Tensor,
other : number) -> Tensor
torch.fmod(a : int,
b : int) -> float
torch.fmod(a : float,
b : float) -> float
torch.fmod(a : int,
b : float) -> float
torch.fmod(a : float,
b : int) -> float
torch.fmod(a : number,
b : number) -> float
torch.frac(self : Tensor) -> Tensor
torch.frac(self : Tensor,
out : Tensor) -> Tensor
torch.frac_(self : Tensor) -> Tensor
torch.frobenius_norm(self : Tensor) -> Tensor
torch.frobenius_norm(self : Tensor,
dim : List[int],
keepdim : bool=False) -> Tensor
torch.frobenius_norm(self : Tensor,
dim : List[int],
keepdim : bool=False,
out : Tensor) -> Tensor
torch.from_file(filename : str,
shared : Optional[bool],
size : Optional[int]=0,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.full(size : List[int],
fill_value : number,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.full(size : List[int],
fill_value : number,
out : Tensor) -> Tensor
torch.full_like(self : Tensor,
fill_value : number,
memory_format : Optional[int]) -> Tensor
torch.full_like(self : Tensor,
fill_value : number,
dtype : int,
layout : int,
device : Device,
pin_memory : bool=False,
memory_format : Optional[int]) -> Tensor
torch.gather(self : Tensor,
dim : int,
index : Tensor,
sparse_grad : bool=False,
out : Tensor) -> Tensor
torch.gather(self : Tensor,
dim : int,
index : Tensor,
sparse_grad : bool=False) -> Tensor
torch.ge(self : Tensor,
other : Tensor) -> Tensor
torch.ge(self : Tensor,
other : number) -> Tensor
torch.ge(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.ge(self : Tensor,
other : number,
out : Tensor) -> Tensor
torch.ge(a : int,
b : int) -> bool
torch.ge(a : float,
b : float) -> bool
torch.ge(a : int,
b : float) -> bool
torch.ge(a : float,
b : int) -> bool
torch.ge(a : number,
b : number) -> bool
torch.ge(a : str,
b : str) -> bool
torch.geqrf(self : Tensor) -> Tuple[Tensor, Tensor]
torch.ger(self : Tensor,
vec2 : Tensor) -> Tensor
torch.ger(self : Tensor,
vec2 : Tensor,
out : Tensor) -> Tensor
torch.get_device(self : Tensor) -> int
torch.get_device(self : Tensor) -> int
torch.get_device(self : Tensor) -> int
torch.grid_sampler(input : Tensor,
grid : Tensor,
interpolation_mode : int,
padding_mode : int,
align_corners : bool) -> Tensor
torch.grid_sampler_2d(input : Tensor,
grid : Tensor,
interpolation_mode : int,
padding_mode : int,
align_corners : bool) -> Tensor
torch.grid_sampler_3d(input : Tensor,
grid : Tensor,
interpolation_mode : int,
padding_mode : int,
align_corners : bool) -> Tensor
torch.group_norm(input : Tensor,
num_groups : int,
weight : Optional[Tensor],
bias : Optional[Tensor],
eps : float=1e-05,
cudnn_enabled : bool=True) -> Tensor
torch.gru(data : Tensor,
batch_sizes : Tensor,
hx : Tensor,
params : List[Tensor],
has_biases : bool,
num_layers : int,
dropout : float,
train : bool,
bidirectional : bool) -> Tuple[Tensor, Tensor]
torch.gru(input : Tensor,
hx : Tensor,
params : List[Tensor],
has_biases : bool,
num_layers : int,
dropout : float,
train : bool,
bidirectional : bool,
batch_first : bool) -> Tuple[Tensor, Tensor]
torch.gru_cell(input : Tensor,
hx : Tensor,
w_ih : Tensor,
w_hh : Tensor,
b_ih : Optional[Tensor],
b_hh : Optional[Tensor]) -> Tensor
torch.gt(self : Tensor,
other : Tensor) -> Tensor
torch.gt(self : Tensor,
other : number) -> Tensor
torch.gt(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.gt(self : Tensor,
other : number,
out : Tensor) -> Tensor
torch.gt(a : int,
b : int) -> bool
torch.gt(a : float,
b : float) -> bool
torch.gt(a : int,
b : float) -> bool
torch.gt(a : float,
b : int) -> bool
torch.gt(a : number,
b : number) -> bool
torch.gt(a : str,
b : str) -> bool
torch.hamming_window(window_length : int,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.hamming_window(window_length : int,
periodic : bool,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.hamming_window(window_length : int,
periodic : bool,
alpha : float,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.hamming_window(window_length : int,
periodic : bool,
alpha : float,
beta : float,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.hann_window(window_length : int,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.hann_window(window_length : int,
periodic : bool,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.hardshrink(self : Tensor,
lambd : number=0.5) -> Tensor
torch.hinge_embedding_loss(self : Tensor,
target : Tensor,
margin : float=1.0,
reduction : int=1) -> Tensor
torch.histc(self : Tensor,
bins : int=100,
min : number=0,
max : number=0,
out : Tensor) -> Tensor
torch.histc(self : Tensor,
bins : int=100,
min : number=0,
max : number=0) -> Tensor
torch.hspmm(mat1 : Tensor,
mat2 : Tensor) -> Tensor
torch.hspmm(mat1 : Tensor,
mat2 : Tensor,
out : Tensor) -> Tensor
torch.ifft(self : Tensor,
signal_ndim : int,
normalized : bool=False) -> Tensor
torch.imag(self : Tensor) -> Tensor
torch.imag(self : Tensor,
out : Tensor) -> Tensor
torch.index_add(self : Tensor,
dim : int,
index : Tensor,
source : Tensor) -> Tensor
torch.index_copy(self : Tensor,
dim : int,
index : Tensor,
source : Tensor) -> Tensor
torch.index_fill(self : Tensor,
dim : int,
index : Tensor,
value : Tensor) -> Tensor
torch.index_fill(self : Tensor,
dim : int,
index : Tensor,
value : number) -> Tensor
torch.index_put(self : Tensor,
indices : List[Optional[Tensor]],
values : Tensor,
accumulate : bool=False) -> Tensor
torch.index_put(self : Tensor,
indices : List[Tensor],
values : Tensor,
accumulate : bool=False) -> Tensor
torch.index_put_(self : Tensor,
indices : List[Optional[Tensor]],
values : Tensor,
accumulate : bool=False) -> Tensor
torch.index_put_(self : Tensor,
indices : List[Tensor],
values : Tensor,
accumulate : bool=False) -> Tensor
torch.index_select(self : Tensor,
dim : int,
index : Tensor,
out : Tensor) -> Tensor
torch.index_select(self : Tensor,
dim : int,
index : Tensor) -> Tensor
torch.instance_norm(input : Tensor,
weight : Optional[Tensor],
bias : Optional[Tensor],
running_mean : Optional[Tensor],
running_var : Optional[Tensor],
use_input_stats : bool,
momentum : float,
eps : float,
cudnn_enabled : bool) -> Tensor
torch.int_repr(self : Tensor) -> Tensor
torch.inverse(self : Tensor,
out : Tensor) -> Tensor
torch.inverse(self : Tensor) -> Tensor
torch.irfft(self : Tensor,
signal_ndim : int,
normalized : bool=False,
onesided : bool=True,
signal_sizes : List[int]=[]) -> Tensor
torch.is_complex(self : Tensor) -> bool
torch.is_distributed(self : Tensor) -> bool
torch.is_floating_point(self : Tensor) -> bool
torch.is_nonzero(self : Tensor) -> bool
torch.is_same_size(self : Tensor,
other : Tensor) -> bool
torch.is_signed(self : Tensor) -> bool
torch.isclose(self : Tensor,
other : Tensor,
rtol : float=1e-05,
atol : float=1e-08,
equal_nan : bool=False) -> Tensor
torch.isfinite(self : Tensor) -> Tensor
torch.isfinite(a : float) -> bool
torch.isinf(a : float) -> bool
torch.isnan(self : Tensor) -> Tensor
torch.isnan(a : float) -> bool
torch.isnan(a : float) -> bool
torch.kl_div(self : Tensor,
target : Tensor,
reduction : int=1) -> Tensor
torch.kthvalue(self : Tensor,
k : int,
dim : int=-1,
keepdim : bool=False) -> Tuple[Tensor, Tensor]
torch.layer_norm(input : Tensor,
normalized_shape : List[int],
weight : Optional[Tensor],
bias : Optional[Tensor],
eps : float=1e-05,
cudnn_enable : bool=True) -> Tensor
torch.le(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.le(self : Tensor,
other : number,
out : Tensor) -> Tensor
torch.le(self : Tensor,
other : Tensor) -> Tensor
torch.le(self : Tensor,
other : number) -> Tensor
torch.le(a : int,
b : int) -> bool
torch.le(a : float,
b : float) -> bool
torch.le(a : int,
b : float) -> bool
torch.le(a : float,
b : int) -> bool
torch.le(a : number,
b : number) -> bool
torch.le(a : str,
b : str) -> bool
torch.lerp(self : Tensor,
end : Tensor,
weight : Tensor) -> Tensor
torch.lerp(self : Tensor,
end : Tensor,
weight : number) -> Tensor
torch.lerp(self : Tensor,
end : Tensor,
weight : Tensor,
out : Tensor) -> Tensor
torch.lerp(self : Tensor,
end : Tensor,
weight : number,
out : Tensor) -> Tensor
torch.lgamma(self : Tensor,
out : Tensor) -> Tensor
torch.lgamma(self : Tensor) -> Tensor
torch.lgamma(a : int) -> float
torch.lgamma(a : float) -> float
torch.lgamma(a : number) -> number
torch.linspace(start : number,
end : number,
steps : int=100,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.linspace(start : number,
end : number,
steps : int=100,
out : Tensor) -> Tensor
torch.log(self : Tensor) -> Tensor
torch.log(self : Tensor,
out : Tensor) -> Tensor
torch.log(a : int) -> float
torch.log(a : float) -> float
torch.log(a : number) -> number
torch.log(a : int,
b : int) -> float
torch.log(a : float,
b : float) -> float
torch.log(a : int,
b : float) -> float
torch.log(a : float,
b : int) -> float
torch.log(a : number,
b : number) -> float
torch.log10(self : Tensor,
out : Tensor) -> Tensor
torch.log10(self : Tensor) -> Tensor
torch.log10(a : int) -> float
torch.log10(a : float) -> float
torch.log10(a : number) -> number
torch.log10_(self : Tensor) -> Tensor
torch.log1p(self : Tensor) -> Tensor
torch.log1p(self : Tensor,
out : Tensor) -> Tensor
torch.log1p(a : int) -> float
torch.log1p(a : float) -> float
torch.log1p(a : number) -> number
torch.log1p_(self : Tensor) -> Tensor
torch.log2(self : Tensor) -> Tensor
torch.log2(self : Tensor,
out : Tensor) -> Tensor
torch.log2_(self : Tensor) -> Tensor
torch.log_(self : Tensor) -> Tensor
torch.log_softmax(self : Tensor,
dim : int,
dtype : Optional[int]) -> Tensor
torch.logdet(self : Tensor) -> Tensor
torch.logical_not(self : Tensor,
out : Tensor) -> Tensor
torch.logical_not(self : Tensor) -> Tensor
torch.logical_xor(self : Tensor,
other : Tensor) -> Tensor
torch.logical_xor(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.logspace(start : number,
end : number,
steps : int=100,
base : float=10.0,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.logspace(start : number,
end : number,
steps : int=100,
base : float=10.0,
out : Tensor) -> Tensor
torch.logsumexp(self : Tensor,
dim : List[int],
keepdim : bool=False) -> Tensor
torch.logsumexp(self : Tensor,
dim : List[int],
keepdim : bool=False,
out : Tensor) -> Tensor
torch.lstm(data : Tensor,
batch_sizes : Tensor,
hx : List[Tensor],
params : List[Tensor],
has_biases : bool,
num_layers : int,
dropout : float,
train : bool,
bidirectional : bool) -> Tuple[Tensor, Tensor, Tensor]
torch.lstm(input : Tensor,
hx : List[Tensor],
params : List[Tensor],
has_biases : bool,
num_layers : int,
dropout : float,
train : bool,
bidirectional : bool,
batch_first : bool) -> Tuple[Tensor, Tensor, Tensor]
torch.lstm_cell(input : Tensor,
hx : List[Tensor],
w_ih : Tensor,
w_hh : Tensor,
b_ih : Optional[Tensor],
b_hh : Optional[Tensor]) -> Tuple[Tensor, Tensor]
torch.lstsq(self : Tensor,
A : Tensor) -> Tuple[Tensor, Tensor]
torch.lt(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.lt(self : Tensor,
other : number,
out : Tensor) -> Tensor
torch.lt(self : Tensor,
other : Tensor) -> Tensor
torch.lt(self : Tensor,
other : number) -> Tensor
torch.lt(a : int,
b : int) -> bool
torch.lt(a : float,
b : float) -> bool
torch.lt(a : int,
b : float) -> bool
torch.lt(a : float,
b : int) -> bool
torch.lt(a : number,
b : number) -> bool
torch.lt(a : str,
b : str) -> bool
torch.lu_solve(self : Tensor,
LU_data : Tensor,
LU_pivots : Tensor) -> Tensor
torch.lu_solve(self : Tensor,
LU_data : Tensor,
LU_pivots : Tensor,
out : Tensor) -> Tensor
torch.manual_seed(seed : int) -> Tuple[]
torch.margin_ranking_loss(input1 : Tensor,
input2 : Tensor,
target : Tensor,
margin : float=0.0,
reduction : int=1) -> Tensor
torch.masked_fill(self : Tensor,
mask : Tensor,
value : Tensor) -> Tensor
torch.masked_fill(self : Tensor,
mask : Tensor,
value : number) -> Tensor
torch.masked_scatter(self : Tensor,
mask : Tensor,
source : Tensor) -> Tensor
torch.masked_select(self : Tensor,
mask : Tensor,
out : Tensor) -> Tensor
torch.masked_select(self : Tensor,
mask : Tensor) -> Tensor
torch.matmul(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.matmul(self : Tensor,
other : Tensor) -> Tensor
torch.matrix_power(self : Tensor,
n : int) -> Tensor
torch.matrix_rank(self : Tensor,
symmetric : bool=False) -> Tensor
torch.matrix_rank(self : Tensor,
tol : float,
symmetric : bool=False) -> Tensor
torch.max(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.max(self : Tensor) -> Tensor
torch.max(self : Tensor,
other : Tensor) -> Tensor
torch.max(self : Tensor,
dim : int,
keepdim : bool=False) -> Tuple[Tensor, Tensor]
torch.max_pool1d(self : Tensor,
kernel_size : List[int],
stride : List[int]=[],
padding : List[int]=[0],
dilation : List[int]=[1],
ceil_mode : bool=False) -> Tensor
torch.max_pool1d_with_indices(self : Tensor,
kernel_size : List[int],
stride : List[int]=[],
padding : List[int]=[0],
dilation : List[int]=[1],
ceil_mode : bool=False) -> Tuple[Tensor, Tensor]
torch.max_pool2d(self : Tensor,
kernel_size : List[int],
stride : List[int]=[],
padding : List[int]=[0, 0],
dilation : List[int]=[1, 1],
ceil_mode : bool=False) -> Tensor
torch.max_pool3d(self : Tensor,
kernel_size : List[int],
stride : List[int]=[],
padding : List[int]=[0, 0, 0],
dilation : List[int]=[1, 1, 1],
ceil_mode : bool=False) -> Tensor
torch.mean(self : Tensor,
dtype : Optional[int]) -> Tensor
torch.mean(self : Tensor,
dim : List[int],
keepdim : bool=False,
dtype : Optional[int]) -> Tensor
torch.mean(self : Tensor,
dim : List[int],
keepdim : bool=False,
dtype : Optional[int],
out : Tensor) -> Tensor
torch.median(self : Tensor) -> Tensor
torch.median(self : Tensor,
dim : int,
keepdim : bool=False) -> Tuple[Tensor, Tensor]
torch.meshgrid(tensors : List[Tensor]) -> List[Tensor]
torch.min(self : Tensor) -> Tensor
torch.min(self : Tensor,
other : Tensor) -> Tensor
torch.min(self : Tensor,
dim : int,
keepdim : bool=False) -> Tuple[Tensor, Tensor]
torch.min(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.miopen_batch_norm(input : Tensor,
weight : Tensor,
bias : Optional[Tensor],
running_mean : Optional[Tensor],
running_var : Optional[Tensor],
training : bool,
exponential_average_factor : float,
epsilon : float) -> Tuple[Tensor, Tensor, Tensor]
torch.miopen_convolution(self : Tensor,
weight : Tensor,
bias : Optional[Tensor],
padding : List[int],
stride : List[int],
dilation : List[int],
groups : int,
benchmark : bool,
deterministic : bool) -> Tensor
torch.miopen_convolution_transpose(self : Tensor,
weight : Tensor,
bias : Optional[Tensor],
padding : List[int],
output_padding : List[int],
stride : List[int],
dilation : List[int],
groups : int,
benchmark : bool,
deterministic : bool) -> Tensor
torch.miopen_depthwise_convolution(self : Tensor,
weight : Tensor,
bias : Optional[Tensor],
padding : List[int],
stride : List[int],
dilation : List[int],
groups : int,
benchmark : bool,
deterministic : bool) -> Tensor
torch.miopen_rnn(input : Tensor,
weight : List[Tensor],
weight_stride0 : int,
hx : Tensor,
cx : Optional[Tensor],
mode : int,
hidden_size : int,
num_layers : int,
batch_first : bool,
dropout : float,
train : bool,
bidirectional : bool,
batch_sizes : List[int],
dropout_state : Optional[Tensor]) -> Tuple[Tensor, Tensor, Tensor, Tensor, Tensor]
torch.mkldnn_adaptive_avg_pool2d(self : Tensor,
output_size : List[int]) -> Tensor
torch.mkldnn_convolution(self : Tensor,
weight : Tensor,
bias : Optional[Tensor],
padding : List[int],
stride : List[int],
dilation : List[int],
groups : int) -> Tensor
torch.mkldnn_convolution_backward_weights(weight_size : List[int],
grad_output : Tensor,
self : Tensor,
padding : List[int],
stride : List[int],
dilation : List[int],
groups : int,
bias_defined : bool) -> Tuple[Tensor, Tensor]
torch.mkldnn_max_pool2d(self : Tensor,
kernel_size : List[int],
stride : List[int]=[],
padding : List[int]=[0, 0],
dilation : List[int]=[1, 1],
ceil_mode : bool=False) -> Tensor
torch.mm(self : Tensor,
mat2 : Tensor,
out : Tensor) -> Tensor
torch.mm(self : Tensor,
mat2 : Tensor) -> Tensor
torch.mode(self : Tensor,
dim : int=-1,
keepdim : bool=False) -> Tuple[Tensor, Tensor]
torch.mul(self : Tensor,
other : Tensor) -> Tensor
torch.mul(self : Tensor,
other : number) -> Tensor
torch.mul(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.mul(l : List[int],
n : int) -> List[int]
torch.mul(n : int,
l : List[int]) -> List[int]
torch.mul(l : List[float],
n : int) -> List[float]
torch.mul(n : int,
l : List[float]) -> List[float]
torch.mul(l : List[bool],
n : int) -> List[bool]
torch.mul(n : int,
l : List[bool]) -> List[bool]
torch.mul(l : List[Tensor],
n : int) -> List[Tensor]
torch.mul(n : int,
l : List[Tensor]) -> List[Tensor]
torch.mul(l : List[t],
n : int) -> List[t]
torch.mul(n : int,
l : List[t]) -> List[t]
torch.mul(a : int,
b : int) -> int
torch.mul(a : float,
b : float) -> float
torch.mul(a : int,
b : float) -> float
torch.mul(a : float,
b : int) -> float
torch.mul(a : number,
b : number) -> number
torch.multinomial(self : Tensor,
num_samples : int,
replacement : bool=False,
generator : Optional[Generator]) -> Tensor
torch.multinomial(self : Tensor,
num_samples : int,
replacement : bool=False,
generator : Optional[Generator],
out : Tensor) -> Tensor
torch.mv(self : Tensor,
vec : Tensor,
out : Tensor) -> Tensor
torch.mv(self : Tensor,
vec : Tensor) -> Tensor
torch.mvlgamma(self : Tensor,
p : int) -> Tensor
torch.narrow(self : Tensor,
dim : int,
start : int,
length : int) -> Tensor
torch.native_batch_norm(input : Tensor,
weight : Optional[Tensor],
bias : Optional[Tensor],
running_mean : Optional[Tensor],
running_var : Optional[Tensor],
training : bool,
momentum : float,
eps : float) -> Tuple[Tensor, Tensor, Tensor]
torch.native_layer_norm(input : Tensor,
weight : Optional[Tensor],
bias : Optional[Tensor],
M : int,
N : int,
eps : float) -> Tuple[Tensor, Tensor, Tensor]
torch.native_norm(self : Tensor,
p : number=2) -> Tensor
torch.ne(self : Tensor,
other : Tensor) -> Tensor
torch.ne(self : Tensor,
other : number) -> Tensor
torch.ne(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.ne(self : Tensor,
other : number,
out : Tensor) -> Tensor
torch.ne(a : str,
b : str) -> bool
torch.ne(a : List[int],
b : List[int]) -> bool
torch.ne(a : List[float],
b : List[float]) -> bool
torch.ne(a : List[Tensor],
b : List[Tensor]) -> bool
torch.ne(a : List[bool],
b : List[bool]) -> bool
torch.ne(a : int,
b : int) -> bool
torch.ne(a : float,
b : float) -> bool
torch.ne(a : int,
b : float) -> bool
torch.ne(a : float,
b : int) -> bool
torch.ne(a : number,
b : number) -> bool
torch.ne(a : str,
b : str) -> bool
torch.neg(self : Tensor,
out : Tensor) -> Tensor
torch.neg(self : Tensor) -> Tensor
torch.neg(a : int) -> int
torch.neg(a : float) -> float
torch.neg(a : number) -> number
torch.neg_(self : Tensor) -> Tensor
torch.nonzero(self : Tensor,
out : Tensor) -> Tensor
torch.nonzero(self : Tensor) -> Tensor
torch.norm(self : Tensor,
p : number=2) -> Tensor
torch.norm(self : Tensor,
p : Optional[number],
dtype : int) -> Tensor
torch.norm(self : Tensor,
p : Optional[number],
dim : List[int],
keepdim : bool=False) -> Tensor
torch.norm(self : Tensor,
p : Optional[number],
dim : List[int],
keepdim : bool,
dtype : int) -> Tensor
torch.norm(self : Tensor,
p : Optional[number],
dim : List[int],
keepdim : bool=False,
out : Tensor) -> Tensor
torch.norm(self : Tensor,
p : Optional[number],
dim : List[int],
keepdim : bool,
dtype : int,
out : Tensor) -> Tensor
torch.norm_except_dim(v : Tensor,
pow : int=2,
dim : int=0) -> Tensor
torch.normal(mean : Tensor,
std : Tensor,
generator : Optional[Generator]) -> Tensor
torch.normal(mean : float,
std : Tensor,
generator : Optional[Generator]) -> Tensor
torch.normal(mean : Tensor,
std : float=1.0,
generator : Optional[Generator]) -> Tensor
torch.normal(mean : float,
std : float,
size : List[int],
generator : Optional[Generator],
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.normal(mean : Tensor,
std : Tensor,
generator : Optional[Generator],
out : Tensor) -> Tensor
torch.normal(mean : float,
std : Tensor,
generator : Optional[Generator],
out : Tensor) -> Tensor
torch.normal(mean : Tensor,
std : float=1.0,
generator : Optional[Generator],
out : Tensor) -> Tensor
torch.normal(mean : float,
std : float,
size : List[int],
generator : Optional[Generator],
out : Tensor) -> Tensor
torch.nuclear_norm(self : Tensor,
keepdim : bool=False) -> Tensor
torch.nuclear_norm(self : Tensor,
dim : List[int],
keepdim : bool=False) -> Tensor
torch.nuclear_norm(self : Tensor,
keepdim : bool=False,
out : Tensor) -> Tensor
torch.nuclear_norm(self : Tensor,
dim : List[int],
keepdim : bool=False,
out : Tensor) -> Tensor
torch.numel(self : Tensor) -> int
torch.ones(size : List[int],
out : Tensor) -> Tensor
torch.ones(size : List[int],
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.ones_like(self : Tensor,
memory_format : Optional[int]) -> Tensor
torch.ones_like(self : Tensor,
dtype : int,
layout : int,
device : Device,
pin_memory : bool=False,
memory_format : Optional[int]) -> Tensor
torch.orgqr(self : Tensor,
input2 : Tensor) -> Tensor
torch.orgqr(self : Tensor,
input2 : Tensor,
out : Tensor) -> Tensor
torch.ormqr(self : Tensor,
input2 : Tensor,
input3 : Tensor,
left : bool=True,
transpose : bool=False) -> Tensor
torch.ormqr(self : Tensor,
input2 : Tensor,
input3 : Tensor,
left : bool=True,
transpose : bool=False,
out : Tensor) -> Tensor
torch.pairwise_distance(x1 : Tensor,
x2 : Tensor,
p : float=2.0,
eps : float=1e-06,
keepdim : bool=False) -> Tensor
torch.pdist(self : Tensor,
p : float=2.0) -> Tensor
torch.pinverse(self : Tensor,
rcond : float=1e-15) -> Tensor
torch.pixel_shuffle(self : Tensor,
upscale_factor : int) -> Tensor
torch.poisson(self : Tensor,
generator : Optional[Generator]) -> Tensor
torch.poisson_nll_loss(input : Tensor,
target : Tensor,
log_input : bool,
full : bool,
eps : float,
reduction : int) -> Tensor
torch.polygamma(n : int,
self : Tensor) -> Tensor
torch.polygamma(n : int,
self : Tensor,
out : Tensor) -> Tensor
torch.pow(self : Tensor,
exponent : Tensor) -> Tensor
torch.pow(self : number,
exponent : Tensor) -> Tensor
torch.pow(self : Tensor,
exponent : number) -> Tensor
torch.pow(self : Tensor,
exponent : Tensor,
out : Tensor) -> Tensor
torch.pow(self : number,
exponent : Tensor,
out : Tensor) -> Tensor
torch.pow(self : Tensor,
exponent : number,
out : Tensor) -> Tensor
torch.pow(a : int,
b : int) -> float
torch.pow(a : float,
b : float) -> float
torch.pow(a : int,
b : float) -> float
torch.pow(a : float,
b : int) -> float
torch.pow(a : number,
b : number) -> float
torch.pow(a : int,
b : int) -> int
torch.pow(a : float,
b : float) -> float
torch.pow(a : int,
b : float) -> float
torch.pow(a : float,
b : int) -> float
torch.pow(a : number,
b : number) -> number
torch.prelu(self : Tensor,
weight : Tensor) -> Tensor
torch.prod(self : Tensor,
dim : int,
keepdim : bool=False,
dtype : Optional[int],
out : Tensor) -> Tensor
torch.prod(self : Tensor,
dtype : Optional[int]) -> Tensor
torch.prod(self : Tensor,
dim : int,
keepdim : bool=False,
dtype : Optional[int]) -> Tensor
torch.promote_types(type1 : int,
type2 : int) -> int
torch.q_per_channel_axis(self : Tensor) -> int
torch.q_per_channel_scales(self : Tensor) -> Tensor
torch.q_per_channel_zero_points(self : Tensor) -> Tensor
torch.q_scale(self : Tensor) -> float
torch.q_zero_point(self : Tensor) -> int
torch.qr(self : Tensor,
some : bool=True) -> Tuple[Tensor, Tensor]
torch.qscheme(self : Tensor) -> int
torch.quantize_per_channel(self : Tensor,
scales : Tensor,
zero_points : Tensor,
axis : int,
dtype : int) -> Tensor
torch.quantize_per_tensor(self : Tensor,
scale : float,
zero_point : int,
dtype : int) -> Tensor
torch.quantized_gru(data : Tensor,
batch_sizes : Tensor,
hx : Tensor,
params : List[Tensor],
has_biases : bool,
num_layers : int,
dropout : float,
train : bool,
bidirectional : bool) -> Tuple[Tensor, Tensor]
torch.quantized_gru(input : Tensor,
hx : Tensor,
params : List[Tensor],
has_biases : bool,
num_layers : int,
dropout : float,
train : bool,
bidirectional : bool,
batch_first : bool) -> Tuple[Tensor, Tensor]
torch.quantized_gru_cell(input : Tensor,
hx : Tensor,
w_ih : Tensor,
w_hh : Tensor,
b_ih : Tensor,
b_hh : Tensor,
packed_ih : Tensor,
packed_hh : Tensor,
col_offsets_ih : Tensor,
col_offsets_hh : Tensor,
scale_ih : number,
scale_hh : number,
zero_point_ih : number,
zero_point_hh : number) -> Tensor
torch.quantized_lstm(data : Tensor,
batch_sizes : Tensor,
hx : List[Tensor],
params : List[Tensor],
has_biases : bool,
num_layers : int,
dropout : float,
train : bool,
bidirectional : bool,
dtype : Optional[int],
use_dynamic : bool=False) -> Tuple[Tensor, Tensor, Tensor]
torch.quantized_lstm(input : Tensor,
hx : List[Tensor],
params : List[Tensor],
has_biases : bool,
num_layers : int,
dropout : float,
train : bool,
bidirectional : bool,
batch_first : bool,
dtype : Optional[int],
use_dynamic : bool=False) -> Tuple[Tensor, Tensor, Tensor]
torch.quantized_lstm_cell(input : Tensor,
hx : List[Tensor],
w_ih : Tensor,
w_hh : Tensor,
b_ih : Tensor,
b_hh : Tensor,
packed_ih : Tensor,
packed_hh : Tensor,
col_offsets_ih : Tensor,
col_offsets_hh : Tensor,
scale_ih : number,
scale_hh : number,
zero_point_ih : number,
zero_point_hh : number) -> Tuple[Tensor, Tensor]
torch.quantized_max_pool2d(self : Tensor,
kernel_size : List[int],
stride : List[int]=[],
padding : List[int]=[0, 0],
dilation : List[int]=[1, 1],
ceil_mode : bool=False) -> Tensor
torch.quantized_rnn_relu_cell(input : Tensor,
hx : Tensor,
w_ih : Tensor,
w_hh : Tensor,
b_ih : Tensor,
b_hh : Tensor,
packed_ih : Tensor,
packed_hh : Tensor,
col_offsets_ih : Tensor,
col_offsets_hh : Tensor,
scale_ih : number,
scale_hh : number,
zero_point_ih : number,
zero_point_hh : number) -> Tensor
torch.quantized_rnn_tanh_cell(input : Tensor,
hx : Tensor,
w_ih : Tensor,
w_hh : Tensor,
b_ih : Tensor,
b_hh : Tensor,
packed_ih : Tensor,
packed_hh : Tensor,
col_offsets_ih : Tensor,
col_offsets_hh : Tensor,
scale_ih : number,
scale_hh : number,
zero_point_ih : number,
zero_point_hh : number) -> Tensor
torch.rand(size : List[int],
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.rand(size : List[int],
out : Tensor) -> Tensor
torch.rand_like(self : Tensor,
memory_format : Optional[int]) -> Tensor
torch.rand_like(self : Tensor,
dtype : int,
layout : int,
device : Device,
pin_memory : bool=False,
memory_format : Optional[int]) -> Tensor
torch.randint(high : int,
size : List[int],
out : Tensor) -> Tensor
torch.randint(low : int,
high : int,
size : List[int],
out : Tensor) -> Tensor
torch.randint(high : int,
size : List[int],
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.randint(low : int,
high : int,
size : List[int],
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.randint_like(self : Tensor,
high : int,
memory_format : Optional[int]) -> Tensor
torch.randint_like(self : Tensor,
low : int,
high : int,
memory_format : Optional[int]) -> Tensor
torch.randint_like(self : Tensor,
high : int,
dtype : int,
layout : int,
device : Device,
pin_memory : bool=False,
memory_format : Optional[int]) -> Tensor
torch.randint_like(self : Tensor,
low : int,
high : int,
dtype : int,
layout : int,
device : Device,
pin_memory : bool=False,
memory_format : Optional[int]) -> Tensor
torch.randn(size : List[int],
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.randn(size : List[int],
out : Tensor) -> Tensor
torch.randn_like(self : Tensor,
memory_format : Optional[int]) -> Tensor
torch.randn_like(self : Tensor,
dtype : int,
layout : int,
device : Device,
pin_memory : bool=False,
memory_format : Optional[int]) -> Tensor
torch.randperm(n : int,
out : Tensor) -> Tensor
torch.randperm(n : int,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.range(start : number,
end : number,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.range(start : number,
end : number,
step : number=1,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.range(start : number,
end : number,
step : number=1,
out : Tensor) -> Tensor
torch.real(self : Tensor) -> Tensor
torch.real(self : Tensor,
out : Tensor) -> Tensor
torch.reciprocal(self : Tensor) -> Tensor
torch.reciprocal(self : Tensor,
out : Tensor) -> Tensor
torch.reciprocal_(self : Tensor) -> Tensor
torch.relu(self : Tensor) -> Tensor
torch.relu_(self : Tensor) -> Tensor
torch.remainder(self : Tensor,
other : Tensor) -> Tensor
torch.remainder(self : Tensor,
other : number) -> Tensor
torch.remainder(self : Tensor,
other : Tensor,
out : Tensor) -> Tensor
torch.remainder(self : Tensor,
other : number,
out : Tensor) -> Tensor
torch.remainder(a : int,
b : int) -> int
torch.remainder(a : float,
b : float) -> float
torch.remainder(a : int,
b : float) -> float
torch.remainder(a : float,
b : int) -> float
torch.remainder(a : number,
b : number) -> number
torch.renorm(self : Tensor,
p : number,
dim : int,
maxnorm : number,
out : Tensor) -> Tensor
torch.renorm(self : Tensor,
p : number,
dim : int,
maxnorm : number) -> Tensor
torch.repeat_interleave(repeats : Tensor) -> Tensor
torch.repeat_interleave(self : Tensor,
repeats : Tensor,
dim : Optional[int]) -> Tensor
torch.repeat_interleave(self : Tensor,
repeats : int,
dim : Optional[int]) -> Tensor
torch.reshape(self : Tensor,
shape : List[int]) -> Tensor
torch.resize_as_(self : Tensor,
the_template : Tensor,
memory_format : Optional[int]) -> Tensor
torch.result_type(tensor : Tensor,
other : Tensor) -> int
torch.result_type(scalar : number,
tensor : Tensor) -> int
torch.result_type(tensor : Tensor,
other : number) -> int
torch.result_type(scalar1 : number,
scalar2 : number) -> int
torch.rfft(self : Tensor,
signal_ndim : int,
normalized : bool=False,
onesided : bool=True) -> Tensor
torch.rnn_relu(data : Tensor,
batch_sizes : Tensor,
hx : Tensor,
params : List[Tensor],
has_biases : bool,
num_layers : int,
dropout : float,
train : bool,
bidirectional : bool) -> Tuple[Tensor, Tensor]
torch.rnn_relu(input : Tensor,
hx : Tensor,
params : List[Tensor],
has_biases : bool,
num_layers : int,
dropout : float,
train : bool,
bidirectional : bool,
batch_first : bool) -> Tuple[Tensor, Tensor]
torch.rnn_relu_cell(input : Tensor,
hx : Tensor,
w_ih : Tensor,
w_hh : Tensor,
b_ih : Optional[Tensor],
b_hh : Optional[Tensor]) -> Tensor
torch.rnn_tanh(data : Tensor,
batch_sizes : Tensor,
hx : Tensor,
params : List[Tensor],
has_biases : bool,
num_layers : int,
dropout : float,
train : bool,
bidirectional : bool) -> Tuple[Tensor, Tensor]
torch.rnn_tanh(input : Tensor,
hx : Tensor,
params : List[Tensor],
has_biases : bool,
num_layers : int,
dropout : float,
train : bool,
bidirectional : bool,
batch_first : bool) -> Tuple[Tensor, Tensor]
torch.rnn_tanh_cell(input : Tensor,
hx : Tensor,
w_ih : Tensor,
w_hh : Tensor,
b_ih : Optional[Tensor],
b_hh : Optional[Tensor]) -> Tensor
torch.roll(self : Tensor,
shifts : List[int],
dims : List[int]=[]) -> Tensor
torch.rot90(self : Tensor,
k : int=1,
dims : List[int]=[0, 1]) -> Tensor
torch.round(self : Tensor) -> Tensor
torch.round(self : Tensor,
out : Tensor) -> Tensor
torch.round(a : int) -> float
torch.round(a : float) -> float
torch.round(a : number) -> number
torch.round_(self : Tensor) -> Tensor
torch.rrelu(self : Tensor,
lower : number=0.125,
upper : number=0.3333333333333333,
training : bool=False,
generator : Optional[Generator]) -> Tensor
torch.rrelu_(self : Tensor,
lower : number=0.125,
upper : number=0.3333333333333333,
training : bool=False,
generator : Optional[Generator]) -> Tensor
torch.rsqrt(self : Tensor,
out : Tensor) -> Tensor
torch.rsqrt(self : Tensor) -> Tensor
torch.rsqrt_(self : Tensor) -> Tensor
torch.rsub(self : Tensor,
other : Tensor,
alpha : number=1) -> Tensor
torch.rsub(self : Tensor,
other : number,
alpha : number=1) -> Tensor
torch.save(item : t,
filename : str) -> Tuple[]
torch.scalar_tensor(s : number,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.scatter(self : Tensor,
dim : int,
index : Tensor,
src : Tensor) -> Tensor
torch.scatter(self : Tensor,
dim : int,
index : Tensor,
value : number) -> Tensor
torch.scatter_add(self : Tensor,
dim : int,
index : Tensor,
src : Tensor) -> Tensor
torch.select(self : Tensor,
dim : int,
index : int) -> Tensor
torch.select(list : List[Tensor],
idx : int) -> Tensor
torch.select(a : List[int],
b : int) -> int
torch.select(a : List[float],
b : int) -> float
torch.select(a : List[bool],
b : int) -> bool
torch.select(list : List[t],
idx : int) -> t
torch.selu(self : Tensor) -> Tensor
torch.selu_(self : Tensor) -> Tensor
torch.sigmoid(self : Tensor) -> Tensor
torch.sigmoid(self : Tensor,
out : Tensor) -> Tensor
torch.sigmoid_(self : Tensor) -> Tensor
torch.sign(self : Tensor) -> Tensor
torch.sign(self : Tensor,
out : Tensor) -> Tensor
torch.sin(self : Tensor) -> Tensor
torch.sin(self : Tensor,
out : Tensor) -> Tensor
torch.sin(a : int) -> float
torch.sin(a : float) -> float
torch.sin(a : number) -> number
torch.sin_(self : Tensor) -> Tensor
torch.sinh(self : Tensor,
out : Tensor) -> Tensor
torch.sinh(self : Tensor) -> Tensor
torch.sinh(a : int) -> float
torch.sinh(a : float) -> float
torch.sinh(a : number) -> number
torch.sinh(a : int) -> float
torch.sinh(a : float) -> float
torch.sinh(a : number) -> number
torch.sinh_(self : Tensor) -> Tensor
torch.slogdet(self : Tensor) -> Tuple[Tensor, Tensor]
torch.smm(self : Tensor,
mat2 : Tensor) -> Tensor
torch.softmax(self : Tensor,
dim : int,
dtype : Optional[int]) -> Tensor
torch.solve(self : Tensor,
A : Tensor) -> Tuple[Tensor, Tensor]
torch.sort(self : Tensor,
dim : int=-1,
descending : bool=False) -> Tuple[Tensor, Tensor]
torch.sort(self : List[int],
reverse : bool=False) -> Tuple[]
torch.sort(self : List[float],
reverse : bool=False) -> Tuple[]
torch.sort(self : List[Tensor],
reverse : bool=False) -> Tuple[]
torch.sort(self : List[bool],
reverse : bool=False) -> Tuple[]
torch.sort(self : List[t],
reverse : bool=False) -> Tuple[]
torch.sparse_coo_tensor(size : List[int],
dtype : int,
layout : int,
device : Device,
pin_memory : bool=False) -> Tensor
torch.sparse_coo_tensor(indices : Tensor,
values : Tensor,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.sparse_coo_tensor(indices : Tensor,
values : Tensor,
size : List[int],
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.split(self : Tensor,
split_size : int,
dim : int=0) -> List[Tensor]
torch.split(self : str,
separator : str= ,
max : int=-1) -> List[str]
torch.split(self : Tensor,
split_sizes : List[int],
dim : int=0) -> List[Tensor]
torch.split_with_sizes(self : Tensor,
split_sizes : List[int],
dim : int=0) -> List[Tensor]
torch.sqrt(self : Tensor,
out : Tensor) -> Tensor
torch.sqrt(self : Tensor) -> Tensor
torch.sqrt(a : int) -> float
torch.sqrt(a : float) -> float
torch.sqrt(a : number) -> number
torch.sqrt_(self : Tensor) -> Tensor
torch.squeeze(self : Tensor) -> Tensor
torch.squeeze(self : Tensor,
dim : int) -> Tensor
torch.sspaddmm(self : Tensor,
mat1 : Tensor,
mat2 : Tensor,
beta : number=1,
alpha : number=1,
out : Tensor) -> Tensor
torch.sspaddmm(self : Tensor,
mat1 : Tensor,
mat2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
torch.stack(tensors : List[Tensor],
dim : int=0) -> Tensor
torch.stack(tensors : List[Tensor],
dim : int=0,
out : Tensor) -> Tensor
torch.std(self : Tensor,
unbiased : bool=True) -> Tensor
torch.std(self : Tensor,
dim : List[int],
unbiased : bool=True,
keepdim : bool=False) -> Tensor
torch.std(self : Tensor,
dim : List[int],
unbiased : bool=True,
keepdim : bool=False,
out : Tensor) -> Tensor
torch.std_mean(self : Tensor,
unbiased : bool=True) -> Tuple[Tensor, Tensor]
torch.std_mean(self : Tensor,
dim : List[int],
unbiased : bool=True,
keepdim : bool=False) -> Tuple[Tensor, Tensor]
torch.stft(self : Tensor,
n_fft : int,
hop_length : Optional[int],
win_length : Optional[int],
window : Optional[Tensor],
normalized : bool=False,
onesided : bool=True) -> Tensor
torch.sub(self : Tensor,
other : Tensor,
alpha : number=1) -> Tensor
torch.sub(self : Tensor,
other : number,
alpha : number=1) -> Tensor
torch.sub(self : Tensor,
other : Tensor,
alpha : number=1,
out : Tensor) -> Tensor
torch.sub(a : int,
b : int) -> int
torch.sub(a : float,
b : float) -> float
torch.sub(a : int,
b : float) -> float
torch.sub(a : float,
b : int) -> float
torch.sub(a : number,
b : number) -> number
torch.sum(self : Tensor,
dim : List[int],
keepdim : bool=False,
dtype : Optional[int],
out : Tensor) -> Tensor
torch.sum(self : Tensor,
dtype : Optional[int]) -> Tensor
torch.sum(self : Tensor,
dim : List[int],
keepdim : bool=False,
dtype : Optional[int]) -> Tensor
torch.svd(self : Tensor,
some : bool=True,
compute_uv : bool=True) -> Tuple[Tensor, Tensor, Tensor]
torch.symeig(self : Tensor,
eigenvectors : bool=False,
upper : bool=True) -> Tuple[Tensor, Tensor]
torch.t(self : Tensor) -> Tensor
torch.take(self : Tensor,
index : Tensor) -> Tensor
torch.take(self : Tensor,
index : Tensor,
out : Tensor) -> Tensor
torch.tan(self : Tensor,
out : Tensor) -> Tensor
torch.tan(self : Tensor) -> Tensor
torch.tan(a : int) -> float
torch.tan(a : float) -> float
torch.tan(a : number) -> number
torch.tan_(self : Tensor) -> Tensor
torch.tanh(self : Tensor) -> Tensor
torch.tanh(self : Tensor,
out : Tensor) -> Tensor
torch.tanh(a : int) -> float
torch.tanh(a : float) -> float
torch.tanh(a : number) -> number
torch.tanh(a : int) -> float
torch.tanh(a : float) -> float
torch.tanh(a : number) -> number
torch.tanh_(self : Tensor) -> Tensor
torch.tensor(t : float,
dtype : Optional[int],
device : Optional[Device],
requires_grad : bool=False) -> Tensor
torch.tensor(t : int,
dtype : Optional[int],
device : Optional[Device],
requires_grad : bool=False) -> Tensor
torch.tensor(t : bool,
dtype : Optional[int],
device : Optional[Device],
requires_grad : bool=False) -> Tensor
torch.tensor(data : List[t],
dtype : Optional[int],
device : Optional[Device],
requires_grad : bool=False) -> Tensor
torch.tensordot(self : Tensor,
other : Tensor,
dims_self : List[int],
dims_other : List[int]) -> Tensor
torch.threshold(self : Tensor,
threshold : number,
value : number) -> Tensor
torch.threshold(self : Tensor,
threshold : number,
value : number,
out : Tensor) -> Tensor
torch.threshold_(self : Tensor,
threshold : number,
value : number) -> Tensor
torch.topk(self : Tensor,
k : int,
dim : int=-1,
largest : bool=True,
sorted : bool=True) -> Tuple[Tensor, Tensor]
torch.trace(self : Tensor) -> Tensor
torch.transpose(self : Tensor,
dim0 : int,
dim1 : int) -> Tensor
torch.trapz(y : Tensor,
x : Tensor,
dim : int=-1) -> Tensor
torch.trapz(y : Tensor,
dx : float=1.0,
dim : int=-1) -> Tensor
torch.triangular_solve(self : Tensor,
A : Tensor,
upper : bool=True,
transpose : bool=False,
unitriangular : bool=False) -> Tuple[Tensor, Tensor]
torch.tril(self : Tensor,
diagonal : int=0,
out : Tensor) -> Tensor
torch.tril(self : Tensor,
diagonal : int=0) -> Tensor
torch.tril_indices(row : int,
col : int,
offset : int=0,
dtype : Optional[int]=4,
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.triplet_margin_loss(anchor : Tensor,
positive : Tensor,
negative : Tensor,
margin : float=1.0,
p : float=2.0,
eps : float=1e-06,
swap : bool=False,
reduction : int=1) -> Tensor
torch.triu(self : Tensor,
diagonal : int=0,
out : Tensor) -> Tensor
torch.triu(self : Tensor,
diagonal : int=0) -> Tensor
torch.triu_indices(row : int,
col : int,
offset : int=0,
dtype : Optional[int]=4,
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.trunc(self : Tensor) -> Tensor
torch.trunc(self : Tensor,
out : Tensor) -> Tensor
torch.trunc_(self : Tensor) -> Tensor
torch.unbind(self : Tensor,
dim : int=0) -> List[Tensor]
torch.unique_consecutive(self : Tensor,
return_inverse : bool=False,
return_counts : bool=False,
dim : Optional[int]) -> Tuple[Tensor, Tensor, Tensor]
torch.unsqueeze(self : Tensor,
dim : int) -> Tensor
torch.var(self : Tensor,
dim : List[int],
unbiased : bool=True,
keepdim : bool=False,
out : Tensor) -> Tensor
torch.var(self : Tensor,
unbiased : bool=True) -> Tensor
torch.var(self : Tensor,
dim : List[int],
unbiased : bool=True,
keepdim : bool=False) -> Tensor
torch.var_mean(self : Tensor,
unbiased : bool=True) -> Tuple[Tensor, Tensor]
torch.var_mean(self : Tensor,
dim : List[int],
unbiased : bool=True,
keepdim : bool=False) -> Tuple[Tensor, Tensor]
torch.wait(self : Future[t]) -> t
torch.where(condition : Tensor) -> List[Tensor]
torch.where(condition : Tensor,
self : Tensor,
other : Tensor) -> Tensor
torch.zero_(self : Tensor) -> Tensor
torch.zeros(size : List[int],
out : Tensor) -> Tensor
torch.zeros(size : List[int],
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
torch.zeros_like(self : Tensor,
memory_format : Optional[int]) -> Tensor
torch.zeros_like(self : Tensor,
dtype : int,
layout : int,
device : Device,
pin_memory : bool=False,
memory_format : Optional[int]) -> Tensor
torch._C._nn.adaptive_avg_pool2d(self : Tensor,
output_size : List[int],
out : Tensor) -> Tensor
torch._C._nn.adaptive_avg_pool2d(self : Tensor,
output_size : List[int]) -> Tensor
torch._C._nn.adaptive_avg_pool3d(self : Tensor,
output_size : List[int]) -> Tensor
torch._C._nn.adaptive_avg_pool3d(self : Tensor,
output_size : List[int],
out : Tensor) -> Tensor
torch._C._nn.adaptive_max_pool2d(self : Tensor,
output_size : List[int]) -> Tuple[Tensor, Tensor]
torch._C._nn.adaptive_max_pool3d(self : Tensor,
output_size : List[int]) -> Tuple[Tensor, Tensor]
torch._C._nn.avg_pool2d(self : Tensor,
kernel_size : List[int],
stride : List[int]=[],
padding : List[int]=[0, 0],
ceil_mode : bool=False,
count_include_pad : bool=True,
divisor_override : Optional[int]) -> Tensor
torch._C._nn.avg_pool2d(self : Tensor,
kernel_size : List[int],
stride : List[int]=[],
padding : List[int]=[0, 0],
ceil_mode : bool=False,
count_include_pad : bool=True,
divisor_override : Optional[int],
out : Tensor) -> Tensor
torch._C._nn.avg_pool3d(self : Tensor,
kernel_size : List[int],
stride : List[int]=[],
padding : List[int]=[0, 0, 0],
ceil_mode : bool=False,
count_include_pad : bool=True,
divisor_override : Optional[int]) -> Tensor
torch._C._nn.avg_pool3d(self : Tensor,
kernel_size : List[int],
stride : List[int]=[],
padding : List[int]=[0, 0, 0],
ceil_mode : bool=False,
count_include_pad : bool=True,
divisor_override : Optional[int],
out : Tensor) -> Tensor
torch._C._nn.binary_cross_entropy(self : Tensor,
target : Tensor,
weight : Optional[Tensor],
reduction : int=1,
out : Tensor) -> Tensor
torch._C._nn.binary_cross_entropy(self : Tensor,
target : Tensor,
weight : Optional[Tensor],
reduction : int=1) -> Tensor
torch._C._nn.col2im(self : Tensor,
output_size : List[int],
kernel_size : List[int],
dilation : List[int],
padding : List[int],
stride : List[int]) -> Tensor
torch._C._nn.col2im(self : Tensor,
output_size : List[int],
kernel_size : List[int],
dilation : List[int],
padding : List[int],
stride : List[int],
out : Tensor) -> Tensor
torch._C._nn.elu(self : Tensor,
alpha : number=1,
scale : number=1,
input_scale : number=1,
out : Tensor) -> Tensor
torch._C._nn.elu(self : Tensor,
alpha : number=1,
scale : number=1,
input_scale : number=1) -> Tensor
torch._C._nn.elu_(self : Tensor,
alpha : number=1,
scale : number=1,
input_scale : number=1) -> Tensor
torch._C._nn.fractional_max_pool2d(self : Tensor,
kernel_size : List[int],
output_size : List[int],
random_samples : Tensor) -> Tuple[Tensor, Tensor]
torch._C._nn.fractional_max_pool3d(self : Tensor,
kernel_size : List[int],
output_size : List[int],
random_samples : Tensor) -> Tuple[Tensor, Tensor]
torch._C._nn.gelu(self : Tensor) -> Tensor
torch._C._nn.glu(self : Tensor,
dim : int=-1) -> Tensor
torch._C._nn.glu(self : Tensor,
dim : int=-1,
out : Tensor) -> Tensor
torch._C._nn.hardtanh(self : Tensor,
min_val : number=-1,
max_val : number=1,
out : Tensor) -> Tensor
torch._C._nn.hardtanh(self : Tensor,
min_val : number=-1,
max_val : number=1) -> Tensor
torch._C._nn.hardtanh_(self : Tensor,
min_val : number=-1,
max_val : number=1) -> Tensor
torch._C._nn.im2col(self : Tensor,
kernel_size : List[int],
dilation : List[int],
padding : List[int],
stride : List[int]) -> Tensor
torch._C._nn.im2col(self : Tensor,
kernel_size : List[int],
dilation : List[int],
padding : List[int],
stride : List[int],
out : Tensor) -> Tensor
torch._C._nn.l1_loss(self : Tensor,
target : Tensor,
reduction : int=1,
out : Tensor) -> Tensor
torch._C._nn.l1_loss(self : Tensor,
target : Tensor,
reduction : int=1) -> Tensor
torch._C._nn.leaky_relu(self : Tensor,
negative_slope : number=0.01) -> Tensor
torch._C._nn.leaky_relu(self : Tensor,
negative_slope : number=0.01,
out : Tensor) -> Tensor
torch._C._nn.leaky_relu_(self : Tensor,
negative_slope : number=0.01) -> Tensor
torch._C._nn.linear(input : Tensor,
weight : Tensor,
bias : Optional[Tensor]) -> Tensor
torch._C._nn.log_sigmoid(self : Tensor) -> Tensor
torch._C._nn.log_sigmoid(self : Tensor,
out : Tensor) -> Tensor
torch._C._nn.max_pool2d_with_indices(self : Tensor,
kernel_size : List[int],
stride : List[int]=[],
padding : List[int]=[0, 0],
dilation : List[int]=[1, 1],
ceil_mode : bool=False) -> Tuple[Tensor, Tensor]
torch._C._nn.max_pool3d_with_indices(self : Tensor,
kernel_size : List[int],
stride : List[int]=[],
padding : List[int]=[0, 0, 0],
dilation : List[int]=[1, 1, 1],
ceil_mode : bool=False) -> Tuple[Tensor, Tensor]
torch._C._nn.max_unpool2d(self : Tensor,
indices : Tensor,
output_size : List[int]) -> Tensor
torch._C._nn.max_unpool2d(self : Tensor,
indices : Tensor,
output_size : List[int],
out : Tensor) -> Tensor
torch._C._nn.max_unpool3d(self : Tensor,
indices : Tensor,
output_size : List[int],
stride : List[int],
padding : List[int],
out : Tensor) -> Tensor
torch._C._nn.max_unpool3d(self : Tensor,
indices : Tensor,
output_size : List[int],
stride : List[int],
padding : List[int]) -> Tensor
torch._C._nn.mkldnn_linear(input : Tensor,
weight : Tensor,
bias : Optional[Tensor]) -> Tensor
torch._C._nn.mkldnn_reorder_conv2d_weight(self : Tensor,
padding : List[int]=[0, 0],
stride : List[int]=[1, 1],
dilation : List[int]=[1, 1],
groups : int=1) -> Tensor
torch._C._nn.mse_loss(self : Tensor,
target : Tensor,
reduction : int=1,
out : Tensor) -> Tensor
torch._C._nn.mse_loss(self : Tensor,
target : Tensor,
reduction : int=1) -> Tensor
torch._C._nn.multi_margin_loss(self : Tensor,
target : Tensor,
p : number=1,
margin : number=1,
weight : Optional[Tensor],
reduction : int=1,
out : Tensor) -> Tensor
torch._C._nn.multi_margin_loss(self : Tensor,
target : Tensor,
p : number=1,
margin : number=1,
weight : Optional[Tensor],
reduction : int=1) -> Tensor
torch._C._nn.multilabel_margin_loss(self : Tensor,
target : Tensor,
reduction : int=1) -> Tensor
torch._C._nn.multilabel_margin_loss(self : Tensor,
target : Tensor,
reduction : int=1,
out : Tensor) -> Tensor
torch._C._nn.nll_loss(self : Tensor,
target : Tensor,
weight : Optional[Tensor],
reduction : int=1,
ignore_index : int=-100) -> Tensor
torch._C._nn.nll_loss(self : Tensor,
target : Tensor,
weight : Optional[Tensor],
reduction : int=1,
ignore_index : int=-100,
out : Tensor) -> Tensor
torch._C._nn.nll_loss2d(self : Tensor,
target : Tensor,
weight : Optional[Tensor],
reduction : int=1,
ignore_index : int=-100) -> Tensor
torch._C._nn.nll_loss2d(self : Tensor,
target : Tensor,
weight : Optional[Tensor],
reduction : int=1,
ignore_index : int=-100,
out : Tensor) -> Tensor
torch._C._nn.one_hot(self : Tensor,
num_classes : int=-1) -> Tensor
torch._C._nn.reflection_pad1d(self : Tensor,
padding : List[int]) -> Tensor
torch._C._nn.reflection_pad1d(self : Tensor,
padding : List[int],
out : Tensor) -> Tensor
torch._C._nn.reflection_pad2d(self : Tensor,
padding : List[int]) -> Tensor
torch._C._nn.reflection_pad2d(self : Tensor,
padding : List[int],
out : Tensor) -> Tensor
torch._C._nn.replication_pad1d(self : Tensor,
padding : List[int]) -> Tensor
torch._C._nn.replication_pad1d(self : Tensor,
padding : List[int],
out : Tensor) -> Tensor
torch._C._nn.replication_pad2d(self : Tensor,
padding : List[int]) -> Tensor
torch._C._nn.replication_pad2d(self : Tensor,
padding : List[int],
out : Tensor) -> Tensor
torch._C._nn.replication_pad3d(self : Tensor,
padding : List[int],
out : Tensor) -> Tensor
torch._C._nn.replication_pad3d(self : Tensor,
padding : List[int]) -> Tensor
torch._C._nn.rrelu_with_noise(self : Tensor,
noise : Tensor,
lower : number=0.125,
upper : number=0.3333333333333333,
training : bool=False,
generator : Optional[Generator],
out : Tensor) -> Tensor
torch._C._nn.rrelu_with_noise(self : Tensor,
noise : Tensor,
lower : number=0.125,
upper : number=0.3333333333333333,
training : bool=False,
generator : Optional[Generator]) -> Tensor
torch._C._nn.rrelu_with_noise_(self : Tensor,
noise : Tensor,
lower : number=0.125,
upper : number=0.3333333333333333,
training : bool=False,
generator : Optional[Generator]) -> Tensor
torch._C._nn.slow_conv3d(self : Tensor,
weight : Tensor,
kernel_size : List[int],
bias : Optional[Tensor],
stride : List[int]=[1, 1, 1],
padding : List[int]=[0, 0, 0]) -> Tensor
torch._C._nn.slow_conv3d(self : Tensor,
weight : Tensor,
kernel_size : List[int],
bias : Optional[Tensor],
stride : List[int]=[1, 1, 1],
padding : List[int]=[0, 0, 0],
out : Tensor) -> Tensor
torch._C._nn.slow_conv_dilated2d(self : Tensor,
weight : Tensor,
kernel_size : List[int],
bias : Optional[Tensor],
stride : List[int]=[1, 1],
padding : List[int]=[0, 0],
dilation : List[int]=[1, 1]) -> Tensor
torch._C._nn.slow_conv_dilated3d(self : Tensor,
weight : Tensor,
kernel_size : List[int],
bias : Optional[Tensor],
stride : List[int]=[1, 1, 1],
padding : List[int]=[0, 0, 0],
dilation : List[int]=[1, 1, 1]) -> Tensor
torch._C._nn.slow_conv_transpose2d(self : Tensor,
weight : Tensor,
kernel_size : List[int],
bias : Optional[Tensor],
stride : List[int]=[1, 1],
padding : List[int]=[0, 0],
output_padding : List[int]=[0, 0],
dilation : List[int]=[1, 1],
out : Tensor) -> Tensor
torch._C._nn.slow_conv_transpose2d(self : Tensor,
weight : Tensor,
kernel_size : List[int],
bias : Optional[Tensor],
stride : List[int]=[1, 1],
padding : List[int]=[0, 0],
output_padding : List[int]=[0, 0],
dilation : List[int]=[1, 1]) -> Tensor
torch._C._nn.slow_conv_transpose3d(self : Tensor,
weight : Tensor,
kernel_size : List[int],
bias : Optional[Tensor],
stride : List[int]=[1, 1, 1],
padding : List[int]=[0, 0, 0],
output_padding : List[int]=[0, 0, 0],
dilation : List[int]=[1, 1, 1]) -> Tensor
torch._C._nn.slow_conv_transpose3d(self : Tensor,
weight : Tensor,
kernel_size : List[int],
bias : Optional[Tensor],
stride : List[int]=[1, 1, 1],
padding : List[int]=[0, 0, 0],
output_padding : List[int]=[0, 0, 0],
dilation : List[int]=[1, 1, 1],
out : Tensor) -> Tensor
torch._C._nn.smooth_l1_loss(self : Tensor,
target : Tensor,
reduction : int=1) -> Tensor
torch._C._nn.smooth_l1_loss(self : Tensor,
target : Tensor,
reduction : int=1,
out : Tensor) -> Tensor
torch._C._nn.soft_margin_loss(self : Tensor,
target : Tensor,
reduction : int=1,
out : Tensor) -> Tensor
torch._C._nn.soft_margin_loss(self : Tensor,
target : Tensor,
reduction : int=1) -> Tensor
torch._C._nn.softplus(self : Tensor,
beta : number=1,
threshold : number=20,
out : Tensor) -> Tensor
torch._C._nn.softplus(self : Tensor,
beta : number=1,
threshold : number=20) -> Tensor
torch._C._nn.softshrink(self : Tensor,
lambd : number=0.5) -> Tensor
torch._C._nn.softshrink(self : Tensor,
lambd : number=0.5,
out : Tensor) -> Tensor
torch._C._nn.thnn_conv2d(self : Tensor,
weight : Tensor,
kernel_size : List[int],
bias : Optional[Tensor],
stride : List[int]=[1, 1],
padding : List[int]=[0, 0]) -> Tensor
torch._C._nn.thnn_conv2d(self : Tensor,
weight : Tensor,
kernel_size : List[int],
bias : Optional[Tensor],
stride : List[int]=[1, 1],
padding : List[int]=[0, 0],
out : Tensor) -> Tensor
torch._C._nn.thnn_conv_depthwise2d(self : Tensor,
weight : Tensor,
kernel_size : List[int],
bias : Optional[Tensor],
stride : List[int]=[1, 1],
padding : List[int]=[0, 0],
dilation : List[int]=[1, 1]) -> Tensor
torch._C._nn.thnn_conv_depthwise2d(self : Tensor,
weight : Tensor,
kernel_size : List[int],
bias : Optional[Tensor],
stride : List[int]=[1, 1],
padding : List[int]=[0, 0],
dilation : List[int]=[1, 1],
out : Tensor) -> Tensor
torch._C._nn.upsample_bicubic2d(self : Tensor,
output_size : List[int],
align_corners : bool) -> Tensor
torch._C._nn.upsample_bicubic2d(self : Tensor,
output_size : List[int],
align_corners : bool,
out : Tensor) -> Tensor
torch._C._nn.upsample_bilinear2d(self : Tensor,
output_size : List[int],
align_corners : bool) -> Tensor
torch._C._nn.upsample_bilinear2d(self : Tensor,
output_size : List[int],
align_corners : bool,
out : Tensor) -> Tensor
torch._C._nn.upsample_linear1d(self : Tensor,
output_size : List[int],
align_corners : bool) -> Tensor
torch._C._nn.upsample_linear1d(self : Tensor,
output_size : List[int],
align_corners : bool,
out : Tensor) -> Tensor
torch._C._nn.upsample_nearest1d(self : Tensor,
output_size : List[int]) -> Tensor
torch._C._nn.upsample_nearest1d(self : Tensor,
output_size : List[int],
out : Tensor) -> Tensor
torch._C._nn.upsample_nearest2d(self : Tensor,
output_size : List[int]) -> Tensor
torch._C._nn.upsample_nearest2d(self : Tensor,
output_size : List[int],
out : Tensor) -> Tensor
torch._C._nn.upsample_nearest3d(self : Tensor,
output_size : List[int],
out : Tensor) -> Tensor
torch._C._nn.upsample_nearest3d(self : Tensor,
output_size : List[int]) -> Tensor
torch._C._nn.upsample_trilinear3d(self : Tensor,
output_size : List[int],
align_corners : bool,
out : Tensor) -> Tensor
torch._C._nn.upsample_trilinear3d(self : Tensor,
output_size : List[int],
align_corners : bool) -> Tensor
Supported Tensor Methods¶
Tensor.__and__(other : Tensor) -> Tensor
Tensor.__and__(other : number) -> Tensor
Tensor.__iand__(other : Tensor) -> Tensor
Tensor.__iand__(other : number) -> Tensor
Tensor.__ilshift__(other : Tensor) -> Tensor
Tensor.__ilshift__(other : number) -> Tensor
Tensor.__ior__(other : Tensor) -> Tensor
Tensor.__ior__(other : number) -> Tensor
Tensor.__irshift__(other : Tensor) -> Tensor
Tensor.__irshift__(other : number) -> Tensor
Tensor.__ixor__(other : Tensor) -> Tensor
Tensor.__ixor__(other : number) -> Tensor
Tensor.__lshift__(other : Tensor) -> Tensor
Tensor.__lshift__(other : number) -> Tensor
Tensor.__or__(other : Tensor) -> Tensor
Tensor.__or__(other : number) -> Tensor
Tensor.__rshift__(other : Tensor) -> Tensor
Tensor.__rshift__(other : number) -> Tensor
Tensor.__xor__(other : Tensor) -> Tensor
Tensor.__xor__(other : number) -> Tensor
Tensor.abs() -> Tensor
Tensor.abs(out : Tensor) -> Tensor
Tensor.abs_() -> Tensor
Tensor.acos(out : Tensor) -> Tensor
Tensor.acos() -> Tensor
Tensor.acos_() -> Tensor
Tensor.add(other : Tensor,
alpha : number=1) -> Tensor
Tensor.add(other : number,
alpha : number=1) -> Tensor
Tensor.add(other : Tensor,
alpha : number=1,
out : Tensor) -> Tensor
Tensor.add_(other : Tensor,
alpha : number=1) -> Tensor
Tensor.add_(other : number,
alpha : number=1) -> Tensor
Tensor.addbmm(batch1 : Tensor,
batch2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
Tensor.addbmm(batch1 : Tensor,
batch2 : Tensor,
beta : number=1,
alpha : number=1,
out : Tensor) -> Tensor
Tensor.addbmm_(batch1 : Tensor,
batch2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
Tensor.addcdiv(tensor1 : Tensor,
tensor2 : Tensor,
value : number=1,
out : Tensor) -> Tensor
Tensor.addcdiv(tensor1 : Tensor,
tensor2 : Tensor,
value : number=1) -> Tensor
Tensor.addcdiv_(tensor1 : Tensor,
tensor2 : Tensor,
value : number=1) -> Tensor
Tensor.addcmul(tensor1 : Tensor,
tensor2 : Tensor,
value : number=1) -> Tensor
Tensor.addcmul(tensor1 : Tensor,
tensor2 : Tensor,
value : number=1,
out : Tensor) -> Tensor
Tensor.addcmul_(tensor1 : Tensor,
tensor2 : Tensor,
value : number=1) -> Tensor
Tensor.addmm(mat1 : Tensor,
mat2 : Tensor,
beta : number=1,
alpha : number=1,
out : Tensor) -> Tensor
Tensor.addmm(mat1 : Tensor,
mat2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
Tensor.addmm_(mat1 : Tensor,
mat2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
Tensor.addmv(mat : Tensor,
vec : Tensor,
beta : number=1,
alpha : number=1,
out : Tensor) -> Tensor
Tensor.addmv(mat : Tensor,
vec : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
Tensor.addmv_(mat : Tensor,
vec : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
Tensor.addr(vec1 : Tensor,
vec2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
Tensor.addr(vec1 : Tensor,
vec2 : Tensor,
beta : number=1,
alpha : number=1,
out : Tensor) -> Tensor
Tensor.addr_(vec1 : Tensor,
vec2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
Tensor.align_as(other : Tensor) -> Tensor
Tensor.all() -> Tensor
Tensor.all(dim : int,
keepdim : bool=False) -> Tensor
Tensor.all(dim : int,
keepdim : bool=False,
out : Tensor) -> Tensor
Tensor.allclose(other : Tensor,
rtol : float=1e-05,
atol : float=1e-08,
equal_nan : bool=False) -> bool
Tensor.angle() -> Tensor
Tensor.angle(out : Tensor) -> Tensor
Tensor.any() -> Tensor
Tensor.any(dim : int,
keepdim : bool=False) -> Tensor
Tensor.any(dim : int,
keepdim : bool=False,
out : Tensor) -> Tensor
Tensor.argmax(dim : Optional[int],
keepdim : bool=False) -> Tensor
Tensor.argmin(dim : Optional[int],
keepdim : bool=False) -> Tensor
Tensor.argsort(dim : int=-1,
descending : bool=False) -> Tensor
Tensor.as_strided(size : List[int],
stride : List[int],
storage_offset : Optional[int]) -> Tensor
Tensor.as_strided_(size : List[int],
stride : List[int],
storage_offset : Optional[int]) -> Tensor
Tensor.asin() -> Tensor
Tensor.asin(out : Tensor) -> Tensor
Tensor.asin_() -> Tensor
Tensor.atan() -> Tensor
Tensor.atan(out : Tensor) -> Tensor
Tensor.atan2(other : Tensor,
out : Tensor) -> Tensor
Tensor.atan2(other : Tensor) -> Tensor
Tensor.atan2_(other : Tensor) -> Tensor
Tensor.atan_() -> Tensor
Tensor.backward(gradient : Optional[Tensor],
retain_graph : Optional[bool],
create_graph : bool=False) -> Tuple[]
Tensor.baddbmm(batch1 : Tensor,
batch2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
Tensor.baddbmm(batch1 : Tensor,
batch2 : Tensor,
beta : number=1,
alpha : number=1,
out : Tensor) -> Tensor
Tensor.baddbmm_(batch1 : Tensor,
batch2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
Tensor.bernoulli(generator : Optional[Generator]) -> Tensor
Tensor.bernoulli(p : float,
generator : Optional[Generator]) -> Tensor
Tensor.bernoulli(generator : Optional[Generator],
out : Tensor) -> Tensor
Tensor.bernoulli_(p : Tensor,
generator : Optional[Generator]) -> Tensor
Tensor.bernoulli_(p : float=0.5,
generator : Optional[Generator]) -> Tensor
Tensor.bincount(weights : Optional[Tensor],
minlength : int=0) -> Tensor
Tensor.bitwise_not() -> Tensor
Tensor.bitwise_not(out : Tensor) -> Tensor
Tensor.bitwise_not_() -> Tensor
Tensor.bitwise_xor(other : Tensor,
out : Tensor) -> Tensor
Tensor.bitwise_xor(other : number,
out : Tensor) -> Tensor
Tensor.bitwise_xor(other : Tensor) -> Tensor
Tensor.bitwise_xor(other : number) -> Tensor
Tensor.bitwise_xor_(other : Tensor) -> Tensor
Tensor.bitwise_xor_(other : number) -> Tensor
Tensor.bmm(mat2 : Tensor) -> Tensor
Tensor.bmm(mat2 : Tensor,
out : Tensor) -> Tensor
Tensor.cauchy_(median : float=0.0,
sigma : float=1.0,
generator : Optional[Generator]) -> Tensor
Tensor.ceil(out : Tensor) -> Tensor
Tensor.ceil() -> Tensor
Tensor.ceil_() -> Tensor
Tensor.cholesky(upper : bool=False,
out : Tensor) -> Tensor
Tensor.cholesky(upper : bool=False) -> Tensor
Tensor.cholesky_inverse(upper : bool=False) -> Tensor
Tensor.cholesky_inverse(upper : bool=False,
out : Tensor) -> Tensor
Tensor.cholesky_solve(input2 : Tensor,
upper : bool=False,
out : Tensor) -> Tensor
Tensor.cholesky_solve(input2 : Tensor,
upper : bool=False) -> Tensor
Tensor.chunk(chunks : int,
dim : int=0) -> List[Tensor]
Tensor.clamp(min : Optional[number],
max : Optional[number]) -> Tensor
Tensor.clamp(min : Optional[number],
max : Optional[number],
out : Tensor) -> Tensor
Tensor.clamp_(min : Optional[number],
max : Optional[number]) -> Tensor
Tensor.clamp_max(max : number) -> Tensor
Tensor.clamp_max(max : number,
out : Tensor) -> Tensor
Tensor.clamp_max_(max : number) -> Tensor
Tensor.clamp_min(min : number,
out : Tensor) -> Tensor
Tensor.clamp_min(min : number) -> Tensor
Tensor.clamp_min_(min : number) -> Tensor
Tensor.clone(memory_format : Optional[int]) -> Tensor
Tensor.coalesce() -> Tensor
Tensor.conj() -> Tensor
Tensor.conj(out : Tensor) -> Tensor
Tensor.contiguous(memory_format : int=0) -> Tensor
Tensor.copy_(src : Tensor,
non_blocking : bool=False) -> Tensor
Tensor.copy_(other : Tensor) -> Tensor
Tensor.copy_(other : int) -> Tensor
Tensor.copy_(other : float) -> Tensor
Tensor.cos() -> Tensor
Tensor.cos(out : Tensor) -> Tensor
Tensor.cos_() -> Tensor
Tensor.cosh() -> Tensor
Tensor.cosh(out : Tensor) -> Tensor
Tensor.cosh_() -> Tensor
Tensor.cpu() -> Tensor
Tensor.cross(other : Tensor,
dim : Optional[int],
out : Tensor) -> Tensor
Tensor.cross(other : Tensor,
dim : Optional[int]) -> Tensor
Tensor.cuda() -> Tensor
Tensor.cumprod(dim : int,
dtype : Optional[int]) -> Tensor
Tensor.cumprod(dim : int,
dtype : Optional[int],
out : Tensor) -> Tensor
Tensor.cumsum(dim : int,
dtype : Optional[int]) -> Tensor
Tensor.cumsum(dim : int,
dtype : Optional[int],
out : Tensor) -> Tensor
Tensor.data() -> Tensor
Tensor.dense_dim() -> int
Tensor.dequantize() -> Tensor
Tensor.det() -> Tensor
Tensor.detach() -> Tensor
Tensor.detach_() -> Tensor
Tensor.diag(diagonal : int=0) -> Tensor
Tensor.diag(diagonal : int=0,
out : Tensor) -> Tensor
Tensor.diag_embed(offset : int=0,
dim1 : int=-2,
dim2 : int=-1) -> Tensor
Tensor.diagflat(offset : int=0) -> Tensor
Tensor.diagonal(offset : int=0,
dim1 : int=0,
dim2 : int=1) -> Tensor
Tensor.digamma() -> Tensor
Tensor.digamma(out : Tensor) -> Tensor
Tensor.digamma_() -> Tensor
Tensor.dim() -> int
Tensor.dist(other : Tensor,
p : number=2) -> Tensor
Tensor.div(other : Tensor,
out : Tensor) -> Tensor
Tensor.div(other : Tensor) -> Tensor
Tensor.div(other : number) -> Tensor
Tensor.div_(other : Tensor) -> Tensor
Tensor.div_(other : number) -> Tensor
Tensor.dot(tensor : Tensor) -> Tensor
Tensor.dot(tensor : Tensor,
out : Tensor) -> Tensor
Tensor.eig(eigenvectors : bool=False) -> Tuple[Tensor, Tensor]
Tensor.eq(other : Tensor) -> Tensor
Tensor.eq(other : number) -> Tensor
Tensor.eq(other : Tensor,
out : Tensor) -> Tensor
Tensor.eq(other : number,
out : Tensor) -> Tensor
Tensor.eq_(other : Tensor) -> Tensor
Tensor.eq_(other : number) -> Tensor
Tensor.equal(other : Tensor) -> bool
Tensor.erf(out : Tensor) -> Tensor
Tensor.erf() -> Tensor
Tensor.erf_() -> Tensor
Tensor.erfc(out : Tensor) -> Tensor
Tensor.erfc() -> Tensor
Tensor.erfc_() -> Tensor
Tensor.erfinv(out : Tensor) -> Tensor
Tensor.erfinv() -> Tensor
Tensor.erfinv_() -> Tensor
Tensor.exp() -> Tensor
Tensor.exp(out : Tensor) -> Tensor
Tensor.exp_() -> Tensor
Tensor.expand(size : List[int],
implicit : bool=False) -> Tensor
Tensor.expand_as(other : Tensor) -> Tensor
Tensor.expm1(out : Tensor) -> Tensor
Tensor.expm1() -> Tensor
Tensor.expm1_() -> Tensor
Tensor.exponential_(lambd : float=1.0,
generator : Optional[Generator]) -> Tensor
Tensor.fft(signal_ndim : int,
normalized : bool=False) -> Tensor
Tensor.fill_(value : Tensor) -> Tensor
Tensor.fill_(value : number) -> Tensor
Tensor.fill_diagonal_(fill_value : number,
wrap : bool=False) -> Tensor
Tensor.flatten(start_dim : int=0,
end_dim : int=-1) -> Tensor
Tensor.flip(dims : List[int]) -> Tensor
Tensor.floor() -> Tensor
Tensor.floor(out : Tensor) -> Tensor
Tensor.floor_() -> Tensor
Tensor.fmod(other : Tensor,
out : Tensor) -> Tensor
Tensor.fmod(other : number,
out : Tensor) -> Tensor
Tensor.fmod(other : Tensor) -> Tensor
Tensor.fmod(other : number) -> Tensor
Tensor.fmod_(other : Tensor) -> Tensor
Tensor.fmod_(other : number) -> Tensor
Tensor.frac() -> Tensor
Tensor.frac(out : Tensor) -> Tensor
Tensor.frac_() -> Tensor
Tensor.gather(dim : int,
index : Tensor,
sparse_grad : bool=False,
out : Tensor) -> Tensor
Tensor.gather(dim : int,
index : Tensor,
sparse_grad : bool=False) -> Tensor
Tensor.ge(other : Tensor) -> Tensor
Tensor.ge(other : number) -> Tensor
Tensor.ge(other : Tensor,
out : Tensor) -> Tensor
Tensor.ge(other : number,
out : Tensor) -> Tensor
Tensor.ge_(other : Tensor) -> Tensor
Tensor.ge_(other : number) -> Tensor
Tensor.geometric_(p : float,
generator : Optional[Generator]) -> Tensor
Tensor.geqrf() -> Tuple[Tensor, Tensor]
Tensor.ger(vec2 : Tensor) -> Tensor
Tensor.ger(vec2 : Tensor,
out : Tensor) -> Tensor
Tensor.get_device() -> int
Tensor.get_device() -> int
Tensor.get_device() -> int
Tensor.gt(other : Tensor) -> Tensor
Tensor.gt(other : number) -> Tensor
Tensor.gt(other : Tensor,
out : Tensor) -> Tensor
Tensor.gt(other : number,
out : Tensor) -> Tensor
Tensor.gt_(other : Tensor) -> Tensor
Tensor.gt_(other : number) -> Tensor
Tensor.hardshrink(lambd : number=0.5) -> Tensor
Tensor.histc(bins : int=100,
min : number=0,
max : number=0,
out : Tensor) -> Tensor
Tensor.histc(bins : int=100,
min : number=0,
max : number=0) -> Tensor
Tensor.ifft(signal_ndim : int,
normalized : bool=False) -> Tensor
Tensor.imag() -> Tensor
Tensor.imag(out : Tensor) -> Tensor
Tensor.index_add(dim : int,
index : Tensor,
source : Tensor) -> Tensor
Tensor.index_add_(dim : int,
index : Tensor,
source : Tensor) -> Tensor
Tensor.index_copy(dim : int,
index : Tensor,
source : Tensor) -> Tensor
Tensor.index_copy_(dim : int,
index : Tensor,
source : Tensor) -> Tensor
Tensor.index_fill(dim : int,
index : Tensor,
value : Tensor) -> Tensor
Tensor.index_fill(dim : int,
index : Tensor,
value : number) -> Tensor
Tensor.index_fill_(dim : int,
index : Tensor,
value : Tensor) -> Tensor
Tensor.index_fill_(dim : int,
index : Tensor,
value : number) -> Tensor
Tensor.index_put(indices : List[Optional[Tensor]],
values : Tensor,
accumulate : bool=False) -> Tensor
Tensor.index_put(indices : List[Tensor],
values : Tensor,
accumulate : bool=False) -> Tensor
Tensor.index_put_(indices : List[Optional[Tensor]],
values : Tensor,
accumulate : bool=False) -> Tensor
Tensor.index_put_(indices : List[Tensor],
values : Tensor,
accumulate : bool=False) -> Tensor
Tensor.index_select(dim : int,
index : Tensor,
out : Tensor) -> Tensor
Tensor.index_select(dim : int,
index : Tensor) -> Tensor
Tensor.indices() -> Tensor
Tensor.int_repr() -> Tensor
Tensor.inverse(out : Tensor) -> Tensor
Tensor.inverse() -> Tensor
Tensor.irfft(signal_ndim : int,
normalized : bool=False,
onesided : bool=True,
signal_sizes : List[int]=[]) -> Tensor
Tensor.is_coalesced() -> bool
Tensor.is_complex() -> bool
Tensor.is_contiguous() -> bool
Tensor.is_contiguous() -> bool
Tensor.is_contiguous() -> bool
Tensor.is_distributed() -> bool
Tensor.is_floating_point() -> bool
Tensor.is_leaf() -> bool
Tensor.is_nonzero() -> bool
Tensor.is_pinned() -> bool
Tensor.is_same_size(other : Tensor) -> bool
Tensor.is_set_to(tensor : Tensor) -> bool
Tensor.is_signed() -> bool
Tensor.isclose(other : Tensor,
rtol : float=1e-05,
atol : float=1e-08,
equal_nan : bool=False) -> Tensor
Tensor.item() -> number
Tensor.kthvalue(k : int,
dim : int=-1,
keepdim : bool=False) -> Tuple[Tensor, Tensor]
Tensor.le(other : Tensor,
out : Tensor) -> Tensor
Tensor.le(other : number,
out : Tensor) -> Tensor
Tensor.le(other : Tensor) -> Tensor
Tensor.le(other : number) -> Tensor
Tensor.le_(other : Tensor) -> Tensor
Tensor.le_(other : number) -> Tensor
Tensor.lerp(end : Tensor,
weight : Tensor) -> Tensor
Tensor.lerp(end : Tensor,
weight : number) -> Tensor
Tensor.lerp(end : Tensor,
weight : Tensor,
out : Tensor) -> Tensor
Tensor.lerp(end : Tensor,
weight : number,
out : Tensor) -> Tensor
Tensor.lerp_(end : Tensor,
weight : Tensor) -> Tensor
Tensor.lerp_(end : Tensor,
weight : number) -> Tensor
Tensor.lgamma(out : Tensor) -> Tensor
Tensor.lgamma() -> Tensor
Tensor.lgamma_() -> Tensor
Tensor.log() -> Tensor
Tensor.log(out : Tensor) -> Tensor
Tensor.log10(out : Tensor) -> Tensor
Tensor.log10() -> Tensor
Tensor.log10_() -> Tensor
Tensor.log1p() -> Tensor
Tensor.log1p(out : Tensor) -> Tensor
Tensor.log1p_() -> Tensor
Tensor.log2() -> Tensor
Tensor.log2(out : Tensor) -> Tensor
Tensor.log2_() -> Tensor
Tensor.log_() -> Tensor
Tensor.log_normal_(mean : float=1.0,
std : float=2.0,
generator : Optional[Generator]) -> Tensor
Tensor.log_softmax(dim : int,
dtype : Optional[int]) -> Tensor
Tensor.logdet() -> Tensor
Tensor.logical_not(out : Tensor) -> Tensor
Tensor.logical_not() -> Tensor
Tensor.logical_not_() -> Tensor
Tensor.logical_xor(other : Tensor) -> Tensor
Tensor.logical_xor(other : Tensor,
out : Tensor) -> Tensor
Tensor.logical_xor_(other : Tensor) -> Tensor
Tensor.logsumexp(dim : List[int],
keepdim : bool=False) -> Tensor
Tensor.logsumexp(dim : List[int],
keepdim : bool=False,
out : Tensor) -> Tensor
Tensor.lstsq(A : Tensor) -> Tuple[Tensor, Tensor]
Tensor.lt(other : Tensor,
out : Tensor) -> Tensor
Tensor.lt(other : number,
out : Tensor) -> Tensor
Tensor.lt(other : Tensor) -> Tensor
Tensor.lt(other : number) -> Tensor
Tensor.lt_(other : Tensor) -> Tensor
Tensor.lt_(other : number) -> Tensor
Tensor.lu_solve(LU_data : Tensor,
LU_pivots : Tensor) -> Tensor
Tensor.lu_solve(LU_data : Tensor,
LU_pivots : Tensor,
out : Tensor) -> Tensor
Tensor.masked_fill(mask : Tensor,
value : Tensor) -> Tensor
Tensor.masked_fill(mask : Tensor,
value : number) -> Tensor
Tensor.masked_fill_(mask : Tensor,
value : Tensor) -> Tensor
Tensor.masked_fill_(mask : Tensor,
value : number) -> Tensor
Tensor.masked_scatter(mask : Tensor,
source : Tensor) -> Tensor
Tensor.masked_scatter_(mask : Tensor,
source : Tensor) -> Tensor
Tensor.masked_select(mask : Tensor,
out : Tensor) -> Tensor
Tensor.masked_select(mask : Tensor) -> Tensor
Tensor.matmul(other : Tensor,
out : Tensor) -> Tensor
Tensor.matmul(other : Tensor) -> Tensor
Tensor.matrix_power(n : int) -> Tensor
Tensor.max(other : Tensor,
out : Tensor) -> Tensor
Tensor.max() -> Tensor
Tensor.max(other : Tensor) -> Tensor
Tensor.max(dim : int,
keepdim : bool=False) -> Tuple[Tensor, Tensor]
Tensor.mean(dtype : Optional[int]) -> Tensor
Tensor.mean(dim : List[int],
keepdim : bool=False,
dtype : Optional[int]) -> Tensor
Tensor.mean(dim : List[int],
keepdim : bool=False,
dtype : Optional[int],
out : Tensor) -> Tensor
Tensor.median() -> Tensor
Tensor.median(dim : int,
keepdim : bool=False) -> Tuple[Tensor, Tensor]
Tensor.min() -> Tensor
Tensor.min(other : Tensor) -> Tensor
Tensor.min(dim : int,
keepdim : bool=False) -> Tuple[Tensor, Tensor]
Tensor.min(other : Tensor,
out : Tensor) -> Tensor
Tensor.mm(mat2 : Tensor,
out : Tensor) -> Tensor
Tensor.mm(mat2 : Tensor) -> Tensor
Tensor.mode(dim : int=-1,
keepdim : bool=False) -> Tuple[Tensor, Tensor]
Tensor.mul(other : Tensor) -> Tensor
Tensor.mul(other : number) -> Tensor
Tensor.mul(other : Tensor,
out : Tensor) -> Tensor
Tensor.mul_(other : Tensor) -> Tensor
Tensor.mul_(other : number) -> Tensor
Tensor.multinomial(num_samples : int,
replacement : bool=False,
generator : Optional[Generator]) -> Tensor
Tensor.multinomial(num_samples : int,
replacement : bool=False,
generator : Optional[Generator],
out : Tensor) -> Tensor
Tensor.mv(vec : Tensor,
out : Tensor) -> Tensor
Tensor.mv(vec : Tensor) -> Tensor
Tensor.mvlgamma(p : int) -> Tensor
Tensor.mvlgamma_(p : int) -> Tensor
Tensor.narrow(dim : int,
start : int,
length : int) -> Tensor
Tensor.narrow_copy(dim : int,
start : int,
length : int) -> Tensor
Tensor.ne(other : Tensor) -> Tensor
Tensor.ne(other : number) -> Tensor
Tensor.ne(other : Tensor,
out : Tensor) -> Tensor
Tensor.ne(other : number,
out : Tensor) -> Tensor
Tensor.ne_(other : Tensor) -> Tensor
Tensor.ne_(other : number) -> Tensor
Tensor.neg(out : Tensor) -> Tensor
Tensor.neg() -> Tensor
Tensor.neg_() -> Tensor
Tensor.new_empty(size : List[int],
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
Tensor.new_full(size : List[int],
fill_value : number,
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
Tensor.new_zeros(size : List[int],
dtype : Optional[int],
layout : Optional[int],
device : Optional[Device],
pin_memory : Optional[bool]) -> Tensor
Tensor.nonzero(out : Tensor) -> Tensor
Tensor.nonzero() -> Tensor
Tensor.norm(p : number=2) -> Tensor
Tensor.norm(p : Optional[number],
dtype : int) -> Tensor
Tensor.norm(p : Optional[number],
dim : List[int],
keepdim : bool=False) -> Tensor
Tensor.norm(p : Optional[number],
dim : List[int],
keepdim : bool,
dtype : int) -> Tensor
Tensor.norm(p : Optional[number],
dim : List[int],
keepdim : bool=False,
out : Tensor) -> Tensor
Tensor.norm(p : Optional[number],
dim : List[int],
keepdim : bool,
dtype : int,
out : Tensor) -> Tensor
Tensor.normal_(mean : float=0.0,
std : float=1.0,
generator : Optional[Generator]) -> Tensor
Tensor.numel() -> int
Tensor.orgqr(input2 : Tensor) -> Tensor
Tensor.orgqr(input2 : Tensor,
out : Tensor) -> Tensor
Tensor.ormqr(input2 : Tensor,
input3 : Tensor,
left : bool=True,
transpose : bool=False) -> Tensor
Tensor.ormqr(input2 : Tensor,
input3 : Tensor,
left : bool=True,
transpose : bool=False,
out : Tensor) -> Tensor
Tensor.output_nr() -> int
Tensor.permute(dims : List[int]) -> Tensor
Tensor.pin_memory() -> Tensor
Tensor.pinverse(rcond : float=1e-15) -> Tensor
Tensor.polygamma_(n : int) -> Tensor
Tensor.pow(exponent : Tensor) -> Tensor
Tensor.pow(exponent : number) -> Tensor
Tensor.pow(exponent : Tensor,
out : Tensor) -> Tensor
Tensor.pow(exponent : number,
out : Tensor) -> Tensor
Tensor.pow_(exponent : Tensor) -> Tensor
Tensor.pow_(exponent : number) -> Tensor
Tensor.prelu(weight : Tensor) -> Tensor
Tensor.prod(dim : int,
keepdim : bool=False,
dtype : Optional[int],
out : Tensor) -> Tensor
Tensor.prod(dtype : Optional[int]) -> Tensor
Tensor.prod(dim : int,
keepdim : bool=False,
dtype : Optional[int]) -> Tensor
Tensor.put_(index : Tensor,
source : Tensor,
accumulate : bool=False) -> Tensor
Tensor.q_per_channel_axis() -> int
Tensor.q_per_channel_scales() -> Tensor
Tensor.q_per_channel_zero_points() -> Tensor
Tensor.q_scale() -> float
Tensor.q_zero_point() -> int
Tensor.qr(some : bool=True) -> Tuple[Tensor, Tensor]
Tensor.qscheme() -> int
Tensor.random_(generator : Optional[Generator]) -> Tensor
Tensor.random_(to : int,
generator : Optional[Generator]) -> Tensor
Tensor.random_(from : int,
to : int,
generator : Optional[Generator]) -> Tensor
Tensor.real() -> Tensor
Tensor.real(out : Tensor) -> Tensor
Tensor.reciprocal() -> Tensor
Tensor.reciprocal(out : Tensor) -> Tensor
Tensor.reciprocal_() -> Tensor
Tensor.relu() -> Tensor
Tensor.relu_() -> Tensor
Tensor.remainder(other : Tensor) -> Tensor
Tensor.remainder(other : number) -> Tensor
Tensor.remainder(other : Tensor,
out : Tensor) -> Tensor
Tensor.remainder(other : number,
out : Tensor) -> Tensor
Tensor.remainder_(other : Tensor) -> Tensor
Tensor.remainder_(other : number) -> Tensor
Tensor.renorm(p : number,
dim : int,
maxnorm : number,
out : Tensor) -> Tensor
Tensor.renorm(p : number,
dim : int,
maxnorm : number) -> Tensor
Tensor.renorm_(p : number,
dim : int,
maxnorm : number) -> Tensor
Tensor.repeat(repeats : List[int]) -> Tensor
Tensor.repeat_interleave(repeats : Tensor,
dim : Optional[int]) -> Tensor
Tensor.repeat_interleave(repeats : int,
dim : Optional[int]) -> Tensor
Tensor.requires_grad_(_requires_grad : bool=True) -> Tensor
Tensor.requires_grad_(_requires_grad : bool=True) -> Tensor
Tensor.reshape(shape : List[int]) -> Tensor
Tensor.reshape_as(other : Tensor) -> Tensor
Tensor.resize_(size : List[int],
memory_format : Optional[int]) -> Tensor
Tensor.resize_as_(the_template : Tensor,
memory_format : Optional[int]) -> Tensor
Tensor.rfft(signal_ndim : int,
normalized : bool=False,
onesided : bool=True) -> Tensor
Tensor.roll(shifts : List[int],
dims : List[int]=[]) -> Tensor
Tensor.rot90(k : int=1,
dims : List[int]=[0, 1]) -> Tensor
Tensor.round() -> Tensor
Tensor.round(out : Tensor) -> Tensor
Tensor.round_() -> Tensor
Tensor.rsqrt(out : Tensor) -> Tensor
Tensor.rsqrt() -> Tensor
Tensor.rsqrt_() -> Tensor
Tensor.scatter(dim : int,
index : Tensor,
src : Tensor) -> Tensor
Tensor.scatter(dim : int,
index : Tensor,
value : number) -> Tensor
Tensor.scatter_(dim : int,
index : Tensor,
src : Tensor) -> Tensor
Tensor.scatter_(dim : int,
index : Tensor,
value : number) -> Tensor
Tensor.scatter_add(dim : int,
index : Tensor,
src : Tensor) -> Tensor
Tensor.scatter_add_(dim : int,
index : Tensor,
src : Tensor) -> Tensor
Tensor.select(dim : int,
index : int) -> Tensor
Tensor.set_() -> Tensor
Tensor.set_(source : Tensor) -> Tensor
Tensor.sigmoid() -> Tensor
Tensor.sigmoid(out : Tensor) -> Tensor
Tensor.sigmoid_() -> Tensor
Tensor.sign() -> Tensor
Tensor.sign(out : Tensor) -> Tensor
Tensor.sign_() -> Tensor
Tensor.sin() -> Tensor
Tensor.sin(out : Tensor) -> Tensor
Tensor.sin_() -> Tensor
Tensor.sinh(out : Tensor) -> Tensor
Tensor.sinh() -> Tensor
Tensor.sinh_() -> Tensor
Tensor.size(dim : int) -> int
Tensor.size() -> List[int]
Tensor.slogdet() -> Tuple[Tensor, Tensor]
Tensor.smm(mat2 : Tensor) -> Tensor
Tensor.softmax(dim : int,
dtype : Optional[int]) -> Tensor
Tensor.solve(A : Tensor) -> Tuple[Tensor, Tensor]
Tensor.sort(dim : int=-1,
descending : bool=False) -> Tuple[Tensor, Tensor]
Tensor.sparse_dim() -> int
Tensor.sparse_mask(mask : Tensor) -> Tensor
Tensor.sparse_resize_(size : List[int],
sparse_dim : int,
dense_dim : int) -> Tensor
Tensor.sparse_resize_and_clear_(size : List[int],
sparse_dim : int,
dense_dim : int) -> Tensor
Tensor.split(split_size : int,
dim : int=0) -> List[Tensor]
Tensor.split(split_sizes : List[int],
dim : int=0) -> List[Tensor]
Tensor.split_with_sizes(split_sizes : List[int],
dim : int=0) -> List[Tensor]
Tensor.sqrt(out : Tensor) -> Tensor
Tensor.sqrt() -> Tensor
Tensor.sqrt_() -> Tensor
Tensor.squeeze() -> Tensor
Tensor.squeeze(dim : int) -> Tensor
Tensor.squeeze_() -> Tensor
Tensor.squeeze_(dim : int) -> Tensor
Tensor.sspaddmm(mat1 : Tensor,
mat2 : Tensor,
beta : number=1,
alpha : number=1,
out : Tensor) -> Tensor
Tensor.sspaddmm(mat1 : Tensor,
mat2 : Tensor,
beta : number=1,
alpha : number=1) -> Tensor
Tensor.std(unbiased : bool=True) -> Tensor
Tensor.std(dim : List[int],
unbiased : bool=True,
keepdim : bool=False) -> Tensor
Tensor.std(dim : List[int],
unbiased : bool=True,
keepdim : bool=False,
out : Tensor) -> Tensor
Tensor.stft(n_fft : int,
hop_length : Optional[int],
win_length : Optional[int],
window : Optional[Tensor],
normalized : bool=False,
onesided : bool=True) -> Tensor
Tensor.storage_offset() -> int
Tensor.storage_offset() -> int
Tensor.storage_offset() -> int
Tensor.stride(dim : int) -> int
Tensor.sub(other : Tensor,
alpha : number=1) -> Tensor
Tensor.sub(other : number,
alpha : number=1) -> Tensor
Tensor.sub(other : Tensor,
alpha : number=1,
out : Tensor) -> Tensor
Tensor.sub_(other : Tensor,
alpha : number=1) -> Tensor
Tensor.sub_(other : number,
alpha : number=1) -> Tensor
Tensor.sum(dim : List[int],
keepdim : bool=False,
dtype : Optional[int],
out : Tensor) -> Tensor
Tensor.sum(dtype : Optional[int]) -> Tensor
Tensor.sum(dim : List[int],
keepdim : bool=False,
dtype : Optional[int]) -> Tensor
Tensor.sum_to_size(size : List[int]) -> Tensor
Tensor.svd(some : bool=True,
compute_uv : bool=True) -> Tuple[Tensor, Tensor, Tensor]
Tensor.symeig(eigenvectors : bool=False,
upper : bool=True) -> Tuple[Tensor, Tensor]
Tensor.t() -> Tensor
Tensor.t_() -> Tensor
Tensor.take(index : Tensor) -> Tensor
Tensor.take(index : Tensor,
out : Tensor) -> Tensor
Tensor.tan(out : Tensor) -> Tensor
Tensor.tan() -> Tensor
Tensor.tan_() -> Tensor
Tensor.tanh() -> Tensor
Tensor.tanh(out : Tensor) -> Tensor
Tensor.tanh_() -> Tensor
Tensor.to(other : Tensor,
non_blocking : bool=False,
copy : bool=False,
memory_format : Optional[int]) -> Tensor
Tensor.to(dtype : int,
non_blocking : bool=False,
copy : bool=False,
memory_format : Optional[int]) -> Tensor
Tensor.to(device : Device,
dtype : int,
non_blocking : bool=False,
copy : bool=False,
memory_format : Optional[int]) -> Tensor
Tensor.to(dtype : int,
layout : int,
device : Device,
pin_memory : bool=False,
non_blocking : bool=False,
copy : bool=False,
memory_format : Optional[int]) -> Tensor
Tensor.to(device : Optional[Device],
dtype : Optional[int],
non_blocking : bool=False,
copy : bool=False) -> Tensor
Tensor.to(dtype : Optional[int],
non_blocking : bool=False,
copy : bool=False) -> Tensor
Tensor.to(non_blocking : bool=False,
copy : bool=False) -> Tensor
Tensor.to_dense() -> Tensor
Tensor.to_mkldnn() -> Tensor
Tensor.to_sparse() -> Tensor
Tensor.to_sparse(sparse_dim : int) -> Tensor
Tensor.topk(k : int,
dim : int=-1,
largest : bool=True,
sorted : bool=True) -> Tuple[Tensor, Tensor]
Tensor.trace() -> Tensor
Tensor.transpose(dim0 : int,
dim1 : int) -> Tensor
Tensor.transpose_(dim0 : int,
dim1 : int) -> Tensor
Tensor.triangular_solve(A : Tensor,
upper : bool=True,
transpose : bool=False,
unitriangular : bool=False) -> Tuple[Tensor, Tensor]
Tensor.tril(diagonal : int=0,
out : Tensor) -> Tensor
Tensor.tril(diagonal : int=0) -> Tensor
Tensor.tril_(diagonal : int=0) -> Tensor
Tensor.triu(diagonal : int=0,
out : Tensor) -> Tensor
Tensor.triu(diagonal : int=0) -> Tensor
Tensor.triu_(diagonal : int=0) -> Tensor
Tensor.trunc() -> Tensor
Tensor.trunc(out : Tensor) -> Tensor
Tensor.trunc_() -> Tensor
Tensor.type_as(other : Tensor) -> Tensor
Tensor.unbind(dim : int=0) -> List[Tensor]
Tensor.unfold(dimension : int,
size : int,
step : int) -> Tensor
Tensor.uniform_(from : float=0.0,
to : float=1.0,
generator : Optional[Generator]) -> Tensor
Tensor.unique_consecutive(return_inverse : bool=False,
return_counts : bool=False,
dim : Optional[int]) -> Tuple[Tensor, Tensor, Tensor]
Tensor.unsqueeze(dim : int) -> Tensor
Tensor.unsqueeze_(dim : int) -> Tensor
Tensor.values() -> Tensor
Tensor.var(dim : List[int],
unbiased : bool=True,
keepdim : bool=False,
out : Tensor) -> Tensor
Tensor.var(unbiased : bool=True) -> Tensor
Tensor.var(dim : List[int],
unbiased : bool=True,
keepdim : bool=False) -> Tensor
Tensor.view(size : List[int]) -> Tensor
Tensor.view_as(other : Tensor) -> Tensor
Tensor.zero_() -> Tensor
