torch.cumsumtorch.cumsum(input, dim, , dtype=None, out=None) -> Tensor
   Returns the cumulative sum of elements of "input" in the dimension
   "dim".
   For example, if "input" is a vector of size N, the result will also
   be a vector of size N, with elements.
      y_i = x_1 + x_2 + x_3 + \dots + x_i
   Parameters:
      * input (Tensor) -- the input tensor.
      * dim (int) -- the dimension to do the operation over
   Keyword Arguments:
      * dtype ("torch.dtype", optional) -- the desired data type
        of returned tensor. If specified, the input tensor is casted
        to "dtype" before the operation is performed. This is useful
        for preventing data type overflows. Default: None.
      * out (Tensor, optional*) -- the output tensor.
   Example:
      >>> a = torch.randn(10)
      >>> a
      tensor([-0.8286, -0.4890,  0.5155,  0.8443,  0.1865, -0.1752, -2.0595,
               0.1850, -1.1571, -0.4243])
      >>> torch.cumsum(a, dim=0)


torch.cumsum(a, dim=0)
      tensor([-0.8286, -1.3175, -0.8020,  0.0423,  0.2289,  0.0537, -2.0058,
              -1.8209, -2.9780, -3.4022])


torch.autograd.graph.Node.nameabstract Node.name()
   Returns the name.
   Example:
      >>> import torch
      >>> a = torch.tensor([0., 0., 0.], requires_grad=True)
      >>> b = a.clone()
      >>> assert isinstance(b.grad_fn, torch.autograd.graph.Node)
      >>> print(b.grad_fn.name())
      CloneBackward0
   Return type:
      str


set_multithreading_enabledclass torch.autograd.set_multithreading_enabled(mode)
   Context-manager that sets multithreaded backwards on or off.
   "set_multithreading_enabled" will enable or disable multithreaded
   backwards based on its argument "mode". It can be used as a
   context-manager or as a function.
   This context manager is thread local; it will not affect
   computation in other threads.
   Parameters:
      mode (bool) -- Flag whether to enable multithreaded
      backwards ("True"), or disable ("False").
   Note:
     This API does not apply to forward-mode AD.


torch.Tensor.is_pinnedTensor.is_pinned()
   Returns true if this tensor resides in pinned memory.


torch.signal.windows.gaussiantorch.signal.windows.gaussian(M, , std=1.0, sym=True, dtype=None, layout=torch.strided, device=None, requires_grad=False)
   Computes a window with a gaussian waveform.
   The gaussian window is defined as follows:
      w_n = \exp{\left(-\left(\frac{n}{2\sigma}\right)^2\right)}
   The window is normalized to 1 (maximum value is 1). However, the 1
   doesn't appear if "M" is even and "sym" is True.
   Parameters:
      M (int) -- the length of the window. In other words, the
      number of points of the returned window.
   Keyword Arguments:
      * std (float, optional) -- the standard deviation of
        the gaussian. It controls how narrow or wide the window is.
        Default: 1.0.
      * sym (bool, optional) -- If False, returns a
        periodic window suitable for use in spectral analysis. If
        True, returns a symmetric window suitable for use in filter
        design. Default: True*.


design. Default: True.
      * dtype ("torch.dtype", optional) -- the desired data type
        of returned tensor. Default: if "None", uses a global default
        (see "torch.set_default_tensor_type()").
      * layout ("torch.layout", optional) -- the desired layout of
        returned Tensor. Default: "torch.strided".
      * device ("torch.device", optional) -- the desired device of
        returned tensor. Default: if "None", uses the current device
        for the default tensor type (see
        "torch.set_default_tensor_type()"). "device" will be the CPU
        for CPU tensor types and the current CUDA device for CUDA
        tensor types.
      * requires_grad (bool, optional) -- If autograd should
        record operations on the returned tensor. Default: "False".
   Return type:
      Tensor
   Examples:
      >>> # Generates a symmetric gaussian window with a standard deviation of 1.0.
      >>> torch.signal.windows.gaussian(10)


torch.signal.windows.gaussian(10)
      tensor([4.0065e-05, 2.1875e-03, 4.3937e-02, 3.2465e-01, 8.8250e-01, 8.8250e-01, 3.2465e-01, 4.3937e-02, 2.1875e-03, 4.0065e-05])
      >>> # Generates a periodic gaussian window and standard deviation equal to 0.9.
      >>> torch.signal.windows.gaussian(10, sym=False,std=0.9)
      tensor([1.9858e-07, 5.1365e-05, 3.8659e-03, 8.4658e-02, 5.3941e-01, 1.0000e+00, 5.3941e-01, 8.4658e-02, 3.8659e-03, 5.1365e-05])


torch.Tensor.isposinfTensor.isposinf() -> Tensor
   See "torch.isposinf()"


torch.Tensor.gatherTensor.gather(dim, index) -> Tensor
   See "torch.gather()"


torch.linalg.lu_factortorch.linalg.lu_factor(A, , bool pivot=True, out=None) -> (Tensor, Tensor)
   Computes a compact representation of the LU factorization with
   partial pivoting of a matrix.
   This function computes a compact representation of the
   decomposition given by "torch.linalg.lu()". If the matrix is
   square, this representation may be used in
   "torch.linalg.lu_solve()" to solve system of linear equations that
   share the matrix "A".
   The returned decomposition is represented as a named tuple (LU,
   pivots). The "LU" matrix has the same shape as the input matrix
   "A". Its upper and lower triangular parts encode the non-constant
   elements of "L" and "U" of the LU decomposition of "A".
   The returned permutation matrix is represented by a 1-indexed
   vector. pivots[i] == j represents that in the i-th step of the
   algorithm, the i-th row was permuted with the j-1-th row.
   On CUDA, one may use "pivot"= False*. In this case, this function


returns the LU decomposition without pivoting if it exists.
   Supports inputs of float, double, cfloat and cdouble dtypes. Also
   supports batches of matrices, and if the inputs are batches of
   matrices then the output has the same batch dimensions.
   Note:
     When inputs are on a CUDA device, this function synchronizes that
     device with the CPU. For a version of this function that does not
     synchronize, see "torch.linalg.lu_factor_ex()".
   Warning:
     The LU decomposition is almost never unique, as often there are
     different permutation matrices that can yield different LU
     decompositions. As such, different platforms, like SciPy, or
     inputs on different devices, may produce different valid
     decompositions.Gradient computations are only supported if the
     input matrix is full-rank. If this condition is not met, no error
     will be thrown, but the gradient may not be finite. This is
     because the LU decomposition with pivoting is not differentiable


at these points.
   See also:
     "torch.linalg.lu_solve()" solves a system of linear equations
     given the output of this function provided the input matrix was
     square and invertible.
     "torch.lu_unpack()" unpacks the tensors returned by "lu_factor()"
     into the three matrices P, L, U that form the decomposition.
     "torch.linalg.lu()" computes the LU decomposition with partial
     pivoting of a possibly non-square matrix. It is a composition of
     "lu_factor()" and "torch.lu_unpack()".
     "torch.linalg.solve()" solves a system of linear equations. It is
     a composition of "lu_factor()" and "lu_solve()".
   Parameters:
      A (Tensor) -- tensor of shape (, m, n) where *** is
      zero or more batch dimensions.
   Keyword Arguments:
      * pivot (bool, optional) -- Whether to compute the LU
        decomposition with partial pivoting, or the regular LU
        decomposition. "pivot"= False not supported on CPU. Default:
        True*.


True.
      * out (tuple, optional) -- tuple of two tensors to
        write the output to. Ignored if None. Default: None.
   Returns:
      A named tuple (LU, pivots).
   Raises:
      RuntimeError -- if the "A" matrix is not invertible or any
      matrix in a batched "A"     is not invertible.
   Examples:
      >>> A = torch.randn(2, 3, 3)
      >>> B1 = torch.randn(2, 3, 4)
      >>> B2 = torch.randn(2, 3, 7)
      >>> A_factor = torch.linalg.lu_factor(A)
      >>> X1 = torch.linalg.lu_solve(A_factor, B1)
      >>> X2 = torch.linalg.lu_solve(A_factor, B2)
      >>> torch.allclose(A @ X1, B1)
      True
      >>> torch.allclose(A @ X2, B2)
      True


torch.logical_nottorch.logical_not(input, , out=None) -> Tensor
   Computes the element-wise logical NOT of the given input tensor. If
   not specified, the output tensor will have the bool dtype. If the
   input tensor is not a bool tensor, zeros are treated as "False" and
   non-zeros are treated as "True".
   Parameters:
      input (Tensor) -- the input tensor.
   Keyword Arguments:
      out (Tensor, optional*) -- the output tensor.
   Example:
      >>> torch.logical_not(torch.tensor([True, False]))
      tensor([False,  True])
      >>> torch.logical_not(torch.tensor([0, 1, -10], dtype=torch.int8))
      tensor([ True, False, False])
      >>> torch.logical_not(torch.tensor([0., 1.5, -10.], dtype=torch.double))
      tensor([ True, False, False])
      >>> torch.logical_not(torch.tensor([0., 1., -10.], dtype=torch.double), out=torch.empty(3, dtype=torch.int16))
      tensor([1, 0, 0], dtype=torch.int16)


LazyConvTranspose3dclass torch.nn.LazyConvTranspose3d(out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, padding_mode='zeros', device=None, dtype=None)
   A "torch.nn.ConvTranspose3d" module with lazy initialization of the
   "in_channels" argument of the "ConvTranspose3d" that is inferred
   from the "input.size(1)". The attributes that will be lazily
   initialized are weight and bias.
   Check the "torch.nn.modules.lazy.LazyModuleMixin" for further
   documentation on lazy modules and their limitations.
   Parameters:
      * out_channels (int) -- Number of channels produced by the
        convolution
      * kernel_size (int or tuple) -- Size of the convolving
        kernel
      * stride (int or tuple, optional) -- Stride of the
        convolution. Default: 1
      * padding (int or tuple, optional) -- "dilation *
        (kernel_size - 1) - padding" zero-padding will be added to


both sides of each dimension in the input. Default: 0
      * output_padding (int or tuple, optional) --
        Additional size added to one side of each dimension in the
        output shape. Default: 0
      * groups (int, optional) -- Number of blocked
        connections from input channels to output channels. Default: 1
      * bias (bool, optional) -- If "True", adds a learnable
        bias to the output. Default: "True"
      * dilation (int or tuple, optional) -- Spacing
        between kernel elements. Default: 1
   See also:
     "torch.nn.ConvTranspose3d" and
     "torch.nn.modules.lazy.LazyModuleMixin"
   cls_to_become
      alias of "ConvTranspose3d"


torch.Tensor.logitTensor.logit() -> Tensor
   See "torch.logit()"


torch.nn.functional.hardtanh_torch.nn.functional.hardtanh_(input, min_val=- 1., max_val=1.) -> Tensor
   In-place version of "hardtanh()".


torch.cuda.reset_max_memory_allocatedtorch.cuda.reset_max_memory_allocated(device=None)
   Resets the starting point in tracking maximum GPU memory occupied
   by tensors for a given device.
   See "max_memory_allocated()" for details.
   Parameters:
      device (torch.device or int, optional) -- selected
      device. Returns statistic for the current device, given by
      "current_device()", if "device" is "None" (default).
   Warning:
     This function now calls "reset_peak_memory_stats()", which resets
     /all/ peak memory stats.
   Note:
     See Memory management for more details about GPU memory
     management.


torch.Tensor.dense_dimTensor.dense_dim() -> int
   Return the number of dense dimensions in a sparse tensor "self".
   Note:
     Returns "len(self.shape)" if "self" is not a sparse tensor.
   See also "Tensor.sparse_dim()" and hybrid tensors.


torch.Tensor.expm1_Tensor.expm1_() -> Tensor
   In-place version of "expm1()"


torch.cuda.initial_seedtorch.cuda.initial_seed()
   Returns the current random seed of the current GPU.
   Warning:
     This function eagerly initializes CUDA.
   Return type:
      int


torch.Tensor.pow_Tensor.pow_(exponent) -> Tensor
   In-place version of "pow()"


