Shortcuts

TorchScript Builtins

This is a full reference of functions and Tensor methods accessible in TorchScript

Supported Tensor Methods

Tensor.__and__(other : number) -> Tensor

Tensor.__and__(other : Tensor) -> Tensor

Tensor.__iand__(other : number) -> Tensor

Tensor.__iand__(other : Tensor) -> Tensor

Tensor.__ilshift__(other : number) -> Tensor

Tensor.__ilshift__(other : Tensor) -> Tensor

Tensor.__ior__(other : number) -> Tensor

Tensor.__ior__(other : Tensor) -> Tensor

Tensor.__irshift__(other : number) -> Tensor

Tensor.__irshift__(other : Tensor) -> Tensor

Tensor.__ixor__(other : number) -> Tensor

Tensor.__ixor__(other : Tensor) -> Tensor

Tensor.__lshift__(other : number) -> Tensor

Tensor.__lshift__(other : Tensor) -> Tensor

Tensor.__or__(other : number) -> Tensor

Tensor.__or__(other : Tensor) -> Tensor

Tensor.__rshift__(other : number) -> Tensor

Tensor.__rshift__(other : Tensor) -> Tensor

Tensor.__xor__(other : number) -> Tensor

Tensor.__xor__(other : Tensor) -> 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 : number,
           alpha : number=1) -> Tensor

Tensor.add(other : Tensor,
           alpha : number=1) -> Tensor

Tensor.add(other : Tensor,
           alpha : number=1,
           out : Tensor) -> Tensor

Tensor.add_(other : number,
            alpha : number=1) -> Tensor

Tensor.add_(other : Tensor,
            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.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 : int,
           keepdim : bool=False,
           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.angle() -> Tensor

Tensor.angle(out : Tensor) -> Tensor

Tensor.any() -> Tensor

Tensor.any(dim : int,
           keepdim : bool=False) -> Tensor

Tensor.any(dim : int,
           keepdim : bool=False,
           out : Tensor) -> Tensor

Tensor.any(dim : str,
           keepdim : bool=False) -> Tensor

Tensor.any(dim : str,
           keepdim : bool=False,
           out : Tensor) -> Tensor

Tensor.argmax(dim : Optional[int],
              keepdim : bool=False) -> Tensor

Tensor.argmin(dim : Optional[int],
              keepdim : bool=False) -> Tensor

Tensor.argsort(dim : int=-1,
               descending : bool=False) -> Tensor

Tensor.argsort(dim : str,
               descending : bool=False) -> Tensor

Tensor.as_strided(size : List[int],
                  stride : List[int],
                  storage_offset : Optional[int]) -> Tensor

Tensor.as_strided_(size : List[int],
                   stride : List[int],
                   storage_offset : Optional[int]) -> Tensor

Tensor.asin() -> Tensor

Tensor.asin(out : Tensor) -> Tensor

Tensor.asin_() -> Tensor

Tensor.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 : float=0.5,
                  generator : Optional[Generator]) -> Tensor

Tensor.bincount(weights : Optional[Tensor],
                minlength : int=0) -> Tensor

Tensor.bitwise_and(other : Tensor,
                   out : Tensor) -> Tensor

Tensor.bitwise_and(other : number,
                   out : Tensor) -> Tensor

Tensor.bitwise_and(other : number) -> Tensor

Tensor.bitwise_and(other : Tensor) -> Tensor

Tensor.bitwise_and_(other : number) -> Tensor

Tensor.bitwise_and_(other : Tensor) -> Tensor

Tensor.bitwise_not() -> Tensor

Tensor.bitwise_not(out : Tensor) -> Tensor

Tensor.bitwise_not_() -> Tensor

Tensor.bitwise_or(other : Tensor,
                  out : Tensor) -> Tensor

Tensor.bitwise_or(other : number,
                  out : Tensor) -> Tensor

Tensor.bitwise_or(other : number) -> Tensor

Tensor.bitwise_or(other : Tensor) -> Tensor

Tensor.bitwise_or_(other : number) -> Tensor

Tensor.bitwise_or_(other : Tensor) -> Tensor

Tensor.bitwise_xor(other : Tensor,
                   out : Tensor) -> Tensor

Tensor.bitwise_xor(other : number,
                   out : Tensor) -> Tensor

Tensor.bitwise_xor(other : number) -> Tensor

Tensor.bitwise_xor(other : Tensor) -> Tensor

Tensor.bitwise_xor_(other : number) -> Tensor

Tensor.bitwise_xor_(other : Tensor) -> Tensor

Tensor.bmm(mat2 : Tensor) -> Tensor

Tensor.bmm(mat2 : Tensor,
           out : Tensor) -> Tensor

Tensor.cauchy_(median : float=0.0,
               sigma : float=1.0,
               generator : Optional[Generator]) -> Tensor

Tensor.ceil() -> Tensor

Tensor.ceil(out : Tensor) -> Tensor

Tensor.ceil_() -> Tensor

Tensor.cholesky(upper : bool=False,
                out : Tensor) -> Tensor

Tensor.cholesky(upper : bool=False) -> Tensor

Tensor.cholesky_inverse(upper : bool=False,
                        out : Tensor) -> Tensor

Tensor.cholesky_inverse(upper : bool=False) -> Tensor

Tensor.cholesky_solve(input2 : Tensor,
                      upper : bool=False,
                      out : Tensor) -> Tensor

Tensor.cholesky_solve(input2 : Tensor,
                      upper : bool=False) -> Tensor

Tensor.chunk(chunks : int,
             dim : int=0) -> List[Tensor]

Tensor.clamp(min : Optional[number],
             max : Optional[number]) -> Tensor

Tensor.clamp(min : Optional[number],
             max : Optional[number],
             out : Tensor) -> Tensor

Tensor.clamp_(min : Optional[number],
              max : Optional[number]) -> Tensor

Tensor.clamp_max(max : number) -> Tensor

Tensor.clamp_max(max : number,
                 out : Tensor) -> Tensor

Tensor.clamp_max_(max : number) -> Tensor

Tensor.clamp_min(min : number) -> Tensor

Tensor.clamp_min(min : number,
                 out : Tensor) -> Tensor

Tensor.clamp_min_(min : number) -> Tensor

Tensor.clone(memory_format : Optional[int]) -> Tensor

Tensor.coalesce() -> Tensor

Tensor.conj() -> Tensor

Tensor.conj(out : Tensor) -> Tensor

Tensor.contiguous(memory_format : int=0) -> Tensor

Tensor.copy_(src : Tensor,
             non_blocking : bool=False) -> Tensor

Tensor.copy_(other : Tensor) -> Tensor

Tensor.copy_(other : int) -> Tensor

Tensor.copy_(other : float) -> Tensor

Tensor.cos() -> Tensor

Tensor.cos(out : Tensor) -> Tensor

Tensor.cos_() -> Tensor

Tensor.cosh() -> Tensor

Tensor.cosh(out : Tensor) -> Tensor

Tensor.cosh_() -> Tensor

Tensor.cpu() -> Tensor

Tensor.cross(other : Tensor,
             dim : Optional[int]) -> Tensor

Tensor.cross(other : Tensor,
             dim : Optional[int],
             out : Tensor) -> 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.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.data() -> Tensor

Tensor.deg2rad() -> Tensor

Tensor.deg2rad(out : Tensor) -> Tensor

Tensor.deg2rad_() -> Tensor

Tensor.dense_dim() -> int

Tensor.dequantize() -> Tensor

Tensor.det() -> Tensor

Tensor.detach() -> Tensor

Tensor.detach_() -> Tensor

Tensor.diag(diagonal : int=0,
            out : Tensor) -> Tensor

Tensor.diag(diagonal : int=0) -> Tensor

Tensor.diag_embed(offset : int=0,
                  dim1 : int=-2,
                  dim2 : int=-1) -> Tensor

Tensor.diagflat(offset : int=0) -> Tensor

Tensor.diagonal(offset : int=0,
                dim1 : int=0,
                dim2 : int=1) -> Tensor

Tensor.diagonal(outdim : str,
                dim1 : str,
                dim2 : str,
                offset : int=0) -> Tensor

Tensor.digamma() -> Tensor

Tensor.digamma(out : Tensor) -> Tensor

Tensor.digamma_() -> Tensor

Tensor.dim() -> int

Tensor.dist(other : Tensor,
            p : number=2) -> Tensor

Tensor.div(other : number) -> Tensor

Tensor.div(other : Tensor) -> Tensor

Tensor.div(other : Tensor,
           out : Tensor) -> Tensor

Tensor.div_(other : number) -> Tensor

Tensor.div_(other : Tensor) -> Tensor

Tensor.dot(tensor : Tensor) -> Tensor

Tensor.dot(tensor : Tensor,
           out : Tensor) -> Tensor

Tensor.eig(eigenvectors : bool=False,
           e : Tensor,
           v : Tensor) -> Tuple[Tensor, Tensor]

Tensor.eig(eigenvectors : bool=False) -> Tuple[Tensor, Tensor]

Tensor.element_size() -> int

Tensor.eq(other : number) -> Tensor

Tensor.eq(other : number,
          out : Tensor) -> Tensor

Tensor.eq(other : 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.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.fft(signal_ndim : int,
           normalized : bool=False) -> Tensor

Tensor.fill_(value : number) -> Tensor

Tensor.fill_(value : Tensor) -> Tensor

Tensor.fill_diagonal_(fill_value : number,
                      wrap : bool=False) -> 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 : int=0,
               end_dim : int=-1) -> Tensor

Tensor.flatten(start_dim : str,
               end_dim : str,
               out_dim : str) -> Tensor

Tensor.flip(dims : List[int]) -> Tensor

Tensor.fliplr() -> Tensor

Tensor.flipud() -> 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) -> Tensor

Tensor.floor_divide_(other : Tensor) -> Tensor

Tensor.fmod(other : number,
            out : Tensor) -> Tensor

Tensor.fmod(other : number) -> Tensor

Tensor.fmod(other : Tensor,
            out : Tensor) -> Tensor

Tensor.fmod(other : Tensor) -> Tensor

Tensor.fmod_(other : number) -> Tensor

Tensor.fmod_(other : Tensor) -> Tensor

Tensor.frac() -> Tensor

Tensor.frac(out : Tensor) -> Tensor

Tensor.frac_() -> Tensor

Tensor.gather(dim : int,
              index : Tensor,
              sparse_grad : bool=False,
              out : Tensor) -> Tensor

Tensor.gather(dim : int,
              index : Tensor,
              sparse_grad : bool=False) -> Tensor

Tensor.gather(dim : str,
              index : Tensor,
              sparse_grad : bool=False,
              out : Tensor) -> Tensor

Tensor.gather(dim : str,
              index : Tensor,
              sparse_grad : bool=False) -> Tensor

Tensor.ge(other : number) -> Tensor

Tensor.ge(other : number,
          out : Tensor) -> Tensor

