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.count_nonzero(dim : List[int]) -> Tensor

Tensor.count_nonzero(dim : Optional[int]) -> 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.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_(dim : int,
                index : Tensor,
                src : Tensor,
                reduce : str) -> Tensor

Tensor.scatter_(dim : int,
                index : Tensor,
                value : number,
                reduce : str) -> Tensor

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

Tensor.scatter_add(dim : 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(dim : int) -> Tensor

Tensor.squeeze() -> 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 : int,
                 dim1 : int) -> Tensor

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

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

Tensor.triangular_solve(A : Tensor,
                        upper : bool=True,
                        transpose : bool=False,
                        unitriangular : bool=False,
                        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.silu(input : Tensor,
                         inplace : bool=False) -> Tensor

torch.nn.functional.smooth_l1_loss(input : Tensor,
                                   target : Tensor,
                                   size_average : Optional[bool],
                                   reduce : Optional[bool],
                                   reduction : str=mean) -> 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 : str,
          b : str) -> str

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

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

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

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

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

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

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

torch.addcdiv(self : Tensor,
              tensor1 : Tensor,
              tensor2 : Tensor,
              value : number=1) -> 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.count_nonzero(self : Tensor,
                    dim : List[int]) -> Tensor

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

torch.squeeze(self : Tensor) -> 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 : int,
                dim1 : int) -> Tensor

torch.transpose(self : Tensor,
                dim0 : str,
                dim1 : str) -> 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 : List[int]=[1, 1],
                                          dilation : List[int]=[1, 1],
                                          groups : int=1) -> Tensor

torch._C._nn.mse_loss(self : Tensor,
                      target : Tensor,
                      reduction : int=1) -> Tensor

torch._C._nn.mse_loss(self : Tensor,
                      target : Tensor,
                      reduction : int=1,
                      out : Tensor) -> Tensor

torch._C._nn.multi_margin_loss(self : Tensor,
                               target : Tensor,
                               p : number=1,
                               margin : number=1,
                               weight : Optional[Tensor],
                               reduction : int=1) -> Tensor

torch._C._nn.multi_margin_loss(self : Tensor,
                               target : Tensor,
                               p : number=1,
                               margin : number=1,
                               weight : Optional[Tensor],
                               reduction : int=1,
                               out : Tensor) -> Tensor

torch._C._nn.multilabel_margin_loss(self : Tensor,
                                    target : Tensor,
                                    reduction : int=1) -> Tensor

torch._C._nn.multilabel_margin_loss(self : Tensor,
                                    target : Tensor,
                                    reduction : int=1,
                                    out : Tensor) -> Tensor

torch._C._nn.nll_loss(self : Tensor,
                      target : Tensor,
                      weight : Optional[Tensor],
                      reduction : int=1,
                      ignore_index : int=-100) -> Tensor

torch._C._nn.nll_loss(self : Tensor,
                      target : Tensor,
                      weight : Optional[Tensor],
                      reduction : int=1,
                      ignore_index : int=-100,
                      out : Tensor) -> Tensor

torch._C._nn.nll_loss2d(self : Tensor,
                        target : Tensor,
                        weight : Optional[Tensor],
                        reduction : int=1,
                        ignore_index : int=-100) -> Tensor

torch._C._nn.nll_loss2d(self : Tensor,
                        target : Tensor,
                        weight : Optional[Tensor],
                        reduction : int=1,
                        ignore_index : int=-100,
                        out : Tensor) -> Tensor

torch._C._nn.one_hot(self : Tensor,
                     num_classes : int=-1) -> Tensor

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

torch._C._nn.slow_conv3d(self : Tensor,
                         weight : Tensor,
                         kernel_size : List[int],
                         bias : Optional[Tensor],
                         stride : List[int]=[1, 1, 1],
                         padding : List[int]=[0, 0, 0],
                         out : Tensor) -> Tensor

torch._C._nn.slow_conv3d(self : Tensor,
                         weight : Tensor,
                         kernel_size : List[int],
                         bias : Optional[Tensor],
                         stride : List[int]=[1, 1, 1],
                         padding : List[int]=[0, 0, 0]) -> Tensor

torch._C._nn.slow_conv_dilated2d(self : Tensor,
                                 weight : Tensor,
                                 kernel_size : List[int],
                                 bias : Optional[Tensor],
                                 stride : List[int]=[1, 1],
                                 padding : List[int]=[0, 0],
                                 dilation : List[int]=[1, 1]) -> Tensor