PruningContainerclass torch.nn.utils.prune.PruningContainer(args)
   Container holding a sequence of pruning methods for iterative
   pruning. Keeps track of the order in which pruning methods are
   applied and handles combining successive pruning calls.
   Accepts as argument an instance of a BasePruningMethod or an
   iterable of them.
   add_pruning_method(method)
      Adds a child pruning "method" to the container.
      Parameters:
         method (subclass of BasePruningMethod) -- child pruning
         method to be added to the container.
   classmethod apply(module, name, args, importance_scores=None, kwargs)
      Adds the forward pre-hook that enables pruning on the fly and
      the reparametrization of a tensor in terms of the original
      tensor and the pruning mask.
      Parameters:
         * module (nn.Module) -- module containing the tensor to
           prune
         * name (str) -- parameter name within "module" on which


pruning will act.
         * args -- arguments passed on to a subclass of
           "BasePruningMethod"
         * importance_scores (torch.Tensor) -- tensor of
           importance scores (of same shape as module parameter) used
           to compute mask for pruning. The values in this tensor
           indicate the importance of the corresponding elements in
           the parameter being pruned. If unspecified or None, the
           parameter will be used in its place.
         * kwargs -- keyword arguments passed on to a subclass of
           a "BasePruningMethod"
   apply_mask(module)
      Simply handles the multiplication between the parameter being
      pruned and the generated mask. Fetches the mask and the original
      tensor from the module and returns the pruned version of the
      tensor.
      Parameters:
         module (nn.Module) -- module containing the tensor to
         prune
      Returns:
         pruned version of the input tensor


pruned version of the input tensor
      Return type:
         pruned_tensor (torch.Tensor)
   compute_mask(t, default_mask)
      Applies the latest "method" by computing the new partial masks
      and returning its combination with the "default_mask". The new
      partial mask should be computed on the entries or channels that
      were not zeroed out by the "default_mask". Which portions of the
      tensor "t" the new mask will be calculated from depends on the
      "PRUNING_TYPE" (handled by the type handler):
      * for 'unstructured', the mask will be computed from the raveled
        list of nonmasked entries;
      * for 'structured', the mask will be computed from the nonmasked
        channels in the tensor;
      * for 'global', the mask will be computed across all entries.
      Parameters:
         * t (torch.Tensor) -- tensor representing the parameter
           to prune (of same dimensions as "default_mask").


default_mask (torch.Tensor) -- mask from previous
           pruning iteration.
      Returns:
         new mask that combines the effects of the "default_mask" and
         the new mask from the current pruning "method" (of same
         dimensions as "default_mask" and "t").
      Return type:
         mask (torch.Tensor)
   prune(t, default_mask=None, importance_scores=None)
      Computes and returns a pruned version of input tensor "t"
      according to the pruning rule specified in "compute_mask()".
      Parameters:
         * t (torch.Tensor) -- tensor to prune (of same
           dimensions as "default_mask").
         * importance_scores (torch.Tensor) -- tensor of
           importance scores (of same shape as "t") used to compute
           mask for pruning "t". The values in this tensor indicate
           the importance of the corresponding elements in the "t"
           that is being pruned. If unspecified or None, the tensor


"t" will be used in its place.
         * default_mask (torch.Tensor, optional) -- mask
           from previous pruning iteration, if any. To be considered
           when determining what portion of the tensor that pruning
           should act on. If None, default to a mask of ones.
      Returns:
         pruned version of tensor "t".
   remove(module)
      Removes the pruning reparameterization from a module. The pruned
      parameter named "name" remains permanently pruned, and the
      parameter named "name+'_orig'" is removed from the parameter
      list. Similarly, the buffer named "name+'_mask'" is removed from
      the buffers.
      Note:
        Pruning itself is NOT undone or reversed!


torch.permutetorch.permute(input, dims) -> Tensor
   Returns a view of the original tensor "input" with its dimensions
   permuted.
   Parameters:
      * input (Tensor) -- the input tensor.
      * dims (tuple of python:int) -- The desired ordering of
        dimensions
   -[ Example ]-

x = torch.randn(2, 3, 5)
x.size()
   torch.Size([2, 3, 5])
torch.permute(x, (2, 0, 1)).size()
   torch.Size([5, 2, 3])


torch.Tensor.le_Tensor.le_(other) -> Tensor
   In-place version of "le()".