Tensor.ge(other : 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(a : Tensor,
             tau : Tensor) -> Tuple[Tensor, Tensor]

Tensor.geqrf() -> Tuple[Tensor, Tensor]

Tensor.ger(vec2 : Tensor) -> Tensor

Tensor.ger(vec2 : Tensor,
           out : Tensor) -> Tensor

Tensor.get_device() -> int

Tensor.gt(other : number) -> Tensor

Tensor.gt(other : number,
          out : Tensor) -> Tensor

Tensor.gt(other : 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.histc(bins : int=100,
             min : number=0,
             max : number=0,
             out : Tensor) -> Tensor

Tensor.histc(bins : int=100,
             min : number=0,
             max : number=0) -> Tensor

Tensor.ifft(signal_ndim : int,
            normalized : bool=False) -> Tensor

Tensor.imag() -> Tensor

Tensor.index_add(dim : int,
                 index : Tensor,
                 source : Tensor) -> Tensor

Tensor.index_add(dim : str,
                 index : Tensor,
                 source : Tensor) -> Tensor

Tensor.index_add_(dim : int,
                  index : Tensor,
                  source : Tensor) -> Tensor

Tensor.index_copy(dim : int,
                  index : Tensor,
                  source : Tensor) -> Tensor

Tensor.index_copy(dim : str,
                  index : Tensor,
                  source : 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 : 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) -> Tensor

Tensor.index_fill(dim : int,
                  index : Tensor,
                  value : Tensor) -> 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) -> Tensor

Tensor.index_fill_(dim : int,
                   index : Tensor,
                   value : Tensor) -> Tensor

Tensor.index_put(indices : List[Optional[Tensor]],
                 values : Tensor,
                 accumulate : bool=False) -> Tensor

Tensor.index_put(indices : List[Tensor],
                 values : Tensor,
                 accumulate : bool=False) -> Tensor

Tensor.index_put_(indices : List[Optional[Tensor]],
                  values : Tensor,
                  accumulate : bool=False) -> Tensor

Tensor.index_put_(indices : List[Tensor],
                  values : Tensor,
                  accumulate : bool=False) -> Tensor

Tensor.index_select(dim : int,
                    index : Tensor,
                    out : Tensor) -> Tensor

Tensor.index_select(dim : int,
                    index : Tensor) -> Tensor

Tensor.index_select(dim : str,
                    index : Tensor,
                    out : Tensor) -> Tensor

Tensor.index_select(dim : str,
                    index : Tensor) -> Tensor

Tensor.indices() -> Tensor

Tensor.int_repr() -> Tensor

Tensor.inverse() -> Tensor

Tensor.inverse(out : Tensor) -> Tensor

Tensor.irfft(signal_ndim : int,
             normalized : bool=False,
             onesided : bool=True,
             signal_sizes : List[int]=[]) -> Tensor

Tensor.is_coalesced() -> bool

Tensor.is_complex() -> bool

Tensor.is_contiguous() -> bool

Tensor.is_distributed() -> bool

Tensor.is_floating_point() -> bool

Tensor.is_leaf() -> bool

Tensor.is_nonzero() -> bool

Tensor.is_pinned() -> bool

Tensor.is_same_size(other : Tensor) -> bool

Tensor.is_set_to(tensor : Tensor) -> bool

Tensor.is_signed() -> bool

Tensor.isclose(other : Tensor,
               rtol : float=1e-05,
               atol : float=1e-08,
               equal_nan : bool=False) -> Tensor

Tensor.isfinite() -> Tensor

Tensor.isinf() -> Tensor

Tensor.isnan() -> Tensor

Tensor.istft(n_fft : int,
             hop_length : Optional[int],
             win_length : Optional[int],
             window : Optional[Tensor],
             center : bool=True,
             normalized : bool=False,
             onesided : bool=True,
             length : Optional[int]) -> Tensor

Tensor.item() -> number

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.le(other : number) -> Tensor

Tensor.le(other : number,
          out : Tensor) -> Tensor

Tensor.le(other : 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,
            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.lerp_(end : Tensor,
             weight : number) -> Tensor

Tensor.lerp_(end : Tensor,
             weight : 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.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.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.lstsq(A : Tensor,
             X : Tensor,
             qr : Tensor) -> Tuple[Tensor, Tensor]

Tensor.lstsq(A : Tensor) -> Tuple[Tensor, Tensor]

Tensor.lt(other : number) -> Tensor

Tensor.lt(other : number,
          out : Tensor) -> Tensor

Tensor.lt(other : 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,
                out : Tensor) -> Tensor

Tensor.lu_solve(LU_data : Tensor,
                LU_pivots : Tensor) -> Tensor

Tensor.masked_fill(mask : Tensor,
                   value : number) -> Tensor

Tensor.masked_fill(mask : Tensor,
                   value : Tensor) -> Tensor

Tensor.masked_fill_(mask : Tensor,
                    value : number) -> Tensor

Tensor.masked_fill_(mask : Tensor,
                    value : Tensor) -> Tensor

Tensor.masked_scatter(mask : Tensor,
                      source : 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_power(n : int) -> 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(other : Tensor,
           out : Tensor) -> Tensor

Tensor.max(other : Tensor) -> Tensor

Tensor.mean(dtype : Optional[int]) -> Tensor

Tensor.mean(dim : 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 : List[int],
            keepdim : bool=False,
            dtype : Optional[int],
            out : Tensor) -> Tensor

Tensor.median() -> Tensor

Tensor.median(dim : int,
              keepdim : bool=False) -> Tuple[Tensor, Tensor]

Tensor.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.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(other : Tensor,
           out : Tensor) -> Tensor

Tensor.min(other : 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.mul(other : Tensor) -> Tensor

Tensor.mul(other : Tensor,
           out : Tensor) -> Tensor

Tensor.mul(other : number) -> Tensor

Tensor.mul_(other : Tensor) -> Tensor

Tensor.mul_(other : number) -> Tensor

Tensor.multinomial(num_samples : int,
                   replacement : bool=False,
                   generator : Optional[Generator],
                   out : Tensor) -> Tensor

Tensor.multinomial(num_samples : int,
                   replacement : bool=False,
                   generator : Optional[Generator]) -> Tensor

Tensor.mv(vec : Tensor) -> Tensor

Tensor.mv(vec : Tensor,
          out : Tensor) -> Tensor

Tensor.mvlgamma(p : int) -> Tensor

Tensor.mvlgamma_(p : int) -> 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.ne(other : number) -> Tensor

Tensor.ne(other : number,
          out : Tensor) -> Tensor

Tensor.ne(other : 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.new_empty(size : List[int],
                 dtype : Optional[int],
                 layout : Optional[int],
                 device : Optional[Device],
                 pin_memory : Optional[bool]) -> Tensor

Tensor.new_full(size : List[int],
                fill_value : number,
                dtype : Optional[int],
                layout : Optional[int],
                device : Optional[Device],
                pin_memory : Optional[bool]) -> Tensor

Tensor.new_zeros(size : List[int],
                 dtype : Optional[int],
                 layout : Optional[int],
                 device : Optional[Device],
                 pin_memory : Optional[bool]) -> Tensor

Tensor.nonzero(out : Tensor) -> Tensor

Tensor.nonzero() -> Tensor

Tensor.norm(p : number=2) -> Tensor

Tensor.norm(p : Optional[number],
            dim : List[int],
            keepdim : bool=False) -> Tensor

Tensor.norm(p : Optional[number],
            dim : List[str],
            keepdim : bool=False) -> Tensor

Tensor.norm(p : Optional[number],
            dtype : int) -> 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],
            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.numel() -> int

Tensor.orgqr(input2 : Tensor,
             out : Tensor) -> Tensor

Tensor.orgqr(input2 : Tensor) -> Tensor

Tensor.ormqr(input2 : Tensor,
             input3 : Tensor,
             left : bool=True,
             transpose : bool=False,
             out : Tensor) -> Tensor

Tensor.ormqr(input2 : Tensor,
             input3 : Tensor,
             left : bool=True,
             transpose : bool=False) -> Tensor

Tensor.output_nr() -> int

Tensor.permute(dims : List[int]) -> Tensor

Tensor.pin_memory() -> Tensor

Tensor.pinverse(rcond : float=1e-15) -> Tensor

Tensor.polygamma_(n : int) -> Tensor

Tensor.pow(exponent : number) -> Tensor

Tensor.pow(exponent : Tensor) -> 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.put_(index : Tensor,
            source : Tensor,
            accumulate : bool=False) -> Tensor

Tensor.q_per_channel_axis() -> int

Tensor.q_per_channel_scales() -> Tensor

Tensor.q_per_channel_zero_points() -> Tensor

Tensor.q_scale() -> float

Tensor.q_zero_point() -> int

Tensor.qr(some : bool=True,
          Q : Tensor,
          R : Tensor) -> Tuple[Tensor, Tensor]

Tensor.qr(some : bool=True) -> Tuple[Tensor, Tensor]

Tensor.qscheme() -> QScheme

Tensor.rad2deg() -> Tensor

Tensor.rad2deg(out : Tensor) -> Tensor

Tensor.rad2deg_() -> Tensor

Tensor.random_(generator : Optional[Generator]) -> Tensor

Tensor.random_(from : int,
               to : Optional[int],
               generator : Optional[Generator]) -> Tensor

Tensor.random_(to : int,
               generator : Optional[Generator]) -> Tensor

Tensor.real() -> Tensor

Tensor.reciprocal() -> Tensor

Tensor.reciprocal(out : Tensor) -> Tensor

Tensor.reciprocal_() -> Tensor

Tensor.refine_names(names : List[str]) -> Tensor

Tensor.relu() -> Tensor

Tensor.relu_() -> Tensor

Tensor.remainder(other : number,
                 out : Tensor) -> Tensor

Tensor.remainder(other : number) -> Tensor

Tensor.remainder(other : Tensor,
                 out : Tensor) -> Tensor

Tensor.remainder(other : Tensor) -> Tensor

Tensor.remainder_(other : number) -> Tensor

Tensor.remainder_(other : Tensor) -> 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_interleave(repeats : Tensor,
                         dim : Optional[int]) -> Tensor

Tensor.repeat_interleave(repeats : int,
                         dim : Optional[int]) -> Tensor

Tensor.requires_grad_(requires_grad : bool=True) -> Tensor

Tensor.requires_grad_(requires_grad : bool=True) -> Tensor

Tensor.reshape(shape : List[int]) -> Tensor

Tensor.reshape_as(other : Tensor) -> Tensor

Tensor.resize_(size : List[int],
               memory_format : Optional[int]) -> Tensor

Tensor.resize_as_(the_template : Tensor,
                  memory_format : Optional[int]) -> Tensor

Tensor.retain_grad() -> Tuple[]

Tensor.rfft(signal_ndim : int,
            normalized : bool=False,
            onesided : bool=True) -> Tensor

Tensor.roll(shifts : List[int],
            dims : List[int]=[]) -> Tensor

Tensor.rot90(k : int=1,
             dims : List[int]=[0, 1]) -> Tensor

Tensor.round() -> Tensor

Tensor.round(out : Tensor) -> Tensor

Tensor.round_() -> Tensor

Tensor.rsqrt() -> Tensor

Tensor.rsqrt(out : Tensor) -> Tensor

Tensor.rsqrt_() -> Tensor

Tensor.scatter(dim : int,
               index : Tensor,
               src : Tensor) -> Tensor

Tensor.scatter(dim : int,
               index : Tensor,
               value : number) -> Tensor

Tensor.scatter(dim : 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_add(dim : int,
                   index : Tensor,
                   src : Tensor) -> Tensor

Tensor.scatter_add(dim : str,
                   index : Tensor,
                   src : Tensor) -> Tensor

Tensor.scatter_add_(dim : int,
                    index : Tensor,
                    src : Tensor) -> Tensor

Tensor.select(dim : str,
              index : int) -> Tensor

Tensor.select(dim : int,
              index : int) -> Tensor

Tensor.set_(source : int) -> Tensor

Tensor.set_(source : int,
            storage_offset : int,
            size : List[int],
            stride : List[int]=[]) -> Tensor

Tensor.set_(source : Tensor) -> Tensor

Tensor.set_() -> Tensor

Tensor.sigmoid() -> Tensor

Tensor.sigmoid(out : Tensor) -> Tensor

Tensor.sigmoid_() -> Tensor

Tensor.sign() -> Tensor

Tensor.sign(out : Tensor) -> Tensor

Tensor.sign_() -> Tensor

Tensor.sin() -> Tensor

Tensor.sin(out : Tensor) -> Tensor

Tensor.sin_() -> Tensor

Tensor.sinh() -> Tensor

Tensor.sinh(out : Tensor) -> Tensor

Tensor.sinh_() -> Tensor

Tensor.size(dim : int) -> int

Tensor.size(dim : str) -> int

Tensor.size() -> List[int]

Tensor.slogdet() -> 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.solve(A : Tensor) -> Tuple[Tensor, Tensor]

Tensor.solve(A : Tensor,
             solution : Tensor,
             lu : Tensor) -> Tuple[Tensor, Tensor]

Tensor.sort(dim : int=-1,
            descending : bool=False,
            values : Tensor,
            indices : Tensor) -> Tuple[Tensor, Tensor]

Tensor.sort(dim : int=-1,
            descending : bool=False) -> Tuple[Tensor, Tensor]

Tensor.sort(dim : str,
            descending : bool=False,
            values : Tensor,
            indices : Tensor) -> Tuple[Tensor, Tensor]

Tensor.sort(dim : str,
            descending : bool=False) -> Tuple[Tensor, Tensor]

Tensor.sparse_dim() -> int

Tensor.sparse_mask(mask : Tensor) -> Tensor

Tensor.sparse_resize_(size : List[int],
                      sparse_dim : int,
                      dense_dim : int) -> Tensor

Tensor.sparse_resize_and_clear_(size : List[int],
                                sparse_dim : int,
                                dense_dim : int) -> Tensor

Tensor.split(split_size : int,
             dim : int=0) -> List[Tensor]

Tensor.split(split_sizes : List[int],
             dim : int=0) -> List[Tensor]

Tensor.split_with_sizes(split_sizes : List[int],
                        dim : int=0) -> List[Tensor]

Tensor.sqrt() -> Tensor

Tensor.sqrt(out : Tensor) -> Tensor

Tensor.sqrt_() -> Tensor

Tensor.square() -> Tensor

Tensor.square_() -> Tensor

Tensor.squeeze() -> Tensor

Tensor.squeeze(dim : int) -> Tensor

Tensor.squeeze(dim : str) -> Tensor

Tensor.squeeze_() -> Tensor

Tensor.squeeze_(dim : 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 : List[int],
           unbiased : bool=True,
           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 : List[int],
           unbiased : bool=True,
           keepdim : bool=False,
           out : Tensor) -> Tensor

Tensor.stft(n_fft : int,
            hop_length : Optional[int],
            win_length : Optional[int],
            window : Optional[Tensor],
            normalized : bool=False,
            onesided : bool=True) -> Tensor

Tensor.storage_offset() -> int

Tensor.stride(dim : str) -> int

Tensor.stride(dim : int) -> int

Tensor.sub(other : number,
           alpha : number=1) -> Tensor

Tensor.sub(other : Tensor,
           alpha : number=1) -> Tensor

Tensor.sub(other : Tensor,
           alpha : number=1,
           out : Tensor) -> Tensor

Tensor.sub_(other : number,
            alpha : number=1) -> Tensor

Tensor.sub_(other : Tensor,
            alpha : number=1) -> Tensor

Tensor.sum(dim : 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 : List[int],
           keepdim : bool=False,
           dtype : Optional[int],
           out : Tensor) -> Tensor

Tensor.sum_to_size(size : List[int]) -> Tensor

Tensor.svd(some : bool=True,
           compute_uv : bool=True,
           U : Tensor,
           S : Tensor,
           V : Tensor) -> Tuple[Tensor, Tensor, Tensor]

Tensor.svd(some : bool=True,
           compute_uv : bool=True) -> Tuple[Tensor, Tensor, Tensor]

Tensor.symeig(eigenvectors : bool=False,
              upper : bool=True,
              e : Tensor,
              V : Tensor) -> Tuple[Tensor, Tensor]

Tensor.symeig(eigenvectors : bool=False,
              upper : bool=True) -> Tuple[Tensor, Tensor]

Tensor.t() -> Tensor

Tensor.t_() -> Tensor

Tensor.take(index : Tensor,
            out : Tensor) -> Tensor

Tensor.take(index : 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.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(dtype : int,
          layout : int,
          device : Device,
          pin_memory : bool=False,
          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(device : Optional[Device],
          dtype : Optional[int],
          non_blocking : bool=False,
          copy : bool=False) -> Tensor

Tensor.to(dtype : Optional[int],
          non_blocking : bool=False,
          copy : bool=False) -> Tensor

Tensor.to(non_blocking : bool=False,
          copy : bool=False) -> Tensor

Tensor.to_dense() -> Tensor

Tensor.to_mkldnn() -> Tensor

Tensor.to_sparse(sparse_dim : int) -> Tensor

Tensor.to_sparse() -> Tensor

Tensor.topk(k : int,
            dim : int=-1,
            largest : bool=True,
            sorted : bool=True,
            values : Tensor,
            indices : Tensor) -> Tuple[Tensor, Tensor]

Tensor.topk(k : int,
            dim : int=-1,
            largest : bool=True,
            sorted : bool=True) -> Tuple[Tensor, Tensor]

Tensor.trace() -> Tensor

Tensor.transpose(dim0 : str,
                 dim1 : str) -> Tensor

Tensor.transpose(dim0 : int,
                 dim1 : int) -> Tensor

Tensor.transpose_(dim0 : int,
                  dim1 : int) -> Tensor

Tensor.triangular_solve(A : Tensor,
                        upper : bool=True,
                        transpose : bool=False,
                        unitriangular : bool=False,
                        X : Tensor,
                        M : Tensor) -> Tuple[Tensor, Tensor]

Tensor.triangular_solve(A : Tensor,
                        upper : bool=True,
                        transpose : bool=False,
                        unitriangular : bool=False) -> Tuple[Tensor, Tensor]

Tensor.tril(diagonal : int=0,
            out : Tensor) -> Tensor

Tensor.tril(diagonal : int=0) -> Tensor

Tensor.tril_(diagonal : int=0) -> Tensor

Tensor.triu(diagonal : int=0,
            out : Tensor) -> Tensor

Tensor.triu(diagonal : int=0) -> Tensor

Tensor.triu_(diagonal : int=0) -> Tensor

Tensor.true_divide(other : number) -> Tensor

Tensor.true_divide(other : Tensor) -> Tensor

Tensor.true_divide(other : Tensor,
                   out : Tensor) -> Tensor

Tensor.true_divide_(other : number) -> Tensor

Tensor.true_divide_(other : Tensor) -> Tensor

Tensor.trunc() -> Tensor

Tensor.trunc(out : Tensor) -> Tensor

Tensor.trunc_() -> Tensor

Tensor.type_as(other : Tensor) -> Tensor

Tensor.unbind(dim : str) -> List[Tensor]

Tensor.unbind(dim : int=0) -> List[Tensor]

Tensor.unflatten(dim : str,
                 sizes : List[int],
                 names : List[str]) -> Tensor

Tensor.unflatten(dim : int,
                 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.unsqueeze(dim : int) -> Tensor

Tensor.unsqueeze_(dim : int) -> Tensor

Tensor.values() -> Tensor

Tensor.var(unbiased : bool=True) -> Tensor

Tensor.var(dim : List[int],
           unbiased : bool=True,
           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 : List[int],
           unbiased : bool=True,
           keepdim : bool=False,
           out : Tensor) -> Tensor

Tensor.view(size : List[int]) -> Tensor

Tensor.view_as(other : Tensor) -> Tensor

Tensor.zero_() -> Tensor

Supported PyTorch Functions

torch.nn.functional.adaptive_avg_pool2d(input : Tensor,
                                        output_size : List[int]) -> Tensor

torch.nn.functional.adaptive_avg_pool3d(input : Tensor,
                                        output_size : List[int]) -> Tensor

torch.nn.functional.adaptive_max_pool1d_with_indices(input : Tensor,
                                                     output_size : List[int],
                                                     return_indices : bool=False) -> Tuple[Tensor, Tensor]

torch.nn.functional.adaptive_max_pool2d_with_indices(input : Tensor,
                                                     output_size : List[int],
                                                     return_indices : bool=False) -> Tuple[Tensor, Tensor]

torch.nn.functional.adaptive_max_pool3d_with_indices(input : Tensor,
                                                     output_size : List[int],
                                                     return_indices : bool=False) -> Tuple[Tensor, Tensor]

torch.nn.functional.affine_grid(theta : Tensor,
                                size : List[int],
                                align_corners : Optional[bool]) -> Tensor

torch.nn.functional.alpha_dropout(input : Tensor,
                                  p : float=0.5,
                                  training : bool=False,
                                  inplace : bool=False) -> Tensor

torch.nn.functional.assert_int_or_pair(arg : List[int],
                                       arg_name : str,
                                       message : str) -> None

torch.nn.functional.batch_norm(input : Tensor,
                               running_mean : Optional[Tensor],
                               running_var : Optional[Tensor],
                               weight : Optional[Tensor],
                               bias : Optional[Tensor],
                               training : bool=False,
                               momentum : float=0.1,
                               eps : float=1e-05) -> Tensor

torch.nn.functional.bilinear(input1 : Tensor,
                             input2 : Tensor,
                             weight : Tensor,
                             bias : Optional[Tensor]) -> Tensor

torch.nn.functional.binary_cross_entropy(input : Tensor,
                                         target : Tensor,
                                         weight : Optional[Tensor],
                                         size_average : Optional[bool],
                                         reduce : Optional[bool],
                                         reduction : str=mean) -> Tensor

torch.nn.functional.binary_cross_entropy_with_logits(input : Tensor,
                                                     target : Tensor,
                                                     weight : Optional[Tensor],
                                                     size_average : Optional[bool],
                                                     reduce : Optional[bool],
                                                     reduction : str=mean,
                                                     pos_weight : Optional[Tensor]) -> Tensor

torch.nn.functional.celu(input : Tensor,
                         alpha : float=1.0,
                         inplace : bool=False) -> Tensor

torch.nn.functional.cosine_embedding_loss(input1 : Tensor,
                                          input2 : Tensor,
                                          target : Tensor,
                                          margin : float=0.0,
                                          size_average : Optional[bool],
                                          reduce : Optional[bool],
                                          reduction : str=mean) -> Tensor

torch.nn.functional.cross_entropy(input : Tensor,
                                  target : Tensor,
                                  weight : Optional[Tensor],
                                  size_average : Optional[bool],
                                  ignore_index : int=-100,
                                  reduce : Optional[bool],
                                  reduction : str=mean) -> Tensor

torch.nn.functional.ctc_loss(log_probs : Tensor,
                             targets : Tensor,
                             input_lengths : Tensor,
                             target_lengths : Tensor,
                             blank : int=0,
                             reduction : str=mean,
                             zero_infinity : bool=False) -> Tensor

torch.nn.functional.dropout(input : Tensor,
                            p : float=0.5,
                            training : bool=True,
                            inplace : bool=False) -> Tensor

torch.nn.functional.dropout2d(input : Tensor,
                              p : float=0.5,
                              training : bool=True,
                              inplace : bool=False) -> Tensor

torch.nn.functional.dropout3d(input : Tensor,
                              p : float=0.5,
                              training : bool=True,
                              inplace : bool=False) -> Tensor

torch.nn.functional.elu(input : Tensor,
                        alpha : float=1.0,
                        inplace : bool=False) -> Tensor

torch.nn.functional.embedding(input : Tensor,
                              weight : Tensor,
                              padding_idx : Optional[int],
                              max_norm : Optional[float],
                              norm_type : float=2.0,
                              scale_grad_by_freq : bool=False,
                              sparse : bool=False) -> Tensor

torch.nn.functional.embedding_bag(input : Tensor,
                                  weight : Tensor,
                                  offsets : Optional[Tensor],
                                  max_norm : Optional[float],
                                  norm_type : float=2.0,
                                  scale_grad_by_freq : bool=False,
                                  mode : str=mean,
                                  sparse : bool=False,
                                  per_sample_weights : Optional[Tensor],
                                  include_last_offset : bool=False) -> Tensor

torch.nn.functional.feature_alpha_dropout(input : Tensor,
                                          p : float=0.5,
                                          training : bool=False,
                                          inplace : bool=False) -> Tensor

torch.nn.functional.fold(input : Tensor,
                         output_size : List[int],
                         kernel_size : List[int],
                         dilation : List[int]=1,
                         padding : List[int]=0,
                         stride : List[int]=1) -> Tensor

torch.nn.functional.fractional_max_pool2d_with_indices(input : Tensor,
                                                       kernel_size : List[int],
                                                       output_size : Optional[List[int]],
                                                       output_ratio : Optional[List[float]],
                                                       return_indices : bool=False,
                                                       _random_samples : Optional[Tensor]) -> Tuple[Tensor, Tensor]

torch.nn.functional.fractional_max_pool3d_with_indices(input : Tensor,
                                                       kernel_size : List[int],
                                                       output_size : Optional[List[int]],
                                                       output_ratio : Optional[List[float]],
                                                       return_indices : bool=False,
                                                       _random_samples : Optional[Tensor]) -> Tuple[Tensor, Tensor]

torch.nn.functional.gelu(input : Tensor) -> Tensor

torch.nn.functional.glu(input : Tensor,
                        dim : int=-1) -> Tensor

torch.nn.functional.grid_sample(input : Tensor,
                                grid : Tensor,
                                mode : str=bilinear,
                                padding_mode : str=zeros,
                                align_corners : Optional[bool]) -> Tensor

torch.nn.functional.group_norm(input : Tensor,
                               num_groups : int,
                               weight : Optional[Tensor],
                               bias : Optional[Tensor],
                               eps : float=1e-05) -> Tensor

torch.nn.functional.gumbel_softmax(logits : Tensor,
                                   tau : float=1.0,
                                   hard : bool=False,
                                   eps : float=1e-10,
                                   dim : int=-1) -> Tensor

torch.nn.functional.hardshrink(input : Tensor,
                               lambd : float=0.5) -> Tensor

torch.nn.functional.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.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.linear(input : Tensor,
                           weight : Tensor,
                           bias : Optional[Tensor]) -> Tensor

torch.nn.functional.local_response_norm(input : Tensor,
                                        size : int,
                                        alpha : float=0.0001,
                                        beta : float=0.75,
                                        k : float=1.0) -> Tensor

torch.nn.functional.log_softmax(input : Tensor,
                                dim : Optional[int],
                                _stacklevel : int=3,
                                dtype : Optional[int]) -> Tensor

torch.nn.functional.lp_pool1d(input : Tensor,
                              norm_type : float,
                              kernel_size : int,
                              stride : Optional[List[int]],
                              ceil_mode : bool=False) -> Tensor

torch.nn.functional.lp_pool2d(input : Tensor,
                              norm_type : float,
                              kernel_size : int,
                              stride : Optional[List[int]],
                              ceil_mode : bool=False) -> Tensor

torch.nn.functional.margin_ranking_loss(input1 : Tensor,
                                        input2 : Tensor,
                                        target : Tensor,
                                        margin : float=0.0,
                                        size_average : Optional[bool],
                                        reduce : Optional[bool],
                                        reduction : str=mean) -> Tensor

torch.nn.functional.max_pool1d_with_indices(input : Tensor,
                                            kernel_size : List[int],
                                            stride : Optional[List[int]],
                                            padding : List[int]=0,
                                            dilation : List[int]=1,
                                            ceil_mode : bool=False,
                                            return_indices : bool=False) -> Tuple[Tensor, Tensor]

torch.nn.functional.max_pool2d_with_indices(input : Tensor,
                                            kernel_size : List[int],
                                            stride : Optional[List[int]],
                                            padding : List[int]=0,
                                            dilation : List[int]=1,
                                            ceil_mode : bool=False,
                                            return_indices : bool=False) -> Tuple[Tensor, Tensor]

torch.nn.functional.max_pool3d_with_indices(input : Tensor,
                                            kernel_size : List[int],
                                            stride : Optional[List[int]],
                                            padding : List[int]=0,
                                            dilation : List[int]=1,
                                            ceil_mode : bool=False,
                                            return_indices : bool=False) -> Tuple[Tensor, Tensor]

torch.nn.functional.max_unpool1d(input : Tensor,
                                 indices : Tensor,
                                 kernel_size : List[int],
                                 stride : Optional[List[int]],
                                 padding : List[int]=0,
                                 output_size : Optional[List[int]]) -> Tensor

torch.nn.functional.max_unpool2d(input : Tensor,
                                 indices : Tensor,
                                 kernel_size : List[int],
                                 stride : Optional[List[int]],
                                 padding : List[int]=0,
                                 output_size : Optional[List[int]]) -> Tensor

torch.nn.functional.max_unpool3d(input : Tensor,
                                 indices : Tensor,
                                 kernel_size : List[int],
                                 stride : Optional[List[int]],
                                 padding : List[int]=0,
                                 output_size : Optional[List[int]]) -> Tensor

torch.nn.functional.mse_loss(input : Tensor,
                             target : Tensor,
                             size_average : Optional[bool],
                             reduce : Optional[bool],
                             reduction : str=mean) -> Tensor

torch.nn.functional.multi_head_attention_forward(query : Tensor,
                                                 key : Tensor,
                                                 value : Tensor,
                                                 embed_dim_to_check : int,
                                                 num_heads : int,
                                                 in_proj_weight : Tensor,
                                                 in_proj_bias : Tensor,
                                                 bias_k : Optional[Tensor],
                                                 bias_v : Optional[Tensor],
                                                 add_zero_attn : bool,
                                                 dropout_p : float,
                                                 out_proj_weight : Tensor,
                                                 out_proj_bias : Tensor,
                                                 training : bool=True,
                                                 key_padding_mask : Optional[Tensor],
                                                 need_weights : bool=True,
                                                 attn_mask : Optional[Tensor],
                                                 use_separate_proj_weight : bool=False,
                                                 q_proj_weight : Optional[Tensor],
                                                 k_proj_weight : Optional[Tensor],
                                                 v_proj_weight : Optional[Tensor],
                                                 static_k : Optional[Tensor],
                                                 static_v : Optional[Tensor]) -> Tuple[Tensor, Optional[Tensor]]

torch.nn.functional.multi_margin_loss(input : Tensor,
                                      target : Tensor,
                                      p : int=1,
                                      margin : float=1.0,
                                      weight : Optional[Tensor],
                                      size_average : Optional[bool],
                                      reduce : Optional[bool],
                                      reduction : str=mean) -> Tensor

torch.nn.functional.multilabel_margin_loss(input : Tensor,
                                           target : Tensor,
                                           size_average : Optional[bool],
                                           reduce : Optional[bool],
                                           reduction : str=mean) -> Tensor

torch.nn.functional.multilabel_soft_margin_loss(input : Tensor,
                                                target : Tensor,
                                                weight : Optional[Tensor],
                                                size_average : Optional[bool],
                                                reduce : Optional[bool],
                                                reduction : str=mean) -> Tensor

torch.nn.functional.nll_loss(input : Tensor,
                             target : Tensor,
                             weight : Optional[Tensor],
                             size_average : Optional[bool],
                             ignore_index : int=-100,
                             reduce : Optional[bool],
                             reduction : str=mean) -> Tensor

torch.nn.functional.normalize(input : Tensor,
                              p : float=2.0,
                              dim : int=1,
                              eps : float=1e-12,
                              out : Optional[Tensor]) -> Tensor

torch.nn.functional.pad(input : Tensor,
                        pad : List[int],
                        mode : str=constant,
                        value : float=0.0) -> Tensor

torch.nn.functional.pairwise_distance(x1 : Tensor,
                                      x2 : Tensor,
                                      p : float=2.0,
                                      eps : float=1e-06,
                                      keepdim : bool=False) -> Tensor

torch.nn.functional.poisson_nll_loss(input : Tensor,
                                     target : Tensor,
                                     log_input : bool=True,
                                     full : bool=False,
                                     size_average : Optional[bool],
                                     eps : float=1e-08,
                                     reduce : Optional[bool],
                                     reduction : str=mean) -> Tensor

torch.nn.functional.prelu(input : Tensor,
                          weight : Tensor) -> Tensor

torch.nn.functional.relu(input : Tensor,
                         inplace : bool=False) -> Tensor

torch.nn.functional.relu6(input : Tensor,
                          inplace : bool=False) -> Tensor

torch.nn.functional.rrelu(input : Tensor,
                          lower : float=0.125,
                          upper : float=0.3333333333333333,
                          training : bool=False,
                          inplace : bool=False) -> Tensor

torch.nn.functional.selu(input : Tensor,
                         inplace : bool=False) -> Tensor

torch.nn.functional.sigmoid(input : Tensor) -> Tensor

torch.nn.functional.smooth_l1_loss(input : Tensor,
                                   target : Tensor,
                                   size_average : Optional[bool],
                                   reduce : Optional[bool],
                                   reduction : str=mean) -> Tensor

torch.nn.functional.soft_margin_loss(input : Tensor,
                                     target : Tensor,
                                     size_average : Optional[bool],
                                     reduce : Optional[bool],
                                     reduction : str=mean) -> Tensor

torch.nn.functional.softmax(input : Tensor,
                            dim : Optional[int],
                            _stacklevel : int=3,
                            dtype : Optional[int]) -> Tensor

torch.nn.functional.softmin(input : Tensor,
                            dim : Optional[int],
                            _stacklevel : int=3,
                            dtype : Optional[int]) -> Tensor

torch.nn.functional.softsign(input : Tensor) -> Tensor

torch.nn.functional.tanh(input : Tensor) -> Tensor

torch.nn.functional.tanhshrink(input : Tensor) -> Tensor

torch.nn.functional.threshold(input : Tensor,
                              threshold : float,
                              value : float,
                              inplace : bool=False) -> Tensor

torch.nn.functional.triplet_margin_loss(anchor : Tensor,
                                        positive : Tensor,
                                        negative : Tensor,
                                        margin : float=1.0,
                                        p : float=2.0,
                                        eps : float=1e-06,
                                        swap : bool=False,
                                        size_average : Optional[bool],
                                        reduce : Optional[bool],
                                        reduction : str=mean) -> Tensor

torch.nn.functional.unfold(input : Tensor,
                           kernel_size : List[int],
                           dilation : List[int]=1,
                           padding : List[int]=0,
                           stride : List[int]=1) -> Tensor

torch.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.absolute_(self : 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 : 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 : 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 : number,
          alpha : number=1) -> Tensor

torch.add(self : Tensor,
          other : Tensor,
          alpha : number=1) -> Tensor

torch.add(self : Tensor,
          other : Tensor,
          alpha : number=1,
          out : Tensor) -> Tensor

torch.add(a : List[t],
          b : List[t]) -> List[t]

torch.add(a : int,
          b : int) -> int

torch.add(a : float,
          b : float) -> float

torch.add(a : int,
          b : float) -> float

torch.add(a : float,
          b : int) -> float

torch.add(a : number,
          b : number) -> number

torch.add(a : str,
          b : str) -> str

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.affine_grid_generator(theta : Tensor,
                            size : List[int],
                            align_corners : bool) -> Tensor

torch.align_tensors(tensors : List[Tensor]) -> List[Tensor]

torch.all(self : Tensor) -> Tensor

torch.all(self : Tensor,
          dim : int,
          keepdim : bool=False) -> Tensor

torch.all(self : Tensor,
          dim : int,
          keepdim : bool=False,
          out : Tensor) -> Tensor

torch.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.angle(self : Tensor) -> Tensor

torch.angle(self : Tensor,
            out : Tensor) -> Tensor

torch.any(self : Tensor) -> Tensor

torch.any(self : Tensor,
          dim : int,
          keepdim : bool=False) -> Tensor

torch.any(self : Tensor,
          dim : int,
          keepdim : bool=False,
          out : Tensor) -> Tensor

torch.any(self : Tensor,
          dim : str,
          keepdim : bool=False) -> Tensor

torch.any(self : Tensor,
          dim : str,
          keepdim : bool=False,
          out : Tensor) -> Tensor

torch.arange(end : number,
             dtype : Optional[int],
             layout : Optional[int],
             device : Optional[Device],
             pin_memory : Optional[bool]) -> Tensor

torch.arange(start : number,
             end : number,
             dtype : Optional[int],
             layout : Optional[int],
             device : Optional[Device],
             pin_memory : Optional[bool]) -> Tensor

torch.arange(start : number,
             end : number,
             step : number,
             dtype : Optional[int],
             layout : Optional[int],
             device : Optional[Device],
             pin_memory : Optional[bool]) -> Tensor

torch.arange(start : number,
             end : number,
             step : number=1,
             out : Tensor) -> Tensor

torch.arange(end : number,
             out : Tensor) -> Tensor

torch.argmax(self : Tensor,
             dim : Optional[int],
             keepdim : bool=False) -> Tensor

torch.argmin(self : Tensor,
             dim : Optional[int],
             keepdim : bool=False) -> Tensor

torch.argsort(self : Tensor,
              dim : int=-1,
              descending : bool=False) -> Tensor

torch.argsort(self : Tensor,
              dim : str,
              descending : bool=False) -> Tensor

torch.as_strided(self : Tensor,
                 size : List[int],
                 stride : List[int],
                 storage_offset : Optional[int]) -> Tensor

torch.as_strided_(self : Tensor,
                  size : List[int],
                  stride : List[int],
                  storage_offset : Optional[int]) -> Tensor

torch.as_tensor(t : float,
                dtype : Optional[int],
                device : Optional[Device]) -> Tensor

torch.as_tensor(t : int,
                dtype : Optional[int],
                device : Optional[Device]) -> Tensor

torch.as_tensor(t : bool,
                dtype : Optional[int],
                device : Optional[Device]) -> Tensor

torch.as_tensor(data : Tensor,
                dtype : Optional[int],
                device : Optional[Device]) -> Tensor

torch.as_tensor(data : List[t],
                dtype : Optional[int],
                device : Optional[Device]) -> Tensor

torch.asin(self : Tensor) -> Tensor

torch.asin(self : Tensor,
           out : Tensor) -> Tensor

torch.asin(a : int) -> float

torch.asin(a : float) -> float

torch.asin(a : number) -> number

torch.asin_(self : Tensor) -> Tensor

torch.asinh(self : Tensor) -> Tensor

torch.asinh(self : Tensor,
            out : Tensor) -> Tensor

torch.asinh(a : int) -> float

torch.asinh(a : float) -> float

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 : 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 : number) -> number

torch.atanh_(self : Tensor) -> Tensor

torch.avg_pool1d(self : Tensor,
                 kernel_size : List[int],
                 stride : List[int]=[],
                 padding : List[int]=[0],
                 ceil_mode : bool=False,
                 count_include_pad : bool=True) -> Tensor

torch.baddbmm(self : Tensor,
              batch1 : Tensor,
              batch2 : Tensor,
              beta : number=1,
              alpha : number=1) -> Tensor

torch.baddbmm(self : Tensor,
              batch1 : Tensor,
              batch2 : Tensor,
              beta : number=1,
              alpha : number=1,
              out : Tensor) -> Tensor

torch.bartlett_window(window_length : int,
                      dtype : Optional[int],
                      layout : Optional[int],
                      device : Optional[Device],
                      pin_memory : Optional[bool]) -> Tensor

torch.bartlett_window(window_length : int,
                      periodic : bool,
                      dtype : Optional[int],
                      layout : Optional[int],
                      device : Optional[Device],
                      pin_memory : Optional[bool]) -> Tensor

torch.batch_norm(input : Tensor,
                 weight : Optional[Tensor],
                 bias : Optional[Tensor],
                 running_mean : Optional[Tensor],
                 running_var : Optional[Tensor],
                 training : bool,
                 momentum : float,
                 eps : float,
                 cudnn_enabled : bool) -> Tensor

torch.batch_norm_backward_elemt(grad_out : Tensor,
                                input : Tensor,
                                mean : Tensor,
                                invstd : Tensor,
                                weight : Optional[Tensor],
                                mean_dy : Tensor,
                                mean_dy_xmu : Tensor) -> Tensor

torch.batch_norm_backward_reduce(grad_out : Tensor,
                                 input : Tensor,
                                 mean : Tensor,
                                 invstd : Tensor,
                                 weight : Optional[Tensor],
                                 input_g : bool,
                                 weight_g : bool,
                                 bias_g : bool) -> Tuple[Tensor, Tensor, Tensor, Tensor]

torch.batch_norm_elemt(input : Tensor,
                       weight : Optional[Tensor],
                       bias : Optional[Tensor],
                       mean : Tensor,
                       invstd : Tensor,
                       eps : float) -> Tensor

torch.batch_norm_elemt(input : Tensor,
                       weight : Optional[Tensor],
                       bias : Optional[Tensor],
                       mean : Tensor,
                       invstd : Tensor,
                       eps : float,
                       out : Tensor) -> Tensor

torch.batch_norm_gather_stats(input : Tensor,
                              mean : Tensor,
                              invstd : Tensor,
                              running_mean : Optional[Tensor],
                              running_var : Optional[Tensor],
                              momentum : float,
                              eps : float,
                              count : int) -> Tuple[Tensor, Tensor]

torch.batch_norm_gather_stats_with_counts(input : Tensor,
                                          mean : Tensor,
                                          invstd : Tensor,
                                          running_mean : Optional[Tensor],
                                          running_var : Optional[Tensor],
                                          momentum : float,
                                          eps : float,
                                          counts : 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.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.bilinear(input1 : Tensor,
               input2 : Tensor,
               weight : Tensor,
               bias : Optional[Tensor]) -> Tensor

torch.binary_cross_entropy_with_logits(self : Tensor,
                                       target : Tensor,
                                       weight : Optional[Tensor],
                                       pos_weight : Optional[Tensor],
                                       reduction : int=1) -> Tensor

torch.bincount(self : Tensor,
               weights : Optional[Tensor],
               minlength : int=0) -> Tensor

torch.binomial(count : Tensor,
               prob : Tensor,
               generator : Optional[Generator]) -> 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 : Tensor,
                  other : number) -> Tensor

torch.bitwise_and(self : Tensor,
                  other : Tensor) -> Tensor

torch.bitwise_not(self : Tensor) -> Tensor

torch.bitwise_not(self : Tensor,
                  out : 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 : Tensor,
                 other : number) -> Tensor

torch.bitwise_or(self : Tensor,
                 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 : Tensor,
                  other : number) -> Tensor

torch.bitwise_xor(self : Tensor,
                  other : 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.block_diag(tensors : List[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.bucketize(self : Tensor,
                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) -> 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.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) -> Tensor

torch.chain_matmul(matrices : List[Tensor]) -> Tensor

torch.channel_shuffle(self : Tensor,
                      groups : int) -> Tensor

torch.cholesky(self : Tensor,
               upper : bool=False,
               out : Tensor) -> Tensor

torch.cholesky(self : Tensor,
               upper : bool=False) -> Tensor

torch.cholesky_inverse(self : Tensor,
                       upper : bool=False,
                       out : Tensor) -> Tensor

torch.cholesky_inverse(self : Tensor,
                       upper : bool=False) -> Tensor

torch.cholesky_solve(self : Tensor,
                     input2 : Tensor,
                     upper : bool=False,
                     out : Tensor) -> Tensor

torch.cholesky_solve(self : Tensor,
                     input2 : Tensor,
                     upper : bool=False) -> Tensor

torch.chunk(self : Tensor,
            chunks : int,
            dim : int=0) -> List[Tensor]

torch.clamp(self : Tensor,
            min : Optional[number],
            max : Optional[number]) -> Tensor

torch.clamp(self : Tensor,
            min : Optional[number],
            max : Optional[number],
            out : Tensor) -> Tensor

torch.clamp_(self : Tensor,
             min : Optional[number],
             max : Optional[number]) -> Tensor

torch.clamp_max(self : Tensor,
                max : number) -> Tensor

torch.clamp_max(self : Tensor,
                max : number,
                out : Tensor) -> Tensor

torch.clamp_max_(self : Tensor,
                 max : number) -> Tensor

torch.clamp_min(self : Tensor,
                min : number) -> Tensor

torch.clamp_min(self : Tensor,
                min : number,
                out : Tensor) -> Tensor

torch.clamp_min_(self : Tensor,
                 min : number) -> Tensor

torch.clone(self : Tensor,
            memory_format : Optional[int]) -> Tensor

torch.combinations(self : Tensor,
                   r : int=2,
                   with_replacement : bool=False) -> Tensor

torch.conj(self : Tensor) -> Tensor

torch.conj(self : Tensor,
           out : Tensor) -> Tensor

torch.constant_pad_nd(self : Tensor,
                      pad : List[int],
                      value : number=0) -> Tensor

torch.conv1d(input : Tensor,
             weight : Tensor,
             bias : Optional[Tensor],
             stride : List[int]=[1],
             padding : List[int]=[0],
             dilation : List[int]=[1],
             groups : int=1) -> Tensor

torch.conv2d(input : Tensor,
             weight : Tensor,
             bias : Optional[Tensor],
             stride : List[int]=[1, 1],
             padding : List[int]=[0, 0],
             dilation : List[int]=[1, 1],
             groups : int=1) -> Tensor

torch.conv3d(input : Tensor,
             weight : Tensor,
             bias : Optional[Tensor],
             stride : List[int]=[1, 1, 1],
             padding : List[int]=[0, 0, 0],
             dilation : List[int]=[1, 1, 1],
             groups : int=1) -> Tensor

torch.conv_tbc(self : Tensor,
               weight : Tensor,
               bias : Tensor,
               pad : int=0) -> Tensor

torch.conv_transpose1d(input : Tensor,
                       weight : Tensor,
                       bias : Optional[Tensor],
                       stride : List[int]=[1],
                       padding : List[int]=[0],
                       output_padding : List[int]=[0],
                       groups : int=1,
                       dilation : List[int]=[1]) -> Tensor

torch.conv_transpose2d(input : Tensor,
                       weight : Tensor,
                       bias : Optional[Tensor],
                       stride : List[int]=[1, 1],
                       padding : List[int]=[0, 0],
                       output_padding : List[int]=[0, 0],
                       groups : int=1,
                       dilation : List[int]=[1, 1]) -> Tensor

torch.conv_transpose3d(input : Tensor,
                       weight : Tensor,
                       bias : Optional[Tensor],
                       stride : List[int]=[1, 1, 1],
                       padding : List[int]=[0, 0, 0],
                       output_padding : List[int]=[0, 0, 0],
                       groups : int=1,
                       dilation : List[int]=[1, 1, 1]) -> Tensor

torch.convolution(input : Tensor,
                  weight : Tensor,
                  bias : Optional[Tensor],
                  stride : List[int],
                  padding : List[int],
                  dilation : List[int],
                  transposed : bool,
                  output_padding : List[int],
                  groups : int) -> Tensor

torch.cos(self : Tensor) -> Tensor

torch.cos(self : Tensor,
          out : Tensor) -> Tensor

torch.cos(a : int) -> float

torch.cos(a : float) -> float

torch.cos(a : number) -> number

torch.cos_(self : Tensor) -> Tensor

torch.cosh(self : Tensor) -> Tensor

torch.cosh(self : Tensor,
           out : Tensor) -> Tensor

torch.cosh(a : int) -> float

torch.cosh(a : float) -> float

torch.cosh(a : number) -> number

torch.cosh_(self : Tensor) -> Tensor

torch.cosine_embedding_loss(input1 : Tensor,
                            input2 : Tensor,
                            target : Tensor,
                            margin : float=0.0,
                            reduction : int=1) -> Tensor

torch.cosine_similarity(x1 : Tensor,
                        x2 : Tensor,
                        dim : int=1,
                        eps : float=1e-08) -> Tensor

torch.cross(self : Tensor,
            other : Tensor,
            dim : Optional[int]) -> Tensor

torch.cross(self : Tensor,
            other : Tensor,
            dim : Optional[int],
            out : 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) -> Tensor

torch.cudnn_batch_norm(input : Tensor,
                       weight : Tensor,
                       bias : Optional[Tensor],
                       running_mean : Optional[Tensor],
                       running_var : Optional[Tensor],
                       training : bool,
                       exponential_average_factor : float,
                       epsilon : float) -> Tuple[Tensor, Tensor, Tensor, Tensor]

torch.cudnn_convolution(self : Tensor,
                        weight : Tensor,
                        bias : Optional[Tensor],
                        padding : List[int],
                        stride : List[int],
                        dilation : List[int],
                        groups : int,
                        benchmark : bool,
                        deterministic : bool) -> Tensor

torch.cudnn_convolution(self : Tensor,
                        weight : Tensor,
                        padding : List[int],
                        stride : List[int],
                        dilation : List[int],
                        groups : int,
                        benchmark : bool,
                        deterministic : bool) -> Tensor

torch.cudnn_convolution_transpose(self : Tensor,
                                  weight : Tensor,
                                  bias : Optional[Tensor],
                                  padding : List[int],
                                  output_padding : List[int],
                                  stride : List[int],
                                  dilation : List[int],
                                  groups : int,
                                  benchmark : bool,
                                  deterministic : bool) -> Tensor

torch.cudnn_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) -> Tensor

torch.cudnn_grid_sampler(self : Tensor,
                         grid : 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.deg2rad(self : Tensor) -> Tensor

torch.deg2rad(self : Tensor,
              out : Tensor) -> Tensor

torch.deg2rad_(self : Tensor) -> Tensor

torch.dequantize(self : Tensor) -> Tensor

torch.dequantize(tensors : List[Tensor]) -> List[Tensor]

torch.det(self : Tensor) -> Tensor

torch.detach(self : Tensor) -> Tensor

torch.detach_(self : Tensor) -> Tensor

torch.device(a : str) -> Device

torch.diag(self : Tensor,
           diagonal : int=0,
           out : Tensor) -> Tensor

torch.diag(self : Tensor,
           diagonal : int=0) -> Tensor

torch.diag_embed(self : Tensor,
                 offset : int=0,
                 dim1 : int=-2,
                 dim2 : int=-1) -> Tensor

torch.diagflat(self : Tensor,
               offset : int=0) -> Tensor

torch.diagonal(self : Tensor,
               offset : int=0,
               dim1 : int=0,
               dim2 : int=1) -> Tensor

torch.diagonal(self : Tensor,
               outdim : str,
               dim1 : str,
               dim2 : str,
               offset : int=0) -> Tensor

torch.digamma(self : Tensor) -> Tensor

torch.digamma(self : Tensor,
              out : Tensor) -> Tensor

torch.dist(self : Tensor,
           other : Tensor,
           p : number=2) -> Tensor

torch.div(self : Tensor,
          other : number) -> Tensor

torch.div(self : Tensor,
          other : Tensor) -> Tensor

torch.div(self : Tensor,
          other : Tensor,
          out : Tensor) -> Tensor

torch.div(a : int,
          b : int) -> float

torch.div(a : float,
          b : float) -> float

torch.div(a : number,
          b : number) -> float

torch.dot(self : Tensor,
          tensor : Tensor) -> Tensor

torch.dot(self : Tensor,
          tensor : Tensor,
          out : Tensor) -> Tensor

torch.dropout(input : Tensor,
              p : float,
              train : bool) -> Tensor

torch.dropout_(self : Tensor,
               p : float,
               train : bool) -> Tensor

torch.eig(self : Tensor,
          eigenvectors : bool=False,
          e : Tensor,
          v : Tensor) -> Tuple[Tensor, Tensor]

torch.eig(self : Tensor,
          eigenvectors : bool=False) -> Tuple[Tensor, Tensor]

torch.einsum(equation : str,
             tensors : List[Tensor]) -> Tensor

torch.embedding(weight : Tensor,
                indices : Tensor,
                padding_idx : int=-1,
                scale_grad_by_freq : bool=False,
                sparse : bool=False) -> Tensor

torch.embedding_bag(weight : Tensor,
                    indices : Tensor,
                    offsets : Tensor,
                    scale_grad_by_freq : bool=False,
                    mode : int=0,
                    sparse : bool=False,
                    per_sample_weights : Optional[Tensor],
                    include_last_offset : bool=False) -> Tuple[Tensor, Tensor, Tensor, Tensor]

torch.embedding_renorm_(self : Tensor,
                        indices : Tensor,
                        max_norm : float,
                        norm_type : float) -> 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],
            dtype : Optional[int],
            layout : Optional[int],
            device : Optional[Device],
            pin_memory : Optional[bool],
            memory_format : Optional[int]) -> Tensor

torch.empty(size : List[int],
            memory_format : Optional[int],
            out : Tensor) -> Tensor

torch.empty_like(self : Tensor,
                 dtype : Optional[int],
                 layout : Optional[int],
                 device : Optional[Device],
                 pin_memory : Optional[bool],
                 memory_format : Optional[int]) -> Tensor

torch.empty_meta(size : List[int],
                 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) -> Tensor

torch.empty_strided(size : List[int],
                    stride : List[int],
                    dtype : Optional[int],
                    layout : Optional[int],
                    device : Optional[Device],
                    pin_memory : Optional[bool]) -> Tensor

torch.eq(self : Tensor,
         other : number) -> Tensor

torch.eq(self : Tensor,
         other : number,
         out : Tensor) -> Tensor

torch.eq(self : Tensor,
         other : Tensor) -> Tensor

torch.eq(self : Tensor,
         other : Tensor,
         out : Tensor) -> Tensor

torch.eq(a : List[int],
         b : List[int]) -> bool

torch.eq(a : int,
         b : int) -> bool

torch.eq(a : float,
         b : float) -> bool

torch.eq(a : int,
         b : float) -> bool

torch.eq(a : float,
         b : int) -> bool

torch.eq(a : number,
         b : number) -> bool

torch.eq(a : str,
         b : str) -> bool

torch.eq(a : Device,
         b : Device) -> bool

torch.eq(a : str,
         b : str) -> bool

torch.eq(a : List[int],
         b : List[int]) -> bool

torch.eq(a : List[float],
         b : List[float]) -> bool

torch.eq(a : List[Tensor],
         b : List[Tensor]) -> bool

torch.eq(a : List[bool],
         b : List[bool]) -> bool

torch.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 : number) -> number

torch.exp_(self : 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.fbgemm_linear_fp16_weight(input : Tensor,
                                packed_weight : Tensor,
                                bias : Tensor) -> Tensor

torch.fbgemm_linear_fp16_weight_fp32_activation(input : Tensor,
                                                packed_weight : Tensor,
                                                bias : Tensor) -> Tensor

torch.fbgemm_linear_int8_weight(input : Tensor,
                                weight : Tensor,
                                packed : Tensor,
                                col_offsets : Tensor,
                                weight_scale : number,
                                weight_zero_point : number,
                                bias : Tensor) -> Tensor

torch.fbgemm_linear_int8_weight_fp32_activation(input : Tensor,
                                                weight : Tensor,
                                                packed : Tensor,
                                                col_offsets : Tensor,
                                                weight_scale : number,
                                                weight_zero_point : number,
                                                bias : Tensor) -> Tensor

torch.fbgemm_linear_quantize_weight(input : Tensor) -> Tuple[Tensor, Tensor, float, int]

torch.fbgemm_pack_gemm_matrix_fp16(input : Tensor) -> Tensor

torch.fbgemm_pack_quantized_matrix(input : Tensor) -> Tensor

torch.fbgemm_pack_quantized_matrix(input : Tensor,
                                   K : int,
                                   N : int) -> Tensor

torch.feature_alpha_dropout(input : Tensor,
                            p : float,
                            train : bool) -> Tensor

torch.feature_alpha_dropout_(self : Tensor,
                             p : float,
                             train : bool) -> Tensor

torch.feature_dropout(input : Tensor,
                      p : float,
                      train : bool) -> Tensor

torch.feature_dropout_(self : Tensor,
                       p : float,
                       train : bool) -> Tensor

torch.fft(self : Tensor,
          signal_ndim : int,
          normalized : bool=False) -> Tensor

torch.fill_(self : Tensor,
            value : number) -> Tensor

torch.fill_(self : Tensor,
            value : Tensor) -> 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 : int=0,
              end_dim : int=-1) -> Tensor

torch.flatten(self : Tensor,
              start_dim : str,
              end_dim : str,
              out_dim : str) -> Tensor

torch.flip(self : Tensor,
           dims : List[int]) -> Tensor

torch.fliplr(self : Tensor) -> Tensor

torch.flipud(self : 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.fmod(self : Tensor,
           other : number,
           out : Tensor) -> Tensor

torch.fmod(self : Tensor,
           other : number) -> Tensor

torch.fmod(self : Tensor,
           other : Tensor,
           out : Tensor) -> Tensor

torch.fmod(self : Tensor,
           other : 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.frobenius_norm(self : Tensor) -> Tensor

torch.frobenius_norm(self : Tensor,
                     dim : List[int],
                     keepdim : bool=False) -> Tensor

torch.frobenius_norm(self : Tensor,
                     dim : List[int],
                     keepdim : bool=False,
                     out : Tensor) -> Tensor

torch.from_file(filename : str,
                shared : Optional[bool],
                size : Optional[int]=0,
                dtype : Optional[int],
                layout : Optional[int],
                device : Optional[Device],
                pin_memory : Optional[bool]) -> Tensor

torch.full(size : List[int],
           fill_value : number,
           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,
           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.gather(self : Tensor,
             dim : int,
             index : Tensor,
             sparse_grad : bool=False,
             out : Tensor) -> Tensor

torch.gather(self : Tensor,
             dim : int,
             index : Tensor,
             sparse_grad : bool=False) -> Tensor

torch.gather(self : Tensor,
             dim : str,
             index : Tensor,
             sparse_grad : bool=False,
             out : Tensor) -> Tensor

torch.gather(self : Tensor,
             dim : str,
             index : Tensor,
             sparse_grad : bool=False) -> Tensor

torch.ge(self : Tensor,
         other : number) -> Tensor

torch.ge(self : Tensor,
         other : number,
         out : Tensor) -> Tensor

torch.ge(self : Tensor,
         other : 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,
            a : Tensor,
            tau : Tensor) -> Tuple[Tensor, Tensor]

torch.geqrf(self : Tensor) -> Tuple[Tensor, Tensor]

torch.ger(self : Tensor,
          vec2 : Tensor) -> Tensor

torch.ger(self : Tensor,
          vec2 : Tensor,
          out : Tensor) -> Tensor

torch.get_device(self : Tensor) -> int

torch.grid_sampler(input : Tensor,
                   grid : Tensor,
                   interpolation_mode : int,
                   padding_mode : int,
                   align_corners : bool) -> Tensor

torch.grid_sampler_2d(input : Tensor,
                      grid : Tensor,
                      interpolation_mode : int,
                      padding_mode : int,
                      align_corners : bool) -> Tensor

torch.grid_sampler_3d(input : Tensor,
                      grid : Tensor,
                      interpolation_mode : int,
                      padding_mode : int,
                      align_corners : bool) -> Tensor

torch.group_norm(input : Tensor,
                 num_groups : int,
                 weight : Optional[Tensor],
                 bias : Optional[Tensor],
                 eps : float=1e-05,
                 cudnn_enabled : bool=True) -> Tensor

torch.gru(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 : number) -> Tensor

torch.gt(self : Tensor,
         other : number,
         out : Tensor) -> Tensor

torch.gt(self : Tensor,
         other : 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.hann_window(window_length : int,
                  dtype : Optional[int],
                  layout : Optional[int],
                  device : Optional[Device],
                  pin_memory : Optional[bool]) -> Tensor

torch.hann_window(window_length : int,
                  periodic : bool,
                  dtype : Optional[int],
                  layout : Optional[int],
                  device : Optional[Device],
                  pin_memory : Optional[bool]) -> Tensor

torch.hardshrink(self : Tensor,
                 lambd : number=0.5) -> Tensor

torch.hinge_embedding_loss(self : Tensor,
                           target : Tensor,
                           margin : float=1.0,
                           reduction : int=1) -> Tensor

torch.histc(self : Tensor,
            bins : int=100,
            min : number=0,
            max : number=0,
            out : Tensor) -> Tensor

torch.histc(self : Tensor,
            bins : int=100,
            min : number=0,
            max : number=0) -> Tensor

torch.hspmm(mat1 : Tensor,
            mat2 : Tensor,
            out : Tensor) -> Tensor

torch.hspmm(mat1 : Tensor,
            mat2 : Tensor) -> Tensor

torch.ifft(self : Tensor,
           signal_ndim : int,
           normalized : bool=False) -> Tensor

torch.imag(self : Tensor) -> Tensor

torch.index_add(self : Tensor,
                dim : int,
                index : Tensor,
                source : Tensor) -> Tensor

torch.index_add(self : Tensor,
                dim : str,
                index : Tensor,
                source : Tensor) -> 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_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) -> Tensor

torch.index_fill(self : Tensor,
                 dim : int,
                 index : Tensor,
                 value : Tensor) -> Tensor

torch.index_put(self : Tensor,
                indices : List[Optional[Tensor]],
                values : Tensor,
                accumulate : bool=False) -> Tensor

torch.index_put(self : Tensor,
                indices : List[Tensor],
                values : Tensor,
                accumulate : bool=False) -> Tensor

torch.index_put_(self : Tensor,
                 indices : List[Optional[Tensor]],
                 values : Tensor,
                 accumulate : bool=False) -> Tensor

torch.index_put_(self : Tensor,
                 indices : List[Tensor],
                 values : Tensor,
                 accumulate : bool=False) -> Tensor

torch.index_select(self : Tensor,
                   dim : int,
                   index : Tensor,
                   out : Tensor) -> Tensor

torch.index_select(self : Tensor,
                   dim : int,
                   index : Tensor) -> Tensor

torch.index_select(self : Tensor,
                   dim : str,
                   index : Tensor,
                   out : Tensor) -> Tensor

torch.index_select(self : Tensor,
                   dim : str,
                   index : Tensor) -> Tensor

torch.instance_norm(input : Tensor,
                    weight : Optional[Tensor],
                    bias : Optional[Tensor],
                    running_mean : Optional[Tensor],
                    running_var : Optional[Tensor],
                    use_input_stats : bool,
                    momentum : float,
                    eps : float,
                    cudnn_enabled : bool) -> Tensor

torch.int_repr(self : Tensor) -> Tensor

torch.inverse(self : Tensor) -> Tensor

torch.inverse(self : Tensor,
              out : Tensor) -> Tensor

torch.irfft(self : Tensor,
            signal_ndim : int,
            normalized : bool=False,
            onesided : bool=True,
            signal_sizes : List[int]=[]) -> Tensor

torch.is_complex(self : Tensor) -> bool

torch.is_distributed(self : Tensor) -> bool

torch.is_floating_point(self : Tensor) -> bool

torch.is_nonzero(self : Tensor) -> bool

torch.is_same_size(self : Tensor,
                   other : Tensor) -> bool

torch.is_signed(self : Tensor) -> bool

torch.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.isinf(self : Tensor) -> Tensor

torch.isinf(a : float) -> bool

torch.isnan(self : Tensor) -> Tensor

torch.isnan(a : float) -> bool

torch.isnan(a : float) -> bool

torch.kl_div(self : Tensor,
             target : Tensor,
             reduction : int=1,
             log_target : bool=False) -> 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.le(self : Tensor,
         other : number) -> Tensor

torch.le(self : Tensor,
         other : number,
         out : Tensor) -> Tensor

torch.le(self : Tensor,
         other : 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,
           out : Tensor) -> Tensor

torch.lerp(self : Tensor,
           end : Tensor,
           weight : Tensor,
           out : Tensor) -> Tensor

torch.lerp(self : Tensor,
           end : Tensor,
           weight : number) -> Tensor

torch.lerp(self : Tensor,
           end : Tensor,
           weight : 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 : number,
               end : number,
               steps : int=100,
               dtype : Optional[int],
               layout : Optional[int],
               device : Optional[Device],
               pin_memory : Optional[bool]) -> Tensor

torch.linspace(start : number,
               end : number,
               steps : int=100,
               out : Tensor) -> Tensor

torch.log(self : Tensor) -> Tensor

torch.log(self : Tensor,
          out : Tensor) -> Tensor

torch.log(a : int) -> float

torch.log(a : float) -> float

torch.log(a : number) -> number

torch.log(a : int,
          b : int) -> float

torch.log(a : float,
          b : float) -> float

torch.log(a : int,
          b : float) -> float

torch.log(a : float,
          b : int) -> float

torch.log(a : number,
          b : number) -> float

torch.log10(self : Tensor) -> Tensor

torch.log10(self : Tensor,
            out : Tensor) -> Tensor

torch.log10(a : int) -> float

torch.log10(a : float) -> float

torch.log10(a : number) -> number

torch.log10_(self : Tensor) -> Tensor

torch.log1p(self : Tensor) -> Tensor

torch.log1p(self : Tensor,
            out : Tensor) -> Tensor

torch.log1p(a : int) -> float

torch.log1p(a : float) -> float

torch.log1p(a : number) -> number

torch.log1p_(self : Tensor) -> Tensor

torch.log2(self : Tensor) -> Tensor

torch.log2(self : Tensor,
           out : Tensor) -> Tensor

torch.log2_(self : Tensor) -> Tensor

torch.log_(self : Tensor) -> Tensor

torch.log_softmax(self : Tensor,
                  dim : int,
                  dtype : Optional[int]) -> Tensor

torch.log_softmax(self : Tensor,
                  dim : str,
                  dtype : Optional[int]) -> 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.logspace(start : number,
               end : number,
               steps : int=100,
               base : float=10.0,
               dtype : Optional[int],
               layout : Optional[int],
               device : Optional[Device],
               pin_memory : Optional[bool]) -> Tensor

torch.logspace(start : number,
               end : number,
               steps : int=100,
               base : float=10.0,
               out : Tensor) -> Tensor

torch.logsumexp(self : Tensor,
                dim : List[int],
                keepdim : bool=False) -> Tensor

torch.logsumexp(self : Tensor,
                dim : List[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.lstsq(self : Tensor,
            A : Tensor,
            X : Tensor,
            qr : Tensor) -> Tuple[Tensor, Tensor]

torch.lstsq(self : Tensor,
            A : Tensor) -> Tuple[Tensor, Tensor]

torch.lt(self : Tensor,
         other : number) -> Tensor

torch.lt(self : Tensor,
         other : number,
         out : Tensor) -> Tensor

torch.lt(self : Tensor,
         other : 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,
               out : Tensor) -> Tensor

torch.lu_solve(self : Tensor,
               LU_data : Tensor,
               LU_pivots : Tensor) -> Tensor

torch.manual_seed(seed : int) -> Tuple[]

torch.margin_ranking_loss(input1 : Tensor,
                          input2 : Tensor,
                          target : Tensor,
                          margin : float=0.0,
                          reduction : int=1) -> Tensor

torch.masked_fill(self : Tensor,
                  mask : Tensor,
                  value : number) -> Tensor

torch.masked_fill(self : Tensor,
                  mask : Tensor,
                  value : Tensor) -> Tensor

torch.masked_scatter(self : Tensor,
                     mask : Tensor,
                     source : 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_power(self : Tensor,
                   n : int) -> Tensor

torch.matrix_rank(self : Tensor,
                  tol : float,
                  symmetric : bool=False) -> Tensor

torch.matrix_rank(self : Tensor,
                  symmetric : bool=False) -> 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,
          other : Tensor,
          out : Tensor) -> Tensor

torch.max(self : Tensor,
          other : Tensor) -> Tensor

torch.max_pool1d(self : Tensor,
                 kernel_size : List[int],
                 stride : List[int]=[],
                 padding : List[int]=[0],
                 dilation : List[int]=[1],
                 ceil_mode : bool=False) -> Tensor

torch.max_pool1d_with_indices(self : Tensor,
                              kernel_size : List[int],
                              stride : List[int]=[],
                              padding : List[int]=[0],
                              dilation : List[int]=[1],
                              ceil_mode : bool=False) -> Tuple[Tensor, Tensor]

torch.max_pool2d(self : Tensor,
                 kernel_size : List[int],
                 stride : List[int]=[],
                 padding : List[int]=[0, 0],
                 dilation : List[int]=[1, 1],
                 ceil_mode : bool=False) -> Tensor

torch.max_pool3d(self : Tensor,
                 kernel_size : List[int],
                 stride : List[int]=[],
                 padding : List[int]=[0, 0, 0],
                 dilation : List[int]=[1, 1, 1],
                 ceil_mode : bool=False) -> Tensor

torch.mean(self : Tensor,
           dtype : Optional[int]) -> Tensor

torch.mean(self : Tensor,
           dim : List[int],
           keepdim : bool=False,
           dtype : Optional[int]) -> Tensor

torch.mean(self : Tensor,
           dim : List[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 : List[int],
           keepdim : bool=False,
           dtype : Optional[int],
           out : Tensor) -> Tensor

torch.median(self : Tensor) -> Tensor

torch.median(self : Tensor,
             dim : int,
             keepdim : bool=False) -> Tuple[Tensor, Tensor]

torch.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.meshgrid(tensors : List[Tensor]) -> List[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,
          other : Tensor,
          out : Tensor) -> Tensor

torch.min(self : Tensor,
          other : Tensor) -> Tensor

torch.miopen_batch_norm(input : Tensor,
                        weight : Tensor,
                        bias : Optional[Tensor],
                        running_mean : Optional[Tensor],
                        running_var : Optional[Tensor],
                        training : bool,
                        exponential_average_factor : float,
                        epsilon : float) -> Tuple[Tensor, Tensor, Tensor]

torch.miopen_convolution(self : Tensor,
                         weight : Tensor,
                         bias : Optional[Tensor],
                         padding : List[int],
                         stride : List[int],
                         dilation : List[int],
                         groups : int,
                         benchmark : bool,
                         deterministic : bool) -> Tensor

torch.miopen_convolution_transpose(self : Tensor,
                                   weight : Tensor,
                                   bias : Optional[Tensor],
                                   padding : List[int],
                                   output_padding : List[int],
                                   stride : List[int],
                                   dilation : List[int],
                                   groups : int,
                                   benchmark : bool,
                                   deterministic : bool) -> Tensor

torch.miopen_depthwise_convolution(self : Tensor,
                                   weight : Tensor,
                                   bias : Optional[Tensor],
                                   padding : List[int],
                                   stride : List[int],
                                   dilation : List[int],
                                   groups : int,
                                   benchmark : bool,
                                   deterministic : bool) -> Tensor

torch.miopen_rnn(input : Tensor,
                 weight : List[Tensor],
                 weight_stride0 : int,
                 hx : Tensor,
                 cx : Optional[Tensor],
                 mode : int,
                 hidden_size : int,
                 num_layers : int,
                 batch_first : bool,
                 dropout : float,
                 train : bool,
                 bidirectional : bool,
                 batch_sizes : List[int],
                 dropout_state : Optional[Tensor]) -> Tuple[Tensor, Tensor, Tensor, Tensor, Tensor]

torch.mkldnn_adaptive_avg_pool2d(self : Tensor,
                                 output_size : List[int]) -> Tensor

torch.mkldnn_convolution(self : Tensor,
                         weight : Tensor,
                         bias : Optional[Tensor],
                         padding : List[int],
                         stride : List[int],
                         dilation : List[int],
                         groups : int) -> Tensor

torch.mkldnn_convolution_backward_weights(weight_size : List[int],
                                          grad_output : Tensor,
                                          self : Tensor,
                                          padding : List[int],
                                          stride : List[int],
                                          dilation : List[int],
                                          groups : int,
                                          bias_defined : bool) -> Tuple[Tensor, Tensor]

torch.mkldnn_max_pool2d(self : Tensor,
                        kernel_size : List[int],
                        stride : List[int]=[],
                        padding : List[int]=[0, 0],
                        dilation : List[int]=[1, 1],
                        ceil_mode : bool=False) -> Tensor

torch.mm(self : Tensor,
         mat2 : Tensor) -> 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.mul(self : Tensor,
          other : Tensor) -> Tensor

torch.mul(self : Tensor,
          other : Tensor,
          out : Tensor) -> Tensor

torch.mul(self : Tensor,
          other : number) -> Tensor

torch.mul(l : List[t],
          n : int) -> List[t]

torch.mul(n : int,
          l : List[t]) -> List[t]

torch.mul(a : int,
          b : int) -> int

torch.mul(a : float,
          b : float) -> float

torch.mul(a : int,
          b : float) -> float

torch.mul(a : float,
          b : int) -> float

torch.mul(a : number,
          b : number) -> number

torch.multinomial(self : Tensor,
                  num_samples : int,
                  replacement : bool=False,
                  generator : Optional[Generator],
                  out : Tensor) -> Tensor

torch.multinomial(self : Tensor,
                  num_samples : int,
                  replacement : bool=False,
                  generator : Optional[Generator]) -> 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.narrow(self : Tensor,
             dim : int,
             start : int,
             length : int) -> Tensor

torch.narrow(self : Tensor,
             dim : int,
             start : Tensor,
             length : int) -> Tensor

torch.native_batch_norm(input : Tensor,
                        weight : Optional[Tensor],
                        bias : Optional[Tensor],
                        running_mean : Optional[Tensor],
                        running_var : Optional[Tensor],
                        training : bool,
                        momentum : float,
                        eps : float) -> Tuple[Tensor, Tensor, Tensor]

torch.native_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_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_layer_norm(input : Tensor,
                        weight : Optional[Tensor],
                        bias : Optional[Tensor],
                        M : int,
                        N : int,
                        eps : float) -> Tuple[Tensor, Tensor, Tensor]

torch.native_norm(self : Tensor,
                  p : number=2) -> Tensor

torch.ne(self : Tensor,
         other : number) -> Tensor

torch.ne(self : Tensor,
         other : number,
         out : Tensor) -> Tensor

torch.ne(self : Tensor,
         other : Tensor) -> Tensor

torch.ne(self : Tensor,
         other : Tensor,
         out : Tensor) -> Tensor

torch.ne(a : List[int],
         b : List[int]) -> bool

torch.ne(a : int,
         b : int) -> bool

torch.ne(a : float,
         b : float) -> bool

torch.ne(a : int,
         b : float) -> bool

torch.ne(a : float,
         b : int) -> bool

torch.ne(a : number,
         b : number) -> bool

torch.ne(a : str,
         b : str) -> bool

torch.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.neg(self : Tensor) -> Tensor

torch.neg(self : Tensor,
          out : Tensor) -> Tensor

torch.neg(a : int) -> int

torch.neg(a : float) -> float

torch.neg(a : number) -> number

torch.neg_(self : Tensor) -> Tensor

torch.nonzero(self : Tensor,
              out : Tensor) -> Tensor

torch.nonzero(self : Tensor) -> Tensor

torch.norm_except_dim(v : Tensor,
                      pow : int=2,
                      dim : int=0) -> Tensor

torch.normal(mean : float,
             std : float,
             size : List[int],
             generator : Optional[Generator],
             dtype : Optional[int],
             layout : Optional[int],
             device : Optional[Device],
             pin_memory : Optional[bool]) -> Tensor

torch.normal(mean : Tensor,
             std : float=1.0,
             generator : Optional[Generator],
             out : Tensor) -> Tensor

torch.normal(mean : Tensor,
             std : float=1.0,
             generator : Optional[Generator]) -> 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],
             out : Tensor) -> Tensor

torch.normal(mean : Tensor,
             std : Tensor,
             generator : Optional[Generator]) -> Tensor

torch.normal(mean : float,
             std : float,
             size : List[int],
             generator : Optional[Generator],
             out : Tensor) -> Tensor

torch.nuclear_norm(self : Tensor,
                   keepdim : bool=False) -> Tensor

torch.nuclear_norm(self : Tensor,
                   dim : List[int],
                   keepdim : bool=False) -> Tensor

torch.nuclear_norm(self : Tensor,
                   keepdim : bool=False,
                   out : Tensor) -> Tensor

torch.nuclear_norm(self : Tensor,
                   dim : List[int],
                   keepdim : bool=False,
                   out : Tensor) -> Tensor

torch.numel(self : Tensor) -> int

torch.ones(size : List[int],
           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],
           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.orgqr(self : Tensor,
            input2 : Tensor,
            out : Tensor) -> Tensor

torch.orgqr(self : Tensor,
            input2 : Tensor) -> Tensor

torch.ormqr(self : Tensor,
            input2 : Tensor,
            input3 : Tensor,
            left : bool=True,
            transpose : bool=False,
            out : Tensor) -> Tensor

torch.ormqr(self : Tensor,
            input2 : Tensor,
            input3 : Tensor,
            left : bool=True,
            transpose : bool=False) -> Tensor

torch.pairwise_distance(x1 : Tensor,
                        x2 : Tensor,
                        p : float=2.0,
                        eps : float=1e-06,
                        keepdim : bool=False) -> Tensor

torch.pdist(self : Tensor,
            p : float=2.0) -> Tensor

torch.pinverse(self : Tensor,
               rcond : float=1e-15) -> Tensor

torch.pixel_shuffle(self : Tensor,
                    upscale_factor : int) -> Tensor

torch.poisson(self : Tensor,
              generator : Optional[Generator]) -> Tensor

torch.poisson_nll_loss(input : Tensor,
                       target : Tensor,
                       log_input : bool,
                       full : bool,
                       eps : float,
                       reduction : int) -> Tensor

torch.polygamma(n : int,
                self : Tensor) -> Tensor

torch.polygamma(n : int,
                self : Tensor,
                out : Tensor) -> Tensor

torch.pow(self : Tensor,
          exponent : number) -> Tensor

torch.pow(self : Tensor,
          exponent : Tensor) -> 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 : float,
          b : float) -> float

torch.pow(a : int,
          b : float) -> float

torch.pow(a : float,
          b : int) -> float

torch.pow(a : number,
          b : number) -> float

torch.pow(a : number,
          b : number) -> number

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.promote_types(type1 : int,
                    type2 : int) -> int

torch.q_per_channel_axis(self : Tensor) -> int

torch.q_per_channel_scales(self : Tensor) -> Tensor

torch.q_per_channel_zero_points(self : Tensor) -> Tensor

torch.q_scale(self : Tensor) -> float

torch.q_zero_point(self : Tensor) -> int

torch.qr(self : Tensor,
         some : bool=True,
         Q : Tensor,
         R : Tensor) -> Tuple[Tensor, Tensor]

torch.qr(self : Tensor,
         some : bool=True) -> Tuple[Tensor, Tensor]

torch.qscheme(self : Tensor) -> QScheme

torch.quantize_per_channel(self : Tensor,
                           scales : Tensor,
                           zero_points : Tensor,
                           axis : int,
                           dtype : int) -> Tensor

torch.quantize_per_tensor(self : Tensor,
                          scale : float,
                          zero_point : int,
                          dtype : int) -> Tensor

torch.quantize_per_tensor(tensors : List[Tensor],
                          scales : Tensor,
                          zero_points : Tensor,
                          dtype : int) -> List[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(input : Tensor,
                    hx : Tensor,
                    params : List[__torch__.torch.classes.rnn.CellParamsBase],
                    has_biases : bool,
                    num_layers : int,
                    dropout : float,
                    train : bool,
                    bidirectional : bool,
                    batch_first : bool) -> Tuple[Tensor, Tensor]

torch.quantized_gru(data : Tensor,
                    batch_sizes : Tensor,
                    hx : Tensor,
                    params : List[__torch__.torch.classes.rnn.CellParamsBase],
                    has_biases : bool,
                    num_layers : int,
                    dropout : float,
                    train : bool,
                    bidirectional : bool) -> Tuple[Tensor, Tensor]

torch.quantized_gru(input : Tensor,
                    hx : Tensor,
                    params : List[Tensor],
                    has_biases : bool,
                    num_layers : int,
                    dropout : float,
                    train : bool,
                    bidirectional : bool,
                    batch_first : bool) -> Tuple[Tensor, Tensor]

torch.quantized_gru(data : Tensor,
                    batch_sizes : Tensor,
                    hx : Tensor,
                    params : List[Tensor],
                    has_biases : bool,
                    num_layers : int,
                    dropout : float,
                    train : bool,
                    bidirectional : bool) -> Tuple[Tensor, Tensor]

torch.quantized_gru_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(input : Tensor,
                     hx : List[Tensor],
                     params : List[__torch__.torch.classes.rnn.CellParamsBase],
                     has_biases : bool,
                     num_layers : int,
                     dropout : float,
                     train : bool,
                     bidirectional : bool,
                     batch_first : bool,
                     dtype : Optional[int],
                     use_dynamic : bool=False) -> Tuple[Tensor, Tensor, Tensor]

torch.quantized_lstm(data : Tensor,
                     batch_sizes : Tensor,
                     hx : List[Tensor],
                     params : List[__torch__.torch.classes.rnn.CellParamsBase],
                     has_biases : bool,
                     num_layers : int,
                     dropout : float,
                     train : bool,
                     bidirectional : bool,
                     dtype : Optional[int],
                     use_dynamic : bool=False) -> Tuple[Tensor, Tensor, Tensor]

torch.quantized_lstm(input : Tensor,
                     hx : List[Tensor],
                     params : List[Tensor],
                     has_biases : bool,
                     num_layers : int,
                     dropout : float,
                     train : bool,
                     bidirectional : bool,
                     batch_first : bool,
                     dtype : Optional[int],
                     use_dynamic : bool=False) -> Tuple[Tensor, Tensor, Tensor]

torch.quantized_lstm(data : Tensor,
                     batch_sizes : Tensor,
                     hx : List[Tensor],
                     params : List[Tensor],
                     has_biases : bool,
                     num_layers : int,
                     dropout : float,
                     train : bool,
                     bidirectional : bool,
                     dtype : Optional[int],
                     use_dynamic : bool=False) -> Tuple[Tensor, Tensor, Tensor]

torch.quantized_lstm_cell(input : Tensor,
                          hx : List[Tensor],
                          w_ih : Tensor,
                          w_hh : Tensor,
                          b_ih : Tensor,
                          b_hh : Tensor,
                          packed_ih : Tensor,
                          packed_hh : Tensor,
                          col_offsets_ih : Tensor,
                          col_offsets_hh : Tensor,
                          scale_ih : number,
                          scale_hh : number,
                          zero_point_ih : number,
                          zero_point_hh : number) -> Tuple[Tensor, Tensor]

torch.quantized_max_pool2d(self : Tensor,
                           kernel_size : List[int],
                           stride : List[int]=[],
                           padding : List[int]=[0, 0],
                           dilation : List[int]=[1, 1],
                           ceil_mode : bool=False) -> Tensor

torch.quantized_rnn_relu_cell(input : Tensor,
                              hx : Tensor,
                              w_ih : Tensor,
                              w_hh : Tensor,
                              b_ih : Tensor,
                              b_hh : Tensor,
                              packed_ih : Tensor,
                              packed_hh : Tensor,
                              col_offsets_ih : Tensor,
                              col_offsets_hh : Tensor,
                              scale_ih : number,
                              scale_hh : number,
                              zero_point_ih : number,
                              zero_point_hh : number) -> Tensor

torch.quantized_rnn_tanh_cell(input : Tensor,
                              hx : Tensor,
                              w_ih : Tensor,
                              w_hh : Tensor,
                              b_ih : Tensor,
                              b_hh : Tensor,
                              packed_ih : Tensor,
                              packed_hh : Tensor,
                              col_offsets_ih : Tensor,
                              col_offsets_hh : Tensor,
                              scale_ih : number,
                              scale_hh : number,
                              zero_point_ih : number,
                              zero_point_hh : number) -> Tensor

torch.rad2deg(self : Tensor) -> Tensor

torch.rad2deg(self : Tensor,
              out : Tensor) -> Tensor

torch.rad2deg_(self : Tensor) -> 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],
           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],
           out : Tensor) -> Tensor

torch.rand(size : List[int],
           generator : Optional[Generator],
           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.randint(high : int,
              size : List[int],
              dtype : Optional[int],
              layout : Optional[int],
              device : Optional[Device],
              pin_memory : Optional[bool]) -> Tensor

torch.randint(high : int,
              size : List[int],
              generator : Optional[Generator],
              dtype : Optional[int],
              layout : Optional[int],
              device : Optional[Device],
              pin_memory : Optional[bool]) -> Tensor

torch.randint(low : int,
              high : int,
              size : List[int],
              dtype : Optional[int],
              layout : Optional[int],
              device : Optional[Device],
              pin_memory : Optional[bool]) -> Tensor

torch.randint(low : int,
              high : int,
              size : List[int],
              generator : Optional[Generator],
              dtype : Optional[int],
              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.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_like(self : Tensor,
                 dtype : Optional[int],
                 layout : Optional[int],
                 device : Optional[Device],
                 pin_memory : Optional[bool],
                 memory_format : Optional[int]) -> Tensor

torch.randperm(n : int,
               dtype : Optional[int],
               layout : Optional[int],
               device : Optional[Device],
               pin_memory : Optional[bool]) -> Tensor

torch.randperm(n : int,
               generator : Optional[Generator],
               dtype : Optional[int],
               layout : Optional[int],
               device : Optional[Device],
               pin_memory : Optional[bool]) -> Tensor

torch.randperm(n : int,
               generator : Optional[Generator],
               out : Tensor) -> Tensor

torch.randperm(n : int,
               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.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) -> Tensor

torch.remainder(self : Tensor,
                other : number,
                out : Tensor) -> Tensor

torch.remainder(self : Tensor,
                other : number) -> Tensor

torch.remainder(self : Tensor,
                other : Tensor,
                out : Tensor) -> Tensor

torch.remainder(self : Tensor,
                other : 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) -> Tensor

torch.repeat_interleave(self : Tensor,
                        repeats : Tensor,
                        dim : Optional[int]) -> Tensor

torch.repeat_interleave(self : Tensor,
                        repeats : int,
                        dim : Optional[int]) -> Tensor

torch.reshape(self : Tensor,
              shape : List[int]) -> Tensor

torch.resize_as_(self : Tensor,
                 the_template : Tensor,
                 memory_format : Optional[int]) -> Tensor

torch.result_type(tensor : Tensor,
                  other : number) -> int

torch.result_type(scalar : number,
                  tensor : Tensor) -> int

torch.result_type(tensor : Tensor,
                  other : Tensor) -> int

torch.result_type(scalar1 : number,
                  scalar2 : number) -> int

torch.rfft(self : Tensor,
           signal_ndim : int,
           normalized : bool=False,
           onesided : bool=True) -> Tensor

torch.rnn_relu(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.rot90(self : Tensor,
            k : int=1,
            dims : List[int]=[0, 1]) -> Tensor

torch.round(self : Tensor) -> Tensor

torch.round(self : Tensor,
            out : Tensor) -> Tensor

torch.round(a : int) -> float

torch.round(a : float) -> float

torch.round(a : number) -> number

torch.round_(self : Tensor) -> Tensor

torch.rrelu(self : Tensor,
            lower : number=0.125,
            upper : number=0.3333333333333333,
            training : bool=False,
            generator : Optional[Generator]) -> Tensor

torch.rrelu_(self : Tensor,
             lower : number=0.125,
             upper : number=0.3333333333333333,
             training : bool=False,
             generator : Optional[Generator]) -> Tensor

torch.rsqrt(self : Tensor) -> Tensor

torch.rsqrt(self : Tensor,
            out : Tensor) -> Tensor

torch.rsqrt_(self : Tensor) -> Tensor

torch.rsub(self : Tensor,
           other : number,
           alpha : number=1) -> Tensor

torch.rsub(self : Tensor,
           other : Tensor,
           alpha : number=1) -> Tensor

torch.save(item : t,
           filename : str) -> Tuple[]

torch.scalar_tensor(s : number,
                    dtype : Optional[int],
                    layout : Optional[int],
                    device : Optional[Device],
                    pin_memory : Optional[bool]) -> Tensor

torch.scatter(self : Tensor,
              dim : int,
              index : Tensor,
              src : Tensor) -> Tensor

torch.scatter(self : Tensor,
              dim : int,
              index : Tensor,
              value : number) -> Tensor

torch.scatter(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 : str,
                  index : Tensor,
                  src : Tensor) -> Tensor

torch.searchsorted(sorted_sequence : Tensor,
                   self : Tensor,
                   out_int32 : bool=False,
                   right : bool=False) -> Tensor

torch.searchsorted(sorted_sequence : Tensor,
                   self : Tensor,
                   out_int32 : bool=False,
                   right : bool=False,
                   out : Tensor) -> Tensor

torch.searchsorted(sorted_sequence : Tensor,
                   self : number,
                   out_int32 : bool=False,
                   right : bool=False) -> 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.selu(self : Tensor) -> Tensor

torch.selu_(self : Tensor) -> Tensor

torch.sigmoid(self : Tensor) -> Tensor

torch.sigmoid(self : Tensor,
              out : Tensor) -> Tensor

torch.sigmoid_(self : Tensor) -> Tensor

torch.sign(self : Tensor) -> Tensor

torch.sign(self : Tensor,
           out : Tensor) -> Tensor

torch.sin(self : Tensor) -> Tensor

torch.sin(self : Tensor,
          out : Tensor) -> Tensor

torch.sin(a : int) -> float

torch.sin(a : float) -> float

torch.sin(a : number) -> number

torch.sin_(self : Tensor) -> Tensor

torch.sinh(self : Tensor) -> Tensor

torch.sinh(self : Tensor,
           out : Tensor) -> Tensor

torch.sinh(a : int) -> float

torch.sinh(a : float) -> float

torch.sinh(a : number) -> number

torch.sinh_(self : Tensor) -> Tensor

torch.slogdet(self : Tensor) -> Tuple[Tensor, Tensor]

torch.smm(self : Tensor,
          mat2 : Tensor) -> Tensor

torch.softmax(self : Tensor,
              dim : int,
              dtype : Optional[int]) -> Tensor

torch.softmax(self : Tensor,
              dim : str,
              dtype : Optional[int]) -> Tensor

torch.solve(self : Tensor,
            A : Tensor) -> Tuple[Tensor, Tensor]

torch.solve(self : Tensor,
            A : Tensor,
            solution : Tensor,
            lu : 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 : int=-1,
           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,
           dim : str,
           descending : bool=False) -> Tuple[Tensor, Tensor]

torch.sort(self : List[int],
           reverse : bool=False) -> Tuple[]

torch.sort(self : List[float],
           reverse : bool=False) -> Tuple[]

torch.sort(self : List[Tensor],
           reverse : bool=False) -> Tuple[]

torch.sort(self : List[bool],
           reverse : bool=False) -> Tuple[]

torch.sort(self : List[t],
           reverse : bool=False) -> Tuple[]

torch.sparse_coo_tensor(size : List[int],
                        dtype : int,
                        layout : int,
                        device : Device,
                        pin_memory : bool=False) -> Tensor

torch.sparse_coo_tensor(indices : Tensor,
                        values : Tensor,
                        dtype : Optional[int],
                        layout : Optional[int],
                        device : Optional[Device],
                        pin_memory : Optional[bool]) -> Tensor

torch.sparse_coo_tensor(indices : Tensor,
                        values : Tensor,
                        size : List[int],
                        dtype : Optional[int],
                        layout : Optional[int],
                        device : Optional[Device],
                        pin_memory : Optional[bool]) -> Tensor

torch.split(self : Tensor,
            split_size : int,
            dim : int=0) -> List[Tensor]

torch.split(self : str,
            separator : Optional[str],
            max : int=-1) -> List[str]

torch.split(self : Tensor,
            split_sizes : List[int],
            dim : int=0) -> List[Tensor]

torch.split_with_sizes(self : Tensor,
                       split_sizes : List[int],
                       dim : int=0) -> List[Tensor]

torch.sqrt(self : Tensor) -> Tensor

torch.sqrt(self : Tensor,
           out : Tensor) -> Tensor

torch.sqrt(a : int) -> float

torch.sqrt(a : float) -> float

torch.sqrt(a : number) -> number

torch.sqrt_(self : Tensor) -> Tensor

torch.square(self : Tensor) -> Tensor

torch.square_(self : Tensor) -> Tensor

torch.squeeze(self : Tensor) -> Tensor

torch.squeeze(self : Tensor,
              dim : int) -> Tensor

torch.squeeze(self : Tensor,
              dim : str) -> Tensor

torch.sspaddmm(self : Tensor,
               mat1 : Tensor,
               mat2 : Tensor,
               beta : number=1,
               alpha : number=1,
               out : Tensor) -> Tensor

torch.sspaddmm(self : Tensor,
               mat1 : Tensor,
               mat2 : Tensor,
               beta : number=1,
               alpha : number=1) -> Tensor

torch.stack(tensors : List[Tensor],
            dim : int=0) -> Tensor

torch.stack(tensors : List[Tensor],
            dim : int=0,
            out : Tensor) -> Tensor

torch.std(self : Tensor,
          unbiased : bool=True) -> Tensor

torch.std(self : Tensor,
          dim : List[int],
          unbiased : bool=True,
          keepdim : bool=False) -> Tensor

torch.std(self : Tensor,
          dim : List[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 : List[int],
          unbiased : bool=True,
          keepdim : bool=False,
          out : Tensor) -> Tensor

torch.std_mean(self : Tensor,
               unbiased : bool=True) -> Tuple[Tensor, Tensor]

torch.std_mean(self : Tensor,
               dim : List[int],
               unbiased : bool=True,
               keepdim : bool=False) -> Tuple[Tensor, Tensor]

torch.std_mean(self : Tensor,
               dim : List[str],
               unbiased : bool=True,
               keepdim : bool=False) -> Tuple[Tensor, Tensor]

torch.sub(self : Tensor,
          other : number,
          alpha : number=1) -> Tensor

torch.sub(self : Tensor,
          other : Tensor,
          alpha : number=1) -> Tensor

torch.sub(self : Tensor,
          other : Tensor,
          alpha : number=1,
          out : Tensor) -> Tensor

torch.sub(a : int,
          b : int) -> int

torch.sub(a : float,
          b : float) -> float

torch.sub(a : int,
          b : float) -> float

torch.sub(a : float,
          b : int) -> float

torch.sub(a : number,
          b : number) -> number

torch.sum(self : Tensor,
          dim : List[int],
          keepdim : bool=False,
          dtype : Optional[int]) -> 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 : List[int],
          keepdim : bool=False,
          dtype : Optional[int],
          out : Tensor) -> Tensor

torch.svd(self : Tensor,
          some : bool=True,
          compute_uv : bool=True,
          U : Tensor,
          S : Tensor,
          V : Tensor) -> Tuple[Tensor, Tensor, Tensor]

torch.svd(self : Tensor,
          some : bool=True,
          compute_uv : bool=True) -> Tuple[Tensor, Tensor, Tensor]

torch.symeig(self : Tensor,
             eigenvectors : bool=False,
             upper : bool=True,
             e : Tensor,
             V : Tensor) -> Tuple[Tensor, Tensor]

torch.symeig(self : Tensor,
             eigenvectors : bool=False,
             upper : bool=True) -> Tuple[Tensor, Tensor]

torch.t(self : Tensor) -> Tensor

torch.take(self : Tensor,
           index : Tensor,
           out : Tensor) -> Tensor

torch.take(self : Tensor,
           index : 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 : number) -> number

torch.tan_(self : Tensor) -> Tensor

torch.tanh(self : Tensor) -> Tensor

torch.tanh(self : Tensor,
           out : Tensor) -> Tensor

torch.tanh(a : int) -> float

torch.tanh(a : float) -> float

torch.tanh(a : number) -> number

torch.tanh_(self : Tensor) -> Tensor

torch.tensor(t : float,
             dtype : Optional[int],
             device : Optional[Device],
             requires_grad : bool=False) -> Tensor

torch.tensor(t : int,
             dtype : Optional[int],
             device : Optional[Device],
             requires_grad : bool=False) -> Tensor

torch.tensor(t : bool,
             dtype : Optional[int],
             device : Optional[Device],
             requires_grad : bool=False) -> Tensor

torch.tensor(data : List[t],
             dtype : Optional[int],
             device : Optional[Device],
             requires_grad : bool=False) -> Tensor

torch.tensordot(self : Tensor,
                other : Tensor,
                dims_self : List[int],
                dims_other : List[int]) -> Tensor

torch.threshold(self : Tensor,
                threshold : number,
                value : number) -> Tensor

torch.threshold(self : Tensor,
                threshold : number,
                value : number,
                out : Tensor) -> Tensor

torch.threshold_(self : Tensor,
                 threshold : number,
                 value : number) -> Tensor

torch.topk(self : Tensor,
           k : int,
           dim : int=-1,
           largest : bool=True,
           sorted : bool=True,
           values : Tensor,
           indices : Tensor) -> Tuple[Tensor, Tensor]

torch.topk(self : Tensor,
           k : int,
           dim : int=-1,
           largest : bool=True,
           sorted : bool=True) -> Tuple[Tensor, Tensor]

torch.trace(self : Tensor) -> Tensor

torch.transpose(self : Tensor,
                dim0 : str,
                dim1 : str) -> Tensor

torch.transpose(self : Tensor,
                dim0 : int,
                dim1 : int) -> Tensor

torch.trapz(y : Tensor,
            x : Tensor,
            dim : int=-1) -> Tensor

torch.trapz(y : Tensor,
            dx : float=1.0,
            dim : int=-1) -> Tensor

torch.triangular_solve(self : Tensor,
                       A : Tensor,
                       upper : bool=True,
                       transpose : bool=False,
                       unitriangular : bool=False,
                       X : Tensor,
                       M : Tensor) -> Tuple[Tensor, Tensor]

torch.triangular_solve(self : Tensor,
                       A : Tensor,
                       upper : bool=True,
                       transpose : bool=False,
                       unitriangular : bool=False) -> Tuple[Tensor, Tensor]

torch.tril(self : Tensor,
           diagonal : int=0,
           out : Tensor) -> Tensor

torch.tril(self : Tensor,
           diagonal : int=0) -> Tensor

torch.tril_indices(row : int,
                   col : int,
                   offset : int=0,
                   dtype : Optional[int]=4,
                   layout : Optional[int],
                   device : Optional[Device],
                   pin_memory : Optional[bool]) -> Tensor

torch.triplet_margin_loss(anchor : Tensor,
                          positive : Tensor,
                          negative : Tensor,
                          margin : float=1.0,
                          p : float=2.0,
                          eps : float=1e-06,
                          swap : bool=False,
                          reduction : int=1) -> Tensor

torch.triu(self : Tensor,
           diagonal : int=0,
           out : Tensor) -> Tensor

torch.triu(self : Tensor,
           diagonal : int=0) -> Tensor

torch.triu_indices(row : int,
                   col : int,
                   offset : int=0,
                   dtype : Optional[int]=4,
                   layout : Optional[int],
                   device : Optional[Device],
                   pin_memory : Optional[bool]) -> Tensor

torch.true_divide(self : Tensor,
                  other : number) -> Tensor

torch.true_divide(self : Tensor,
                  other : Tensor) -> 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 : str) -> List[Tensor]

torch.unbind(self : Tensor,
             dim : int=0) -> List[Tensor]

torch.unsqueeze(self : Tensor,
                dim : int) -> 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 : List[int],
          unbiased : bool=True,
          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 : List[int],
          unbiased : bool=True,
          keepdim : bool=False,
          out : Tensor) -> Tensor

torch.var_mean(self : Tensor,
               unbiased : bool=True) -> Tuple[Tensor, Tensor]

torch.var_mean(self : Tensor,
               dim : List[int],
               unbiased : bool=True,
               keepdim : bool=False) -> Tuple[Tensor, Tensor]

torch.var_mean(self : Tensor,
               dim : List[str],
               unbiased : bool=True,
               keepdim : bool=False) -> Tuple[Tensor, Tensor]

torch.view_as_complex(self : Tensor) -> Tensor

torch.view_as_real(self : Tensor) -> Tensor

torch.wait(self : Future[t]) -> t

torch.where(condition : Tensor,
            self : Tensor,
            other : Tensor) -> Tensor

torch.where(condition : Tensor) -> List[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],
            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._C._nn.adaptive_avg_pool2d(self : Tensor,
                                 output_size : List[int],
                                 out : Tensor) -> Tensor

torch._C._nn.adaptive_avg_pool2d(self : Tensor,
                                 output_size : List[int]) -> Tensor

torch._C._nn.adaptive_avg_pool3d(self : Tensor,
                                 output_size : List[int],
                                 out : Tensor) -> Tensor

torch._C._nn.adaptive_avg_pool3d(self : Tensor,
                                 output_size : List[int]) -> 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_pool2d(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.adaptive_max_pool3d(self : Tensor,
                                 output_size : List[int]) -> Tuple[Tensor, Tensor]

torch._C._nn.avg_pool2d(self : Tensor,
                        kernel_size : List[int],
                        stride : List[int]=[],
                        padding : List[int]=[0, 0],
                        ceil_mode : bool=False,
                        count_include_pad : bool=True,
                        divisor_override : Optional[int],
                        out : 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_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.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.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],
                    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.elu(self : Tensor,
                 alpha : number=1,
                 scale : number=1,
                 input_scale : number=1,
                 out : Tensor) -> Tensor

torch._C._nn.elu(self : Tensor,
                 alpha : number=1,
                 scale : number=1,
                 input_scale : number=1) -> Tensor

torch._C._nn.elu_(self : Tensor,
                  alpha : number=1,
                  scale : number=1,
                  input_scale : number=1) -> Tensor

torch._C._nn.fractional_max_pool2d(self : Tensor,
                                   kernel_size : List[int],
                                   output_size : List[int],
                                   random_samples : Tensor,
                                   output : Tensor,
                                   indices : Tensor) -> Tuple[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_pool3d(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.gelu(self : Tensor) -> Tensor

torch._C._nn.glu(self : Tensor,
                 dim : int=-1,
                 out : Tensor) -> Tensor

torch._C._nn.glu(self : Tensor,
                 dim : int=-1) -> 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,
                       out : Tensor) -> Tensor

torch._C._nn.hardswish(self : Tensor) -> Tensor

torch._C._nn.hardswish_(self : Tensor) -> Tensor

torch._C._nn.hardtanh(self : Tensor,
                      min_val : number=-1,
                      max_val : number=1,
                      out : Tensor) -> Tensor

torch._C._nn.hardtanh(self : Tensor,
                      min_val : number=-1,
                      max_val : number=1) -> Tensor

torch._C._nn.hardtanh_(self : Tensor,
                       min_val : number=-1,
                       max_val : number=1) -> Tensor

torch._C._nn.im2col(self : Tensor,
                    kernel_size : List[int],
                    dilation : List[int],
                    padding : List[int],
                    stride : List[int],
                    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.l1_loss(self : Tensor,
                     target : Tensor,
                     reduction : int=1) -> Tensor

torch._C._nn.l1_loss(self : Tensor,
                     target : Tensor,
                     reduction : int=1,
                     out : Tensor) -> 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.leaky_relu_(self : Tensor,
                         negative_slope : number=0.01) -> Tensor

torch._C._nn.linear(input : Tensor,
                    weight : Tensor,
                    bias : Optional[Tensor]) -> Tensor

torch._C._nn.log_sigmoid(self : Tensor,
                         out : Tensor) -> Tensor

torch._C._nn.log_sigmoid(self : 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],
                          out : Tensor) -> Tensor

torch._C._nn.max_unpool2d(self : Tensor,
                          indices : Tensor,
                          output_size : 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.max_unpool3d(self : Tensor,
                          indices : Tensor,
                          output_size : List[int],
                          stride : List[int],
                          padding : List[int]) -> Tensor

torch._C._nn.mkldnn_linear(input : Tensor,
                           weight : Tensor,
                           bias : Optional[Tensor]) -> Tensor

torch._C._nn.mkldnn_reorder_conv2d_weight(self : Tensor,
                                          padding : List[int]=[0, 0],
                                          stride :