torch._C._nn.slow_conv_dilated3d(self : Tensor,
                                 weight : Tensor,
                                 kernel_size : List[int],
                                 bias : Optional[Tensor],
                                 stride : List[int]=[1, 1, 1],
                                 padding : List[int]=[0, 0, 0],
                                 dilation : List[int]=[1, 1, 1]) -> Tensor

torch._C._nn.slow_conv_transpose2d(self : Tensor,
                                   weight : Tensor,
                                   kernel_size : List[int],
                                   bias : Optional[Tensor],
                                   stride : List[int]=[1, 1],
                                   padding : List[int]=[0, 0],
                                   output_padding : List[int]=[0, 0],
                                   dilation : List[int]=[1, 1],
                                   out : Tensor) -> Tensor

torch._C._nn.slow_conv_transpose2d(self : Tensor,
                                   weight : Tensor,
                                   kernel_size : List[int],
                                   bias : Optional[Tensor],
                                   stride : List[int]=[1, 1],
                                   padding : List[int]=[0, 0],
                                   output_padding : List[int]=[0, 0],
                                   dilation : List[int]=[1, 1]) -> Tensor

torch._C._nn.slow_conv_transpose3d(self : Tensor,
                                   weight : Tensor,
                                   kernel_size : List[int],
                                   bias : Optional[Tensor],
                                   stride : List[int]=[1, 1, 1],
                                   padding : List[int]=[0, 0, 0],
                                   output_padding : List[int]=[0, 0, 0],
                                   dilation : List[int]=[1, 1, 1],
                                   out : Tensor) -> Tensor

torch._C._nn.slow_conv_transpose3d(self : Tensor,
                                   weight : Tensor,
                                   kernel_size : List[int],
                                   bias : Optional[Tensor],
                                   stride : List[int]=[1, 1, 1],
                                   padding : List[int]=[0, 0, 0],
                                   output_padding : List[int]=[0, 0, 0],
                                   dilation : List[int]=[1, 1, 1]) -> Tensor

torch._C._nn.smooth_l1_loss(self : Tensor,
                            target : Tensor,
                            reduction : int=1) -> Tensor

torch._C._nn.smooth_l1_loss(self : Tensor,
                            target : Tensor,
                            reduction : int=1,
                            out : Tensor) -> Tensor

torch._C._nn.soft_margin_loss(self : Tensor,
                              target : Tensor,
                              reduction : int=1) -> Tensor

torch._C._nn.soft_margin_loss(self : Tensor,
                              target : Tensor,
                              reduction : int=1,
                              out : Tensor) -> Tensor

torch._C._nn.softplus(self : Tensor,
                      beta : number=1,
                      threshold : number=20) -> Tensor

torch._C._nn.softplus(self : Tensor,
                      beta : number=1,
                      threshold : number=20,
                      out : Tensor) -> Tensor

torch._C._nn.softshrink(self : Tensor,
                        lambd : number=0.5,
                        out : Tensor) -> Tensor

torch._C._nn.softshrink(self : Tensor,
                        lambd : number=0.5) -> Tensor

torch._C._nn.thnn_conv2d(self : Tensor,
                         weight : Tensor,
                         kernel_size : List[int],
                         bias : Optional[Tensor],
                         stride : List[int]=[1, 1],
                         padding : List[int]=[0, 0],
                         out : Tensor) -> Tensor

torch._C._nn.thnn_conv2d(self : Tensor,
                         weight : Tensor,
                         kernel_size : List[int],
                         bias : Optional[Tensor],
                         stride : List[int]=[1, 1],
                         padding : List[int]=[0, 0]) -> Tensor

torch._C._nn.thnn_conv_depthwise2d(self : Tensor,
                                   weight : Tensor,
                                   kernel_size : List[int],
                                   bias : Optional[Tensor],
                                   stride : List[int]=[1, 1],
                                   padding : List[int]=[0, 0],
                                   dilation : List[int]=[1, 1],
                                   out : Tensor) -> Tensor

torch._C._nn.thnn_conv_depthwise2d(self : Tensor,
                                   weight : Tensor,
                                   kernel_size : List[int],
                                   bias : Optional[Tensor],
                                   stride : List[int]=[1, 1],
                                   padding : List[int]=[0, 0],
                                   dilation : List[int]=[1, 1]) -> Tensor

torch._C._nn.upsample_bicubic2d(self : Tensor,
                                output_size : List[int],
                                align_corners : bool,
                                scales_h : Optional[float],
                                scales_w : Optional[float],
                                out : Tensor) -> Tensor

torch._C._nn.upsample_bicubic2d(self : Tensor,
                                output_size : List[int],
                                align_corners : bool,
                                scales_h : Optional[float],
                                scales_w : Optional[float]) -> Tensor