torch.movedimtorch.movedim(input, source, destination) -> Tensor
   Moves the dimension(s) of "input" at the position(s) in "source" to
   the position(s) in "destination".
   Other dimensions of "input" that are not explicitly moved remain in
   their original order and appear at the positions not specified in
   "destination".
   Parameters:
      * input (Tensor) -- the input tensor.
      * source (int or tuple of ints) -- Original positions
        of the dims to move. These must be unique.
      * destination (int or tuple of ints) -- Destination
        positions for each of the original dims. These must also be
        unique.
   Examples:
      >>> t = torch.randn(3,2,1)
      >>> t
      tensor([[[-0.3362],
              [-0.8437]],
              [[-0.9627],
              [ 0.1727]],
              [[ 0.5173],
              [-0.1398]]])
      >>> torch.movedim(t, 1, 0).shape
      torch.Size([2, 3, 1])
      >>> torch.movedim(t, 1, 0)
      tensor([[[-0.3362],


tensor([[[-0.3362],
              [-0.9627],
              [ 0.5173]],
              [[-0.8437],
              [ 0.1727],
              [-0.1398]]])
      >>> torch.movedim(t, (1, 2), (0, 1)).shape
      torch.Size([2, 1, 3])
      >>> torch.movedim(t, (1, 2), (0, 1))
      tensor([[[-0.3362, -0.9627,  0.5173]],
              [[-0.8437,  0.1727, -0.1398]]])


CustomFromMaskclass torch.nn.utils.prune.CustomFromMask(mask)
   classmethod apply(module, name, mask)
      Adds the forward pre-hook that enables pruning on the fly and
      the reparametrization of a tensor in terms of the original
      tensor and the pruning mask.
      Parameters:
         * module (nn.Module) -- module containing the tensor to
           prune
         * name (str) -- parameter name within "module" on which
           pruning will act.
   apply_mask(module)
      Simply handles the multiplication between the parameter being
      pruned and the generated mask. Fetches the mask and the original
      tensor from the module and returns the pruned version of the
      tensor.
      Parameters:
         module (nn.Module) -- module containing the tensor to
         prune
      Returns:
         pruned version of the input tensor
      Return type:
         pruned_tensor (torch.Tensor)
   prune(t, default_mask=None, importance_scores=None)


Computes and returns a pruned version of input tensor "t"
      according to the pruning rule specified in "compute_mask()".
      Parameters:
         * t (torch.Tensor) -- tensor to prune (of same
           dimensions as "default_mask").
         * importance_scores (torch.Tensor) -- tensor of
           importance scores (of same shape as "t") used to compute
           mask for pruning "t". The values in this tensor indicate
           the importance of the corresponding elements in the "t"
           that is being pruned. If unspecified or None, the tensor
           "t" will be used in its place.
         * default_mask (torch.Tensor, optional) -- mask
           from previous pruning iteration, if any. To be considered
           when determining what portion of the tensor that pruning
           should act on. If None, default to a mask of ones.
      Returns:
         pruned version of tensor "t".
   remove(module)


remove(module)
      Removes the pruning reparameterization from a module. The pruned
      parameter named "name" remains permanently pruned, and the
      parameter named "name+'_orig'" is removed from the parameter
      list. Similarly, the buffer named "name+'_mask'" is removed from
      the buffers.
      Note:
        Pruning itself is NOT undone or reversed!


torch.foreach_expm1_torch._foreach_expm1(self: List[Tensor]) -> None
   Apply "torch.expm1()" to each Tensor of the input list.


torch.Tensor.greaterTensor.greater(other) -> Tensor
   See "torch.greater()".


torch.linalg.eigvalshtorch.linalg.eigvalsh(A, UPLO='L', , out=None) -> Tensor
   Computes the eigenvalues of a complex Hermitian or real symmetric
   matrix.
   Letting \mathbb{K} be \mathbb{R} or \mathbb{C}, the eigenvalues
   of a complex Hermitian or real symmetric  matrix A \in
   \mathbb{K}^{n \times n} are defined as the roots (counted with
   multiplicity) of the polynomial p of degree n given by
      p(\lambda) = \operatorname{det}(A - \lambda
      \mathrm{I}_n)\mathrlap{\qquad \lambda \in \mathbb{R}}
   where \mathrm{I}_n is the n*-dimensional identity matrix. The
   eigenvalues of a real symmetric or complex Hermitian matrix are
   always real.
   Supports input of float, double, cfloat and cdouble dtypes. Also
   supports batches of matrices, and if "A" is a batch of matrices
   then the output has the same batch dimensions.
   The eigenvalues are returned in ascending order.
   "A" is assumed to be Hermitian (resp. symmetric), but this is not


checked internally, instead:
   * If "UPLO"= 'L' (default), only the lower triangular part of the
     matrix is used in the computation.
   * If "UPLO"= 'U', only the upper triangular part of the matrix is
     used.
   Note:
     When inputs are on a CUDA device, this function synchronizes that
     device with the CPU.
   See also:
     "torch.linalg.eigh()" computes the full eigenvalue decomposition.
   Parameters:
      * A (Tensor) -- tensor of shape (, n, n) where *** is
        zero or more batch dimensions consisting of symmetric or
        Hermitian matrices.
      * UPLO ('L', 'U', optional) -- controls whether to
        use the upper or lower triangular part of "A" in the
        computations. Default: 'L'.
   Keyword Arguments:
      out (Tensor, optional) -- output tensor. Ignored if
      None. Default: None*.
   Returns:
      A real-valued tensor containing the eigenvalues even when "A" is


complex. The eigenvalues are returned in ascending order.
   Examples:
      >>> A = torch.randn(2, 2, dtype=torch.complex128)
      >>> A = A + A.T.conj()  # creates a Hermitian matrix
      >>> A
      tensor([[2.9228+0.0000j, 0.2029-0.0862j],
              [0.2029+0.0862j, 0.3464+0.0000j]], dtype=torch.complex128)
      >>> torch.linalg.eigvalsh(A)
      tensor([0.3277, 2.9415], dtype=torch.float64)
      >>> A = torch.randn(3, 2, 2, dtype=torch.float64)
      >>> A = A + A.mT  # creates a batch of symmetric matrices
      >>> torch.linalg.eigvalsh(A)
      tensor([[ 2.5797,  3.4629],
              [-4.1605,  1.3780],
              [-3.1113,  2.7381]], dtype=torch.float64)


torch.nn.functional.adaptive_max_pool3dtorch.nn.functional.adaptive_max_pool3d(args, kwargs)
   Applies a 3D adaptive max pooling over an input signal composed of
   several input planes.
   See "AdaptiveMaxPool3d" for details and output shape.
   Parameters:
      * output_size -- the target output size (single integer or
        triple-integer tuple)
      * return_indices* -- whether to return pooling indices.
        Default: "False"


torch.mvtorch.mv(input, vec, , out=None) -> Tensor
   Performs a matrix-vector product of the matrix "input" and the
   vector "vec".
   If "input" is a (n \times m) tensor, "vec" is a 1-D tensor of size
   m, "out" will be 1-D of size n.
   Note:
     This function does not broadcast.
   Parameters:
      * input (Tensor) -- matrix to be multiplied
      * vec (Tensor) -- vector to be multiplied
   Keyword Arguments:
      out (Tensor, optional*) -- the output tensor.
   Example:
      >>> mat = torch.randn(2, 3)
      >>> vec = torch.randn(3)
      >>> torch.mv(mat, vec)
      tensor([ 1.0404, -0.6361])


torch.Tensor.medianTensor.median(dim=None, keepdim=False)
   See "torch.median()"


default_qat_qconfigtorch.quantization.qconfig.default_qat_qconfig
   alias of QConfig(activation=functools.partial(,
   observer=,
   quant_min=0, quant_max=255, dtype=torch.quint8,
   qscheme=torch.per_tensor_affine, reduce_range=True){},
   weight=functools.partial(,
   observer=,
   quant_min=-128, quant_max=127, dtype=torch.qint8,
   qscheme=torch.per_tensor_symmetric, reduce_range=False){})


torch.Tensor.set_Tensor.set_(source=None, storage_offset=0, size=None, stride=None) -> Tensor
   Sets the underlying storage, size, and strides. If "source" is a
   tensor, "self" tensor will share the same storage and have the same
   size and strides as "source". Changes to elements in one tensor
   will be reflected in the other.
   If "source" is a "Storage", the method sets the underlying storage,
   offset, size, and stride.
   Parameters:
      * source (Tensor or Storage) -- the tensor or storage
        to use
      * storage_offset (int, optional) -- the offset in the
        storage
      * size (torch.Size, optional) -- the desired size.
        Defaults to the size of the source.
      * stride (tuple, optional) -- the desired stride.
        Defaults to C-contiguous strides.


torch.amaxtorch.amax(input, dim, keepdim=False, , out=None) -> Tensor
   Returns the maximum value of each slice of the "input" tensor in
   the given dimension(s) "dim".
   Note:
     The difference between "max"/"min" and "amax"/"amin" is:
        * "amax"/"amin" supports reducing on multiple dimensions,
        * "amax"/"amin" does not return indices,
        * "amax"/"amin" evenly distributes gradient between equal
          values, while "max(dim)"/"min(dim)" propagates gradient only
          to a single index in the source tensor.
   If "keepdim" is "True", the output tensor is of the same size as
   "input" except in the dimension(s) "dim" where it is of size 1.
   Otherwise, "dim" is squeezed (see "torch.squeeze()"), resulting in
   the output tensor having 1 (or "len(dim)") fewer dimension(s).
   Parameters:
      * input (Tensor) -- the input tensor.
      * dim (int or tuple of ints*) -- the dimension or
        dimensions to reduce.


dimensions to reduce.
      * keepdim (bool) -- whether the output tensor has "dim"
        retained or not.
   Keyword Arguments:
      out (Tensor, optional) -- the output tensor.
   Example:
      >>> a = torch.randn(4, 4)
      >>> a
      tensor([[ 0.8177,  1.4878, -0.2491,  0.9130],
              [-0.7158,  1.1775,  2.0992,  0.4817],
              [-0.0053,  0.0164, -1.3738, -0.0507],
              [ 1.9700,  1.1106, -1.0318, -1.0816]])
      >>> torch.amax(a, 1)
      tensor([1.4878, 2.0992, 0.0164, 1.9700])


torch.cuda.manual_seedtorch.cuda.manual_seed(seed)
   Sets the seed for generating random numbers for the current GPU.
   It's safe to call this function if CUDA is not available; in that
   case, it is silently ignored.
   Parameters:
      seed (int) -- The desired seed.
   Warning:
     If you are working with a multi-GPU model, this function is
     insufficient to get determinism.  To seed all GPUs, use
     "manual_seed_all()".


torch.lobpcgtorch.lobpcg(A, k=None, B=None, X=None, n=None, iK=None, niter=None, tol=None, largest=None, method=None, tracker=None, ortho_iparams=None, ortho_fparams=None, ortho_bparams=None)
   Find the k largest (or smallest) eigenvalues and the corresponding
   eigenvectors of a symmetric positive definite generalized
   eigenvalue problem using matrix-free LOBPCG methods.
   This function is a front-end to the following LOBPCG algorithms
   selectable via method argument:
      method="basic" - the LOBPCG method introduced by Andrew
      Knyazev, see [Knyazev2001]. A less robust method, may fail when
      Cholesky is applied to singular input.
      method="ortho" - the LOBPCG method with orthogonal basis
      selection [StathopoulosEtal2002]. A robust method.
   Supported inputs are dense, sparse, and batches of dense matrices.
   Note:
     In general, the basic method spends least time per iteration.
     However, the robust methods converge much faster and are more


stable. So, the usage of the basic method is generally not
     recommended but there exist cases where the usage of the basic
     method may be preferred.
   Warning:
     The backward method does not support sparse and complex inputs.
     It works only when B is not provided (i.e. B == None). We are
     actively working on extensions, and the details of the algorithms
     are going to be published promptly.
   Warning:
     While it is assumed that A is symmetric, A.grad is not. To
     make sure that A.grad is symmetric, so that A - t * A.grad is
     symmetric in first-order optimization routines, prior to running
     lobpcg we do the following symmetrization map: A -> (A +
     A.t()) / 2. The map is performed only when the A requires
     gradients.
   Parameters:
      * A (Tensor) -- the input tensor of size (, m, m)
      * B (Tensor, optional) -- the input tensor of size (,
        m, m). When not specified, B is interpreted as identity
        matrix.


matrix.
      * X (tensor, optional) -- the input tensor of size (,
        m, n) where k <= n <= m. When specified, it is used as
        initial approximation of eigenvectors. X must be a dense
        tensor.
      * iK (tensor, optional) -- the input tensor of size
        (, m, m). When specified, it will be used as preconditioner.
      * k (integer, optional) -- the number of requested
        eigenpairs. Default is the number of X columns (when
        specified) or 1.
      * n (integer, optional) -- if X is not specified then
        n specifies the size of the generated random approximation
        of eigenvectors. Default value for n is k. If X is
        specified, the value of n (when specified) must be the
        number of X columns.
      * tol (float, optional) -- residual tolerance for
        stopping criterion. Default is feps ** 0.5 where feps is
        smallest non-zero floating-point number of the given input


tensor A data type.
      * largest (bool, optional) -- when True, solve the
        eigenproblem for the largest eigenvalues. Otherwise, solve the
        eigenproblem for smallest eigenvalues. Default is True.
      * method (str, optional) -- select LOBPCG method. See
        the description of the function above. Default is "ortho".
      * niter (int, optional) -- maximum number of
        iterations. When reached, the iteration process is hard-
        stopped and the current approximation of eigenpairs is
        returned. For infinite iteration but until convergence
        criteria is met, use -1.
      * tracker (callable, optional) --
        a function for tracing the iteration process. When specified,
        it is called at each iteration step with LOBPCG instance as an
        argument. The LOBPCG instance holds the full state of the
        iteration process in the following attributes:


iparams, fparams, bparams - dictionaries of integer,
           float, and boolean valued input parameters, respectively
           ivars, fvars, bvars, tvars - dictionaries of
           integer, float, boolean, and Tensor valued iteration
           variables, respectively.
           A, B, iK - input Tensor arguments.
           E, X, S, R - iteration Tensor variables.
        For instance:
           ivars["istep"] - the current iteration step X - the
           current approximation of eigenvectors E - the current
           approximation of eigenvalues R - the current residual
           ivars["converged_count"] - the current number of
           converged eigenpairs tvars["rerr"] - the current state of
           convergence criteria
        Note that when tracker stores Tensor objects from the LOBPCG
        instance, it must make copies of these.
        If tracker sets bvars["force_stop"] = True, the iteration


process will be hard-stopped.
      * ortho_iparams (dict, optional) -- various parameters
        to LOBPCG algorithm when using method="ortho".
      * ortho_fparams (dict, optional) -- various parameters
        to LOBPCG algorithm when using method="ortho".
      * ortho_bparams (dict, optional) -- various parameters
        to LOBPCG algorithm when using method="ortho".
   Returns:
      tensor of eigenvalues of size (, k)
      X (Tensor): tensor of eigenvectors of size (, m, k)
   Return type:
      E (Tensor)
   -[ References ]-
   [Knyazev2001] Andrew V. Knyazev. (2001) Toward the Optimal
   Preconditioned Eigensolver: Locally Optimal Block Preconditioned
   Conjugate Gradient Method. SIAM J. Sci. Comput., 23(2), 517-541.
   (25 pages) https://epubs.siam.org/doi/abs/10.1137/S1064827500366124
   [StathopoulosEtal2002] Andreas Stathopoulos and Kesheng Wu. (2002)
   A Block Orthogonalization Procedure with Constant Synchronization


Requirements. SIAM J. Sci. Comput., 23(6), 2165-2182. (18 pages)
   https://epubs.siam.org/doi/10.1137/S1064827500370883
   [DuerschEtal2018] Jed A. Duersch, Meiyue Shao, Chao Yang, Ming Gu.
   (2018) A Robust and Efficient Implementation of LOBPCG. SIAM J.
   Sci. Comput., 40(5), C655-C676. (22 pages)
   https://epubs.siam.org/doi/abs/10.1137/17M1129830


torch.Tensor.movedimTensor.movedim(source, destination) -> Tensor
   See "torch.movedim()"


torch.signal.windows.general_hammingtorch.signal.windows.general_hamming(M, , alpha=0.54, sym=True, dtype=None, layout=torch.strided, device=None, requires_grad=False)
   Computes the general Hamming window.
   The general Hamming window is defined as follows:
      w_n = \alpha - (1 - \alpha) \cos{ \left( \frac{2 \pi n}{M-1}
      \right)}
   The window is normalized to 1 (maximum value is 1). However, the 1
   doesn't appear if "M" is even and "sym" is True.
   Parameters:
      M (int) -- the length of the window. In other words, the
      number of points of the returned window.
   Keyword Arguments:
      * alpha (float, optional) -- the window coefficient.
        Default: 0.54.
      * sym (bool, optional) -- If False, returns a
        periodic window suitable for use in spectral analysis. If
        True, returns a symmetric window suitable for use in filter
        design. Default: True*.


design. Default: True.
      * dtype ("torch.dtype", optional) -- the desired data type
        of returned tensor. Default: if "None", uses a global default
        (see "torch.set_default_tensor_type()").
      * layout ("torch.layout", optional) -- the desired layout of
        returned Tensor. Default: "torch.strided".
      * device ("torch.device", optional) -- the desired device of
        returned tensor. Default: if "None", uses the current device
        for the default tensor type (see
        "torch.set_default_tensor_type()"). "device" will be the CPU
        for CPU tensor types and the current CUDA device for CUDA
        tensor types.
      * requires_grad (bool, optional) -- If autograd should
        record operations on the returned tensor. Default: "False".
   Return type:
      Tensor
   Examples:
      >>> # Generates a symmetric Hamming window with the general Hamming window.
      >>> torch.signal.windows.general_hamming(10, sym=True)


tensor([0.0800, 0.1876, 0.4601, 0.7700, 0.9723, 0.9723, 0.7700, 0.4601, 0.1876, 0.0800])
      >>> # Generates a periodic Hann window with the general Hamming window.
      >>> torch.signal.windows.general_hamming(10, alpha=0.5, sym=False)
      tensor([0.0000, 0.0955, 0.3455, 0.6545, 0.9045, 1.0000, 0.9045, 0.6545, 0.3455, 0.0955])


torch.Tensor.arctanhTensor.arctanh() -> Tensor
   See "torch.arctanh()"


torch.Tensor.less_equal_Tensor.less_equal_(other) -> Tensor
   In-place version of "less_equal()".


torch.Tensor.lu_solveTensor.lu_solve(LU_data, LU_pivots) -> Tensor
   See "torch.lu_solve()"


torch.addcdivtorch.addcdiv(input, tensor1, tensor2, , value=1, out=None) -> Tensor
   Performs the element-wise division of "tensor1" by "tensor2",
   multiplies the result by the scalar "value" and adds it to "input".
   Warning:
     Integer division with addcdiv is no longer supported, and in a
     future release addcdiv will perform a true division of tensor1
     and tensor2. The historic addcdiv behavior can be implemented as
     (input + value * torch.trunc(tensor1 / tensor2)).to(input.dtype)
     for integer inputs and as (input + value * tensor1 / tensor2) for
     float inputs. The future addcdiv behavior is just the latter
     implementation: (input + value * tensor1 / tensor2), for all
     dtypes.
      \text{out}_i = \text{input}_i + \text{value} \times
      \frac{\text{tensor1}_i}{\text{tensor2}_i}
   The shapes of "input", "tensor1", and "tensor2" must be
   broadcastable.
   For inputs of type FloatTensor or DoubleTensor*, "value" must be


a real number, otherwise an integer.
   Parameters:
      * input (Tensor) -- the tensor to be added
      * tensor1 (Tensor) -- the numerator tensor
      * tensor2 (Tensor) -- the denominator tensor
   Keyword Arguments:
      * value (Number, optional) -- multiplier for
        \text{tensor1} / \text{tensor2}
      * out (Tensor, optional) -- the output tensor.
   Example:
      >>> t = torch.randn(1, 3)
      >>> t1 = torch.randn(3, 1)
      >>> t2 = torch.randn(1, 3)
      >>> torch.addcdiv(t, t1, t2, value=0.1)
      tensor([[-0.2312, -3.6496,  0.1312],
              [-1.0428,  3.4292, -0.1030],
              [-0.5369, -0.9829,  0.0430]])


VerificationOptionsclass torch.onnx.verification.VerificationOptions(flatten=True, ignore_none=True, check_shape=True, check_dtype=True, backend=OnnxBackend.ONNX_RUNTIME_CPU, rtol=0.001, atol=1e-07, remained_onnx_input_idx=None, acceptable_error_percentage=None)
   Options for ONNX export verification.
   Variables:
      * flatten (bool) -- If True, unpack nested list/tuple/dict
        inputs into a flattened list of Tensors for ONNX. Set this to
        False if nested structures are to be preserved for ONNX, which
        is usually the case with exporting ScriptModules. Default
        True.
      * ignore_none (bool) -- Whether to ignore None type in
        torch output, which is usually the case with tracing. Set this
        to False, if torch output should keep None type, which is
        usually the case with exporting ScriptModules. Default to
        True.
      * check_shape (bool) -- Whether to check the shapes


between PyTorch and ONNX Runtime outputs are exactly the same.
        Set this to False to allow output shape broadcasting. Default
        to True.
      * check_dtype (bool) -- Whether to check the dtypes
        between PyTorch and ONNX Runtime outputs are consistent.
        Default to True.
      * backend (torch.onnx.verification.OnnxBackend) -- ONNX
        backend for verification. Default to
        OnnxBackend.ONNX_RUNTIME_CPU.
      * rtol (float) -- relative tolerance in comparison between
        ONNX and PyTorch outputs.
      * atol (float) -- absolute tolerance in comparison between
        ONNX and PyTorch outputs.
      * remained_onnx_input_idx
        (Optional[Sequence[int]]) -- If provided, only
        the specified inputs will be passed to the ONNX model. Supply
        a list when there are unused inputs in the model. Since unused
        inputs will be removed in the exported ONNX model, supplying


all inputs will cause an error on unexpected inputs. This
        parameter tells the verifier which inputs to pass into the
        ONNX model.
      * acceptable_error_percentage (Optional[float]) --
        acceptable percentage of element mismatches in comparison. It
        should be a float of value between 0.0 and 1.0.


torch.foreach_floor_torch._foreach_floor(self: List[Tensor]) -> None
   Apply "torch.floor()" to each Tensor of the input list.


torch.Tensor.true_divideTensor.true_divide(value) -> Tensor
   See "torch.true_divide()"


torch.Tensor.isinfTensor.isinf() -> Tensor
   See "torch.isinf()"


torch.sqrttorch.sqrt(input, , out=None) -> Tensor
   Returns a new tensor with the square-root of the elements of
   "input".
      \text{out}{i} = \sqrt{\text{input}}
   Parameters:
      input (Tensor) -- the input tensor.
   Keyword Arguments:
      out (Tensor, optional*) -- the output tensor.
   Example:
      >>> a = torch.randn(4)
      >>> a
      tensor([-2.0755,  1.0226,  0.0831,  0.4806])
      >>> torch.sqrt(a)
      tensor([    nan,  1.0112,  0.2883,  0.6933])


torch.func.stack_module_statetorch.func.stack_module_state(models) -> params, buffers
   Prepares a list of torch.nn.Modules for ensembling with "vmap()".
   Given a list of "M" "nn.Modules" of the same class, returns two
   dictionaries that stack all of their parameters and buffers
   together, indexed by name. The stacked parameters are optimizable
   (i.e. they are new leaf nodes in the autograd history that are
   unrelated to the original parameters and can be passed directly to
   an optimizer).
   Here's an example of how to ensemble over a very simple model:
      num_models = 5
      batch_size = 64
      in_features, out_features = 3, 3
      models = [torch.nn.Linear(in_features, out_features) for i in range(num_models)]
      data = torch.randn(batch_size, 3)
      def wrapper(params, buffers, data):
          return torch.func.functional_call(model[0], (params, buffers), data)
      params, buffers = stack_module_state(models)


params, buffers = stack_module_state(models)
      output = vmap(wrapper, (0, 0, None))(params, buffers, data)
      assert output.shape == (num_models, batch_size, out_features)
   When there's submodules, this follows state dict naming conventions
      import torch.nn as nn
      class Foo(nn.Module):
          def init(self, in_features, out_features):
              super().init()
              hidden = 4
              self.l1 = nn.Linear(in_features, hidden)
              self.l2 = nn.Linear(hidden, out_features)
          def forward(self, x):
              return self.l2(self.l1(x))
      num_models = 5
      in_features, out_features = 3, 3
      models = [Foo(in_features, out_features) for i in range(num_models)]
      params, buffers = stack_module_state(models)
      print(list(params.keys()))  # "l1.weight", "l1.bias", "l2.weight", "l2.bias"
   Warning:
     All of the modules being stacked together must be the same


(except for the values of their parameters/buffers). For example,
     they should be in the same mode (training vs eval).
   Return type:
      Tuple[Dict[str, Any], Dict[str, Any]]


swap_moduleclass torch.quantization.swap_module(mod, mapping, custom_module_class_mapping)
   Swaps the module if it has a quantized counterpart and it has an
   observer attached.
   Parameters:
      * mod -- input module
      * mapping -- a dictionary that maps from nn module to nnq
        module
   Returns:
      The corresponding quantized module of mod


ConvReLU2dclass torch.ao.nn.intrinsic.quantized.ConvReLU2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)
   A ConvReLU2d module is a fused module of Conv2d and ReLU
   We adopt the same interface as "torch.ao.nn.quantized.Conv2d".
   Variables:
      torch.ao.nn.quantized.Conv2d (Same as) --


torch.narrowtorch.narrow(input, dim, start, length) -> Tensor
   Returns a new tensor that is a narrowed version of "input" tensor.
   The dimension "dim" is input from "start" to "start + length". The
   returned tensor and "input" tensor share the same underlying
   storage.
   Parameters:
      * input (Tensor) -- the tensor to narrow
      * dim (int) -- the dimension along which to narrow
      * start (int or Tensor) -- index of the element to
        start the narrowed dimension from. Can be negative, which
        means indexing from the end of dim. If Tensor, it must be
        an 0-dim integral Tensor (bools not allowed)
      * length (int) -- length of the narrowed dimension, must
        be weakly positive
   Example:
      >>> x = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
      >>> torch.narrow(x, 0, 0, 2)
      tensor([[ 1,  2,  3],
              [ 4,  5,  6]])
      >>> torch.narrow(x, 1, 1, 2)
      tensor([[ 2,  3],


tensor([[ 2,  3],
              [ 5,  6],
              [ 8,  9]])
      >>> torch.narrow(x, -1, torch.tensor(-1), 1)
      tensor([[3],
              [6],
              [9]])


float16_static_qconfigtorch.quantization.qconfig.float16_static_qconfig
   alias of QConfig(activation=functools.partial(,
   dtype=torch.float16){}, weight=functools.partial(,
   dtype=torch.float16){})


torch.nn.functional.dropout2dtorch.nn.functional.dropout2d(input, p=0.5, training=True, inplace=False)
   Randomly zero out entire channels (a channel is a 2D feature map,
   e.g., the j-th channel of the i-th sample in the batched input is a
   2D tensor \text{input}[i, j]) of the input tensor). Each channel
   will be zeroed out independently on every forward call with
   probability "p" using samples from a Bernoulli distribution.
   See "Dropout2d" for details.
   Parameters:
      * p (float) -- probability of a channel to be zeroed.
        Default: 0.5
      * training (bool) -- apply dropout if is "True". Default:
        "True"
      * inplace (bool) -- If set to "True", will do this
        operation in-place. Default: "False"
   Return type:
      Tensor


torch.Tensor.cummaxTensor.cummax(dim)
   See "torch.cummax()"


torch.nn.functional.upsample_bilineartorch.nn.functional.upsample_bilinear(input, size=None, scale_factor=None)
   Upsamples the input, using bilinear upsampling.
   Warning:
     This function is deprecated in favor of
     "torch.nn.functional.interpolate()". This is equivalent with
     "nn.functional.interpolate(..., mode='bilinear',
     align_corners=True)".
   Expected inputs are spatial (4 dimensional). Use
   upsample_trilinear fo volumetric (5 dimensional) inputs.
   Parameters:
      * input (Tensor) -- input
      * size (int or Tuple[int, int]) -- output
        spatial size.
      * scale_factor (int or Tuple[int, int]) --
        multiplier for spatial size
   Note:
     This operation may produce nondeterministic gradients when given
     tensors on a CUDA device. See Reproducibility for more
     information.


torch.reciprocaltorch.reciprocal(input, , out=None) -> Tensor
   Returns a new tensor with the reciprocal of the elements of "input"
      \text{out}{i} = \frac{1}{\text{input}}
   Note:
     Unlike NumPy's reciprocal, torch.reciprocal supports integral
     inputs. Integral inputs to reciprocal are automatically promoted
     to the default scalar type.
   Parameters:
      input (Tensor) -- the input tensor.
   Keyword Arguments:
      out (Tensor, optional*) -- the output tensor.
   Example:
      >>> a = torch.randn(4)
      >>> a
      tensor([-0.4595, -2.1219, -1.4314,  0.7298])
      >>> torch.reciprocal(a)
      tensor([-2.1763, -0.4713, -0.6986,  1.3702])


torch.cuda.reset_max_memory_cachedtorch.cuda.reset_max_memory_cached(device=None)
   Resets the starting point in tracking maximum GPU memory managed by
   the caching allocator for a given device.
   See "max_memory_cached()" for details.
   Parameters:
      device (torch.device or int, optional) -- selected
      device. Returns statistic for the current device, given by
      "current_device()", if "device" is "None" (default).
   Warning:
     This function now calls "reset_peak_memory_stats()", which resets
     /all/ peak memory stats.
   Note:
     See Memory management for more details about GPU memory
     management.


torch.Tensor.lgammaTensor.lgamma() -> Tensor
   See "torch.lgamma()"


SparseAdamclass torch.optim.SparseAdam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, maximize=False)
   Implements lazy version of Adam algorithm suitable for sparse
   tensors.
   In this variant, only moments that show up in the gradient get
   updated, and only those portions of the gradient get applied to the
   parameters.
   Parameters:
      * params (iterable) -- iterable of parameters to optimize
        or dicts defining parameter groups
      * lr (float, optional) -- learning rate (default:
        1e-3)
      * betas (Tuple[float, float], optional) --
        coefficients used for computing running averages of gradient
        and its square (default: (0.9, 0.999))
      * eps (float, optional) -- term added to the
        denominator to improve numerical stability (default: 1e-8)
      * maximize (bool, optional) -- maximize the params
        based on the objective, instead of minimizing (default: False)


add_param_group(param_group)
      Add a param group to the "Optimizer" s param_groups.
      This can be useful when fine tuning a pre-trained network as
      frozen layers can be made trainable and added to the "Optimizer"
      as training progresses.
      Parameters:
         param_group (dict) -- Specifies what Tensors should be
         optimized along with group specific optimization options.
   load_state_dict(state_dict)
      Loads the optimizer state.
      Parameters:
         state_dict (dict) -- optimizer state. Should be an
         object returned from a call to "state_dict()".
   register_step_post_hook(hook)
      Register an optimizer step post hook which will be called after
      optimizer step. It should have the following signature:
         hook(optimizer, args, kwargs) -> None
      The "optimizer" argument is the optimizer instance being used.
      Parameters:
         hook (Callable) -- The user defined hook to be
         registered.
      Returns:


registered.
      Returns:
         a handle that can be used to remove the added hook by calling
         "handle.remove()"
      Return type:
         "torch.utils.hooks.RemoveableHandle"
   register_step_pre_hook(hook)
      Register an optimizer step pre hook which will be called before
      optimizer step. It should have the following signature:
         hook(optimizer, args, kwargs) -> None or modified args and kwargs
      The "optimizer" argument is the optimizer instance being used.
      If args and kwargs are modified by the pre-hook, then the
      transformed values are returned as a tuple containing the
      new_args and new_kwargs.
      Parameters:
         hook (Callable) -- The user defined hook to be
         registered.
      Returns:
         a handle that can be used to remove the added hook by calling
         "handle.remove()"
      Return type:
         "torch.utils.hooks.RemoveableHandle"
   state_dict()
      Returns the state of the optimizer as a "dict".


It contains two entries:
      * state - a dict holding current optimization state. Its content
           differs between optimizer classes.
      * param_groups - a list containing all parameter groups where
        each
           parameter group is a dict
   step(closure=None)
      Performs a single optimization step.
      Parameters:
         closure (Callable, optional) -- A closure that
         reevaluates the model and returns the loss.
   zero_grad(set_to_none=False)
      Sets the gradients of all optimized "torch.Tensor" s to zero.
      Parameters:
         set_to_none (bool) -- instead of setting to zero, set
         the grads to None. This will in general have lower memory
         footprint, and can modestly improve performance. However, it
         changes certain behaviors. For example: 1. When the user
         tries to access a gradient and perform manual ops on it, a
         None attribute or a Tensor full of 0s will behave


differently. 2. If the user requests
         "zero_grad(set_to_none=True)" followed by a backward pass,
         ".grad"s are guaranteed to be None for params that did not
         receive a gradient. 3. "torch.optim" optimizers have a
         different behavior if the gradient is 0 or None (in one case
         it does the step with a gradient of 0 and in the other it
         skips the step altogether).


torch.Tensor.addbmmTensor.addbmm(batch1, batch2, *, beta=1, alpha=1) -> Tensor
   See "torch.addbmm()"


torch.is_conjtorch.is_conj(input)
   Returns True if the "input" is a conjugated tensor, i.e. its
   conjugate bit is set to True.
   Parameters:
      input (Tensor) -- the input tensor.


torch.logtorch.log(input, , out=None) -> Tensor
   Returns a new tensor with the natural logarithm of the elements of
   "input".
      y_{i} = \log_{e} (x_{i})
   Parameters:
      input (Tensor) -- the input tensor.
   Keyword Arguments:
      out (Tensor, optional*) -- the output tensor.
   Example:
      >>> a = torch.rand(5) * 5
      >>> a
      tensor([4.7767, 4.3234, 1.2156, 0.2411, 4.5739])
      >>> torch.log(a)
      tensor([ 1.5637,  1.4640,  0.1952, -1.4226,  1.5204])


torch.nn.functional.alpha_dropouttorch.nn.functional.alpha_dropout(input, p=0.5, training=False, inplace=False)
   Applies alpha dropout to the input.
   See "AlphaDropout" for details.
   Return type:
      Tensor


torch.count_nonzerotorch.count_nonzero(input, dim=None) -> Tensor
   Counts the number of non-zero values in the tensor "input" along
   the given "dim". If no dim is specified then all non-zeros in the
   tensor are counted.
   Parameters:
      * input (Tensor) -- the input tensor.
      * dim (int or tuple of ints, optional) -- Dim or
        tuple of dims along which to count non-zeros.
   Example:
      >>> x = torch.zeros(3,3)
      >>> x[torch.randn(3,3) > 0.5] = 1
      >>> x
      tensor([[0., 1., 1.],
              [0., 0., 0.],
              [0., 0., 1.]])
      >>> torch.count_nonzero(x)
      tensor(3)
      >>> torch.count_nonzero(x, dim=0)
      tensor([0, 1, 2])


NAdamclass torch.optim.NAdam(params, lr=0.002, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, momentum_decay=0.004, *, foreach=None, differentiable=False)
   Implements NAdam algorithm.
      \begin{aligned}      &\rule{110mm}{0.4pt}
      \      &\textbf{input}      : \gamma_t \text{ (lr)}, \:
      \beta_1,\beta_2 \text{ (betas)},          \: \theta_0 \text{
      (params)}, \: f(\theta) \text{ (objective)}                   \
      &\hspace{13mm} \: \lambda \text{ (weight decay)}, \:\psi \text{
      (momentum decay)}    \      &\textbf{initialize} :  m_0
      \leftarrow 0 \text{ ( first moment)},          v_0 \leftarrow 0
      \text{ ( second moment)}
      \[-1.ex]      &\rule{110mm}{0.4pt}
      \      &\textbf{for} \: t=1 \: \textbf{to} \: \ldots \:
      \textbf{do}                         \      &\hspace{5mm}g_t
      \leftarrow   \nabla_{\theta} f_t (\theta_{t-1})           \
      &\hspace{5mm}if \: \lambda \neq 0


&\hspace{5mm}if \: \lambda \neq 0
      \      &\hspace{10mm} g_t \leftarrow g_t + \lambda \theta_{t-1}
      \      &\hspace{5mm} \mu_t \leftarrow \beta_1 \big(1 -
      \frac{1}{2}  0.96^{t \psi} \big)     \      &\hspace{5mm}
      \mu_{t+1} \leftarrow \beta_1 \big(1 - \frac{1}{2}
      0.96^{(t+1)\psi}\big)\      &\hspace{5mm}m_t
      \leftarrow   \beta_1 m_{t-1} + (1 - \beta_1) g_t          \
      &\hspace{5mm}v_t           \leftarrow   \beta_2 v_{t-1} +
      (1-\beta_2) g^2_t          \      &\hspace{5mm}\widehat{m_t}
      \leftarrow \mu_{t+1} m_t/(1-\prod_{i=1}^{t+1}\mu_i)\[-1.ex]
      & \hspace{11mm} + (1-\mu_t) g_t /(1-\prod_{i=1}^{t} \mu_{i})
      \      &\hspace{5mm}\widehat{v_t} \leftarrow
      v_t/\big(1-\beta_2^t \big)                   \
      &\hspace{5mm}\theta_t \leftarrow \theta_{t-1} - \gamma
      \widehat{m_t}/          \big(\sqrt{\widehat{v_t}} + \epsilon
      \big)                                       \
      &\rule{110mm}{0.4pt}


&\rule{110mm}{0.4pt}
      \[-1.ex]      &\bf{return} \:  \theta_t
      \[-1.ex]      &\rule{110mm}{0.4pt}
      \[-1.ex] \end{aligned}
   For further details regarding the algorithm we refer to
   Incorporating Nesterov Momentum into Adam.
   Parameters:
      * params (iterable) -- iterable of parameters to optimize
        or dicts defining parameter groups
      * lr (float, optional) -- learning rate (default:
        2e-3)
      * betas (Tuple[float, float], optional) --
        coefficients used for computing running averages of gradient
        and its square (default: (0.9, 0.999))
      * eps (float, optional) -- term added to the
        denominator to improve numerical stability (default: 1e-8)
      * weight_decay (float, optional) -- weight decay (L2
        penalty) (default: 0)
      * momentum_decay (float, optional) -- momentum
        momentum_decay (default: 4e-3)


momentum_decay (default: 4e-3)
      * foreach (bool, optional) -- whether foreach
        implementation of optimizer is used. If unspecified by the
        user (so foreach is None), we will try to use foreach over the
        for-loop implementation on CUDA, since it is usually
        significantly more performant. (default: None)
      * differentiable (bool, optional) -- whether autograd
        should occur through the optimizer step in training.
        Otherwise, the step() function runs in a torch.no_grad()
        context. Setting to True can impair performance, so leave it
        False if you don't intend to run autograd through this
        instance (default: False)
   add_param_group(param_group)
      Add a param group to the "Optimizer" s param_groups.
      This can be useful when fine tuning a pre-trained network as
      frozen layers can be made trainable and added to the "Optimizer"
      as training progresses.
      Parameters:


as training progresses.
      Parameters:
         param_group (dict) -- Specifies what Tensors should be
         optimized along with group specific optimization options.
   load_state_dict(state_dict)
      Loads the optimizer state.
      Parameters:
         state_dict (dict) -- optimizer state. Should be an
         object returned from a call to "state_dict()".
   register_step_post_hook(hook)
      Register an optimizer step post hook which will be called after
      optimizer step. It should have the following signature:
         hook(optimizer, args, kwargs) -> None
      The "optimizer" argument is the optimizer instance being used.
      Parameters:
         hook (Callable) -- The user defined hook to be
         registered.
      Returns:
         a handle that can be used to remove the added hook by calling
         "handle.remove()"
      Return type:
         "torch.utils.hooks.RemoveableHandle"
   register_step_pre_hook(hook)


register_step_pre_hook(hook)
      Register an optimizer step pre hook which will be called before
      optimizer step. It should have the following signature:
         hook(optimizer, args, kwargs) -> None or modified args and kwargs
      The "optimizer" argument is the optimizer instance being used.
      If args and kwargs are modified by the pre-hook, then the
      transformed values are returned as a tuple containing the
      new_args and new_kwargs.
      Parameters:
         hook (Callable) -- The user defined hook to be
         registered.
      Returns:
         a handle that can be used to remove the added hook by calling
         "handle.remove()"
      Return type:
         "torch.utils.hooks.RemoveableHandle"
   state_dict()
      Returns the state of the optimizer as a "dict".
      It contains two entries:
      * state - a dict holding current optimization state. Its content
           differs between optimizer classes.


differs between optimizer classes.
      * param_groups - a list containing all parameter groups where
        each
           parameter group is a dict
   zero_grad(set_to_none=False)
      Sets the gradients of all optimized "torch.Tensor" s to zero.
      Parameters:
         set_to_none (bool) -- instead of setting to zero, set
         the grads to None. This will in general have lower memory
         footprint, and can modestly improve performance. However, it
         changes certain behaviors. For example: 1. When the user
         tries to access a gradient and perform manual ops on it, a
         None attribute or a Tensor full of 0s will behave
         differently. 2. If the user requests
         "zero_grad(set_to_none=True)" followed by a backward pass,
         ".grad"s are guaranteed to be None for params that did not
         receive a gradient. 3. "torch.optim" optimizers have a
         different behavior if the gradient is 0 or None (in one case


it does the step with a gradient of 0 and in the other it
         skips the step altogether).


torch.Tensor.bitwise_orTensor.bitwise_or() -> Tensor
   See "torch.bitwise_or()"


torch.Tensor.floor_divideTensor.floor_divide(value) -> Tensor
   See "torch.floor_divide()"


torch.Tensor.allTensor.all(dim=None, keepdim=False) -> Tensor
   See "torch.all()"


torch.rad2degtorch.rad2deg(input, , out=None) -> Tensor
   Returns a new tensor with each of the elements of "input" converted
   from angles in radians to degrees.
   Parameters:
      input (Tensor) -- the input tensor.
   Keyword Arguments:
      out (Tensor, optional*) -- the output tensor.
   Example:
      >>> a = torch.tensor([[3.142, -3.142], [6.283, -6.283], [1.570, -1.570]])
      >>> torch.rad2deg(a)
      tensor([[ 180.0233, -180.0233],
              [ 359.9894, -359.9894],
              [  89.9544,  -89.9544]])


LSTMclass torch.ao.nn.quantized.dynamic.LSTM(args, kwargs)
   A dynamic quantized LSTM module with floating point tensor as
   inputs and outputs. We adopt the same interface as torch.nn.LSTM*,
   please see https://pytorch.org/docs/stable/nn.html#torch.nn.LSTM
   for documentation.
   Examples:
      >>> rnn = nn.LSTM(10, 20, 2)
      >>> input = torch.randn(5, 3, 10)
      >>> h0 = torch.randn(2, 3, 20)
      >>> c0 = torch.randn(2, 3, 20)
      >>> output, (hn, cn) = rnn(input, (h0, c0))


torch.can_casttorch.can_cast(from, to) -> bool
   Determines if a type conversion is allowed under PyTorch casting
   rules described in the type promotion documentation.
   Parameters:
      * from (dtype) -- The original "torch.dtype".
      * to (dtype) -- The target "torch.dtype".
   Example:
      >>> torch.can_cast(torch.double, torch.float)
      True
      >>> torch.can_cast(torch.float, torch.int)
      False


torch.autograd.function.FunctionCtx.set_materialize_gradsFunctionCtx.set_materialize_grads(value)
   Sets whether to materialize grad tensors. Default is "True".
   This should be called only from inside the "forward()"
   method
   If "True", undefined grad tensors will be expanded to tensors full
   of zeros prior to calling the "backward()" and "jvp()" methods.
   Example::
      >>> class SimpleFunc(Function):
      >>>     @staticmethod
      >>>     def forward(ctx, x):
      >>>         return x.clone(), x.clone()
      >>>
      >>>     @staticmethod
      >>>     @once_differentiable
      >>>     def backward(ctx, g1, g2):
      >>>         return g1 + g2  # No check for None necessary
      >>>
      >>> # We modify SimpleFunc to handle non-materialized grad outputs
      >>> class Func(Function):
      >>>     @staticmethod
      >>>     def forward(ctx, x):
      >>>         ctx.set_materialize_grads(False)


    ctx.set_materialize_grads(False)
  >>>         ctx.save_for_backward(x)
  >>>         return x.clone(), x.clone()
  >>>
  >>>     @staticmethod
  >>>     @once_differentiable
  >>>     def backward(ctx, g1, g2):
  >>>         x, = ctx.saved_tensors
  >>>         grad_input = torch.zeros_like(x)
  >>>         if g1 is not None:  # We must check for None now
  >>>             grad_input += g1
  >>>         if g2 is not None:
  >>>             grad_input += g2
  >>>         return grad_input
  >>>
  >>> a = torch.tensor(1., requires_grad=True)
  >>> b, _ = Func.apply(a)  # induces g2 to be undefined


torch.Tensor.unique_consecutiveTensor.unique_consecutive(return_inverse=False, return_counts=False, dim=None)
   Eliminates all but the first element from every consecutive group
   of equivalent elements.
   See "torch.unique_consecutive()"


torch.foreach_neg_torch._foreach_neg(self: List[Tensor]) -> None
   Apply "torch.neg()" to each Tensor of the input list.


torch.bmmtorch.bmm(input, mat2, , out=None) -> Tensor
   Performs a batch matrix-matrix product of matrices stored in
   "input" and "mat2".
   "input" and "mat2" must be 3-D tensors each containing the same
   number of matrices.
   If "input" is a (b \times n \times m) tensor, "mat2" is a (b \times
   m \times p) tensor, "out" will be a (b \times n \times p) tensor.
      \text{out}_i = \text{input}_i \mathbin{@} \text{mat2}_i
   This operator supports TensorFloat32.
   On certain ROCm devices, when using float16 inputs this module will
   use different precision for backward.
   Note:
     This function does not broadcast. For broadcasting matrix
     products, see "torch.matmul()".
   Parameters:
      * input (Tensor) -- the first batch of matrices to be
        multiplied
      * mat2 (Tensor) -- the second batch of matrices to be
        multiplied
   Keyword Arguments:
      out (Tensor, optional*) -- the output tensor.
   Example:


Example:
      >>> input = torch.randn(10, 3, 4)
      >>> mat2 = torch.randn(10, 4, 5)
      >>> res = torch.bmm(input, mat2)
      >>> res.size()
      torch.Size([10, 3, 5])


torch.cuda.memory_statstorch.cuda.memory_stats(device=None)
   Returns a dictionary of CUDA memory allocator statistics for a
   given device.
   The return value of this function is a dictionary of statistics,
   each of which is a non-negative integer.
   Core statistics:
   * ""allocated.{all,large_pool,small_pool}.{current,peak,allocated,
     freed}"": number of allocation requests received by the memory
     allocator.
   * ""allocated_bytes.{all,large_pool,small_pool}.{current,peak,allo
     cated,freed}"": amount of allocated memory.
   * ""segment.{all,large_pool,small_pool}.{current,peak,allocated,fr
     eed}"": number of reserved segments from "cudaMalloc()".
   * ""reserved_bytes.{all,large_pool,small_pool}.{current,peak,alloc
     ated,freed}"": amount of reserved memory.
   * ""active.{all,large_pool,small_pool}.{current,peak,allocated,fre
     ed}"": number of active memory blocks.
   * ""active_bytes.{all,large_pool,small_pool}.{current,peak,allocat


ed,freed}"": amount of active memory.
   * ""inactive_split.{all,large_pool,small_pool}.{current,peak,alloc
     ated,freed}"": number of inactive, non-releasable memory blocks.
   * ""inactive_split_bytes.{all,large_pool,small_pool}.{current,peak
     ,allocated,freed}"": amount of inactive, non-releasable memory.
   For these core statistics, values are broken down as follows.
   Pool type:
   * "all": combined statistics across all memory pools.
   * "large_pool": statistics for the large allocation pool (as of
     October 2019, for size >= 1MB allocations).
   * "small_pool": statistics for the small allocation pool (as of
     October 2019, for size < 1MB allocations).
   Metric type:
   * "current": current value of this metric.
   * "peak": maximum value of this metric.
   * "allocated": historical total increase in this metric.
   * "freed": historical total decrease in this metric.
   In addition to the core statistics, we also provide some simple
   event counters:


event counters:
   * ""num_alloc_retries"": number of failed "cudaMalloc" calls that
     result in a cache flush and retry.
   * ""num_ooms"": number of out-of-memory errors thrown.
   The caching allocator can be configured via ENV to not split blocks
   larger than a defined size (see Memory Management section of the
   Cuda Semantics documentation). This helps avoid memory
   fragmentation but may have a performance penalty. Additional
   outputs to assist with tuning and evaluating impact:
   * ""max_split_size"": blocks above this size will not be split.
   * ""oversize_allocations.{current,peak,allocated,freed}"": number
     of over-size allocation requests received by the memory
     allocator.
   * ""oversize_segments.{current,peak,allocated,freed}"": number of
     over-size reserved segments from "cudaMalloc()".
   Parameters:
      device (torch.device or int, optional) -- selected
      device. Returns statistics for the current device, given by


"current_device()", if "device" is "None" (default).
   Return type:
      Dict[str, Any]
   Note:
     See Memory management for more details about GPU memory
     management.
   Note:
     With backend:cudaMallocAsync, some stats are not meaningful, and
     are always reported as zero.


BatchNorm2dclass torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None)
   Applies Batch Normalization over a 4D input (a mini-batch of 2D
   inputs with additional channel dimension) as described in the paper
   Batch Normalization: Accelerating Deep Network Training by Reducing
   Internal Covariate Shift .
      y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}}
      * \gamma + \beta
   The mean and standard-deviation are calculated per-dimension over
   the mini-batches and \gamma and \beta are learnable parameter
   vectors of size C (where C is the input size). By default, the
   elements of \gamma are set to 1 and the elements of \beta are set
   to 0. The standard-deviation is calculated via the biased
   estimator, equivalent to torch.var(input, unbiased=False).
   Also by default, during training this layer keeps running estimates
   of its computed mean and variance, which are then used for


