(input: Tensor, normalized_shape: List[int], weight: Optional[Tensor] = None,

(input: Tensor, other: Number, *, out: Optional[Tensor]=None)

(input: Tensor, negative_slope: float = 0.01, inplace: bool = False)

(x: Tensor)

(input: Tensor, end: Tensor, weight, *, out: Optional[Tensor] = None)

(input, weight, bias=None, out=None)

(start, end, steps: _int, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_l

(input: Tensor, *, out: Optional[Tensor]=None)

(input: Tensor, *, out: Optional[Tensor]=None)

(input: Tensor, *, out: Optional[Tensor]=None)

(input: Tensor, *, out: Optional[Tensor]=None)

(input: Tensor, dim, *, dtype: Optional[_dtype]=None)

(input: Tensor, other)

(input: Tensor, other)

(input: Tensor, *, out: Optional[Tensor]=None)

(self, memory_format=None)

(input: Tensor, other: Number, *, out: Optional[Tensor]=None)

(input: Tensor, mask: Tensor, value: Number)

(input: Tensor, mask: Tensor, *, out: Optional[Tensor]=None)

(input: Tensor, other: Tensor, *, out: Optional[Tensor]=None)

(input: Tensor, dim=None, keepdim: _bool=False, *, out=None)

(input: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size]=(), padding: Union[_int, _size]=0,

(input: Tensor, other: Tensor, *, out: Optional[Tensor]=None)

(input: Tensor, dim=None, keepdim: _bool=False, *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None)

(*tensors, indexing: Optional[str] = None)

(input: Tensor, dim=None, keepdim: _bool=False, *, out=None)

(input: Tensor, other: Tensor, *, out: Optional[Tensor]=None)

(self, value, *args, **kwargs)

(input: Tensor, source: _size, destination: _size)

(input: Union[Tensor, Number], other: Union[Tensor, Number], *, out: Optional[Tensor]=None)

(input: Tensor, vec: Tensor, *, out: Optional[Tensor]=None)

(input, dim, start, length)

(self, *args, **kwargs)

(self)

(self, size, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False)

(self, size, fill_value, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False)

(self, size, *args, **kwargs)

(self, data, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False)

(self, size, *args, **kwargs)

(boxes: Tensor, scores: Tensor, iou_threshold: float)

(input, p="fro", dim=None, keepdim=False, out=None, dtype=None)

(input: Tensor, p: float = 2.0, dim: int = 1, eps: float = 1e-12, out: Optional[Tensor] = None)

(tensor, num_classes=-1)

(*size: _int, out: Optional[Tensor]=None, dtype: Optional[_dtype]=None, layout: Optional[_layout]=None, device

(input: Tensor, *, memory_format=None, dtype=None, layout=None, device=None, pin_memory=False, requires_grad=F

(input: Tensor, pad: List[int], mode: str = "constant", value: float = 0.0)

(input: Tensor, dims: _size)

(input: Tensor, upscale_factor: _int)

(input: Tensor, downscale_factor: _int)

(input: Tensor, exponent: Number, *, out: Optional[Tensor]=None)

(input: Tensor, weight: Tensor)

(self, other)

(input: Tensor, inplace: bool = False)

(input: Tensor)

(self, *sizes)

(input: Tensor, repeats, dim: Optional[_int] = None, *, output_size: Optional[_int] = None)

(self, requires_grad)

(self, *shape)

(input, n=None, dim=-1, norm=None, *, out=None)

(input, s=None, dim=(-2, -1), norm=None, *, out=None)

(input: Tensor, shifts: Union[_int, _size], dims: Union[_int, _size]=())

(input: Tensor, *, decimals: _int, out=None)

(self, other)

(input: Tensor, *, out: Optional[Tensor] = None)

(self, other)

(s: Number, *, dtype: Optional[_dtype]=None, layout: Optional[_layout]=None, device: Optional[Union[_device, s

(query, key, value, attn_mask=None, dropout_p=0.0, is_causal=False, scale=None)

(input, dim, index, src)

(self, l, x, deltaA, deltaB_u, C)

(sliced_tensor, slice_args, assigned_tensor)

(x: Tensor, dim=None)

(self)

(input: Tensor, *, out: Optional[Tensor]=None)

(input, *args, **kwargs)

(input: Tensor, inplace=False)

(input, *args, **kwargs)

(input: Tensor, dim: Union[str, None], *, dtype: Optional[_dtype]=None)

(self, dim=-1, descending=False)

(self, input: torch.Tensor)

(self, split_size, dim=0)

(input: Tensor, *, out: Optional[Tensor]=None)

(input: Tensor, *, out: Optional[Tensor] = None)

(input: Tensor, dim)

(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: _int=0, *, out: Optional[Tensor]=None)

(input: Tensor, dim, unbiased: _bool=True, keepdim: _bool=False, *, out: Optional[Tensor]=None)

(input: Tensor, n_fft: int, hop_length: Optional[int] = None, win_length: Optional[int] = None, windo

(input: Union[Tensor, Number], other: Union[Tensor, Number], *, alpha: Optional[Number]=1, out: Optional[Tenso

(input: Tensor, dim=None, keepdim: _bool=False, *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None)

(self: Tensor)

(input, start_dim=0, end_dim=-1)

(self, *dims)

(self, decimals=0)

(input: Tensor, *, out: Optional[Tensor]=None)

(data: Any, dtype: Optional[_dtype]=None, device: Device=None, requires_grad: _bool=False)

(self, device=None, dtype=None, non_blocking=False, copy=False, memory_format=torch.preserve_format)

(input, k, dim=-1, largest=True, sorted=True, *, out=None)

(input: Tensor, dim0, dim1)

(self, diagonal=0)

(self, dtype=None, non_blocking=False, **kwargs)

(self, tensor)