torch._C._nn.upsample_bilinear2d(self : Tensor,
                                 output_size : List[int],
                                 align_corners : bool,
                                 scales_h : Optional[float],
                                 scales_w : Optional[float],
                                 out : Tensor) -> Tensor

torch._C._nn.upsample_bilinear2d(self : Tensor,
                                 output_size : List[int],
                                 align_corners : bool,
                                 scales_h : Optional[float],
                                 scales_w : Optional[float]) -> Tensor

torch._C._nn.upsample_linear1d(self : Tensor,
                               output_size : List[int],
                               align_corners : bool,
                               scales : Optional[float],
                               out : Tensor) -> Tensor

torch._C._nn.upsample_linear1d(self : Tensor,
                               output_size : List[int],
                               align_corners : bool,
                               scales : Optional[float]) -> Tensor

torch._C._nn.upsample_nearest1d(self : Tensor,
                                output_size : List[int],
                                scales : Optional[float],
                                out : Tensor) -> Tensor

torch._C._nn.upsample_nearest1d(self : Tensor,
                                output_size : List[int],
                                scales : Optional[float]) -> Tensor

torch._C._nn.upsample_nearest2d(self : Tensor,
                                output_size : List[int],
                                scales_h : Optional[float],
                                scales_w : Optional[float],
                                out : Tensor) -> Tensor

torch._C._nn.upsample_nearest2d(self : Tensor,
                                output_size : List[int],
                                scales_h : Optional[float],
                                scales_w : Optional[float]) -> Tensor

torch._C._nn.upsample_nearest3d(self : Tensor,
                                output_size : List[int],
                                scales_d : Optional[float],
                                scales_h : Optional[float],
                                scales_w : Optional[float],
                                out : Tensor) -> Tensor

torch._C._nn.upsample_nearest3d(self : Tensor,
                                output_size : List[int],
                                scales_d : Optional[float],
                                scales_h : Optional[float],
                                scales_w : Optional[float]) -> Tensor

torch._C._nn.upsample_trilinear3d(self : Tensor,
                                  output_size : List[int],
                                  align_corners : bool,
                                  scales_d : Optional[float],
                                  scales_h : Optional[float],
                                  scales_w : Optional[float],
                                  out : Tensor) -> Tensor

torch._C._nn.upsample_trilinear3d(self : Tensor,
                                  output_size : List[int],
                                  align_corners : bool,
                                  scales_d : Optional[float],
                                  scales_h : Optional[float],
                                  scales_w : Optional[float]) -> Tensor

TorchScript Builtin Functions

collections.OrderedDict(inputs : List[Tuple[str, tVal]]) -> Dict[str, tVal]

collections.OrderedDict(inputs : List[Tuple[int, tVal]]) -> Dict[int, tVal]

collections.OrderedDict(inputs : List[Tuple[float, tVal]]) -> Dict[float, tVal]

collections.OrderedDict(inputs : List[Tuple[Tensor, tVal]]) -> Dict[Tensor, tVal]

collections.OrderedDict() -> Dict[str, Tensor]

builtins.dict(inputs : List[Tuple[str, tVal]]) -> Dict[str, tVal]

builtins.dict(inputs : List[Tuple[int, tVal]]) -> Dict[int, tVal]

builtins.dict(inputs : List[Tuple[float, tVal]]) -> Dict[float, tVal]

builtins.dict(inputs : List[Tuple[Tensor, tVal]]) -> Dict[Tensor, tVal]

builtins.dict() -> Dict[str, Tensor]

torch.backends.cudnn.is_acceptable(self : Tensor) -> bool

torch.autograd.grad(outputs : List[Tensor],
                    inputs : List[Tensor],
                    grad_outputs : Optional[List[Optional[Tensor]]],
                    retain_graph : Optional[bool],
                    create_graph : bool=False,
                    allow_unused : bool=False) -> List[Optional[Tensor]]

torch.autograd.backward(tensors : List[Tensor],
                        grad_tensors : Optional[List[Optional[Tensor]]],
                        retain_graph : Optional[bool],
                        create_graph : bool=False) -> Tuple[]

torch.autograd.backward(self : Tensor,
                        gradient : Optional[Tensor],
                        retain_graph : Optional[bool],
                        create_graph : bool=False) -> Tuple[]

torch.Size(sizes : List[int]) -> List[int]

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

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

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

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

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

torch.device(a : str) -> Device

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

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

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

torch.qscheme(self : Tensor) -> QScheme

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

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

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

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

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

torch.distributed.autograd.get_gradients(context_id : int) -> Dict[Tensor, Tensor]