normalization during evaluation. The running estimates are kept
   with a default "momentum" of 0.1.
   If "track_running_stats" is set to "False", this layer then does
   not keep running estimates, and batch statistics are instead used
   during evaluation time as well.
   Note:
     This "momentum" argument is different from one used in optimizer
     classes and the conventional notion of momentum. Mathematically,
     the update rule for running statistics here is \hat{x}_\text{new}
     = (1 - \text{momentum}) \times \hat{x} + \text{momentum} \times
     x_t, where \hat{x} is the estimated statistic and x_t is the new
     observed value.
   Because the Batch Normalization is done over the C dimension,
   computing statistics on (N, H, W) slices, it's common terminology
   to call this Spatial Batch Normalization.
   Parameters:
      * num_features (int) -- C from an expected input of size
        (N, C, H, W)
      * eps (float) -- a value added to the denominator for


numerical stability. Default: 1e-5
      * momentum (float) -- the value used for the running_mean
        and running_var computation. Can be set to "None" for
        cumulative moving average (i.e. simple average). Default: 0.1
      * affine (bool) -- a boolean value that when set to
        "True", this module has learnable affine parameters. Default:
        "True"
      * track_running_stats (bool) -- a boolean value that when
        set to "True", this module tracks the running mean and
        variance, and when set to "False", this module does not track
        such statistics, and initializes statistics buffers
        "running_mean" and "running_var" as "None". When these buffers
        are "None", this module always uses batch statistics. in both
        training and eval modes. Default: "True"
   Shape:
      * Input: (N, C, H, W)
      * Output: (N, C, H, W) (same shape as input)
   Examples:
      >>> # With Learnable Parameters
      >>> m = nn.BatchNorm2d(100)


