TorchScript 内置功能
这是 TorchScript 中可用的函数和 Tensor 方法的完整参考。
支持的张量方法
Tensor.__and__(other : number) -> Tensor Tensor.__and__(other : Tensor) -> 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.__lshift__(other : number, out : Tensor) -> Tensor Tensor.__lshift__(other : Tensor, out : Tensor) -> Tensor Tensor.__or__(other : Tensor) -> Tensor Tensor.__or__(other : number) -> Tensor Tensor.__rshift__(other : Tensor) -> Tensor Tensor.__rshift__(other : number) -> Tensor Tensor.__rshift__(other : number, out : Tensor) -> Tensor Tensor.__rshift__(other : Tensor, out : Tensor) -> Tensor Tensor.__xor__(other : Tensor) -> Tensor Tensor.__xor__(other : number) -> Tensor Tensor.abs() -> Tensor Tensor.abs(out : Tensor) -> Tensor Tensor.abs_() -> Tensor Tensor.absolute() -> Tensor Tensor.absolute(out : Tensor) -> Tensor Tensor.absolute_() -> Tensor Tensor.acos() -> Tensor Tensor.acos(out : Tensor) -> Tensor Tensor.acos_() -> Tensor Tensor.acosh() -> Tensor Tensor.acosh(out : Tensor) -> Tensor Tensor.acosh_() -> 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 : number, 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) -> Tensor Tensor.addcdiv(tensor1 : Tensor, tensor2 : Tensor, value : number=1, out : Tensor) -> 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) -> 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.addmv(mat : Tensor, vec : 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.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.adjoint() -> Tensor Tensor.align_as(other : Tensor) -> Tensor Tensor.align_to(names : List[str]) -> Tensor Tensor.align_to(order : List[str], ellipsis_idx : int) -> Tensor Tensor.all() -> Tensor Tensor.all(dim : int, keepdim : bool=False) -> Tensor Tensor.all(dim : Optional[List[int]], keepdim : bool=False) -> Tensor Tensor.all(dim : int, keepdim : bool=False, out : Tensor) -> Tensor Tensor.all(dim : Optional[List[int]], keepdim : bool=False, out : Tensor) -> Tensor Tensor.all(out : Tensor) -> Tensor Tensor.all(dim : str, keepdim : bool=False) -> Tensor Tensor.all(dim : str, keepdim : bool=False, out : Tensor) -> Tensor Tensor.allclose(other : Tensor, rtol : float=1e-05, atol : float=1e-08, equal_nan : bool=False) -> bool Tensor.amax(dim : List[int]=[], keepdim : bool=False) -> Tensor Tensor.amax(dim : List[int]=[], keepdim : bool=False, out : Tensor) -> Tensor Tensor.amin(dim : List[int]=[], keepdim : bool=False) -> Tensor Tensor.amin(dim : List[int]=[], keepdim : bool=False, out : Tensor) -> Tensor Tensor.aminmax(dim : Optional[int], keepdim : bool=False) -> Tuple[Tensor, Tensor] Tensor.aminmax(dim : Optional[int], keepdim : bool=False, min : Tensor, max : Tensor) -> Tuple[Tensor, Tensor] Tensor.angle() -> Tensor Tensor.angle(out : Tensor) -> Tensor Tensor.any() -> Tensor Tensor.any(dim : int, keepdim : bool=False) -> Tensor Tensor.any(dim : Optional[List[int]], keepdim : bool=False) -> Tensor Tensor.any(dim : int, keepdim : bool=False, out : Tensor) -> Tensor Tensor.any(dim : Optional[List[int]], keepdim : bool=False, out : Tensor) -> Tensor Tensor.any(out : Tensor) -> Tensor Tensor.any(dim : str, keepdim : bool=False) -> Tensor Tensor.any(dim : str, keepdim : bool=False, out : Tensor) -> Tensor Tensor.arccos() -> Tensor Tensor.arccos(out : Tensor) -> Tensor Tensor.arccos_() -> Tensor Tensor.arccosh() -> Tensor Tensor.arccosh(out : Tensor) -> Tensor Tensor.arccosh_() -> Tensor Tensor.arcsin() -> Tensor Tensor.arcsin(out : Tensor) -> Tensor Tensor.arcsin_() -> Tensor Tensor.arcsinh() -> Tensor Tensor.arcsinh(out : Tensor) -> Tensor Tensor.arcsinh_() -> Tensor Tensor.arctan() -> Tensor Tensor.arctan(out : Tensor) -> Tensor Tensor.arctan2(other : Tensor) -> Tensor Tensor.arctan2(other : Tensor, out : Tensor) -> Tensor Tensor.arctan2_(other : Tensor) -> Tensor Tensor.arctan_() -> Tensor Tensor.arctanh() -> Tensor Tensor.arctanh(out : Tensor) -> Tensor Tensor.arctanh_() -> Tensor Tensor.argmax(dim : Optional[int], keepdim : bool=False) -> Tensor Tensor.argmax(dim : Optional[int], keepdim : bool=False, out : Tensor) -> Tensor Tensor.argmin(dim : Optional[int], keepdim : bool=False) -> Tensor Tensor.argmin(dim : Optional[int], keepdim : bool=False, out : Tensor) -> Tensor Tensor.argsort(dim : int=-1, descending : bool=False) -> Tensor Tensor.argsort(stable : bool, dim : int=-1, descending : bool=False) -> Tensor Tensor.argsort(stable : bool, dim : int=-1, descending : bool=False, out : Tensor) -> Tensor Tensor.argsort(dim : str, descending : bool=False) -> Tensor Tensor.argwhere() -> 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.as_strided_scatter(src : Tensor, size : List[int], stride : List[int], storage_offset : Optional[int]) -> Tensor Tensor.as_strided_scatter(src : Tensor, size : List[int], stride : List[int], storage_offset : Optional[int], out : Tensor) -> Tensor Tensor.asin() -> Tensor Tensor.asin(out : Tensor) -> Tensor Tensor.asin_() -> Tensor Tensor.asinh() -> Tensor Tensor.asinh(out : Tensor) -> Tensor Tensor.asinh_() -> Tensor Tensor.atan() -> Tensor Tensor.atan(out : Tensor) -> Tensor Tensor.atan2(other : Tensor) -> Tensor Tensor.atan2(other : Tensor, out : Tensor) -> Tensor Tensor.atan2_(other : Tensor) -> Tensor Tensor.atan_() -> Tensor Tensor.atanh() -> Tensor Tensor.atanh(out : Tensor) -> Tensor Tensor.atanh_() -> 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(generator : Optional[Generator], out : Tensor) -> Tensor Tensor.bernoulli(p : float, generator : Optional[Generator]) -> Tensor Tensor.bernoulli(p : Tensor, generator : Optional[Generator]) -> Tensor Tensor.bernoulli(p : Tensor, generator : Optional[Generator], out : Tensor) -> Tensor Tensor.bernoulli(p : float=0.5, 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.bincount(weights : Optional[Tensor], minlength : int=0, out : Tensor) -> Tensor Tensor.bitwise_and(other : Tensor) -> Tensor Tensor.bitwise_and(other : number) -> Tensor Tensor.bitwise_and(other : Tensor, out : Tensor) -> Tensor Tensor.bitwise_and(other : number, out : Tensor) -> Tensor Tensor.bitwise_and_(other : Tensor) -> Tensor Tensor.bitwise_and_(other : number) -> Tensor Tensor.bitwise_left_shift(other : Tensor) -> Tensor Tensor.bitwise_left_shift(other : number) -> Tensor Tensor.bitwise_left_shift(other : Tensor, out : Tensor) -> Tensor Tensor.bitwise_left_shift(other : number, out : Tensor) -> Tensor Tensor.bitwise_left_shift_(other : number) -> Tensor Tensor.bitwise_left_shift_(other : Tensor) -> Tensor Tensor.bitwise_not() -> Tensor Tensor.bitwise_not(out : Tensor) -> Tensor Tensor.bitwise_not_() -> Tensor Tensor.bitwise_or(other : Tensor) -> Tensor Tensor.bitwise_or(other : number) -> Tensor Tensor.bitwise_or(other : Tensor, out : Tensor) -> Tensor Tensor.bitwise_or(other : number, out : Tensor) -> Tensor Tensor.bitwise_or_(other : Tensor) -> Tensor Tensor.bitwise_or_(other : number) -> Tensor Tensor.bitwise_right_shift(other : Tensor) -> Tensor Tensor.bitwise_right_shift(other : number) -> Tensor Tensor.bitwise_right_shift(other : Tensor, out : Tensor) -> Tensor Tensor.bitwise_right_shift(other : number, out : Tensor) -> Tensor Tensor.bitwise_right_shift_(other : number) -> Tensor Tensor.bitwise_right_shift_(other : Tensor) -> Tensor Tensor.bitwise_xor(other : Tensor) -> Tensor Tensor.bitwise_xor(other : number) -> 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.bmm(mat2 : Tensor) -> Tensor Tensor.bmm(mat2 : Tensor, out : Tensor) -> Tensor Tensor.broadcast_to(size : List[int]) -> Tensor Tensor.cauchy_(median : float=0.0, sigma : float=1.0, generator : Optional[Generator]) -> Tensor Tensor.ccol_indices() -> Tensor Tensor.ceil() -> Tensor Tensor.ceil(out : Tensor) -> Tensor Tensor.ceil_() -> Tensor Tensor.chalf(memory_format : Optional[int]) -> Tensor Tensor.cholesky(upper : bool=False) -> Tensor Tensor.cholesky(upper : bool=False, out : Tensor) -> 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) -> Tensor Tensor.cholesky_solve(input2 : Tensor, upper : bool=False, out : Tensor) -> Tensor Tensor.chunk(chunks : int, dim : int=0) -> List[Tensor] Tensor.clamp(min : Optional[number], max : Optional[number]) -> Tensor Tensor.clamp(min : Optional[Tensor], max : Optional[Tensor]) -> Tensor Tensor.clamp(min : Optional[number], max : Optional[number], out : Tensor) -> Tensor Tensor.clamp(min : Optional[Tensor], max : Optional[Tensor], out : Tensor) -> Tensor Tensor.clamp_(min : Optional[number], max : Optional[number]) -> Tensor Tensor.clamp_(min : Optional[Tensor], max : Optional[Tensor]) -> Tensor Tensor.clamp_max(max : number) -> Tensor Tensor.clamp_max(max : Tensor) -> Tensor Tensor.clamp_max(max : number, out : Tensor) -> Tensor Tensor.clamp_max(max : Tensor, out : Tensor) -> Tensor Tensor.clamp_max_(max : number) -> Tensor Tensor.clamp_max_(max : Tensor) -> Tensor Tensor.clamp_min(min : number) -> Tensor Tensor.clamp_min(min : Tensor) -> Tensor Tensor.clamp_min(min : number, out : Tensor) -> Tensor Tensor.clamp_min(min : Tensor, out : Tensor) -> Tensor Tensor.clamp_min_(min : number) -> Tensor Tensor.clamp_min_(min : Tensor) -> Tensor Tensor.clip(min : Optional[number], max : Optional[number]) -> Tensor Tensor.clip(min : Optional[Tensor], max : Optional[Tensor]) -> Tensor Tensor.clip(min : Optional[number], max : Optional[number], out : Tensor) -> Tensor Tensor.clip(min : Optional[Tensor], max : Optional[Tensor], out : Tensor) -> Tensor Tensor.clip_(min : Optional[number], max : Optional[number]) -> Tensor Tensor.clip_(min : Optional[Tensor], max : Optional[Tensor]) -> Tensor Tensor.clone(memory_format : Optional[int]) -> Tensor Tensor.clone(memory_format : Optional[int], out : Tensor) -> Tensor Tensor.coalesce() -> Tensor Tensor.col_indices() -> Tensor Tensor.conj() -> Tensor Tensor.conj_physical() -> Tensor Tensor.conj_physical(out : Tensor) -> Tensor Tensor.conj_physical_() -> 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.copysign(other : Tensor) -> Tensor Tensor.copysign(other : number) -> Tensor Tensor.copysign(other : Tensor, out : Tensor) -> Tensor Tensor.copysign(other : number, out : Tensor) -> Tensor Tensor.copysign_(other : Tensor) -> Tensor Tensor.copysign_(other : number) -> Tensor Tensor.corrcoef() -> Tensor Tensor.cos() -> Tensor Tensor.cos(out : Tensor) -> Tensor Tensor.cos_() -> Tensor Tensor.cosh() -> Tensor Tensor.cosh(out : Tensor) -> Tensor Tensor.cosh_() -> Tensor Tensor.count_nonzero(dim : List[int]) -> Tensor Tensor.count_nonzero(dim : List[int], out : Tensor) -> Tensor Tensor.count_nonzero(dim : Optional[int]) -> Tensor Tensor.count_nonzero(dim : Optional[int], out : Tensor) -> Tensor Tensor.cov(correction : int=1, fweights : Optional[Tensor], aweights : Optional[Tensor]) -> Tensor Tensor.cpu() -> Tensor Tensor.cross(other : Tensor, dim : Optional[int]) -> Tensor Tensor.cross(other : Tensor, dim : Optional[int], out : Tensor) -> Tensor Tensor.crow_indices() -> Tensor Tensor.cuda() -> Tensor Tensor.cummax(dim : int) -> Tuple[Tensor, Tensor] Tensor.cummax(dim : str) -> Tuple[Tensor, Tensor] Tensor.cummax(dim : str, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.cummax(dim : int, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.cummin(dim : int) -> Tuple[Tensor, Tensor] Tensor.cummin(dim : str) -> Tuple[Tensor, Tensor] Tensor.cummin(dim : str, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.cummin(dim : int, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.cumprod(dim : int, dtype : Optional[int]) -> Tensor Tensor.cumprod(dim : str, dtype : Optional[int]) -> Tensor Tensor.cumprod(dim : str, dtype : Optional[int], out : Tensor) -> Tensor Tensor.cumprod(dim : int, dtype : Optional[int], out : Tensor) -> Tensor Tensor.cumprod_(dim : int, dtype : Optional[int]) -> Tensor Tensor.cumprod_(dim : str, dtype : Optional[int]) -> Tensor Tensor.cumsum(dim : int, dtype : Optional[int]) -> Tensor Tensor.cumsum(dim : str, dtype : Optional[int]) -> Tensor Tensor.cumsum(dim : str, dtype : Optional[int], out : Tensor) -> Tensor Tensor.cumsum(dim : int, dtype : Optional[int], out : Tensor) -> Tensor Tensor.cumsum_(dim : int, dtype : Optional[int]) -> Tensor Tensor.cumsum_(dim : str, dtype : Optional[int]) -> Tensor Tensor.data() -> Tensor Tensor.deg2rad() -> Tensor Tensor.deg2rad(out : Tensor) -> Tensor Tensor.deg2rad_() -> Tensor Tensor.dense_dim() -> int Tensor.dequantize() -> Tensor Tensor.dequantize(out : Tensor) -> 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.diag_embed(offset : int=0, dim1 : int=-2, dim2 : int=-1, out : Tensor) -> Tensor Tensor.diagflat(offset : int=0) -> Tensor Tensor.diagonal(offset : int=0, dim1 : int=0, dim2 : int=1) -> Tensor Tensor.diagonal(outdim : str, dim1 : str, dim2 : str, offset : int=0) -> Tensor Tensor.diagonal_scatter(src : Tensor, offset : int=0, dim1 : int=0, dim2 : int=1) -> Tensor Tensor.diagonal_scatter(src : Tensor, offset : int=0, dim1 : int=0, dim2 : int=1, out : Tensor) -> Tensor Tensor.diff(n : int=1, dim : int=-1, prepend : Optional[Tensor], append : Optional[Tensor]) -> Tensor Tensor.diff(n : int=1, dim : int=-1, prepend : Optional[Tensor], append : Optional[Tensor], out : Tensor) -> Tensor Tensor.digamma() -> Tensor Tensor.digamma(out : Tensor) -> Tensor Tensor.digamma_() -> Tensor Tensor.dim() -> int Tensor.dist(other : Tensor, p : number=2) -> Tensor Tensor.dist(other : Tensor, p : number=2, out : Tensor) -> Tensor Tensor.div(other : Tensor) -> Tensor Tensor.div(other : number) -> Tensor Tensor.div(other : Tensor, rounding_mode : Optional[str]) -> Tensor Tensor.div(other : number, rounding_mode : Optional[str]) -> Tensor Tensor.div(other : Tensor, out : Tensor) -> Tensor Tensor.div(other : Tensor, rounding_mode : Optional[str], out : Tensor) -> Tensor Tensor.div(other : number, out : Tensor) -> Tensor Tensor.div(other : number, rounding_mode : Optional[str], out : Tensor) -> Tensor Tensor.div_(other : Tensor) -> Tensor Tensor.div_(other : Tensor, rounding_mode : Optional[str]) -> Tensor Tensor.div_(other : number) -> Tensor Tensor.div_(other : number, rounding_mode : Optional[str]) -> Tensor Tensor.divide(other : Tensor) -> Tensor Tensor.divide(other : number) -> Tensor Tensor.divide(other : Tensor, rounding_mode : Optional[str]) -> Tensor Tensor.divide(other : number, rounding_mode : Optional[str]) -> Tensor Tensor.divide(other : Tensor, out : Tensor) -> Tensor Tensor.divide(other : Tensor, rounding_mode : Optional[str], out : Tensor) -> Tensor Tensor.divide_(other : Tensor) -> Tensor Tensor.divide_(other : Tensor, rounding_mode : Optional[str]) -> Tensor Tensor.divide_(other : number, rounding_mode : Optional[str]) -> Tensor Tensor.divide_(other : number) -> Tensor Tensor.dot(tensor : Tensor) -> Tensor Tensor.dot(tensor : Tensor, out : Tensor) -> Tensor Tensor.dsplit(sections : int) -> List[Tensor] Tensor.dsplit(indices : List[int]) -> List[Tensor] Tensor.element_size() -> int Tensor.eq(other : Tensor) -> Tensor Tensor.eq(other : number) -> Tensor Tensor.eq(other : number, out : Tensor) -> Tensor Tensor.eq(other : Tensor, out : Tensor) -> Tensor Tensor.eq_(other : number) -> Tensor Tensor.eq_(other : Tensor) -> Tensor Tensor.equal(other : Tensor) -> bool Tensor.erf() -> Tensor Tensor.erf(out : Tensor) -> Tensor Tensor.erf_() -> Tensor Tensor.erfc() -> Tensor Tensor.erfc(out : Tensor) -> Tensor Tensor.erfc_() -> Tensor Tensor.erfinv() -> Tensor Tensor.erfinv(out : Tensor) -> Tensor Tensor.erfinv_() -> Tensor Tensor.exp() -> Tensor Tensor.exp(out : Tensor) -> Tensor Tensor.exp2() -> Tensor Tensor.exp2(out : Tensor) -> Tensor Tensor.exp2_() -> Tensor Tensor.exp_() -> Tensor Tensor.expand(size : List[int], implicit : bool=False) -> Tensor Tensor.expand_as(other : Tensor) -> Tensor Tensor.expm1() -> Tensor Tensor.expm1(out : Tensor) -> Tensor Tensor.expm1_() -> Tensor Tensor.exponential_(lambd : float=1.0, generator : Optional[Generator]) -> Tensor Tensor.fill_(value : number) -> Tensor Tensor.fill_(value : Tensor) -> Tensor Tensor.fill_diagonal_(fill_value : number, wrap : bool=False) -> Tensor Tensor.fix() -> Tensor Tensor.fix(out : Tensor) -> Tensor Tensor.fix_() -> Tensor Tensor.flatten(start_dim : int=0, end_dim : int=-1) -> Tensor Tensor.flatten(dims : List[str], out_dim : str) -> Tensor Tensor.flatten(start_dim : int, end_dim : int, out_dim : str) -> Tensor Tensor.flatten(start_dim : str, end_dim : str, out_dim : str) -> Tensor Tensor.flip(dims : List[int]) -> Tensor Tensor.flip(dims : List[int], out : Tensor) -> Tensor Tensor.fliplr() -> Tensor Tensor.flipud() -> Tensor Tensor.float_power(exponent : Tensor) -> Tensor Tensor.float_power(exponent : number) -> Tensor Tensor.float_power(exponent : Tensor, out : Tensor) -> Tensor Tensor.float_power(exponent : number, out : Tensor) -> Tensor Tensor.float_power_(exponent : Tensor) -> Tensor Tensor.float_power_(exponent : number) -> Tensor Tensor.floor() -> Tensor Tensor.floor(out : Tensor) -> Tensor Tensor.floor_() -> Tensor Tensor.floor_divide(other : Tensor) -> Tensor Tensor.floor_divide(other : number) -> Tensor Tensor.floor_divide(other : Tensor, out : Tensor) -> Tensor Tensor.floor_divide(other : number, out : Tensor) -> Tensor Tensor.floor_divide_(other : number) -> Tensor Tensor.floor_divide_(other : Tensor) -> Tensor Tensor.fmax(other : Tensor) -> Tensor Tensor.fmax(other : Tensor, out : Tensor) -> Tensor Tensor.fmin(other : Tensor) -> Tensor Tensor.fmin(other : Tensor, out : Tensor) -> Tensor Tensor.fmod(other : Tensor) -> Tensor Tensor.fmod(other : number) -> 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.frac() -> Tensor Tensor.frac(out : Tensor) -> Tensor Tensor.frac_() -> Tensor Tensor.frexp() -> Tuple[Tensor, Tensor] Tensor.frexp(mantissa : Tensor, exponent : Tensor) -> Tuple[Tensor, Tensor] Tensor.gather(dim : int, index : Tensor, sparse_grad : bool=False) -> Tensor Tensor.gather(dim : int, index : Tensor, sparse_grad : bool=False, out : Tensor) -> Tensor Tensor.gather(dim : str, index : Tensor, sparse_grad : bool=False) -> Tensor Tensor.gather(dim : str, index : Tensor, sparse_grad : bool=False, out : Tensor) -> Tensor Tensor.gcd(other : Tensor) -> Tensor Tensor.gcd(other : Tensor, out : Tensor) -> Tensor Tensor.gcd_(other : Tensor) -> Tensor Tensor.ge(other : Tensor) -> Tensor Tensor.ge(other : number) -> Tensor Tensor.ge(other : number, out : Tensor) -> Tensor Tensor.ge(other : Tensor, out : Tensor) -> Tensor Tensor.ge_(other : number) -> Tensor Tensor.ge_(other : Tensor) -> Tensor Tensor.geometric_(p : float, generator : Optional[Generator]) -> Tensor Tensor.geqrf() -> Tuple[Tensor, Tensor] Tensor.geqrf(a : Tensor, tau : Tensor) -> Tuple[Tensor, Tensor] Tensor.ger(vec2 : Tensor) -> Tensor Tensor.ger(vec2 : Tensor, out : Tensor) -> Tensor Tensor.get_device() -> int Tensor.greater(other : Tensor) -> Tensor Tensor.greater(other : number) -> Tensor Tensor.greater(other : number, out : Tensor) -> Tensor Tensor.greater(other : Tensor, out : Tensor) -> Tensor Tensor.greater_(other : number) -> Tensor Tensor.greater_(other : Tensor) -> Tensor Tensor.greater_equal(other : Tensor) -> Tensor Tensor.greater_equal(other : number) -> Tensor Tensor.greater_equal(other : number, out : Tensor) -> Tensor Tensor.greater_equal(other : Tensor, out : Tensor) -> Tensor Tensor.greater_equal_(other : number) -> Tensor Tensor.greater_equal_(other : Tensor) -> Tensor Tensor.gt(other : Tensor) -> Tensor Tensor.gt(other : number) -> Tensor Tensor.gt(other : number, out : Tensor) -> Tensor Tensor.gt(other : Tensor, out : Tensor) -> Tensor Tensor.gt_(other : number) -> Tensor Tensor.gt_(other : Tensor) -> Tensor Tensor.hardshrink(lambd : number=0.5) -> Tensor Tensor.hardshrink(lambd : number=0.5, out : Tensor) -> Tensor Tensor.heaviside(values : Tensor) -> Tensor Tensor.heaviside(values : Tensor, out : Tensor) -> Tensor Tensor.heaviside_(values : Tensor) -> Tensor Tensor.histc(bins : int=100, min : number=0, max : number=0) -> Tensor Tensor.histc(bins : int=100, min : number=0, max : number=0, out : Tensor) -> Tensor Tensor.histogram(bins : Tensor, weight : Optional[Tensor], density : bool=False) -> Tuple[Tensor, Tensor] Tensor.histogram(bins : Tensor, weight : Optional[Tensor], density : bool=False, hist : Tensor, bin_edges : Tensor) -> Tuple[Tensor, Tensor] Tensor.histogram(bins : int=100, range : Optional[List[float]], weight : Optional[Tensor], density : bool=False) -> Tuple[Tensor, Tensor] Tensor.histogram(bins : int=100, range : Optional[List[float]], weight : Optional[Tensor], density : bool=False, hist : Tensor, bin_edges : Tensor) -> Tuple[Tensor, Tensor] Tensor.hsplit(sections : int) -> List[Tensor] Tensor.hsplit(indices : List[int]) -> List[Tensor] Tensor.hypot(other : Tensor) -> Tensor Tensor.hypot(other : Tensor, out : Tensor) -> Tensor Tensor.hypot_(other : Tensor) -> Tensor Tensor.i0() -> Tensor Tensor.i0(out : Tensor) -> Tensor Tensor.i0_() -> Tensor Tensor.igamma(other : Tensor) -> Tensor Tensor.igamma(other : Tensor, out : Tensor) -> Tensor Tensor.igamma_(other : Tensor) -> Tensor Tensor.igammac(other : Tensor) -> Tensor Tensor.igammac(other : Tensor, out : Tensor) -> Tensor Tensor.igammac_(other : Tensor) -> Tensor Tensor.imag() -> Tensor Tensor.index_add(dim : int, index : Tensor, source : Tensor, alpha : number=1) -> Tensor Tensor.index_add(dim : int, index : Tensor, source : Tensor, alpha : number=1, out : Tensor) -> Tensor Tensor.index_add(dim : str, index : Tensor, source : Tensor, alpha : number=1) -> Tensor Tensor.index_add_(dim : int, index : Tensor, source : Tensor, alpha : number=1) -> Tensor Tensor.index_copy(dim : int, index : Tensor, source : Tensor) -> Tensor Tensor.index_copy(dim : str, index : Tensor, source : Tensor) -> Tensor Tensor.index_copy(dim : int, index : Tensor, source : Tensor, out : Tensor) -> Tensor Tensor.index_copy_(dim : int, index : Tensor, source : Tensor) -> Tensor Tensor.index_copy_(dim : str, 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 : str, index : Tensor, value : number) -> Tensor Tensor.index_fill(dim : str, index : Tensor, value : Tensor) -> Tensor Tensor.index_fill(dim : int, index : Tensor, value : number, out : Tensor) -> Tensor Tensor.index_fill(dim : int, index : Tensor, value : Tensor, out : 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 : str, index : Tensor, value : number) -> Tensor Tensor.index_fill_(dim : str, index : Tensor, value : Tensor) -> Tensor Tensor.index_put(indices : List[Optional[Tensor]], values : Tensor, accumulate : bool=False) -> Tensor Tensor.index_put(indices : List[Optional[Tensor]], values : Tensor, accumulate : bool=False, out : Tensor) -> 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_reduce(dim : int, index : Tensor, source : Tensor, reduce : str, include_self : bool=True) -> Tensor Tensor.index_reduce(dim : int, index : Tensor, source : Tensor, reduce : str, include_self : bool=True, out : Tensor) -> Tensor Tensor.index_reduce_(dim : int, index : Tensor, source : Tensor, reduce : str, include_self : bool=True) -> Tensor Tensor.index_select(dim : int, index : Tensor) -> Tensor Tensor.index_select(dim : int, index : Tensor, out : Tensor) -> Tensor Tensor.index_select(dim : str, index : Tensor) -> Tensor Tensor.index_select(dim : str, index : Tensor, out : Tensor) -> Tensor Tensor.indices() -> Tensor Tensor.inner(other : Tensor) -> Tensor Tensor.inner(other : Tensor, out : Tensor) -> Tensor Tensor.int_repr(out : Tensor) -> Tensor Tensor.int_repr() -> Tensor Tensor.inverse() -> Tensor Tensor.inverse(out : Tensor) -> Tensor Tensor.is_coalesced() -> bool Tensor.is_complex() -> bool Tensor.is_conj() -> bool Tensor.is_contiguous() -> bool Tensor.is_contiguous(memory_format : int) -> bool Tensor.is_distributed() -> bool Tensor.is_floating_point() -> bool Tensor.is_inference() -> bool Tensor.is_leaf() -> bool Tensor.is_neg() -> bool Tensor.is_nonzero() -> bool Tensor.is_pinned(device : Optional[Device]) -> 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.isfinite() -> Tensor Tensor.isinf() -> Tensor Tensor.isinf(out : Tensor) -> Tensor Tensor.isnan() -> Tensor Tensor.isnan(out : Tensor) -> Tensor Tensor.isneginf() -> Tensor Tensor.isneginf(out : Tensor) -> Tensor Tensor.isposinf() -> Tensor Tensor.isposinf(out : Tensor) -> Tensor Tensor.isreal() -> Tensor Tensor.istft(n_fft : int, hop_length : Optional[int], win_length : Optional[int], window : Optional[Tensor], center : bool=True, normalized : bool=False, onesided : Optional[bool], length : Optional[int], return_complex : bool=False) -> Tensor Tensor.item() -> number Tensor.kron(other : Tensor) -> Tensor Tensor.kron(other : Tensor, out : Tensor) -> Tensor Tensor.kthvalue(k : int, dim : int=-1, keepdim : bool=False) -> Tuple[Tensor, Tensor] Tensor.kthvalue(k : int, dim : str, keepdim : bool=False) -> Tuple[Tensor, Tensor] Tensor.kthvalue(k : int, dim : str, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.kthvalue(k : int, dim : int=-1, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.lcm(other : Tensor) -> Tensor Tensor.lcm(other : Tensor, out : Tensor) -> Tensor Tensor.lcm_(other : Tensor) -> Tensor Tensor.ldexp(other : Tensor) -> Tensor Tensor.ldexp(other : Tensor, out : Tensor) -> Tensor Tensor.ldexp_(other : Tensor) -> Tensor Tensor.le(other : Tensor) -> Tensor Tensor.le(other : number) -> Tensor Tensor.le(other : number, out : Tensor) -> Tensor Tensor.le(other : Tensor, out : Tensor) -> Tensor Tensor.le_(other : number) -> Tensor Tensor.le_(other : Tensor) -> Tensor Tensor.lerp(end : Tensor, weight : number) -> Tensor Tensor.lerp(end : Tensor, weight : Tensor) -> Tensor Tensor.lerp(end : Tensor, weight : number, out : Tensor) -> Tensor Tensor.lerp(end : Tensor, weight : Tensor, out : Tensor) -> Tensor Tensor.lerp_(end : Tensor, weight : number) -> Tensor Tensor.lerp_(end : Tensor, weight : Tensor) -> Tensor Tensor.less(other : Tensor) -> Tensor Tensor.less(other : number) -> Tensor Tensor.less(other : number, out : Tensor) -> Tensor Tensor.less(other : Tensor, out : Tensor) -> Tensor Tensor.less_(other : number) -> Tensor Tensor.less_(other : Tensor) -> Tensor Tensor.less_equal(other : Tensor) -> Tensor Tensor.less_equal(other : number) -> Tensor Tensor.less_equal(other : number, out : Tensor) -> Tensor Tensor.less_equal(other : Tensor, out : Tensor) -> Tensor Tensor.less_equal_(other : number) -> Tensor Tensor.less_equal_(other : Tensor) -> Tensor Tensor.lgamma() -> Tensor Tensor.lgamma(out : Tensor) -> Tensor Tensor.lgamma_() -> Tensor Tensor.log() -> Tensor Tensor.log(out : Tensor) -> Tensor Tensor.log10() -> Tensor Tensor.log10(out : Tensor) -> 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.log_softmax(dim : str, dtype : Optional[int]) -> Tensor Tensor.log_softmax(dim : int, dtype : Optional[int], out : Tensor) -> Tensor Tensor.logaddexp(other : Tensor) -> Tensor Tensor.logaddexp(other : Tensor, out : Tensor) -> Tensor Tensor.logaddexp2(other : Tensor) -> Tensor Tensor.logaddexp2(other : Tensor, out : Tensor) -> Tensor Tensor.logcumsumexp(dim : int) -> Tensor Tensor.logcumsumexp(dim : str) -> Tensor Tensor.logcumsumexp(dim : str, out : Tensor) -> Tensor Tensor.logcumsumexp(dim : int, out : Tensor) -> Tensor Tensor.logdet() -> Tensor Tensor.logical_and(other : Tensor) -> Tensor Tensor.logical_and(other : Tensor, out : Tensor) -> Tensor Tensor.logical_and_(other : Tensor) -> Tensor Tensor.logical_not() -> Tensor Tensor.logical_not(out : Tensor) -> Tensor Tensor.logical_not_() -> Tensor Tensor.logical_or(other : Tensor) -> Tensor Tensor.logical_or(other : Tensor, out : Tensor) -> Tensor Tensor.logical_or_(other : Tensor) -> Tensor Tensor.logical_xor(other : Tensor) -> Tensor Tensor.logical_xor(other : Tensor, out : Tensor) -> Tensor Tensor.logical_xor_(other : Tensor) -> Tensor Tensor.logit(eps : Optional[float]) -> Tensor Tensor.logit(eps : Optional[float], out : Tensor) -> Tensor Tensor.logit_(eps : Optional[float]) -> Tensor Tensor.logsumexp(dim : List[int], keepdim : bool=False) -> Tensor Tensor.logsumexp(dim : List[str], keepdim : bool=False) -> Tensor Tensor.logsumexp(dim : List[str], keepdim : bool=False, out : Tensor) -> Tensor Tensor.logsumexp(dim : List[int], keepdim : bool=False, out : Tensor) -> Tensor Tensor.lt(other : Tensor) -> Tensor Tensor.lt(other : number) -> Tensor Tensor.lt(other : number, out : Tensor) -> Tensor Tensor.lt(other : Tensor, out : Tensor) -> Tensor Tensor.lt_(other : number) -> Tensor Tensor.lt_(other : Tensor) -> Tensor Tensor.lu_solve(LU_data : Tensor, LU_pivots : Tensor) -> Tensor Tensor.lu_solve(LU_data : Tensor, LU_pivots : Tensor, out : Tensor) -> Tensor Tensor.mH() -> Tensor Tensor.mH() -> Tensor Tensor.mT() -> Tensor Tensor.mT() -> Tensor Tensor.masked_fill(mask : Tensor, value : number) -> Tensor Tensor.masked_fill(mask : Tensor, value : Tensor) -> Tensor Tensor.masked_fill(mask : Tensor, value : number, out : Tensor) -> Tensor Tensor.masked_fill(mask : Tensor, value : Tensor, out : Tensor) -> Tensor Tensor.masked_fill_(mask : Tensor, value : number) -> Tensor Tensor.masked_fill_(mask : Tensor, value : Tensor) -> Tensor Tensor.masked_scatter(mask : Tensor, source : Tensor) -> Tensor Tensor.masked_scatter(mask : Tensor, source : Tensor, out : Tensor) -> Tensor Tensor.masked_scatter_(mask : Tensor, source : Tensor) -> Tensor Tensor.masked_select(mask : Tensor) -> Tensor Tensor.masked_select(mask : Tensor, out : Tensor) -> Tensor Tensor.matmul(other : Tensor) -> Tensor Tensor.matmul(other : Tensor, out : Tensor) -> Tensor Tensor.matrix_exp() -> Tensor Tensor.matrix_power(n : int) -> Tensor Tensor.matrix_power(n : int, out : Tensor) -> Tensor Tensor.max(other : Tensor) -> Tensor Tensor.max() -> Tensor Tensor.max(dim : int, keepdim : bool=False) -> Tuple[Tensor, Tensor] Tensor.max(dim : int, keepdim : bool=False, max : Tensor, max_values : Tensor) -> Tuple[Tensor, Tensor] Tensor.max(dim : str, keepdim : bool=False) -> Tuple[Tensor, Tensor] Tensor.max(dim : str, keepdim : bool=False, max : Tensor, max_values : Tensor) -> Tuple[Tensor, Tensor] Tensor.max(out : Tensor) -> Tensor Tensor.max(other : Tensor, out : Tensor) -> Tensor Tensor.maximum(other : Tensor) -> Tensor Tensor.maximum(other : Tensor, out : Tensor) -> Tensor Tensor.mean(dtype : Optional[int]) -> Tensor Tensor.mean(dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int]) -> Tensor Tensor.mean(dim : List[str], keepdim : bool=False, dtype : Optional[int]) -> Tensor Tensor.mean(dim : List[str], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor Tensor.mean(dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor Tensor.mean(dtype : Optional[int], out : Tensor) -> Tensor Tensor.median() -> Tensor Tensor.median(dim : int, keepdim : bool=False) -> Tuple[Tensor, Tensor] Tensor.median(dim : int, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.median(dim : str, keepdim : bool=False) -> Tuple[Tensor, Tensor] Tensor.median(dim : str, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.median(out : Tensor) -> Tensor Tensor.min(other : Tensor) -> Tensor Tensor.min() -> Tensor Tensor.min(dim : int, keepdim : bool=False) -> Tuple[Tensor, Tensor] Tensor.min(dim : int, keepdim : bool=False, min : Tensor, min_indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.min(dim : str, keepdim : bool=False) -> Tuple[Tensor, Tensor] Tensor.min(dim : str, keepdim : bool=False, min : Tensor, min_indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.min(out : Tensor) -> Tensor Tensor.min(other : Tensor, out : Tensor) -> Tensor Tensor.minimum(other : Tensor) -> Tensor Tensor.minimum(other : Tensor, out : Tensor) -> Tensor Tensor.mm(mat2 : Tensor) -> Tensor Tensor.mm(mat2 : Tensor, out : Tensor) -> Tensor Tensor.mode(dim : int=-1, keepdim : bool=False) -> Tuple[Tensor, Tensor] Tensor.mode(dim : str, keepdim : bool=False) -> Tuple[Tensor, Tensor] Tensor.mode(dim : str, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.mode(dim : int=-1, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.moveaxis(source : List[int], destination : List[int]) -> Tensor Tensor.moveaxis(source : int, destination : int) -> Tensor Tensor.movedim(source : int, destination : int) -> Tensor Tensor.movedim(source : List[int], destination : List[int]) -> Tensor Tensor.msort() -> Tensor Tensor.msort(out : Tensor) -> Tensor Tensor.mul(other : Tensor) -> Tensor Tensor.mul(other : number) -> Tensor Tensor.mul(other : Tensor, out : Tensor) -> Tensor Tensor.mul(other : number, 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.multiply(other : Tensor) -> Tensor Tensor.multiply(other : number) -> Tensor Tensor.multiply(other : Tensor, out : Tensor) -> Tensor Tensor.multiply_(other : Tensor) -> Tensor Tensor.multiply_(other : number) -> Tensor Tensor.mv(vec : Tensor) -> Tensor Tensor.mv(vec : Tensor, out : Tensor) -> Tensor Tensor.mvlgamma(p : int) -> Tensor Tensor.mvlgamma(p : int, out : Tensor) -> Tensor Tensor.mvlgamma_(p : int) -> Tensor Tensor.nan_to_num(nan : Optional[float], posinf : Optional[float], neginf : Optional[float]) -> Tensor Tensor.nan_to_num(nan : Optional[float], posinf : Optional[float], neginf : Optional[float], out : Tensor) -> Tensor Tensor.nan_to_num_(nan : Optional[float], posinf : Optional[float], neginf : Optional[float]) -> Tensor Tensor.nanmean(dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int]) -> Tensor Tensor.nanmean(dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor Tensor.nanmedian() -> Tensor Tensor.nanmedian(dim : int, keepdim : bool=False) -> Tuple[Tensor, Tensor] Tensor.nanmedian(dim : int, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.nanmedian(dim : str, keepdim : bool=False) -> Tuple[Tensor, Tensor] Tensor.nanmedian(dim : str, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.nanmedian(out : Tensor) -> Tensor Tensor.nanquantile(q : Tensor, dim : Optional[int], keepdim : bool=False, interpolation : str=linear) -> Tensor Tensor.nanquantile(q : float, dim : Optional[int], keepdim : bool=False, interpolation : str=linear) -> Tensor Tensor.nanquantile(q : Tensor, dim : Optional[int], keepdim : bool=False, interpolation : str=linear, out : Tensor) -> Tensor Tensor.nanquantile(q : float, dim : Optional[int], keepdim : bool=False, interpolation : str=linear, out : Tensor) -> Tensor Tensor.nansum(dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int]) -> Tensor Tensor.nansum(dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor Tensor.narrow(dim : int, start : int, length : int) -> Tensor Tensor.narrow(dim : int, start : Tensor, length : int) -> Tensor Tensor.narrow_copy(dim : int, start : int, length : int) -> Tensor Tensor.narrow_copy(dim : int, start : int, length : int, out : Tensor) -> Tensor Tensor.ne(other : Tensor) -> Tensor Tensor.ne(other : number) -> Tensor Tensor.ne(other : number, out : Tensor) -> Tensor Tensor.ne(other : Tensor, out : Tensor) -> Tensor Tensor.ne_(other : number) -> Tensor Tensor.ne_(other : Tensor) -> Tensor Tensor.neg() -> Tensor Tensor.neg(out : Tensor) -> Tensor Tensor.neg_() -> Tensor Tensor.negative() -> Tensor Tensor.negative(out : Tensor) -> Tensor Tensor.negative_() -> Tensor Tensor.new_empty(size : List[int], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor Tensor.new_empty(size : List[int], out : Tensor) -> Tensor Tensor.new_empty_strided(size : List[int], stride : List[int], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor Tensor.new_empty_strided(size : List[int], stride : List[int], out : Tensor) -> 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_full(size : List[int], fill_value : number, out : Tensor) -> Tensor Tensor.new_ones(size : List[int], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor Tensor.new_ones(size : List[int], out : Tensor) -> Tensor Tensor.new_zeros(size : List[int], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor Tensor.new_zeros(size : List[int], out : Tensor) -> Tensor Tensor.nextafter(other : Tensor) -> Tensor Tensor.nextafter(other : Tensor, out : Tensor) -> Tensor Tensor.nextafter_(other : Tensor) -> Tensor Tensor.nonzero() -> Tensor Tensor.nonzero(out : Tensor) -> Tensor Tensor.nonzero_static(size : int, fill_value : int=-1) -> Tensor Tensor.nonzero_static(size : int, fill_value : int=-1, out : Tensor) -> Tensor Tensor.norm(p : number=2) -> Tensor Tensor.norm(p : Optional[number], dim : List[int], keepdim : bool=False) -> Tensor Tensor.norm(p : Optional[number], dim : List[str], 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, dtype : int, out : Tensor) -> Tensor Tensor.norm(p : Optional[number], dim : List[int], keepdim : bool=False, out : Tensor) -> Tensor Tensor.norm(p : Optional[number], dtype : int) -> Tensor Tensor.norm(p : Optional[number], dtype : int, out : Tensor) -> Tensor Tensor.norm(p : number=2, out : Tensor) -> Tensor Tensor.norm(p : Optional[number], dim : List[str], keepdim : bool, dtype : int) -> Tensor Tensor.norm(p : Optional[number], dim : List[str], keepdim : bool, dtype : int, out : Tensor) -> Tensor Tensor.norm(p : Optional[number], dim : List[str], keepdim : bool=False, out : Tensor) -> Tensor Tensor.normal_(mean : float=0.0, std : float=1.0, generator : Optional[Generator]) -> Tensor Tensor.not_equal(other : Tensor) -> Tensor Tensor.not_equal(other : number) -> Tensor Tensor.not_equal(other : number, out : Tensor) -> Tensor Tensor.not_equal(other : Tensor, out : Tensor) -> Tensor Tensor.not_equal_(other : number) -> Tensor Tensor.not_equal_(other : Tensor) -> 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.outer(vec2 : Tensor) -> Tensor Tensor.outer(vec2 : Tensor, out : Tensor) -> Tensor Tensor.output_nr() -> int Tensor.permute(dims : List[int]) -> Tensor Tensor.pin_memory(device : Optional[Device]) -> Tensor Tensor.pinverse(rcond : float=1e-15) -> Tensor Tensor.polygamma_(n : int) -> Tensor Tensor.positive() -> Tensor Tensor.pow(exponent : Tensor) -> Tensor Tensor.pow(exponent : number) -> Tensor Tensor.pow(exponent : number, out : Tensor) -> Tensor Tensor.pow(exponent : Tensor, out : Tensor) -> Tensor Tensor.pow_(exponent : number) -> Tensor Tensor.pow_(exponent : Tensor) -> Tensor Tensor.prelu(weight : Tensor) -> Tensor Tensor.prod(dtype : Optional[int]) -> Tensor Tensor.prod(dim : int, keepdim : bool=False, dtype : Optional[int]) -> Tensor Tensor.prod(dim : str, keepdim : bool=False, dtype : Optional[int]) -> Tensor Tensor.prod(dim : str, keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor Tensor.prod(dim : int, keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor Tensor.prod(dtype : Optional[int], out : Tensor) -> Tensor Tensor.put(index : Tensor, source : Tensor, accumulate : bool=False) -> Tensor Tensor.put(index : Tensor, source : Tensor, accumulate : bool=False, out : Tensor) -> Tensor Tensor.put_(index : Tensor, source : Tensor, accumulate : bool=False) -> Tensor Tensor.q_per_channel_axis() -> int Tensor.q_per_channel_scales(out : Tensor) -> Tensor Tensor.q_per_channel_scales() -> Tensor Tensor.q_per_channel_zero_points(out : Tensor) -> 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.qr(some : bool=True, Q : Tensor, R : Tensor) -> Tuple[Tensor, Tensor] Tensor.qscheme() -> QScheme Tensor.quantile(q : Tensor, dim : Optional[int], keepdim : bool=False, interpolation : str=linear) -> Tensor Tensor.quantile(q : float, dim : Optional[int], keepdim : bool=False, interpolation : str=linear) -> Tensor Tensor.quantile(q : Tensor, dim : Optional[int], keepdim : bool=False, interpolation : str=linear, out : Tensor) -> Tensor Tensor.quantile(q : float, dim : Optional[int], keepdim : bool=False, interpolation : str=linear, out : Tensor) -> Tensor Tensor.rad2deg() -> Tensor Tensor.rad2deg(out : Tensor) -> Tensor Tensor.rad2deg_() -> Tensor Tensor.random_(from : int, to : Optional[int], generator : Optional[Generator]) -> Tensor Tensor.random_(to : int, generator : Optional[Generator]) -> Tensor Tensor.random_(generator : Optional[Generator]) -> Tensor Tensor.ravel() -> Tensor Tensor.real() -> Tensor Tensor.reciprocal() -> Tensor Tensor.reciprocal(out : Tensor) -> Tensor Tensor.reciprocal_() -> Tensor Tensor.record_stream(s : Stream) -> Tuple[] Tensor.refine_names(names : List[str]) -> Tensor Tensor.relu() -> Tensor Tensor.relu(out : Tensor) -> 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.rename(names : Optional[List[str]]) -> Tensor Tensor.rename_(names : Optional[List[str]]) -> Tensor Tensor.renorm(p : number, dim : int, maxnorm : number) -> Tensor Tensor.renorm(p : number, dim : int, maxnorm : number, out : Tensor) -> Tensor Tensor.renorm_(p : number, dim : int, maxnorm : number) -> Tensor Tensor.repeat(repeats : List[int]) -> Tensor Tensor.repeat(repeats : List[int], out : Tensor) -> Tensor Tensor.repeat_interleave(repeats : Tensor, dim : Optional[int], output_size : Optional[int]) -> Tensor Tensor.repeat_interleave(repeats : int, dim : Optional[int], output_size : Optional[int]) -> 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(size : List[int], memory_format : Optional[int], out : Tensor) -> Tensor Tensor.resize_(size : List[int], memory_format : Optional[int]) -> Tensor Tensor.resize_as(the_template : Tensor, memory_format : Optional[int]) -> Tensor Tensor.resize_as(the_template : Tensor, memory_format : Optional[int], out : Tensor) -> Tensor Tensor.resize_as_(the_template : Tensor, memory_format : Optional[int]) -> Tensor Tensor.resize_as_sparse_(the_template : Tensor) -> Tensor Tensor.resolve_conj() -> Tensor Tensor.resolve_neg() -> Tensor Tensor.retain_grad() -> Tuple[] Tensor.retains_grad() -> bool Tensor.roll(shifts : List[int], dims : List[int]=[]) -> Tensor Tensor.roll(shifts : List[int], dims : List[int]=[], out : Tensor) -> Tensor Tensor.rot90(k : int=1, dims : List[int]=[0, 1]) -> Tensor Tensor.rot90(k : int=1, dims : List[int]=[0, 1], out : Tensor) -> Tensor Tensor.round() -> Tensor Tensor.round(decimals : int) -> Tensor Tensor.round(out : Tensor) -> Tensor Tensor.round(decimals : int, out : Tensor) -> Tensor Tensor.round_() -> Tensor Tensor.round_(decimals : int) -> Tensor Tensor.row_indices() -> Tensor Tensor.rsqrt() -> Tensor Tensor.rsqrt(out : Tensor) -> Tensor Tensor.rsqrt_() -> 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, src : Tensor, reduce : str) -> Tensor Tensor.scatter(dim : int, index : Tensor, value : number, reduce : str) -> Tensor Tensor.scatter(dim : int, index : Tensor, src : Tensor, out : Tensor) -> Tensor Tensor.scatter(dim : int, index : Tensor, value : number, out : Tensor) -> Tensor Tensor.scatter(dim : int, index : Tensor, src : Tensor, reduce : str, out : Tensor) -> Tensor Tensor.scatter(dim : int, index : Tensor, value : number, reduce : str, out : Tensor) -> Tensor Tensor.scatter(dim : str, index : Tensor, src : Tensor) -> Tensor Tensor.scatter(dim : str, 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_(dim : int, index : Tensor, src : Tensor, reduce : str) -> Tensor Tensor.scatter_(dim : int, index : Tensor, value : number, reduce : str) -> Tensor Tensor.scatter_add(dim : int, index : Tensor, src : Tensor) -> Tensor Tensor.scatter_add(dim : int, index : Tensor, src : Tensor, out : Tensor) -> Tensor Tensor.scatter_add(dim : str, index : Tensor, src : Tensor) -> Tensor Tensor.scatter_add_(dim : int, index : Tensor, src : Tensor) -> Tensor Tensor.scatter_reduce(dim : int, index : Tensor, src : Tensor, reduce : str, include_self : bool=True) -> Tensor Tensor.scatter_reduce(dim : int, index : Tensor, src : Tensor, reduce : str, include_self : bool=True, out : Tensor) -> Tensor Tensor.scatter_reduce_(dim : int, index : Tensor, src : Tensor, reduce : str, include_self : bool=True) -> Tensor Tensor.select(dim : str, index : int) -> Tensor Tensor.select(dim : int, index : int) -> Tensor Tensor.select_scatter(src : Tensor, dim : int, index : int) -> Tensor Tensor.select_scatter(src : Tensor, dim : int, index : int, out : Tensor) -> Tensor Tensor.set_(source : Storage, storage_offset : int, size : List[int], stride : List[int]=[]) -> Tensor Tensor.set_(source : Tensor) -> Tensor Tensor.set_() -> Tensor Tensor.set_(source : Storage) -> Tensor Tensor.set_(source : Tensor, storage_offset : int, size : List[int], stride : List[int]=[]) -> Tensor Tensor.sgn() -> Tensor Tensor.sgn(out : Tensor) -> Tensor Tensor.sgn_() -> Tensor Tensor.sigmoid() -> Tensor Tensor.sigmoid(out : Tensor) -> Tensor Tensor.sigmoid_() -> Tensor Tensor.sign() -> Tensor Tensor.sign(out : Tensor) -> Tensor Tensor.sign_() -> Tensor Tensor.signbit() -> Tensor Tensor.signbit(out : Tensor) -> Tensor Tensor.sin() -> Tensor Tensor.sin(out : Tensor) -> Tensor Tensor.sin_() -> Tensor Tensor.sinc() -> Tensor Tensor.sinc(out : Tensor) -> Tensor Tensor.sinc_() -> Tensor Tensor.sinh() -> Tensor Tensor.sinh(out : Tensor) -> Tensor Tensor.sinh_() -> Tensor Tensor.size(dim : int) -> int Tensor.size(dim : str) -> int Tensor.size() -> List[int] Tensor.slice_inverse(src : Tensor, dim : int=0, start : Optional[int], end : Optional[int], step : int=1) -> Tensor Tensor.slice_scatter(src : Tensor, dim : int=0, start : Optional[int], end : Optional[int], step : int=1) -> Tensor Tensor.slice_scatter(src : Tensor, dim : int=0, start : Optional[int], end : Optional[int], step : int=1, out : Tensor) -> Tensor Tensor.slogdet() -> Tuple[Tensor, Tensor] Tensor.slogdet(sign : Tensor, logabsdet : Tensor) -> Tuple[Tensor, Tensor] Tensor.smm(mat2 : Tensor) -> Tensor Tensor.softmax(dim : int, dtype : Optional[int]) -> Tensor Tensor.softmax(dim : str, dtype : Optional[int]) -> Tensor Tensor.softmax(dim : int, dtype : Optional[int], out : Tensor) -> Tensor Tensor.sort(dim : int=-1, descending : bool=False) -> Tuple[Tensor, Tensor] Tensor.sort(stable : Optional[bool], dim : int=-1, descending : bool=False) -> Tuple[Tensor, Tensor] Tensor.sort(stable : Optional[bool], dim : int=-1, descending : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.sort(dim : int=-1, descending : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.sort(dim : str, descending : bool=False) -> Tuple[Tensor, Tensor] Tensor.sort(dim : str, descending : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.sort(stable : Optional[bool], dim : str, descending : bool=False) -> Tuple[Tensor, Tensor] Tensor.sort(stable : Optional[bool], dim : str, descending : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.sparse_dim() -> int Tensor.sparse_mask(mask : Tensor, out : Tensor) -> Tensor 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_size : List[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() -> Tensor Tensor.sqrt(out : Tensor) -> Tensor Tensor.sqrt_() -> Tensor Tensor.square() -> Tensor Tensor.square(out : Tensor) -> Tensor Tensor.square_() -> Tensor Tensor.squeeze() -> Tensor Tensor.squeeze(dim : int) -> Tensor Tensor.squeeze(dim : List[int]) -> Tensor Tensor.squeeze(dim : str) -> Tensor Tensor.squeeze_() -> Tensor Tensor.squeeze_(dim : int) -> Tensor Tensor.squeeze_(dim : List[int]) -> Tensor Tensor.squeeze_(dim : str) -> 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 : Optional[List[int]], unbiased : bool=True, keepdim : bool=False) -> Tensor Tensor.std(dim : Optional[List[int]], correction : Optional[number], keepdim : bool=False) -> Tensor Tensor.std(dim : List[str], unbiased : bool=True, keepdim : bool=False) -> Tensor Tensor.std(dim : List[str], unbiased : bool=True, keepdim : bool=False, out : Tensor) -> Tensor Tensor.std(dim : Optional[List[int]], unbiased : bool=True, keepdim : bool=False, out : Tensor) -> Tensor Tensor.std(dim : Optional[List[int]], correction : Optional[number], keepdim : bool=False, out : Tensor) -> Tensor Tensor.std(dim : List[str], correction : Optional[number], keepdim : bool=False) -> Tensor Tensor.std(dim : List[str], correction : Optional[number], 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 : Optional[bool], return_complex : Optional[bool]) -> Tensor Tensor.stft(n_fft : int, hop_length : Optional[int], win_length : Optional[int], window : Optional[Tensor], center : bool=True, pad_mode : str=reflect, normalized : bool=False, onesided : Optional[bool], return_complex : Optional[bool]) -> Tensor Tensor.storage_offset() -> int Tensor.stride(dim : int) -> int Tensor.stride(dim : str) -> int Tensor.stride() -> List[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 : number, alpha : number=1, out : Tensor) -> Tensor Tensor.sub_(other : Tensor, alpha : number=1) -> Tensor Tensor.sub_(other : number, alpha : number=1) -> Tensor Tensor.subtract(other : Tensor, alpha : number=1) -> Tensor Tensor.subtract(other : Tensor, alpha : number=1, out : Tensor) -> Tensor Tensor.subtract(other : number, alpha : number=1) -> Tensor Tensor.subtract_(other : Tensor, alpha : number=1) -> Tensor Tensor.subtract_(other : number, alpha : number=1) -> Tensor Tensor.sum(dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int]) -> Tensor Tensor.sum(dtype : Optional[int]) -> Tensor Tensor.sum(dim : List[str], keepdim : bool=False, dtype : Optional[int]) -> Tensor Tensor.sum(dim : List[str], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor Tensor.sum(dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor Tensor.sum(dtype : Optional[int], out : Tensor) -> Tensor Tensor.sum_to_size(size : List[int]) -> Tensor Tensor.svd(some : bool=True, compute_uv : bool=True) -> Tuple[Tensor, Tensor, Tensor] Tensor.svd(some : bool=True, compute_uv : bool=True, U : Tensor, S : Tensor, V : Tensor) -> Tuple[Tensor, Tensor, Tensor] Tensor.swapaxes(axis0 : int, axis1 : int) -> Tensor Tensor.swapaxes_(axis0 : int, axis1 : int) -> Tensor Tensor.swapdims(dim0 : int, dim1 : int) -> Tensor Tensor.swapdims_(dim0 : int, dim1 : int) -> Tensor Tensor.t() -> Tensor Tensor.t_() -> Tensor Tensor.take(index : Tensor) -> Tensor Tensor.take(index : Tensor, out : Tensor) -> Tensor Tensor.take_along_dim(indices : Tensor, dim : Optional[int]) -> Tensor Tensor.take_along_dim(indices : Tensor, dim : Optional[int], out : Tensor) -> Tensor Tensor.tan() -> Tensor Tensor.tan(out : Tensor) -> Tensor Tensor.tan_() -> Tensor Tensor.tanh() -> Tensor Tensor.tanh(out : Tensor) -> Tensor Tensor.tanh_() -> Tensor Tensor.tensor_split(sections : int, dim : int=0) -> List[Tensor] Tensor.tensor_split(indices : List[int], dim : int=0) -> List[Tensor] Tensor.tensor_split(tensor_indices_or_sections : Tensor, dim : int=0) -> List[Tensor] Tensor.tile(dims : List[int]) -> Tensor Tensor.to(device : Device, dtype : int, 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(other : Tensor, non_blocking : bool=False, copy : bool=False, memory_format : Optional[int]) -> Tensor Tensor.to(dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool], 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(dtype : Optional[int], masked_grad : Optional[bool]) -> Tensor Tensor.to_mkldnn(dtype : Optional[int]) -> Tensor Tensor.to_mkldnn(dtype : Optional[int], out : Tensor) -> Tensor Tensor.to_padded_tensor(padding : float, output_size : Optional[List[int]], out : Tensor) -> Tensor Tensor.to_padded_tensor(padding : float, output_size : Optional[List[int]]) -> Tensor Tensor.to_sparse(sparse_dim : int) -> Tensor Tensor.to_sparse(layout : Optional[int], blocksize : Optional[List[int]], dense_dim : Optional[int]) -> Tensor Tensor.to_sparse_bsc(blocksize : List[int], dense_dim : Optional[int]) -> Tensor Tensor.to_sparse_bsr(blocksize : List[int], dense_dim : Optional[int]) -> Tensor Tensor.to_sparse_csc(dense_dim : Optional[int]) -> Tensor Tensor.to_sparse_csr(dense_dim : Optional[int]) -> Tensor Tensor.topk(k : int, dim : int=-1, largest : bool=True, sorted : bool=True) -> Tuple[Tensor, Tensor] Tensor.topk(k : int, dim : int=-1, largest : bool=True, sorted : bool=True, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] Tensor.trace() -> Tensor Tensor.trace(out : Tensor) -> Tensor Tensor.transpose(dim0 : int, dim1 : int) -> Tensor Tensor.transpose(dim0 : str, dim1 : str) -> 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.triangular_solve(A : Tensor, upper : bool=True, transpose : bool=False, unitriangular : bool=False, X : Tensor, M : Tensor) -> Tuple[Tensor, Tensor] Tensor.tril(diagonal : int=0) -> Tensor Tensor.tril(diagonal : int=0, out : Tensor) -> Tensor Tensor.tril_(diagonal : int=0) -> Tensor Tensor.triu(diagonal : int=0) -> Tensor Tensor.triu(diagonal : int=0, out : Tensor) -> Tensor Tensor.triu_(diagonal : int=0) -> Tensor Tensor.true_divide(other : Tensor) -> Tensor Tensor.true_divide(other : number) -> Tensor Tensor.true_divide(other : Tensor, out : Tensor) -> Tensor Tensor.true_divide_(other : Tensor) -> Tensor Tensor.true_divide_(other : number) -> 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.unbind(dim : str) -> List[Tensor] Tensor.unflatten(dim : int, sizes : List[int]) -> Tensor Tensor.unflatten(dim : str, sizes : List[int], names : List[str]) -> 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.unique_consecutive(return_inverse : bool=False, return_counts : bool=False, dim : Optional[int], out0 : Tensor, out1 : Tensor, out2 : Tensor) -> Tuple[Tensor, Tensor, Tensor] Tensor.unsafe_chunk(chunks : int, dim : int=0) -> List[Tensor] Tensor.unsafe_split(split_size : int, dim : int=0) -> List[Tensor] Tensor.unsafe_split(split_size : int, dim : int=0, out : List[Tensor]) -> Tuple[] Tensor.unsafe_split_with_sizes(split_sizes : List[int], dim : int=0) -> List[Tensor] Tensor.unsafe_split_with_sizes(split_sizes : List[int], dim : int=0, out : List[Tensor]) -> Tuple[] Tensor.unsqueeze(dim : int) -> Tensor Tensor.unsqueeze_(dim : int) -> Tensor Tensor.values() -> Tensor Tensor.var(unbiased : bool=True) -> Tensor Tensor.var(dim : Optional[List[int]], unbiased : bool=True, keepdim : bool=False) -> Tensor Tensor.var(dim : Optional[List[int]], correction : Optional[number], keepdim : bool=False) -> Tensor Tensor.var(dim : List[str], unbiased : bool=True, keepdim : bool=False) -> Tensor Tensor.var(dim : List[str], unbiased : bool=True, keepdim : bool=False, out : Tensor) -> Tensor Tensor.var(dim : Optional[List[int]], unbiased : bool=True, keepdim : bool=False, out : Tensor) -> Tensor Tensor.var(dim : Optional[List[int]], correction : Optional[number], keepdim : bool=False, out : Tensor) -> Tensor Tensor.var(dim : List[str], correction : Optional[number], keepdim : bool=False) -> Tensor Tensor.var(dim : List[str], correction : Optional[number], keepdim : bool=False, out : Tensor) -> Tensor Tensor.vdot(other : Tensor) -> Tensor Tensor.vdot(other : Tensor, out : Tensor) -> Tensor Tensor.view(size : List[int]) -> Tensor Tensor.view(dtype : int) -> Tensor Tensor.view_as(other : Tensor) -> Tensor Tensor.vsplit(sections : int) -> List[Tensor] Tensor.vsplit(indices : List[int]) -> List[Tensor] Tensor.xlogy(other : Tensor) -> Tensor Tensor.xlogy(other : number) -> Tensor Tensor.xlogy(other : Tensor, out : Tensor) -> Tensor Tensor.xlogy(other : number, out : Tensor) -> Tensor Tensor.xlogy_(other : Tensor) -> Tensor Tensor.xlogy_(other : number) -> Tensor Tensor.zero_() -> Tensor
支持的 PyTorch 函数
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.assert_int_or_pair(arg : List[int], arg_name : str, message : str) -> NoneType 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.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, label_smoothing : float=0.0) -> 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.dropout1d(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], include_last_offset : bool=False, padding_idx : Optional[int]) -> 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.gaussian_nll_loss(input : Tensor, target : Tensor, var : Tensor, full : bool=False, eps : float=1e-06, reduction : str=mean) -> 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.hardsigmoid(input : Tensor, inplace : bool=False) -> Tensor torch.nn.functional.hardswish(input : Tensor, inplace : bool=False) -> 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.huber_loss(input : Tensor, target : Tensor, reduction : str=mean, delta : float=1.0) -> 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, log_target : bool=False) -> 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.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 : Union[float, int], kernel_size : int, stride : Optional[List[int]], ceil_mode : bool=False) -> Tensor torch.nn.functional.lp_pool2d(input : Tensor, norm_type : Union[float, int], kernel_size : List[int], stride : Optional[List[int]], ceil_mode : bool=False) -> Tensor torch.nn.functional.lp_pool3d(input : Tensor, norm_type : Union[float, int], kernel_size : List[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.mish(input : Tensor, inplace : bool=False) -> 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 : Optional[Tensor], in_proj_bias : Optional[Tensor], bias_k : Optional[Tensor], bias_v : Optional[Tensor], add_zero_attn : bool, dropout_p : float, out_proj_weight : Tensor, out_proj_bias : Optional[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], average_attn_weights : bool=True, is_causal : bool=False) -> 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 : Optional[float]) -> 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.relu(input : Tensor, inplace : bool=False) -> Tensor torch.nn.functional.relu6(input : Tensor, inplace : bool=False) -> Tensor torch.nn.functional.rms_norm(input : Tensor, normalized_shape : List[int], weight : Optional[Tensor], eps : Optional[float]) -> 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.silu(input : Tensor, inplace : bool=False) -> Tensor torch.nn.functional.smooth_l1_loss(input : Tensor, target : Tensor, size_average : Optional[bool], reduce : Optional[bool], reduction : str=mean, beta : float=1.0) -> 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.Generator(device : Optional[Device], seed : Optional[int]) -> Generator 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.absolute(self : Tensor) -> Tensor torch.absolute(self : Tensor, out : Tensor) -> Tensor torch.acos(self : Tensor) -> Tensor torch.acos(self : Tensor, out : Tensor) -> Tensor torch.acos(a : int) -> float torch.acos(a : float) -> float torch.acos(a : complex) -> complex torch.acos(a : number) -> number torch.acos_(self : Tensor) -> Tensor torch.acosh(self : Tensor) -> Tensor torch.acosh(self : Tensor, out : Tensor) -> Tensor torch.acosh(a : int) -> float torch.acosh(a : float) -> float torch.acosh(a : complex) -> complex torch.acosh(a : number) -> number torch.acosh_(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(self : Tensor, other : number, alpha : number=1, out : Tensor) -> Tensor torch.add(a : List[t], b : List[t]) -> List[t] torch.add(a : str, b : str) -> str torch.add(a : int, b : int) -> int torch.add(a : complex, b : complex) -> complex torch.add(a : float, b : float) -> float torch.add(a : int, b : complex) -> complex torch.add(a : complex, b : int) -> complex torch.add(a : float, b : complex) -> complex torch.add(a : complex, b : float) -> complex 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) -> Tensor torch.addcdiv(self : Tensor, tensor1 : Tensor, tensor2 : Tensor, value : number=1, out : Tensor) -> 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) -> Tensor torch.addmm(self : Tensor, mat1 : Tensor, mat2 : 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, out : Tensor) -> 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.adjoint(self : Tensor) -> Tensor torch.affine_grid_generator(theta : Tensor, size : List[int], align_corners : bool) -> Tensor torch.affine_grid_generator(theta : Tensor, size : List[int], align_corners : bool, out : Tensor) -> Tensor torch.alias_copy(self : Tensor) -> Tensor torch.alias_copy(self : Tensor, out : Tensor) -> 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 : Optional[List[int]], keepdim : bool=False) -> Tensor torch.all(self : Tensor, dim : int, keepdim : bool=False, out : Tensor) -> Tensor torch.all(self : Tensor, dim : Optional[List[int]], keepdim : bool=False, out : Tensor) -> Tensor torch.all(self : Tensor, out : Tensor) -> Tensor torch.all(self : Tensor, dim : str, keepdim : bool=False) -> Tensor torch.all(self : Tensor, dim : str, keepdim : bool=False, out : Tensor) -> Tensor torch.all(self : List[int]) -> bool torch.all(self : List[float]) -> bool torch.all(self : List[bool]) -> bool 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.amax(self : Tensor, dim : List[int]=[], keepdim : bool=False) -> Tensor torch.amax(self : Tensor, dim : List[int]=[], keepdim : bool=False, out : Tensor) -> Tensor torch.amin(self : Tensor, dim : List[int]=[], keepdim : bool=False) -> Tensor torch.amin(self : Tensor, dim : List[int]=[], keepdim : bool=False, out : Tensor) -> Tensor torch.aminmax(self : Tensor, dim : Optional[int], keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.aminmax(self : Tensor, dim : Optional[int], keepdim : bool=False, min : Tensor, max : Tensor) -> Tuple[Tensor, Tensor] torch.angle(self : Tensor) -> Tensor torch.angle(self : Tensor, out : Tensor) -> Tensor torch.angle(a : int) -> float torch.angle(a : float) -> float torch.angle(a : complex) -> float torch.angle(a : number) -> number torch.any(self : Tensor) -> Tensor torch.any(self : Tensor, dim : int, keepdim : bool=False) -> Tensor torch.any(self : Tensor, dim : Optional[List[int]], keepdim : bool=False) -> Tensor torch.any(self : Tensor, dim : int, keepdim : bool=False, out : Tensor) -> Tensor torch.any(self : Tensor, dim : Optional[List[int]], keepdim : bool=False, out : Tensor) -> Tensor torch.any(self : Tensor, out : Tensor) -> Tensor torch.any(self : Tensor, dim : str, keepdim : bool=False) -> Tensor torch.any(self : Tensor, dim : str, keepdim : bool=False, out : Tensor) -> Tensor torch.any(self : List[str]) -> bool torch.any(self : List[int]) -> bool torch.any(self : List[float]) -> bool torch.any(self : List[bool]) -> bool 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=1, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.arange(start : number, end : number, step : number=1, out : Tensor) -> Tensor torch.arange(end : number, out : Tensor) -> Tensor torch.arccos(self : Tensor) -> Tensor torch.arccos(self : Tensor, out : Tensor) -> Tensor torch.arccos_(self : Tensor) -> Tensor torch.arccosh(self : Tensor) -> Tensor torch.arccosh(self : Tensor, out : Tensor) -> Tensor torch.arccosh_(self : Tensor) -> Tensor torch.arcsin(self : Tensor) -> Tensor torch.arcsin(self : Tensor, out : Tensor) -> Tensor torch.arcsin_(self : Tensor) -> Tensor torch.arcsinh(self : Tensor) -> Tensor torch.arcsinh(self : Tensor, out : Tensor) -> Tensor torch.arcsinh_(self : Tensor) -> Tensor torch.arctan(self : Tensor) -> Tensor torch.arctan(self : Tensor, out : Tensor) -> Tensor torch.arctan2(self : Tensor, other : Tensor) -> Tensor torch.arctan2(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.arctan_(self : Tensor) -> Tensor torch.arctanh(self : Tensor) -> Tensor torch.arctanh(self : Tensor, out : Tensor) -> Tensor torch.arctanh_(self : Tensor) -> Tensor torch.argmax(self : Tensor, dim : Optional[int], keepdim : bool=False) -> Tensor torch.argmax(self : Tensor, dim : Optional[int], keepdim : bool=False, out : Tensor) -> Tensor torch.argmin(self : Tensor, dim : Optional[int], keepdim : bool=False) -> Tensor torch.argmin(self : Tensor, dim : Optional[int], keepdim : bool=False, out : Tensor) -> Tensor torch.argsort(self : Tensor, dim : int=-1, descending : bool=False) -> Tensor torch.argsort(self : Tensor, stable : bool, dim : int=-1, descending : bool=False) -> Tensor torch.argsort(self : Tensor, stable : bool, dim : int=-1, descending : bool=False, out : Tensor) -> Tensor torch.argsort(self : Tensor, dim : str, descending : bool=False) -> Tensor torch.argwhere(self : Tensor) -> 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_strided_copy(self : Tensor, size : List[int], stride : List[int], storage_offset : Optional[int]) -> Tensor torch.as_strided_copy(self : Tensor, size : List[int], stride : List[int], storage_offset : Optional[int], out : Tensor) -> Tensor torch.as_strided_scatter(self : Tensor, src : Tensor, size : List[int], stride : List[int], storage_offset : Optional[int]) -> Tensor torch.as_strided_scatter(self : Tensor, src : Tensor, size : List[int], stride : List[int], storage_offset : Optional[int], out : Tensor) -> Tensor torch.as_tensor(t : bool, dtype : Optional[int], device : Optional[Device]) -> 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 : complex, 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 : complex) -> complex torch.asin(a : number) -> number torch.asin_(self : Tensor) -> Tensor torch.asinh(self : Tensor) -> Tensor torch.asinh(self : Tensor, out : Tensor) -> Tensor torch.asinh(a : int) -> float torch.asinh(a : float) -> float torch.asinh(a : complex) -> complex torch.asinh(a : number) -> number torch.asinh_(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 : complex) -> complex torch.atan(a : number) -> number torch.atan2(self : Tensor, other : Tensor) -> Tensor torch.atan2(self : Tensor, other : Tensor, out : 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.atanh(self : Tensor) -> Tensor torch.atanh(self : Tensor, out : Tensor) -> Tensor torch.atanh(a : int) -> float torch.atanh(a : float) -> float torch.atanh(a : complex) -> complex torch.atanh(a : number) -> number torch.atanh_(self : Tensor) -> Tensor torch.atleast_1d(self : Tensor) -> Tensor torch.atleast_1d(tensors : List[Tensor]) -> List[Tensor] torch.atleast_2d(self : Tensor) -> Tensor torch.atleast_2d(tensors : List[Tensor]) -> List[Tensor] torch.atleast_3d(self : Tensor) -> Tensor torch.atleast_3d(tensors : List[Tensor]) -> List[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.bartlett_window(window_length : int, out : Tensor) -> Tensor torch.bartlett_window(window_length : int, periodic : bool, out : Tensor) -> 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], sum_dy : Tensor, sum_dy_xmu : Tensor, count : Tensor, out : Tensor) -> Tensor torch.batch_norm_backward_elemt(grad_out : Tensor, input : Tensor, mean : Tensor, invstd : Tensor, weight : Optional[Tensor], sum_dy : Tensor, sum_dy_xmu : Tensor, count : 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, out0 : Tensor, out1 : Tensor, out2 : Tensor, out3 : Tensor) -> Tuple[Tensor, Tensor, 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, out : Tensor) -> Tensor torch.batch_norm_elemt(input : Tensor, weight : Optional[Tensor], bias : Optional[Tensor], mean : Tensor, invstd : Tensor, eps : float) -> 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, out0 : Tensor, out1 : Tensor) -> Tuple[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 : Tensor, out0 : Tensor, out1 : Tensor) -> 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 : Tensor) -> Tuple[Tensor, Tensor] torch.batch_norm_stats(input : Tensor, eps : float, out0 : Tensor, out1 : Tensor) -> 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.batch_norm_update_stats(input : Tensor, running_mean : Optional[Tensor], running_var : Optional[Tensor], momentum : float, out0 : Tensor, out1 : Tensor) -> Tuple[Tensor, Tensor] torch.bernoulli(self : Tensor, generator : Optional[Generator]) -> Tensor torch.bernoulli(self : Tensor, generator : Optional[Generator], out : Tensor) -> Tensor torch.bernoulli(self : Tensor, p : float, generator : Optional[Generator]) -> Tensor torch.bernoulli(self : Tensor, p : Tensor, generator : Optional[Generator]) -> Tensor torch.bernoulli(self : Tensor, p : Tensor, generator : Optional[Generator], out : Tensor) -> Tensor torch.bernoulli(self : Tensor, p : float=0.5, 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.binary_cross_entropy_with_logits(self : Tensor, target : Tensor, weight : Optional[Tensor], pos_weight : Optional[Tensor], reduction : int=1, out : Tensor) -> Tensor torch.bincount(self : Tensor, weights : Optional[Tensor], minlength : int=0) -> Tensor torch.bincount(self : Tensor, weights : Optional[Tensor], minlength : int=0, out : Tensor) -> Tensor torch.binomial(count : Tensor, prob : Tensor, generator : Optional[Generator]) -> Tensor torch.binomial(count : Tensor, prob : Tensor, generator : Optional[Generator], out : Tensor) -> Tensor torch.bitwise_and(self : Tensor, other : Tensor) -> Tensor torch.bitwise_and(self : Tensor, other : number) -> Tensor torch.bitwise_and(self : number, other : Tensor) -> Tensor torch.bitwise_and(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.bitwise_and(self : Tensor, other : number, out : Tensor) -> Tensor torch.bitwise_and(self : number, other : Tensor, out : Tensor) -> Tensor torch.bitwise_left_shift(self : Tensor, other : Tensor) -> Tensor torch.bitwise_left_shift(self : Tensor, other : number) -> Tensor torch.bitwise_left_shift(self : number, other : Tensor) -> Tensor torch.bitwise_left_shift(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.bitwise_left_shift(self : Tensor, other : number, out : Tensor) -> Tensor torch.bitwise_left_shift(self : number, other : Tensor, out : Tensor) -> Tensor torch.bitwise_not(self : Tensor) -> Tensor torch.bitwise_not(self : Tensor, out : Tensor) -> Tensor torch.bitwise_or(self : Tensor, other : Tensor) -> Tensor torch.bitwise_or(self : Tensor, other : number) -> Tensor torch.bitwise_or(self : number, other : Tensor) -> Tensor torch.bitwise_or(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.bitwise_or(self : Tensor, other : number, out : Tensor) -> Tensor torch.bitwise_or(self : number, other : Tensor, out : Tensor) -> Tensor torch.bitwise_right_shift(self : Tensor, other : Tensor) -> Tensor torch.bitwise_right_shift(self : Tensor, other : number) -> Tensor torch.bitwise_right_shift(self : number, other : Tensor) -> Tensor torch.bitwise_right_shift(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.bitwise_right_shift(self : Tensor, other : number, out : Tensor) -> Tensor torch.bitwise_right_shift(self : number, other : Tensor, out : Tensor) -> Tensor torch.bitwise_xor(self : Tensor, other : Tensor) -> Tensor torch.bitwise_xor(self : Tensor, other : number) -> Tensor torch.bitwise_xor(self : number, other : 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 : number, other : Tensor, out : Tensor) -> 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.blackman_window(window_length : int, out : Tensor) -> Tensor torch.blackman_window(window_length : int, periodic : bool, out : Tensor) -> Tensor torch.block_diag(tensors : List[Tensor]) -> Tensor torch.block_diag(tensors : List[Tensor], out : Tensor) -> 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.broadcast_to(self : Tensor, size : List[int]) -> Tensor torch.bucketize(self : Tensor, boundaries : Tensor, out_int32 : bool=False, right : bool=False) -> Tensor torch.bucketize(self : number, boundaries : Tensor, out_int32 : bool=False, right : bool=False) -> Tensor torch.bucketize(self : Tensor, boundaries : Tensor, out_int32 : bool=False, right : bool=False, out : Tensor) -> Tensor torch.bucketize(self : number, boundaries : Tensor, out_int32 : bool=False, right : bool=False, out : Tensor) -> 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 : str) -> Tensor torch.cat(tensors : List[Tensor], dim : str, out : Tensor) -> Tensor torch.cat(tensors : List[Tensor], dim : int=0, out : Tensor) -> Tensor torch.ccol_indices_copy(self : Tensor, out : Tensor) -> Tensor torch.ccol_indices_copy(self : Tensor) -> Tensor torch.ceil(self : Tensor) -> Tensor torch.ceil(self : Tensor, out : 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, out : Tensor) -> Tensor torch.celu_(self : Tensor, alpha : number=1.0) -> Tensor torch.chain_matmul(matrices : List[Tensor]) -> Tensor torch.chain_matmul(matrices : List[Tensor], out : Tensor) -> Tensor torch.channel_shuffle(self : Tensor, groups : int) -> Tensor torch.channel_shuffle(self : Tensor, groups : int, out : Tensor) -> Tensor torch.cholesky(self : Tensor, upper : bool=False) -> Tensor torch.cholesky(self : Tensor, upper : bool=False, out : Tensor) -> 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) -> Tensor torch.cholesky_solve(self : Tensor, input2 : Tensor, upper : bool=False, out : Tensor) -> Tensor torch.choose_qparams_optimized(input : Tensor, numel : int, n_bins : int, ratio : float, bit_width : int) -> Tuple[Tensor, 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[Tensor], max : Optional[Tensor]) -> Tensor torch.clamp(self : Tensor, min : Optional[number], max : Optional[number], out : Tensor) -> Tensor torch.clamp(self : Tensor, min : Optional[Tensor], max : Optional[Tensor], out : Tensor) -> Tensor torch.clamp_(self : Tensor, min : Optional[number], max : Optional[number]) -> Tensor torch.clamp_(self : Tensor, min : Optional[Tensor], max : Optional[Tensor]) -> Tensor torch.clamp_max(self : Tensor, max : number) -> Tensor torch.clamp_max(self : Tensor, max : Tensor) -> Tensor torch.clamp_max(self : Tensor, max : number, out : Tensor) -> Tensor torch.clamp_max(self : Tensor, max : Tensor, out : Tensor) -> Tensor torch.clamp_max_(self : Tensor, max : number) -> Tensor torch.clamp_max_(self : Tensor, max : Tensor) -> Tensor torch.clamp_min(self : Tensor, min : number) -> Tensor torch.clamp_min(self : Tensor, min : Tensor) -> Tensor torch.clamp_min(self : Tensor, min : number, out : Tensor) -> Tensor torch.clamp_min(self : Tensor, min : Tensor, out : Tensor) -> Tensor torch.clamp_min_(self : Tensor, min : number) -> Tensor torch.clamp_min_(self : Tensor, min : Tensor) -> Tensor torch.clip(self : Tensor, min : Optional[number], max : Optional[number]) -> Tensor torch.clip(self : Tensor, min : Optional[Tensor], max : Optional[Tensor]) -> Tensor torch.clip(self : Tensor, min : Optional[number], max : Optional[number], out : Tensor) -> Tensor torch.clip(self : Tensor, min : Optional[Tensor], max : Optional[Tensor], out : Tensor) -> Tensor torch.clip_(self : Tensor, min : Optional[number], max : Optional[number]) -> Tensor torch.clip_(self : Tensor, min : Optional[Tensor], max : Optional[Tensor]) -> Tensor torch.clone(self : Tensor, memory_format : Optional[int]) -> Tensor torch.clone(self : Tensor, memory_format : Optional[int], out : Tensor) -> Tensor torch.col_indices_copy(self : Tensor, out : Tensor) -> Tensor torch.col_indices_copy(self : Tensor) -> Tensor torch.column_stack(tensors : List[Tensor]) -> Tensor torch.column_stack(tensors : List[Tensor], out : Tensor) -> Tensor torch.combinations(self : Tensor, r : int=2, with_replacement : bool=False) -> Tensor torch.complex(real : Tensor, imag : Tensor) -> Tensor torch.complex(real : Tensor, imag : Tensor, out : Tensor) -> Tensor torch.concat(tensors : List[Tensor], dim : int=0) -> Tensor torch.concat(tensors : List[Tensor], dim : int=0, out : Tensor) -> Tensor torch.concat(tensors : List[Tensor], dim : str) -> Tensor torch.concat(tensors : List[Tensor], dim : str, out : Tensor) -> Tensor torch.concatenate(tensors : List[Tensor], dim : int=0) -> Tensor torch.concatenate(tensors : List[Tensor], dim : int=0, out : Tensor) -> Tensor torch.concatenate(tensors : List[Tensor], dim : str) -> Tensor torch.concatenate(tensors : List[Tensor], dim : str, out : Tensor) -> Tensor torch.conj(self : Tensor) -> Tensor torch.conj_physical(self : Tensor) -> Tensor torch.conj_physical(self : Tensor, out : Tensor) -> Tensor torch.conj_physical_(self : Tensor) -> Tensor torch.constant_pad_nd(self : Tensor, pad : List[int], value : number=0) -> Tensor torch.constant_pad_nd(self : Tensor, pad : List[int], value : number=0, out : Tensor) -> 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.conv1d(input : Tensor, weight : Tensor, bias : Optional[Tensor], stride : List[int]=[1], padding : str=valid, 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.conv2d(input : Tensor, weight : Tensor, bias : Optional[Tensor], stride : List[int]=[1, 1], padding : str=valid, 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.conv3d(input : Tensor, weight : Tensor, bias : Optional[Tensor], stride : List[int]=[1, 1, 1], padding : str=valid, 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_tbc(self : Tensor, weight : Tensor, bias : Tensor, pad : int=0, out : Tensor) -> 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.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, out : Tensor) -> Tensor torch.copysign(self : Tensor, other : Tensor) -> Tensor torch.copysign(self : Tensor, other : number) -> Tensor torch.copysign(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.copysign(self : Tensor, other : number, out : Tensor) -> Tensor torch.copysign(a : int, b : int) -> float torch.copysign(a : float, b : float) -> float torch.copysign(a : int, b : float) -> float torch.copysign(a : float, b : int) -> float torch.copysign(a : number, b : number) -> float torch.corrcoef(self : Tensor) -> 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 : complex) -> complex 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 : complex) -> complex 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.count_nonzero(self : Tensor, dim : List[int]) -> Tensor torch.count_nonzero(self : Tensor, dim : List[int], out : Tensor) -> Tensor torch.count_nonzero(self : Tensor, dim : Optional[int]) -> Tensor torch.count_nonzero(self : Tensor, dim : Optional[int], out : Tensor) -> Tensor torch.cov(self : Tensor, correction : int=1, fweights : Optional[Tensor], aweights : Optional[Tensor]) -> Tensor torch.cross(self : Tensor, other : Tensor, dim : Optional[int]) -> Tensor torch.cross(self : Tensor, other : Tensor, dim : Optional[int], out : Tensor) -> Tensor torch.crow_indices_copy(self : Tensor, out : Tensor) -> Tensor torch.crow_indices_copy(self : Tensor) -> 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.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.cudnn_affine_grid_generator(theta : Tensor, N : int, C : int, H : int, W : int, out : Tensor) -> 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_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, out0 : Tensor, out1 : Tensor, out2 : Tensor, out3 : Tensor) -> Tuple[Tensor, Tensor, Tensor, Tensor] torch.cudnn_convolution(self : Tensor, weight : Tensor, padding : List[int], stride : List[int], dilation : List[int], groups : int, benchmark : bool, deterministic : bool, allow_tf32 : bool) -> Tensor torch.cudnn_convolution(self : Tensor, weight : Tensor, padding : List[int], stride : List[int], dilation : List[int], groups : int, benchmark : bool, deterministic : bool, allow_tf32 : bool, out : Tensor) -> Tensor torch.cudnn_convolution_add_relu(self : Tensor, weight : Tensor, z : Tensor, alpha : Optional[number], bias : Optional[Tensor], stride : List[int], padding : List[int], dilation : List[int], groups : int, out : Tensor) -> Tensor torch.cudnn_convolution_add_relu(self : Tensor, weight : Tensor, z : Tensor, alpha : Optional[number], bias : Optional[Tensor], stride : List[int], padding : List[int], dilation : List[int], groups : int) -> Tensor torch.cudnn_convolution_relu(self : Tensor, weight : Tensor, bias : Optional[Tensor], stride : List[int], padding : List[int], dilation : List[int], groups : int, out : Tensor) -> Tensor torch.cudnn_convolution_relu(self : Tensor, weight : Tensor, bias : Optional[Tensor], stride : List[int], padding : List[int], dilation : List[int], groups : int) -> Tensor torch.cudnn_convolution_transpose(self : Tensor, weight : Tensor, padding : List[int], output_padding : List[int], stride : List[int], dilation : List[int], groups : int, benchmark : bool, deterministic : bool, allow_tf32 : bool) -> Tensor torch.cudnn_convolution_transpose(self : Tensor, weight : Tensor, padding : List[int], output_padding : List[int], stride : List[int], dilation : List[int], groups : int, benchmark : bool, deterministic : bool, allow_tf32 : bool, out : Tensor) -> Tensor torch.cudnn_grid_sampler(self : Tensor, grid : Tensor) -> Tensor torch.cudnn_grid_sampler(self : Tensor, grid : Tensor, out : Tensor) -> Tensor torch.cudnn_is_acceptable(self : Tensor) -> bool torch.cummax(self : Tensor, dim : int) -> Tuple[Tensor, Tensor] torch.cummax(self : Tensor, dim : str) -> Tuple[Tensor, Tensor] torch.cummax(self : Tensor, dim : str, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.cummax(self : Tensor, dim : int, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.cummin(self : Tensor, dim : int) -> Tuple[Tensor, Tensor] torch.cummin(self : Tensor, dim : str) -> Tuple[Tensor, Tensor] torch.cummin(self : Tensor, dim : str, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.cummin(self : Tensor, dim : int, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.cumprod(self : Tensor, dim : int, dtype : Optional[int]) -> Tensor torch.cumprod(self : Tensor, dim : str, dtype : Optional[int]) -> Tensor torch.cumprod(self : Tensor, dim : str, dtype : Optional[int], out : Tensor) -> 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 : str, dtype : Optional[int]) -> Tensor torch.cumsum(self : Tensor, dim : str, dtype : Optional[int], out : Tensor) -> Tensor torch.cumsum(self : Tensor, dim : int, dtype : Optional[int], out : Tensor) -> Tensor torch.cumulative_trapezoid(y : Tensor, x : Tensor, dim : int=-1) -> Tensor torch.cumulative_trapezoid(y : Tensor, dx : number=1, dim : int=-1) -> Tensor torch.deg2rad(self : Tensor) -> Tensor torch.deg2rad(self : Tensor, out : Tensor) -> Tensor torch.deg2rad_(self : Tensor) -> Tensor torch.dequantize(self : Tensor) -> Tensor torch.dequantize(self : Tensor, out : Tensor) -> Tensor torch.dequantize(tensors : List[Tensor], out : List[Tensor]) -> Tuple[] torch.dequantize(tensors : List[Tensor]) -> List[Tensor] torch.dequantize(qtensor : Tensor) -> Tensor torch.dequantize(qtensors : List[Tensor]) -> List[Tensor] torch.dequantize(tensors : Any) -> Any torch.det(self : Tensor) -> Tensor torch.detach(self : Tensor) -> Tensor torch.detach_(self : Tensor) -> Tensor torch.detach_copy(self : Tensor, out : Tensor) -> Tensor torch.detach_copy(self : Tensor) -> Tensor torch.device(a : str) -> Device torch.device(type : str, index : int) -> 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.diag_embed(self : Tensor, offset : int=0, dim1 : int=-2, dim2 : int=-1, out : Tensor) -> Tensor torch.diagflat(self : Tensor, offset : int=0) -> Tensor torch.diagonal(self : Tensor, offset : int=0, dim1 : int=0, dim2 : int=1) -> Tensor torch.diagonal(self : Tensor, outdim : str, dim1 : str, dim2 : str, offset : int=0) -> Tensor torch.diagonal_copy(self : Tensor, offset : int=0, dim1 : int=0, dim2 : int=1) -> Tensor torch.diagonal_copy(self : Tensor, offset : int=0, dim1 : int=0, dim2 : int=1, out : Tensor) -> Tensor torch.diagonal_scatter(self : Tensor, src : Tensor, offset : int=0, dim1 : int=0, dim2 : int=1) -> Tensor torch.diagonal_scatter(self : Tensor, src : Tensor, offset : int=0, dim1 : int=0, dim2 : int=1, out : Tensor) -> Tensor torch.diff(self : Tensor, n : int=1, dim : int=-1, prepend : Optional[Tensor], append : Optional[Tensor]) -> Tensor torch.diff(self : Tensor, n : int=1, dim : int=-1, prepend : Optional[Tensor], append : Optional[Tensor], out : Tensor) -> Tensor torch.digamma(self : Tensor) -> Tensor torch.digamma(self : Tensor, out : Tensor) -> Tensor torch.dist(self : Tensor, other : Tensor, p : number=2) -> Tensor torch.dist(self : Tensor, other : Tensor, p : number=2, out : Tensor) -> Tensor torch.div(self : Tensor, other : Tensor) -> Tensor torch.div(self : Tensor, other : number) -> Tensor torch.div(self : Tensor, other : Tensor, rounding_mode : Optional[str]) -> Tensor torch.div(self : Tensor, other : number, rounding_mode : Optional[str]) -> Tensor torch.div(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.div(self : Tensor, other : Tensor, rounding_mode : Optional[str], out : Tensor) -> Tensor torch.div(self : Tensor, other : number, out : Tensor) -> Tensor torch.div(self : Tensor, other : number, rounding_mode : Optional[str], out : Tensor) -> Tensor torch.div(a : int, b : int) -> float torch.div(a : complex, b : complex) -> complex torch.div(a : float, b : float) -> float torch.div(a : number, b : number) -> float torch.divide(self : Tensor, other : Tensor) -> Tensor torch.divide(self : Tensor, other : number) -> Tensor torch.divide(self : Tensor, other : Tensor, rounding_mode : Optional[str]) -> Tensor torch.divide(self : Tensor, other : number, rounding_mode : Optional[str]) -> Tensor torch.divide(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.divide(self : Tensor, other : Tensor, rounding_mode : Optional[str], out : Tensor) -> Tensor 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.dsplit(self : Tensor, sections : int) -> List[Tensor] torch.dsplit(self : Tensor, indices : List[int]) -> List[Tensor] torch.dstack(tensors : List[Tensor]) -> Tensor torch.dstack(tensors : List[Tensor], out : Tensor) -> Tensor torch.einsum(equation : str, tensors : List[Tensor], path : Optional[List[int]]) -> Tensor torch.einsum(a : Tensor) -> Tensor torch.embedding(weight : Tensor, indices : Tensor, padding_idx : int=-1, scale_grad_by_freq : bool=False, sparse : bool=False) -> Tensor torch.embedding(weight : Tensor, indices : Tensor, padding_idx : int=-1, scale_grad_by_freq : bool=False, sparse : bool=False, out : Tensor) -> 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], include_last_offset : bool=False) -> Tuple[Tensor, Tensor, Tensor, Tensor] torch.embedding_bag(weight : Tensor, indices : Tensor, offsets : Tensor, scale_grad_by_freq : bool, mode : int, sparse : bool, per_sample_weights : Optional[Tensor], include_last_offset : bool, padding_idx : Optional[int]) -> 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(size : List[int], names : Optional[List[str]], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool], memory_format : Optional[int]) -> Tensor torch.empty(size : List[int], names : Optional[List[str]], memory_format : Optional[int], out : Tensor) -> Tensor torch.empty_like(self : Tensor, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool], memory_format : Optional[int]) -> Tensor torch.empty_like(self : Tensor, memory_format : Optional[int], out : Tensor) -> Tensor torch.empty_permuted(size : List[int], physical_layout : List[int], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.empty_permuted(size : List[int], physical_layout : List[int], out : Tensor) -> Tensor torch.empty_quantized(size : List[int], qtensor : Tensor, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool], memory_format : Optional[int]) -> Tensor torch.empty_quantized(size : List[int], qtensor : Tensor, memory_format : Optional[int], out : Tensor) -> 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.empty_strided(size : List[int], stride : List[int], out : Tensor) -> Tensor torch.eq(self : Tensor, other : Tensor) -> Tensor torch.eq(self : Tensor, other : number) -> Tensor torch.eq(self : Tensor, other : number, out : Tensor) -> Tensor torch.eq(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.eq(a : List[int], b : List[int]) -> bool torch.eq(a : Device, b : Device) -> bool torch.eq(a : bool, b : bool) -> bool torch.eq(a : AnyEnumType, b : AnyEnumType) -> bool torch.eq(a : int, b : int) -> bool torch.eq(a : complex, b : complex) -> 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 : float, b : complex) -> bool torch.eq(a : complex, b : float) -> bool torch.eq(a : number, b : number) -> bool torch.eq(a : str, b : str) -> 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 : List[str], b : List[str]) -> bool torch.equal(self : Tensor, other : Tensor) -> bool torch.erf(self : Tensor) -> Tensor torch.erf(self : Tensor, out : 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) -> Tensor torch.erfc(self : Tensor, out : 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) -> Tensor torch.erfinv(self : Tensor, out : 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 : complex) -> complex torch.exp(a : number) -> number torch.exp2(self : Tensor) -> Tensor torch.exp2(self : Tensor, out : Tensor) -> Tensor torch.exp2_(self : Tensor) -> Tensor torch.exp_(self : Tensor) -> Tensor torch.expand_copy(self : Tensor, size : List[int], implicit : bool=False) -> Tensor torch.expand_copy(self : Tensor, size : List[int], implicit : bool=False, out : Tensor) -> Tensor torch.expm1(self : Tensor) -> Tensor torch.expm1(self : Tensor, out : 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, 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.eye(n : int, out : Tensor) -> Tensor torch.eye(n : int, m : int, out : Tensor) -> 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.fake_quantize_per_tensor_affine(self : Tensor, scale : Tensor, zero_point : Tensor, 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.fill(self : Tensor, value : number) -> Tensor torch.fill(self : Tensor, value : number, out : Tensor) -> Tensor torch.fill(self : Tensor, value : Tensor) -> Tensor torch.fill(self : Tensor, value : Tensor, out : Tensor) -> Tensor torch.fill_(self : Tensor, value : number) -> Tensor torch.fill_(self : Tensor, value : Tensor) -> Tensor torch.fix(self : Tensor) -> Tensor torch.fix(self : Tensor, out : Tensor) -> Tensor torch.fix_(self : Tensor) -> Tensor torch.flatten(self : Tensor, start_dim : int=0, end_dim : int=-1) -> Tensor torch.flatten(self : Tensor, dims : List[str], out_dim : str) -> Tensor torch.flatten(self : Tensor, start_dim : int, end_dim : int, out_dim : str) -> Tensor torch.flatten(self : Tensor, start_dim : str, end_dim : str, out_dim : str) -> Tensor torch.flip(self : Tensor, dims : List[int]) -> Tensor torch.flip(self : Tensor, dims : List[int], out : Tensor) -> Tensor torch.fliplr(self : Tensor) -> Tensor torch.flipud(self : Tensor) -> Tensor torch.float_power(self : Tensor, exponent : Tensor) -> Tensor torch.float_power(self : Tensor, exponent : number) -> Tensor torch.float_power(self : number, exponent : Tensor) -> Tensor torch.float_power(self : Tensor, exponent : Tensor, out : Tensor) -> Tensor torch.float_power(self : number, exponent : Tensor, out : Tensor) -> Tensor torch.float_power(self : Tensor, exponent : number, out : Tensor) -> 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.floor_divide(self : Tensor, other : Tensor) -> Tensor torch.floor_divide(self : Tensor, other : number) -> Tensor torch.floor_divide(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.floor_divide(self : Tensor, other : number, out : Tensor) -> Tensor torch.fmax(self : Tensor, other : Tensor) -> Tensor torch.fmax(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.fmin(self : Tensor, other : Tensor) -> Tensor torch.fmin(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.fmod(self : Tensor, other : Tensor) -> Tensor torch.fmod(self : Tensor, other : number) -> Tensor torch.fmod(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.fmod(self : Tensor, other : number, out : Tensor) -> 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.frexp(self : Tensor) -> Tuple[Tensor, Tensor] torch.frexp(self : Tensor, mantissa : Tensor, exponent : Tensor) -> Tuple[Tensor, Tensor] torch.frexp(a : float) -> Tuple[float, int] 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.from_file(filename : str, shared : Optional[bool], size : Optional[int]=0, out : Tensor) -> Tensor torch.full(size : List[int], fill_value : number, names : Optional[List[str]], 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, names : Optional[List[str]], out : Tensor) -> Tensor torch.full(size : List[int], fill_value : number, out : Tensor) -> Tensor torch.full_like(self : Tensor, fill_value : number, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool], memory_format : Optional[int]) -> Tensor torch.full_like(self : Tensor, fill_value : number, memory_format : Optional[int], out : Tensor) -> Tensor torch.fused_moving_avg_obs_fake_quant(self : Tensor, observer_on : Tensor, fake_quant_on : Tensor, running_min : Tensor, running_max : Tensor, scale : Tensor, zero_point : Tensor, averaging_const : float, quant_min : int, quant_max : int, ch_axis : int, per_row_fake_quant : bool=False, symmetric_quant : bool=False) -> Tensor torch.gather(self : Tensor, dim : int, index : Tensor, sparse_grad : bool=False) -> Tensor torch.gather(self : Tensor, dim : int, index : Tensor, sparse_grad : bool=False, out : Tensor) -> Tensor torch.gather(self : Tensor, dim : str, index : Tensor, sparse_grad : bool=False) -> Tensor torch.gather(self : Tensor, dim : str, index : Tensor, sparse_grad : bool=False, out : Tensor) -> Tensor torch.gcd(self : Tensor, other : Tensor) -> Tensor torch.gcd(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.gcd(a : int, b : int) -> int torch.gcd_(self : Tensor, other : Tensor) -> Tensor torch.ge(self : Tensor, other : Tensor) -> Tensor torch.ge(self : Tensor, other : number) -> Tensor torch.ge(self : Tensor, other : number, out : Tensor) -> Tensor torch.ge(self : Tensor, other : Tensor, 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.geqrf(self : Tensor, a : Tensor, tau : Tensor) -> Tuple[Tensor, Tensor] torch.ger(self : Tensor, vec2 : Tensor) -> Tensor torch.ger(self : Tensor, vec2 : Tensor, out : Tensor) -> Tensor torch.get_autocast_dtype(device_type : str) -> int torch.get_device(self : Tensor) -> int torch.gradient(self : Tensor, spacing : Optional[number], dim : Optional[int], edge_order : int=1) -> List[Tensor] torch.gradient(self : Tensor, spacing : number, dim : List[int], edge_order : int=1) -> List[Tensor] torch.gradient(self : Tensor, dim : List[int], edge_order : int=1) -> List[Tensor] torch.gradient(self : Tensor, spacing : List[number], dim : Optional[int], edge_order : int=1) -> List[Tensor] torch.gradient(self : Tensor, spacing : List[number], dim : List[int], edge_order : int=1) -> List[Tensor] torch.gradient(self : Tensor, spacing : List[Tensor], dim : Optional[int], edge_order : int=1) -> List[Tensor] torch.gradient(self : Tensor, spacing : List[Tensor], dim : List[int], edge_order : int=1) -> List[Tensor] torch.greater(self : Tensor, other : Tensor) -> Tensor torch.greater(self : Tensor, other : number) -> Tensor torch.greater(self : Tensor, other : number, out : Tensor) -> Tensor torch.greater(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.greater_equal(self : Tensor, other : Tensor) -> Tensor torch.greater_equal(self : Tensor, other : number) -> Tensor torch.greater_equal(self : Tensor, other : number, out : Tensor) -> Tensor torch.greater_equal(self : Tensor, other : Tensor, out : Tensor) -> Tensor 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_2d(input : Tensor, grid : Tensor, interpolation_mode : int, padding_mode : int, align_corners : bool, out : Tensor) -> Tensor torch.grid_sampler_3d(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, out : Tensor) -> 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(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(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_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 : number, out : Tensor) -> Tensor torch.gt(self : Tensor, other : Tensor, 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.hamming_window(window_length : int, out : Tensor) -> Tensor torch.hamming_window(window_length : int, periodic : bool, out : Tensor) -> Tensor torch.hamming_window(window_length : int, periodic : bool, alpha : float, out : Tensor) -> Tensor torch.hamming_window(window_length : int, periodic : bool, alpha : float, beta : float, out : Tensor) -> 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.hann_window(window_length : int, out : Tensor) -> Tensor torch.hann_window(window_length : int, periodic : bool, out : Tensor) -> Tensor torch.hardshrink(self : Tensor, lambd : number=0.5) -> Tensor torch.hardshrink(self : Tensor, lambd : number=0.5, out : Tensor) -> Tensor torch.heaviside(self : Tensor, values : Tensor) -> Tensor torch.heaviside(self : Tensor, values : Tensor, out : Tensor) -> 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) -> Tensor torch.histc(self : Tensor, bins : int=100, min : number=0, max : number=0, out : Tensor) -> Tensor torch.histogram(self : Tensor, bins : Tensor, weight : Optional[Tensor], density : bool=False) -> Tuple[Tensor, Tensor] torch.histogram(self : Tensor, bins : Tensor, weight : Optional[Tensor], density : bool=False, hist : Tensor, bin_edges : Tensor) -> Tuple[Tensor, Tensor] torch.histogram(self : Tensor, bins : int=100, range : Optional[List[float]], weight : Optional[Tensor], density : bool=False) -> Tuple[Tensor, Tensor] torch.histogram(self : Tensor, bins : int=100, range : Optional[List[float]], weight : Optional[Tensor], density : bool=False, hist : Tensor, bin_edges : Tensor) -> Tuple[Tensor, Tensor] torch.histogramdd(self : Tensor, bins : List[int], range : Optional[List[float]], weight : Optional[Tensor], density : bool=False) -> Tuple[Tensor, List[Tensor]] torch.histogramdd(self : Tensor, bins : int, range : Optional[List[float]], weight : Optional[Tensor], density : bool=False) -> Tuple[Tensor, List[Tensor]] torch.histogramdd(self : Tensor, bins : List[Tensor], range : Optional[List[float]], weight : Optional[Tensor], density : bool=False) -> Tuple[Tensor, List[Tensor]] torch.hsplit(self : Tensor, sections : int) -> List[Tensor] torch.hsplit(self : Tensor, indices : List[int]) -> List[Tensor] torch.hspmm(mat1 : Tensor, mat2 : Tensor, out : Tensor) -> Tensor torch.hspmm(mat1 : Tensor, mat2 : Tensor) -> Tensor torch.hstack(tensors : List[Tensor]) -> Tensor torch.hstack(tensors : List[Tensor], out : Tensor) -> Tensor torch.hypot(self : Tensor, other : Tensor) -> Tensor torch.hypot(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.i0(self : Tensor) -> Tensor torch.i0(self : Tensor, out : Tensor) -> Tensor torch.i0_(self : Tensor) -> Tensor torch.igamma(self : Tensor, other : Tensor) -> Tensor torch.igamma(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.igammac(self : Tensor, other : Tensor) -> Tensor torch.igammac(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.imag(self : Tensor) -> Tensor torch.index_add(self : Tensor, dim : int, index : Tensor, source : Tensor, alpha : number=1) -> Tensor torch.index_add(self : Tensor, dim : int, index : Tensor, source : Tensor, alpha : number=1, out : Tensor) -> Tensor torch.index_add(self : Tensor, dim : str, index : Tensor, source : Tensor, alpha : number=1) -> Tensor torch.index_copy(self : Tensor, dim : int, index : Tensor, source : Tensor) -> Tensor torch.index_copy(self : Tensor, dim : str, index : Tensor, source : Tensor) -> Tensor torch.index_copy(self : Tensor, dim : int, index : Tensor, source : Tensor, out : 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_fill(self : Tensor, dim : str, index : Tensor, value : number) -> Tensor torch.index_fill(self : Tensor, dim : str, index : Tensor, value : Tensor) -> Tensor torch.index_fill(self : Tensor, dim : int, index : Tensor, value : number, out : Tensor) -> Tensor torch.index_fill(self : Tensor, dim : int, index : Tensor, value : Tensor, out : Tensor) -> Tensor torch.index_put(self : Tensor, indices : List[Optional[Tensor]], values : Tensor, accumulate : bool=False) -> Tensor torch.index_put(self : Tensor, indices : List[Optional[Tensor]], values : Tensor, accumulate : bool=False, out : Tensor) -> 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_reduce(self : Tensor, dim : int, index : Tensor, source : Tensor, reduce : str, include_self : bool=True) -> Tensor torch.index_reduce(self : Tensor, dim : int, index : Tensor, source : Tensor, reduce : str, include_self : bool=True, out : Tensor) -> Tensor torch.index_select(self : Tensor, dim : int, index : Tensor) -> Tensor torch.index_select(self : Tensor, dim : int, index : Tensor, out : Tensor) -> Tensor torch.index_select(self : Tensor, dim : str, index : Tensor) -> Tensor torch.index_select(self : Tensor, dim : str, index : Tensor, out : Tensor) -> Tensor torch.indices_copy(self : Tensor, out : Tensor) -> Tensor torch.indices_copy(self : Tensor) -> Tensor torch.initial_seed(self : Generator) -> int torch.inner(self : Tensor, other : Tensor) -> Tensor torch.inner(self : Tensor, other : Tensor, out : 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, out : Tensor) -> Tensor torch.int_repr(self : Tensor) -> Tensor torch.inverse(self : Tensor) -> Tensor torch.inverse(self : Tensor, out : Tensor) -> Tensor torch.is_autocast_cpu_enabled() -> bool torch.is_autocast_enabled() -> bool torch.is_complex(self : Tensor) -> bool torch.is_conj(self : Tensor) -> bool torch.is_distributed(self : Tensor) -> bool torch.is_floating_point(self : Tensor) -> bool torch.is_grad_enabled() -> bool torch.is_inference(self : Tensor) -> bool torch.is_neg(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.is_vulkan_available() -> 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.isfinite(a : complex) -> bool torch.isin(elements : Tensor, test_elements : Tensor, assume_unique : bool=False, invert : bool=False) -> Tensor torch.isin(elements : Tensor, test_elements : Tensor, assume_unique : bool=False, invert : bool=False, out : Tensor) -> Tensor torch.isin(elements : Tensor, test_element : number, assume_unique : bool=False, invert : bool=False) -> Tensor torch.isin(elements : Tensor, test_element : number, assume_unique : bool=False, invert : bool=False, out : Tensor) -> Tensor torch.isin(element : number, test_elements : Tensor, assume_unique : bool=False, invert : bool=False) -> Tensor torch.isin(element : number, test_elements : Tensor, assume_unique : bool=False, invert : bool=False, out : Tensor) -> Tensor torch.isinf(self : Tensor) -> Tensor torch.isinf(self : Tensor, out : Tensor) -> Tensor torch.isinf(a : float) -> bool torch.isinf(a : complex) -> bool torch.isnan(self : Tensor) -> Tensor torch.isnan(self : Tensor, out : Tensor) -> Tensor torch.isnan(a : float) -> bool torch.isnan(a : complex) -> bool torch.isneginf(self : Tensor) -> Tensor torch.isneginf(self : Tensor, out : Tensor) -> Tensor torch.isposinf(self : Tensor) -> Tensor torch.isposinf(self : Tensor, out : Tensor) -> Tensor torch.isreal(self : Tensor) -> Tensor torch.istft(self : Tensor, n_fft : int, hop_length : Optional[int], win_length : Optional[int], window : Optional[Tensor], center : bool=True, normalized : bool=False, onesided : Optional[bool], length : Optional[int], return_complex : bool=False) -> Tensor torch.kaiser_window(window_length : int, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.kaiser_window(window_length : int, periodic : bool, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.kaiser_window(window_length : int, periodic : bool, beta : float, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.kaiser_window(window_length : int, out : Tensor) -> Tensor torch.kaiser_window(window_length : int, periodic : bool, out : Tensor) -> Tensor torch.kaiser_window(window_length : int, periodic : bool, beta : float, out : Tensor) -> Tensor torch.kl_div(self : Tensor, target : Tensor, reduction : int=1, log_target : bool=False) -> Tensor torch.kron(self : Tensor, other : Tensor) -> Tensor torch.kron(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.kthvalue(self : Tensor, k : int, dim : int=-1, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.kthvalue(self : Tensor, k : int, dim : str, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.kthvalue(self : Tensor, k : int, dim : str, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.kthvalue(self : Tensor, k : int, dim : int=-1, keepdim : bool=False, values : Tensor, indices : Tensor) -> 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.lcm(self : Tensor, other : Tensor) -> Tensor torch.lcm(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.lcm_(self : Tensor, other : Tensor) -> Tensor torch.ldexp(self : Tensor, other : Tensor) -> Tensor torch.ldexp(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.ldexp(x : float, i : int) -> float torch.ldexp_(self : Tensor, other : Tensor) -> Tensor torch.le(self : Tensor, other : Tensor) -> Tensor torch.le(self : Tensor, other : number) -> Tensor torch.le(self : Tensor, other : number, out : Tensor) -> Tensor torch.le(self : Tensor, other : Tensor, out : Tensor) -> 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 : number) -> Tensor torch.lerp(self : Tensor, end : Tensor, weight : Tensor) -> Tensor torch.lerp(self : Tensor, end : Tensor, weight : number, out : Tensor) -> Tensor torch.lerp(self : Tensor, end : Tensor, weight : Tensor, out : Tensor) -> Tensor torch.less(self : Tensor, other : Tensor) -> Tensor torch.less(self : Tensor, other : number) -> Tensor torch.less(self : Tensor, other : number, out : Tensor) -> Tensor torch.less(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.less_equal(self : Tensor, other : Tensor) -> Tensor torch.less_equal(self : Tensor, other : number) -> Tensor torch.less_equal(self : Tensor, other : number, out : Tensor) -> Tensor torch.less_equal(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.lgamma(self : Tensor) -> Tensor torch.lgamma(self : Tensor, out : Tensor) -> Tensor torch.lgamma(a : int) -> float torch.lgamma(a : float) -> float torch.lgamma(a : number) -> number torch.linspace(start : Tensor, end : Tensor, steps : int, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.linspace(start : Tensor, end : number, steps : int, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.linspace(start : number, end : Tensor, steps : int, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.linspace(start : number, end : number, steps : int, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.linspace(start : number, end : number, steps : int, out : Tensor) -> Tensor torch.linspace(start : Tensor, end : Tensor, steps : int, out : Tensor) -> Tensor torch.linspace(start : Tensor, end : number, steps : int, out : Tensor) -> Tensor torch.linspace(start : number, end : Tensor, steps : int, 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 : complex) -> complex torch.log(a : number) -> number torch.log(a : int, b : int) -> float torch.log(a : float, b : float) -> float torch.log(a : complex, b : complex) -> complex torch.log(a : int, b : float) -> float torch.log(a : float, b : int) -> float torch.log(a : int, b : complex) -> complex torch.log(a : complex, b : int) -> complex torch.log(a : float, b : complex) -> complex torch.log(a : complex, b : float) -> complex torch.log(a : number, b : number) -> float torch.log10(self : Tensor) -> Tensor torch.log10(self : Tensor, out : Tensor) -> Tensor torch.log10(a : int) -> float torch.log10(a : float) -> float torch.log10(a : complex) -> complex 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.log_softmax(self : Tensor, dim : str, dtype : Optional[int]) -> Tensor torch.log_softmax(self : Tensor, dim : int, dtype : Optional[int], out : Tensor) -> Tensor torch.logaddexp(self : Tensor, other : Tensor) -> Tensor torch.logaddexp(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.logaddexp2(self : Tensor, other : Tensor) -> Tensor torch.logaddexp2(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.logcumsumexp(self : Tensor, dim : int) -> Tensor torch.logcumsumexp(self : Tensor, dim : str) -> Tensor torch.logcumsumexp(self : Tensor, dim : str, out : Tensor) -> Tensor torch.logcumsumexp(self : Tensor, dim : int, out : Tensor) -> Tensor torch.logdet(self : Tensor) -> Tensor torch.logical_and(self : Tensor, other : Tensor) -> Tensor torch.logical_and(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.logical_not(self : Tensor) -> Tensor torch.logical_not(self : Tensor, out : Tensor) -> Tensor torch.logical_or(self : Tensor, other : Tensor) -> Tensor torch.logical_or(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.logical_xor(self : Tensor, other : Tensor) -> Tensor torch.logical_xor(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.logit(self : Tensor, eps : Optional[float]) -> Tensor torch.logit(self : Tensor, eps : Optional[float], out : Tensor) -> Tensor torch.logit_(self : Tensor, eps : Optional[float]) -> Tensor torch.logspace(start : Tensor, end : Tensor, steps : int, base : float=10.0, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.logspace(start : Tensor, end : number, steps : int, base : float=10.0, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.logspace(start : number, end : Tensor, steps : int, 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, 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, base : float=10.0, out : Tensor) -> Tensor torch.logspace(start : Tensor, end : Tensor, steps : int, base : float=10.0, out : Tensor) -> Tensor torch.logspace(start : Tensor, end : number, steps : int, base : float=10.0, out : Tensor) -> Tensor torch.logspace(start : number, end : Tensor, steps : int, base : float=10.0, out : Tensor) -> Tensor torch.logsumexp(self : Tensor, dim : List[int], keepdim : bool=False) -> Tensor torch.logsumexp(self : Tensor, dim : List[str], keepdim : bool=False) -> Tensor torch.logsumexp(self : Tensor, dim : List[str], keepdim : bool=False, out : Tensor) -> Tensor torch.logsumexp(self : Tensor, dim : List[int], keepdim : bool=False, out : 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(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_cell(input : Tensor, hx : List[Tensor], w_ih : Tensor, w_hh : Tensor, b_ih : Optional[Tensor], b_hh : Optional[Tensor]) -> Tuple[Tensor, Tensor] torch.lt(self : Tensor, other : Tensor) -> Tensor torch.lt(self : Tensor, other : number) -> Tensor torch.lt(self : Tensor, other : number, out : Tensor) -> Tensor torch.lt(self : Tensor, other : Tensor, out : Tensor) -> 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.lu_unpack(LU_data : Tensor, LU_pivots : Tensor, unpack_data : bool=True, unpack_pivots : bool=True) -> Tuple[Tensor, Tensor, Tensor] torch.lu_unpack(LU_data : Tensor, LU_pivots : Tensor, unpack_data : bool=True, unpack_pivots : bool=True, P : Tensor, L : Tensor, U : Tensor) -> Tuple[Tensor, Tensor, Tensor] torch.manual_seed(seed : int) -> Tuple[] torch.manual_seed(self : Generator, seed : int) -> Generator 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 : number) -> Tensor torch.masked_fill(self : Tensor, mask : Tensor, value : Tensor) -> Tensor torch.masked_fill(self : Tensor, mask : Tensor, value : number, out : Tensor) -> Tensor torch.masked_fill(self : Tensor, mask : Tensor, value : Tensor, out : Tensor) -> Tensor torch.masked_scatter(self : Tensor, mask : Tensor, source : Tensor) -> Tensor torch.masked_scatter(self : Tensor, mask : Tensor, source : Tensor, out : Tensor) -> Tensor torch.masked_select(self : Tensor, mask : Tensor) -> Tensor torch.masked_select(self : Tensor, mask : Tensor, out : Tensor) -> Tensor torch.matmul(self : Tensor, other : Tensor) -> Tensor torch.matmul(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.matrix_exp(self : Tensor) -> Tensor torch.matrix_power(self : Tensor, n : int) -> Tensor torch.matrix_power(self : Tensor, n : int, out : Tensor) -> Tensor torch.max(self : Tensor, other : Tensor) -> Tensor torch.max(self : Tensor) -> Tensor torch.max(self : Tensor, dim : int, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.max(self : Tensor, dim : int, keepdim : bool=False, max : Tensor, max_values : Tensor) -> Tuple[Tensor, Tensor] torch.max(self : Tensor, dim : str, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.max(self : Tensor, dim : str, keepdim : bool=False, max : Tensor, max_values : Tensor) -> Tuple[Tensor, Tensor] torch.max(self : Tensor, out : Tensor) -> Tensor torch.max(self : Tensor, other : Tensor, out : 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.maximum(self : Tensor, other : Tensor) -> Tensor torch.maximum(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.mean(self : Tensor, dtype : Optional[int]) -> Tensor torch.mean(self : Tensor, dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int]) -> Tensor torch.mean(self : Tensor, dim : List[str], keepdim : bool=False, dtype : Optional[int]) -> Tensor torch.mean(self : Tensor, dim : List[str], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor torch.mean(self : Tensor, dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor torch.mean(self : Tensor, dtype : Optional[int], out : Tensor) -> Tensor torch.median(self : Tensor) -> Tensor torch.median(self : Tensor, dim : int, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.median(self : Tensor, dim : int, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.median(self : Tensor, dim : str, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.median(self : Tensor, dim : str, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.median(self : Tensor, out : Tensor) -> Tensor torch.meshgrid(tensors : List[Tensor]) -> List[Tensor] torch.meshgrid(tensors : List[Tensor], indexing : str) -> List[Tensor] torch.min(self : Tensor, other : Tensor) -> Tensor torch.min(self : Tensor) -> Tensor torch.min(self : Tensor, dim : int, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.min(self : Tensor, dim : int, keepdim : bool=False, min : Tensor, min_indices : Tensor) -> Tuple[Tensor, Tensor] torch.min(self : Tensor, dim : str, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.min(self : Tensor, dim : str, keepdim : bool=False, min : Tensor, min_indices : Tensor) -> Tuple[Tensor, Tensor] torch.min(self : Tensor, out : Tensor) -> Tensor torch.min(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.minimum(self : Tensor, other : Tensor) -> Tensor torch.minimum(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_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, out0 : Tensor, out1 : Tensor, out2 : Tensor) -> 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, out : 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_add_relu(self : Tensor, weight : Tensor, z : Tensor, alpha : Optional[number], bias : Optional[Tensor], stride : List[int], padding : List[int], dilation : List[int], groups : int) -> Tensor torch.miopen_convolution_relu(self : Tensor, weight : Tensor, bias : Optional[Tensor], stride : List[int], padding : List[int], dilation : List[int], groups : int) -> 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, out : Tensor) -> 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, out : Tensor) -> 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], out0 : Tensor, out1 : Tensor, out2 : Tensor, out3 : Tensor, out4 : Tensor) -> Tuple[Tensor, Tensor, Tensor, Tensor, 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], out : 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(self : Tensor, weight : Tensor, bias : Optional[Tensor], padding : List[int], stride : List[int], dilation : List[int], groups : int, out : Tensor) -> Tensor torch.mkldnn_linear_backward_weights(grad_output : Tensor, input : Tensor, weight : Tensor, bias_defined : bool, out0 : Tensor, out1 : Tensor) -> Tuple[Tensor, Tensor] torch.mkldnn_linear_backward_weights(grad_output : Tensor, input : Tensor, weight : Tensor, 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, out : 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.mkldnn_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, out : Tensor) -> Tensor torch.mkldnn_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.mkldnn_rnn_layer(input : Tensor, weight0 : Tensor, weight1 : Tensor, weight2 : Tensor, weight3 : Tensor, hx_ : Tensor, cx_ : Tensor, reverse : bool, batch_sizes : List[int], mode : int, hidden_size : int, num_layers : int, has_biases : bool, bidirectional : bool, batch_first : bool, train : bool) -> Tuple[Tensor, Tensor, Tensor, Tensor] torch.mkldnn_rnn_layer(input : Tensor, weight0 : Tensor, weight1 : Tensor, weight2 : Tensor, weight3 : Tensor, hx_ : Tensor, cx_ : Tensor, reverse : bool, batch_sizes : List[int], mode : int, hidden_size : int, num_layers : int, has_biases : bool, bidirectional : bool, batch_first : bool, train : bool, out0 : Tensor, out1 : Tensor, out2 : Tensor, out3 : Tensor) -> Tuple[Tensor, Tensor, Tensor, Tensor] torch.mm(self : Tensor, mat2 : Tensor) -> Tensor torch.mm(self : Tensor, mat2 : Tensor, out : Tensor) -> Tensor torch.mode(self : Tensor, dim : int=-1, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.mode(self : Tensor, dim : str, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.mode(self : Tensor, dim : str, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.mode(self : Tensor, dim : int=-1, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.moveaxis(self : Tensor, source : List[int], destination : List[int]) -> Tensor torch.moveaxis(self : Tensor, source : int, destination : int) -> Tensor torch.movedim(self : Tensor, source : int, destination : int) -> Tensor torch.movedim(self : Tensor, source : List[int], destination : List[int]) -> Tensor torch.msort(self : Tensor) -> Tensor torch.msort(self : Tensor, out : 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(self : Tensor, other : number, out : Tensor) -> 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 : complex, b : complex) -> complex torch.mul(a : float, b : float) -> float torch.mul(a : int, b : complex) -> complex torch.mul(a : complex, b : int) -> complex torch.mul(a : float, b : complex) -> complex torch.mul(a : complex, b : float) -> complex 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.multiply(self : Tensor, other : Tensor) -> Tensor torch.multiply(self : Tensor, other : number) -> Tensor torch.multiply(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.mv(self : Tensor, vec : Tensor) -> Tensor torch.mv(self : Tensor, vec : Tensor, out : Tensor) -> Tensor torch.mvlgamma(self : Tensor, p : int) -> Tensor torch.mvlgamma(self : Tensor, p : int, out : Tensor) -> Tensor torch.nan_to_num(self : Tensor, nan : Optional[float], posinf : Optional[float], neginf : Optional[float]) -> Tensor torch.nan_to_num(self : Tensor, nan : Optional[float], posinf : Optional[float], neginf : Optional[float], out : Tensor) -> Tensor torch.nan_to_num_(self : Tensor, nan : Optional[float], posinf : Optional[float], neginf : Optional[float]) -> Tensor torch.nanmean(self : Tensor, dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int]) -> Tensor torch.nanmean(self : Tensor, dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor torch.nanmedian(self : Tensor) -> Tensor torch.nanmedian(self : Tensor, dim : int, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.nanmedian(self : Tensor, dim : int, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.nanmedian(self : Tensor, dim : str, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.nanmedian(self : Tensor, dim : str, keepdim : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.nanmedian(self : Tensor, out : Tensor) -> Tensor torch.nanquantile(self : Tensor, q : Tensor, dim : Optional[int], keepdim : bool=False, interpolation : str=linear) -> Tensor torch.nanquantile(self : Tensor, q : float, dim : Optional[int], keepdim : bool=False, interpolation : str=linear) -> Tensor torch.nanquantile(self : Tensor, q : Tensor, dim : Optional[int], keepdim : bool=False, interpolation : str=linear, out : Tensor) -> Tensor torch.nanquantile(self : Tensor, q : float, dim : Optional[int], keepdim : bool=False, interpolation : str=linear, out : Tensor) -> Tensor torch.nansum(self : Tensor, dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int]) -> Tensor torch.nansum(self : Tensor, dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor torch.narrow(self : Tensor, dim : int, start : int, length : int) -> Tensor torch.narrow(self : Tensor, dim : int, start : Tensor, length : int) -> Tensor torch.narrow_copy(self : Tensor, dim : int, start : int, length : int) -> Tensor torch.narrow_copy(self : Tensor, dim : int, start : int, length : int, out : Tensor) -> 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_batch_norm(input : Tensor, weight : Optional[Tensor], bias : Optional[Tensor], running_mean : Optional[Tensor], running_var : Optional[Tensor], training : bool, momentum : float, eps : float, out : Tensor, save_mean : Tensor, save_invstd : Tensor) -> Tuple[Tensor, Tensor, Tensor] torch.native_channel_shuffle(self : Tensor, groups : int) -> Tensor torch.native_dropout(input : Tensor, p : float, train : Optional[bool]) -> Tuple[Tensor, Tensor] torch.native_dropout(input : Tensor, p : float, train : Optional[bool], out0 : Tensor, out1 : Tensor) -> Tuple[Tensor, Tensor] torch.native_group_norm(input : Tensor, weight : Optional[Tensor], bias : Optional[Tensor], N : int, C : int, HxW : int, group : int, eps : float) -> Tuple[Tensor, Tensor, Tensor] torch.native_group_norm(input : Tensor, weight : Optional[Tensor], bias : Optional[Tensor], N : int, C : int, HxW : int, group : int, eps : float, out0 : Tensor, out1 : Tensor, out2 : Tensor) -> Tuple[Tensor, Tensor, Tensor] torch.native_layer_norm(input : Tensor, normalized_shape : List[int], weight : Optional[Tensor], bias : Optional[Tensor], eps : float) -> Tuple[Tensor, Tensor, Tensor] torch.native_layer_norm(input : Tensor, normalized_shape : List[int], weight : Optional[Tensor], bias : Optional[Tensor], eps : float, out0 : Tensor, out1 : Tensor, out2 : Tensor) -> Tuple[Tensor, Tensor, Tensor] torch.native_norm(self : Tensor, p : number=2, out : Tensor) -> Tensor torch.native_norm(self : Tensor, p : Optional[number], dim : List[int], keepdim : bool, dtype : Optional[int], out : Tensor) -> Tensor torch.native_norm(self : Tensor, p : number=2) -> Tensor torch.native_norm(self : Tensor, p : Optional[number], dim : List[int], keepdim : bool, dtype : Optional[int]) -> Tensor torch.ne(self : Tensor, other : Tensor) -> Tensor torch.ne(self : Tensor, other : number) -> Tensor torch.ne(self : Tensor, other : number, out : Tensor) -> Tensor torch.ne(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.ne(a : List[int], b : List[int]) -> bool torch.ne(a : Device, b : Device) -> bool torch.ne(a : bool, b : bool) -> bool torch.ne(a : AnyEnumType, b : AnyEnumType) -> bool torch.ne(a : int, b : int) -> bool torch.ne(a : complex, b : complex) -> 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 : float, b : complex) -> bool torch.ne(a : complex, b : float) -> bool torch.ne(a : number, b : number) -> bool torch.ne(a : str, b : str) -> 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 : List[str], b : List[str]) -> bool torch.neg(self : Tensor) -> Tensor torch.neg(self : Tensor, out : Tensor) -> Tensor torch.neg(a : int) -> int torch.neg(a : float) -> float torch.neg(a : complex) -> complex torch.neg(a : number) -> number torch.neg_(self : Tensor) -> Tensor torch.negative(self : Tensor) -> Tensor torch.negative(self : Tensor, out : Tensor) -> Tensor torch.negative_(self : Tensor) -> Tensor torch.nextafter(self : Tensor, other : Tensor) -> Tensor torch.nextafter(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.nonzero(self : Tensor) -> Tensor torch.nonzero(self : Tensor, out : Tensor) -> Tensor torch.nonzero_static(self : Tensor, size : int, fill_value : int=-1) -> Tensor torch.nonzero_static(self : Tensor, size : int, fill_value : int=-1, out : Tensor) -> Tensor torch.norm_except_dim(v : Tensor, pow : int=2, dim : int=0) -> Tensor torch.normal(mean : Tensor, std : float=1.0, generator : Optional[Generator]) -> Tensor torch.normal(mean : Tensor, std : float=1.0, generator : Optional[Generator], out : Tensor) -> Tensor torch.normal(mean : float, std : Tensor, generator : Optional[Generator], out : Tensor) -> Tensor torch.normal(mean : float, std : Tensor, generator : Optional[Generator]) -> Tensor torch.normal(mean : Tensor, std : Tensor, generator : Optional[Generator]) -> Tensor torch.normal(mean : Tensor, std : Tensor, generator : Optional[Generator], out : Tensor) -> 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 : float, std : float, size : List[int], generator : Optional[Generator], out : Tensor) -> Tensor torch.normal(self : Tensor, mean : float=0.0, std : float=1.0, generator : Optional[Generator], out : Tensor) -> Tensor torch.not_equal(self : Tensor, other : Tensor) -> Tensor torch.not_equal(self : Tensor, other : number) -> Tensor torch.not_equal(self : Tensor, other : number, out : Tensor) -> Tensor torch.not_equal(self : Tensor, other : Tensor, 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], names : Optional[List[str]], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.ones(size : List[int], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.ones(size : List[int], names : Optional[List[str]], out : Tensor) -> Tensor torch.ones(size : List[int], out : Tensor) -> Tensor torch.ones_like(self : Tensor, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool], memory_format : Optional[int]) -> Tensor torch.ones_like(self : Tensor, memory_format : Optional[int], out : Tensor) -> 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.outer(self : Tensor, vec2 : Tensor) -> Tensor torch.outer(self : Tensor, vec2 : Tensor, 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.permute(self : Tensor, dims : List[int]) -> Tensor torch.permute_copy(self : Tensor, dims : List[int], out : Tensor) -> Tensor torch.permute_copy(self : Tensor, dims : List[int]) -> Tensor torch.pinverse(self : Tensor, rcond : float=1e-15) -> Tensor torch.pixel_shuffle(self : Tensor, upscale_factor : int) -> Tensor torch.pixel_shuffle(self : Tensor, upscale_factor : int, out : Tensor) -> Tensor torch.pixel_unshuffle(self : Tensor, downscale_factor : int) -> Tensor torch.pixel_unshuffle(self : Tensor, downscale_factor : int, out : Tensor) -> Tensor torch.poisson(self : Tensor, generator : Optional[Generator]) -> Tensor torch.poisson(self : Tensor, generator : Optional[Generator], out : Tensor) -> Tensor torch.poisson_nll_loss(input : Tensor, target : Tensor, log_input : bool, full : bool, eps : float, reduction : int) -> Tensor torch.polar(abs : Tensor, angle : Tensor) -> Tensor torch.polar(abs : Tensor, angle : Tensor, out : Tensor) -> Tensor torch.polar(a : int, b : int) -> complex torch.polar(a : float, b : float) -> complex torch.polar(a : int, b : float) -> complex torch.polar(a : float, b : int) -> complex torch.polar(a : number, b : number) -> number torch.polygamma(n : int, self : Tensor) -> Tensor torch.polygamma(n : int, self : Tensor, out : Tensor) -> Tensor torch.positive(self : Tensor) -> Tensor torch.pow(self : Tensor, exponent : Tensor) -> Tensor torch.pow(self : Tensor, exponent : number) -> Tensor torch.pow(self : number, exponent : Tensor) -> Tensor torch.pow(self : number, exponent : Tensor, out : Tensor) -> Tensor torch.pow(self : Tensor, exponent : number, out : Tensor) -> Tensor torch.pow(self : Tensor, exponent : Tensor, out : Tensor) -> Tensor torch.pow(a : int, b : int) -> float torch.pow(a : complex, b : complex) -> complex torch.pow(a : float, b : float) -> float torch.pow(a : int, b : float) -> float torch.pow(a : float, b : int) -> float torch.pow(a : float, b : complex) -> complex torch.pow(a : complex, b : float) -> complex torch.pow(a : number, b : number) -> float torch.pow(a : int, b : int) -> int torch.prelu(self : Tensor, weight : Tensor) -> Tensor torch.prod(self : Tensor, dtype : Optional[int]) -> Tensor torch.prod(self : Tensor, dim : int, keepdim : bool=False, dtype : Optional[int]) -> Tensor torch.prod(self : Tensor, dim : str, keepdim : bool=False, dtype : Optional[int]) -> Tensor torch.prod(self : Tensor, dim : str, keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor torch.prod(self : Tensor, dim : int, keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor torch.prod(self : Tensor, dtype : Optional[int], out : Tensor) -> Tensor torch.promote_types(type1 : int, type2 : int) -> int torch.put(self : Tensor, index : Tensor, source : Tensor, accumulate : bool=False) -> Tensor torch.put(self : Tensor, index : Tensor, source : Tensor, accumulate : bool=False, out : Tensor) -> Tensor torch.q_per_channel_axis(self : Tensor) -> int torch.q_per_channel_scales(self : Tensor, out : Tensor) -> Tensor torch.q_per_channel_scales(self : Tensor) -> Tensor torch.q_per_channel_zero_points(self : Tensor, out : 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.qr(self : Tensor, some : bool=True, Q : Tensor, R : Tensor) -> Tuple[Tensor, Tensor] torch.qscheme(self : Tensor) -> QScheme torch.quantile(self : Tensor, q : Tensor, dim : Optional[int], keepdim : bool=False, interpolation : str=linear) -> Tensor torch.quantile(self : Tensor, q : float, dim : Optional[int], keepdim : bool=False, interpolation : str=linear) -> Tensor torch.quantile(self : Tensor, q : Tensor, dim : Optional[int], keepdim : bool=False, interpolation : str=linear, out : Tensor) -> Tensor torch.quantile(self : Tensor, q : float, dim : Optional[int], keepdim : bool=False, interpolation : str=linear, out : Tensor) -> Tensor torch.quantize_per_channel(self : Tensor, scales : Tensor, zero_points : Tensor, axis : int, dtype : int) -> Tensor torch.quantize_per_channel(self : Tensor, scales : Tensor, zero_points : Tensor, axis : int, dtype : int, out : Tensor) -> Tensor torch.quantize_per_tensor(self : Tensor, scale : float, zero_point : int, dtype : int) -> Tensor torch.quantize_per_tensor(self : Tensor, scale : Tensor, zero_point : Tensor, dtype : int) -> Tensor torch.quantize_per_tensor(tensors : List[Tensor], scales : Tensor, zero_points : Tensor, dtype : int) -> List[Tensor] torch.quantize_per_tensor(self : Tensor, scale : float, zero_point : int, dtype : int, out : Tensor) -> Tensor torch.quantize_per_tensor(self : Tensor, scale : Tensor, zero_point : Tensor, dtype : int, out : Tensor) -> Tensor torch.quantize_per_tensor(tensors : List[Tensor], scales : Tensor, zero_points : Tensor, dtype : int, out : List[Tensor]) -> Tuple[] torch.quantize_per_tensor_dynamic(self : Tensor, dtype : int, reduce_range : bool) -> Tensor torch.quantize_per_tensor_dynamic(self : Tensor, dtype : int, reduce_range : bool, out : Tensor) -> Tensor torch.quantized_batch_norm(input : Tensor, weight : Optional[Tensor], bias : Optional[Tensor], mean : Tensor, var : Tensor, eps : float, output_scale : float, output_zero_point : int, out : Tensor) -> Tensor torch.quantized_batch_norm(input : Tensor, weight : Optional[Tensor], bias : Optional[Tensor], mean : Tensor, var : Tensor, eps : float, output_scale : float, output_zero_point : int) -> 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_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_pool1d(self : Tensor, kernel_size : List[int], stride : List[int]=[], padding : List[int]=[0], dilation : List[int]=[1], ceil_mode : bool=False, out : Tensor) -> Tensor torch.quantized_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.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, out : 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_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, out : Tensor) -> Tensor torch.quantized_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.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.rad2deg(self : Tensor) -> Tensor torch.rad2deg(self : Tensor, out : Tensor) -> Tensor torch.rad2deg_(self : Tensor) -> 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], generator : Optional[Generator], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.rand(size : List[int], names : Optional[List[str]], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.rand(size : List[int], generator : Optional[Generator], names : Optional[List[str]], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.rand(size : List[int], out : Tensor) -> Tensor torch.rand(size : List[int], generator : Optional[Generator], out : Tensor) -> Tensor torch.rand(size : List[int], names : Optional[List[str]], out : Tensor) -> Tensor torch.rand(size : List[int], generator : Optional[Generator], names : Optional[List[str]], out : Tensor) -> Tensor torch.rand_like(self : Tensor, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool], memory_format : Optional[int]) -> Tensor torch.rand_like(self : Tensor, memory_format : Optional[int], out : Tensor) -> Tensor torch.randint(high : int, size : List[int], dtype : Optional[int]=4, layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.randint(high : int, size : List[int], generator : Optional[Generator], dtype : Optional[int]=4, layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.randint(low : int, high : int, size : List[int], dtype : Optional[int]=4, layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.randint(low : int, high : int, size : List[int], generator : Optional[Generator], dtype : Optional[int]=4, layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.randint(high : int, size : List[int], out : Tensor) -> Tensor torch.randint(high : int, size : List[int], generator : Optional[Generator], out : Tensor) -> Tensor torch.randint(low : int, high : int, size : List[int], out : Tensor) -> Tensor torch.randint(low : int, high : int, size : List[int], generator : Optional[Generator], out : Tensor) -> Tensor torch.randint_like(self : Tensor, high : int, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool], memory_format : Optional[int]) -> Tensor torch.randint_like(self : Tensor, low : int, high : int, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool], memory_format : Optional[int]) -> Tensor torch.randint_like(self : Tensor, high : int, memory_format : Optional[int], out : Tensor) -> Tensor torch.randint_like(self : Tensor, low : int, high : int, memory_format : Optional[int], out : Tensor) -> 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], generator : Optional[Generator], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.randn(size : List[int], names : Optional[List[str]], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.randn(size : List[int], generator : Optional[Generator], names : Optional[List[str]], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.randn(size : List[int], out : Tensor) -> Tensor torch.randn(size : List[int], generator : Optional[Generator], out : Tensor) -> Tensor torch.randn(size : List[int], names : Optional[List[str]], out : Tensor) -> Tensor torch.randn(size : List[int], generator : Optional[Generator], names : Optional[List[str]], out : Tensor) -> Tensor torch.randn_like(self : Tensor, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool], memory_format : Optional[int]) -> Tensor torch.randn_like(self : Tensor, memory_format : Optional[int], out : Tensor) -> Tensor torch.randperm(n : int, dtype : Optional[int]=4, layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.randperm(n : int, generator : Optional[Generator], dtype : Optional[int]=4, layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.randperm(n : int, out : Tensor) -> Tensor torch.randperm(n : int, generator : Optional[Generator], out : Tensor) -> 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, 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.range(start : number, end : number, out : Tensor) -> Tensor torch.ravel(self : Tensor) -> Tensor torch.real(self : 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, out : Tensor) -> Tensor torch.relu_(self : Tensor) -> Tensor torch.remainder(self : Tensor, other : Tensor) -> Tensor torch.remainder(self : Tensor, other : number) -> Tensor torch.remainder(self : number, other : Tensor) -> Tensor torch.remainder(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.remainder(self : Tensor, other : number, out : Tensor) -> Tensor torch.remainder(self : number, other : Tensor, 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) -> Tensor torch.renorm(self : Tensor, p : number, dim : int, maxnorm : number, out : Tensor) -> Tensor torch.repeat_interleave(repeats : Tensor, output_size : Optional[int]) -> Tensor torch.repeat_interleave(self : Tensor, repeats : Tensor, dim : Optional[int], output_size : Optional[int]) -> Tensor torch.repeat_interleave(self : Tensor, repeats : int, dim : Optional[int], output_size : Optional[int]) -> Tensor torch.repeat_interleave(repeats : Tensor, output_size : Optional[int], out : Tensor) -> Tensor torch.reshape(self : Tensor, shape : List[int]) -> Tensor torch.resize_as_(self : Tensor, the_template : Tensor, memory_format : Optional[int]) -> Tensor torch.resize_as_sparse_(self : Tensor, the_template : Tensor) -> Tensor torch.resolve_conj(self : Tensor) -> Tensor torch.resolve_neg(self : Tensor) -> Tensor torch.result_type(tensor : Tensor, other : Tensor) -> int torch.result_type(tensor : Tensor, other : number) -> int torch.result_type(scalar : number, tensor : Tensor) -> int torch.result_type(scalar1 : number, scalar2 : number) -> int torch.rms_norm(input : Tensor, normalized_shape : List[int], weight : Optional[Tensor], eps : Optional[float]) -> 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(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_cell(input : Tensor, hx : Tensor, w_ih : Tensor, w_hh : Tensor, b_ih : Optional[Tensor], b_hh : Optional[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(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_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.roll(self : Tensor, shifts : List[int], dims : List[int]=[], out : Tensor) -> Tensor torch.rot90(self : Tensor, k : int=1, dims : List[int]=[0, 1]) -> Tensor torch.rot90(self : Tensor, k : int=1, dims : List[int]=[0, 1], out : Tensor) -> Tensor torch.round(self : Tensor) -> Tensor torch.round(self : Tensor, decimals : int) -> Tensor torch.round(self : Tensor, out : Tensor) -> Tensor torch.round(self : Tensor, decimals : int, out : Tensor) -> Tensor torch.round(a : int) -> float torch.round(a : float) -> float torch.round(a : number) -> number torch.round_(self : Tensor) -> Tensor torch.round_(self : Tensor, decimals : int) -> Tensor torch.row_indices_copy(self : Tensor, out : Tensor) -> Tensor torch.row_indices_copy(self : Tensor) -> Tensor torch.row_stack(tensors : List[Tensor]) -> Tensor torch.row_stack(tensors : List[Tensor], out : 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) -> Tensor torch.rsqrt(self : Tensor, out : 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.rsub(self : Tensor, other : Tensor, alpha : number=1, out : Tensor) -> Tensor torch.rsub(self : Tensor, other : number, alpha : number=1, out : Tensor) -> 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.scalar_tensor(s : number, out : Tensor) -> Tensor torch.scatter(self : Tensor, dim : int, index : Tensor, value : number) -> Tensor torch.scatter(self : Tensor, dim : int, index : Tensor, src : Tensor) -> Tensor torch.scatter(self : Tensor, dim : int, index : Tensor, src : Tensor, reduce : str) -> Tensor torch.scatter(self : Tensor, dim : int, index : Tensor, value : number, reduce : str) -> Tensor torch.scatter(self : Tensor, dim : int, index : Tensor, src : Tensor, out : Tensor) -> Tensor torch.scatter(self : Tensor, dim : int, index : Tensor, value : number, out : Tensor) -> Tensor torch.scatter(self : Tensor, dim : int, index : Tensor, src : Tensor, reduce : str, out : Tensor) -> Tensor torch.scatter(self : Tensor, dim : int, index : Tensor, value : number, reduce : str, out : Tensor) -> Tensor torch.scatter(self : Tensor, dim : str, index : Tensor, src : Tensor) -> Tensor torch.scatter(self : Tensor, dim : str, index : Tensor, value : number) -> Tensor torch.scatter_add(self : Tensor, dim : int, index : Tensor, src : Tensor) -> Tensor torch.scatter_add(self : Tensor, dim : int, index : Tensor, src : Tensor, out : Tensor) -> Tensor torch.scatter_add(self : Tensor, dim : str, index : Tensor, src : Tensor) -> Tensor torch.scatter_reduce(self : Tensor, dim : int, index : Tensor, src : Tensor, reduce : str, include_self : bool=True) -> Tensor torch.scatter_reduce(self : Tensor, dim : int, index : Tensor, src : Tensor, reduce : str, include_self : bool=True, out : Tensor) -> Tensor torch.searchsorted(sorted_sequence : Tensor, self : Tensor, out_int32 : bool=False, right : bool=False, side : Optional[str], sorter : Optional[Tensor]) -> Tensor torch.searchsorted(sorted_sequence : Tensor, self : Tensor, out_int32 : bool=False, right : bool=False, side : Optional[str], sorter : Optional[Tensor], out : Tensor) -> Tensor torch.searchsorted(sorted_sequence : Tensor, self : number, out_int32 : bool=False, right : bool=False, side : Optional[str], sorter : Optional[Tensor]) -> Tensor torch.searchsorted(sorted_sequence : Tensor, self : number, out_int32 : bool=False, right : bool=False, side : Optional[str], sorter : Optional[Tensor], out : Tensor) -> Tensor torch.seed(self : Generator) -> int torch.segment_reduce(data : Tensor, reduce : str, lengths : Optional[Tensor], indices : Optional[Tensor], offsets : Optional[Tensor], axis : int=0, unsafe : bool=False, initial : Optional[number]) -> Tensor torch.segment_reduce(data : Tensor, reduce : str, lengths : Optional[Tensor], indices : Optional[Tensor], offsets : Optional[Tensor], axis : int=0, unsafe : bool=False, initial : Optional[number], out : Tensor) -> Tensor torch.select(self : Tensor, dim : str, index : int) -> Tensor torch.select(self : Tensor, dim : int, index : int) -> Tensor torch.select(list : List[t], idx : int) -> t torch.select_copy(self : Tensor, dim : int, index : int, out : Tensor) -> Tensor torch.select_copy(self : Tensor, dim : int, index : int) -> Tensor torch.select_scatter(self : Tensor, src : Tensor, dim : int, index : int) -> Tensor torch.select_scatter(self : Tensor, src : Tensor, dim : int, index : int, out : Tensor) -> Tensor torch.selu(self : Tensor) -> Tensor torch.selu_(self : Tensor) -> Tensor torch.set_grad_enabled(val : bool) -> Tuple[] torch.sgn(self : Tensor) -> Tensor torch.sgn(self : Tensor, out : 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.signbit(self : Tensor) -> Tensor torch.signbit(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 : complex) -> complex torch.sin(a : number) -> number torch.sin_(self : Tensor) -> Tensor torch.sinc(self : Tensor) -> Tensor torch.sinc(self : Tensor, out : Tensor) -> Tensor torch.sinc_(self : Tensor) -> Tensor torch.sinh(self : Tensor) -> Tensor torch.sinh(self : Tensor, out : Tensor) -> Tensor torch.sinh(a : int) -> float torch.sinh(a : float) -> float torch.sinh(a : complex) -> complex torch.sinh(a : number) -> number torch.sinh_(self : Tensor) -> Tensor torch.slice_copy(self : Tensor, dim : int=0, start : Optional[int], end : Optional[int], step : int=1, out : Tensor) -> Tensor torch.slice_copy(self : Tensor, dim : int=0, start : Optional[int], end : Optional[int], step : int=1) -> Tensor torch.slice_inverse(self : Tensor, src : Tensor, dim : int=0, start : Optional[int], end : Optional[int], step : int=1) -> Tensor torch.slice_scatter(self : Tensor, src : Tensor, dim : int=0, start : Optional[int], end : Optional[int], step : int=1) -> Tensor torch.slice_scatter(self : Tensor, src : Tensor, dim : int=0, start : Optional[int], end : Optional[int], step : int=1, out : Tensor) -> Tensor torch.slogdet(self : Tensor) -> Tuple[Tensor, Tensor] torch.slogdet(self : Tensor, sign : Tensor, logabsdet : Tensor) -> Tuple[Tensor, Tensor] torch.smm(self : Tensor, mat2 : Tensor) -> Tensor torch.softmax(self : Tensor, dim : int, dtype : Optional[int]) -> Tensor torch.softmax(self : Tensor, dim : str, dtype : Optional[int]) -> Tensor torch.softmax(self : Tensor, dim : int, dtype : Optional[int], out : Tensor) -> Tensor torch.sort(self : Tensor, dim : int=-1, descending : bool=False) -> Tuple[Tensor, Tensor] torch.sort(self : Tensor, stable : Optional[bool], dim : int=-1, descending : bool=False) -> Tuple[Tensor, Tensor] torch.sort(self : Tensor, stable : Optional[bool], dim : int=-1, descending : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.sort(self : Tensor, dim : int=-1, descending : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.sort(self : Tensor, dim : str, descending : bool=False) -> Tuple[Tensor, Tensor] torch.sort(self : Tensor, dim : str, descending : bool=False, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.sort(self : Tensor, stable : Optional[bool], dim : str, descending : bool=False) -> Tuple[Tensor, Tensor] torch.sort(self : Tensor, stable : Optional[bool], dim : str, descending : bool=False, values : Tensor, indices : Tensor) -> 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[str], reverse : bool=False) -> Tuple[] torch.sort(self : List[t], reverse : bool=False) -> Tuple[] torch.sparse_bsc_tensor(ccol_indices : Tensor, row_indices : Tensor, values : Tensor, size : List[int], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]=False) -> Tensor torch.sparse_bsc_tensor(ccol_indices : Tensor, row_indices : Tensor, values : Tensor, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]=False) -> Tensor torch.sparse_bsr_tensor(crow_indices : Tensor, col_indices : Tensor, values : Tensor, size : List[int], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]=False) -> Tensor torch.sparse_bsr_tensor(crow_indices : Tensor, col_indices : Tensor, values : Tensor, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]=False) -> Tensor torch.sparse_compressed_tensor(compressed_indices : Tensor, plain_indices : Tensor, values : Tensor, size : List[int], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]=False) -> Tensor torch.sparse_compressed_tensor(compressed_indices : Tensor, plain_indices : Tensor, values : Tensor, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]=False) -> Tensor torch.sparse_coo_tensor(size : List[int], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]=False) -> Tensor torch.sparse_coo_tensor(indices : Tensor, values : Tensor, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool], is_coalesced : 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], is_coalesced : Optional[bool]) -> Tensor torch.sparse_coo_tensor(size : List[int], out : Tensor) -> Tensor torch.sparse_csc_tensor(ccol_indices : Tensor, row_indices : Tensor, values : Tensor, size : List[int], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]=False) -> Tensor torch.sparse_csc_tensor(ccol_indices : Tensor, row_indices : Tensor, values : Tensor, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]=False) -> Tensor torch.sparse_csr_tensor(crow_indices : Tensor, col_indices : Tensor, values : Tensor, size : List[int], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]=False) -> Tensor torch.sparse_csr_tensor(crow_indices : Tensor, col_indices : Tensor, values : Tensor, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]=False) -> Tensor torch.split(self : Tensor, split_size : int, dim : int=0) -> List[Tensor] torch.split(self : Tensor, split_size : List[int], dim : int=0) -> List[Tensor] torch.split(self : str, separator : Optional[str], max : int=-1) -> List[str] torch.split(self : Tensor, split_sizes : List[int], dim : int=0) -> List[Tensor] torch.split_copy(self : Tensor, split_size : int, dim : int=0, out : List[Tensor]) -> Tuple[] torch.split_copy(self : Tensor, split_size : int, dim : int=0) -> List[Tensor] torch.split_with_sizes(self : Tensor, split_sizes : List[int], dim : int=0) -> List[Tensor] torch.split_with_sizes_copy(self : Tensor, split_sizes : List[int], dim : int=0) -> List[Tensor] torch.split_with_sizes_copy(self : Tensor, split_sizes : List[int], dim : int=0, out : List[Tensor]) -> Tuple[] torch.sqrt(self : Tensor) -> Tensor torch.sqrt(self : Tensor, out : Tensor) -> Tensor torch.sqrt(a : int) -> float torch.sqrt(a : float) -> float torch.sqrt(a : complex) -> complex torch.sqrt(a : number) -> number torch.sqrt_(self : Tensor) -> Tensor torch.square(self : Tensor) -> Tensor torch.square(self : Tensor, out : Tensor) -> Tensor torch.square_(self : Tensor) -> Tensor torch.squeeze(self : Tensor) -> Tensor torch.squeeze(self : Tensor, dim : int) -> Tensor torch.squeeze(self : Tensor, dim : List[int]) -> Tensor torch.squeeze(self : Tensor, dim : str) -> Tensor torch.squeeze_copy(self : Tensor, out : Tensor) -> Tensor torch.squeeze_copy(self : Tensor, dim : int, out : Tensor) -> Tensor torch.squeeze_copy(self : Tensor, dim : List[int], out : Tensor) -> Tensor torch.squeeze_copy(self : Tensor) -> Tensor torch.squeeze_copy(self : Tensor, dim : int) -> Tensor torch.squeeze_copy(self : Tensor, dim : List[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 : Optional[List[int]], unbiased : bool=True, keepdim : bool=False) -> Tensor torch.std(self : Tensor, dim : Optional[List[int]], correction : Optional[number], keepdim : bool=False) -> Tensor torch.std(self : Tensor, dim : List[str], unbiased : bool=True, keepdim : bool=False) -> Tensor torch.std(self : Tensor, dim : List[str], unbiased : bool=True, keepdim : bool=False, out : Tensor) -> Tensor torch.std(self : Tensor, dim : Optional[List[int]], unbiased : bool=True, keepdim : bool=False, out : Tensor) -> Tensor torch.std(self : Tensor, dim : Optional[List[int]], correction : Optional[number], keepdim : bool=False, out : Tensor) -> Tensor torch.std(self : Tensor, dim : List[str], correction : Optional[number], keepdim : bool=False) -> Tensor torch.std(self : Tensor, dim : List[str], correction : Optional[number], keepdim : bool=False, out : Tensor) -> Tensor torch.std_mean(self : Tensor, unbiased : bool=True) -> Tuple[Tensor, Tensor] torch.std_mean(self : Tensor, dim : Optional[List[int]], unbiased : bool=True, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.std_mean(self : Tensor, dim : Optional[List[int]], correction : Optional[number], keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.std_mean(self : Tensor, dim : List[str], unbiased : bool=True, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.std_mean(self : Tensor, dim : List[str], correction : Optional[number], keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.std_mean(self : Tensor, dim : Optional[List[int]], correction : Optional[number], keepdim : bool=False, out0 : Tensor, out1 : Tensor) -> Tuple[Tensor, 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(self : Tensor, other : number, alpha : number=1, out : Tensor) -> Tensor torch.sub(a : int, b : int) -> int torch.sub(a : complex, b : complex) -> complex torch.sub(a : float, b : float) -> float torch.sub(a : int, b : complex) -> complex torch.sub(a : complex, b : int) -> complex torch.sub(a : float, b : complex) -> complex torch.sub(a : complex, b : float) -> complex torch.sub(a : int, b : float) -> float torch.sub(a : float, b : int) -> float torch.sub(a : number, b : number) -> number torch.subtract(self : Tensor, other : Tensor, alpha : number=1) -> Tensor torch.subtract(self : Tensor, other : Tensor, alpha : number=1, out : Tensor) -> Tensor torch.subtract(self : Tensor, other : number, alpha : number=1) -> Tensor torch.sum(self : Tensor, dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int]) -> Tensor torch.sum(self : Tensor, dtype : Optional[int]) -> Tensor torch.sum(self : Tensor, dim : List[str], keepdim : bool=False, dtype : Optional[int]) -> Tensor torch.sum(self : Tensor, dim : List[str], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor torch.sum(self : Tensor, dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor torch.sum(self : Tensor, dtype : Optional[int], out : Tensor) -> Tensor torch.sum(self : List[int]) -> int torch.sum(self : List[float]) -> float torch.sum(self : List[complex]) -> complex torch.sum(self : List[bool]) -> int torch.svd(self : Tensor, some : bool=True, compute_uv : bool=True) -> Tuple[Tensor, Tensor, Tensor] torch.svd(self : Tensor, some : bool=True, compute_uv : bool=True, U : Tensor, S : Tensor, V : Tensor) -> Tuple[Tensor, Tensor, Tensor] torch.swapaxes(self : Tensor, axis0 : int, axis1 : int) -> Tensor torch.swapdims(self : Tensor, dim0 : int, dim1 : int) -> Tensor torch.sym_constrain_range(size : number, min : Optional[int], max : Optional[int]) -> Tuple[] torch.sym_constrain_range_for_size(size : number, min : Optional[int], max : Optional[int]) -> Tuple[] torch.t(self : Tensor) -> Tensor torch.t_copy(self : Tensor, out : Tensor) -> Tensor torch.t_copy(self : Tensor) -> Tensor torch.take(self : Tensor, index : Tensor) -> Tensor torch.take(self : Tensor, index : Tensor, out : Tensor) -> Tensor torch.take_along_dim(self : Tensor, indices : Tensor, dim : Optional[int]) -> Tensor torch.take_along_dim(self : Tensor, indices : Tensor, dim : Optional[int], out : Tensor) -> Tensor torch.tan(self : Tensor) -> Tensor torch.tan(self : Tensor, out : Tensor) -> Tensor torch.tan(a : int) -> float torch.tan(a : float) -> float torch.tan(a : complex) -> complex 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 : complex) -> complex torch.tanh(a : number) -> number torch.tanh_(self : Tensor) -> Tensor torch.tensor(t : bool, dtype : Optional[int], device : Optional[Device], requires_grad : bool=False) -> 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 : complex, 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.tensor_split(self : Tensor, sections : int, dim : int=0) -> List[Tensor] torch.tensor_split(self : Tensor, indices : List[int], dim : int=0) -> List[Tensor] torch.tensor_split(self : Tensor, tensor_indices_or_sections : Tensor, dim : int=0) -> List[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.tile(self : Tensor, dims : List[int]) -> Tensor torch.topk(self : Tensor, k : int, dim : int=-1, largest : bool=True, sorted : bool=True) -> Tuple[Tensor, Tensor] torch.topk(self : Tensor, k : int, dim : int=-1, largest : bool=True, sorted : bool=True, values : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch.trace(self : Tensor) -> Tensor torch.trace(self : Tensor, out : Tensor) -> Tensor torch.transpose(self : Tensor, dim0 : int, dim1 : int) -> Tensor torch.transpose(self : Tensor, dim0 : str, dim1 : str) -> Tensor torch.transpose_copy(self : Tensor, dim0 : int, dim1 : int, out : Tensor) -> Tensor torch.transpose_copy(self : Tensor, dim0 : int, dim1 : int) -> Tensor torch.trapezoid(y : Tensor, x : Tensor, dim : int=-1) -> Tensor torch.trapezoid(y : Tensor, dx : number=1, dim : int=-1) -> 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.triangular_solve(self : Tensor, A : Tensor, upper : bool=True, transpose : bool=False, unitriangular : bool=False, X : Tensor, M : Tensor) -> Tuple[Tensor, Tensor] torch.tril(self : Tensor, diagonal : int=0) -> Tensor torch.tril(self : Tensor, diagonal : int=0, out : Tensor) -> 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.tril_indices(row : int, col : int, offset : int=0, out : Tensor) -> 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) -> Tensor torch.triu(self : Tensor, diagonal : int=0, out : Tensor) -> 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.triu_indices(row : int, col : int, offset : int=0, out : Tensor) -> Tensor torch.true_divide(self : Tensor, other : Tensor) -> Tensor torch.true_divide(self : Tensor, other : number) -> Tensor torch.true_divide(self : Tensor, other : Tensor, out : Tensor) -> 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.unbind(self : Tensor, dim : str) -> List[Tensor] torch.unbind_copy(self : Tensor, dim : int=0, out : List[Tensor]) -> Tuple[] torch.unbind_copy(self : Tensor, dim : int=0) -> List[Tensor] torch.unflatten(self : Tensor, dim : int, sizes : List[int]) -> Tensor torch.unflatten(self : Tensor, dim : str, sizes : List[int], names : List[str]) -> Tensor torch.unfold_copy(self : Tensor, dimension : int, size : int, step : int) -> Tensor torch.unfold_copy(self : Tensor, dimension : int, size : int, step : int, out : Tensor) -> Tensor torch.unsafe_chunk(self : Tensor, chunks : int, dim : int=0) -> List[Tensor] torch.unsafe_split(self : Tensor, split_size : int, dim : int=0) -> List[Tensor] torch.unsafe_split(self : Tensor, split_size : int, dim : int=0, out : List[Tensor]) -> Tuple[] torch.unsafe_split_with_sizes(self : Tensor, split_sizes : List[int], dim : int=0) -> List[Tensor] torch.unsafe_split_with_sizes(self : Tensor, split_sizes : List[int], dim : int=0, out : List[Tensor]) -> Tuple[] torch.unsqueeze(self : Tensor, dim : int) -> Tensor torch.unsqueeze_copy(self : Tensor, dim : int, out : Tensor) -> Tensor torch.unsqueeze_copy(self : Tensor, dim : int) -> Tensor torch.values_copy(self : Tensor, out : Tensor) -> Tensor torch.values_copy(self : Tensor) -> Tensor torch.vander(x : Tensor, N : Optional[int], increasing : bool=False) -> Tensor torch.var(self : Tensor, unbiased : bool=True) -> Tensor torch.var(self : Tensor, dim : Optional[List[int]], unbiased : bool=True, keepdim : bool=False) -> Tensor torch.var(self : Tensor, dim : Optional[List[int]], correction : Optional[number], keepdim : bool=False) -> Tensor torch.var(self : Tensor, dim : List[str], unbiased : bool=True, keepdim : bool=False) -> Tensor torch.var(self : Tensor, dim : List[str], unbiased : bool=True, keepdim : bool=False, out : Tensor) -> Tensor torch.var(self : Tensor, dim : Optional[List[int]], unbiased : bool=True, keepdim : bool=False, out : Tensor) -> Tensor torch.var(self : Tensor, dim : Optional[List[int]], correction : Optional[number], keepdim : bool=False, out : Tensor) -> Tensor torch.var(self : Tensor, dim : List[str], correction : Optional[number], keepdim : bool=False) -> Tensor torch.var(self : Tensor, dim : List[str], correction : Optional[number], keepdim : bool=False, out : Tensor) -> Tensor torch.var_mean(self : Tensor, unbiased : bool=True) -> Tuple[Tensor, Tensor] torch.var_mean(self : Tensor, dim : Optional[List[int]], unbiased : bool=True, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.var_mean(self : Tensor, dim : Optional[List[int]], correction : Optional[number], keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.var_mean(self : Tensor, dim : List[str], unbiased : bool=True, keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.var_mean(self : Tensor, dim : List[str], correction : Optional[number], keepdim : bool=False) -> Tuple[Tensor, Tensor] torch.var_mean(self : Tensor, dim : Optional[List[int]], correction : Optional[number], keepdim : bool=False, out0 : Tensor, out1 : Tensor) -> Tuple[Tensor, Tensor] torch.vdot(self : Tensor, other : Tensor) -> Tensor torch.vdot(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.view_as_complex(self : Tensor) -> Tensor torch.view_as_complex_copy(self : Tensor, out : Tensor) -> Tensor torch.view_as_complex_copy(self : Tensor) -> Tensor torch.view_as_real(self : Tensor) -> Tensor torch.view_as_real_copy(self : Tensor, out : Tensor) -> Tensor torch.view_as_real_copy(self : Tensor) -> Tensor torch.view_copy(self : Tensor, size : List[int]) -> Tensor torch.view_copy(self : Tensor, size : List[int], out : Tensor) -> Tensor torch.view_copy(self : Tensor, dtype : int, out : Tensor) -> Tensor torch.view_copy(self : Tensor, dtype : int) -> Tensor torch.vsplit(self : Tensor, sections : int) -> List[Tensor] torch.vsplit(self : Tensor, indices : List[int]) -> List[Tensor] torch.vstack(tensors : List[Tensor]) -> Tensor torch.vstack(tensors : List[Tensor], out : Tensor) -> Tensor torch.wait(self : Future[t]) -> t torch.where(condition : Tensor, self : Tensor, other : Tensor) -> Tensor torch.where(condition : Tensor, self : Tensor, other : number) -> Tensor torch.where(condition : Tensor, self : number, other : Tensor) -> Tensor torch.where(condition : Tensor, self : number, other : number) -> Tensor torch.where(condition : Tensor) -> List[Tensor] torch.where(condition : Tensor, self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.xlogy(self : Tensor, other : Tensor) -> Tensor torch.xlogy(self : Tensor, other : number) -> Tensor torch.xlogy(self : number, other : Tensor) -> Tensor torch.xlogy(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch.xlogy(self : number, other : Tensor, out : Tensor) -> Tensor torch.xlogy(self : Tensor, other : number, out : Tensor) -> Tensor torch.xlogy_(self : Tensor, other : Tensor) -> Tensor torch.xlogy_(self : Tensor, other : number) -> Tensor torch.zero_(self : Tensor) -> Tensor torch.zeros(size : List[int], names : Optional[List[str]], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.zeros(size : List[int], dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch.zeros(size : List[int], names : Optional[List[str]], out : Tensor) -> Tensor torch.zeros(size : List[int], out : Tensor) -> Tensor torch.zeros_like(self : Tensor, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool], memory_format : Optional[int]) -> Tensor torch.zeros_like(self : Tensor, memory_format : Optional[int], out : Tensor) -> Tensor torch._C._nn.adaptive_avg_pool2d(self : Tensor, output_size : List[int]) -> Tensor torch._C._nn.adaptive_avg_pool2d(self : Tensor, output_size : List[int], out : Tensor) -> 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_pool2d(self : Tensor, output_size : List[int], out : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch._C._nn.adaptive_max_pool3d(self : Tensor, output_size : List[int]) -> Tuple[Tensor, Tensor] torch._C._nn.adaptive_max_pool3d(self : Tensor, output_size : List[int], out : Tensor, indices : Tensor) -> 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) -> Tensor torch._C._nn.binary_cross_entropy(self : Tensor, target : Tensor, weight : Optional[Tensor], reduction : int=1, out : Tensor) -> 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.conv_depthwise3d(self : Tensor, weight : Tensor, kernel_size : List[int], bias : Optional[Tensor], stride : List[int], padding : List[int], dilation : List[int], out : Tensor) -> Tensor torch._C._nn.conv_depthwise3d(self : Tensor, weight : Tensor, kernel_size : List[int], bias : Optional[Tensor], stride : List[int], padding : List[int], dilation : List[int]) -> Tensor torch._C._nn.cross_entropy_loss(self : Tensor, target : Tensor, weight : Optional[Tensor], reduction : int=1, ignore_index : int=-100, label_smoothing : float=0.0) -> 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, out : Tensor) -> Tensor torch._C._nn.elu_(self : Tensor, alpha : number=1, scale : number=1, input_scale : number=1) -> Tensor torch._C._nn.flatten_dense_tensors(tensors : List[Tensor]) -> 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_pool2d(self : Tensor, kernel_size : List[int], output_size : List[int], random_samples : Tensor, output : Tensor, indices : 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.fractional_max_pool3d(self : Tensor, kernel_size : List[int], output_size : List[int], random_samples : Tensor, output : Tensor, indices : Tensor) -> Tuple[Tensor, Tensor] torch._C._nn.gelu(self : Tensor, approximate : str=none) -> Tensor torch._C._nn.gelu(self : Tensor, approximate : str=none, out : Tensor) -> Tensor torch._C._nn.gelu_(self : Tensor, approximate : str=none) -> 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.hardsigmoid(self : Tensor) -> Tensor torch._C._nn.hardsigmoid(self : Tensor, out : Tensor) -> Tensor torch._C._nn.hardsigmoid_(self : Tensor) -> Tensor torch._C._nn.hardswish(self : Tensor) -> Tensor torch._C._nn.hardswish(self : Tensor, out : Tensor) -> Tensor torch._C._nn.hardswish_(self : 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, out : Tensor) -> Tensor torch._C._nn.hardtanh_(self : Tensor, min_val : number=-1, max_val : number=1) -> Tensor torch._C._nn.huber_loss(self : Tensor, target : Tensor, reduction : int=1, delta : float=1.0) -> Tensor torch._C._nn.huber_loss(self : Tensor, target : Tensor, reduction : int=1, delta : float=1.0, out : Tensor) -> 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) -> 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.linear(input : Tensor, weight : Tensor, bias : Optional[Tensor], out : 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_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, out : Tensor, indices : Tensor) -> 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_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, out : Tensor, indices : Tensor) -> 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]) -> 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.mish(self : Tensor) -> Tensor torch._C._nn.mish(self : Tensor, out : Tensor) -> Tensor torch._C._nn.mish_(self : Tensor) -> Tensor torch._C._nn.mkldnn_linear(self : Tensor, weight : Tensor, bias : Optional[Tensor], out : Tensor) -> Tensor torch._C._nn.mkldnn_linear(self : 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, input_size : Optional[List[int]], out : 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, input_size : Optional[List[int]]) -> Tensor torch._C._nn.mkldnn_reorder_conv3d_weight(self : Tensor, padding : List[int]=[0, 0, 0], stride : List[int]=[1, 1, 1], dilation : List[int]=[1, 1, 1], groups : int=1, input_size : Optional[List[int]], out : Tensor) -> Tensor torch._C._nn.mkldnn_reorder_conv3d_weight(self : Tensor, padding : List[int]=[0, 0, 0], stride : List[int]=[1, 1, 1], dilation : List[int]=[1, 1, 1], groups : int=1, input_size : Optional[List[int]]) -> Tensor torch._C._nn.mse_loss(self : Tensor, target : Tensor, reduction : int=1) -> Tensor torch._C._nn.mse_loss(self : Tensor, target : 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.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.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.nll_loss_nd(self : Tensor, target : Tensor, weight : Optional[Tensor], reduction : int=1, ignore_index : int=-100) -> Tensor torch._C._nn.one_hot(self : Tensor, num_classes : int=-1) -> Tensor torch._C._nn.pad(self : Tensor, pad : List[int], mode : str=constant, value : Optional[float]) -> Tensor torch._C._nn.pad_sequence(sequences : List[Tensor], batch_first : bool=False, padding_value : float=0.0, padding_side : str=right) -> 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.reflection_pad3d(self : Tensor, padding : List[int]) -> Tensor torch._C._nn.reflection_pad3d(self : Tensor, padding : List[int], out : Tensor) -> Tensor torch._C._nn.relu6(self : Tensor) -> Tensor torch._C._nn.relu6_(self : 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]) -> Tensor torch._C._nn.replication_pad3d(self : Tensor, padding : List[int], 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], 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.scaled_dot_product_attention(query : Tensor, key : Tensor, value : Tensor, attn_mask : Optional[Tensor], dropout_p : float=0.0, is_causal : bool=False, scale : Optional[float], enable_gqa : bool=False) -> Tensor torch._C._nn.silu(self : Tensor) -> Tensor torch._C._nn.silu(self : Tensor, out : Tensor) -> Tensor torch._C._nn.silu_(self : Tensor) -> 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_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], out : Tensor) -> 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_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], 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_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_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, beta : float=1.0) -> Tensor torch._C._nn.smooth_l1_loss(self : Tensor, target : Tensor, reduction : int=1, beta : float=1.0, out : Tensor) -> Tensor torch._C._nn.soft_margin_loss(self : Tensor, target : Tensor, reduction : int=1) -> Tensor torch._C._nn.soft_margin_loss(self : Tensor, target : Tensor, reduction : int=1, out : Tensor) -> Tensor torch._C._nn.softplus(self : Tensor, beta : number=1, threshold : number=20) -> Tensor torch._C._nn.softplus(self : Tensor, beta : number=1, threshold : number=20, out : Tensor) -> 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.unflatten_dense_tensors(flat : Tensor, tensors : List[Tensor]) -> List[Tensor] torch._C._nn.upsample_bicubic2d(self : Tensor, output_size : List[int], align_corners : bool, scales_h : Optional[float], scales_w : Optional[float]) -> Tensor torch._C._nn.upsample_bicubic2d(input : Tensor, output_size : Optional[List[int]], align_corners : bool, scale_factors : Optional[List[float]]) -> Tensor torch._C._nn.upsample_bicubic2d(self : Tensor, output_size : List[int], align_corners : bool, scales_h : Optional[float], scales_w : Optional[float], out : Tensor) -> Tensor torch._C._nn.upsample_bilinear2d(self : Tensor, output_size : List[int], align_corners : bool, scales_h : Optional[float], scales_w : Optional[float]) -> Tensor torch._C._nn.upsample_bilinear2d(input : Tensor, output_size : Optional[List[int]], align_corners : bool, scale_factors : Optional[List[float]]) -> Tensor torch._C._nn.upsample_bilinear2d(self : Tensor, output_size : List[int], align_corners : bool, scales_h : Optional[float], scales_w : Optional[float], out : Tensor) -> Tensor torch._C._nn.upsample_linear1d(self : Tensor, output_size : List[int], align_corners : bool, scales : Optional[float]) -> Tensor torch._C._nn.upsample_linear1d(input : Tensor, output_size : Optional[List[int]], align_corners : bool, scale_factors : Optional[List[float]]) -> Tensor torch._C._nn.upsample_linear1d(self : Tensor, output_size : List[int], align_corners : bool, scales : Optional[float], out : Tensor) -> Tensor torch._C._nn.upsample_nearest1d(self : Tensor, output_size : List[int], scales : Optional[float]) -> Tensor torch._C._nn.upsample_nearest1d(input : Tensor, output_size : Optional[List[int]], scale_factors : Optional[List[float]]) -> Tensor torch._C._nn.upsample_nearest1d(self : Tensor, output_size : List[int], scales : Optional[float], out : Tensor) -> Tensor torch._C._nn.upsample_nearest2d(self : Tensor, output_size : List[int], scales_h : Optional[float], scales_w : Optional[float]) -> Tensor torch._C._nn.upsample_nearest2d(input : Tensor, output_size : Optional[List[int]], scale_factors : Optional[List[float]]) -> Tensor torch._C._nn.upsample_nearest2d(self : Tensor, output_size : List[int], scales_h : Optional[float], scales_w : Optional[float], out : Tensor) -> Tensor torch._C._nn.upsample_nearest3d(self : Tensor, output_size : List[int], scales_d : Optional[float], scales_h : Optional[float], scales_w : Optional[float]) -> Tensor torch._C._nn.upsample_nearest3d(input : Tensor, output_size : Optional[List[int]], scale_factors : Optional[List[float]]) -> Tensor torch._C._nn.upsample_nearest3d(self : Tensor, output_size : List[int], scales_d : Optional[float], scales_h : Optional[float], scales_w : Optional[float], out : Tensor) -> Tensor torch._C._nn.upsample_trilinear3d(self : Tensor, output_size : List[int], align_corners : bool, scales_d : Optional[float], scales_h : Optional[float], scales_w : Optional[float]) -> Tensor torch._C._nn.upsample_trilinear3d(input : Tensor, output_size : Optional[List[int]], align_corners : bool, scale_factors : Optional[List[float]]) -> Tensor torch._C._nn.upsample_trilinear3d(self : Tensor, output_size : List[int], align_corners : bool, scales_d : Optional[float], scales_h : Optional[float], scales_w : Optional[float], out : Tensor) -> Tensor torch._C._fft.fft_fft(self : Tensor, n : Optional[int], dim : int=-1, norm : Optional[str]) -> Tensor torch._C._fft.fft_fft(self : Tensor, n : Optional[int], dim : int=-1, norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_fft2(self : Tensor, s : Optional[List[int]], dim : List[int]=[-2, -1], norm : Optional[str]) -> Tensor torch._C._fft.fft_fft2(self : Tensor, s : Optional[List[int]], dim : List[int]=[-2, -1], norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_fftfreq(n : int, d : float=1.0, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch._C._fft.fft_fftfreq(n : int, d : float=1.0, out : Tensor) -> Tensor torch._C._fft.fft_fftn(self : Tensor, s : Optional[List[int]], dim : Optional[List[int]], norm : Optional[str]) -> Tensor torch._C._fft.fft_fftn(self : Tensor, s : Optional[List[int]], dim : Optional[List[int]], norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_fftshift(self : Tensor, dim : Optional[List[int]]) -> Tensor torch._C._fft.fft_hfft(self : Tensor, n : Optional[int], dim : int=-1, norm : Optional[str]) -> Tensor torch._C._fft.fft_hfft(self : Tensor, n : Optional[int], dim : int=-1, norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_hfft2(self : Tensor, s : Optional[List[int]], dim : List[int]=[-2, -1], norm : Optional[str]) -> Tensor torch._C._fft.fft_hfft2(self : Tensor, s : Optional[List[int]], dim : List[int]=[-2, -1], norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_hfftn(self : Tensor, s : Optional[List[int]], dim : Optional[List[int]], norm : Optional[str]) -> Tensor torch._C._fft.fft_hfftn(self : Tensor, s : Optional[List[int]], dim : Optional[List[int]], norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_ifft(self : Tensor, n : Optional[int], dim : int=-1, norm : Optional[str]) -> Tensor torch._C._fft.fft_ifft(self : Tensor, n : Optional[int], dim : int=-1, norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_ifft2(self : Tensor, s : Optional[List[int]], dim : List[int]=[-2, -1], norm : Optional[str]) -> Tensor torch._C._fft.fft_ifft2(self : Tensor, s : Optional[List[int]], dim : List[int]=[-2, -1], norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_ifftn(self : Tensor, s : Optional[List[int]], dim : Optional[List[int]], norm : Optional[str]) -> Tensor torch._C._fft.fft_ifftn(self : Tensor, s : Optional[List[int]], dim : Optional[List[int]], norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_ifftshift(self : Tensor, dim : Optional[List[int]]) -> Tensor torch._C._fft.fft_ihfft(self : Tensor, n : Optional[int], dim : int=-1, norm : Optional[str]) -> Tensor torch._C._fft.fft_ihfft(self : Tensor, n : Optional[int], dim : int=-1, norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_ihfft2(self : Tensor, s : Optional[List[int]], dim : List[int]=[-2, -1], norm : Optional[str]) -> Tensor torch._C._fft.fft_ihfft2(self : Tensor, s : Optional[List[int]], dim : List[int]=[-2, -1], norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_ihfftn(self : Tensor, s : Optional[List[int]], dim : Optional[List[int]], norm : Optional[str]) -> Tensor torch._C._fft.fft_ihfftn(self : Tensor, s : Optional[List[int]], dim : Optional[List[int]], norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_irfft(self : Tensor, n : Optional[int], dim : int=-1, norm : Optional[str]) -> Tensor torch._C._fft.fft_irfft(self : Tensor, n : Optional[int], dim : int=-1, norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_irfft2(self : Tensor, s : Optional[List[int]], dim : List[int]=[-2, -1], norm : Optional[str]) -> Tensor torch._C._fft.fft_irfft2(self : Tensor, s : Optional[List[int]], dim : List[int]=[-2, -1], norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_irfftn(self : Tensor, s : Optional[List[int]], dim : Optional[List[int]], norm : Optional[str]) -> Tensor torch._C._fft.fft_irfftn(self : Tensor, s : Optional[List[int]], dim : Optional[List[int]], norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_rfft(self : Tensor, n : Optional[int], dim : int=-1, norm : Optional[str]) -> Tensor torch._C._fft.fft_rfft(self : Tensor, n : Optional[int], dim : int=-1, norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_rfft2(self : Tensor, s : Optional[List[int]], dim : List[int]=[-2, -1], norm : Optional[str]) -> Tensor torch._C._fft.fft_rfft2(self : Tensor, s : Optional[List[int]], dim : List[int]=[-2, -1], norm : Optional[str], out : Tensor) -> Tensor torch._C._fft.fft_rfftfreq(n : int, d : float=1.0, dtype : Optional[int], layout : Optional[int], device : Optional[Device], pin_memory : Optional[bool]) -> Tensor torch._C._fft.fft_rfftfreq(n : int, d : float=1.0, out : Tensor) -> Tensor torch._C._fft.fft_rfftn(self : Tensor, s : Optional[List[int]], dim : Optional[List[int]], norm : Optional[str]) -> Tensor torch._C._fft.fft_rfftn(self : Tensor, s : Optional[List[int]], dim : Optional[List[int]], norm : Optional[str], out : Tensor) -> Tensor torch._C._linalg.linalg_cholesky(self : Tensor, upper : bool=False) -> Tensor torch._C._linalg.linalg_cholesky(self : Tensor, upper : bool=False, out : Tensor) -> Tensor torch._C._linalg.linalg_cholesky_ex(self : Tensor, upper : bool=False, check_errors : bool=False) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_cholesky_ex(self : Tensor, upper : bool=False, check_errors : bool=False, L : Tensor, info : Tensor) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_cond(self : Tensor, p : Optional[number]) -> Tensor torch._C._linalg.linalg_cond(self : Tensor, p : str) -> Tensor torch._C._linalg.linalg_cond(self : Tensor, p : Optional[number], out : Tensor) -> Tensor torch._C._linalg.linalg_cond(self : Tensor, p : str, out : Tensor) -> Tensor torch._C._linalg.linalg_cross(self : Tensor, other : Tensor, dim : int=-1) -> Tensor torch._C._linalg.linalg_cross(self : Tensor, other : Tensor, dim : int=-1, out : Tensor) -> Tensor torch._C._linalg.linalg_det(A : Tensor) -> Tensor torch._C._linalg.linalg_det(A : Tensor, out : Tensor) -> Tensor torch._C._linalg.linalg_diagonal(A : Tensor, offset : int=0, dim1 : int=-2, dim2 : int=-1) -> Tensor torch._C._linalg.linalg_eig(self : Tensor) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_eig(self : Tensor, eigenvalues : Tensor, eigenvectors : Tensor) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_eigh(self : Tensor, UPLO : str=L) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_eigh(self : Tensor, UPLO : str=L, eigvals : Tensor, eigvecs : Tensor) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_eigvals(self : Tensor) -> Tensor torch._C._linalg.linalg_eigvals(self : Tensor, out : Tensor) -> Tensor torch._C._linalg.linalg_eigvalsh(self : Tensor, UPLO : str=L) -> Tensor torch._C._linalg.linalg_eigvalsh(self : Tensor, UPLO : str=L, out : Tensor) -> Tensor torch._C._linalg.linalg_householder_product(input : Tensor, tau : Tensor) -> Tensor torch._C._linalg.linalg_householder_product(input : Tensor, tau : Tensor, out : Tensor) -> Tensor torch._C._linalg.linalg_inv(A : Tensor) -> Tensor torch._C._linalg.linalg_inv(A : Tensor, out : Tensor) -> Tensor torch._C._linalg.linalg_inv_ex(A : Tensor, check_errors : bool=False) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_inv_ex(A : Tensor, check_errors : bool=False, inverse : Tensor, info : Tensor) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_ldl_factor(self : Tensor, hermitian : bool=False) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_ldl_factor(self : Tensor, hermitian : bool=False, LD : Tensor, pivots : Tensor) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_ldl_factor_ex(self : Tensor, hermitian : bool=False, check_errors : bool=False) -> Tuple[Tensor, Tensor, Tensor] torch._C._linalg.linalg_ldl_factor_ex(self : Tensor, hermitian : bool=False, check_errors : bool=False, LD : Tensor, pivots : Tensor, info : Tensor) -> Tuple[Tensor, Tensor, Tensor] torch._C._linalg.linalg_ldl_solve(LD : Tensor, pivots : Tensor, B : Tensor, hermitian : bool=False) -> Tensor torch._C._linalg.linalg_ldl_solve(LD : Tensor, pivots : Tensor, B : Tensor, hermitian : bool=False, out : Tensor) -> Tensor torch._C._linalg.linalg_lstsq(self : Tensor, b : Tensor, rcond : Optional[float], driver : Optional[str]) -> Tuple[Tensor, Tensor, Tensor, Tensor] torch._C._linalg.linalg_lstsq(self : Tensor, b : Tensor, rcond : Optional[float], driver : Optional[str], solution : Tensor, residuals : Tensor, rank : Tensor, singular_values : Tensor) -> Tuple[Tensor, Tensor, Tensor, Tensor] torch._C._linalg.linalg_lu(A : Tensor, pivot : bool=True) -> Tuple[Tensor, Tensor, Tensor] torch._C._linalg.linalg_lu(A : Tensor, pivot : bool=True, P : Tensor, L : Tensor, U : Tensor) -> Tuple[Tensor, Tensor, Tensor] torch._C._linalg.linalg_lu_factor(A : Tensor, pivot : bool=True) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_lu_factor(A : Tensor, pivot : bool=True, LU : Tensor, pivots : Tensor) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_lu_factor_ex(A : Tensor, pivot : bool=True, check_errors : bool=False) -> Tuple[Tensor, Tensor, Tensor] torch._C._linalg.linalg_lu_factor_ex(A : Tensor, pivot : bool=True, check_errors : bool=False, LU : Tensor, pivots : Tensor, info : Tensor) -> Tuple[Tensor, Tensor, Tensor] torch._C._linalg.linalg_lu_solve(LU : Tensor, pivots : Tensor, B : Tensor, left : bool=True, adjoint : bool=False) -> Tensor torch._C._linalg.linalg_lu_solve(LU : Tensor, pivots : Tensor, B : Tensor, left : bool=True, adjoint : bool=False, out : Tensor) -> Tensor torch._C._linalg.linalg_matmul(self : Tensor, other : Tensor) -> Tensor torch._C._linalg.linalg_matmul(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch._C._linalg.linalg_matrix_exp(self : Tensor) -> Tensor torch._C._linalg.linalg_matrix_exp(self : Tensor, out : Tensor) -> Tensor torch._C._linalg.linalg_matrix_norm(self : Tensor, ord : number, dim : List[int]=[-2, -1], keepdim : bool=False, dtype : Optional[int]) -> Tensor torch._C._linalg.linalg_matrix_norm(self : Tensor, ord : str=fro, dim : List[int]=[-2, -1], keepdim : bool=False, dtype : Optional[int]) -> Tensor torch._C._linalg.linalg_matrix_norm(self : Tensor, ord : number, dim : List[int]=[-2, -1], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor torch._C._linalg.linalg_matrix_norm(self : Tensor, ord : str=fro, dim : List[int]=[-2, -1], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor torch._C._linalg.linalg_matrix_power(self : Tensor, n : int) -> Tensor torch._C._linalg.linalg_matrix_power(self : Tensor, n : int, out : Tensor) -> Tensor torch._C._linalg.linalg_matrix_rank(self : Tensor, tol : float, hermitian : bool=False) -> Tensor torch._C._linalg.linalg_matrix_rank(input : Tensor, tol : Tensor, hermitian : bool=False) -> Tensor torch._C._linalg.linalg_matrix_rank(input : Tensor, atol : Optional[Tensor], rtol : Optional[Tensor], hermitian : bool=False) -> Tensor torch._C._linalg.linalg_matrix_rank(self : Tensor, atol : Optional[float], rtol : Optional[float], hermitian : bool=False) -> Tensor torch._C._linalg.linalg_matrix_rank(input : Tensor, atol : Optional[Tensor], rtol : Optional[Tensor], hermitian : bool=False, out : Tensor) -> Tensor torch._C._linalg.linalg_matrix_rank(self : Tensor, atol : Optional[float], rtol : Optional[float], hermitian : bool=False, out : Tensor) -> Tensor torch._C._linalg.linalg_matrix_rank(self : Tensor, tol : float, hermitian : bool=False, out : Tensor) -> Tensor torch._C._linalg.linalg_matrix_rank(input : Tensor, tol : Tensor, hermitian : bool=False, out : Tensor) -> Tensor torch._C._linalg.linalg_multi_dot(tensors : List[Tensor]) -> Tensor torch._C._linalg.linalg_multi_dot(tensors : List[Tensor], out : Tensor) -> Tensor torch._C._linalg.linalg_norm(self : Tensor, ord : Optional[number], dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int]) -> Tensor torch._C._linalg.linalg_norm(self : Tensor, ord : str, dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int]) -> Tensor torch._C._linalg.linalg_norm(self : Tensor, ord : Optional[number], dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor torch._C._linalg.linalg_norm(self : Tensor, ord : str, dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor torch._C._linalg.linalg_pinv(self : Tensor, rcond : float, hermitian : bool=False) -> Tensor torch._C._linalg.linalg_pinv(self : Tensor, atol : Optional[float], rtol : Optional[float], hermitian : bool=False) -> Tensor torch._C._linalg.linalg_pinv(self : Tensor, atol : Optional[Tensor], rtol : Optional[Tensor], hermitian : bool=False) -> Tensor torch._C._linalg.linalg_pinv(self : Tensor, atol : Optional[Tensor], rtol : Optional[Tensor], hermitian : bool=False, out : Tensor) -> Tensor torch._C._linalg.linalg_pinv(self : Tensor, atol : Optional[float], rtol : Optional[float], hermitian : bool=False, out : Tensor) -> Tensor torch._C._linalg.linalg_pinv(self : Tensor, rcond : float, hermitian : bool=False, out : Tensor) -> Tensor torch._C._linalg.linalg_pinv(self : Tensor, rcond : Tensor, hermitian : bool=False) -> Tensor torch._C._linalg.linalg_pinv(self : Tensor, rcond : Tensor, hermitian : bool=False, out : Tensor) -> Tensor torch._C._linalg.linalg_qr(A : Tensor, mode : str=reduced) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_qr(A : Tensor, mode : str=reduced, Q : Tensor, R : Tensor) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_slogdet(A : Tensor) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_slogdet(A : Tensor, sign : Tensor, logabsdet : Tensor) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_solve(A : Tensor, B : Tensor, left : bool=True) -> Tensor torch._C._linalg.linalg_solve(A : Tensor, B : Tensor, left : bool=True, out : Tensor) -> Tensor torch._C._linalg.linalg_solve_ex(A : Tensor, B : Tensor, left : bool=True, check_errors : bool=False) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_solve_ex(A : Tensor, B : Tensor, left : bool=True, check_errors : bool=False, result : Tensor, info : Tensor) -> Tuple[Tensor, Tensor] torch._C._linalg.linalg_solve_triangular(self : Tensor, B : Tensor, upper : bool, left : bool=True, unitriangular : bool=False) -> Tensor torch._C._linalg.linalg_solve_triangular(self : Tensor, B : Tensor, upper : bool, left : bool=True, unitriangular : bool=False, out : Tensor) -> Tensor torch._C._linalg.linalg_svd(A : Tensor, full_matrices : bool=True, driver : Optional[str]) -> Tuple[Tensor, Tensor, Tensor] torch._C._linalg.linalg_svd(A : Tensor, full_matrices : bool=True, driver : Optional[str], U : Tensor, S : Tensor, Vh : Tensor) -> Tuple[Tensor, Tensor, Tensor] torch._C._linalg.linalg_svdvals(A : Tensor, driver : Optional[str]) -> Tensor torch._C._linalg.linalg_svdvals(A : Tensor, driver : Optional[str], out : Tensor) -> Tensor torch._C._linalg.linalg_tensorinv(self : Tensor, ind : int=2) -> Tensor torch._C._linalg.linalg_tensorinv(self : Tensor, ind : int=2, out : Tensor) -> Tensor torch._C._linalg.linalg_tensorsolve(self : Tensor, other : Tensor, dims : Optional[List[int]]) -> Tensor torch._C._linalg.linalg_tensorsolve(self : Tensor, other : Tensor, dims : Optional[List[int]], out : Tensor) -> Tensor torch._C._linalg.linalg_vander(x : Tensor, N : Optional[int]) -> Tensor torch._C._linalg.linalg_vecdot(x : Tensor, y : Tensor, dim : int=-1) -> Tensor torch._C._linalg.linalg_vecdot(x : Tensor, y : Tensor, dim : int=-1, out : Tensor) -> Tensor torch._C._linalg.linalg_vector_norm(self : Tensor, ord : number=2, dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int]) -> Tensor torch._C._linalg.linalg_vector_norm(self : Tensor, ord : number=2, dim : Optional[List[int]], keepdim : bool=False, dtype : Optional[int], out : Tensor) -> Tensor torch._C._nested.nested_to_padded_tensor(self : Tensor, padding : float, output_size : Optional[List[int]]) -> Tensor torch._C._sparse.sparse_sampled_addmm(self : Tensor, mat1 : Tensor, mat2 : Tensor, beta : number=1, alpha : number=1, out : Tensor) -> Tensor torch._C._sparse.sparse_sampled_addmm(self : Tensor, mat1 : Tensor, mat2 : Tensor, beta : number=1, alpha : number=1) -> Tensor torch._C._special.special_airy_ai(x : Tensor) -> Tensor torch._C._special.special_airy_ai(x : Tensor, out : Tensor) -> Tensor torch._C._special.special_bessel_j0(self : Tensor) -> Tensor torch._C._special.special_bessel_j0(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_bessel_j1(self : Tensor) -> Tensor torch._C._special.special_bessel_j1(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_bessel_y0(self : Tensor) -> Tensor torch._C._special.special_bessel_y0(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_bessel_y1(self : Tensor) -> Tensor torch._C._special.special_bessel_y1(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_t(x : Tensor, n : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_t(x : Tensor, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_t(x : number, n : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_t(x : number, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_t(x : Tensor, n : number) -> Tensor torch._C._special.special_chebyshev_polynomial_t(x : Tensor, n : number, out : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_u(x : Tensor, n : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_u(x : Tensor, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_u(x : number, n : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_u(x : number, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_u(x : Tensor, n : number) -> Tensor torch._C._special.special_chebyshev_polynomial_u(x : Tensor, n : number, out : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_v(x : Tensor, n : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_v(x : Tensor, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_v(x : number, n : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_v(x : number, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_v(x : Tensor, n : number) -> Tensor torch._C._special.special_chebyshev_polynomial_v(x : Tensor, n : number, out : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_w(x : Tensor, n : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_w(x : Tensor, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_w(x : number, n : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_w(x : number, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_chebyshev_polynomial_w(x : Tensor, n : number) -> Tensor torch._C._special.special_chebyshev_polynomial_w(x : Tensor, n : number, out : Tensor) -> Tensor torch._C._special.special_digamma(self : Tensor) -> Tensor torch._C._special.special_digamma(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_entr(self : Tensor) -> Tensor torch._C._special.special_entr(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_erf(self : Tensor) -> Tensor torch._C._special.special_erf(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_erfc(self : Tensor) -> Tensor torch._C._special.special_erfc(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_erfcx(self : Tensor) -> Tensor torch._C._special.special_erfcx(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_erfinv(self : Tensor) -> Tensor torch._C._special.special_erfinv(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_exp2(self : Tensor) -> Tensor torch._C._special.special_exp2(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_expit(self : Tensor) -> Tensor torch._C._special.special_expit(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_expm1(self : Tensor) -> Tensor torch._C._special.special_expm1(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_gammainc(self : Tensor, other : Tensor) -> Tensor torch._C._special.special_gammainc(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch._C._special.special_gammaincc(self : Tensor, other : Tensor) -> Tensor torch._C._special.special_gammaincc(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch._C._special.special_gammaln(self : Tensor) -> Tensor torch._C._special.special_gammaln(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_hermite_polynomial_h(x : Tensor, n : Tensor) -> Tensor torch._C._special.special_hermite_polynomial_h(x : Tensor, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_hermite_polynomial_h(x : number, n : Tensor) -> Tensor torch._C._special.special_hermite_polynomial_h(x : number, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_hermite_polynomial_h(x : Tensor, n : number) -> Tensor torch._C._special.special_hermite_polynomial_h(x : Tensor, n : number, out : Tensor) -> Tensor torch._C._special.special_hermite_polynomial_he(x : Tensor, n : Tensor) -> Tensor torch._C._special.special_hermite_polynomial_he(x : Tensor, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_hermite_polynomial_he(x : number, n : Tensor) -> Tensor torch._C._special.special_hermite_polynomial_he(x : number, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_hermite_polynomial_he(x : Tensor, n : number) -> Tensor torch._C._special.special_hermite_polynomial_he(x : Tensor, n : number, out : Tensor) -> Tensor torch._C._special.special_i0(self : Tensor) -> Tensor torch._C._special.special_i0(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_i0e(self : Tensor) -> Tensor torch._C._special.special_i0e(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_i1(self : Tensor) -> Tensor torch._C._special.special_i1(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_i1e(self : Tensor) -> Tensor torch._C._special.special_i1e(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_laguerre_polynomial_l(x : Tensor, n : Tensor) -> Tensor torch._C._special.special_laguerre_polynomial_l(x : Tensor, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_laguerre_polynomial_l(x : number, n : Tensor) -> Tensor torch._C._special.special_laguerre_polynomial_l(x : number, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_laguerre_polynomial_l(x : Tensor, n : number) -> Tensor torch._C._special.special_laguerre_polynomial_l(x : Tensor, n : number, out : Tensor) -> Tensor torch._C._special.special_legendre_polynomial_p(x : Tensor, n : Tensor) -> Tensor torch._C._special.special_legendre_polynomial_p(x : Tensor, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_legendre_polynomial_p(x : number, n : Tensor) -> Tensor torch._C._special.special_legendre_polynomial_p(x : number, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_legendre_polynomial_p(x : Tensor, n : number) -> Tensor torch._C._special.special_legendre_polynomial_p(x : Tensor, n : number, out : Tensor) -> Tensor torch._C._special.special_log1p(self : Tensor) -> Tensor torch._C._special.special_log1p(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_log_ndtr(self : Tensor) -> Tensor torch._C._special.special_log_ndtr(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_log_softmax(self : Tensor, dim : int, dtype : Optional[int]) -> Tensor torch._C._special.special_logit(self : Tensor, eps : Optional[float]) -> Tensor torch._C._special.special_logit(self : Tensor, eps : Optional[float], out : Tensor) -> Tensor torch._C._special.special_logsumexp(self : Tensor, dim : List[int], keepdim : bool=False) -> Tensor torch._C._special.special_logsumexp(self : Tensor, dim : List[int], keepdim : bool=False, out : Tensor) -> Tensor torch._C._special.special_modified_bessel_i0(self : Tensor) -> Tensor torch._C._special.special_modified_bessel_i0(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_modified_bessel_i1(self : Tensor) -> Tensor torch._C._special.special_modified_bessel_i1(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_modified_bessel_k0(self : Tensor) -> Tensor torch._C._special.special_modified_bessel_k0(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_modified_bessel_k1(self : Tensor) -> Tensor torch._C._special.special_modified_bessel_k1(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_multigammaln(self : Tensor, p : int) -> Tensor torch._C._special.special_multigammaln(self : Tensor, p : int, out : Tensor) -> Tensor torch._C._special.special_ndtr(self : Tensor) -> Tensor torch._C._special.special_ndtr(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_ndtri(self : Tensor) -> Tensor torch._C._special.special_ndtri(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_polygamma(n : int, self : Tensor) -> Tensor torch._C._special.special_polygamma(n : int, self : Tensor, out : Tensor) -> Tensor torch._C._special.special_psi(self : Tensor) -> Tensor torch._C._special.special_psi(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_round(self : Tensor, decimals : int=0) -> Tensor torch._C._special.special_round(self : Tensor, decimals : int=0, out : Tensor) -> Tensor torch._C._special.special_scaled_modified_bessel_k0(x : Tensor) -> Tensor torch._C._special.special_scaled_modified_bessel_k0(x : Tensor, out : Tensor) -> Tensor torch._C._special.special_scaled_modified_bessel_k1(x : Tensor) -> Tensor torch._C._special.special_scaled_modified_bessel_k1(x : Tensor, out : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_t(x : Tensor, n : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_t(x : Tensor, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_t(x : number, n : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_t(x : number, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_t(x : Tensor, n : number) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_t(x : Tensor, n : number, out : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_u(x : Tensor, n : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_u(x : Tensor, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_u(x : number, n : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_u(x : number, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_u(x : Tensor, n : number) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_u(x : Tensor, n : number, out : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_v(x : Tensor, n : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_v(x : Tensor, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_v(x : number, n : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_v(x : number, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_v(x : Tensor, n : number) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_v(x : Tensor, n : number, out : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_w(x : Tensor, n : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_w(x : Tensor, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_w(x : number, n : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_w(x : number, n : Tensor, out : Tensor) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_w(x : Tensor, n : number) -> Tensor torch._C._special.special_shifted_chebyshev_polynomial_w(x : Tensor, n : number, out : Tensor) -> Tensor torch._C._special.special_sinc(self : Tensor) -> Tensor torch._C._special.special_sinc(self : Tensor, out : Tensor) -> Tensor torch._C._special.special_softmax(self : Tensor, dim : int, dtype : Optional[int]) -> Tensor torch._C._special.special_spherical_bessel_j0(x : Tensor) -> Tensor torch._C._special.special_spherical_bessel_j0(x : Tensor, out : Tensor) -> Tensor torch._C._special.special_xlog1py(self : Tensor, other : Tensor) -> Tensor torch._C._special.special_xlog1py(self : Tensor, other : number) -> Tensor torch._C._special.special_xlog1py(self : number, other : Tensor) -> Tensor torch._C._special.special_xlog1py(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch._C._special.special_xlog1py(self : number, other : Tensor, out : Tensor) -> Tensor torch._C._special.special_xlog1py(self : Tensor, other : number, out : Tensor) -> Tensor torch._C._special.special_xlogy(self : Tensor, other : Tensor) -> Tensor torch._C._special.special_xlogy(self : Tensor, other : number) -> Tensor torch._C._special.special_xlogy(self : number, other : Tensor) -> Tensor torch._C._special.special_xlogy(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch._C._special.special_xlogy(self : number, other : Tensor, out : Tensor) -> Tensor torch._C._special.special_xlogy(self : Tensor, other : number, out : Tensor) -> Tensor torch._C._special.special_zeta(self : Tensor, other : Tensor) -> Tensor torch._C._special.special_zeta(self : Tensor, other : number) -> Tensor torch._C._special.special_zeta(self : number, other : Tensor) -> Tensor torch._C._special.special_zeta(self : Tensor, other : Tensor, out : Tensor) -> Tensor torch._C._special.special_zeta(self : number, other : Tensor, out : Tensor) -> Tensor torch._C._special.special_zeta(self : Tensor, other : number, out : Tensor) -> Tensor
TorchScript 内置函数
collections.OrderedDict() -> Dict[str, Tensor] collections.OrderedDict(inputs : List[Tuple[str, tVal]]) -> Dict[str, tVal] collections.OrderedDict(self : Dict[str, t]) -> Dict[str, t] collections.OrderedDict(inputs : List[Tuple[int, tVal]]) -> Dict[int, tVal] collections.OrderedDict(self : Dict[int, t]) -> Dict[int, t] collections.OrderedDict(inputs : List[Tuple[bool, tVal]]) -> Dict[bool, tVal] collections.OrderedDict(self : Dict[bool, t]) -> Dict[bool, t] collections.OrderedDict(inputs : List[Tuple[float, tVal]]) -> Dict[float, tVal] collections.OrderedDict(self : Dict[float, t]) -> Dict[float, t] collections.OrderedDict(inputs : List[Tuple[complex, tVal]]) -> Dict[complex, tVal] collections.OrderedDict(self : Dict[complex, t]) -> Dict[complex, t] collections.OrderedDict(inputs : List[Tuple[Tensor, tVal]]) -> Dict[Tensor, tVal] collections.OrderedDict(self : Dict[Tensor, t]) -> Dict[Tensor, t] builtins.dict() -> Dict[str, Tensor] builtins.dict(inputs : List[Tuple[str, tVal]]) -> Dict[str, tVal] builtins.dict(self : Dict[str, t]) -> Dict[str, t] builtins.dict(inputs : List[Tuple[int, tVal]]) -> Dict[int, tVal] builtins.dict(self : Dict[int, t]) -> Dict[int, t] builtins.dict(inputs : List[Tuple[bool, tVal]]) -> Dict[bool, tVal] builtins.dict(self : Dict[bool, t]) -> Dict[bool, t] builtins.dict(inputs : List[Tuple[float, tVal]]) -> Dict[float, tVal] builtins.dict(self : Dict[float, t]) -> Dict[float, t] builtins.dict(inputs : List[Tuple[complex, tVal]]) -> Dict[complex, tVal] builtins.dict(self : Dict[complex, t]) -> Dict[complex, t] builtins.dict(inputs : List[Tuple[Tensor, tVal]]) -> Dict[Tensor, tVal] builtins.dict(self : Dict[Tensor, t]) -> Dict[Tensor, t] torch.backends.cudnn.is_acceptable(self : Tensor) -> bool cmath.isnan(self : Tensor) -> Tensor cmath.isnan(self : Tensor, out : Tensor) -> Tensor cmath.isnan(a : float) -> bool cmath.isnan(a : complex) -> bool cmath.isfinite(self : Tensor) -> Tensor cmath.isfinite(a : float) -> bool cmath.isfinite(a : complex) -> bool cmath.isinf(self : Tensor) -> Tensor cmath.isinf(self : Tensor, out : Tensor) -> Tensor cmath.isinf(a : float) -> bool cmath.isinf(a : complex) -> bool cmath.phase(self : Tensor) -> Tensor cmath.phase(self : Tensor, out : Tensor) -> Tensor cmath.phase(a : int) -> float cmath.phase(a : float) -> float cmath.phase(a : complex) -> float cmath.phase(a : number) -> number cmath.rect(abs : Tensor, angle : Tensor) -> Tensor cmath.rect(abs : Tensor, angle : Tensor, out : Tensor) -> Tensor cmath.rect(a : int, b : int) -> complex cmath.rect(a : float, b : float) -> complex cmath.rect(a : int, b : float) -> complex cmath.rect(a : float, b : int) -> complex cmath.rect(a : number, b : number) -> number cmath.log(self : Tensor) -> Tensor cmath.log(self : Tensor, out : Tensor) -> Tensor cmath.log(a : int) -> float cmath.log(a : float) -> float cmath.log(a : complex) -> complex cmath.log(a : number) -> number cmath.log(a : int, b : int) -> float cmath.log(a : float, b : float) -> float cmath.log(a : complex, b : complex) -> complex cmath.log(a : int, b : float) -> float cmath.log(a : float, b : int) -> float cmath.log(a : int, b : complex) -> complex cmath.log(a : complex, b : int) -> complex cmath.log(a : float, b : complex) -> complex cmath.log(a : complex, b : float) -> complex cmath.log(a : number, b : number) -> float cmath.log10(self : Tensor) -> Tensor cmath.log10(self : Tensor, out : Tensor) -> Tensor cmath.log10(a : int) -> float cmath.log10(a : float) -> float cmath.log10(a : complex) -> complex cmath.log10(a : number) -> number cmath.sqrt(self : Tensor) -> Tensor cmath.sqrt(self : Tensor, out : Tensor) -> Tensor cmath.sqrt(a : int) -> float cmath.sqrt(a : float) -> float cmath.sqrt(a : complex) -> complex cmath.sqrt(a : number) -> number cmath.exp(self : Tensor) -> Tensor cmath.exp(self : Tensor, out : Tensor) -> Tensor cmath.exp(a : int) -> float cmath.exp(a : float) -> float cmath.exp(a : complex) -> complex cmath.exp(a : number) -> number cmath.sin(self : Tensor) -> Tensor cmath.sin(self : Tensor, out : Tensor) -> Tensor cmath.sin(a : int) -> float cmath.sin(a : float) -> float cmath.sin(a : complex) -> complex cmath.sin(a : number) -> number cmath.tan(self : Tensor) -> Tensor cmath.tan(self : Tensor, out : Tensor) -> Tensor cmath.tan(a : int) -> float cmath.tan(a : float) -> float cmath.tan(a : complex) -> complex cmath.tan(a : number) -> number cmath.cos(self : Tensor) -> Tensor cmath.cos(self : Tensor, out : Tensor) -> Tensor cmath.cos(a : int) -> float cmath.cos(a : float) -> float cmath.cos(a : complex) -> complex cmath.cos(a : number) -> number cmath.asin(self : Tensor) -> Tensor cmath.asin(self : Tensor, out : Tensor) -> Tensor cmath.asin(a : int) -> float cmath.asin(a : float) -> float cmath.asin(a : complex) -> complex cmath.asin(a : number) -> number cmath.acos(self : Tensor) -> Tensor cmath.acos(self : Tensor, out : Tensor) -> Tensor cmath.acos(a : int) -> float cmath.acos(a : float) -> float cmath.acos(a : complex) -> complex cmath.acos(a : number) -> number cmath.atan(self : Tensor) -> Tensor cmath.atan(self : Tensor, out : Tensor) -> Tensor cmath.atan(a : int) -> float cmath.atan(a : float) -> float cmath.atan(a : complex) -> complex cmath.atan(a : number) -> number cmath.sinh(self : Tensor) -> Tensor cmath.sinh(self : Tensor, out : Tensor) -> Tensor cmath.sinh(a : int) -> float cmath.sinh(a : float) -> float cmath.sinh(a : complex) -> complex cmath.sinh(a : number) -> number cmath.cosh(self : Tensor) -> Tensor cmath.cosh(self : Tensor, out : Tensor) -> Tensor cmath.cosh(a : int) -> float cmath.cosh(a : float) -> float cmath.cosh(a : complex) -> complex cmath.cosh(a : number) -> number cmath.tanh(self : Tensor) -> Tensor cmath.tanh(self : Tensor, out : Tensor) -> Tensor cmath.tanh(a : int) -> float cmath.tanh(a : float) -> float cmath.tanh(a : complex) -> complex cmath.tanh(a : number) -> number cmath.asinh(self : Tensor) -> Tensor cmath.asinh(self : Tensor, out : Tensor) -> Tensor cmath.asinh(a : int) -> float cmath.asinh(a : float) -> float cmath.asinh(a : complex) -> complex cmath.asinh(a : number) -> number cmath.acosh(self : Tensor) -> Tensor cmath.acosh(self : Tensor, out : Tensor) -> Tensor cmath.acosh(a : int) -> float cmath.acosh(a : float) -> float cmath.acosh(a : complex) -> complex cmath.acosh(a : number) -> number cmath.atanh(self : Tensor) -> Tensor cmath.atanh(self : Tensor, out : Tensor) -> Tensor cmath.atanh(a : int) -> float cmath.atanh(a : float) -> float cmath.atanh(a : complex) -> complex cmath.atanh(a : number) -> number 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(self : Tensor, gradient : Optional[Tensor], retain_graph : Optional[bool], create_graph : bool=False) -> Tuple[] torch.autograd.backward(tensors : List[Tensor], grad_tensors : Optional[List[Optional[Tensor]]], retain_graph : Optional[bool], create_graph : bool=False) -> Tuple[] torch.Size(sizes : List[int]) -> List[int] torch.functional.align_tensors(tensors : List[Tensor]) -> List[Tensor] torch.functional.atleast_1d(self : Tensor) -> Tensor torch.functional.atleast_1d(tensors : List[Tensor]) -> List[Tensor] torch.functional.atleast_2d(self : Tensor) -> Tensor torch.functional.atleast_2d(tensors : List[Tensor]) -> List[Tensor] torch.functional.atleast_3d(self : Tensor) -> Tensor torch.functional.atleast_3d(tensors : List[Tensor]) -> List[Tensor] torch.functional.block_diag(tensors : List[Tensor]) -> Tensor torch.functional.block_diag(tensors : List[Tensor], out : Tensor) -> Tensor torch.functional.broadcast_tensors(tensors : List[Tensor]) -> List[Tensor] torch.functional.cartesian_prod(tensors : List[Tensor]) -> Tensor torch.functional.chain_matmul(matrices : List[Tensor]) -> Tensor torch.functional.chain_matmul(matrices : List[Tensor], out : Tensor) -> Tensor torch.device(a : str) -> Device torch.device(type : str, index : int) -> Device torch.functional.einsum(equation : str, tensors : List[Tensor], path : Optional[List[int]]) -> Tensor torch.functional.einsum(a : Tensor) -> Tensor torch.get_autocast_dtype(device_type : str) -> int torch.random.initial_seed(self : Generator) -> int torch.is_autocast_cpu_enabled() -> bool torch.is_autocast_enabled() -> bool torch.is_grad_enabled() -> bool torch.random.manual_seed(seed : int) -> Tuple[] torch.random.manual_seed(self : Generator, seed : int) -> Generator torch.functional.meshgrid(tensors : List[Tensor]) -> List[Tensor] torch.functional.meshgrid(tensors : List[Tensor], indexing : str) -> List[Tensor] torch.qscheme(self : Tensor) -> QScheme torch.serialization.save(item : t, filename : str) -> Tuple[] torch.random.seed(self : Generator) -> int torch.autograd.grad_mode.set_grad_enabled(val : bool) -> Tuple[] torch.functional.split(self : Tensor, split_size : int, dim : int=0) -> List[Tensor] torch.functional.split(self : Tensor, split_size : List[int], dim : int=0) -> List[Tensor] torch.functional.split(self : str, separator : Optional[str], max : int=-1) -> List[str] torch.functional.split(self : Tensor, split_sizes : List[int], dim : int=0) -> List[Tensor] torch.wait(self : Future[t]) -> t
Python 内置函数
下表中的函数受支持，但没有静态模式
|
功能 |
注意 |
|---|---|
|
打印任意值 |
|
|
由于它们的大小在编译时未知，因此无法使用此方法将列表转换为元组 |
|
|
属性名称必须是具体的字符串 |
|
|
属性名称必须是具体的字符串 |
|
|
结果是固定的 |
|
|
只能在for循环中用作迭代器 |
|
|
参数必须是可迭代的。详情请参阅可迭代对象。 |
|
|
参数必须是可迭代的。详情请参阅可迭代对象。 |
以下函数将使用 TorchScript 类 对应的魔法方法
|
功能 |
魔术方法 |
|---|---|
|
复杂的 |
|
|
浮点数 |
|
|
整型 |
|
|
布尔值 |
|
|
str |
|
|
长度 |
|
|
hex |
|
|
十月 |
|
这些内置函数基于模式进行定义
float(a : Tensor) -> float float(a : number) -> float float(a : int) -> float float(a : bool) -> float float(a : str) -> float complex(a : number) -> complex complex(a : Tensor, b : Tensor) -> complex complex(x : int, y : bool) -> complex complex(x : bool, y : int) -> complex complex(x : float, y : bool) -> complex complex(x : bool, y : float) -> complex complex(x : float, y : int) -> complex complex(x : int, y : float) -> complex complex(x : int, y : int) -> complex complex(x : bool, y : bool) -> complex complex(x : float, y : float) -> complex complex(x : Tensor, y : float) -> complex complex(x : float, y : Tensor) -> complex complex(x : Tensor, y : int) -> complex complex(x : int, y : Tensor) -> complex complex(x : Tensor, y : bool) -> complex complex(x : bool, y : Tensor) -> complex int(a : Tensor) -> int int(a : bool) -> int int(a : float) -> int int(a : number) -> int int(a : str) -> int bool(a : Tensor) -> bool bool(a : int) -> bool bool(a : float) -> bool str(elem : t) -> str len(a : List[t]) -> int len(t : Tensor) -> int len(s : str) -> int len(self : Dict[str, t]) -> int len(self : Dict[int, t]) -> int len(self : Dict[bool, t]) -> int len(self : Dict[float, t]) -> int len(self : Dict[complex, t]) -> int len(self : Dict[Tensor, t]) -> int len(a : List[Any]) -> int hex(i : int) -> str oct(i : int) -> str round(self : Tensor) -> Tensor round(self : Tensor, decimals : int) -> Tensor round(self : Tensor, out : Tensor) -> Tensor round(self : Tensor, decimals : int, out : Tensor) -> Tensor round(a : int) -> float round(a : float) -> float round(a : number) -> number hash(value : t) -> int min(a : int, b : int) -> int min(a : float, b : float) -> float min(a : int, b : float) -> float min(a : float, b : int) -> float min(a : number, b : number) -> number min(l : List[int], r : List[int]) -> List[int] min(self : List[int]) -> int min(l : List[float], r : List[float]) -> List[float] min(self : List[float]) -> float min(l : List[bool], r : List[bool]) -> List[bool] min(self : List[bool]) -> bool max(a : int, b : int) -> int max(a : float, b : float) -> float max(a : int, b : float) -> float max(a : float, b : int) -> float max(a : number, b : number) -> number max(l : List[int], r : List[int]) -> List[int] max(self : List[int]) -> int max(l : List[float], r : List[float]) -> List[float] max(self : List[float]) -> float max(l : List[bool], r : List[bool]) -> List[bool] max(self : List[bool]) -> bool abs(a : int) -> int abs(a : float) -> float abs(a : complex) -> float abs(a : number) -> number abs(x : Tensor) -> Tensor all(self : Tensor) -> Tensor all(self : Tensor, dim : int, keepdim : bool=False) -> Tensor all(self : Tensor, dim : Optional[List[int]], keepdim : bool=False) -> Tensor all(self : Tensor, dim : int, keepdim : bool=False, out : Tensor) -> Tensor all(self : Tensor, dim : Optional[List[int]], keepdim : bool=False, out : Tensor) -> Tensor all(self : Tensor, out : Tensor) -> Tensor all(self : Tensor, dim : str, keepdim : bool=False) -> Tensor all(self : Tensor, dim : str, keepdim : bool=False, out : Tensor) -> Tensor all(self : List[int]) -> bool all(self : List[float]) -> bool all(self : List[bool]) -> bool divmod(x : int, y : int) -> Tuple[int, int] divmod(x : float, y : float) -> Tuple[float, float] divmod(x : int, y : float) -> Tuple[float, float] divmod(x : float, y : int) -> Tuple[float, float] list(t : str) -> List[str] list(l : List[t]) -> List[t] ord(string : str) -> int chr(i : int) -> str bin(i : int) -> str sorted(input : List[int]) -> List[int] sorted(input : List[float]) -> List[float] sorted(input : List[Tensor]) -> List[Tensor] sorted(input : List[bool]) -> List[bool] sorted(input : List[str]) -> List[str] sorted(self : List[t]) -> List[t]
《math》模块
aten::ceil.int(int a) -> int aten::ceil.float(float a) -> int aten::ceil.Scalar(Scalar a) -> Scalar aten::copysign.int(int a, int b) -> float aten::copysign.float(float a, float b) -> float aten::copysign.int_float(int a, float b) -> float aten::copysign.float_int(float a, int b) -> float aten::copysign(Scalar a, Scalar b) -> float aten::erf.int(int a) -> float aten::erf.float(float a) -> float aten::erf.Scalar(Scalar a) -> Scalar aten::erfc.int(int a) -> float aten::erfc.float(float a) -> float aten::erfc.Scalar(Scalar a) -> Scalar aten::exp.int(int a) -> float aten::exp.float(float a) -> float aten::exp.complex(complex a) -> complex aten::exp.Scalar(Scalar a) -> Scalar aten::expm1.int(int a) -> float aten::expm1.float(float a) -> float aten::expm1.Scalar(Scalar a) -> Scalar aten::fabs.int(int a) -> float aten::fabs.float(float a) -> float aten::fabs.Scalar(Scalar a) -> Scalar aten::floor.int(int a) -> int aten::floor.float(float a) -> int aten::floor.Scalar(Scalar a) -> Scalar aten::gamma.int(int a) -> float aten::gamma.float(float a) -> float aten::gamma.Scalar(Scalar a) -> Scalar aten::lgamma.int(int a) -> float aten::lgamma.float(float a) -> float aten::lgamma.Scalar(Scalar a) -> Scalar aten::log.int(int a) -> float aten::log.float(float a) -> float aten::log.complex(complex a) -> complex aten::log.Scalar(Scalar a) -> Scalar aten::log.int_int(int a, int b) -> float aten::log.float_float(float a, float b) -> float aten::log.complex_complex(complex a, complex b) -> complex aten::log.int_float(int a, float b) -> float aten::log.float_int(float a, int b) -> float aten::log.int_complex(int a, complex b) -> complex aten::log.complex_int(complex a, int b) -> complex aten::log.float_complex(float a, complex b) -> complex aten::log.complex_float(complex a, float b) -> complex aten::log.Scalar_Scalar(Scalar a, Scalar b) -> float aten::log10.int(int a) -> float aten::log10.float(float a) -> float aten::log10.complex(complex a) -> complex aten::log10.Scalar(Scalar a) -> Scalar aten::log1p.int(int a) -> float aten::log1p.float(float a) -> float aten::log1p.Scalar(Scalar a) -> Scalar aten::pow.int(int a, int b) -> float aten::pow.complex(complex a, complex b) -> complex aten::pow.float(float a, float b) -> float aten::pow.int_float(int a, float b) -> float aten::pow.float_int(float a, int b) -> float aten::pow.float_complex(float a, complex b) -> complex aten::pow.complex_float(complex a, float b) -> complex aten::pow.Scalar_Scalar(Scalar a, Scalar b) -> float aten::pow.int_to_int(int a, int b) -> int aten::sqrt.int(int a) -> float aten::sqrt.float(float a) -> float aten::sqrt.complex(complex a) -> complex aten::sqrt.Scalar(Scalar a) -> Scalar aten::isnan.float(float a) -> bool aten::isnan.complex(complex a) -> bool aten::asinh.int(int a) -> float aten::asinh.float(float a) -> float aten::asinh.complex(complex a) -> complex aten::asinh.Scalar(Scalar a) -> Scalar aten::atanh.int(int a) -> float aten::atanh.float(float a) -> float aten::atanh.complex(complex a) -> complex aten::atanh.Scalar(Scalar a) -> Scalar aten::cosh.int(int a) -> float aten::cosh.float(float a) -> float aten::cosh.complex(complex a) -> complex aten::cosh.Scalar(Scalar a) -> Scalar aten::sinh.int(int a) -> float aten::sinh.float(float a) -> float aten::sinh.complex(complex a) -> complex aten::sinh.Scalar(Scalar a) -> Scalar aten::tanh.int(int a) -> float aten::tanh.float(float a) -> float aten::tanh.complex(complex a) -> complex aten::tanh.Scalar(Scalar a) -> Scalar aten::acos.int(int a) -> float aten::acos.float(float a) -> float aten::acos.complex(complex a) -> complex aten::acos.Scalar(Scalar a) -> Scalar aten::asin.int(int a) -> float aten::asin.float(float a) -> float aten::asin.complex(complex a) -> complex aten::asin.Scalar(Scalar a) -> Scalar aten::atan.int(int a) -> float aten::atan.float(float a) -> float aten::atan.complex(complex a) -> complex aten::atan.Scalar(Scalar a) -> Scalar aten::atan2.int(int a, int b) -> float aten::atan2.float(float a, float b) -> float aten::atan2.int_float(int a, float b) -> float aten::atan2.float_int(float a, int b) -> float aten::atan2.Scalar_Scalar(Scalar a, Scalar b) -> float aten::cos.int(int a) -> float aten::cos.float(float a) -> float aten::cos.complex(complex a) -> complex aten::cos.Scalar(Scalar a) -> Scalar aten::sin.int(int a) -> float aten::sin.float(float a) -> float aten::sin.complex(complex a) -> complex aten::sin.Scalar(Scalar a) -> Scalar aten::tan.int(int a) -> float aten::tan.float(float a) -> float aten::tan.complex(complex a) -> complex aten::tan.Scalar(Scalar a) -> Scalar aten::asinh.int(int a) -> float aten::asinh.float(float a) -> float aten::asinh.complex(complex a) -> complex aten::asinh.Scalar(Scalar a) -> Scalar aten::atanh.int(int a) -> float aten::atanh.float(float a) -> float aten::atanh.complex(complex a) -> complex aten::atanh.Scalar(Scalar a) -> Scalar aten::acosh.int(int a) -> float aten::acosh.float(float a) -> float aten::acosh.complex(complex a) -> complex aten::acosh.Scalar(Scalar a) -> Scalar aten::fmod.int(int a, int b) -> float aten::fmod.float(float a, float b) -> float aten::fmod.int_float(int a, float b) -> float aten::fmod.float_int(float a, int b) -> float aten::fmod(Scalar a, Scalar b) -> float aten::modf(float a) -> (float, float) aten::factorial.int(int a) -> int aten::frexp(float a) -> (float, int) aten::isinf.float(float a) -> bool aten::isinf.complex(complex a) -> bool aten::degrees.int(int a) -> float aten::degrees.float(float a) -> float aten::degrees.Scalar(Scalar a) -> Scalar aten::radians.int(int a) -> float aten::radians.float(float a) -> float aten::radians.Scalar(Scalar a) -> Scalar aten::ldexp(float x, int i) -> float aten::gcd.int(int a, int b) -> int aten::isfinite.float(float a) -> bool aten::isfinite.complex(complex a) -> bool aten::mathremainder.int(int a, int b) -> float aten::mathremainder.float(float a, float b) -> float aten::mathremainder.int_float(int a, float b) -> float aten::mathremainder.float_int(float a, int b) -> float aten::mathremainder(Scalar a, Scalar b) -> float