torch.distributed.autograd.backward(context_id : int,
                                    roots : List[Tensor],
                                    retain_graph : bool=False) -> Tuple[]

Python Built-in Functions

The functions in the following table are supported but do not have a static schema

Function

Note

print

Print any value

tuple

Lists cannot be converted to tuples with this method since their size is not statically known

getattr

Attribute name must be a literal string

hasattr

Attribute name must be a literal string

isinstance

Result is static

range

Can only be used as an iterator in a for loop

zip

Arguments must be iterable. See Iterables for details.

enumerate

Arguments must be iterable. See Iterables for details.

The following functions will use the corresponding magic method on TorchScript Classes

Function

Magic Method

float

__float__

int

__int__

bool

__bool__

str

__str__

len

__len__

hex

__hex__

oct

__oct__

These built-in functions use the schema

float(a : Tensor) -> float
float(a : number) -> float
float(a : int) -> float
float(a : bool) -> float
float(a : str) -> float

int(a : Tensor) -> int
int(a : bool) -> int
int(a : float) -> int
int(a : number) -> int
int(a : str) -> int

bool(a : Tensor) -> bool
bool(a : int) -> bool
bool(a : float) -> bool

str(elem : t) -> str

len(s : str) -> int
len(a : List[t]) -> int
len(t : Tensor) -> int
len(self : Dict[str, t]) -> int
len(self : Dict[int, t]) -> int
len(self : Dict[float, t]) -> int
len(self : Dict[Tensor, t]) -> int
len(a : List[Any]) -> int

hex(i : int) -> str

oct(i : int) -> str

round(self : Tensor) -> Tensor
round(self : Tensor,
      out : Tensor) -> Tensor
round(a : int) -> float
round(a : float) -> float
round(a : number) -> number

hash(t : str) -> int
hash(t : int) -> int
hash(t : float) -> int

min(a : int,
    b : int) -> int
min(a : float,
    b : float) -> float
min(a : int,
    b : float) -> float
min(a : float,
    b : int) -> float
min(a : number,
    b : number) -> number
min(l : List[int],
    r : List[int]) -> List[int]
min(self : List[int]) -> int
min(l : List[float],
    r : List[float]) -> List[float]
min(self : List[float]) -> float
min(l : List[bool],
    r : List[bool]) -> List[bool]
min(self : List[bool]) -> bool

max(a : int,
    b : int) -> int
max(a : float,
    b : float) -> float
max(a : int,
    b : float) -> float
max(a : float,
    b : int) -> float
max(a : number,
    b : number) -> number
max(l : List[int],
    r : List[int]) -> List[int]
max(self : List[int]) -> int
max(l : List[float],
    r : List[float]) -> List[float]
max(self : List[float]) -> float
max(l : List[bool],
    r : List[bool]) -> List[bool]
max(self : List[bool]) -> bool

abs(a : int) -> int
abs(a : float) -> float
abs(a : number) -> number
abs(x : Tensor) -> Tensor

all(self : Tensor) -> Tensor
all(self : Tensor,
    dim : int,
    keepdim : bool=False) -> Tensor
all(self : Tensor,
    dim : int,
    keepdim : bool=False,
    out : Tensor) -> Tensor
all(self : Tensor,
    dim : str,
    keepdim : bool=False) -> Tensor
all(self : Tensor,
    dim : str,
    keepdim : bool=False,
    out : Tensor) -> Tensor
all(self : List[int]) -> bool
all(self : List[float]) -> bool
all(self : List[bool]) -> bool

divmod(x : int,
       y : int) -> Tuple[int, int]
divmod(x : float,
       y : float) -> Tuple[float, float]
divmod(x : int,
       y : float) -> Tuple[float, float]
divmod(x : float,
       y : int) -> Tuple[float, float]

list(t : str) -> List[str]
list(l : List[t]) -> List[t]

ord(string : str) -> int

chr(i : int) -> str

bin(i : int) -> str

sorted(input : List[int]) -> List[int]
sorted(input : List[float]) -> List[float]
sorted(input : List[Tensor]) -> List[Tensor]
sorted(input : List[bool]) -> List[bool]
sorted(self : List[t]) -> List[t]

math Module

math.ceil(a : int) -> int

math.ceil(a : float) -> int

math.ceil(a : number) -> number

math.copysign(a : int,
              b : int) -> float

math.copysign(a : float,
              b : float) -> float

math.copysign(a : int,
              b : float) -> float

math.copysign(a : float,
              b : int) -> float

math.copysign(a : number,
              b : number) -> float

math.erf(a : int) -> float

math.erf(a : float) -> float

math.erf(a : number) -> number