m = nn.BatchNorm2d(100)
      >>> # Without Learnable Parameters
      >>> m = nn.BatchNorm2d(100, affine=False)
      >>> input = torch.randn(20, 100, 35, 45)
      >>> output = m(input)


torch.triangular_solvetorch.triangular_solve(b, A, upper=True, transpose=False, unitriangular=False, , out=None)
   Solves a system of equations with a square upper or lower
   triangular invertible matrix A and multiple right-hand sides b.
   In symbols, it solves AX = b and assumes A is square upper-
   triangular (or lower-triangular if "upper"= False) and does not
   have zeros on the diagonal.
   torch.triangular_solve(b, A) can take in 2D inputs b, A or
   inputs that are batches of 2D matrices. If the inputs are batches,
   then returns batched outputs X
   If the diagonal of "A" contains zeros or elements that are very
   close to zero and "unitriangular"= False (default) or if the
   input matrix is badly conditioned, the result may contain NaN* s.
   Supports input of float, double, cfloat and cdouble data types.
   Warning:
     "torch.triangular_solve()" is deprecated in favor of
     "torch.linalg.solve_triangular()" and will be removed in a future


PyTorch release. "torch.linalg.solve_triangular()" has its
     arguments reversed and does not return a copy of one of the
     inputs."X = torch.triangular_solve(B, A).solution" should be
     replaced with
        X = torch.linalg.solve_triangular(A, B)
   Parameters:
      * b (Tensor) -- multiple right-hand sides of size (, m,
        k) where * is zero of more batch dimensions
      * A (Tensor) -- the input triangular coefficient matrix of
        size (, m, m) where * is zero or more batch dimensions
      * upper (bool, optional) -- whether A is upper or
        lower triangular. Default: "True".
      * transpose (bool, optional) -- solves op(A)X = b
        where op(A) = A^T if this flag is "True", and op(A) = A if
        it is "False". Default: "False".
      * unitriangular (bool, optional) -- whether A is unit
        triangular. If True, the diagonal elements of A are assumed to
        be 1 and not referenced from A. Default: "False".


Keyword Arguments:
      out ((Tensor, Tensor), optional) -- tuple of
      two tensors to write the output to. Ignored if None. Default:
      None.
   Returns:
      A namedtuple (solution, cloned_coefficient) where
      cloned_coefficient is a clone of A and solution is the
      solution X to AX = b (or whatever variant of the system of
      equations, depending on the keyword arguments.)
   Examples:
      >>> A = torch.randn(2, 2).triu()
      >>> A
      tensor([[ 1.1527, -1.0753],
              [ 0.0000,  0.7986]])
      >>> b = torch.randn(2, 3)
      >>> b
      tensor([[-0.0210,  2.3513, -1.5492],
              [ 1.5429,  0.7403, -1.0243]])
      >>> torch.triangular_solve(b, A)
      torch.return_types.triangular_solve(
      solution=tensor([[ 1.7841,  2.9046, -2.5405],
              [ 1.9320,  0.9270, -1.2826]]),
      cloned_coefficient=tensor([[ 1.1527, -1.0753],
              [ 0.0000,  0.7986]]))


torch.frombuffertorch.frombuffer(buffer, *, dtype, count=- 1, offset=0, requires_grad=False) -> Tensor
   Creates a 1-dimensional "Tensor" from an object that implements the
   Python buffer protocol.
   Skips the first "offset" bytes in the buffer, and interprets the
   rest of the raw bytes as a 1-dimensional tensor of type "dtype"
   with "count" elements.
   Note that either of the following must be true:
   1. "count" is a positive non-zero number, and the total number of
   bytes in the buffer is less than "offset" plus "count" times the
   size (in bytes) of "dtype".
   2. "count" is negative, and the length (number of bytes) of the
   buffer subtracted by the "offset" is a multiple of the size (in
   bytes) of "dtype".
   The returned tensor and buffer share the same memory. Modifications
   to the tensor will be reflected in the buffer and vice versa. The
   returned tensor is not resizable.
   Note:
     This function increments the reference count for the object that