math.erfc(a : int) -> float

math.erfc(a : float) -> float

math.erfc(a : number) -> number

math.exp(a : int) -> float

math.exp(a : float) -> float

math.exp(a : number) -> number

math.expm1(a : int) -> float

math.expm1(a : float) -> float

math.expm1(a : number) -> number

math.fabs(a : int) -> float

math.fabs(a : float) -> float

math.fabs(a : number) -> number

math.floor(a : int) -> int

math.floor(a : float) -> int

math.floor(a : number) -> number

math.gamma(a : int) -> float

math.gamma(a : float) -> float

math.gamma(a : number) -> number

math.lgamma(a : int) -> float

math.lgamma(a : float) -> float

math.lgamma(a : number) -> number

math.log(a : int) -> float

math.log(a : float) -> float

math.log(a : number) -> number

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

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

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

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

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

math.log10(a : int) -> float

math.log10(a : float) -> float

math.log10(a : number) -> number

math.log1p(a : int) -> float

math.log1p(a : float) -> float

math.log1p(a : number) -> number

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

math.pow(a : float,
         b : float) -> float

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

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

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

math.pow(a : int,
         b : int) -> int

math.sqrt(a : int) -> float

math.sqrt(a : float) -> float

math.sqrt(a : number) -> number

math.isnan(a : float) -> bool

math.asinh(a : int) -> float

math.asinh(a : float) -> float

math.asinh(a : number) -> number

math.atanh(a : int) -> float

math.atanh(a : float) -> float

math.atanh(a : number) -> number

math.cosh(a : int) -> float

math.cosh(a : float) -> float

math.cosh(a : number) -> number

math.sinh(a : int) -> float

math.sinh(a : float) -> float

math.sinh(a : number) -> number

math.tanh(a : int) -> float

math.tanh(a : float) -> float

math.tanh(a : number) -> number

math.acos(a : int) -> float

math.acos(a : float) -> float

math.acos(a : number) -> number

math.asin(a : int) -> float

math.asin(a : float) -> float

math.asin(a : number) -> number

math.atan(a : int) -> float

math.atan(a : float) -> float

math.atan(a : number) -> number

math.atan2(a : int,
           b : int) -> float

math.atan2(a : float,
           b : float) -> float

math.atan2(a : int,
           b : float) -> float

math.atan2(a : float,
           b : int) -> float

math.atan2(a : number,
           b : number) -> float

math.cos(a : int) -> float

math.cos(a : float) -> float

math.cos(a : number) -> number

math.sin(a : int) -> float

math.sin(a : float) -> float

math.sin(a : number) -> number

math.tan(a : int) -> float

math.tan(a : float) -> float

math.tan(a : number) -> number

math.asinh(a : int) -> float

math.asinh(a : float) -> float

math.asinh(a : number) -> number

math.atanh(a : int) -> float

math.atanh(a : float) -> float

math.atanh(a : number) -> number

math.acosh(a : int) -> float

math.acosh(a : float) -> float

math.acosh(a : number) -> number

math.sinh(a : int) -> float

math.sinh(a : float) -> float

math.sinh(a : number) -> number

math.cosh(a : int) -> float

math.cosh(a : float) -> float

math.cosh(a : number) -> number

math.tanh(a : int) -> float

math.tanh(a : float) -> float

math.tanh(a : number) -> number

math.fmod(a : int,
          b : int) -> float

math.fmod(a : float,
          b : float) -> float

math.fmod(a : int,
          b : float) -> float

math.fmod(a : float,
          b : int) -> float

math.fmod(a : number,
          b : number) -> float

math.modf(a : float) -> Tuple[float, float]

math.factorial(a : int) -> int

math.frexp(a : float) -> Tuple[float, int]

math.isnan(a : float) -> bool

math.isinf(a : float) -> bool

math.degrees(a : int) -> float

math.degrees(a : float) -> float

math.degrees(a : number) -> number

math.radians(a : int) -> float

math.radians(a : float) -> float

math.radians(a : number) -> number

math.ldexp(x : float,
           i : int) -> float

math.gcd(a : int,
         b : int) -> int

math.isfinite(a : float) -> bool

math.remainder(a : int,
               b : int) -> float

math.remainder(a : float,
               b : float) -> float

math.remainder(a : int,
               b : float) -> float

math.remainder(a : float,
               b : int) -> float

math.remainder(a : number,
               b : number) -> float

Docs

Access comprehensive developer documentation for PyTorch

View Docs

Tutorials

Get in-depth tutorials for beginners and advanced developers

View Tutorials

Resources

Find development resources and get your questions answered

View Resources