owns the shared memory. Therefore, such memory will not be
     deallocated before the returned tensor goes out of scope.
   Warning:
     This function's behavior is undefined when passed an object
     implementing the buffer protocol whose data is not on the CPU.
     Doing so is likely to cause a segmentation fault.
   Warning:
     This function does not try to infer the "dtype" (hence, it is not
     optional). Passing a different "dtype" than its source may result
     in unexpected behavior.
   Parameters:
      buffer (object) -- a Python object that exposes the buffer
      interface.
   Keyword Arguments:
      * dtype ("torch.dtype") -- the desired data type of returned
        tensor.
      * count (int, optional) -- the number of desired
        elements to be read. If negative, all the elements (until the
        end of the buffer) will be read. Default: -1.
      * offset (int, optional) -- the number of bytes to


skip at the start of the buffer. Default: 0.
      * requires_grad (bool, optional) -- If autograd should
        record operations on the returned tensor. Default: "False".
   Example:
      >>> import array
      >>> a = array.array('i', [1, 2, 3])
      >>> t = torch.frombuffer(a, dtype=torch.int32)
      >>> t
      tensor([ 1,  2,  3])
      >>> t[0] = -1
      >>> a
      array([-1,  2,  3])
      >>> # Interprets the signed char bytes as 32-bit integers.
      >>> # Each 4 signed char elements will be interpreted as
      >>> # 1 signed 32-bit integer.
      >>> import array
      >>> a = array.array('b', [-1, 0, 0, 0])
      >>> torch.frombuffer(a, dtype=torch.int32)
      tensor([255], dtype=torch.int32)


StandaloneModuleConfigEntryclass torch.ao.quantization.fx.custom_config.StandaloneModuleConfigEntry(qconfig_mapping: 'Optional[QConfigMapping]', example_inputs: 'Tuple[Any, ...]', prepare_custom_config: 'Optional[PrepareCustomConfig]', backend_config: 'Optional[BackendConfig]')


torch.foreach_erf_torch._foreach_erf(self: List[Tensor]) -> None
   Apply "torch.erf()" to each Tensor of the input list.


torch.Tensor.detTensor.det() -> Tensor
   See "torch.det()"


torch.autograd.Function.forwardstatic Function.forward(ctx, args, kwargs)
   This function is to be overridden by all subclasses. There are two
   ways to define forward:
   Usage 1 (Combined forward and ctx):
      @staticmethod
      def forward(ctx: Any, args: Any, kwargs: Any) -> Any:
          pass
   * It must accept a context ctx as the first argument, followed by
     any number of arguments (tensors or other types).
   * See Combined or separate forward() and setup_context() for more
     details
   Usage 2 (Separate forward and ctx):
      @staticmethod
      def forward(*args: Any, kwargs: Any) -> Any:
          pass
      @staticmethod
      def setup_context(ctx: Any, inputs: Tuple[Any, ...], output: Any) -> None:
          pass
   * The forward no longer accepts a ctx argument.
   * Instead, you must also override the
     "torch.autograd.Function.setup_context()" staticmethod to handle
     setting up the "ctx" object. "output" is the output of the


forward, "inputs" are a Tuple of inputs to the forward.
   * See Extending torch.autograd for more details
   The context can be used to store arbitrary data that can be then
   retrieved during the backward pass. Tensors should not be stored
   directly on ctx (though this is not currently enforced for
   backward compatibility). Instead, tensors should be saved either
   with "ctx.save_for_backward()" if they are intended to be used in
   "backward" (equivalently, "vjp") or "ctx.save_for_forward()" if
   they are intended to be used for in "jvp".
   Return type:
      Any


torch.nn.functional.max_unpool3dtorch.nn.functional.max_unpool3d(input, indices, kernel_size, stride=None, padding=0, output_size=None)
   Computes a partial inverse of "MaxPool3d".
   See "MaxUnpool3d" for details.
   Return type:
      Tensor


torch.Tensor.add_Tensor.add_(other, *, alpha=1) -> Tensor
   In-place version of "add()"


PrepareCustomConfigclass torch.ao.quantization.fx.custom_config.PrepareCustomConfig
   Custom configuration for "prepare_fx()" and "prepare_qat_fx()".
   Example usage:
      prepare_custom_config = PrepareCustomConfig()             .set_standalone_module_name("module1", qconfig_mapping, example_inputs,                 child_prepare_custom_config, backend_config)             .set_standalone_module_class(MyStandaloneModule, qconfig_mapping, example_inputs,                 child_prepare_custom_config, backend_config)             .set_float_to_observed_mapping(FloatCustomModule, ObservedCustomModule)             .set_non_traceable_module_names(["module2", "module3"])             .set_non_traceable_module_classes([NonTraceableModule1, NonTraceableModule2])             .set_input_quantized_indexes([0])             .set_output_quantized_indexes([0])             .set_preserved_attributes(["attr1", "attr2"])
   classmethod from_dict(prepare_custom_config_dict)


Create a "PrepareCustomConfig" from a dictionary with the
      following items:
         "standalone_module_name": a list of (module_name,
         qconfig_mapping, example_inputs, child_prepare_custom_config,
         backend_config) tuples
         "standalone_module_class" a list of (module_class,
         qconfig_mapping, example_inputs, child_prepare_custom_config,
         backend_config) tuples
         "float_to_observed_custom_module_class": a nested dictionary
         mapping from quantization mode to an inner mapping from float
         module classes to observed module classes, e.g. {"static":
         {FloatCustomModule: ObservedCustomModule}}
         "non_traceable_module_name": a list of modules names that are
         not symbolically traceable "non_traceable_module_class": a
         list of module classes that are not symbolically traceable
         "input_quantized_idxs": a list of indexes of graph inputs
         that should be quantized "output_quantized_idxs": a list of


indexes of graph outputs that should be quantized
         "preserved_attributes": a list of attributes that persist
         even if they are not used in "forward"
      This function is primarily for backward compatibility and may be
      removed in the future.
      Return type:
         PrepareCustomConfig
   set_float_to_observed_mapping(float_class, observed_class, quant_type=QuantType.STATIC)
      Set the mapping from a custom float module class to a custom
      observed module class.
      The observed module class must have a "from_float" class method
      that converts the float module class to the observed module
      class. This is currently only supported for static quantization.
      Return type:
         PrepareCustomConfig
   set_input_quantized_indexes(indexes)
      Set the indexes of the inputs of the graph that should be
      quantized. Inputs are otherwise assumed to be in fp32 by default
      instead.
      Return type:
         PrepareCustomConfig


Return type:
         PrepareCustomConfig
   set_non_traceable_module_classes(module_classes)
      Set the modules that are not symbolically traceable, identified
      by class.
      Return type:
         PrepareCustomConfig
   set_non_traceable_module_names(module_names)
      Set the modules that are not symbolically traceable, identified
      by name.
      Return type:
         PrepareCustomConfig
   set_output_quantized_indexes(indexes)
      Set the indexes of the outputs of the graph that should be
      quantized. Outputs are otherwise assumed to be in fp32 by
      default instead.
      Return type:
         PrepareCustomConfig
   set_preserved_attributes(attributes)
      Set the names of the attributes that will persist in the graph
      module even if they are not used in the model's "forward"
      method.
      Return type:
         PrepareCustomConfig
   set_standalone_module_class(module_class, qconfig_mapping, example_inputs, prepare_custom_config, backend_config)


Set the configuration for running a standalone module identified
      by "module_class".
      If "qconfig_mapping" is None, the parent "qconfig_mapping" will
      be used instead. If "prepare_custom_config" is None, an empty
      "PrepareCustomConfig" will be used. If "backend_config" is None,
      the parent "backend_config" will be used instead.
      Return type:
         PrepareCustomConfig
   set_standalone_module_name(module_name, qconfig_mapping, example_inputs, prepare_custom_config, backend_config)
      Set the configuration for running a standalone module identified
      by "module_name".
      If "qconfig_mapping" is None, the parent "qconfig_mapping" will
      be used instead. If "prepare_custom_config" is None, an empty
      "PrepareCustomConfig" will be used. If "backend_config" is None,
      the parent "backend_config" will be used instead.
      Return type:
         PrepareCustomConfig
   to_dict()
      Convert this "PrepareCustomConfig" to a dictionary with the


items described in "from_dict()".
      Return type:
         Dict[str, Any]


torch.renormtorch.renorm(input, p, dim, maxnorm, , out=None) -> Tensor
   Returns a tensor where each sub-tensor of "input" along dimension
   "dim" is normalized such that the p-norm of the sub-tensor is
   lower than the value "maxnorm"
   Note:
     If the norm of a row is lower than maxnorm, the row is
     unchanged
   Parameters:
      * input (Tensor) -- the input tensor.
      * p (float) -- the power for the norm computation
      * dim (int) -- the dimension to slice over to get the sub-
        tensors
      * maxnorm (float) -- the maximum norm to keep each sub-
        tensor under
   Keyword Arguments:
      out (Tensor, optional*) -- the output tensor.
   Example:
      >>> x = torch.ones(3, 3)
      >>> x[1].fill_(2)
      tensor([ 2.,  2.,  2.])
      >>> x[2].fill_(3)
      tensor([ 3.,  3.,  3.])
      >>> x
      tensor([[ 1.,  1.,  1.],
              [ 2.,  2.,  2.],
              [ 3.,  3.,  3.]])
      >>> torch.renorm(x, 1, 0, 5)


torch.renorm(x, 1, 0, 5)
      tensor([[ 1.0000,  1.0000,  1.0000],
              [ 1.6667,  1.6667,  1.6667],
              [ 1.6667,  1.6667,  1.6667]])


torch._foreach_costorch._foreach_cos(self: List[Tensor]) -> List[Tensor]
   Apply "torch.cos()" to each Tensor of the input list.


torch.Tensor.numelTensor.numel() -> int
   See "torch.numel()"


CosineSimilarityclass torch.nn.CosineSimilarity(dim=1, eps=1e-08)
   Returns cosine similarity between x_1 and x_2, computed along
   dim.
      \text{similarity} = \dfrac{x_1 \cdot x_2}{\max(\Vert x_1 \Vert
      _2 \cdot \Vert x_2 \Vert _2, \epsilon)}.
   Parameters:
      * dim (int, optional) -- Dimension where cosine
        similarity is computed. Default: 1
      * eps (float, optional) -- Small value to avoid
        division by zero. Default: 1e-8
   Shape:
      * Input1: (\ast_1, D, \ast_2) where D is at position dim
      * Input2: (\ast_1, D, \ast_2), same number of dimensions as x1,
        matching x1 size at dimension dim,
           and broadcastable with x1 at other dimensions.
      * Output: (\ast_1, \ast_2)
   Examples::
      >>> input1 = torch.randn(100, 128)
      >>> input2 = torch.randn(100, 128)
      >>> cos = nn.CosineSimilarity(dim=1, eps=1e-6)
      >>> output = cos(input1, input2)


torch.Tensor.cosh_Tensor.cosh_() -> Tensor
   In-place version of "cosh()"


torch.tensortorch.tensor(data, , dtype=None, device=None, requires_grad=False, pin_memory=False) -> Tensor
   Constructs a tensor with no autograd history (also known as a "leaf
   tensor", see Autograd mechanics) by copying "data".
   Warning:
     When working with tensors prefer using "torch.Tensor.clone()",
     "torch.Tensor.detach()", and "torch.Tensor.requires_grad_()" for
     readability. Letting t be a tensor, "torch.tensor(t)" is
     equivalent to "t.clone().detach()", and "torch.tensor(t,
     requires_grad=True)" is equivalent to
     "t.clone().detach().requires_grad_(True)".
   See also:
     "torch.as_tensor()" preserves autograd history and avoids copies
     where possible. "torch.from_numpy()" creates a tensor that shares
     storage with a NumPy array.
   Parameters:
      data (array_like*) -- Initial data for the tensor. Can be a
      list, tuple, NumPy "ndarray", scalar, and other types.
   Keyword Arguments:


Keyword Arguments:
      * dtype ("torch.dtype", optional) -- the desired data type
        of returned tensor. Default: if "None", infers data type from
        "data".
      * device ("torch.device", optional) -- the device of the
        constructed tensor. If None and data is a tensor then the
        device of data is used. If None and data is not a tensor then
        the result tensor is constructed on the CPU.
      * requires_grad (bool, optional) -- If autograd should
        record operations on the returned tensor. Default: "False".
      * pin_memory (bool, optional) -- If set, returned
        tensor would be allocated in the pinned memory. Works only for
        CPU tensors. Default: "False".
   Example:
      >>> torch.tensor([[0.1, 1.2], [2.2, 3.1], [4.9, 5.2]])
      tensor([[ 0.1000,  1.2000],
              [ 2.2000,  3.1000],
              [ 4.9000,  5.2000]])
      >>> torch.tensor([0, 1])  # Type inference on data
      tensor([ 0,  1])


tensor([ 0,  1])
      >>> torch.tensor([[0.11111, 0.222222, 0.3333333]],
      ...              dtype=torch.float64,
      ...              device=torch.device('cuda:0'))  # creates a double tensor on a CUDA device
      tensor([[ 0.1111,  0.2222,  0.3333]], dtype=torch.float64, device='cuda:0')
      >>> torch.tensor(3.14159)  # Create a zero-dimensional (scalar) tensor
      tensor(3.1416)
      >>> torch.tensor([])  # Create an empty tensor (of size (0,))
      tensor([])


Foldclass torch.nn.Fold(output_size, kernel_size, dilation=1, padding=0, stride=1)
   Combines an array of sliding local blocks into a large containing
   tensor.
   Consider a batched "input" tensor containing sliding local blocks,
   e.g., patches of images, of shape (N, C \times
   \prod(\text{kernel_size}), L), where N is batch dimension, C
   \times \prod(\text{kernel_size}) is the number of values within a
   block (a block has \prod(\text{kernel_size}) spatial locations
   each containing a C-channeled vector), and L is the total number of
   blocks. (This is exactly the same specification as the output shape
   of "Unfold".) This operation combines these local blocks into the
   large "output" tensor of shape (N, C, \text{output_size}[0],
   \text{output_size}[1], \dots) by summing the overlapping values.
   Similar to "Unfold", the arguments must satisfy
      L = \prod_d \left\lfloor\frac{\text{output_size}[d] + 2 \times
      \text{padding}[d] %     - \text{dilation}[d] \times


(\text{kernel_size}[d] - 1) - 1}{\text{stride}[d]} +
      1\right\rfloor,
   where d is over all spatial dimensions.
   * "output_size" describes the spatial shape of the large containing
     tensor of the sliding local blocks. It is useful to resolve the
     ambiguity when multiple input shapes map to same number of
     sliding blocks, e.g., with "stride > 0".
   The "padding", "stride" and "dilation" arguments specify how the
   sliding blocks are retrieved.
   * "stride" controls the stride for the sliding blocks.
   * "padding" controls the amount of implicit zero-paddings on both
     sides for "padding" number of points for each dimension before
     reshaping.
   * "dilation" controls the spacing between the kernel points; also
     known as the Ã  trous algorithm. It is harder to describe, but
     this link has a nice visualization of what "dilation" does.
   Parameters:
      * output_size (int or tuple) -- the shape of the


spatial dimensions of the output (i.e., "output.sizes()[2:]")
      * kernel_size (int or tuple) -- the size of the
        sliding blocks
      * dilation (int or tuple, optional) -- a parameter
        that controls the stride of elements within the neighborhood.
        Default: 1
      * padding (int or tuple, optional) -- implicit
        zero padding to be added on both sides of input. Default: 0
      * stride (int or tuple) -- the stride of the sliding
        blocks in the input spatial dimensions. Default: 1
   * If "output_size", "kernel_size", "dilation", "padding" or
     "stride" is an int or a tuple of length 1 then their values will
     be replicated across all spatial dimensions.
   * For the case of two output spatial dimensions this operation is
     sometimes called "col2im".
   Note:
     "Fold" calculates each combined value in the resulting large
     tensor by summing all values from all containing blocks. "Unfold"


extracts the values in the local blocks by copying from the large
     tensor. So, if the blocks overlap, they are not inverses of each
     other.In general, folding and unfolding operations are related as
     follows. Consider "Fold" and "Unfold" instances created with the
     same parameters:
     >>> fold_params = dict(kernel_size=..., dilation=..., padding=..., stride=...)
     >>> fold = nn.Fold(output_size=..., fold_params)
     >>> unfold = nn.Unfold(fold_params)
     Then for any (supported) "input" tensor the following equality
     holds:
        fold(unfold(input)) == divisor * input
     where "divisor" is a tensor that depends only on the shape and
     dtype of the "input":
     >>> input_ones = torch.ones(input.shape, dtype=input.dtype)
     >>> divisor = fold(unfold(input_ones))
     When the "divisor" tensor contains no zero elements, then "fold"
     and "unfold" operations are inverses of each other (up to
     constant divisor).
   Warning:


constant divisor).
   Warning:
     Currently, only unbatched (3D) or batched (4D) image-like output
     tensors are supported.
   Shape:
      * Input: (N, C \times \prod(\text{kernel_size}), L) or (C
        \times \prod(\text{kernel_size}), L)
      * Output: (N, C, \text{output_size}[0], \text{output_size}[1],
        \dots) or (C, \text{output_size}[0], \text{output_size}[1],
        \dots) as described above
   Examples:
      >>> fold = nn.Fold(output_size=(4, 5), kernel_size=(2, 2))
      >>> input = torch.randn(1, 3 * 2 * 2, 12)
      >>> output = fold(input)
      >>> output.size()
      torch.Size([1, 3, 4, 5])


torch.nanmediantorch.nanmedian(input) -> Tensor
   Returns the median of the values in "input", ignoring "NaN" values.
   This function is identical to "torch.median()" when there are no
   "NaN" values in "input". When "input" has one or more "NaN" values,
   "torch.median()" will always return "NaN", while this function will
   return the median of the non-"NaN" elements in "input". If all the
   elements in "input" are "NaN" it will also return "NaN".
   Parameters:
      input (Tensor) -- the input tensor.
   Example:
      >>> a = torch.tensor([1, float('nan'), 3, 2])
      >>> a.median()
      tensor(nan)
      >>> a.nanmedian()
      tensor(2.)
   torch.nanmedian(input, dim=- 1, keepdim=False, *, out=None)
   Returns a namedtuple "(values, indices)" where "values" contains
   the median of each row of "input" in the dimension "dim", ignoring
   "NaN" values, and "indices" contains the index of the median values
   found in the dimension "dim".


found in the dimension "dim".
   This function is identical to "torch.median()" when there are no
   "NaN" values in a reduced row. When a reduced row has one or more
   "NaN" values, "torch.median()" will always reduce it to "NaN",
   while this function will reduce it to the median of the non-"NaN"
   elements. If all the elements in a reduced row are "NaN" then it
   will be reduced to "NaN", too.
   Parameters:
      * input (Tensor) -- the input tensor.
      * dim (int) -- the dimension to reduce.
      * keepdim (bool) -- whether the output tensor has "dim"
        retained or not.
   Keyword Arguments:
      out ((Tensor, Tensor), optional) -- The first
      tensor will be populated with the median values and the second
      tensor, which must have dtype long, with their indices in the
      dimension "dim" of "input".
   Example:
      >>> a = torch.tensor([[2, 3, 1], [float('nan'), 1, float('nan')]])
      >>> a
      tensor([[2., 3., 1.],


a
      tensor([[2., 3., 1.],
              [nan, 1., nan]])
      >>> a.median(0)
      torch.return_types.median(values=tensor([nan, 1., nan]), indices=tensor([1, 1, 1]))
      >>> a.nanmedian(0)
      torch.return_types.nanmedian(values=tensor([2., 1., 1.]), indices=tensor([0, 1, 0]))


EmbeddingBagclass torch.ao.nn.quantized.EmbeddingBag(num_embeddings, embedding_dim, max_norm=None, norm_type=2.0, scale_grad_by_freq=False, mode='sum', sparse=False, _weight=None, include_last_offset=False, dtype=torch.quint8)
   A quantized EmbeddingBag module with quantized packed weights as
   inputs. We adopt the same interface as torch.nn.EmbeddingBag,
   please see
   https://pytorch.org/docs/stable/nn.html#torch.nn.EmbeddingBag for
   documentation.
   Similar to "EmbeddingBag", attributes will be randomly initialized
   at module creation time and will be overwritten later
   Variables:
      weight (Tensor) -- the non-learnable quantized weights of
      the module of shape (\text{num_embeddings},
      \text{embedding_dim}).
   Examples::
      >>> m = nn.quantized.EmbeddingBag(num_embeddings=10, embedding_dim=12, include_last_offset=True, mode='sum')


indices = torch.tensor([9, 6, 5, 7, 8, 8, 9, 2, 8, 6, 6, 9, 1, 6, 8, 8, 3, 2, 3, 6, 3, 6, 5, 7, 0, 8, 4, 6, 5, 8, 2, 3])
      >>> offsets = torch.tensor([0, 19, 20, 28, 28, 32])
      >>> output = m(indices, offsets)
      >>> print(output.size())
      torch.Size([5, 12])
   classmethod from_float(mod)
      Create a quantized embedding_bag module from a float module
      Parameters:
         mod (Module) -- a float module, either produced by
         torch.ao.quantization utilities or provided by user


torch.linalg.slogdettorch.linalg.slogdet(A, , out=None)
   Computes the sign and natural logarithm of the absolute value of
   the determinant of a square matrix.
   For complex "A", it returns the sign and the natural logarithm of
   the modulus of the determinant, that is, a logarithmic polar
   decomposition of the determinant.
   The determinant can be recovered as sign * exp(logabsdet). When a
   matrix has a determinant of zero, it returns (0, -inf).
   Supports input of float, double, cfloat and cdouble dtypes. Also
   supports batches of matrices, and if "A" is a batch of matrices
   then the output has the same batch dimensions.
   See also:
     "torch.linalg.det()" computes the determinant of square matrices.
   Parameters:
      A (Tensor) -- tensor of shape (, n, n) where *** is
      zero or more batch dimensions.
   Keyword Arguments:
      out (tuple, optional) -- output tuple of two tensors.
      Ignored if None. Default: None.
   Returns:


Returns:
      A named tuple (sign, logabsdet).
      sign will have the same dtype as "A".
      logabsdet will always be real-valued, even when "A" is
      complex.
   Examples:
      >>> A = torch.randn(3, 3)
      >>> A
      tensor([[ 0.0032, -0.2239, -1.1219],
              [-0.6690,  0.1161,  0.4053],
              [-1.6218, -0.9273, -0.0082]])
      >>> torch.linalg.det(A)
      tensor(-0.7576)
      >>> torch.logdet(A)
      tensor(nan)
      >>> torch.linalg.slogdet(A)
      torch.return_types.linalg_slogdet(sign=tensor(-1.), logabsdet=tensor(-0.2776))