| 1 | _adaptive_avg_pool3d_backward | NeuralNetwork | Alpha | 5.1 | aten, KernelGen, reduction | Computes the gradient of 3D adaptive average pooling. |
| 2 | _aminmax | Reduction | Alpha | 5.5 | aten, KernelGen | Computes the minimum and maximum values of the input tensor. |
| 3 | _aminmax_out | Reduction | Alpha | 5.5 | aten, KernelGen | A variant of _aminmax() that writes the result into the out tensor. |
| 4 | _conj | Math | Alpha | 5.4 | aten, KernelGen | The private conjugate primitive backing torch.conj and torch._conj. Raises on non-complex inputs. |
| 5 | _conj_physical | Math | Alpha | 5.5 | aten, KernelGen | Computes the element-wise conjugate of the given input tensor as a physical (non-view) tensor. For non-complex dtypes the input is returned unchanged. |
| 6 | _conj_physical_out | Math | Alpha | 5.5 | aten, KernelGen | A variant of _conj_physical() that writes the result into the out tensor. |
| 7 | _ctc_loss | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Computes the CTC loss and the alpha lattice used by its backward pass. |
| 8 | _ctc_loss_backward | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Computes the gradient of the CTC loss with respect to log_probs. |
| 9 | _ctc_loss_backward_out | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | A variant of _ctc_loss_backward that allows the output to be assigned to out. |
| 10 | _ctc_loss_out | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | A variant of _ctc_loss that allows the outputs to be assigned to out. |
| 11 | _flash_attention_forward | NeuralNetwork | Alpha | 5.4 | aten, NoCPU, KernelGen | Run the canonical FlashAttention forward operator. |
| 12 | _fused_dropout | NeuralNetwork | Alpha | 5.5 | aten | Applies dropout using a keep probability and returns a uint8 mask. |
| 13 | _linalg_eigh | Math | Alpha | 5.4 | aten, KernelGen | Computes the eigenvalues and eigenvectors of a symmetric or Hermitian matrix. |
| 14 | _linalg_slogdet | LinearAlg | Alpha | 5.5 | aten, KernelGen | Computes the sign and natural logarithm of the absolute value of the
determinant of a square matrix using LU decomposition with partial
pivoting, returning the intermediate LU factorization and pivot buffer. |
| 15 | _linalg_solve_ex | LinearAlg | Alpha | 5.5 | aten, KernelGen | Solves a linear system AX = B (or XA = B) via fused LU decomposition with partial pivoting and forward/backward substitution in a single Triton kernel; the private primitive backing torch.linalg.solve_ex and the autograd formula of torch.linalg.solve. Returns (result, LU, pivots, info) where LU and pivots are the factorization of A that the backward pass reuses and info indicates singularity status. |
| 16 | _linalg_svd | BLAS | Alpha | 5.5 | aten, KernelGen | Computes the singular value decomposition (SVD) of a matrix; the private primitive backing torch.linalg.svd and torch.linalg.svdvals. |
| 17 | _logcumsumexp | Math | Alpha | 5.5 | aten, KernelGen | Returns the log of the cumulative sum of exponentials of elements along a dimension, computed in a numerically stable way. Underscored variant of torch.logcumsumexp. |
| 18 | _logcumsumexp_out | Math | Alpha | 5.5 | aten, KernelGen | A variant of _logcumsumexp that assigns the output to the out tensor. |
| 19 | _philox_uniform_ | Distribution | Alpha | 5.5.0 | aten, KernelGen, pointwise | Fills the tensor in place with samples from a uniform distribution over
[low, high) drawn from a stateless Philox RNG stream identified by the
(seed, offset) pair in key. |
| 20 | _reshape_alias | Tensor | Alpha | 5.4 | aten, KernelGen | Creates a view of the input tensor with the given size and stride,
sharing the same storage as the input. This is an internal reshape
helper that skips the validity checks a normal reshape performs. |
| 21 | _reshape_copy | Tensor | Alpha | 5.5.0 | aten, KernelGen | Returns a contiguous copy of the input tensor reshaped to the requested size. The row-major logical order of the input is materialized into fresh contiguous storage, so the result is never a view and never aliases the input. Unlike _reshape_alias_copy no explicit stride is accepted, and size may contain a single -1 dimension that is inferred from the remaining dimensions and the input numel, exactly like PyTorch's infer_size. |
| 22 | _saturate_weight_to_fp16 | Tensor | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for _saturate_weight_to_fp16. |
| 23 | _scaled_mm_v2 | BLAS | Alpha | 5.5.0 | aten, KernelGen | Recipe-driven scaled matrix multiply: mat_a @ mat_b where the low
precision (fp8/fp4) operands carry decoding scales described by
recipe_a/recipe_b. Supports the TensorWise (one scalar factor per
operand) and RowWise (one factor per row of mat_a / column of
mat_b) recipes, with an optional bias added to the result. |
| 24 | _stack | Tensor | Alpha | 5.5 | aten, KernelGen | Concatenates a sequence of tensors along a new dimension. This is the
internal _stack implementation that mirrors stack. |
| 25 | _transformer_encoder_layer_fwd | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for _transformer_encoder_layer_fwd. |
| 26 | _weight_norm | NeuralNetwork | Stable | 3.0 | aten, fused, KernelGen | Reparameterizes a module's weight tensor by decoupling its magnitude (g)
from its direction (v). It is a hook that compute the actual weight before
each forward pass. |
| 27 | abs | Math | Stable | 1.0 | aten, pointwise | Computes the absolute value of each element in input.
This is a simple wrapper of the existing torch abs operator. |
| 28 | abs_ | Math | Stable | 2.2 | aten, pointwise | The in-place version of abs(), which is a simple wrapper of the Torch abs operator. |
| 29 | absolute | Math | Stable | 5.3 | aaten, KernelGen | This is an alias for abs() with the low-level operations implemented
by invoking low-level Torch operators. |
| 30 | absolute_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of absolute(). |
| 31 | acos | Math | Stable | 5.0 | aten, pointwise | Returns a new tensor with the arccosine (in radians) of each element in input. |
| 32 | acos_ | Math | Alpha | 5.4 | aten, pointwise, inplace, KernelGen | In-place version of acos. Computes the arccosine (in radians) of each element of input and writes the result back to the input tensor. |
| 33 | acosh | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for acosh. |
| 34 | acosh_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of acosh(). |
| 35 | act_quant_triton | Quantization | Beta | 5.3 | fused | This is a fused operator. |
| 36 | adaptive_avg_pool1d | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Applies a one-dimensional adaptive average pooling over an input signal,
producing an output of the requested length. |
| 37 | adaptive_avg_pool2d | NeuralNetwork | Beta | 5.3 | aten, nn.functional, KernelGen | Apply a 2D adaptive average pooling over an input signal composed of several input planes. |
| 38 | adaptive_avg_pool2d_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen, reduction | Computes the gradient of two-dimensional adaptive average pooling with
respect to the input tensor. |
| 39 | adaptive_avg_pool3d_backward | NeuralNetwork | Alpha | 5.1 | aten, KernelGen, reduction | Computes the gradient of 3D adaptive average pooling. |
| 40 | adaptive_max_pool1d | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Applies a one-dimensional adaptive max pooling over an input signal,
returning both the pooled values and the selected input indices. |
| 41 | adaptive_max_pool2d | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Applies two-dimensional adaptive max pooling and returns both pooled values
and the selected input indices. |
| 42 | adaptive_max_pool2d_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Computes the input gradient for two-dimensional adaptive max pooling by
scattering output gradients to the saved maximum indices. |
| 43 | adaptive_max_pool3d | NeuralNetwork | Beta | 5.4 | aten | Applies three-dimensional adaptive max pooling over an input signal and
returns both the pooled values and the selected input indices. |
| 44 | adaptive_max_pool3d_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Computes the gradient for adaptive max pooling 3D. |
| 45 | add | Math | Stable | 1.0 | aten, pointwise | Add a scalar or tensor to self tensor. If both alpha and other are specified,
each element of other is scaled by alpha before being used. |
| 46 | add_ | Math | Stable | 2.2 | aten, pointwise | The in-place version of add(). |
| 47 | add_relu | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for _add_relu. |
| 48 | add_relu_ | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for the in-place _add_relu_(). |
| 49 | add_rms_norm | NeuralNetwork | Alpha | 5.4 | aten, KernelGen, Normalization | Add two inputs element-wise and apply Root Mean Square Layer Normalization. |
| 50 | addbmm | LinearAlg | Alpha | 5.4 | aten, KernelGen | Performs a batch matrix-matrix product of matrices in batch1 and batch2,
with a reduced add step (sum over batch dimension), and adds input to the result.
Formula: out = beta * input + alpha * (sum_i batch1_i @ batch2_i). |
| 51 | addbmm_ | LinearAlg | Alpha | 5.4 | aten, KernelGen | Inplace variant of addbmm. Performs a batch matrix-matrix product of matrices in
batch1 and batch2, with a reduced add step, and stores the result in self.
Formula: self = beta * self + alpha * (sum_i batch1_i @ batch2_i). |
| 52 | addcdiv | LinearAlg | Stable | 4.0 | aten, pointwise | Performs the element-wise division of tensor1 by tensor2, multiplies the result
by the scalar value and adds it to input. |
| 53 | addcdiv_ | Math | Alpha | 5.1 | aten, KernelGen | The in-place version of addcdiv(). Performs the element-wise division of
tensor1 by tensor2, multiplies the result by the scalar value and adds
it to input, storing the result in input. |
| 54 | addcdiv_out | LinearAlg | Stable | 5.3 | aten, pointwise, KernelGen | A variant of addcdiv() that assigns the output to the given out parameter.. |
| 55 | addcmul | LinearAlg | Stable | 4.0 | aten, pointwise | Performs the element-wise multiplication of tensor1 by tensor2,
multiplies the result by the scalar value and adds it to input. |
| 56 | addcmul_ | LinearAlg | Alpha | 5.4 | aten, pointwise, KernelGen | The in-place version of addcmul(). |
| 57 | addcmul_out | LinearAlg | Beta | 5.3 | aten, pointwise, KernelGen | A variant of addcmul that allows the output to be assigned to out. |
| 58 | addmm | BLAS | Stable | 1.0 | aten | Performs a matrix multiplication of the matrices mat1 and mat2.
The matrix input is added to the final result. |
| 59 | addmm_ | BLAS | Alpha | 5.4 | aten, KernelGen | The in-place version of addmm. Performs the matrix multiplication of mat1
and mat2, multiplied by alpha, then adds beta times input to the result
in-place. |
| 60 | addmm_activation | BLAS | Alpha | 5.5 | aten, KernelGen | Performs addmm followed by an activation function. Computes
beta * input + alpha * (mat1 @ mat2) and applies ReLU, or GELU (tanh
approximation) when use_gelu is True. |
| 61 | addmm_activation_out | BLAS | Alpha | 5.5 | aten, KernelGen | A variant of _addmm_activation() that assigns the output to the provided out parameter. |
| 62 | addmm_dtype | BLAS | Beta | 5.3 | aten | A variant of addmm that allows the dtype of the output tensor to be specified.
This is supported only on CUDA and for torch.float32 given torch.float16 or torch.bfloat16 input dtypes. |
| 63 | addmm_dtype_out | BLAS | Beta | 5.3 | aten | A variant of addmm_dtype() that allows the output to be saved to the provided out parameter. |
| 64 | addmm_out | BLAS | Stable | 4.0 | aten | A variant of addmm that assigns to the output to the provided out parameter. |
| 65 | addmm_out_vector_bias | BLAS | Beta | 5.4 | aten | A variant of addmm_out that exercises the vector bias (1-D input) broadcast path of the out overload. |
| 66 | addmm_vector_bias | BLAS | Beta | 5.4 | aten | A variant of addmm that exercises the vector bias (1-D input) broadcast path. |
| 67 | addmv | BLAS | Stable | 4.0 | aten | Performs a matrix-vector product of the matrix mat and the vector vec.
The vector input is added to the final result. |
| 68 | addmv_ | BLAS | Alpha | 5.4 | aten, KernelGen | Performs matrix-vector product with accumulation in-place. |
| 69 | addmv_out | BLAS | Stable | 4.0 | aten | Performs a matrix-vector product of the matrix mat and the vector vec.
The vector input is added to the final result. |
| 70 | addr | BLAS | Stable | 4.0 | aten | Performs the outer-product of vectors vec1 and vec2
and adds it to the matrix input. |
| 71 | addr_ | BLAS | Stable | 4.0 | aten, KernelGen | In-place version of addr. Performs the outer-product of vectors vec1 and vec2
and adds it to the matrix input in-place. |
| 72 | adjoint | Tensor | Alpha | 5.5 | aten, KernelGen | Returns the conjugate transpose view of a tensor: out[..., j, i] = conj(self[..., i, j]). |
| 73 | affine_grid_generator | Tensor | Alpha | 5.3 | aten, KernelGen, pointwise | Generates a 2D or 3D flow field (sampling grid), given a batch of affine matrices theta. |
| 74 | alias | Math | Alpha | 5.4 | aten, KernelGen | Return a view tensor sharing the same storage (zero-copy alias). |
| 75 | alias_copy | Tensor | Stable | 5.3 | aten, KernelGen | Creates a new tensor that shares the same storage data as the original tensor,
but without preserving the original tensor's metadata (like shape or strides)
in a way that links future mutations. |
| 76 | alias_copy_out | Tensor | Stable | 5.3 | aten, KernelGen | A variant of alias_copy() that assigns the output to the out tensor. |
| 77 | all | Math | Stable | 2.0 | aten, Reduction | Tests if all elements in input evaluate to True. |
| 78 | all_dim | Math | Stable | 2.0 | aten, Reduction | For each row of input in the given dimension dim, returns True if all elements
in the row evaluate to True and False otherwise. |
| 79 | all_dims | Math | Stable | 2.0 | aten, Reduction | A variant of all. |
| 80 | allclose | Math | Stable | 2.1 | aten | This function checks if input and other satisfy a condition specified via
atol and rtol elementwise, for all elements of input and other. |
| 81 | alpha_dropout | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Applies alpha dropout to the input. Alpha Dropout is a type of Dropout
that maintains the self-normalizing property by scaling activations
with SELU activation function parameters. |
| 82 | alpha_dropout_ | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Applies alpha dropout to the input inplace. Alpha Dropout is a type of
Dropout that maintains the self-normalizing property by scaling
activations with SELU activation function parameters. |
| 83 | amax | LinearAlg | Stable | 2.0 | aten, Reduction | Returns the maximum value of each slice of the input tensor in the given dimension(s) dim. |
| 84 | amin | Reduction | Alpha | 5.4 | aten, KernelGen | Returns the minimum value of each row of the input tensor in the given dimension dim. |
| 85 | amin_ | Reduction | Alpha | 5.4 | aten, KernelGen | The in-place version of amin, returns the minimum value of each row in the given dimension. |
| 86 | aminmax | Tensor | Beta | 5.3 | aten | Computes the minimum and maximum values of the input tensor. |
| 87 | amp_foreach_non_finite_check_and_unscale_ | Math | Alpha | 5.4 | aten, KernelGen | Checks gradient tensors for non-finite values (inf or nan) and
unscales each tensor in-place by inv_scale. If any non-finite
value is detected, found_inf is set to 1.0. |
| 88 | amp_update_scale_ | Math | Alpha | 5.4 | aten, KernelGen | Updates the AMP loss scale in-place: when found_inf is non-zero the
scale is multiplied by scale_backoff_factor and the growth tracker
is reset to 0; otherwise the growth tracker is incremented and, once
it reaches growth_interval, the scale is multiplied by
scale_growth_factor and the tracker is reset to 0. |
| 89 | and_scalar | Math | Beta | 5.4 | aten, KernelGen | Computes the bitwise AND operation through the tensor dunder method with a scalar operand. |
| 90 | and_tensor | Math | Beta | 5.4 | aten, KernelGen | Computes the bitwise AND operation through the tensor dunder method with tensor operands. |
| 91 | angle | Math | Stable | 3.0 | aten, pointwise | Computes the element-wise angle (in radians) of the given input tensor. |
| 92 | any | Math | Stable | 2.0 | aten, Reduction | Tests if any element in input evaluates to True. |
| 93 | any_dim | Math | Stable | 2.0 | aten, Reduction | For each row of input in the given dimension dim, returns True if any element in the row evaluate to True and False otherwise. |
| 94 | any_dims | Math | Stable | 2.0 | aten, Reduction | For each row of input in the given dimensions in dims, returns True if any element in the row evaluate to True and False otherwise.
The dims contains tuple of ints indicating the dimensions to reduce. |
| 95 | apply_repetition_penalties | NeuralNetwork | Stable | 5.0 | fused, vLLM | Modifies logit tensors in place to penalize tokens that have already appeared in the generated sequence. |
| 96 | apply_rotary_pos_emb | NeuralNetwork | Stable | 2.0 | fused | A method to incorporate positional information into the Transformer architecture.
Rotary Positional Embedding (RoPE) applies position-dependent rotation to the query (Q)
and key (K) vectors before computing the attention score. |
| 97 | arange | Tensor | Stable | 2.1 | aten | Returns a 1-D tensor of size ceiling((end−start)/step) with values from the interval [start, end)
taken with common difference step beginning from start. |
| 98 | arange_start | tensor | Stable | 2.1 | aten | A variant of arange, with start and/or step specified. |
| 99 | arange_start_step | tensor | Stable | 2.1 | aten | A variant of arange, with start and/or step specified. |
| 100 | arccos | Math | Alpha | 5.4 | aten, KernelGen | Returns a new tensor with the arccosine of the elements of input. |
| 101 | arccos_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of arccos(). |
| 102 | arccosh | Math | Alpha | 5.4 | aten, KernelGen | Returns a new tensor with the inverse hyperbolic cosine of the elements of input. |
| 103 | arccosh_ | Math | Alpha | 5.4 | aten, KernelGen | Computes the element-wise inverse hyperbolic cosine of a given input tensor.
This is an in-place version. |
| 104 | arccosh_out | Math | Alpha | 5.4 | aten, KernelGen | A variant of arccosh that allows the output to be assigned to the out tensor. |
| 105 | arcsin | Math | Alpha | 5.4 | aten, KernelGen | Returns a new tensor with the arcsine of the elements of input. |
| 106 | arcsin_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of arcsin(). |
| 107 | arcsin_out | Math | Alpha | 5.4 | aten, KernelGen | A variant of arcsin that allows the output to be assigned to the out tensor. |
| 108 | arcsinh | Math | Stable | 5.4 | aten, KernelGen | Performs an element-wise inverse hyperbolic sine computation on the given tensor. |
| 109 | arcsinh_ | Math | Stable | 5.4 | aten, KernelGen | The in-place version of arcsinh(). |
| 110 | arcsinh_out | Math | Stable | 5.4 | aten, KernelGen | A variant of arcsinh that allows the output to be assigned to the out tensor. |
| 111 | arctan | Math | Alpha | 5.4 | aten, KernelGen | Returns a new tensor with the element-wise inverse tangent (arctangent) of the input tensor. |
| 112 | arctan2 | Math | Alpha | 5.4 | aten, KernelGen | Computes the element-wise arctangent of input / other. Alias for atan2. |
| 113 | arctan2_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of arctan2().
Computes the element-wise arc tangent of input/other(y/x),
returning angles in radians between -PI and PI and stores the result in input. |
| 114 | arctan_ | Math | Alpha | 5.4 | aten, KernelGen | Computes the element-wise inverse tangent (arctangent) of a given input tensor.
This is an in-place version. |
| 115 | arctanh | Math | Alpha | 5.4 | aten, KernelGen | Computes the element-wise inverse hyperbolic tangent of a given input tensor. |
| 116 | arctanh_ | Math | Stable | 5.4 | aten, KernelGen | Computes the element-wise inverse hyperbolic tangent of a given input tensor.
This is an in-place version. |
| 117 | arctanh_out | Math | Alpha | 5.4 | aten, KernelGen | A variant of arctanh that assigns the output to the provided out parameter. |
| 118 | argmax | LinearAlg | Stable | 2.0 | aten, Reduction | Returns the indices of the maximum value of all elements in the input tensor. |
| 119 | argmin | LinearAlg | Stable | 2.2 | aten, Reduction | Returns the indices of the minimum value(s) of the flattened tensor or along a dimension. |
| 120 | argsort | Tensor | Alpha | 5.4 | skip_precision_check, KernelGen | Sorting/selection operator (argsort). |
| 121 | as_strided_copy | Tensor | Beta | 5.3 | aten, KernelGen | Creates a contiguous copy of an as_strided view of the input tensor. |
| 122 | as_strided_copy_out | Tensor | Beta | 5.3 | aten, KernelGen | A variant of as_strided_copy() that assigns the output to the out tensor. |
| 123 | as_strided_scatter | Tensor | Alpha | 5.4 | aten, KernelGen | Returns a clone of the input storage with source values written through a
view defined by the requested size, stride, and storage offset. |
| 124 | asin | Math | Alpha | 5.4 | aten, KernelGen | Returns a new tensor with the arcsine of the elements of input. |
| 125 | asin_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of asin(). |
| 126 | asinh | Math | Alpha | 5.3 | aten, KernelGen | Returns a new tensor with the inverse hyperbolic sine of the elements of input. |
| 127 | asinh_ | Math | Stable | 5.3 | aten, KernelGen | Computes the inverse hyperbolic sine for each element of a tensor in-place. |
| 128 | assert_async | Tensor | Stable | 5.3 | utility | A utility used to perform data-dependent assertions on GPU tensors
without triggering an immediate, performance-heavy GPU-to-CPU synchronization. |
| 129 | atan | Math | Stable | 4.0 | aten, pointwise | Returns a new tensor with the arctangent of the elements (in radians) in the input tensor. |
| 130 | atan2 | Math | Stable | 5.3 | aten, pointwise | Computes the element-wise arc tangent of input/other(y/x),
returning angles in radians between -PI and PI. |
| 131 | atan2_ | Math | Alpha | 5.4 | aten, KernelGen, pointwise | Computes the element-wise arctangent of input/other in-place. |
| 132 | atan2_out | Math | Beta | 5.3 | aten, pointwise | A variant of atan2 that allows the output to be saved into out. |
| 133 | atan_ | Math | Stable | 4.0 | aten, pointwise | The in-place version of atan(). |
| 134 | atanh | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for atanh. |
| 135 | atanh_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of atanh(). |
| 136 | atleast_3d | Tensor | Alpha | 5.5 | aten, KernelGen | Returns a view of the input tensor with at least three dimensions (view operation). |
| 137 | avg_pool1d | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Applies 1D average-pooling operation in kL regions by step size sL steps.
The number of output features is equal to the number of input planes. |
| 138 | avg_pool2d | NeuralNetwork | Stable | 4.1 | nn.functional | Applies 2D average-pooling operation in kH \mul kW regions by step size sH \mul sW steps.
The number of output features is equal to the number of input planes.
This is for the forward case. |
| 139 | avg_pool2d_backward | NeuralNetwork | Stable | 4.1 | aten | The backward version of avg_pool2d(). |
| 140 | avg_pool3d | NeuralNetwork | Beta | 5.3 | aten | Applies 3D average-pooling operation in kD \times kH \times kW regions by step size
sD \times sH \times sW steps. |
| 141 | avg_pool3d_backward | NeuralNetwork | Alpha | 5.3 | aten | This is the backward version of avg_pool3d(). |
| 142 | baddbmm | BLAS | Stable | 4.1 | aten | Performs a batch matrix-matrix product of matrices in batch1 and batch2.
input is added to the final result. batch1 and batch2 must be 3-D tensors
each containing the same number of matrices. |
| 143 | baddbmm_ | BLAS | Alpha | 5.4 | aten, KernelGen | Performs batched matrix-matrix product with accumulation in-place. |
| 144 | baddbmm_out | BLAS | Beta | 5.3 | aten | This is a variant of baddbmm(). |
| 145 | bartlett_window | Math | Alpha | 5.5 | aten, KernelGen | Generates a Bartlett window of given length, returning a 1-D tensor with the triangular window coefficients. |
| 146 | batch_norm | NeuralNetwork | Stable | 3.0 | aten | An internal operator used for implementing the BatchNorm functionality. |
| 147 | batch_norm_backward | NeuralNetwork | Stable | 3.0 | aten | The backward version of batch_norm(). |
| 148 | batch_norm_backward_elemt | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Compute the per-element gradient for batch normalization backward pass.
Given pre-computed channel statistics (sum_dy, sum_dy_xmu), produces
grad_input without reduction. |
| 149 | batch_norm_backward_reduce | NeuralNetwork | Alpha | 5.5 | aten, NoCPU, KernelGen | Triton kernel implementation for batch normalization backward reduce stage. |
| 150 | batch_norm_gather_stats | NeuralNetwork | Alpha | 5.5 | aten, NoCPU, KernelGen | Triton kernel implementation for gathering per-device batch normalization statistics into global mean and inverse standard deviation. |
| 151 | batch_norm_gather_stats_with_counts | NeuralNetwork | Alpha | 5.5 | aten, NoCPU, KernelGen | Triton kernel implementation for gathering per-device batch normalization statistics with per-segment counts into global mean and inverse standard deviation. |
| 152 | batch_norm_impl_index | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Applies Batch Normalization and returns the normalized output along with saved statistics, a reserve tensor, and the backend implementation index. |
| 153 | batch_norm_impl_index_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Backward pass dispatcher for _batch_norm_impl_index. Selects the
matching batch-norm backward backend (native / cudnn / miopen) from the
impl_index returned by the forward and produces the gradients with
respect to the input, weight and bias. |
| 154 | batch_norm_no_update | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Applies Batch Normalization using precomputed running statistics without updating running_mean/running_var. |
| 155 | batch_norm_stats | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Computes per-channel mean and inverse standard deviation for batch normalization. |
| 156 | batch_norm_update_stats | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for computing per-channel mean and invstd from input and updating running statistics. |
| 157 | batch_norm_with_update | NeuralNetwork | Alpha | 5.5 | KernelGen, aten | Applies training-mode Batch Normalization using batch statistics and updates running_mean/running_var in place. |
| 158 | batch_norm_with_update_functional | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Functional variant of _batch_norm_with_update that applies training-mode Batch Normalization and updates running statistics. |
| 159 | beam_search_score | Math | Alpha | 5.4 | KernelGen, fused | Computes beam search scores by adding cumulative log probabilities with new token scores. |
| 160 | beam_search_score_ | Math | Alpha | 5.4 | KernelGen, fused | In-place version of beam search score computation. |
| 161 | bernoulli | Tensor | Alpha | 5.4 | aten, KernelGen | Draws binary random numbers (0 or 1) from a Bernoulli distribution with per-element probabilities. |
| 162 | bernoulli_ | Tensor | Beta | 5.3 | aten, skip_precision_check, KernelGen | Draws binary random numbers (0 or 1) from a Bernoulli distribution. |
| 163 | bf16_paged_mqa_logits | NeuralNetwork | Alpha | 5.4 | fused, KernelGen | Compute multi-head weighted ReLU attention logits on paged BF16
KV cache. Uses shape-specialized Triton kernels for H=32 and H=64
with zero-constexpr dispatch for decode-phase inference. |
| 164 | bilinear | BLAS | Alpha | 5.4 | aten, KernelGen | Applies a bilinear transformation to the incoming data: y = x1^T A x2 + b. |
| 165 | binary_cross_entropy | NeuralNetwork | Alpha | 5.4 | aten, pointwise, nn.functional, KernelGen | Measures the binary cross entropy between the target and input probabilities,
with optional per-element weighting. |
| 166 | binary_cross_entropy_backward | Math | Alpha | 5.4 | aten, KernelGen | Computes the gradient of binary cross entropy loss with respect to the input, with optional per-element weight. |
| 167 | binary_cross_entropy_out | NeuralNetwork | Alpha | 5.4 | aten, pointwise, nn.functional, KernelGen | The out variant of binary_cross_entropy. Measures the binary cross entropy
between the target and input probabilities and writes the result to the
provided output tensor. |
| 168 | binary_cross_entropy_with_logits | NeuralNetwork | Alpha | 5.4 | nn.functional, KernelGen, aten | Compute the binary cross entropy loss with logits. |
| 169 | bincount | Reduction | Stable | 5.0 | aten, pointwise, KernelGen | Count the frequency of each value in an array of non-negative integers. |
| 170 | binomial | Math | Alpha | 5.4 | aten, KernelGen | Draws samples from a binomial distribution with the number of trials
given by count and the success probability given by prob. |
| 171 | binomial_out | Math | Alpha | 5.4 | aten, KernelGen | A variant of binomial() that writes the result into the out tensor. |
| 172 | bitwise_and_scalar | Math | Stable | 2.0 | aten, pointwise | Computes the bitwise AND of input and other scalar. |
| 173 | bitwise_and_scalar_ | Math | Stable | 2.2 | aten, pointwise | The in-place, scalar version of bitwise_and(). |
| 174 | bitwise_and_scalar_tensor | Math | Stable | 2.0 | aten, pointwise | A variant of bitwise_and(). |
| 175 | bitwise_and_tensor | Math | Stable | 2.0 | aten, pointwise | The Tensor method version of bitwise_and(). |
| 176 | bitwise_and_tensor_ | Math | Stable | 2.2 | aten, pointwise | The in-place, Tensor method version of bitwise_and(). |
| 177 | bitwise_left_shift | Math | Stable | 4.0 | aten, pointwise | Computes the left arithmetic shift of input by other bits. |
| 178 | bitwise_left_shift_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of bitwise_left_shift(). |
| 179 | bitwise_not | Math | Stable | 2.0 | aten, pointwise | Computes the bitwise NOT of the given input tensor. |
| 180 | bitwise_not_ | Math | Stable | 2.2 | aten, pointwise | The in-place version of bitwise_not(). |
| 181 | bitwise_or_scalar | Math | Stable | 2.0 | aten, pointwise | Computes the bitwise OR of scalars input and other. |
| 182 | bitwise_or_scalar_ | Math | Stable | 2.2 | aten, pointwise | The in-place version of bitwise_or_scalar. |
| 183 | bitwise_or_scalar_tensor | Math | Stable | 2.0 | aten, pointwise | Computes the bitwise OR of input and other. |
| 184 | bitwise_or_tensor | Math | Stable | 2.0 | aten, pointwise | Computes the bitwise OR of input and other, this is the Tensor method variant. |
| 185 | bitwise_or_tensor_ | Math | Stable | 2.2 | aten, pointwise | The in-place version of bitwise_or_tensor(). |
| 186 | bitwise_right_shift | Math | Stable | 4.0 | aten, pointwise | Computes the right arithmetic shift of input by other bits. |
| 187 | bitwise_right_shift_ | Math | Alpha | 5.4 | aten, KernelGen, pointwise | The in-place version of bitwise_right_shift(). |
| 188 | bitwise_xor_scalar | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the bitwise XOR of tensor input and scalar other. |
| 189 | bitwise_xor_scalar_ | Math | Alpha | 5.4 | aten, pointwise, KernelGen | The in-place version of bitwise_xor_scalar(). |
| 190 | bitwise_xor_scalar_tensor | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the bitwise XOR of scalar input and tensor other. |
| 191 | bitwise_xor_tensor | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the element-wise bitwise XOR of tensor input and tensor other. |
| 192 | bitwise_xor_tensor_ | Math | Alpha | 5.4 | aten, pointwise, KernelGen | The in-place version of bitwise_xor_tensor(). |
| 193 | blackman_window | Math | Alpha | 5.4 | aten, KernelGen | Computes the Blackman window function. |
| 194 | blackman_window_periodic | Math | Alpha | 5.4 | aten, KernelGen | A variant of blackman_window() that takes an explicit periodic flag. |
| 195 | block_diag | LinearAlg | Alpha | 5.4 | aten, KernelGen | Creates a block diagonal matrix from provided tensors. Each input tensor
forms a diagonal block in the output, with zeros elsewhere. |
| 196 | bmm | BLAS | Stable | 1.0 | aten | Performs a batch matrix-matrix product of matrices stored in input and mat2. |
| 197 | bmm_out | BLAS | Stable | 5.0 | aten | Performs a batch matrix-matrix product of matrices stored in input and mat2.
This is a variant of bmm with out specified. |
| 198 | bmm_w8a8_fp8 | BLAS | Alpha | 5.4 | NoCPU, Quantization | Performs batched matrix multiplication with block-wise FP8 E4M3
quantized activations and weights using FP32 accumulation. |
| 199 | broadcast_tensors | Tensor | Alpha | 5.4 | aten, KernelGen | Broadcasts the given tensors to a common shape according to broadcasting semantics, returning a list of tensors. |
| 200 | broadcast_to | Tensor | Alpha | 5.4 | aten, KernelGen | Broadcasts input to the shape size. Equivalent to calling input.expand(size). |
| 201 | bucket_sort_topk | NeuralNetwork | Beta | 5.3 | fused, DSA | A wrapper of the TLE version and the Triton version bucket-sort topk operation. |
| 202 | bucketize | Math | Alpha | 5.4 | aten, KernelGen | Returns the indices of the buckets to which each input value belongs. |
| 203 | cat | Tensor | Stable | 2.2 | aten | Concatenates the given sequence of tensors in tensors in the given dimension. |
| 204 | cat_out | Tensor | Stable | 2.2 | aten | A variant of cat that assigns the result to the provided out parameter. |
| 205 | cauchy | Distribution | Beta | 5.3 | aten | Draws random numbers from a Cauchy distribution. |
| 206 | cauchy_ | Distribution | Beta | 5.3 | aten | Fills the tensor with numbers drawn from the Cauchy distribution. |
| 207 | cdist | Math | Alpha | 5.4 | aten, KernelGen | Computes the p-norm distance between each pair of the two collections of row vectors.
This is the canonical user-facing API for cdist computation. |
| 208 | cdist_backward | Math | Alpha | 5.4 | aten, KernelGen | Computes the backward pass for the batched pairwise distance (cdist) computation,
computing the gradient with respect to the input tensors. |
| 209 | cdist_forward | Math | Alpha | 5.4 | aten, KernelGen | Computes the batched pairwise distance (cdist) between two collections of row vectors,
supporting p=2.0 (L2 norm). |
| 210 | ceil | Math | Stable | 5.0 | aten, pointwise | Returns a new tensor with the ceil of the elements of input, the smallest integer greater than
or equal to each element. |
| 211 | ceil_ | Math | Stable | 5.0 | aten, pointwise | The in-place version of ceil(). |
| 212 | ceil_out | Math | Stable | 5.0 | aten, pointwise | A variant of ceil() with out specified. |
| 213 | celu | NeuralNetwork | Stable | 4.0 | aten, nn.functional, pointwise | Applies the quantized CELU (Continuously Differentiable Exponential Linear Unit)
activation function element-wise. |
| 214 | celu_ | NeuralNetwork | Stable | 4.0 | aten, nn.functional, pointwise | The in-place version of celu(). |
| 215 | chalf | Math | Alpha | 5.4 | aten, KernelGen | Returns a copy of the tensor cast to the complex32 dtype. Real inputs are
down-cast to a complex tensor with zero imaginary part, and complex inputs have
both their real and imaginary components cast to half precision. |
| 216 | channel_shuffle | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Divides the channels into groups and rearranges each group. |
| 217 | cholesky_inverse | Math | Alpha | 5.4 | aten, KernelGen | Compute inverse of symmetric positive-definite matrix from Cholesky factor. |
| 218 | cholesky_solve | BLAS | Alpha | 5.4 | aten | Solves a system of linear equations with a symmetric positive-definite matrix
using its Cholesky factorization. |
| 219 | cholesky_solve_helper | Math | Alpha | 5.4 | aten, KernelGen | Solves a positive-definite linear system using its lower- or upper-triangular
Cholesky factor. |
| 220 | cholesky_solve_out | BLAS | Alpha | 5.4 | aten | Solves a system of linear equations with a symmetric positive-definite matrix
using its Cholesky factorization. |
| 221 | choose_qparams_optimized | Math | Alpha | 5.4 | aten, KernelGen | Chooses optimized quantization parameters (scale and zero-point) for a tensor
by searching candidate value ranges and selecting the pair that minimizes the
quantization error. |
| 222 | chunk | Math | Alpha | 5.4 | aten, KernelGen | Split a tensor into a specific number of chunks along a given dimension. |
| 223 | chunk_cat | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for _chunk_cat. |
| 224 | chunk_gated_delta_rule_fwd | Attention | Beta | 5.3 | fused, FLA | The forward case for ChunkGatedDeltaRuleFunction with Flash Linear Attention (FLA). |
| 225 | clamp | Math | Stable | 2.0 | aten, pointwise | Clamps all elements in input into the range [min, max]. |
| 226 | clamp_ | Math | Stable | 2.2 | aten, pointwise | The in-place version of clamp(). |
| 227 | clamp_max | Math | Alpha | 5.4 | aten, KernelGen, pointwise | Clamps all elements in input to be smaller or equal max. |
| 228 | clamp_max_ | Math | Alpha | 5.4 | aten, KernelGen, pointwise | The in-place version of clamp_max(). |
| 229 | clamp_min | Math | Stable | 4.0 | aten, pointwise | A variant of clamp() with min set to min. |
| 230 | clamp_min_ | Math | Stable | 4.0 | aten, pointwise | The in-place version of clamp_(). |
| 231 | clamp_tensor | Math | Stable | 2.0 | aten, pointwise | The tensor version of clamp(). |
| 232 | clamp_tensor_ | Math | Stable | 2.2 | aten, pointwise | The in-place, tensor version of clamp(). |
| 233 | clip | Math | Beta | 5.3 | aten, KernelGen | This is identical to clamp(). |
| 234 | clip_ | Math | Beta | 5.3 | aten, KernelGen | This is identical to clamp_(). |
| 235 | clone | Tensor | Alpha | 5.4 | KernelGen, aten, skip_precision_check | Pure layout/memory operation (clone). |
| 236 | coalesced_ | Tensor | Alpha | 5.4 | aten, KernelGen | Sets the coalesced flag of a sparse coordinate (COO) tensor in place
and returns self. This is a metadata-only mutation: the underlying
indices/values data is not modified, only the is_coalesced bit is
toggled. The flag flip is dispatched through the native backend kernel
(below the autograd key); a Triton identity kernel is provided over the
values data as the per-element implementation. |
| 237 | col2im | Math | Alpha | 5.3 | aten, KernelGen | Rearranges column blocks back into a multidimensional tensor (inverse of im2col). |
| 238 | col_indices | Tensor | Alpha | 5.5 | aten, KernelGen | Returns the column indices of a sparse compressed tensor as a zero-copy view. |
| 239 | column_stack | Tensor | Alpha | 5.4 | aten, KernelGen | Creates a new tensor by horizontally stacking the tensors in tensors. Equivalent to
torch.hstack after 0-D and 1-D tensors have been reshaped into (numel, 1) columns. |
| 240 | column_stack_out | Tensor | Alpha | 5.4 | aten, KernelGen | A variant of column_stack() that writes the result into the out tensor. |
| 241 | combine_topk_swa_indices | NeuralNetwork | Beta | 5.3 | fused, Attention, vLLM, DeepSeekV4 | Combines compressed top-k sparse attention indices with sliding-window attention indices
for DeepSeekV4 attention. |
| 242 | compute_global_topk_indices_and_lens | NeuralNetwork | Beta | 5.3 | fused, Attention, vLLM, DeepSeekV4 | Converts local top-k sparse attention indices to global KV-cache indices and computes
valid top-k lengths for DeepSeekV4 attention. |
| 243 | compute_linear_combination | BLAS | Alpha | 5.4 | aten, KernelGen | Computes a batched linear combination: given coefficients of shape
[m, n] and input of shape [n, ...], returns an output of shape
[m, ...] where output[i, ...] = sum_j coefficients[i, j] * input[j, ...]
(equivalent to coefficients @ input.flatten(1)). Backs the string-padding
form dispatched by torch._compute_linear_combination. |
| 244 | compute_linear_combination_out | BLAS | Alpha | 5.4 | aten, KernelGen | A variant of _compute_linear_combination() that writes the result into
the out tensor. |
| 245 | concat | Tensor | Alpha | 5.4 | aten, KernelGen | An alias of cat(). |
| 246 | concat_and_cache_mla | Attention | Beta | 3.0 | fused, MLA | Writes the latent and RoPE value into KV cache for Multi-head Latent Attention forward case. |
| 247 | concatenate | Tensor | Alpha | 5.3 | aten, KernelGen | An alias of cat(). |
| 248 | conj | Math | Alpha | 5.5 | aten, KernelGen | Computes the element-wise conjugate of a complex tensor. |
| 249 | conj_copy | Math | Alpha | 5.4 | aten, KernelGen | Computes the element-wise conjugate of a complex input tensor and
returns it as a new (copied) tensor. For non-complex tensors this op
is not supported. |
| 250 | conj_copy_out | Math | Alpha | 5.4 | aten, KernelGen | A variant of _conj_copy() that writes the result into the out tensor. |
| 251 | conj_physical | LinearAlg | Beta | 5.3 | aten | Computes the element-wise conjugate of the given input tensor.
If input has a non-complex dtype, this function just returns input. |
| 252 | conj_physical_ | LinearAlg | Alpha | 5.4 | aten | In-place version of conj_physical.
Computes the element-wise conjugate of the given input tensor in place.
If input has a non-complex dtype, this function just returns input. |
| 253 | constant_pad_nd | NeuralNetwork | Stable | 2.2 | aten, IR | Pads the input tensor boundaries with a constant value.
This is an IR representation, not a public API. |
| 254 | contiguous | Tensor | Removed | 4.1 | aten, skip_precision_check | Returns a contiguous in memory tensor containing the same data as self tensor. |
| 255 | conv1d | Convolution | Stable | 4.2 | aten | Applies a 1D convolution over a quantized 1D input composed of several input planes. |
| 256 | conv1d_padding | Convolution | Stable | 4.2 | aten | Applies a 1D convolution over a quantized 1D input composed of several input planes. |
| 257 | conv2d | Convolution | Stable | 4.2 | aten | Applies a 2D convolution over a quantized 2D input composed of several input planes. |
| 258 | conv2d_padding | Convolution | Stable | 4.2 | aten | Applies a 2D convolution over a quantized 2D input composed of several input planes. |
| 259 | conv3d | Convolution | Stable | 4.2 | aten | Applies a 3D convolution over a quantized 3D input composed of several input planes. |
| 260 | conv3d_padding | Convolution | Stable | 4.2 | aten | Applies a 3D convolution over a quantized 3D input composed of several input planes. |
| 261 | conv_depthwise2d | NeuralNetwork | Stable | 5.3 | aten, Convolution, NoCPU | A depthwise convolution for the conv2d neural network function. |
| 262 | conv_tbc | Math | Alpha | 5.4 | aten, KernelGen | Applies a 1D convolution over an input with time-batch-channel (T, B, C) layout. |
| 263 | conv_tbc_backward | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for conv_tbc_backward. |
| 264 | conv_tbc_out | Math | Alpha | 5.4 | aten, KernelGen | A variant of conv_tbc() that assigns the output to the given out parameter. |
| 265 | conv_transpose1d | Convolution | Beta | 5.3 | aten, KernelGen | Applies a 1D transposed convolution operator over an input image composed of several input planes. |
| 266 | conv_transpose2d | Convolution | Alpha | 5.3 | aten, KernelGen | Applies a 2D transposed convolution operator over an input image composed of several input planes. |
| 267 | conv_transpose3d | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Applies a 3D transposed convolution operator over an input volume composed of several input planes. |
| 268 | convert_weight_to_int4pack | Math | Alpha | 5.4 | aten, KernelGen | Converts a weight tensor to int4 packed format. |
| 269 | convolution_backward_overrideable | Convolution | Alpha | 5.5 | aten, KernelGen | Computes the gradients of a convolution with respect to the input, weight, and bias, returning (grad_input, grad_weight, grad_bias). |
| 270 | convolution_backward_overrideable_out | Convolution | Alpha | 5.5 | aten, KernelGen | A variant of convolution_backward_overrideable() that writes the result into the out tensors. |
| 271 | convolution_double_backward | Convolution | Alpha | 5.4 | aten, KernelGen | Second-order backward of a convolution, supporting both 1D (3-D operands
[N, C, L]) and 2D (4-D operands [N, C, H, W]) cases. Given the gradients of
the first-order gradients (ggI, ggW, ggb) and the output gradient (gO),
returns the gradients of the scalar <gX, ggI> + <gW, ggW> + <gB, ggb> with
respect to (gO, input, weight). The 2D path runs on Triton conv /
conv-transpose kernels plus a custom Triton weight-gradient correlation
kernel; 1D reuses the 2D path by unsqueezing the lone spatial axis
(mirroring how conv1d delegates to conv2d). 3D (5-D operands) is not
yet supported and raises NotImplementedError. |
| 272 | convolution_mode | Convolution | Alpha | 5.4 | aten, KernelGen | Low-level dispatcher backing the string-padding form of convolution.
Given an input, a weight, an optional bias, stride, a string padding mode
(valid or same), dilation and groups, it computes the N-D convolution
by dispatching to the FlagGems conv1d/conv2d/conv3d Triton kernels
based on the spatial dimensionality of the weight tensor. same padding
requires unit strides. |
| 273 | convolution_overrideable | Convolution | Alpha | 5.4 | aten, KernelGen | Generic overrideable convolution dispatch. Infers the spatial rank from
the weight tensor and routes to the FlagGems Triton convolution kernels
(forward conv2d im2col kernel and transposed conv variants), supporting
stride, padding, dilation, transposed, output_padding and groups. |
| 274 | convolution_overrideable_out | Convolution | Alpha | 5.4 | aten, KernelGen | A variant of convolution_overrideable() that writes the result into the out tensor. |
| 275 | copy | Tensor | Stable | 5.3 | aten, pointwise | As a wrapper of copy_, this operator copies elements from src to out
using given template for shapes. |
| 276 | copy_ | Tensor | Stable | 4.1 | aten, pointwise, skip_precision_check | Copies the elements from src into self tensor and returns self. |
| 277 | copysign | Tensor | Beta | 5.3 | aten, pointwise | Create a new floating-point tensor with the magnitude of input and the sign of other, elementwise. |
| 278 | copysign_ | Math | Alpha | 5.3 | aten, KernelGen | Triton kernel implementation for copysign_. |
| 279 | copysign_out | Tensor | Beta | 5.3 | aten, pointwise | A variant of copysign that allows the output to be saved into out. |
| 280 | corrcoef | Reduction | Alpha | 5.4 | aten, KernelGen | Estimates the Pearson product-moment correlation coefficient matrix of the
variables given by the input matrix, where rows are the variables and
columns are the observations. The correlation matrix R is computed from
the covariance matrix C as R_ij = C_ij / sqrt(C_ii * C_jj), with the
internal computation carried out in float32 for numerical stability. |
| 281 | cos | Math | Stable | 2.0 | aten, pointwise | Returns a new tensor with the cosine of the elements of input given in radians. |
| 282 | cos_ | Math | Stable | 2.2 | aten, pointwise | The in-place version of cos(). |
| 283 | cosh | Math | Stable | 5.3 | aten, pointwise | Returns a new tensor with the hyperbolic cosine of the elements of input. |
| 284 | cosh_ | Math | Stable | 5.3 | aten, pointwise | This is the in-place version of cosh(). |
| 285 | cosh_out | Math | Stable | 5.3 | aten, pointwise | This is an variant of cosh() that assigns the output to the provided out. |
| 286 | cosine_embedding_loss | NeuralNetwork | Alpha | 5.4 | aten, nn.functional, KernelGen | Compute the cosine embedding loss. |
| 287 | cosine_similarity | Reduction | Alpha | 5.5 | aten, nn.functional, KernelGen | Computes the cosine similarity between x1 and x2 along dim, broadcasting the
inputs to a common shape first. Returns <x1, x2> / (max(||x1||_2, eps) *
max(||x2||_2, eps)) reduced over dim, with eps guarding against zero norms. |
| 288 | count_nonzero | Tensor | Stable | 2.2 | aten, Reduction | 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. |
| 289 | cov | Reduction | Alpha | 5.4 | aten, KernelGen | Estimates the covariance matrix of the variables given by the input
matrix, where rows are the variables and columns are the observations.
Supports Bessel's correction and optional frequency/analytic observation
weights, with the internal computation carried out in float32 for
numerical stability. |
| 290 | cp_gather_indexer_k_quant_cache | Quantization | Beta | 5.3 | fused, vLLM | This is a fused operator that gathers FP8 K cache values and scales. |
| 291 | cross | LinearAlg | Alpha | 5.5 | aten | Computes the cross product of two 3-dimensional vectors along a dimension of size 3. |
| 292 | cross_attention | NeuralNetwork | Alpha | 5.5 | Attention, NoCPU | Forward-only dense cross attention over BNSD tensors: computes softmax(scale * Q @ K^T) @ V with an optional bool/uint8 mask whose non-zero entries block the corresponding key. Supports MHA, GQA and MQA, and a value head dimension smaller than the query/key head dimension. |
| 293 | cross_entropy_loss | NeuralNetwork | Removed | 3.0 | fused, Reduction | Computes the cross entropy loss between input logits and target. |
| 294 | cross_out | LinearAlg | Alpha | 5.5 | aten | A variant of cross that allows the output to be assigned to out. |
| 295 | crow_indices_copy | Tensor | Alpha | 5.5 | aten, KernelGen | Returns a fresh copy of the crow (row) indices of a sparse compressed tensor, mirroring aten::crow_indices_copy. |
| 296 | cslt_sparse_mm | Tensor | Alpha | 5.5 | aten, NoCPU, KernelGen | Triton implementation of aten._cslt_sparse_mm; decodes the cuSPARSELt 2:4 structured-sparse compressed blob back to dense and runs a tiled dense matmul, supporting alpha, bias, and transpose_result. The compressed layout is architecture specific, so this decoder targets the Hopper swizzle and is only registered on compute capability 9.x; other architectures keep using the native cuSPARSELt op. |
| 297 | ctc_loss | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Connectionist Temporal Classification loss for sequence-to-sequence models. |
| 298 | ctc_loss_backward | NeuralNetwork | Beta | 5.4 | aten, KernelGen | The backward computation of ctc_loss(), exercised through the autograd of the forward operator. |
| 299 | cudnn_attention_backward | NeuralNetwork | Alpha | 5.4 | aten, NoCPU, KernelGen | Backward kernel for cuDNN attention, computing gradients of query,
key, and value from the cuDNN attention forward pass. Uses a BHSD-native two-kernel design that eliminates the BHSD-BSHD permute+contiguous overhead. |
| 300 | cudnn_attention_forward | NeuralNetwork | Beta | 5.5 | aten, NoCPU | Forward kernel for cuDNN attention, computing scaled dot-product
attention outputs and log-sum-exp statistics. Uses a Triton
FlashAttention-2 kernel in BHSD layout. |
| 301 | cudnn_batch_norm_backward | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for cudnn_batch_norm_backward. |
| 302 | cudnn_convolution | NeuralNetwork | Beta | 5.3 | aten, KernelGen | A wrapper for cuDNN convolution backend. |
| 303 | cudnn_convolution_transpose | Math | Alpha | 5.4 | aten, KernelGen | Wrapper for torch.cudnn_convolution_transpose, providing autograd support and device-agnostic interface for cuDNN transposed convolution. |
| 304 | cudnn_rnn | NeuralNetwork | Alpha | 5.4 | aten, NoCPU, KernelGen | Vendor-agnostic RNN forward pass using Triton kernels that replaces the cuDNN-backed _cudnn_rnn operator. Supports RNN_RELU, RNN_TANH, LSTM and GRU modes with multi-layer, bidirectional, LSTM projection (proj_size > 0), dropout during training, and packed variable-length sequences. |
| 305 | cudnn_rnn_backward | Math | Alpha | 5.4 | aten, NoCPU, KernelGen | Backward pass of a single-layer unidirectional cuDNN LSTM. Reimplements the
RNN forward in pure PyTorch and applies autograd to compute gradients,
avoiding the opaque cuDNN reserve tensor. |
| 306 | cummax | Math | Stable | 3.0 | aten, Reduction | Returns a named tuple (values, indices) where values is the cumulative maximum of elements
of input in the dimension dim. And indices is the index location of each maximum value
found in the dimension dim. |
| 307 | cummax_helper | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for _cummax_helper, the out-of-place helper used
by aten::cummax / aten::cummax.out. It writes the cumulative maximum of
elements of input along dim into the pre-allocated values tensor and the
index location of each maximum value into the pre-allocated indices tensor. |
| 308 | cummaxmin_backward | Math | Alpha | 5.4 | aten, Reduction | Backward pass shared by cummax and cummin. Scatter-adds the output gradient back to the
input positions selected during the forward pass (given by indices), accumulating in
float32 for numerical stability. Equivalent to grad_input.scatter_add_(dim, indices, grad_output). |
| 309 | cummin | Math | Stable | 2.2 | aten, Reduction | Returns a named tuple (values, indices) where values is the cumulative minimum of elements
of input in the dimension dim. And indices is the index location of each minimum value
found in the dimension dim. |
| 310 | cummin_helper | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for _cummin_helper, the out-of-place helper used
by aten::cummin / aten::cummin.out. It writes the cumulative minimum of
elements of input along dim into the pre-allocated values tensor and the
index location of each minimum value into the pre-allocated indices tensor. |
| 311 | cumprod | Math | Beta | 5.3 | aten, Reduction | Returns the cumulative product of elements of input in the dimension dim. |
| 312 | cumprod_ | Math | Beta | 5.3 | aten, Reduction | This is the in-place version of cumprod(). |
| 313 | cumprod_backward | Math | Alpha | 5.5.0 | aten, Reduction | Backward pass for cumprod. Given the output gradient, the forward input and the forward
output, computes the gradient with respect to the input. Zero elements along the reduction
dimension are handled explicitly: the reverse cumulative sum of grad * output divided by
input gives the gradient for non-zero positions, while the first zero position uses a
modified cumulative product. Accumulation is performed in float32 for numerical stability. |
| 314 | cumsum | LinearAlg | Stable | 1.0 | aten | Returns the cumulative sum of elements of input in the dimension dim. |
| 315 | cumsum_ | Reduction | Alpha | 5.4 | aten, KernelGen | In-place version of cumsum. |
| 316 | cumsum_out | Reduction | Stable | 3.0 | aten | Returns the cumulative sum of elements of input in the dimension dim.
It is a variant of cumsum(). |
| 317 | cumulative_trapezoid | Reduction | Alpha | 5.4 | aten, KernelGen | Cumulatively integrate y using the composite trapezoidal rule with uniform spacing dx along the given dimension. |
| 318 | cutlass_scaled_mm | LinearAlg | Beta | 5.0 | fused, vLLM | |
| 319 | deg2rad | Math | Alpha | 5.4 | aten, KernelGen | Converts angles from degrees to radians. |
| 320 | deg2rad_ | Math | Alpha | 5.4 | aten, KernelGen | In-place version of deg2rad. |
| 321 | deg2rad_out | Math | Alpha | 5.4 | aten, KernelGen | Out-of-place variant of deg2rad with pre-allocated output tensor. |
| 322 | dequantize | Math | Alpha | 5.4 | aten, KernelGen | Returns an fp32 Tensor by dequantizing a quantized Tensor. |
| 323 | dequantize_and_gather_k_cache | NeuralNetwork | Beta | 5.3 | fused, Attention, vLLM, DeepSeekV4 | Dequantizes FP8 K-cache entries and gathers them into a BF16 tensor for DeepSeekV4 attention. |
| 324 | det | LinearAlg | Alpha | 5.5 | aten, KernelGen | Computes the determinant of a square matrix via LU decomposition with partial pivoting. Equivalent to linalg.det. |
| 325 | detach_copy | Tensor | Alpha | 5.5 | aten, KernelGen | Returns a tensor with the same values as self in freshly allocated memory, detached from the autograd graph (equivalent to self.detach().clone()). |
| 326 | dgeglu | NeuralNetwork | Stable | 5.0 | fused, Transformer | Gaussian Error Gated Linear Unit with GELU activation instead of sigmoid function.
This is for the backward case. |
| 327 | diag | Tensor | Stable | 2.2 | aten | - If
input is a vector (1-D tensor), then returns a 2-D square tensor
with the elements of input as the diagonal. - If
input is a matrix (2-D tensor), then returns a 1-D tensor
with the diagonal elements of input.
|
| 328 | diag_embed | Tensor | Stable | 2.2 | aten, pointwise | Creates a tensor whose diagonals of certain 2D planes (specified by dim1 and dim2) are filled by input.
To facilitate creating batched diagonal matrices, the 2D planes formed by the last two dimensions
of the returned tensor are chosen by default. |
| 329 | diagonal_backward | LinearAlg | Stable | 2.2 | aten, pointwise | A diagonal operation returns a partial view of input with the its diagonal elements
with respect to dim1 and dim2 appended as a dimension at the end of the shape.
This is the backward case for diagonal(). |
| 330 | diagonal_copy | Tensor | Alpha | 5.4 | aten, KernelGen | Performs the same operation as torch.diagonal, but all output tensors
are freshly created instead of aliasing the input. |
| 331 | diagonal_scatter | Math | Alpha | 5.4 | aten, KernelGen | Scatter source values into the diagonal of a tensor with optional offset. |
| 332 | diff | Math | Beta | 5.3 | aten, KernelGen | Computes the n-th forward difference along the given dimension. |
| 333 | digamma | Math | Alpha | 5.3 | aten, KernelGen | Computes the digamma function, which is the logarithmic derivative of the Gamma function. |
| 334 | digamma_ | Math | Stable | 5.3 | aten, KernelGen | Computes the in-place digamma function, which is the logarithmic derivative of the Gamma function. |
| 335 | dim | Tensor | Alpha | 5.5 | aten, KernelGen | Returns the number of dimensions (rank) of a tensor: a pure metadata query independent of layout, dtype and stored data. |
| 336 | dirichlet_grad | Math | Alpha | 5.5 | aten, NoCPU, KernelGen | Computes the reparameterized-gradient of the Dirichlet distribution with respect
to its concentration parameters, used by torch.distributions.Dirichlet autograd. |
| 337 | dispatch_fused_moe_kernel | MoE | Stable | 5.3 | fused, Activation, vLLM | Accelerates neural network training by combining token routing (dispatch/all-to-all communication),
expert computation (GEMM), and result aggregation into a single GPU kernel. |
| 338 | dist | Math | Alpha | 5.4 | aten, Reduction | Computes the p-norm distance between two tensors. |
| 339 | div_mode | Math | Stable | 1.0 | aten, pointwise | Divides each element of the input by the corresponding element of other.
An optional rounding_mode can be specified. |
| 340 | div_mode_ | Math | Stable | 2.2 | aten, pointwise | The in-place version of div_mode(). |
| 341 | div_out | Math | Stable | 4.2 | aten | This is an variant of div() with an out argument. |
| 342 | div_scalar | Math | Stable | 2.1 | aten | This is the scalar version of div(). |
| 343 | div_scalar_ | Math | Stable | 2.1 | aten | This is the in-place version of div_scalar(). |
| 344 | div_tensor | Math | Stable | 2.1 | aten, pointwise | Divides each element of the input input by the corresponding element of other.
Note that torch.divide() is an alias of torch.div() and torch.true_divide()
is an alias of torch.div() with rounding_mode=None. |
| 345 | div_tensor_ | Math | Stable | 2.1 | aten | This is the in-place version of div_tensor(). |
| 346 | divide | Math | Alpha | 5.4 | aten, pointwise, KernelGen | An alias of div() for element-wise division. |
| 347 | dot | BLAS | Stable | 3.0 | aten | Computes the dot product of two 1D tensors. |
| 348 | dreglu | NeuralNetwork | Beta | 5.3 | fused, Transformer | Rectified Gated Linear Unit is a variant of GLU that uses ReLU instead of
the sigmoid function for gating. This is the backward case. |
| 349 | dropout | NeuralNetwork | Stable | 1.0 | aten, nn.functional | An internal IR for implementing torch.nn.functional.dropout. |
| 350 | dropout_ | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | The in-place version of dropout (aten::dropout_). |
| 351 | dsplit | Tensor | Alpha | 5.4 | aten, KernelGen, skip_precision_check | Split a tensor along the third axis (depth-wise). Pure layout operation returning zero-copy views. |
| 352 | dstack | Tensor | Alpha | 5.5 | aten, KernelGen | Stack tensors in sequence depth wise (along the third axis). Inputs are promoted with atleast_3d first, so 1-D and 2-D tensors each contribute a single depth slot. |
| 353 | dswiglu | NeuralNetwork | Beta | 5.3 | fused, Transformer | Swish-Gated Linear Unit, a variant of GLU with the Swish activation function.
This is for the backward case. |
| 354 | dyn_quant_matmul_4bit | BLAS | Alpha | 5.4 | aten | Dynamic per-row INT8 activation and signed INT4 weight matrix multiplication. |
| 355 | dyn_quant_pack_4bit_weight | Tensor | Alpha | 5.4 | aten, KernelGen | Packs dynamic 4-bit quantized weights, scale/zero values, and optional bias
into ATen's portable packed representation. |
| 356 | efficient_attention_backward | NeuralNetwork | Beta | 5.4 | aten, NoCPU | Backward kernel for FlashAttention, computing gradients of queries, keys, values, and attention outputs efficiently. |
| 357 | einsum | Reduction | Alpha | 5.3 | aten, KernelGen | Sums the product of the elements of the input operands along dimensions specified using a notation
based on the Einstein summation convention. |
| 358 | elu | NeuralNetwork | Stable | 2.2 | aten, nn.functional, pointwise | Apply the Exponential Linear Unit (ELU) function element-wise. |
| 359 | elu_ | NeuralNetwork | Stable | 4.0 | aten, pointwise | The in-place version of elu(). |
| 360 | elu_backward | NeuralNetwork | Stable | 4.0 | aten, pointwise | The backward version of elu(). |
| 361 | embedding | NeuralNetwork | Stable | 2.1 | aten, nn.functional | Generate a simple lookup table that looks up embeddings in a fixed dictionary and size.
Note that the parameter sequence differs from torch.nn.functional.embedding. |
| 362 | embedding_backward | NeuralNetwork | Stable | 3.0 | aten, NoCPU | The backward version of embedding(). |
| 363 | embedding_bag | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Compute sums, means, or maxes of bags of embeddings, without instantiating the intermediate embeddings. |
| 364 | embedding_bag_dense_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Computes the gradient for the backward pass of embedding_bag in dense mode. |
| 365 | embedding_bag_per_sample_weights_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for _embedding_bag_per_sample_weights_backward. |
| 366 | embedding_bag_sparse_backward | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Computes the sparse (COO) gradient for the backward pass of embedding_bag. |
| 367 | embedding_dense_backward | NeuralNetwork | Stable | 5.0 | aten, NoCPU | Calculates the gradient of the weight matrix for a dense embedding layer during backpropagation. |
| 368 | embedding_renorm_ | Math | Alpha | 5.4 | aten, KernelGen | In-place renormalization of the embedding rows selected by indices: each indexed row whose norm_type-norm exceeds max_norm is scaled down so its norm equals max_norm. |
| 369 | embedding_sparse_backward | NeuralNetwork | Alpha | 5.5 | aten, KernelGen, NoCPU | Calculates the sparse gradient of the weight matrix for an embedding
layer during backpropagation, returning an uncoalesced sparse COO tensor. |
| 370 | empty | Tensor | Alpha | 5.4 | aten, KernelGen, skip_precision_check | Tensor factory operator — verifies dtype inference for newly allocated tensors. |
| 371 | empty_permuted | Tensor | Alpha | 5.4 | aten, KernelGen, skip_precision_check | Tensor factory operator — allocates an uninitialized tensor whose memory
follows the given physical layout. |
| 372 | eq | Math | Stable | 2.0 | aten, pointwise | Computes element-wise equality. |
| 373 | eq_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of eq(). |
| 374 | eq_scalar | Math | Stable | 2.0 | aten, pointwise | Computes equality between scalars. |
| 375 | eq_scalar_ | Math | Alpha | 5.4 | aten, KernelGen | The scalar version of eq_(). |
| 376 | equal | Math | Stable | 5.0 | aten, Reduction | Returns True if two tensors have the same size and elements, False otherwise. |
| 377 | erf | Science | Stable | 2.1 | aten, pointwise | Computes the error function of input. |
| 378 | erf_ | Science | Stable | 2.2 | aten, pointwise | The in-place version of erf(). |
| 379 | erfc | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the complementary error function. |
| 380 | erfc_ | Math | Alpha | 5.4 | aten, pointwise, KernelGen | In-place version of erfc. |
| 381 | erfinv | Math | Alpha | 5.4 | aten, KernelGen | Computes the inverse error function of input. |
| 382 | erfinv_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of erfinv(). |
| 383 | euclidean_dist | Math | Alpha | 5.3 | aten, KernelGen, pointwise | Computes pairwise Euclidean distances between rows of two 2D tensors. |
| 384 | exp | Math | Stable | 1.0 | aten, pointwise | Returns a new tensor with the exponential of the elements of the input tensor input. |
| 385 | exp2 | Math | Stable | 4.0 | aten, pointwise | Computes the base two exponential function of input. |
| 386 | exp2_ | Math | Stable | 4.0 | aten, pointwise | The in-place version of exp2(). |
| 387 | exp_ | Math | Stable | 2.2 | aten, pointwise | The in-place version of exp(). |
| 388 | exp_out | Math | Stable | 4.1 | aten, pointwise | A variant of exp2(), with out specified. |
| 389 | expand | Tensor | Alpha | 5.4 | aten, KernelGen, skip_precision_check | Pure layout operation (expand). |
| 390 | expand_ | Tensor | Alpha | 5.4 | aten, KernelGen, skip_precision_check | Pure layout operation (expand, in-place). |
| 391 | expand_as | Math | Alpha | 5.4 | aten, KernelGen | Expand tensor to the same size as another tensor (view operation). |
| 392 | expand_copy | Math | Alpha | 5.4 | aten, KernelGen | Returns a copy of the input tensor expanded by broadcasting singleton dimensions. |
| 393 | expm1 | Math | Beta | 5.3 | aten | Computes the exponential of the elements minus 1 of input. |
| 394 | expm1_ | Math | Beta | 5.3 | aten | The inplace version of expm1. |
| 395 | expm1_out | Math | Beta | 5.3 | aten | A variant of expm1 that saves the output to the specified out. |
| 396 | exponential | Distribution | Alpha | 5.4 | aten, skip_precision_check | Returns a new tensor with elements drawn from an exponential PDF (probability density function). |
| 397 | exponential_ | Distribution | Stable | 2.1 | aten, skip_precision_check | Fills self tensor with elements drawn from a PDF (probability density function). |
| 398 | eye | LinearAlg | Stable | 3.0 | aten, Reduction | Returns a 2-D tensor with ones on the diagonal and zeros elsewhere. |
| 399 | eye_m | LinearAlg | Stable | 3.0 | aten, Reduction | Triton-based implementation of torch.eye_m(n, m), using 2D tiles to split the matrix into blocks. |
| 400 | fake_quantize_learnable_per_channel_affine | Math | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for _fake_quantize_learnable_per_channel_affine,
the per-channel fake-quantize affine operator with learnable scale and zero point. |
| 401 | fake_quantize_learnable_per_channel_affine_backward | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for _fake_quantize_learnable_per_channel_affine_backward,
the backward of learnable per-channel fake quantization. Computes the gradients
with respect to the input, scale and zero-point, accounting for the saturation
branch where the quantized value is clamped to [quant_min, quant_max]. |
| 402 | fake_quantize_learnable_per_tensor_affine | Math | Alpha | 5.4 | aten, KernelGen, pointwise | Fake-quantizes the input tensor per-tensor with learnable scale and zero_point. |
| 403 | fake_quantize_learnable_per_tensor_affine_backward | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for the backward pass of learnable
per-tensor affine fake quantization. Computes gradients with respect to
the input, scale, and zero-point. |
| 404 | fake_quantize_per_channel_affine | Quantization | Alpha | 5.4 | aten, pointwise, KernelGen | Applies fake quantization per channel with affine parameters (scale and zero_point). |
| 405 | fake_quantize_per_channel_affine_cachemask | Quantization | Alpha | 5.4 | aten, pointwise, KernelGen | Applies per-channel affine fake quantization and returns the quantization-range mask. |
| 406 | fake_quantize_per_channel_affine_cachemask_backward | Quantization | Alpha | 5.4 | aten, pointwise, KernelGen | Applies the cache mask to the gradient of per-channel affine fake quantization. |
| 407 | fake_quantize_per_channel_affine_cachemask_out | Quantization | Alpha | 5.4 | aten, pointwise, KernelGen | A variant of fake_quantize_per_channel_affine_cachemask that assigns the results to the provided output tensors. |
| 408 | fake_quantize_per_tensor_affine | Quantization | Alpha | 5.4 | aten, pointwise, KernelGen | Applies per-tensor affine fake quantization using shared scale and zero-point parameters. |
| 409 | fake_quantize_per_tensor_affine_cachemask | Quantization | Alpha | 5.5 | aten, pointwise, KernelGen | Applies per-tensor affine fake quantization and returns the quantized output with its unclamped-range mask. |
| 410 | fake_quantize_per_tensor_affine_cachemask_backward | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the gradient for fake_quantize_per_tensor_affine_cachemask by multiplying the incoming
gradient by the cached boolean mask. |
| 411 | fake_quantize_per_tensor_affine_cachemask_out | Quantization | Alpha | 5.5 | aten, pointwise, KernelGen | A variant of fake_quantize_per_tensor_affine_cachemask that assigns the results to the provided output tensors. |
| 412 | fake_quantize_per_tensor_affine_cachemask_tensor_qparams | Math | Alpha | 5.4 | aten, KernelGen | Fake-quantizes input per-tensor with affine mapping given by scale and
zero_point, clamping the quantized integer into [quant_min, quant_max],
and returns both the dequantized output and a boolean mask indicating which
elements fell inside the quantized range. |
| 413 | feature_alpha_dropout | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Applies alpha dropout independently to each feature map, preserving the self-normalizing properties of SELU activations. |
| 414 | feature_alpha_dropout_ | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Applies feature alpha dropout to the input tensor in-place while preserving the self-normalizing properties of SELU activations. |
| 415 | feature_dropout | NeuralNetwork | Alpha | 5.3 | aten, KernelGen | Applies feature dropout to the input tensor. Randomly zeroes out entire channels of the input tensor with probability p.
Each batch element has its own independent channel mask. |
| 416 | feature_dropout_ | NeuralNetwork | Alpha | 5.3 | aten, KernelGen | The in-place version of feature_dropout(). |
| 417 | fft_irfftn | Math | Alpha | 5.4 | aten, KernelGen | Computes the N-dimensional inverse of torch.fft.rfftn. |
| 418 | fill_diagonal_ | Tensor | Alpha | 5.4 | aten, pointwise, KernelGen | Fills the main diagonal of a tensor that has at least two dimensions
with the specified scalar value, in-place. |
| 419 | fill_mem_eff_dropout_mask_ | NeuralNetwork | Alpha | 5.4 | aten, NoCPU, KernelGen | Triton kernel implementation for _fill_mem_eff_dropout_mask_, the in-place
helper used by the memory efficient attention dropout path. It fills a
contiguous 4D float32 tensor of shape (batch, heads, queries, keys) with
random uniform values in [0, 1) drawn from a Philox4x32-10 stream
identified by seed and offset. |
| 420 | fill_scalar | Tensor | Stable | 2.2 | aten, pointwise | Fills a scalar with the specified value. |
| 421 | fill_scalar_ | Tensor | Stable | 2.2 | aten, pointwise | The in-place version of fill_scalar(). |
| 422 | fill_scalar_out | Tensor | Stable | 5.0 | aten, pointwise, KernelGen | A variant of fill_scalar() that assigns the output to an out tensor. |
| 423 | fill_tensor | Tensor | Stable | 2.2 | aten, pointwise | Fills a tensor with the specified value. |
| 424 | fill_tensor_ | Tensor | Stable | 2.2 | aten, pointwise | The in-place version of fill_tensor(). |
| 425 | fill_tensor_out | Tensor | Stable | 5.0 | aten, pointwise, KernelGen | A variant of fill_tensor() that assigns the output to an out tensor. |
| 426 | fix | Math | Alpha | 5.4 | aten, KernelGen | fix operator |
| 427 | fix_ | Math | Alpha | 5.4 | aten, KernelGen | In-place version of fix. Truncates each element toward zero
(floor for non-negative values, ceil for negative values).
Integer tensors are left unchanged. |
| 428 | flash_attention_backward | NeuralNetwork | Beta | 5.4 | aten, NoCPU | Backward kernel for FlashAttention, computing gradients of queries, keys, values, and attention outputs efficiently. |
| 429 | flash_attention_forward | NeuralNetwork | Stable | 3.0 | aten, NoCPU | |
| 430 | flash_attn_varlen_func | NeuralNetwork | Stable | 3.1 | aten, Attention, FlashAttention | Compute attention for sequences of variable lengths within a single batch.
Eliminating the need for padding. |
| 431 | flash_attn_varlen_opt_func | NeuralNetwork | Beta | 5.3 | aten, Attention, FlashAttention | A variant of flash_attn_varlen_func that has lse as an optional parameter. |
| 432 | flash_mla | NeuralNetwork | Stable | 3.0 | fused, Attention, vLLM | A variant of Multi-head Latent Attention (MLA). |
| 433 | flash_mla_sparse_fwd | NeuralNetwork | Alpha | 5.3 | fused, Attention, vLLM | Part of the FlashMLA. |
| 434 | flatten | Math | Alpha | 5.4 | aten, KernelGen | Flatten a contiguous range of dimensions into a single dimension (view operation). |
| 435 | flip | Tensor | Stable | 2.1 | aten, pointwise | Reverse the order of an n-D tensor along given axis in dims. |
| 436 | fliplr | Tensor | Alpha | 5.4 | aten, pointwise, KernelGen | Flips a tensor in the left-to-right direction by reversing dimension 1.
The input must have at least two dimensions. |
| 437 | flipud | Tensor | Alpha | 5.4 | aten, pointwise, KernelGen | Flips a tensor in the up-to-down direction by reversing dimension 0.
The input must have at least one dimension. |
| 438 | float_power_ | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for float_power_. |
| 439 | float_power_scalar_tensor | Math | Alpha | 5.4 | aten, KernelGen | Computes a scalar base raised element-wise to tensor exponents in float64. |
| 440 | float_power_scalar_tensor_out | Math | Alpha | 5.4 | aten, KernelGen | Out variant of float_power.Scalar. |
| 441 | float_power_tensor_scalar | Math | Alpha | 5.4 | aten, KernelGen | Raises tensor elements to a scalar exponent in float64. |
| 442 | float_power_tensor_scalar_out | Math | Alpha | 5.4 | aten, KernelGen | Out variant of float_power.Tensor_Scalar. |
| 443 | float_power_tensor_tensor | Math | Alpha | 5.4 | aten, KernelGen | Raises tensor elements to tensor exponents in float64 with broadcasting. |
| 444 | float_power_tensor_tensor_out | Math | Alpha | 5.4 | aten, KernelGen | Out variant of float_power.Tensor_Tensor. |
| 445 | floor | Math | Stable | 5.3 | aten, KernelGen | Performs an element-wise floor operation, rounding each element of a tensor
down to the nearest integer less than or equal to itself. |
| 446 | floor_ | Math | Stable | 5.3 | aten, KernelGen | Performs an in-place element-wise floor operation, rounding each element of a tensor
down to the nearest integer less than or equal to itself. |
| 447 | floor_divide_scalar | Math | Stable | 2.1 | aten | Computes input divided by other, elementwise, and floors the result. |
| 448 | floor_divide_scalar_ | Math | Stable | 2.2 | aten | Computes input divided by other, elementwise, and floors the result. |
| 449 | floor_divide_tensor | Math | Stable | 2.1 | aten | Computes input divided by other, elementwise, and floors the result. |
| 450 | floor_divide_tensor_ | Math | Stable | 2.2 | aten | Computes input divided by other, elementwise, and floors the result. |
| 451 | floor_out | Math | Stable | 5.3 | aten, KernelGen | Performs an element-wise floor operation with output tensor, rounding each element
down to the nearest integer less than or equal to itself. |
| 452 | fmax | Math | Alpha | 5.4 | aten, KernelGen | Computes the element-wise maximum of input and other, ignoring NaNs. |
| 453 | fmax_out | Math | Alpha | 5.4 | aten, KernelGen | Computes the element-wise maximum of input and other, ignoring NaNs (out variant). |
| 454 | fmin | Math | Stable | 5.3 | aten, KernelGen | Computes the element-wise minimum of two tensors, specially handling NaN values
by prioritizing the numerical value. Unlike minimum(), if one input is NaN and the other is a number,
fmin() returns the number. It supports broadcasting, type promotion, and operates on both CPU and GPU. |
| 455 | fmin_out | Math | Stable | 5.3 | aten, KernelGen | A variant of fmin() that assigns the output to the out tensor. |
| 456 | fmod_ | Math | Alpha | 5.4 | aten, KernelGen | In-place remainder of division (fmod_), computes element-wise remainder with truncation toward zero. |
| 457 | fmod_scalar | Math | Alpha | 5.3 | aten, KernelGen | Computes the element-wise remainder of division of input by a scalar divisor. |
| 458 | fmod_scalar_ | Math | Alpha | 5.3 | aten, KernelGen | In-place version of fmod with a scalar divisor. |
| 459 | fmod_tensor | Math | Alpha | 5.3 | aten, KernelGen | Computes the element-wise remainder of division of input by a tensor divisor. |
| 460 | fmod_tensor_ | Math | Alpha | 5.3 | aten, KernelGen | In-place version of fmod with a tensor divisor. |
| 461 | foreach_abs | PointWise | Alpha | 5.4 | aten, KernelGen | Apply absolute value to each tensor in a list. |
| 462 | foreach_abs_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place absolute value for each tensor in a list. |
| 463 | foreach_acos | PointWise | Alpha | 5.4 | aten, KernelGen | Apply arccosine to each tensor in a list. |
| 464 | foreach_acos_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place arccosine for each tensor in a list. |
| 465 | foreach_add_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise addition for each tensor in a list, paired with a second tensor list. |
| 466 | foreach_add_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise addition for each tensor in a list, paired with a second tensor list. |
| 467 | foreach_add_scalar | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise addition for each tensor in a list, against a single scalar. |
| 468 | foreach_add_scalar_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise addition for each tensor in a list, against a single scalar. |
| 469 | foreach_add_scalar_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise addition for each tensor in a list, against one scalar per tensor. |
| 470 | foreach_add_scalar_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise addition for each tensor in a list, against one scalar per tensor. |
| 471 | foreach_add_tensor | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise addition for each tensor in a list, against a broadcast tensor. |
| 472 | foreach_add_tensor_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise addition for each tensor in a list, against a broadcast tensor. |
| 473 | foreach_addcdiv_scalar | PointWise | Alpha | 5.4 | aten, KernelGen | add the element-wise quotient of two tensors, scaled for each tensor in a list, against a single scalar. |
| 474 | foreach_addcdiv_scalar_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place add the element-wise quotient of two tensors, scaled for each tensor in a list, against a single scalar. |
| 475 | foreach_addcdiv_scalar_list | PointWise | Alpha | 5.4 | aten, KernelGen | add the element-wise quotient of two tensors, scaled for each tensor in a list, against one scalar per tensor. |
| 476 | foreach_addcdiv_scalar_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place add the element-wise quotient of two tensors, scaled for each tensor in a list, against one scalar per tensor. |
| 477 | foreach_addcdiv_tensor | PointWise | Alpha | 5.4 | aten, KernelGen | add the element-wise quotient of two tensors, scaled for each tensor in a list, against a broadcast tensor. |
| 478 | foreach_addcdiv_tensor_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place add the element-wise quotient of two tensors, scaled for each tensor in a list, against a broadcast tensor. |
| 479 | foreach_addcmul_scalar | PointWise | Alpha | 5.4 | aten, KernelGen | add the element-wise product of two tensors, scaled for each tensor in a list, against a single scalar. |
| 480 | foreach_addcmul_scalar_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place add the element-wise product of two tensors, scaled for each tensor in a list, against a single scalar. |
| 481 | foreach_addcmul_scalar_list | PointWise | Alpha | 5.4 | aten, KernelGen | add the element-wise product of two tensors, scaled for each tensor in a list, against one scalar per tensor. |
| 482 | foreach_addcmul_scalar_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place add the element-wise product of two tensors, scaled for each tensor in a list, against one scalar per tensor. |
| 483 | foreach_addcmul_tensor | PointWise | Alpha | 5.4 | aten, KernelGen | add the element-wise product of two tensors, scaled for each tensor in a list, against a broadcast tensor. |
| 484 | foreach_addcmul_tensor_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place add the element-wise product of two tensors, scaled for each tensor in a list, against a broadcast tensor. |
| 485 | foreach_asin | PointWise | Alpha | 5.4 | aten, KernelGen | Apply arcsine to each tensor in a list. |
| 486 | foreach_asin_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place arcsine for each tensor in a list. |
| 487 | foreach_atan | PointWise | Alpha | 5.4 | aten, KernelGen | Apply arctangent to each tensor in a list. |
| 488 | foreach_atan_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place arctangent for each tensor in a list. |
| 489 | foreach_ceil | PointWise | Alpha | 5.4 | aten, KernelGen | Apply ceiling to each tensor in a list. |
| 490 | foreach_ceil_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place ceiling for each tensor in a list. |
| 491 | foreach_clamp_max_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise upper clamp for each tensor in a list, paired with a second tensor list. |
| 492 | foreach_clamp_max_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise upper clamp for each tensor in a list, paired with a second tensor list. |
| 493 | foreach_clamp_max_scalar | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise upper clamp for each tensor in a list, against a single scalar. |
| 494 | foreach_clamp_max_scalar_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise upper clamp for each tensor in a list, against a single scalar. |
| 495 | foreach_clamp_max_scalar_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise upper clamp for each tensor in a list, against one scalar per tensor. |
| 496 | foreach_clamp_max_scalar_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise upper clamp for each tensor in a list, against one scalar per tensor. |
| 497 | foreach_clamp_min_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise lower clamp for each tensor in a list, paired with a second tensor list. |
| 498 | foreach_clamp_min_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise lower clamp for each tensor in a list, paired with a second tensor list. |
| 499 | foreach_clamp_min_scalar | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise lower clamp for each tensor in a list, against a single scalar. |
| 500 | foreach_clamp_min_scalar_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise lower clamp for each tensor in a list, against a single scalar. |
| 501 | foreach_clamp_min_scalar_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise lower clamp for each tensor in a list, against one scalar per tensor. |
| 502 | foreach_clamp_min_scalar_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise lower clamp for each tensor in a list, against one scalar per tensor. |
| 503 | foreach_copy | PointWise | Alpha | 5.4 | aten, KernelGen | copy values from a source list for each tensor in a list. |
| 504 | foreach_copy_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place copy values from a source list for each tensor in a list. |
| 505 | foreach_cos | PointWise | Alpha | 5.4 | aten, KernelGen | Apply cosine to each tensor in a list. |
| 506 | foreach_cos_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place cosine for each tensor in a list. |
| 507 | foreach_cosh | PointWise | Alpha | 5.4 | aten, KernelGen | Apply hyperbolic cosine to each tensor in a list. |
| 508 | foreach_cosh_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place hyperbolic cosine for each tensor in a list. |
| 509 | foreach_div_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise division for each tensor in a list, paired with a second tensor list. |
| 510 | foreach_div_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise division for each tensor in a list, paired with a second tensor list. |
| 511 | foreach_div_scalar | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise division for each tensor in a list, against a single scalar. |
| 512 | foreach_div_scalar_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise division for each tensor in a list, against a single scalar. |
| 513 | foreach_div_scalar_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise division for each tensor in a list, against one scalar per tensor. |
| 514 | foreach_div_scalar_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise division for each tensor in a list, against one scalar per tensor. |
| 515 | foreach_div_tensor | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise division for each tensor in a list, against a broadcast tensor. |
| 516 | foreach_div_tensor_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise division for each tensor in a list, against a broadcast tensor. |
| 517 | foreach_erf | PointWise | Alpha | 5.4 | aten, KernelGen | Apply error function to each tensor in a list. |
| 518 | foreach_erf_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place error function for each tensor in a list. |
| 519 | foreach_erfc | PointWise | Alpha | 5.4 | aten, KernelGen | Apply complementary error function to each tensor in a list. |
| 520 | foreach_erfc_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place complementary error function for each tensor in a list. |
| 521 | foreach_exp | PointWise | Alpha | 5.4 | aten, KernelGen | Apply exponential to each tensor in a list. |
| 522 | foreach_exp_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place exponential for each tensor in a list. |
| 523 | foreach_expm1 | PointWise | Alpha | 5.4 | aten, KernelGen | Apply exp(x) - 1 to each tensor in a list. |
| 524 | foreach_expm1_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place exp(x) - 1 for each tensor in a list. |
| 525 | foreach_floor | PointWise | Alpha | 5.4 | aten, KernelGen | Apply floor to each tensor in a list. |
| 526 | foreach_floor_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place floor for each tensor in a list. |
| 527 | foreach_frac | PointWise | Alpha | 5.4 | aten, KernelGen | Apply fractional part to each tensor in a list. |
| 528 | foreach_frac_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place fractional part for each tensor in a list. |
| 529 | foreach_lerp_list | PointWise | Alpha | 5.4 | aten, KernelGen | linear interpolation for each tensor in a list, paired with a second tensor list. |
| 530 | foreach_lerp_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place linear interpolation for each tensor in a list, paired with a second tensor list. |
| 531 | foreach_lerp_scalar | PointWise | Alpha | 5.4 | aten, KernelGen | linear interpolation for each tensor in a list, against a single scalar. |
| 532 | foreach_lerp_scalar_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place linear interpolation for each tensor in a list, against a single scalar. |
| 533 | foreach_lerp_scalar_list | PointWise | Alpha | 5.4 | aten, KernelGen | linear interpolation for each tensor in a list, against one scalar per tensor. |
| 534 | foreach_lerp_scalar_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place linear interpolation for each tensor in a list, against one scalar per tensor. |
| 535 | foreach_lgamma | PointWise | Alpha | 5.4 | aten, KernelGen | Apply log absolute gamma to each tensor in a list. |
| 536 | foreach_lgamma_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place log absolute gamma for each tensor in a list. |
| 537 | foreach_log | PointWise | Alpha | 5.4 | aten, KernelGen | Apply natural logarithm to each tensor in a list. |
| 538 | foreach_log10 | PointWise | Alpha | 5.4 | aten, KernelGen | Apply base-10 logarithm to each tensor in a list. |
| 539 | foreach_log10_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place base-10 logarithm for each tensor in a list. |
| 540 | foreach_log1p | PointWise | Alpha | 5.4 | aten, KernelGen | Apply log(1 + x) to each tensor in a list. |
| 541 | foreach_log1p_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place log(1 + x) for each tensor in a list. |
| 542 | foreach_log2 | PointWise | Alpha | 5.4 | aten, KernelGen | Apply base-2 logarithm to each tensor in a list. |
| 543 | foreach_log2_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place base-2 logarithm for each tensor in a list. |
| 544 | foreach_log_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place natural logarithm for each tensor in a list. |
| 545 | foreach_max | Reduction | Alpha | 5.4 | aten, KernelGen | per-tensor maximum reduction for each tensor in a list. |
| 546 | foreach_maximum_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise maximum for each tensor in a list, paired with a second tensor list. |
| 547 | foreach_maximum_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise maximum for each tensor in a list, paired with a second tensor list. |
| 548 | foreach_maximum_scalar | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise maximum for each tensor in a list, against a single scalar. |
| 549 | foreach_maximum_scalar_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise maximum for each tensor in a list, against a single scalar. |
| 550 | foreach_maximum_scalar_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise maximum for each tensor in a list, against one scalar per tensor. |
| 551 | foreach_maximum_scalar_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise maximum for each tensor in a list, against one scalar per tensor. |
| 552 | foreach_minimum_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise minimum for each tensor in a list, paired with a second tensor list. |
| 553 | foreach_minimum_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise minimum for each tensor in a list, paired with a second tensor list. |
| 554 | foreach_minimum_scalar | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise minimum for each tensor in a list, against a single scalar. |
| 555 | foreach_minimum_scalar_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise minimum for each tensor in a list, against a single scalar. |
| 556 | foreach_minimum_scalar_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise minimum for each tensor in a list, against one scalar per tensor. |
| 557 | foreach_minimum_scalar_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise minimum for each tensor in a list, against one scalar per tensor. |
| 558 | foreach_mul_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise multiplication for each tensor in a list, paired with a second tensor list. |
| 559 | foreach_mul_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise multiplication for each tensor in a list, paired with a second tensor list. |
| 560 | foreach_mul_scalar | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise multiplication for each tensor in a list, against a single scalar. |
| 561 | foreach_mul_scalar_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise multiplication for each tensor in a list, against a single scalar. |
| 562 | foreach_mul_scalar_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise multiplication for each tensor in a list, against one scalar per tensor. |
| 563 | foreach_mul_scalar_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise multiplication for each tensor in a list, against one scalar per tensor. |
| 564 | foreach_mul_tensor | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise multiplication for each tensor in a list, against a broadcast tensor. |
| 565 | foreach_mul_tensor_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise multiplication for each tensor in a list, against a broadcast tensor. |
| 566 | foreach_neg | PointWise | Alpha | 5.4 | aten, KernelGen | Apply negation to each tensor in a list. |
| 567 | foreach_neg_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place negation for each tensor in a list. |
| 568 | foreach_norm_scalar | Reduction | Alpha | 5.4 | aten, KernelGen | per-tensor vector norm for each tensor in a list, against a single scalar. |
| 569 | foreach_pow_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise power for each tensor in a list, paired with a second tensor list. |
| 570 | foreach_pow_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise power for each tensor in a list, paired with a second tensor list. |
| 571 | foreach_pow_scalar | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise power for each tensor in a list, against a single scalar. |
| 572 | foreach_pow_scalar_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise power for each tensor in a list, against a single scalar. |
| 573 | foreach_pow_scalar_and_tensor | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise power for each tensor in a list, with a scalar base and a tensor-list exponent. |
| 574 | foreach_pow_scalar_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise power for each tensor in a list, against one scalar per tensor. |
| 575 | foreach_pow_scalar_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise power for each tensor in a list, against one scalar per tensor. |
| 576 | foreach_reciprocal | PointWise | Alpha | 5.4 | aten, KernelGen | Apply reciprocal to each tensor in a list. |
| 577 | foreach_reciprocal_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place reciprocal for each tensor in a list. |
| 578 | foreach_round | PointWise | Alpha | 5.4 | aten, KernelGen | Apply round to nearest integer to each tensor in a list. |
| 579 | foreach_round_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place round to nearest integer for each tensor in a list. |
| 580 | foreach_rsqrt | PointWise | Alpha | 5.4 | aten, KernelGen | Apply reciprocal square root to each tensor in a list. |
| 581 | foreach_rsqrt_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place reciprocal square root for each tensor in a list. |
| 582 | foreach_sigmoid | PointWise | Alpha | 5.4 | aten, KernelGen | Apply sigmoid to each tensor in a list. |
| 583 | foreach_sigmoid_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place sigmoid for each tensor in a list. |
| 584 | foreach_sign | PointWise | Alpha | 5.4 | aten, KernelGen | Apply sign to each tensor in a list. |
| 585 | foreach_sign_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place sign for each tensor in a list. |
| 586 | foreach_sin | PointWise | Alpha | 5.4 | aten, KernelGen | Apply sine to each tensor in a list. |
| 587 | foreach_sin_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place sine for each tensor in a list. |
| 588 | foreach_sinh | PointWise | Alpha | 5.4 | aten, KernelGen | Apply hyperbolic sine to each tensor in a list. |
| 589 | foreach_sinh_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place hyperbolic sine for each tensor in a list. |
| 590 | foreach_sqrt | PointWise | Alpha | 5.4 | aten, KernelGen | Apply square root to each tensor in a list. |
| 591 | foreach_sqrt_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place square root for each tensor in a list. |
| 592 | foreach_sub_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise subtraction for each tensor in a list, paired with a second tensor list. |
| 593 | foreach_sub_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise subtraction for each tensor in a list, paired with a second tensor list. |
| 594 | foreach_sub_scalar | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise subtraction for each tensor in a list, against a single scalar. |
| 595 | foreach_sub_scalar_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise subtraction for each tensor in a list, against a single scalar. |
| 596 | foreach_sub_scalar_list | PointWise | Alpha | 5.4 | aten, KernelGen | element-wise subtraction for each tensor in a list, against one scalar per tensor. |
| 597 | foreach_sub_scalar_list_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place element-wise subtraction for each tensor in a list, against one scalar per tensor. |
| 598 | foreach_tan | PointWise | Alpha | 5.4 | aten, KernelGen | Apply tangent to each tensor in a list. |
| 599 | foreach_tan_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place tangent for each tensor in a list. |
| 600 | foreach_tanh | PointWise | Alpha | 5.4 | aten, KernelGen | Apply hyperbolic tangent to each tensor in a list. |
| 601 | foreach_tanh_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place hyperbolic tangent for each tensor in a list. |
| 602 | foreach_trunc | PointWise | Alpha | 5.4 | aten, KernelGen | Apply truncate to each tensor in a list. |
| 603 | foreach_trunc_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place truncate for each tensor in a list. |
| 604 | foreach_zero | PointWise | Alpha | 5.4 | aten, KernelGen | fill each tensor with zeros for each tensor in a list. |
| 605 | foreach_zero_ | PointWise | Alpha | 5.4 | aten, KernelGen | In-place fill each tensor with zeros for each tensor in a list. |
| 606 | fp8_fp4_mega_moe | MoE
NeuralNetwork | Alpha | 5.4 | fused, vLLM, Triton | Functional Triton fallback for local FP8 x FP4 MegaMoE. It consumes
staged FP8 activations, packed FP4 expert weights, scales, and top-k
routing tensors, then computes the two-layer SwiGLU MoE output. |
| 607 | fp8_fp4_mqa_logits | NeuralNetwork | Alpha | 5.1 | fused, vLLM, KernelGen | Compute weighted MQA logits with FP8 quantized Q and K tensors.
Uses head-batched tiled dot products with K reuse for high throughput
on DeepSeek V4 sparse attention indexer workloads. |
| 608 | fp8_fp4_paged_mqa_logits | NeuralNetwork | Beta | 5.3 | fused, vLLM, DeepSeekV4, KernelGen | Compute paged multi-query attention logits from FP8 queries against
FP8/FP4 paged KV cache with per-token scaling. Used in DeepSeek-V4
decode-phase inference with adaptive tile sizing. |
| 609 | fp8_mqa_logits | NeuralNetwork | Beta | 5.3 | fused, vLLM | For each token in the given E4M3 tensor, iterate all tokens from two other given tensors,
calculate the logit. |
| 610 | frac | Math | Alpha | 5.4 | aten, KernelGen | Computes the fractional part of each element, returning x - trunc(x). |
| 611 | frac_ | Math | Alpha | 5.4 | aten, KernelGen | In-place fractional part computation, returning x - trunc(x). |
| 612 | fractional_max_pool2d | Math | Alpha | 5.4 | aten, KernelGen | Applies 2D fractional max pooling over an input signal composed of several input planes. |
| 613 | fractional_max_pool2d_backward | Math | Alpha | 5.4 | aten, KernelGen | Computes the gradient of fractional_max_pool2d. |
| 614 | fractional_max_pool3d | Math | Alpha | 5.5 | aten, KernelGen | Applies 3D fractional max pooling over an input signal composed of several input planes. |
| 615 | frexp | Math | Alpha | 5.4 | aten, KernelGen | Return mantissa and exponent of input, such that x = mantissa * 2^exponent, with mantissa in (-1, 1). |
| 616 | full | Tensor | Stable | 2.1 | aten, pointwise, skip_precision_check | Creates a tensor of size size filled with fill_value.
The tensor's dtype is inferred from fill_value. |
| 617 | full_like | Tensor | Stable | 2.1 | aten, pointwise | Returns a tensor with the same size as input filled with fill_value. |
| 618 | functional_assert_async | Tensor | Alpha | 5.4 | utility, KernelGen | Functional version of _assert_async that takes a dependency token and returns a new token.
Part of PyTorch's functionalization framework for tracking operation dependencies. |
| 619 | functional_sym_constrain_range | Tensor | Alpha | 5.4 | aten, KernelGen | A low-level function used in symbolic shape analysis to restrict the possible numerical range
(min/max) of a symbolic integer based on tensor input arguments. |
| 620 | functional_sym_constrain_range_for_size | Tensor | Beta | 5.0 | aten, KernelGen | A low-level function used in symbolic shape analysis to restrict the possible numerical range
(min/max) of an unbacked symbolic integer. |
| 621 | fused_adagrad_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of fused_adagrad(). |
| 622 | fused_adam | Math | Alpha | 5.4 | aten, KernelGen | Fused Adam optimizer step with optional AdamW weight decay, AMSGrad, and gradient maximize support. |
| 623 | fused_adam_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of fused_adam(). |
| 624 | fused_adamw_ | Math | Alpha | 5.4 | aten | In-place fused AdamW with scalar learning rate, AMSGrad and AMP. |
| 625 | fused_adamw__tensor_lr | Math | Alpha | 5.4 | aten | In-place fused AdamW with tensor learning rate, AMSGrad and AMP. |
| 626 | fused_add_rms_norm | NeuralNetwork | Stable | 2.0 | fused, Normalization | |
| 627 | fused_deepseek_v4_qnorm_rope_kv_rope_insert | NeuralNetwork | Alpha | 5.4 | fused, KernelGen | Horizontally-fused DeepseekV4-MLA BF16 variant.
per-head RMSNorm + GPT-J RoPE for Q, and GPT-J RoPE + bf16 paged
cache insert for KV, all in one kernel launch. No FP8 quantization. |
| 628 | fused_deepseek_v4_qnorm_rope_kv_rope_quant_insert | NeuralNetwork | Beta | 5.3 | fused, vLLM, DeepSeekV4 | Horizontally-fused DeepseekV4-MLA.
per-head RMSNorm + GPT-J RoPE for Q, and GPT-J RoPE + UE8M0 FP8
quant + paged cache insert for KV, all in one kernel launch. |
| 629 | fused_experts_impl | NeuralNetwork | Beta | 5.3 | fused, vLLM, MoE | An implementation of fused MoE. |
| 630 | fused_indexer_q_rope_quant | NeuralNetwork | Beta | 5.4 | fused, Attention, vLLM, DeepSeekV4 | Applies RoPE to sparse indexer Q, quantizes it to FP8 or MXFP4, and folds
indexer weights for DeepSeekV4 attention. |
| 631 | fused_marlin_moe_w4a16_int4 | NeuralNetwork | Beta | 5.4 | fused, vLLM, MoE | Fused MoE with GPTQ INT4 (uint4b8) W4A16 weights in plain row-major layout; Triton wna16 fused-dequant GEMM with SwiGLU activation, aligned with vLLM's fused_marlin_moe call signature. |
| 632 | fused_marlin_moe_w4a16_mxfp4 | NeuralNetwork | Beta | 5.4 | fused, vLLM, MoE | Fused MoE with MXFP4 (E2M1) W4A16 weights packed two codes per byte and E8M0 scales; Triton wna16 fused-dequant GEMM with SwiGLU activation, aligned with vLLM's fused_marlin_moe call signature. |
| 633 | fused_marlin_moe_w8a16_int8 | NeuralNetwork | Beta | 5.4 | fused, vLLM, MoE | Fused MoE with GPTQ INT8 (uint8b128) W8A16 weights; Triton wna16 fused-dequant GEMM with SwiGLU activation, aligned with vLLM's fused_marlin_moe call signature. |
| 634 | fused_moe | NeuralNetwork | Beta | 5.3 | fused, vLLM, MoE | The generic interface for fused MoE. |
| 635 | fused_moving_avg_obs_fake_quant | Tensor | Alpha | 5.5 | aten, quantization, KernelGen | Fused moving-average observer with fake-quantize for QAT; performs min/max reduction, EMA running stats update, scale/zero_point calculation, and fake quantization in a single Triton kernel launch. |
| 636 | fused_moving_avg_obs_fq_helper | Tensor | Alpha | 5.4 | aten, quantization, KernelGen | Fused moving-average observer with fake-quantize for QAT; updates running min/max, recomputes scale/zero_point, and fake-quantizes the input for both per-tensor and per-channel modes. |
| 637 | fused_q_kv_rmsnorm | NeuralNetwork | Beta | 5.3 | fused, Attention, vLLM, DeepSeekV4 | Applies RMSNorm to Q and KV tensors in a single fused kernel for DeepSeekV4 attention. |
| 638 | fused_recurrent_gated_delta_rule_fwd | Attention | Beta | 5.3 | fused, FLA | The forward case for fused_recurrent_gated_delta_rule used in Flash Linear Attention (FLA). |
| 639 | fused_rms_norm | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Fused RMS normalization returning the normalized output and inverse RMS. |
| 640 | fused_rms_norm_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Computes input and weight gradients for fused RMS normalization using the
saved reciprocal root-mean-square values. |
| 641 | fused_sgd_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of fused_sgd(). Covers both the default overload and
_fused_sgd_.tensor_lr, which takes the learning rate as a tensor so a
scheduler can update it without a host round-trip; both share one kernel. |
| 642 | gather | Tensor | Stable | 2.2 | aten, Reduction | Gathers values along an axis specified by dim. |
| 643 | gather_backward | Tensor | Stable | 2.2 | aten, Reduction | The backward version of gather(). |
| 644 | gather_block_quantized | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for gather_block_quantized. |
| 645 | gather_sparse_backward | Tensor | Alpha | 5.4 | aten, KernelGen | Backward of gather() producing a sparse (COO) gradient w.r.t. self. Each entry of the flattened grad/index contributes one non-zero at the gather position index[..., ] along dim (the other coordinates are the unraveled index of the entry). The result is an uncoalesced sparse COO tensor of size self.size(). |
| 646 | gcd | Math | Beta | 5.3 | aten | Computes the element-wise greatest common divisor (GCD) of input and other. |
| 647 | gcd_ | Math | Alpha | 5.4 | aten, KernelGen | Computes the element-wise greatest common divisor (GCD) of input and other in-place. |
| 648 | gcd_out | Math | Beta | 5.3 | aten | A variant of gcd() that allows the output to be assigned to the specified out. |
| 649 | ge | Math | Stable | 2.0 | aten, pointwise | Computes input is greater or equal to other element-wise. |
| 650 | ge_scalar | Math | Stable | 2.0 | aten, pointwise | The scalar version of ge(). |
| 651 | geglu | NeuralNetwork | Beta | 5.3 | fused, Activation, Transformer | Gaussian Error Gated Linear Unit with GELU activation instead of sigmoid function. |
| 652 | gelu | NeuralNetwork | Stable | 1.0 | aten, pointwise, Activation, nn.functional | Apply Cumulative Distribution Function for Gaussian Distribution function element-wise. |
| 653 | gelu_ | NeuralNetwork | Stable | 2.2 | aten, Activation, pointwise | The in-place version of gelu(). |
| 654 | gelu_and_mul | NeuralNetwork | Stable | 2.0 | fused, pointwise, Activation | An activation function for GeGLU. |
| 655 | gelu_backward | NeuralNetwork | Stable | 3.0 | aten, Activation, pointwise | The backward version of gelu(). |
| 656 | geometric | Distribution | Beta | 5.1 | aten | Draws random numbers from a geometric distribution. |
| 657 | geometric_ | Distribution | Beta | 5.1 | aten | Fills self tensor with elements drawn from the geometric distribution. |
| 658 | geqrf | LinearAlg | Alpha | 5.5 | aten, KernelGen | Computes the packed Householder QR factorization of a (batched) m x n matrix (LAPACK GEQRF): a holds R in and above the diagonal and the Householder vectors below it, tau holds the scalar factors with shape (*, min(m, n)). |
| 659 | get_paged_mqa_logits_metadata | NeuralNetwork | Beta | 5.3 | vLLM | Build scheduling metadata for paged MQA logits. |
| 660 | get_scheduler_metadata | Attention | Stable | 4.0 | NoCPU, vLLM | Computes scheduling metadata for attention work partitioning so that
CPU computations can be routed to ISA-specific kernel implmentations.
The metadata is stored in a tensor. |
| 661 | glu | NeuralNetwork | Stable | 3.0 | aten, Activation, pointwise | Gated Linear Unit activation for modulating the output of a linear transformation with a gate. |
| 662 | glu_backward | NeuralNetwork | Stable | 4.0 | aten, Activation, pointwise | The backward version of glu(). |
| 663 | glu_jvp | NeuralNetwork | Alpha | 5.5.0 | aten, KernelGen | This function computes the Jacobian-vector product of :func:~torch.nn.functional.glu. |
| 664 | greater | Math | Stable | 5.3 | aten | Test if input is greater than other elementwise. |
| 665 | greater_ | Math | Alpha | 5.5 | aten, KernelGen | The in-place version of greater(). |
| 666 | greater_equal | Math | Alpha | 5.5 | aten, pointwise | Computes input is greater or equal to other element-wise. An alias for ge(). |
| 667 | greater_equal_ | Math | Alpha | 5.4 | aten, pointwise, KernelGen | The in-place version of greater_equal(), which is an alias for ge(). |
| 668 | greater_equal_scalar | Math | Alpha | 5.5 | aten, pointwise | The scalar version of greater_equal(), which is an alias for ge(). |
| 669 | greater_out | Math | Stable | 5.3 | aten | A variant of greater that saves the output to the specified out. |
| 670 | greater_scalar | Math | Stable | 5.3 | aten | A variant of greater for scalar variables. |
| 671 | greater_scalar_out | Math | Stable | 5.3 | aten | A variant of greater_out that saves the output to the specified out. |
| 672 | grid_sampler | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Given an input and a flow-field grid, computes the output using input values and pixel locations from grid. Supports bilinear, nearest, and bicubic interpolation with zeros, border, and reflection padding for 4D inputs, and trilinear/nearest for 5D inputs. |
| 673 | grid_sampler_2d | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Performs 2D grid sampling of the input tensor using the given grid.
Supports bilinear, nearest, and bicubic interpolation with zeros, border, and reflection padding. |
| 674 | grid_sampler_3d | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Given an input and a flow-field grid in 3D, computes the output using input values and pixel locations from grid with trilinear or nearest interpolation. |
| 675 | grid_sampler_3d_backward | Math | Alpha | 5.4 | aten, KernelGen | Backward pass for 3D grid sampling with bilinear/nearest interpolation and multiple padding modes. |
| 676 | group_norm | NeuralNetwork | Stable | 2.0 | aten, Reduction | An internal IR for applying Group Normalization for last certain number of dimensions. |
| 677 | group_norm_backward | NeuralNetwork | Stable | 3.0 | aten, Reduction | The backward case for group_norm(). |
| 678 | grouped_matmul | BLAS | Alpha | 5.5 | NoCPU, MoE | Grouped matrix multiplication on Ascend NPUs, mirroring torch_npu.npu_grouped_matmul.
Computes Y[group] = X[group] @ Weight[group] for Mixture-of-Experts (MoE) models, where x is [M, K], weight is [G, K, N] and group_list holds either cumulative group ends (type 0) or per-group row counts (type 1). |
| 679 | grouped_mm | BLAS | Beta | 5.3 | aten | Grouped matrix multiply is a functional operator designed to accelerate Mixture-of-Experts (MoE) models
by computing multiple matrix multiplications in a single kernel launch. |
| 680 | grouped_topk | MoE | Stable | 5.0 | fused, NoCPU, vLLM | A specialized routing mechanism used in Mixture-of-Experts (MoE) models (like DeepSeek-V3/R1)
to select top-k experts by first grouping them, rather than selecting globally. |
| 681 | gru | NeuralNetwork | Beta | 5.4 | aten | Gated recurrent unit (GRU). At each time step, computes a new hidden state from the input and the previous hidden state using a reset gate and an update gate, across one or more layers and optionally bidirectionally. |
| 682 | gru_data | NeuralNetwork | Beta | 5.4 | aten | Gated recurrent unit (GRU) over packed-sequence data. |
| 683 | gt | Math | Stable | 2.0 | aten, pointwise | Computes that input is greater than other element-wise. |
| 684 | gt_scalar | Math | Stable | 2.0 | aten, pointwise | The scalar version of gt(). |
| 685 | gt_scalar_ | Math | Alpha | 5.4 | aten, pointwise, KernelGen | In-place version of gt for scalar comparison, computes element-wise greater-than with a scalar storing result in input. |
| 686 | gt_tensor_ | Math | Alpha | 5.4 | aten, pointwise, KernelGen | In-place version of gt for tensor comparison, computes element-wise greater-than with a tensor storing result in input. |
| 687 | hamming_window | Math | Alpha | 5.5 | aten, KernelGen | Computes the Hamming window function. |
| 688 | hamming_window_periodic | Math | Alpha | 5.5 | aten, KernelGen | A variant of hamming_window() that takes an explicit periodic flag. |
| 689 | hamming_window_periodic_alpha | Math | Alpha | 5.5 | aten, KernelGen | A variant of hamming_window() that takes an explicit periodic flag and alpha parameter. |
| 690 | hamming_window_periodic_alpha_beta | Math | Alpha | 5.5 | aten, KernelGen | A variant of hamming_window() that takes an explicit periodic flag, alpha, and beta parameters. |
| 691 | hardshrink | NeuralNetwork | Alpha | 5.4 | aten, pointwise, nn.functional, Activation, KernelGen | Applies the hard shrinkage function element-wise: returns x if |x| > lambd, else 0. |
| 692 | hardshrink_backward | NeuralNetwork | Alpha | 5.5.0 | aten, pointwise, KernelGen | Computes the gradient of the Hard Shrink activation function with respect to its input
during backpropagation. The gradient is passed through where the input magnitude is
strictly greater than the threshold lambd, and is zero elsewhere. |
| 693 | hardshrink_out | NeuralNetwork | Alpha | 5.4 | aten, pointwise, nn.functional, Activation, KernelGen | Out-variant of hardshrink. Writes the element-wise result into the out tensor. |
| 694 | hardsigmoid | NeuralNetwork | Beta | 5.0 | aten, pointwise, nn.functional, Activation, KernelGen | An activation function that provides a piecewise linear approximation of the standard sigmoid function,
mapping inputs to a range between 0 and 1. |
| 695 | hardsigmoid_ | NeuralNetwork | Alpha | 5.4 | aten, pointwise, KernelGen, Activation | An in-place variant of hardsigmoid, an activation function that provides a piecewise
linear approximation of the standard sigmoid function, mapping inputs to a range between 0 and 1. |
| 696 | hardsigmoid_backward | Math | Alpha | 5.4 | aten, KernelGen | The backward pass for hardsigmoid. Computes the gradient of the hardsigmoid
activation function: grad_output * (|self| < 3) / 6. |
| 697 | hardsigmoid_out | NeuralNetwork | Beta | 5.0 | aten, pointwise, nn.functional, Activation, KernelGen | A variant of hardsigmoid that supports an output tensor to receive the result. |
| 698 | hardswish | NeuralNetwork | Alpha | 5.4 | aten, pointwise, nn.functional, Activation, KernelGen | Applies the Hard Swish activation function, commonly used in models like MobileNetV3
to improve accuracy while reducing computational cost compared to traditional Swish. |
| 699 | hardswish_ | NeuralNetwork | Beta | 5.0 | aten, pointwise, KernelGen, Activation | Applies the Hard Swish activation function, commonly used in models like MobileNetV3
to improve accuracy while reducing computational cost compared to traditional Swish.
This is an in-place version. |
| 700 | hardswish_backward | Math | Alpha | 5.4 | aten, KernelGen | The backward pass for hardswish. Computes the gradient of the hardswish activation
function: piecewise derivative 0 for x <= -3, (2x + 3) / 6 for -3 < x < 3,
and 1 for x >= 3. |
| 701 | hardswish_out | NeuralNetwork | Alpha | 5.4 | aten, pointwise, nn.functional, Activation, KernelGen | A variant of hardswish that supports an output tensor to receive the result. |
| 702 | hardtanh | NeuralNetwork | Alpha | 5.4 | aten, pointwise, nn.functional, Activation, KernelGen | An activation function that clips input values to lie within a fixed range
[min_val, max_val], leaving values inside the range unchanged. |
| 703 | hardtanh_ | NeuralNetwork | Alpha | 5.4 | aten, pointwise, Activation, KernelGen | An activation function that clips input values to lie within a fixed range
[min_val, max_val], leaving values inside the range unchanged.
This is an in-place version. |
| 704 | hardtanh_backward | Math | Alpha | 5.4 | aten, KernelGen | The backward pass for hardtanh activation function. Computes the gradient of hardtanh:
grad_output when min_val < x < max_val, 0 otherwise. |
| 705 | hardtanh_out | NeuralNetwork | Alpha | 5.4 | aten, pointwise, nn.functional, Activation, KernelGen | A variant of hardtanh that supports an output tensor to receive the result. |
| 706 | has_compatible_shallow_copy_type | Tensor | Alpha | 5.4 | aten | Metadata-only check that returns True when self can shallow-copy the
TensorImpl type of from. Compatibility is decided on the tensors'
DispatchKeySets: the sets are equal, or both are dense, both are sparse
COO, or both are sparse compressed. It is independent of dtype and shape,
and of device within a family, but opaque impls (meta, MKL-DNN, nested,
quantized) only match an identical key set even though some of them
report a strided layout. |
| 707 | hash_tensor | Reduction | Alpha | 5.4 | aten, KernelGen | Reduces the input tensor by XOR-ing the raw 64-bit representations of its elements over the given dims (an empty dim list reduces over all elements).
Floating types are widened to float64 and bit-cast to uint64; integer and bool types are extended to int64 and bit-cast to uint64. The output dtype is always uint64 and mode must be 0. |
| 708 | hc_head_fused_kernel | NeuralNetwork | Stable | 5.3 | fused, vLLM, DSA | The head fusion kernel for MHC (Manifold-Constrained Hyper-Connections).
This fused implementation computes RMS-normalized hidden states and applies
per-head weighted mixing to produce the output activations. |
| 709 | hc_split_sinkhorn_forward | NeuralNetwork | Beta | 5.3 | fused | Computes a differentiable approximation of the Wasserstein distance (Optimal Transport)
between two probability distributions or point clouds. |
| 710 | heaviside | Math | Alpha | 5.4 | aten, KernelGen | The heaviside step function. Computes 0 where input < 0, 1 where input > 0,
and values where input == 0. Supports tensor values. |
| 711 | heaviside_ | Math | Alpha | 5.4 | aten, KernelGen | In-place version of heaviside. For each element: 0 if x < 0, 1 if x > 0,
and the corresponding values element if x == 0. |
| 712 | hinge_embedding_loss | NeuralNetwork | Alpha | 5.5 | aten, nn.functional, KernelGen | Compute the hinge embedding loss. |
| 713 | histc | Math | Alpha | 5.3 | aten, KernelGen | Computes the histogram of a tensor, binning each element into equal-width bins. |
| 714 | histogram | Math | Alpha | 5.5.0 | aten, KernelGen | Compute histogram of a tensor into bins. histogram.bin_ct uses uniform bins (integer count), histogram.bins_tensor uses non-uniform bins (Tensor edges). Returns (hist, bin_edges). |
| 715 | histogramdd | Reduction | Alpha | 5.5 | aten, KernelGen | Computes D-dimensional histogram over (N, D) input tensor. Returns histogram tensor and list of bin edge tensors per dimension. |
| 716 | histogramdd_from_bin_cts | Reduction | Alpha | 5.4 | aten, KernelGen | Computes a multi-dimensional histogram of the values in a tensor using a sequence of per-dimension bin counts (equal-width bins). |
| 717 | histogramdd_from_bin_cts_out | Reduction | Alpha | 5.4 | aten, KernelGen | A variant of _histogramdd_from_bin_cts() that assigns the output to the given out parameter. |
| 718 | histogramdd_from_bin_tensors | Reduction | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for _histogramdd_from_bin_tensors. Computes a multi-dimensional histogram from explicit per-dimension bin-edge tensors, supporting optional weights and density normalisation. |
| 719 | histogramdd_from_bin_tensors_out | Reduction | Alpha | 5.4 | aten, KernelGen | A variant of _histogramdd_from_bin_tensors() that assigns the output to the given out parameter. |
| 720 | hsplit | Tensor | Alpha | 5.4 | aten, KernelGen | Split a tensor into multiple sub-tensors horizontally (column-wise).
Equivalent to tensor_split with dim=1 for 2D+ tensors, or dim=0 for 1D tensors. |
| 721 | hspmm | BLAS | Alpha | 5.5.0 | aten, KernelGen | Performs a matrix multiplication of a sparse COO tensor with a dense tensor.
Returns an uncoalesced sparse COO tensor with the same number of specified elements as the input sparse tensor. |
| 722 | hstack | Tensor | Stable | 2.2 | aten | Stack tensors in sequence horizontally (column wise). This is equivalent to concatenation
along the first axis for 1-D tensors, and along the second axis for all other tensors. |
| 723 | huber_loss | NeuralNetwork | Alpha | 5.4 | aten, KernelGen, Loss | Computes the Huber loss between input and target. Quadratic for small errors
(|x - y| <= delta) and linear for large errors. Supports reduction none/mean/sum. |
| 724 | huber_loss_out | NeuralNetwork | Alpha | 5.4 | aten, KernelGen, Loss | Out-variant of huber_loss. Writes the computed loss into the out tensor. |
| 725 | hypot | Math | Stable | 5.3 | aten, KernelGen | Given the legs of a right triangle, return its hypotenuse.
The shapes of both input tensors must be broadcastable. |
| 726 | hypot_ | Math | Alpha | 5.4 | aten, KernelGen | In-place version of hypot. Given the legs of a right triangle, writes its
hypotenuse into self. The shape of other must be broadcastable to self. |
| 727 | hypot_out | Math | Stable | 5.3 | aten, KernelGen | Given the legs of a right triangle, return its hypotenuse.
The shapes of both input tensors must be broadcastable.
This is a variant of hypot that allows the output to be a different tensor. |
| 728 | i0 | Math | Stable | 5.3 | aten, KernelGen | Computes the modified Bessel function of the first kind of order zero element-wise for a given input tensor. |
| 729 | i0_ | Math | Stable | 5.3 | aten, KernelGen | The inplace version of i0. |
| 730 | i0_out | Math | Stable | 5.3 | aten, KernelGen | A variant of i0 that assigns the output to the out tensor. |
| 731 | iand_scalar | Math | Alpha | 5.5 | aten, KernelGen | The scalar version of iand_tensor. |
| 732 | iand_tensor | Math | Alpha | 5.5 | aten, KernelGen | The in-place version of bitwise and operation for two tensors. |
| 733 | igamma | Math | Alpha | 5.4 | aten, KernelGen | Computes the regularized lower incomplete gamma function element-wise. |
| 734 | igamma_ | Math | Alpha | 5.4 | aten, KernelGen | In-place computation of the regularized lower incomplete gamma function. |
| 735 | igammac | Math | Alpha | 5.4 | aten | Computes the regularized upper incomplete gamma function Q(a, x) element-wise. |
| 736 | igammac_ | Math | Alpha | 5.4 | aten, KernelGen, pointwise | In-place version of igammac. Computes the regularized upper incomplete gamma function complement. |
| 737 | igammac_out | Math | Alpha | 5.4 | aten | Out-of-place variant of igammac that writes the result to the out tensor. |
| 738 | ilshift | Math | Alpha | 5.4 | aten, KernelGen | Computes the in-place bitwise left shift of self by other bits. |
| 739 | im2col | Math | Alpha | 5.4 | aten, KernelGen | Extracts sliding local blocks from a batched input tensor. |
| 740 | index | Reduction | Stable | 4.2 | aten | Extract, access or modify specific elements, slices, or subsets of data within a tensor.
The location of data is specified for each dimension, starting from index 0. |
| 741 | index_add | Tensor | Stable | 2.2 | aten | Accumulate the elements of alpha times source into the input tensor
by adding to the indices in the order given in index. |
| 742 | index_add_ | Tensor | Stable | 4.0 | aten | The in-place version of index_add(). |
| 743 | index_copy | Tensor | Beta | 5.3 | aten, KernelGen | Copies the elements from source into input at the positions specified by
index along the given dim. |
| 744 | index_copy_ | Tensor | Beta | 5.3 | aten, KernelGen | The in-place version of index_copy(). |
| 745 | index_fill | Tensor | Alpha | 5.4 | aten | Fills elements of the input tensor with a scalar or 0-dimensional tensor value
at positions selected by index along the given dim. |
| 746 | index_fill_ | Tensor | Alpha | 5.4 | aten | The in-place version of index_fill(). |
| 747 | index_put | Tensor | Stable | 2.2 | aten | Puts values from the tensor values into the tensor input using the indices specified
in indices (which is a tuple of Tensors). |
| 748 | index_put_ | Tensor | Stable | 3.0 | aten | The in-place version of index_put(). |
| 749 | index_put_impl_ | Tensor | Beta | 5.3 | aten | An internal C++ function that handles the heavy lifting for placing values into a tensor at specific indices. |
| 750 | index_reduce | Tensor | Alpha | 5.5 | aten, KernelGen | Returns a new tensor after accumulating source into input at the indices
specified by index, using prod, mean, amax, or amin reduction. |
| 751 | index_reduce_ | Tensor | Beta | 5.4 | aten, KernelGen | Accumulates the elements of source into input at the indices specified
by index along dim, using prod, mean, amax, or amin reduction. |
| 752 | index_reduce_out | Tensor | Alpha | 5.5 | aten, KernelGen | An out variant of index_reduce that writes the reduced values to out. |
| 753 | index_select | Tensor | Stable | 2.1 | aten | Returns a new tensor which indexes the input tensor along dimension dim
using the entries in index. |
| 754 | index_select_backward | Math | Alpha | 5.4 | aten, KernelGen | Backward of index_select. Accumulates gradients into the output at positions specified by the index. |
| 755 | indexer_k_quant_and_cache | Quantization | Beta | 5.3 | fused, vLLM | This is a fused operator that quantizes K tensors and writes them into the FP8 KV cache. |
| 756 | infinitely_differentiable_gelu_backward | NeuralNetwork | Alpha | 5.5.0 | aten, Activation, pointwise, KernelGen | The smooth (erf-based) GELU gradient used by higher-order autograd, computed as grad * (0.5 * erf(x / sqrt(2)) + 0.5 + x * exp(-x * x / 2) / sqrt(2 * pi)). |
| 757 | inner | Math | Alpha | 5.5.0 | aten, KernelGen | Computes the inner product of two tensors by contracting their last dimension, keeping the leading dimensions of each operand per-side without broadcasting. |
| 758 | inplace_fused_experts | MoE | Stable | 5.3 | fused, Activation, vLLM | This operator writes output directly to hidden_states. |
| 759 | instance_norm | NeuralNetwork | Beta | 5.3 | fused | Apply Instance Normalization independently for each channel in every data sample within a batch. |
| 760 | int_mm | BLAS | Alpha | 5.5 | aten | Performs matrix multiplication of two two-dimensional int8 tensors and returns a contiguous int32 tensor. |
| 761 | int_mm_out | BLAS | Alpha | 5.5 | aten | A variant of _int_mm that writes the int32 result into out. |
| 762 | inverse | LinearAlg | Alpha | 5.4 | aten, KernelGen | Computes the inverse of a square matrix, batched over the leading dimensions
and equivalent to torch.inverse. Small real matrices use a fused pivoted
Gauss-Jordan Triton kernel; larger real matrices and complex inputs are
delegated to the vendor (cuSOLVER) inverse. |
| 763 | ior_scalar | Math | Beta | 5.3 | aten, KernelGen | The scalar version of ior_tensor. |
| 764 | ior_tensor | Math | Beta | 5.3 | aten, KernelGen | The in-place version of bitwise or operation for two tensors. |
| 765 | irshift | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for irshift. |
| 766 | is_all_true | Tensor | Beta | 5.3 | aten, pointwise, KernelGen | The low-level implementation for checking if all elements in a tensor are True. |
| 767 | is_nonzero | Math | Alpha | 5.4 | aten, KernelGen | Returns True if the single-element input tensor is not equal to zero. |
| 768 | is_same_size | Tensor | Alpha | 5.5 | aten, KernelGen | Returns True if the two input tensors have the same shape. |
| 769 | isclose | Math | Stable | 2.1 | aten, pointwise | Returns a new tensor with boolean elements representing if each element of input
is "close" to the corresponding element of other.
The closeness is defined with rtol and atol. |
| 770 | isfinite | Math | Stable | 2.1 | aten, pointwise | Returns a new tensor with boolean elements representing if each element is finite or not. |
| 771 | isin | Tensor | Stable | 2.2 | aten | Tests if each element of elements is in test_elements.
Returns a boolean tensor of the same shape as elements that is True
for elements in test_elements and False otherwise. |
| 772 | isin_scalar_tensor | Tensor | Stable | 2.2 | aten | A variant of isin(). |
| 773 | isin_tensor_scalar | Tensor | Stable | 2.2 | aten | A variant of isin(). |
| 774 | isinf | Math | Stable | 2.0 | aten, pointwise | Tests if each element of input is infinite (positive or negative infinity) or not. |
| 775 | isnan | Math | Stable | 2.0 | aten, pointwise | Returns a new tensor with boolean elements representing if each element of input is NaN or not. |
| 776 | isneginf | Math | Stable | 5.3 | aten, KernelGen, pointwise | Tests if each element of input is negative infinity or not. |
| 777 | isneginf_out | Math | Stable | 5.3 | aten, KernelGen, pointwise | A variant of isneginf that saves the output to the specified out. |
| 778 | isposinf | Math | Alpha | 5.4 | aten, KernelGen | Tests if each element of input is positive infinity or not. |
| 779 | isreal | Math | Alpha | 5.5 | aten, KernelGen | Tests whether each element is real, i.e. whether its imaginary part is
zero, and returns a bool tensor. Real-valued dtypes are always True; for
complex dtypes the imaginary component is compared against an exact zero
(a negative zero counts as zero). |
| 780 | istft | Math | Alpha | 5.5.0 | aten, KernelGen | Computes the inverse short-time Fourier transform of an stft spectrogram,
equivalent to torch.istft. The spectrum is inverted frame by frame with
cuFFT (irfft/ifft), windowed, overlap-added, and normalized by the
squared-window envelope; the overlap-add, envelope and normalization run in
fused Triton kernels. |
| 781 | ixor | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the bitwise XOR of input tensors or a tensor and a scalar (inplace). |
| 782 | jagged_to_padded_dense_forward | Tensor | Alpha | 5.4 | aten, KernelGen | Converts a jagged (variable-length) tensor to a padded dense tensor. |
| 783 | kaiser_window | Math | Alpha | 5.5.0 | aten, KernelGen | Computes the Kaiser window function. |
| 784 | kaiser_window_beta | Math | Alpha | 5.5.0 | aten, KernelGen | A variant of kaiser_window() that takes an explicit periodic flag and beta shape parameter. |
| 785 | kaiser_window_periodic | Math | Alpha | 5.5.0 | aten, KernelGen | A variant of kaiser_window() that takes an explicit periodic flag. |
| 786 | kl_div | Math | Alpha | 5.5.0 | aten, KernelGen | Compute the Kullback-Leibler divergence loss between the input
(log-probabilities) and the target, supporting none/mean/sum reductions
and both the probability and log-space target interpretations. |
| 787 | kron | LinearAlg | Stable | 2.2 | aten | Computes the Kronecker product of input and other. |
| 788 | kthvalue | Tensor | Alpha | 5.4 | aten, KernelGen | Returns the kth smallest element of the given input tensor along a given dimension. |
| 789 | l1_loss | NeuralNetwork | Alpha | 5.5.0 | aten, pointwise, nn.functional, KernelGen | Compute the L1 loss between input and target tensors, i.e. the element-wise
absolute difference, with optional none/mean/sum reduction. |
| 790 | layer_norm | NeuralNetwork | Stable | 1.0 | aten | An internal IR for applying Layer Normalization for last certain number of dimensions. |
| 791 | layer_norm_backward | Reduction | Stable | 3.0 | aten | The backward case for layer_norm(). |
| 792 | lcm | Pointwise | Alpha | 5.4 | aten, pointwise, KernelGen | Compute the element-wise least common multiple of input tensors. |
| 793 | lcm_ | Pointwise | Alpha | 5.4 | aten, pointwise, KernelGen | Compute the element-wise least common multiple of input tensors, storing result in-place. |
| 794 | ldexp | Pointwise | Alpha | 5.5 | aten, pointwise, KernelGen | Multiplies input by 2 raised to the power of other, element-wise. |
| 795 | ldexp_ | Math | Alpha | 5.5 | aten, pointwise, KernelGen | In-place version of ldexp. |
| 796 | ldexp_out | Pointwise | Alpha | 5.5 | aten, pointwise, KernelGen | A variant of ldexp() that assigns the output to the out tensor. |
| 797 | le | Math | Stable | 2.0 | aten, pointwise | Computes that input is less than or equal to other element-wise. |
| 798 | le_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of le(). |
| 799 | le_scalar | Math | Stable | 2.0 | aten, pointwise | The scalar version of le(). |
| 800 | le_scalar_ | Math | Alpha | 5.4 | aten, KernelGen | The scalar version of le_(). |
| 801 | leaky_relu | NeuralNetwork | Beta | 5.3 | aten | Applies the LeakyReLU function element-wise. |
| 802 | leaky_relu_ | NeuralNetwork | Beta | 5.3 | aten | The in-place version of leaky_relu(). |
| 803 | leaky_relu_backward | NeuralNetwork | Beta | 5.3 | aten, pointwise | A variant of leaky_relu() for backward case. |
| 804 | leaky_relu_out | NeuralNetwork | Beta | 5.3 | aten | A variant of leaky_relu(). |
| 805 | lerp_scalar | LinearAlg | Stable | 3.0 | aten, pointwise | The scalar version of lerp(). |
| 806 | lerp_scalar_ | LinearAlg | Stable | 3.0 | aten, pointwise | The in-place, scalar version of lerp(). |
| 807 | lerp_tensor | LinearAlg | Stable | 3.0 | aten, pointwise | Performs a linear interpolation of two tensors start (given by input) and end
based on a scalar or tensor weight and returns the resulting out tensor. |
| 808 | lerp_tensor_ | LinearAlg | Stable | 3.0 | aten, pointwise | The in-place version of lerp(). |
| 809 | less_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of less(). |
| 810 | less_equal | Math | Alpha | 5.4 | aten, KernelGen | Computes element-wise less-than-or-equal-to comparison. |
| 811 | less_equal_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of less_equal(). |
| 812 | less_equal_scalar | Math | Alpha | 5.4 | aten, KernelGen | Computes less-than-or-equal-to comparison with a scalar. |
| 813 | less_equal_scalar_ | Math | Alpha | 5.4 | aten, KernelGen | The scalar version of less_equal_(). |
| 814 | less_scalar_ | Math | Alpha | 5.4 | aten, KernelGen | The scalar version of less_(). |
| 815 | lgamma | Math | Alpha | 5.4 | aten, KernelGen | Computes the logarithm of the gamma function on input. |
| 816 | lgamma_ | Math | Alpha | 5.4 | aten, KernelGen | In-place version of lgamma(). |
| 817 | lift | Tensor | Alpha | 5.4 | aten, KernelGen | Returns self tensor. Used within compiled graphs to lift
tensors out of the graph or modify autograd metadata. |
| 818 | lift_fresh | Tensor | Alpha | 5.4 | aten, KernelGen | Returns a fresh tensor holding the same values as the input, used to
lift constants into a compiled graph. |
| 819 | lift_fresh_copy | Tensor | Stable | 5.3 | aten, KernelGen | Creates a new, independent copy of a tensor within a compiled graph. |
| 820 | lift_out | Tensor | Alpha | 5.4 | aten, KernelGen | Out-of-place variant of lift that copies self to the out tensor. |
| 821 | linalg__powsum | LinearAlg | Alpha | 5.5 | aten, KernelGen, Reduction | Computes the sum of the absolute input values raised to ord over the requested dimensions, without applying the final norm root. |
| 822 | linalg_cholesky | LinearAlg
BLAS | Alpha | 5.4 | aten, KernelGen | Computes the Cholesky decomposition of a symmetric positive-definite matrix A
or for batches of symmetric positive-definite matrices. |
| 823 | linalg_cond | LinearAlg | Alpha | 5.5 | aten, KernelGen | Compute the condition number of a matrix with respect to various norms. |
| 824 | linalg_cross | LinearAlg | Alpha | 5.4 | aten | Computes the cross product of two 3-dimensional vectors along a specified dimension. |
| 825 | linalg_cross_out | LinearAlg | Alpha | 5.4 | aten | A variant of linalg_cross that allows the output to be assigned to out. |
| 826 | linalg_det | LinearAlg | Alpha | 5.4 | aten | Computes the determinant of a square matrix via LU decomposition with partial pivoting. |
| 827 | linalg_det_out | LinearAlg | Alpha | 5.4 | aten | A variant of linalg_det that writes the determinant to the provided out tensor. |
| 828 | linalg_eig | Math | Alpha | 5.4 | aten, KernelGen | Computes the eigenvalue decomposition of a general square matrix, returning
the complex eigenvalues and eigenvectors. Also supports batches of matrices. |
| 829 | linalg_eigh | LinearAlg | Alpha | 5.4 | aten, KernelGen | Computes the eigenvalue decomposition of a symmetric (or Hermitian) matrix or a batch of matrices. |
| 830 | linalg_eigvals | Math | Alpha | 5.4 | aten, KernelGen | Computes the eigenvalues of a square matrix. |
| 831 | linalg_eigvals_out | Math | Alpha | 5.5 | aten, KernelGen | A variant of linalg_eigvals that allows the output to be assigned to out. |
| 832 | linalg_householder_product | Math | Alpha | 5.4 | aten, KernelGen | Compute the matrix product of Householder matrices from QR decomposition. |
| 833 | linalg_inv_ex | LinearAlg | Alpha | 5.5 | aten, KernelGen | Compute the inverse of a square matrix using LU factorization with partial pivoting. |
| 834 | linalg_ldl_factor | LinearAlg | Alpha | 5.4 | aten, KernelGen | Computes the compact LDL factorization of a Hermitian or symmetric matrix. |
| 835 | linalg_ldl_factor_ex | Math | Alpha | 5.4 | aten, KernelGen | Computes the LDL factorization with pivot information for a symmetric or Hermitian matrix. |
| 836 | linalg_ldl_solve | LinearAlg | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for linalg_ldl_solve. |
| 837 | linalg_lstsq | LinearAlg
BLAS | Alpha | 5.4 | aten | Computes the least-squares solution (gels driver) to A X = B for full-rank
over- or underdetermined systems, including batches, via Householder TSQR. |
| 838 | linalg_lu | Math | Alpha | 5.4 | aten | Computes the LU factorization with partial pivoting of a matrix and
returns the permutation matrix P and the lower/upper triangular factors
L and U such that P @ L @ U = A (or L @ U = A for pivot=False). |
| 839 | linalg_lu_factor | Math | Alpha | 5.4 | aten | Computes a compact representation of the LU factorization with partial pivoting of a matrix. |
| 840 | linalg_lu_factor_ex | Math | Alpha | 5.4 | aten | Computes a compact representation of the LU factorization with partial
pivoting of a matrix and returns an info tensor indicating whether the
factorization was successful (info == 0) or the position of the first zero
pivot (1-indexed). This is the "expert" version of linalg_lu_factor,
equivalent to LAPACK's getrf. |
| 841 | linalg_lu_factor_ex_out | Math | Alpha | 5.4 | aten | Out-of-place version of linalg_lu_factor_ex. Supports calling
torch.linalg.lu_factor_ex(A, *, pivot=True, check_errors=False,
out=(LU, pivots, info)). The out parameter provides pre-allocated output
tensors for in-place writing. |
| 842 | linalg_lu_factor_out | Math | Alpha | 5.4 | aten | Out-of-place version of linalg_lu_factor. Supports calling torch.linalg.lu_factor(A, *, pivot=True, out=(LU, pivots)). The out parameter provides pre-allocated output tensors. |
| 843 | linalg_lu_out | Math | Alpha | 5.4 | aten | Out-of-place version of linalg_lu. Supports calling
torch.linalg.lu(A, *, pivot=True, out=(P, L, U)). The out parameter
provides pre-allocated output tensors for in-place writing. |
| 844 | linalg_lu_solve | LinearAlg | Alpha | 5.5 | aten, KernelGen | Solves a linear system AX = B given the LU factorization of A with partial pivoting.
Performs pivot permutation, forward substitution (L), and backward substitution (U)
in a single fused Triton kernel. |
| 845 | linalg_matmul | LinearAlg | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for linalg_matmul. |
| 846 | linalg_matrix_exp | LinearAlg | Beta | 5.4 | aten | Computes the matrix exponential of a square matrix via scaling-and-squaring with an optimized Taylor polynomial approximation of degree 18. |
| 847 | linalg_matrix_exp_out | LinearAlg | Beta | 5.4 | aten | A variant of linalg_matrix_exp that writes the matrix exponential to the provided out tensor. |
| 848 | linalg_matrix_norm | LinearAlg | Beta | 5.5 | aten | Computes the matrix norm over the given dimensions.
Supports ord values: 1, -1, 2, -2, inf, -inf, 'fro', 'nuc'.
For ord=2/-2/nuc, internally uses SVD (singular value decomposition).
For ord=1/-1/inf/-inf, uses max/min absolute column/row sums.
For ord='fro', uses Frobenius norm via per-row L2 reduction. |
| 849 | linalg_matrix_norm_out | LinearAlg | Beta | 5.5 | aten | Out-of-place version of linalg_matrix_norm,
Computes the matrix norm over the given dimensions.
Supports ord values: 1, -1, 2, -2, inf, -inf, 'fro', 'nuc'.
For ord=2/-2/nuc, internally uses SVD (singular value decomposition).
For ord=1/-1/inf/-inf, uses max/min absolute column/row sums.
For ord='fro', uses Frobenius norm via per-row L2 reduction. |
| 850 | linalg_matrix_power | LinearAlg | Beta | 5.4 | aten | Computes the n-th power of a square matrix using binary exponentiation. |
| 851 | linalg_matrix_power_out | LinearAlg | Beta | 5.4 | aten | Out-of-place version of linalg_matrix_power. Supports calling torch.linalg.matrix_power(A, n, *, out=None). The out parameter provides a pre-allocated output tensor for in-place writing. |
| 852 | linalg_matrix_rank | LinearAlg | Beta | 5.4 | aten | Computes the numerical rank of a matrix or a batch of matrices. |
| 853 | linalg_matrix_rank_atol_rtol_float | LinearAlg | Beta | 5.4 | aten | Computes numerical matrix rank using optional scalar absolute and relative tolerances. |
| 854 | linalg_matrix_rank_atol_rtol_float_out | LinearAlg | Beta | 5.4 | aten | Computes numerical matrix rank using scalar tolerances and an output tensor. |
| 855 | linalg_matrix_rank_atol_rtol_tensor | LinearAlg | Beta | 5.4 | aten | Computes numerical matrix rank using optional tensor absolute and relative tolerances. |
| 856 | linalg_matrix_rank_atol_rtol_tensor_out | LinearAlg | Beta | 5.4 | aten | Computes numerical matrix rank using tensor tolerances and an output tensor. |
| 857 | linalg_matrix_rank_hermitian | LinearAlg | Beta | 5.4 | aten | Computes numerical matrix rank of a Hermitian matrix (hermitian=True). |
| 858 | linalg_matrix_rank_out | LinearAlg | Beta | 5.4 | aten | Computes numerical matrix rank using a scalar tolerance and an output tensor. |
| 859 | linalg_matrix_rank_out_tol_tensor | LinearAlg | Beta | 5.4 | aten | Computes numerical matrix rank using a tensor tolerance and an output tensor. |
| 860 | linalg_matrix_rank_tol_tensor | LinearAlg | Beta | 5.4 | aten | Computes numerical matrix rank using a positional tensor tolerance. |
| 861 | linalg_matrix_sqrth | LinearAlg | Alpha | 5.4 | aten, KernelGen | Computes the principal square root of a symmetric or Hermitian positive-definite matrix. |
| 862 | linalg_matrix_sqrth_out | LinearAlg | Alpha | 5.4 | aten, KernelGen | Writes the principal square root of a symmetric or Hermitian positive-definite matrix to an output tensor. |
| 863 | linalg_multi_dot | LinearAlg | Alpha | 5.5 | aten, KernelGen | Efficiently multiplies a chain of two or more matrices using the optimal multiplication order. |
| 864 | linalg_multi_dot_out | LinearAlg | Alpha | 5.5 | aten, KernelGen | Writes the optimally ordered product of a matrix chain to a provided output tensor. |
| 865 | linalg_norm | LinearAlg | Beta | 5.4 | aten | Computes a vector or matrix norm, mirroring torch.linalg.norm dispatch.
The vector branch (ord=None/2/1/0/p/±inf, dim as int or 1-tuple or None)
reuses linalg_vector_norm; the matrix branch (ord='fro'/'nuc'/±1/±2/±inf,
dim as 2-tuple) reuses linalg_matrix_norm. |
| 866 | linalg_pinv | LinearAlg | Alpha | 5.5 | aten, KernelGen | Computes the Moore-Penrose pseudoinverse of a matrix via Jacobi SVD. |
| 867 | linalg_polar | LinearAlg | Alpha | 5.5 | aten, KernelGen | Computes the right polar decomposition A = U @ H. |
| 868 | linalg_polar_out | LinearAlg | Alpha | 5.5 | aten, KernelGen | Writes the right polar decomposition into U and H output tensors. |
| 869 | linalg_qr | LinearAlg | Beta | 5.4 | aten | Computes the QR decomposition of a matrix (or a batch of matrices) via a blocked Householder algorithm with a TSQR fast path for tall-skinny inputs. Pure-Triton implementation supporting the "reduced", "complete" and "r" modes. |
| 870 | linalg_qr_out | LinearAlg | Beta | 5.4 | aten | The out= variant of linalg_qr; writes the Q and R factors into the caller-provided output tensors. |
| 871 | linalg_slogdet | LinearAlg | Alpha | 5.4 | aten, KernelGen | Computes the sign and natural logarithm of the absolute value of the determinant of a square matrix using LU decomposition with partial pivoting. |
| 872 | linalg_solve | LinearAlg | Alpha | 5.5 | aten, KernelGen | Solves a linear system AX = B via fused LU decomposition with partial pivoting
and forward/backward substitution in a single Triton kernel. |
| 873 | linalg_solve_ex | LinearAlg | Alpha | 5.5 | aten, KernelGen | Solves a linear system AX = B via fused LU decomposition with partial pivoting
and forward/backward substitution in a single Triton kernel. Returns (result, info)
where info indicates singularity status. |
| 874 | linalg_solve_triangular | LinearAlg
BLAS | Alpha | 5.4 | aten | Solves a triangular system of linear equations with a unique solution, returning
a tensor X such that AX = B (or XA = B when right=True) for a triangular
matrix A and matrix of right-hand sides B. |
| 875 | linalg_solve_triangular_out | LinearAlg
BLAS | Alpha | 5.4 | aten | Out-of-place variant of linalg_solve_triangular: solves a triangular system
of linear equations and writes the result into the provided out tensor. |
| 876 | linalg_svd | BLAS | Alpha | 5.4 | aten, KernelGen | Computes the singular value decomposition (SVD) of a matrix. |
| 877 | linalg_svdvals | Math | Alpha | 5.4 | aten, KernelGen | Computes the singular values of a matrix. |
| 878 | linalg_tensorinv | Math | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for linalg_tensorinv. |
| 879 | linalg_tensorinv_out | Math | Alpha | 5.5 | aten, KernelGen | Out-of-place variant of linalg_tensorinv: computes the tensor inverse
and writes the result into the provided out tensor. |
| 880 | linalg_vander | Math | Alpha | 5.5 | aten, KernelGen | Computes the Vandermonde matrix of a given vector. |
| 881 | linalg_vecdot | Math | Alpha | 5.4 | aten | Computes the dot product of two vectors along a specified dimension. |
| 882 | linalg_vecdot_out | Math | Alpha | 5.4 | aten | Computes the dot product of two vectors along a specified dimension. |
| 883 | linear | BLAS | Beta | 5.5 | aten | Applies a linear transformation to the incoming data: y = x @ W^T + b. |
| 884 | linear_backward | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for linear_backward. |
| 885 | linspace | Tensor | Stable | 2.2 | aten | Creates a one-dimensional tensor of size steps whose values are evenly spaced from start to end, inclusive. |
| 886 | list_to_tensor | | Alpha | 5.4 | aten, KernelGen, IR | Constructs a 1-D int32 tensor from a Python list of integers. This is an
IR/prim operator; the FlagGems implementation copies the values into the
output tensor with a Triton kernel. |
| 887 | log | Math | Stable | 2.2 | aten, pointwise | Returns a new tensor with the natural logarithm of the elements of input. |
| 888 | log10 | Math | Beta | 5.3 | aten, pointwise | Returns a new tensor with the logarithm to the base 10 of the elements of input. |
| 889 | log10_ | Math | Beta | 5.3 | aten, pointwise | The in-place version of log10(). |
| 890 | log10_out | Math | Beta | 5.3 | aten, pointwise | A variant of log10() that assigns the output to the provided out. |
| 891 | log1p | Math | Stable | 5.3 | aten, KernelGen | Computes the natural logarithm of 1+x(y_i=log_e(x_i+1)) for each element in the input tensor. |
| 892 | log1p_ | Math | Stable | 5.3 | aten, KernelGen | Computes the natural logarithm of 1+x(y_i=log_e(x_i+1)) for each element in the input tensor in-place. |
| 893 | log2 | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Returns a new tensor with the logarithm to the base 2 of the elements of input. |
| 894 | log2_ | Math | Alpha | 5.4 | aten, pointwise, KernelGen | The in-place version of log2(). |
| 895 | log_ | Math | Beta | 5.3 | aten, KernelGen | The in-place version of log(). Computes the natural logarithm of each element in the input tensor in-place. |
| 896 | log_normal | Distribution | Beta | 5.4 | aten, skip_precision_check | Returns a new tensor with log-normal samples parameterized by mean and standard deviation. |
| 897 | log_normal_ | Distribution | Alpha | 5.1 | aten, KernelGen | Fills the tensor with log-normal samples parameterized by mean and standard deviation, in-place. |
| 898 | log_sigmoid | NeuralNetwork | Stable | 2.2 | aten, pointwise, nn.functional | Applies the Logsigmoid function element-wise. |
| 899 | log_sigmoid_backward | NeuralNetwork | Alpha | 5.4 | aten, pointwise | Computes the input gradient of the Logsigmoid function. |
| 900 | log_sigmoid_backward_out | NeuralNetwork | Alpha | 5.4 | aten, pointwise | A variant of log_sigmoid_backward that assigns the output to the grad_input tensor. |
| 901 | log_sigmoid_forward | Math | Alpha | 5.4 | aten, KernelGen | Computes the output and buffer for the log-sigmoid function, used in autograd backward pass. |
| 902 | log_softmax | NeuralNetwork | Stable | 3.0 | aten, Reduction | An internal IR for applying a softmax followed by a logarithm. |
| 903 | log_softmax_backward_data | NeuralNetwork | Beta | 5.3 | aten, KernelGen | Computes the gradient of the input tensor with respect to a log_softmax operation
during backpropagation. |
| 904 | log_softmax_backward_data_out | NeuralNetwork | Beta | 5.3 | aten, KernelGen | A variant of _log_softmax_backward_data that assigns the output to the out tensor. |
| 905 | log_softmax_out | NeuralNetwork | Stable | 3.0 | aten, Reduction | An internal IR for applying a softmax followed by a logarithm. |
| 906 | logaddexp | Math | Stable | 5.3 | aten, pointwise, KernelGen | Computes the element-wise logarithm of the sum of the exponentials of two input tensors. |
| 907 | logaddexp2 | Math | Beta | 5.4 | aten, pointwise | Computes the element-wise base-2 logarithm of the sum of base-2 exponentiations of two input tensors. |
| 908 | logaddexp2_out | Math | Beta | 5.4 | aten, pointwise | A variant of logaddexp2 that allows the output to be assigned to an out tensor. |
| 909 | logaddexp_out | Math | Stable | 5.3 | aten, pointwise, KernelGen | A variant of logaddexp that allows the output to be assigned to an out tensor. |
| 910 | logcumsumexp | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for logcumsumexp. |
| 911 | logcumsumexp_out | Math | Alpha | 5.4 | aten, KernelGen | A variant of logcumsumexp that allows the output to be assigned to an out tensor. |
| 912 | logdet | LinearAlg | Alpha | 5.5 | aten, KernelGen | Computes the logarithm of the determinant of a square matrix or batch of square matrices. |
| 913 | logical_and | Math | Stable | 2.2 | aten, pointwise | Computes the element-wise logical AND of the given input tensors.
Zeros are treated as False and nonzeros are treated as True. |
| 914 | logical_and_ | Math | Stable | 5.0 | aten, pointwise | The in-place version of logical_and(). |
| 915 | logical_not | Math | Stable | 2.2 | aten, pointwise | Computes the element-wise logical NOT of the given input tensor. |
| 916 | logical_not_ | Math | Alpha | 5.4 | aten, KernelGen | In-place version of logical_not. Computes the element-wise logical NOT. |
| 917 | logical_or | Math | Stable | 2.2 | aten, pointwise | Computes the element-wise logical OR of the given input tensors. |
| 918 | logical_or_ | Math | Stable | 5.0 | aten, pointwise | The in-place version of logical_or(). |
| 919 | logical_xor | Math | Stable | 2.2 | aten, pointwise | Computes the element-wise logical XOR of the given input tensors. |
| 920 | logical_xor_ | Math | Alpha | 5.4 | aten, KernelGen, pointwise | The in-place version of logical_xor(). |
| 921 | logit | LinearAlg | Stable | 5.3 | aten, pointwise, KernelGen | Returns a new tensor with the logit of the elements of input.
input is clamped to [eps, 1-eps] when eps is not None.
When eps is None and input<0 or input>1, the function will yield NaN. |
| 922 | logit_ | LinearAlg | Stable | 5.3 | aten, pointwise, KernelGen | The in-place version of logit(). |
| 923 | logit_backward | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for logit_backward. |
| 924 | logit_out | LinearAlg | Stable | 5.3 | aten, pointwise, KernelGen | A variant of logit that allows the output to be assigned to another tensor. |
| 925 | logspace | tensor | Stable | 4.0 | aten | Creates a one-dimensional tensor of size steps whose values are evenly spaced
from base^start to base^end, inclusive, on a logarithmic scale with base base. |
| 926 | logsumexp | Math | Alpha | 5.3 | aten, KernelGen | Computes the log of the sum of exponentials of elements in the input tensor along given dimensions. |
| 927 | lshift_scalar | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Applies a bitwise left shift to an integer tensor with a scalar shift value. |
| 928 | lshift_tensor | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Applies a bitwise left shift to an integer tensor with a tensor shift value. |
| 929 | lstm | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for lstm. |
| 930 | lt | Math | Stable | 2.0 | aten, pointwise | Computes that input is less than other element-wise. |
| 931 | lt_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of lt(). |
| 932 | lt_scalar | Math | Stable | 2.0 | aten, pointwise | The scalar version of lt. |
| 933 | lt_scalar_ | Math | Alpha | 5.4 | aten, KernelGen | The scalar version of lt_(). |
| 934 | lu_unpack | Math | Alpha | 5.4 | aten, KernelGen | Unpacks the LU decomposition returned by lu_factor into separate permutation matrix P, lower triangular L, and upper triangular U. |
| 935 | lu_unpack_out | Math | Alpha | 5.4 | aten, KernelGen | Out-of-place variant of lu_unpack that writes results into pre-allocated output tensors. |
| 936 | lu_with_info | LinearAlg | Alpha | 5.4 | aten, KernelGen | Computes a compact LU factorization with partial pivoting of a matrix,
returning the packed LU matrix, the 1-indexed pivots and an info tensor
that reports the first singular diagonal of U (0 on success). This is the
deprecated torch._lu_with_info interface mirrored on linalg.lu_factor_ex. |
| 937 | make_dep_token | Tensor | Alpha | 5.4 | aten, KernelGen | Creates a scalar tensor as a dependency token for TorchScript tracing
and class-based compiler frameworks. The value of the returned tensor
is uninitialized and should not be consumed. |
| 938 | margin_ranking_loss | NeuralNetwork | Beta | 5.3 | aten, nn.functional, KernelGen | Compute the margin ranking loss. |
| 939 | margin_ranking_loss_backward | NeuralNetwork | Beta | 5.4 | aten, nn.functional, KernelGen | The backward computation of margin_ranking_loss(), exercised through the autograd of the forward operator. |
| 940 | masked_fill | Tensor | Stable | 2.2 | aten, pointwise | Fills elements of given tensor with value where mask is True. |
| 941 | masked_fill_ | Tensor | Stable | 2.2 | aten, pointwise, skip_precision_check | The in-place version of masked_fill(). |
| 942 | masked_fill_scalar | Tensor | Stable | 2.2 | aten, pointwise | Fills elements of given tensor with value where mask is True. |
| 943 | masked_fill_scalar_ | Tensor | Stable | 2.2 | aten, pointwise, skip_precision_check | The in-place version of masked_fill(). |
| 944 | masked_scale | Tensor | Alpha | 5.4 | aten, KernelGen, pointwise | The low-level implementation for computing input multiplied by scale with masking. |
| 945 | masked_scatter | tensor | Stable | 4.2 | aten | Copies elements from source into the given tensor at positions where the mask is True. |
| 946 | masked_scatter_ | tensor | Stable | 4.2 | aten | The in-place version of masked_scatter(). |
| 947 | masked_scatter_backward | tensor | Alpha | 5.4 | aten | Backward of masked_scatter with respect to the source tensor.
Returns a tensor of shape sizes where the first mask.sum() elements
are the gradient values from the positions where mask was True
(obtained via stream-compaction / masked_select), and the remaining
elements are zero (the tail of source that was never consumed by the
forward pass). |
| 948 | masked_select | Tensor | Stable | 2.1 | aten | Returns a new 1-D tensor which indexes the input tensor according to
the boolean mask mask which is a BoolTensor. |
| 949 | masked_select_backward | Tensor | Alpha | 5.5 | aten, KernelGen | Backward of masked_select with respect to input. Scatters the compact
gradient into a zero tensor at the True mask positions after broadcasting
input and mask to a common shape. |
| 950 | masked_softmax | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Apply a softmax over dim while excluding positions where the boolean
mask is True. mask_type selects how the mask broadcasts: 2 for an
elementwise mask, 1 for a (B, L) attention padding mask, and 0 for an
(L, L) source mask. |
| 951 | masked_softmax_backward | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Computes the input gradient of a masked softmax: masked positions are
zeroed and the remaining positions follow the standard softmax backward
formula output * (grad_output - sum(output * grad_output over dim)). |
| 952 | matmul_backward | BLAS | Alpha | 5.5 | aten, KernelGen | Computes gradients for matrix multiplication backward pass. |
| 953 | matmul_bias_activation | BLAS | Alpha | 5.4 | KernelGen | Fused matrix multiplication with bias addition and ReLU activation. |
| 954 | matmuladd | Math | Alpha | 5.4 | fused, KernelGen | Computes matrix multiplication followed by bias addition. |
| 955 | matrix_exp | Math | Alpha | 5.5 | aten, KernelGen | Computes the matrix exponential of one or more square matrices via scaling-and-squaring with a degree-18 Taylor polynomial, evaluated entirely with the Triton bmm kernel. |
| 956 | matrix_exp_backward | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for matrix_exp_backward. |
| 957 | matrix_power | Math | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for matrix_power. |
| 958 | matrix_power_out | Math | Alpha | 5.5 | aten, KernelGen | An out variant of matrix_power() that writes the result into a pre-allocated output tensor. |
| 959 | max | LinearAlg | Stable | 2.0 | aten, Reduction | Returns the maximum value of all elements in the input tensor. |
| 960 | max_dim | LinearAlg | Stable | 2.0 | aten, Reduction | Returns a namedtuple (values, indices) where values is the maximum value
of each row of the input tensor in the given dimension dim.
And indices is the index location of each maximum value found (argmax). |
| 961 | max_pool1d | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for max_pool1d. |
| 962 | max_pool1d_with_indices | Math | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for max_pool1d_with_indices. |
| 963 | max_pool2d_backward | IR | Stable | 4.0 | aten | Applies a 2D max pooling over an input signal composed of several input planes.
This is an IR representation rather than a public API and it is for the backward step. |
| 964 | max_pool2d_with_indices | IR | Stable | 4.0 | aten | Applies a 2D max pooling over an input signal composed of several input planes.
This is an IR representation rather than a public API. |
| 965 | max_pool2d_with_indices_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | The backward version of max_pool2d_with_indices().
This is an IR representation rather than a public API and it is for the backward step. |
| 966 | max_pool3d | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Applies a 3D max pooling over an input signal composed of several input planes. |
| 967 | max_pool3d_backward | NeuralNetwork | Beta | 5.3 | aten, nn.functional | The backward version of max_pool2d_with_indices(). |
| 968 | max_pool3d_with_indices | NeuralNetwork | Beta | 5.3 | aten, nn.functional | Applies a 3D max pooling over an input signal composed of several input planes. |
| 969 | max_pool3d_with_indices_backward | NeuralNetwork | Beta | 5.3 | aten, KernelGen | Backward pass for 3D max pooling with indices. Computes the gradient of the
input given the gradient of the output and the indices from the forward pass. |
| 970 | max_unpool2d | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Computes a partial inverse of MaxPool2d. |
| 971 | max_unpool3d | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for max_unpool3d. |
| 972 | maximum | Math | Stable | 2.1 | aten, pointwise | Computes the element-wise maximum of input and other. |
| 973 | mean | LinearAlg | Stable | 1.0 | aten, Reduction | Returns the mean value of all elements in the input tensor. Input must be floating point or complex. |
| 974 | mean_dim | Reduction | Stable | 2.0 | aten | Returns the mean value of each row of the input tensor in the given dimension dim.
If dim is a list of dimensions, reduce over all of them. |
| 975 | median | LinearAlg | Beta | 5.4 | aten, KernelGen, Reduction | Returns the median of the values in input. |
| 976 | median_dim | LinearAlg | Beta | 5.4 | aten, KernelGen, Reduction | Returns a namedtuple (values, indices) where values contains the median
of each row of input in the dimension dim, and indices contains the
index location of each median value found. |
| 977 | median_dim_values | LinearAlg | Beta | 5.4 | aten, KernelGen, Reduction | A variant of median_dim() with the out argument. |
| 978 | median_out | LinearAlg | Beta | 5.4 | aten, KernelGen, Reduction | A variant of median() with the out argument. |
| 979 | mH | Tensor | Alpha | 5.5.0 | aten, KernelGen | Returns a view of this tensor with the last two dimensions conjugated and transposed. |
| 980 | mhc_bwd | NeuralNetwork | Beta | 5.3 | fused, vLLM, DSA | The backward case for MHC (Manifold-Constrained Hyper-Connections).
This is the Triton implmentation for Sinkhorn implicit CG differentiation.
It computes the gradient of the Sinkhorn normalization using implicit differentiation via the conjugate gradient method. |
| 981 | mhc_post | NeuralNetwork | Beta | 5.3 | fused, vLLM, DSA | Triton implementation of mHC Post operator (optimized v3). |
| 982 | mhc_pre | NeuralNetwork | Beta | 5.3 | fused, vLLM, DSA | Triton implementation of mHC Pre operator (optimized v2). |
| 983 | min | Tensor | Stable | 2.0 | aten, Reduction | Returns the minimum value of all elements in the input tensor. |
| 984 | min_dim | LinearAlg | Stable | 2.0 | aten, Reduction | Returns a namedtuple (values, indices) where values is the minimum value of
each row of the input tensor in the given dimension dim.
And indices is the index location of each minimum value found (argmin). |
| 985 | minimum | Math | Stable | 2.1 | aten, pointwise | Computes the element-wise minimum of input and other. |
| 986 | miopen_batch_norm | Math | Alpha | 5.4 | aten, KernelGen | Computes batch normalization on the input tensor using the MIOpen convention and updates the running statistics. |
| 987 | miopen_batch_norm_backward | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for miopen_batch_norm_backward. |
| 988 | mish | NeuralNetwork | Alpha | 5.4 | aten, KernelGen, pointwise, Activation | Applies the Mish activation function element-wise. |
| 989 | mish_ | NeuralNetwork | Alpha | 5.4 | aten, KernelGen, pointwise, Activation | The in-place version of mish(). |
| 990 | mish_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen, pointwise | Computes the gradient of Mish activation with respect to the input. |
| 991 | mixed_dtypes_linear | BLAS | Alpha | 5.5 | aten, KernelGen | Weight-only quantized matrix multiplication (CUTLASS fpA_intB semantics).
Computes out = activation(input @ dequant(weight) + bias) where weight is uint8
(int8 mode: (u-128)*scale or packed int4 mode: (u-8)*scale). Bias and activation
are optional. |
| 992 | mkldnn_rnn_layer | Math | Alpha | 5.4 | aten, KernelGen, NoCPU | Applies a single-layer unidirectional LSTM (oneDNN mkldnn_rnn_layer, mode=2)
to the input sequence, returning the output sequence and the final hidden and
cell states. |
| 993 | mm | BLAS | Stable | 1.0 | aten | Performs a matrix multiplication of the two input matrices. |
| 994 | mm_out | BLAS | Stable | 3.0 | aten | A variant of mm() with out specified. |
| 995 | mm_self_transpose | BLAS | Beta | 5.4 | aten | Multiplies a transposed view with its base tensor (mm(inp, inp.t())), exercising the column-major B operand path of mm. |
| 996 | mm_w8a8_fp8 | BLAS | Alpha | 5.4 | NoCPU, Quantization | Dynamically quantizes BF16 activations and weights to FP8 E4M3, computes their matrix product with FP8 Tensor Cores, and applies FP32 scales. |
| 997 | mm_w8a8_int8 | BLAS | Alpha | 5.5 | non-aten | Multiplies prequantized INT8 matrices with scalar or per-row/column FP32 scales and optional bias; input quantization is external. |
| 998 | mm_w8a8_int8_out | BLAS | Alpha | 5.5 | non-aten | A variant of mm_w8a8_int8 with caller-owned output. |
| 999 | mode | LinearAlg | Beta | 5.3 | aten, Reduction | Returns a namedtuple (values, indices) where values is the mode value of each row of the input tensor in the given dimension dim, i.e. a value which appears most often in that row, and indices is the index location of each mode value found. |
| 1000 | moe_align_block_size_triton | MoE | Stable | 4.2 | fused, Reduction, vLLM | Aligns the token distribution across experts to be compatible with block size
for matrix multiplication. |
| 1001 | moe_sum | MoE | Stable | 4.2 | fused, Reduction, vLLM | An implementation of Mixture of Experts (MoE) with sum-based aggregation
instead of the more common weighted average. |
| 1002 | mse_loss | NeuralNetwork | Stable | 2.2 | aten, pointwise, nn.functional | Compute the element-wise mean squared error, with optional weighting. |
| 1003 | mse_loss_backward | NeuralNetwork | Alpha | 5.4 | aten, NeuralNetwork, KernelGen | Compute the gradient of mean squared error loss with respect to the input. |
| 1004 | msort | Math | Alpha | 5.5 | aten, KernelGen | Sorts each column of the input tensor in ascending order. |
| 1005 | msort_out | Math | Alpha | 5.5 | aten, KernelGen | Writes the column-wise sorted values into the provided output tensor. |
| 1006 | mT | Tensor | Alpha | 5.5.0 | aten, KernelGen | Returns a view of this tensor with the last two dimensions transposed. |
| 1007 | mul | Math | Stable | 1.0 | aten, pointwise | Multiplies input by other. |
| 1008 | mul_ | Math | Stable | 2.2 | aten, pointwise | The in-place version of mul(). |
| 1009 | multi_margin_loss | NeuralNetwork | Alpha | 5.5 | aten, Loss, nn.functional | Computes the multi-class margin loss with optional class weights. |
| 1010 | multi_margin_loss_backward | NeuralNetwork | Alpha | 5.5 | aten, Loss | Computes the input gradient of the multi-class margin loss. |
| 1011 | multi_margin_loss_backward_out | NeuralNetwork | Alpha | 5.5 | aten, Loss | Writes the multi-class margin-loss gradient into grad_input. |
| 1012 | multi_margin_loss_out | NeuralNetwork | Alpha | 5.5 | aten, Loss | Writes the multi-class margin loss into the provided output tensor. |
| 1013 | multilabel_margin_loss_forward | NeuralNetwork | Alpha | 5.5 | aten, Loss | Computes the forward multi-label margin loss and returns both the loss and the per-class target membership mask. |
| 1014 | multinomial | Distribution | Stable | 2.1 | aten, skip_precision_check | Returns a tensor where each row contains num_samples indices sampled
from the multinomial probability distribution located in the corresponding row
of tensor input. |
| 1015 | multiply | Math | Alpha | 5.4 | aten, KernelGen | Multiplies input by other element-wise (out-of-place alias for mul). |
| 1016 | multiply_ | Math | Alpha | 5.4 | aten, KernelGen | In-place multiplication using Triton kernel (alias for mul_). Supports tensor-tensor and tensor-scalar operations. |
| 1017 | mv | BLAS | Stable | 2.0 | aten | Performs a matrix-vector product of the matrix input and the vector vec. |
| 1018 | mvlgamma | Math | Alpha | 5.4 | aten, KernelGen | Computes the multivariate log-gamma function element-wise (out-of-place). |
| 1019 | mvlgamma_ | Math | Alpha | 5.4 | aten, KernelGen | Computes the multivariate log-gamma function in-place for each element of the input tensor. |
| 1020 | nan_to_num | Math | Stable | 3.0 | aten, pointwise | Replaces NaN, positive infinity, and negative infinity values in input
with the values specified by nan, posinf, and neginf, respectively. |
| 1021 | nan_to_num_ | Math | Alpha | 5.4 | aten, KernelGen, pointwise | Replaces NaN, positive infinity, and negative infinity values in input in-place. |
| 1022 | nanmean | Math | Alpha | 5.5 | aten, Reduction, KernelGen | Computes the mean of all non-NaN elements along the specified dimensions,
ignoring NaN values. |
| 1023 | nanmean_out | Math | Alpha | 5.5 | aten, Reduction, KernelGen | Computes the mean of non-NaN values into the supplied output tensor. |
| 1024 | nanmedian | LinearAlg | Beta | 5.4 | aten, Reduction | Returns the median of the values in input, ignoring NaN values. |
| 1025 | nanmedian_dim | LinearAlg | Beta | 5.4 | aten, Reduction | 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 location of each median value found. |
| 1026 | nanmedian_dim_values | LinearAlg | Beta | 5.4 | aten, Reduction | A variant of nanmedian_dim() with the out argument. |
| 1027 | nanmedian_out | LinearAlg | Beta | 5.4 | aten, Reduction | A variant of nanmedian() with the out argument. |
| 1028 | nanquantile | Tensor | Alpha | 5.5 | aten, KernelGen | Computes the q-th quantiles of each row of the input tensor along the
dimension dim, ignoring NaN values. |
| 1029 | nanquantile_out | Tensor | Alpha | 5.5 | aten, KernelGen | Tensor-q out overload of nanquantile. |
| 1030 | nanquantile_scalar | Tensor | Alpha | 5.5 | aten, KernelGen | Scalar-q overload of nanquantile. |
| 1031 | nanquantile_scalar_out | Tensor | Alpha | 5.5 | aten, KernelGen | Scalar-q out overload of nanquantile. |
| 1032 | nansum | LinearAlg | Beta | 5.4 | aten, Reduction | Returns the sum of all elements in the input tensor, treating NaN values as zero.
Supports global reduction and reduction along specified dimensions. |
| 1033 | nansum_out | LinearAlg | Beta | 5.4 | aten, Reduction | A variant of nansum() with the out argument. |
| 1034 | narrow | Tensor | Alpha | 5.4 | aten, KernelGen, skip_precision_check | Pure layout operation (narrow); returns a zero-copy view sharing storage with the input. |
| 1035 | narrow_copy | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for narrow_copy. |
| 1036 | native_batch_norm | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Apply native batch normalization using the existing implementation. |
| 1037 | native_batch_norm_legit | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Batch normalization with in-place running statistics updates, returning the normalized output along with the saved mean and inverse standard deviation. |
| 1038 | native_batch_norm_legit_functional | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Functional version of batch normalization that returns the saved mean and inverse standard deviation, along with updated running estimates. |
| 1039 | native_batch_norm_legit_no_stats | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Batch normalization without persistent running statistics. |
| 1040 | native_batch_norm_legit_no_stats_out | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Out variant of batch normalization without running statistics. |
| 1041 | native_batch_norm_legit_no_training | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Inference-only batch normalization using precomputed running_mean and running_var without updating them; returns the normalized output plus two empty save_mean/save_var tensors matching the aten schema. |
| 1042 | native_batch_norm_legit_out | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Out variant of batch normalization with running statistics. |
| 1043 | native_channel_shuffle | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Divides the channels into groups and rearranges each group. |
| 1044 | native_dropout_backward | NeuralNetwork | Stable | 3.0 | aten, nn.functional | The backward case of dropout(). |
| 1045 | native_group_norm | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Apply native group normalization using the existing implementation. |
| 1046 | native_layer_norm | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Apply native layer normalization using the existing implementation. |
| 1047 | native_multi_head_attention | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation of the native multi-head attention forward pass, including the fused qkv projection, scaled dot-product attention and output projection. |
| 1048 | native_norm | Reduction | Alpha | 5.5.0 | aten, KernelGen | Computes the p-norm over all elements of the input tensor, reducing to a scalar. |
| 1049 | ne | Math | Stable | 2.0 | aten, pointwise | Computes that input is not equal to other element-wise. |
| 1050 | ne_ | Math | Alpha | 5.4 | aten, KernelGen, pointwise | Computes element-wise not-equal comparison in-place. |
| 1051 | ne_scalar | Math | Stable | 2.0 | aten, pointwise | The scalar version of ne(). |
| 1052 | neg | Math | Stable | 2.0 | aten, pointwise | Returns a new tensor with the negative of the elements of input. |
| 1053 | neg_ | Math | Stable | 2.2 | aten, pointwise | The in-place version of neg(). |
| 1054 | negative | Math | Alpha | 5.4 | aten, KernelGen | negative operator |
| 1055 | negative_ | Math | Alpha | 5.4 | aten, KernelGen | Computes the negative of input in-place. |
| 1056 | nested_from_padded_tensor | Tensor | Alpha | 5.4 | aten, NoCPU, KernelGen | Constructs a nested tensor from a padded tensor and offsets. |
| 1057 | nested_select_backward | Tensor | Alpha | 5.5 | aten, NoCPU, KernelGen | Triton kernel implementation for the backward of nested tensor select
along the batch dimension. Scatters the gradient of the selected
component into a zero buffer with the same nested structure as the input. |
| 1058 | nested_sum_backward | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for _nested_sum_backward, the backward of
a (nested) tensor sum over a single dimension. It broadcasts the
gradient back to the shape of the original input along the reduced dim. |
| 1059 | nested_tensor_from_mask | Tensor | Alpha | 5.5.0 | aten, KernelGen | Builds a nested tensor from a padded dense tensor of shape (N, L, D) and a
boolean padding mask of shape (N, L), using the mask to determine the ragged
length of each component. |
| 1060 | nested_tensor_from_mask_left_aligned | Tensor | Alpha | 5.4 | aten, KernelGen | Checks whether a 3D tensor t (N * L * D) combined with a 2D boolean padding
mask (N * L) is left-aligned, i.e. the valid (True) elements of every row appear
at the beginning with no gaps. Returns a bool. |
| 1061 | nested_tensor_softmax_with_shape | Tensor | Alpha | 5.5.0 | aten, KernelGen | Computes softmax over the last dimension of nested-tensor attention scores,
deriving the per-batch sequence length from the query tensor's nested shape
and masking the out-of-range entries to zero. |
| 1062 | nested_to_padded_tensor | Tensor | Alpha | 5.5.0 | aten, KernelGen | Converts a nested (ragged) tensor into a padded dense tensor, filling unoccupied positions with a scalar padding value. |
| 1063 | nested_view_from_buffer_copy | Tensor | Alpha | 5.4 | aten, KernelGen, Metax | Creates a nested tensor from a flat buffer using component sizes, strides,
and offsets, with a Metax backend specialization. |
| 1064 | nested_view_from_jagged | Tensor | Alpha | 5.4 | aten, NoCPU, KernelGen | Constructs a jagged-layout nested tensor from a flat values buffer and an
offsets tensor. This is a pure view operation that wraps the values buffer
without copying any data. |
| 1065 | nested_view_from_jagged_copy | Tensor | Alpha | 5.4 | aten, KernelGen | Constructs a jagged-layout nested tensor from a flat buffer split into
batch elements according to offsets/lengths metadata, owning a fresh copy
of the buffer. |
| 1066 | new_full | Tensor | Beta | 5.3 | aten, pointwise | Returns a Tensor of size size filled with fill_value.
By default, the returned Tensor has the same torch.dtype and torch.device
as this tensor. |
| 1067 | new_ones | Tensor | Alpha | 5.4 | aten, KernelGen | Returns a Tensor of size size filled with 1, with the
same torch.dtype and torch.device as the input tensor. |
| 1068 | nextafter | Math | Alpha | 5.4 | aten, KernelGen | Return the next floating-point value after input towards other, elementwise. |
| 1069 | nextafter_ | Math | Alpha | 5.4 | aten, pointwise | Returns the next representable floating-point value from input toward
other, elementwise. In-place version of nextafter. |
| 1070 | nll_loss2d | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Negative log likelihood loss for a 4D input (N, C, H, W) of log-probabilities
and a 3D integer target (N, H, W). Returns only the loss tensor, applying the
requested reduction (none/mean/sum) with optional per-class weights and an
ignore_index. |
| 1071 | nll_loss2d_backward | NeuralNetwork | Stable | 2.2 | aten, IR | An internal IR for supporting torch.nn.NLLLoss2d, which has been deprecated
and is now integrated into the standard torch.nn.NLLLoss.
This is the backward case. |
| 1072 | nll_loss2d_forward | NeuralNetwork | Stable | 2.2 | aten, IR | An internal IR for supporting torch.nn.NLLLoss2d, which has been deprecated
and is now integrated into the standard torch.nn.NLLLoss. This is the forward case. |
| 1073 | nll_loss_backward | NeuralNetwork | Stable | 2.2 | aten, IR | Compute the negative log likelihood loss. This is the backward case. |
| 1074 | nll_loss_forward | NeuralNetwork | Stable | 2.2 | aten, IR | Compute the negative log likelihood loss. This is the forward case. |
| 1075 | nll_loss_nd_backward | NeuralNetwork | Stable | 5.0 | aten | Measures the performance of a classification model by penalizing low probabilities for correct classe.s
This computes the gradients of this loss with respect to model parameters using automatic differentiation. |
| 1076 | nll_loss_nd_forward | NeuralNetwork | Stable | 5.0 | aten | Measures the performance of a classification model by calculating the negative log probability
of the true class. This defines the computation flow, transforming input data through layers
to produce output predictions. |
| 1077 | nonzero | Tensor | Stable | 2.1 | aten | Returns a 2-D tensor where each row is the index for a nonzero value.
When as_tuple is explicitly set to True, this returns a tuple of 1-D index tensors,
allowing for advanced indexing of all nonzero values. |
| 1078 | nonzero_numpy | Tensor | Alpha | 5.3 | aten, KernelGen | Returns a tuple of 1-D tensors, one for each dimension, containing the indices of
the nonzero elements in the input tensor (NumPy-style). |
| 1079 | nonzero_static | Tensor | Alpha | 5.4 | aten | Returns a fixed-size 2-D int64 tensor containing indices of nonzero elements.
Rows beyond the number of nonzero elements are filled with fill_value. |
| 1080 | nonzero_static_out | Tensor | Alpha | 5.4 | aten | A variant of nonzero_static that writes the fixed-size result to out. |
| 1081 | norm | Reduction | Alpha | 5.4 | aten, KernelGen, reduction | Computes the norm of vectors, matrices, and tensors. |
| 1082 | norm_except_dim | Reduction | Alpha | 5.5 | aten, KernelGen, reduction | Computes the p-norm of a tensor over all dimensions except the given one, keeping that dimension so the result broadcasts against the input. |
| 1083 | norm_scalar | Reduction | Alpha | 5.4 | aten, KernelGen, reduction | A variant of norm that computes the norm over all elements. |
| 1084 | norm_scalaropt_dim | Reduction | Alpha | 5.4 | aten, KernelGen, reduction | A variant of norm that computes the norm along specified dimensions. |
| 1085 | normal_ | Tensor | Alpha | 5.3 | skip_precision_check | Random sampling operator (normal_). |
| 1086 | normal_float_float_ | Distribution | Stable | 5.0 | aten, pointwise, skip_precision_check | Returns a tensor of random numbers drawn from separate normal distributions
whose mean and standard deviation are given.
This is one of the variants that takes a float mean and a float std. |
| 1087 | normal_float_tensor | Distribution | Stable | 2.1 | aten, pointwise | Returns a tensor of random numbers drawn from separate normal distributions
whose mean and standard deviation are given.
This is one of the variants that takes a float mean and a tensor std. |
| 1088 | normal_functional | Distribution | Alpha | 5.5.0 | aten, KernelGen, pointwise, skip_precision_check | Returns a fresh tensor of random numbers drawn from a normal distribution
parameterized by a float mean and a float std. This is the out-of-place
functional variant of normal_ (aten::normal_functional). |
| 1089 | normal_tensor_float | Distribution | Stable | 2.1 | aten, pointwise | Returns a tensor of random numbers drawn from separate normal distributions
whose mean and standard deviation are given.
This is one of the variants that takes a tensor mean and a float std. |
| 1090 | normal_tensor_tensor | Distribution | Stable | 2.1 | aten, pointwise | Returns a tensor of random numbers drawn from separate normal distributions
whose mean and standard deviation are given.
This is one of the variants that takes a tensor mean and a tensor std. |
| 1091 | normed_cumsum | Reduction | Stable | 2.1 | aten | Get the normalized cumulative sum where each step is divided by the total sum
of the dataset, resulting in values ranging from 0 to 1.
Internally used by the multinomial operator. |
| 1092 | not_equal | Logic | Alpha | 5.4 | aten, KernelGen, pointwise | Computes the element-wise logical NOT EQUAL of the given input tensors. |
| 1093 | not_equal_ | Logic | Alpha | 5.4 | aten, KernelGen, pointwise | Computes element-wise not-equal comparison in-place. |
| 1094 | not_equal_scalar | Logic | Alpha | 5.4 | aten, KernelGen, pointwise | Computes the element-wise logical NOT EQUAL comparing a tensor to a scalar. |
| 1095 | nuclear_norm | Math | Alpha | 5.4 | aten, KernelGen | Computes the nuclear norm (sum of singular values) of a matrix. |
| 1096 | one_hot | NeuralNetwork | Stable | 5.0 | aten, nn.functional, KernelGen | Takes LongTensor with index values of shape (*) and returns a tensor of shape (*, num_classes)
that have zeros everywhere except where the index of last dimension matches the corresponding value
of the input tensor, in which case it will be 1. |
| 1097 | ones | Tensor | Stable | 2.1 | aten, skip_precision_check | Returns a tensor filled with the scalar value 1, with the shape defined
by the variable argument size. |
| 1098 | ones_like | Tensor | Stable | 2.1 | aten | Returns a tensor filled with the scalar value 1, with the same size as input. |
| 1099 | or_scalar | Math | Beta | 5.3 | aten, KernelGen | The scalar version of or_tensor. |
| 1100 | or_tensor | Math | Beta | 5.3 | aten, KernelGen | Computes the bitwise OR operation through the tensor dunder method with tensor operands. |
| 1101 | orgqr | LinearAlg | Alpha | 5.5 | aten, KernelGen | Computes the first n columns of a product of Householder matrices.
Alias for torch.linalg.householder_product. |
| 1102 | orgqr_out | LinearAlg | Alpha | 5.5 | aten, KernelGen | Computes the Householder matrix product into the supplied output tensor. |
| 1103 | ormqr | LinearAlg | Alpha | 5.4 | aten, KernelGen | Computes the matrix-matrix multiplication of a product of Householder matrices
with a general matrix. |
| 1104 | outer | BLAS | Stable | 2.0 | fused | Computes outer product of self and the input vector.
If the self tensor is a vector of size n and the input tensor is a vector of size m,
the out tensor (if specified) must be a matrix of size n * m. |
| 1105 | outplace_fused_experts | MoE | Stable | 5.3 | fused, Activation, vLLM | This operator allocates and returns a new output tensor. |
| 1106 | pack_padded_sequence | Tensor | Alpha | 5.5.0 | aten, KernelGen | Packs a padded batch of variable length sequences into a PackedSequence
data tensor together with the per-time-step batch sizes. |
| 1107 | pack_seq_triton | NeuralNetwork | Beta | 5.3 | fused, vLLM, DeepSeekV4 | Pack variable-length token sequences into a padded batched tensor. |
| 1108 | pad | NeuralNetwork | Stable | 2.1 | aten, pointwise, nn.functional | This pads a tenor using the specified mode. |
| 1109 | pad_circular | NeuralNetwork | Alpha | 5.5 | aten, IR, KernelGen | Pads the last one to three dimensions of an N-D tensor using circular
(periodic wrap-around) boundary values. Negative padding crops.
This is an IR representation, not a public API. |
| 1110 | pad_enum | NeuralNetwork | Alpha | 5.5.0 | aten, pointwise, nn.functional, KernelGen | Integer-mode dispatcher backing torch.nn.functional.pad. Pads an N-D
tensor where mode is an integer enum (0 reflect, 1 replicate,
2 circular, 3 constant); value is only used for constant padding. |
| 1111 | pad_packed_sequence | Tensor | Alpha | 5.5.0 | aten, KernelGen | Pads a packed batch of variable length sequences back into a dense
(T, B, *) tensor together with the per-batch-element sequence lengths. |
| 1112 | pad_sequence | Utility
NeuralNetwork | Beta | 5.5 | aten, sequence, rnn | Pads a list of variable length tensors with a given padding value and stacks them into a single padded batch tensor. |
| 1113 | padded_dense_to_jagged_forward | Tensor | Alpha | 5.5 | aten | Converts padded dense storage to a one- to five-level jagged tensor. |
| 1114 | pairwise_distance | Math | Alpha | 5.4 | aten, nn.functional | Computes the pairwise distance between input vectors, or between columns of input matrices.
Distances are computed using p-norm, with constant eps added to avoid division
by zero if p is negative. |
| 1115 | pdist | Math | Alpha | 5.4 | aten, KernelGen | Computes the p-norm distance between every pair of row vectors in the input.
Input must be a 2-D tensor of shape (N, M). Returns a tensor of shape
(N*(N-1)//2,) containing pairwise distances. |
| 1116 | pdist_backward | Math | Alpha | 5.4 | aten, KernelGen | Computes the gradient of pairwise distance computation. |
| 1117 | pdist_forward | Math | Alpha | 5.4 | aten, KernelGen | Computes the pairwise distance between rows of a matrix. |
| 1118 | per_token_group_quant_fp8 | Quantization | Beta | 5.3 | NoCPU, vLLM | Function to perform per-token-group quantization on an input tensor x.
It converts the tensor values into signed float8 values and returns the
quantized tensor along with the scaling factor used for quantization. |
| 1119 | permute_copy | Tensor | Alpha | 5.4 | aten, KernelGen | Creates and returns a copy of x with permuted dimensions. |
| 1120 | philox_normal_ | Distribution | Alpha | 5.5.0 | aten, KernelGen, pointwise | Fills the tensor in place with samples from a normal distribution with
the given mean and std, drawn from a stateless Philox RNG stream
identified by the (seed, offset) pair in key. |
| 1121 | pin_memory | Tensor | Alpha | 5.4 | aten, KernelGen | Public entry that pins a strided CPU tensor into page-locked host memory; delegates to _pin_memory. |
| 1122 | pinverse | BLAS | Alpha | 5.5 | aten, KernelGen | Computes the pseudoinverse of a matrix. |
| 1123 | pixel_shuffle | NeuralNetwork | Stable | 5.3 | aten, nn.functional | Rearranges elements in a tensor to a new tensor of different shape. |
| 1124 | pixel_unshuffle | NeuralNetwork | Stable | 5.3 | aten, KernelGen | Rearranges elements from a low-resolution feature map with many channels
into a higher-resolution feature map with fewer channels. |
| 1125 | pixel_unshuffle_out | NeuralNetwork | Beta | 5.0 | aten, KernelGen | A variant of pixel_unshuffle that assigns the output to the out tensor. |
| 1126 | poisson | Math | Beta | 5.3 | aten, KernelGen | Returns a tensor of the same size as input with each element sampled
from a Poisson distribution with rate given by the corresponding element in input. |
| 1127 | poisson_nll_loss | NeuralNetwork
Reduction | Alpha | 5.5 | aten, KernelGen | Computes the Poisson negative log likelihood loss. |
| 1128 | polar | Math | Stable | 3.0 | aten, pointwise | Constructs a complex tensor whose elements are Cartesian coordinates corresponding to
the polar coordinates with absolute value abs and angle angle. |
| 1129 | polygamma | Math | Alpha | 5.4 | aten | Computes the n-th derivative of the digamma function of the input (the polygamma function),
dispatching to dedicated digamma (n=0), trigamma (n=1), or Hurwitz-zeta (n>=2) Triton kernels. |
| 1130 | polygamma_ | Math | Alpha | 5.4 | aten | The in-place version of polygamma(). |
| 1131 | polygamma_out | Math | Alpha | 5.4 | aten | A variant of polygamma that allows the output to be assigned to the out tensor. |
| 1132 | post_layer_norm_residual | NeuralNetwork | Beta | 5.4 | fused | Fuses LayerNorm followed by a residual addition. |
| 1133 | pow_scalar | Math | Stable | 1.0 | aten | Takes the power of each element in input with exponent and returns a tensor with the result.
The input is a single float, while the exponent is a tensor. |
| 1134 | pow_tensor_scalar | Math | Stable | 1.0 | aten, pointwise | Takes the power of each element in input with exponent and returns a tensor with the result.
The input is a tensor, while the exponent is a float. |
| 1135 | pow_tensor_scalar_ | Math | Stable | 2.2 | aten, pointwise | This is the in-place version of pow_tensor_scalar(). |
| 1136 | pow_tensor_tensor | Math | Stable | 1.0 | aten, pointwise | Takes the power of each element in input with exponent and returns a tensor with the result.
The input is a tensor, while the exponent is also a tensor. |
| 1137 | pow_tensor_tensor_ | Math | Stable | 2.2 | aten, pointwise | This is the in-place version of pow_tensor_tensor(). |
| 1138 | prelu | NeuralNetwork | Stable | 5.3 | aten, Activation, pointwise, nn.functional, KernelGen | An activation function used in neural networks that improves upon ReLU (Rectified Linear Unit)
by allowing the network to learn the slope of negative inputs.
It performs an element-wise operation that keeps positive values and scales negative values
by a learnable parameter. |
| 1139 | prelu_kernel | NeuralNetwork | Alpha | 5.4 | aten, Activation, pointwise, KernelGen | Applies the element-wise Parametric ReLU (PReLU) activation: f(x)=max(0,x)+weight*min(0,x),
where weight is a learnable parameter with the same shape as the input. |
| 1140 | prelu_kernel_backward | Math | Alpha | 5.1 | aten, KernelGen | Computes backward gradients for Parametric ReLU (PReLU) forward pass.
PReLU scales negative inputs by a learnable per-channel weight. This backward
kernel computes gradients with respect to both input and weight. |
| 1141 | prod | LinearAlg | Stable | 2.0 | aten, Reduction | Returns the product of all elements in the input tensor. |
| 1142 | prod_dim_int | Reduction | Stable | 2.0 | aten | Returns the product of each row of the input tensor in the given dimension dim. |
| 1143 | put | Tensor | Alpha | 5.5 | aten, KernelGen | Copies the elements of source into self at the flattened (row-major)
positions given by index. When accumulate is True, the values are
added to the existing elements of self instead of overwriting them. |
| 1144 | put_ | Math | Alpha | 5.5 | aten, KernelGen | The in-place version of put(). |
| 1145 | put_out | Tensor | Alpha | 5.5 | aten, KernelGen | A variant of put() that writes the result into the out tensor. |
| 1146 | quantile | Tensor | Stable | 2.2 | aten | Computes the q-th quantiles of each row of the input tensor along the dimension dim. |
| 1147 | quantize_per_channel | Math | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for quantize_per_channel. Quantizes a float
tensor per channel with the given scales and zero_points along the
specified axis, producing a per-channel affine quantized tensor. |
| 1148 | quantize_per_channel_out | Math | Alpha | 5.5 | aten, KernelGen | A variant of quantize_per_channel() that writes the result into the out tensor. |
| 1149 | quantize_per_tensor | Math | Alpha | 5.5 | aten, KernelGen | Quantizes a float32 tensor to a quantized tensor (torch.quint8 / qint8 / qint32)
with the given scale and zero point, using round-half-to-even rounding and
clamping to the representable integer range. |
| 1150 | quantize_per_tensor_out | Math | Alpha | 5.5 | aten, KernelGen | A variant of quantize_per_tensor() that writes the result into the out
quantized tensor. Computed with the same Triton kernel as the base variant. |
| 1151 | quantized_batch_norm | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Applies batch normalization on a 4D (NCHW) quantized tensor. |
| 1152 | quantized_batch_norm_out | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | A variant of quantized_batch_norm() that writes the result into the out tensor. |
| 1153 | quantized_gru | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Quantized GRU (Gated Recurrent Unit) implementation using Triton fused gate kernel for efficient RNN inference. |
| 1154 | quantized_lstm | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Applies a multi-layer quantized LSTM over an input sequence. Takes the input sequence, initial hidden and cell states, and per-layer quantized weights, and returns the output sequence together with the final hidden and cell states. |
| 1155 | quantized_max_pool1d | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Applies 1D max pooling over a per-tensor quantized tensor. |
| 1156 | quantized_max_pool1d_out | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | A variant of quantized_max_pool1d() that writes the result into the out tensor. |
| 1157 | quantized_max_pool2d | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for quantized_max_pool2d. Applies 2D max pooling
over a quantized input tensor by pooling the underlying integer
representation. |
| 1158 | quantized_max_pool2d_out | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | A variant of quantized_max_pool2d() that writes the result into the out tensor. |
| 1159 | quantized_max_pool3d | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Applies 3D max pooling over a per-tensor quantized quint8 tensor. |
| 1160 | quantized_max_pool3d_out | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | A variant of quantized_max_pool3d() that writes the result into the out tensor. |
| 1161 | rad2deg | Math | Alpha | 5.3 | aten, KernelGen, pointwise | Converts each element from angles in radians to degrees. |
| 1162 | rad2deg_ | Math | Alpha | 5.3 | aten, KernelGen, pointwise | In-place version of rad2deg. |
| 1163 | rand | Distribution | Stable | 2.1 | aten | Returns a tensor filled with random numbers from a uniform distribution on the interval [0,1). |
| 1164 | rand_like | Distribution | Stable | 2.1 | aten | Returns a tensor with the same size as input that is filled with random numbers
from a uniform distribution on the interval [0,1). |
| 1165 | randint | Distribution | Stable | 5.1 | aten, KernelGen | Returns a tensor filled with random integers generated uniformly between low (inclusive) and high (exclusive). |
| 1166 | randint_like | Distribution | Alpha | 5.4 | aten, KernelGen | Returns a tensor with the same size as input that is filled with random integers
generated uniformly between 0 (inclusive) and high (exclusive). |
| 1167 | randn | Distribution | Stable | 2.1 | aten | Returns a tensor filled with random numbers from a normal distribution with mean 0
and variance 1 (also called the standard normal distribution). |
| 1168 | randn_like | Distribution | Stable | 2.1 | aten | Returns a tensor with the same size as input that is filled with random numbers
from a normal distribution with mean 0 and variance 1. |
| 1169 | random_ | Tensor | Alpha | 5.1 | skip_precision_check | Random sampling operator (random_). |
| 1170 | randperm | Distribution | Stable | 2.2 | aten, skip_precision_check | Returns a random permutation of integers from 0 to n - 1. |
| 1171 | range | Tensor | Alpha | 5.4 | aten, KernelGen | Returns a 1-D tensor of size floor(end - start) + 1 with values from start to
end with step 1. |
| 1172 | real | Tensor | Alpha | 5.5 | aten | Returns the real component of a complex tensor as a zero-copy view. For
non-complex tensors, returns the input tensor unchanged. |
| 1173 | reciprocal | Math | Stable | 1.0 | aten, pointwise | Returns a new tensor with the reciprocal of the elements of input. |
| 1174 | reciprocal_ | Math | Stable | 2.2 | aten, pointwise | This is the in-place version of reciprocal(). |
| 1175 | reflection_pad1d | NeuralNetwork | Stable | 5.3 | aten, pointwise, KernelGen | Pads the input 3D or 2D tensor (typically representing signals or sequences)
by reflecting the boundary values at the edges. |
| 1176 | reflection_pad1d_backward | Math | Alpha | 5.3 | aten, KernelGen | Computes the gradient of reflection_pad1d with respect to the input tensor. |
| 1177 | reflection_pad1d_out | NeuralNetwork | Stable | 5.3 | aten, pointwise, KernelGen | A variant of reflection_pad1d that assigns the output to out tensor. |
| 1178 | reflection_pad2d | NeuralNetwork | Stable | 5.3 | aten, pointwise, KernelGen | Pads the input 3D or 2D tensor (typically representing signals or sequences)
by reflecting the boundary values at the both edges. |
| 1179 | reflection_pad2d_backward | Math | Alpha | 5.4 | aten, KernelGen | Computes the gradient of reflection_pad2d with respect to the input tensor. |
| 1180 | reflection_pad2d_out | NeuralNetwork | Stable | 5.3 | aten, pointwise, KernelGen | A variant of reflection_pad2d that assigns the output to out tensor. |
| 1181 | reflection_pad3d | NeuralNetwork | Alpha | 5.4 | aten, pointwise, KernelGen | Pads the input 5D tensor by reflecting the boundary values at both edges
along the last three spatial dimensions (depth, height, width). |
| 1182 | reflection_pad3d_backward | Math | Alpha | 5.1 | aten, KernelGen | Computes the gradient of reflection_pad3d with respect to the input tensor. |
| 1183 | reglu | NeuralNetwork | Beta | 5.3 | fused, Transformer | Rectified Gated Linear Unit is a variant of GLU that uses ReLU instead of the sigmoid function for gating. |
| 1184 | relu | NeuralNetwork | Stable | 1.0 | aten, Activation, pointwise, nn.functional | Apply the RELU (Rectified Linear Unit) activation function element-wise. |
| 1185 | relu6 | NeuralNetwork | Stable | 5.3 | aten, pointwise, Activation, KernelGen | Applies the element-wise function f(x)=min(max(0,x),6).
This is a variation of the standard ReLU activation function that "caps" its output
at a maximum value of 6. |
| 1186 | relu6_ | NeuralNetwork | Alpha | 5.5.0 | aten, pointwise, Activation, KernelGen | In-place version of relu6(). Applies the element-wise function
f(x)=min(max(0,x),6) to the input tensor and stores the result back
into it. |
| 1187 | relu_ | NeuralNetwork | Stable | 2.2 | aten, pointwise, Activation | This is the in-place version of relu(). |
| 1188 | remainder | Math | Alpha | 5.4 | aten, KernelGen | Computes Python's modulus operation entrywise. The result has the same sign
as the divisor other and its absolute value is less than that of other. |
| 1189 | remainder_scalar | Math | Stable | 2.2 | aten | Computes Python's modulus operation entrywise. The result has the same sign
as the divisor other and its absolute value is less than that of other. |
| 1190 | remainder_scalar_ | Math | Stable | 2.2 | aten | This is the in-place version of remainder(). |
| 1191 | remainder_scalar_tensor | Math | Stable | 2.2 | aten | Computes Python's modulus operation entrywise. The result has the same sign
as the divisor other and its absolute value is less than that of other. |
| 1192 | remainder_tensor | Math | Stable | 2.2 | aten | Computes Python's modulus operation entrywise. The result has the same sign
as the divisor other and its absolute value is less than that of other. |
| 1193 | remainder_tensor_ | Math | Stable | 2.2 | aten | This is the in-place version of remainder(). |
| 1194 | renorm | Math | Alpha | 5.4 | aten, KernelGen | Returns a tensor where each sub-tensor along the given dimension is normalized such that the p-norm is lower than a max norm value. |
| 1195 | renorm_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of renorm(). |
| 1196 | repeat | Tensor | Stable | 2.1 | aten | Repeats this tensor along the specified dimensions. |
| 1197 | repeat_interleave_self_int | Tensor | Stable | 2.2 | aten, pointwise | Repeats elements of a tensor. The number of repetitions is specified as an integer repeats. |
| 1198 | repeat_interleave_self_tensor | Tensor | Stable | 2.2 | aten, pointwise | Repeats elements of a tensor. The number of repetitions is specified as a tensor repeats.
repeats is broadcasted to fit the shape of the given axis. |
| 1199 | repeat_interleave_tensor | Tensor | Stable | 2.2 | aten, pointwise | Repeats 0 repeats[0] times, 1 repeats[1] times, 2 repeats[2] times, etc. |
| 1200 | replication_pad1d | Tensor | Stable | 5.4 | aten, KernelGen | Pads the edge of a 1D input tensor by repeating the boundary values. |
| 1201 | replication_pad1d_backward | Tensor | Alpha | 5.4 | aten, KernelGen | Computes the gradient of replication_pad1d. |
| 1202 | replication_pad1d_out | Tensor | Stable | 5.4 | aten, KernelGen | A variant of replication_pad1d that assigns the output to the out tensor. |
| 1203 | replication_pad2d | Tensor | Alpha | 5.4 | aten, KernelGen | Pads the edge of a 2D input tensor by repeating the boundary values. |
| 1204 | replication_pad2d_backward | NeuralNetwork | Alpha | 5.4 | aten | Computes the gradient for replication_pad2d. Gradients from padded output are redistributed back to the original input boundaries via replication (edge-value duplication) semantics. |
| 1205 | replication_pad2d_backward_grad_input | NeuralNetwork | Alpha | 5.4 | aten | A variant of replication_pad2d_backward that writes gradients into a pre-allocated grad_input tensor instead of allocating a new one. |
| 1206 | replication_pad2d_out | Tensor | Alpha | 5.4 | aten, KernelGen | A variant of replication_pad2d that assigns the output to the out tensor. |
| 1207 | replication_pad3d | NeuralNetwork | Beta | 5.3 | aten | Pads the edge of a 3D input tensor by repeating the boundary values. |
| 1208 | replication_pad3d_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Accumulates output gradients into the clamped input positions used by
three-dimensional replication padding. |
| 1209 | reshape_and_cache | Attention | Stable | 3.0 | fused, vLLM | Store the key/value token states into the pre-allcated kv_cache buffers of paged attention. |
| 1210 | reshape_and_cache_flash | Attention | Stable | 3.0 | fused | Store the key/value token states into the pre-allcated kv_cache buffers of paged attention. |
| 1211 | resize | Tensor | Alpha | 5.4 | aten, KernelGen | Resizes the input tensor to the specified size. |
| 1212 | resize_ | Tensor | Alpha | 5.4 | aten, KernelGen | The in-place version of resize(). |
| 1213 | resize_as | Tensor | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for resize_as. |
| 1214 | resize_as_ | Tensor | Alpha | 5.4 | aten, KernelGen | The in-place version of resize_as(). |
| 1215 | resize_output | Math | Alpha | 5.3 | aten, KernelGen | Resizes tensor output storage and copies overlapping elements. |
| 1216 | resize_output_ | Math | Alpha | 5.4 | aten, KernelGen | Resizes the output tensor in-place to the given size. |
| 1217 | resolve_conj | Science | Stable | 2.1 | aten | Returns a new tensor with materialized conjugation if input's conjugate bit is set to True,
else returns input. The output tensor will always have its conjugate bit set to False. |
| 1218 | resolve_neg | Science | Stable | 2.1 | aten | Returns a new tensor with materialized negation if input's negative bit is set to True,
else returns input. The output tensor will always have its negative bit set to False. |
| 1219 | rms_norm | NeuralNetwork | Stable | 2.0 | aten, nn.functional, Reduction | Apply Root Mean Square Layer Normalization over a mini-batch of inputs. |
| 1220 | rms_norm_w8a16_fp8 | NeuralNetwork | Alpha | 5.4 | NoCPU, Normalization, Quantization | Applies Root Mean Square Layer Normalization to BF16 activations using
group-wise FP8 E4M3 weights and per-group scales. |
| 1221 | rms_norm_w8a16_int8 | NeuralNetwork | Alpha | 5.4 | NoCPU, Normalization, Quantization | Applies Root Mean Square Layer Normalization to BF16 activations using
group-wise INT8 weights and per-group scales. |
| 1222 | rnn_relu | Math | Alpha | 5.4 | aten, KernelGen, NoCPU | Triton kernel implementation for rnn_relu. |
| 1223 | rnn_tanh | NeuralNetwork | Beta | 5.5 | aten, NoCPU | Pure Triton implementation for the rnn_tanh input overload. |
| 1224 | rnn_tanh_data | NeuralNetwork | Beta | 5.5 | aten, NoCPU | Pure Triton implementation for the rnn_tanh data overload. |
| 1225 | roll | BLAS | Beta | 5.3 | aten, KernelGen | Roll the tensor input along the given dimension(s). Elements that are shifted beyond the last position
are re-introduced at the first position. |
| 1226 | rot90 | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for rot90. |
| 1227 | round | Math | Beta | 5.3 | aten, pointwise | Rounds elements of input to the nearest integer. |
| 1228 | round_ | Math | Beta | 5.3 | aten, pointwise | The inplace version of round. |
| 1229 | round_out | Math | Beta | 5.3 | aten, pointwise | A variant of round that assigns the output to the specifiec out. |
| 1230 | row_indices | Math | Alpha | 5.4 | aten, KernelGen | Returns the row indices of a column-compressed (CSC or BSC) sparse tensor. |
| 1231 | row_indices_copy | Math | Alpha | 5.5 | aten, KernelGen | Returns the row indices of a column-compressed (CSC or BSC) sparse tensor as a contiguous strided tensor. |
| 1232 | row_indices_copy_out | Math | Alpha | 5.5 | aten, KernelGen | A variant of row_indices_copy() that writes the result into the out tensor. |
| 1233 | row_stack | Tensor | Alpha | 5.5.0 | aten, KernelGen | Stack tensors in sequence vertically (row wise). Alias of vstack. |
| 1234 | row_stack_out | Tensor | Alpha | 5.5.0 | aten, KernelGen | A variant of row_stack() that writes the result into the out tensor. |
| 1235 | rrelu | Math | Alpha | 5.5.0 | aten, KernelGen | Applies the randomized leaky ReLU (RReLU) function element-wise. In training
mode the slope for negative inputs is drawn uniformly from [lower, upper],
while in evaluation mode the average of lower and upper is used. |
| 1236 | rrelu_ | NeuralNetwork | Alpha | 5.5.0 | aten, KernelGen, pointwise | In-place Randomized Leaky ReLU (RReLU). Applies RReLU in place: positive
inputs are passed through unchanged, while negative inputs are multiplied
by a slope. During training the slope is sampled uniformly from
[lower, upper] per element, and at evaluation time the constant slope
(lower + upper) / 2 is used. |
| 1237 | rrelu_with_noise | NeuralNetwork | Beta | 5.5 | aten | Triton kernel implementation for rrelu_with_noise |
| 1238 | rrelu_with_noise_ | NeuralNetwork | Beta | 5.5 | aten | Triton kernel implementation for rrelu_with_noise_ |
| 1239 | rrelu_with_noise_backward | NeuralNetwork | Beta | 5.0 | aten, KernelGen | Computes the gradient of the Randomized Leaky ReLU (RReLU) activation function with respect to
its input during backpropagation. It uses the noise tensor generated in the forward pass
to correctly apply the slope to negative input values. |
| 1240 | rrelu_with_noise_functional | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for rrelu_with_noise_functional. |
| 1241 | rshift_scalar | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Applies a bitwise right shift to an integer tensor with a scalar shift value. |
| 1242 | rshift_scalar_out | Math | Alpha | 5.4 | aten, pointwise, KernelGen | A variant of rshift() that assigns the output to the given out parameter, with a scalar shift value. |
| 1243 | rshift_tensor | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Applies a bitwise right shift to an integer tensor with a tensor shift value. |
| 1244 | rshift_tensor_out | Math | Alpha | 5.4 | aten, pointwise, KernelGen | A variant of rshift() that assigns the output to the given out parameter, with a tensor shift value. |
| 1245 | rsqrt | Math | Stable | 1.0 | aten, pointwise | Returns a new tensor with the reciprocal of the square-root of each of the elements of input. |
| 1246 | rsqrt_ | Math | Stable | 2.2 | aten, pointwise | The in-place version of rsqrt(). |
| 1247 | rsub_scalar | Math | Alpha | 5.3 | aten, KernelGen | Substracts other, scaled by alpha, from input. This is the scalar version. |
| 1248 | rsub_tensor | Math | Alpha | 5.3 | aten, KernelGen | Substracts other, scaled by alpha, from input. This is the tensor version. |
| 1249 | rwkv_ka_fusion | RWKV | Stable | 4.1 | fused | Merges, aligns, and enhances features from different data sources or spatial directions
using the efficient, linear-time RWKV framework. |
| 1250 | rwkv_mm_sparsity | RWKV | Stable | 4.1 | fused | Optimized, lossless sparse matrix multiplication in RWKV-7 models. |
| 1251 | safe_softmax | NeuralNetwork | Alpha | 5.3 | aten, IR, KernelGen | Apply a softmax function. Note this version may not be functional. |
| 1252 | sample_dirichlet | Math | Alpha | 5.5 | aten, KernelGen | Draws samples from a Dirichlet distribution parameterized by alpha. |
| 1253 | scalar_tensor | Tensor | Alpha | 5.4 | aten | Creates a 0-dimensional (scalar) tensor from a Python numeric value.
The tensor's dtype can be specified, otherwise inferred from the input value. |
| 1254 | scaled_dot_product_attention | NeuralNetwork | Stable | 2.2 | nn.functional, Attention | Computes scaled dot product attention on query, key and value tensors,
using an optional attention mask if passed and applying dropout
if a probability greater than 0.0 is specified.
The optional scale argument can only be specified as a keyword argument. |
| 1255 | scaled_dot_product_attention_backward | NeuralNetwork | Stable | 2.2 | nn.functional, Attention | The backward case for scaled_dot_product_attention. |
| 1256 | scaled_dot_product_attention_forward | NeuralNetwork | Stable | 2.2 | nn.functional, Attention | The forward case for scaled_dot_product_attention. |
| 1257 | scaled_dot_product_attention_math | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Computes scaled dot-product attention using the math-based implementation. |
| 1258 | scaled_dot_product_attention_math_for_mps | NeuralNetwork | Alpha | 5.5.0 | aten, KernelGen | Computes scaled dot-product attention using the math-based implementation for the MPS backend. |
| 1259 | scaled_dot_product_cudnn_attention | NeuralNetwork | Alpha | 5.4 | aten, NoCPU, KernelGen | Computes scaled dot product attention using the cuDNN attention API
interface, returning output, log-sum-exp, and auxiliary tensors for
backward computation. |
| 1260 | scaled_dot_product_cudnn_attention_backward | NeuralNetwork | Beta | 5.4 | aten, NoCPU | Backward kernel for FlashAttention, computing gradients of queries, keys, values, and attention outputs efficiently. |
| 1261 | scaled_dot_product_efficient_attention | NeuralNetwork | Alpha | 5.4 | KernelGen, nn.functional, Attention, aten | Computes the efficient memory attention for scaled_dot_product_attention.
This is a composite operator that wraps scaled_dot_product_attention_forward
and additionally returns log-sumexp and dropout RNG state. |
| 1262 | scaled_dot_product_efficient_attention_backward | NeuralNetwork | Beta | 5.4 | aten, NoCPU | Backward kernel for FlashAttention, computing gradients of queries, keys, values, and attention outputs efficiently. |
| 1263 | scaled_dot_product_flash_attention | NeuralNetwork | Alpha | 5.4 | aten, NoCPU, KernelGen | Run the scaled dot product FlashAttention forward operation. |
| 1264 | scaled_dot_product_flash_attention_backward | NeuralNetwork | Beta | 5.4 | aten, NoCPU | Backward kernel for FlashAttention, computing gradients of queries, keys, values, and attention outputs efficiently. |
| 1265 | scaled_dot_product_fused_attention_overrideable | NeuralNetwork | Alpha | 5.4 | aten, Attention, KernelGen | Computes scaled dot product attention on query, key and value tensors, using an optional attention mask if passed. Returns extra values including logsumexp, cumulative sequence lengths, max sequence lengths, philox RNG state, and debug attention mask. |
| 1266 | scaled_dot_product_fused_attention_overrideable_backward | NeuralNetwork | Alpha | 5.5.0 | aten, KernelGen, NoCPU | Backward pass of the overrideable fused scaled dot product attention, computing
gradients of query, key, value and attention bias for privateuse1-style backends. |
| 1267 | scaled_grouped_mm | NeuralNetwork | Beta | 5.4 | MoE | Performs grouped matrix multiplication with row-wise and column-wise scaling,
commonly used by quantized Mixture-of-Experts (MoE) workloads. |
| 1268 | scaled_grouped_mm_v2 | NeuralNetwork | Alpha | 5.5.0 | aten, KernelGen, MoE | Recipe-driven grouped scaled matrix multiply: a stack of per-group GEMMs
whose operands carry per-row (RowWise) or per-tensor (TensorWise) decoding
scales, with the jagged dimension described by an int32 offs tensor.
Backs quantized Mixture-of-Experts layers. |
| 1269 | scaled_mm | BLAS | Beta | 5.4 | aten | Scaled FP8 matrix multiplication with FP32 scales and optional bias. |
| 1270 | scaled_mm_out | BLAS | Beta | 5.4 | aten | A variant of _scaled_mm that writes the result into out. |
| 1271 | scaled_softmax_backward | Reduction | Stable | 4.2 | aten | The backward pass for a scaled softmax function, commonly used in Scaled Dot-Product Attention (SDPA)
within Transformer models, computes the gradient of the loss with respect to the input logits,
incorporating a scaling factor to stabilize training. |
| 1272 | scaled_softmax_forward | Reduction | Stable | 4.2 | aten | The backward pass for a scaled softmax function, commonly used in Scaled Dot-Product Attention (SDPA)
within Transformer models, computes the gradient of the loss with respect to the input logits,
incorporating a scaling factor to stabilize training. |
| 1273 | scatter_add | Tensor | Alpha | 5.4 | aten, KernelGen | Out-of-place version of scatter_add_: adds all values from the tensor src
into inp at the indices specified in the index tensor along dimension
dim and returns the result without modifying the input. |
| 1274 | scatter_add_ | Tensor | Stable | 4.2 | aten | Adds all values from the tensor src into self at the indices specified
in the index tensor in a similar fashion as scatter_().
For each value in src, it is added to an index in self which is specified
by its index in src for dimension != dim and by the corresponding value
in index for dimension = dim. |
| 1275 | scatter_reduce | Tensor | Stable | 2.2 | aten | Writes all values from the tensor src into provided tensor at the indices
specified in the index tensor. For each value in src, its output index
is specified by its index in src for dimension != dim and by the corresponding value
in index for dimension = dim.
The optional reduce argument allows specification of an optional reduction operation,
which is applied to all values in the tensor src into the tensor at the indices
specified in the index. |
| 1276 | scatter_reduce_ | Tensor | Stable | 3.0 | aten, KernelGen | This is the in-place version of scatter_reduce(). |
| 1277 | scatter_reduce_two | Reduction | Alpha | 5.5 | aten, KernelGen | Applies a reduction to source values scattered at the indices specified by index.
This entry covers the functional scatter_reduce.two ATen overload. |
| 1278 | scatter_reduce_two_ | Reduction | Alpha | 5.3 | aten, KernelGen | A specific low-level ATen operator primarily encountered during model compilation
or when using advanced backends like TensorRT or MPS. |
| 1279 | scatter_reduce_two_out | Reduction | Alpha | 5.5 | aten, KernelGen | Applies a scatter reduction and writes the result to the provided out tensor.
This entry covers the scatter_reduce.two_out ATen overload. |
| 1280 | scatter_src | Tensor | Stable | 2.2 | aten | Writes all values from the tensor src into provided tensor at the indices
specified in the index tensor. For each value in src, its output index
is specified by its index in src for dimension != dim and by the corresponding value
in index for dimension = dim.
The optional reduce argument allows specification of an optional reduction operation,
which is applied to all values in the tensor src into the tensor at the indices
specified in the index. |
| 1281 | scatter_src_ | Tensor | Stable | 3.0 | aten | This is the in-place version of scatter_src(). |
| 1282 | searchsorted | Tensor | Beta | 5.4 | aten, KernelGen | Finds insertion indices for tensor values in sorted innermost-dimension boundaries. |
| 1283 | searchsorted_out | Tensor | Beta | 5.4 | aten, KernelGen | A variant of searchsorted.Tensor that assigns the result to out. |
| 1284 | searchsorted_scalar | Tensor | Beta | 5.4 | aten, KernelGen | Finds insertion indices for a scalar value in one-dimensional sorted boundaries. |
| 1285 | searchsorted_scalar_out | Tensor | Beta | 5.4 | aten, KernelGen | A variant of searchsorted.Scalar that assigns the result to out. |
| 1286 | segment_reduce | Reduction | Beta | 5.4 | aten | Reduces contiguous segments of a tensor along the specified axis. Segments are described
by lengths or offsets, and supported reductions include sum, mean, max, min, and prod. |
| 1287 | segment_reduce_backward | Reduction | Beta | 5.4 | aten | Computes gradients for segment_reduce with lengths or offsets based segment definitions. |
| 1288 | segment_reduce_backward_out | Reduction | Beta | 5.4 | aten | A variant of _segment_reduce_backward that assigns the gradient input to the out tensor. |
| 1289 | segment_reduce_out | Reduction | Beta | 5.4 | aten | A variant of segment_reduce that assigns the reduced segments to the out tensor. |
| 1290 | select_backward | NeuralNetwork | Beta | 5.3 | aten | Calculate the gradient during the backward pass in the neural network. |
| 1291 | select_copy | Tensor | Alpha | 5.5 | aten, KernelGen | Returns a copy of the input with the selected slice along the given
dimension at the given index removed. This is the out-of-place counterpart
of torch.select(): the output has one dimension less than the input and
is freshly created instead of aliasing the input, equivalent to
self.select(dim, index).clone(). |
| 1292 | select_scatter | Tensor | Stable | 2.2 | aten | Embeds the values of the src tensor into input at the given index.
This function returns a tensor with fresh storage; it does not create a view. |
| 1293 | selu | NeuralNetwork | Stable | 5.3 | aten, pointwise, nn.functional, Activation, KernelGen | Applies an element-wise activation function that induces self-normalizing properties in neural networks.
It scales the Exponential Linear Unit (ELU) to ensure activations remain close to zero mean and unit variance. |
| 1294 | selu_ | NeuralNetwork | Stable | 5.3 | aten, pointwise, Activation, KernelGen | This is the in-place version of selu. |
| 1295 | set_ | Math | Alpha | 5.5 | aten, KernelGen | Reset tensor to an empty tensor with zero storage. |
| 1296 | set_source_Tensor | Math | Alpha | 5.5 | aten, KernelGen | Set tensor to share storage, shape, and strides with source tensor. |
| 1297 | set_source_Tensor_storage_offset | Math | Alpha | 5.5 | aten, KernelGen | Set tensor storage from another tensor with explicit offset, size, stride. |
| 1298 | sgn | Math | Alpha | 5.4 | aten, KernelGen | Computes the sign of each element in the input tensor, element-wise.
This function extends sign() to complex tensors. |
| 1299 | sgn_ | Math | Stable | 5.3 | aten, KernelGen | Computes the sign of each element in the self tensor, element-wise.
This function is an extension of sign() designed to handle complex tensors
in addition to real-valued ones. |
| 1300 | sgn_out | Math | Alpha | 5.4 | aten, KernelGen | Writes the element-wise sign of the input tensor to the out tensor.
This function extends sign() to complex tensors. |
| 1301 | sigmoid | NeuralNetwork | Stable | 2.0 | aten, pointwise | Computes the expit (also known as the logistic sigmoid function) of the elements of input. |
| 1302 | sigmoid_ | NeuralNetwork | Stable | 2.2 | aten, pointwise | The in-place version of sigmoid(). |
| 1303 | sigmoid_backward | NeuralNetwork | Stable | 3.0 | aten, pointwise | The backward version of sigmoid(). |
| 1304 | sign | Math | Alpha | 5.4 | aten, KernelGen, pointwise | Returns a new tensor with the sign of the elements of input.
For real numbers: 1 if x > 0, -1 if x < 0, 0 if x == 0, 0 if x is NaN.
Complex dtypes are not supported (use torch.sgn instead). |
| 1305 | sign_ | Math | Alpha | 5.5 | aten, KernelGen, pointwise | The in-place version of sign(), writing the element-wise sign back
into the input tensor. |
| 1306 | sign_out | Math | Alpha | 5.4 | aten, KernelGen, pointwise | Out-variant of sign. Writes the element-wise sign to the out tensor. |
| 1307 | signbit | Tensor | Beta | 5.3 | aten, pointwise | Tests if each element of input has its sign bit set or not. |
| 1308 | signbit_out | Tensor | Beta | 5.3 | aten, pointwise | A variant of signbit that assigns the output to out. |
| 1309 | silu | NeuralNetwork | Stable | 1.0 | aten, pointwise, nn.functional | SiLU (Sigmoid Linear Unit), a simple approximation of ReLU but
without any discontinuity of the first derivative. |
| 1310 | silu_ | NeuralNetwork | Stable | 2.2 | aten, nn.functional, pointwise | The in-place version of silu(). |
| 1311 | silu_and_mul | Activation | Stable | 2.0 | fused, pointwise, vLLM | A custom operator in vLLM as activation function for SwiGLU. |
| 1312 | silu_and_mul_out | Activation | Stable | 2.0 | fused, pointwise, vLLM | A variant of silu_and_mul with an extra out argument. |
| 1313 | silu_and_mul_with_clamp | Activation | Stable | 5.3 | fused, pointwise, vLLM | A custom operator in vLLM as activation function for SwiGLU. |
| 1314 | silu_and_mul_with_clamp_out | Activation | Stable | 5.3 | fused, pointwise, vLLM | A variant of silu_and_mul_with_clamp with an extra out argument. |
| 1315 | silu_backward | NeuralNetwork | Stable | 3.0 | aten, pointwise | A variant of silu() for backward case. |
| 1316 | sin | Math | Stable | 2.0 | aten, pointwise | Returns a new tensor with the sine of the elements in the input tensor,
where each value in this input tensor is in radians. |
| 1317 | sin_ | Math | Stable | 2.2 | aten, pointwise | The in-place version of sin(). |
| 1318 | sinc | Math | Alpha | 5.4 | aten, KernelGen | Computes the normalized sinc function sin(π·x) / (π·x) for each element of the input. |
| 1319 | sinc_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of sinc(). |
| 1320 | sinh | Math | Alpha | 5.4 | aten, KernelGen | Computes the hyperbolic sine (e^x - e^{-x}) / 2 element-wise. |
| 1321 | sinh_ | Math | Stable | 5.3 | aten, KernelGen | Computes the hyperbolic sine (e^x-e^{-x})/2 of each element in a tensor.
This is an in-place version. |
| 1322 | skip_layer_norm | NeuralNetwork | Stable | 2.0 | fused, Transformer | An optimized operation used in Transformer models to improve performance
by combining residual connection (skip connection) addition and Layer Normalization
(LayerNorm) into a single kernel. |
| 1323 | slice | Tensor | Alpha | 5.4 | aten, KernelGen | Slices the input tensor along the specified dimension.
Returns a view of the original tensor with the given dimension sliced from start to end. |
| 1324 | slice_backward | NeuralNetwork | Stable | 5.0 | aten | An automatic differentiation (autograd) function that computes the gradient of a tensor slicing operation
(tensor[start:end]) during backpropagation. |
| 1325 | slice_copy | Tensor | Alpha | 5.5 | aten, KernelGen | Performs the same operation as torch.slice, but all output tensors are freshly
created instead of aliasing the input. Returns a new tensor containing the
selected slice of self along the given dimension. |
| 1326 | slice_copy_out | Tensor | Alpha | 5.5 | aten, KernelGen | A variant of slice_copy() that assigns the output to an out tensor. |
| 1327 | slice_scatter | Tensor | Stable | 2.2 | aten | Embeds the values of the src tensor into input at the given dimension.
This function returns a tensor with fresh storage; it does not create a view. |
| 1328 | slogdet | LinearAlg | Alpha | 5.5 | aten, KernelGen | Computes the sign and natural logarithm of the absolute value of the
determinant of a square matrix (or a batch of square matrices) using LU
decomposition with partial pivoting. This is the public alias for
torch.linalg.slogdet. |
| 1329 | slow_conv2d_forward | NeuralNetwork | Alpha | 5.5.0 | aten, KernelGen | An internal slow reference implementation of the 2-D convolution forward
pass that applies a 2-D cross-correlation over the input with the given
kernel. |
| 1330 | smm | Math | Alpha | 5.4 | aten, KernelGen | Performs a matrix multiplication of the sparse (COO) matrix self with the
dense matrix mat using a fused Triton kernel. The sparse operand is
materialized to dense, the product is computed with tl.dot, and the COO
output (indices + values) is written directly to match torch.smm
semantics: every row that appears in the sparse input contributes all
output columns. |
| 1331 | smooth_l1_loss | NeuralNetwork | Alpha | 5.3 | aten, pointwise, nn.functional | Compute the smooth L1 loss between input and target tensors. |
| 1332 | smooth_l1_loss_backward | NeuralNetwork | Alpha | 5.3 | aten, pointwise, nn.functional | Compute the gradient of smooth L1 loss with respect to the input tensor. |
| 1333 | sobol_engine_ff_ | NeuralNetwork | Alpha | 5.5 | aten, pointwise, KernelGen | Fast-forward Sobol quasi-random number generator state by n steps using Gray code. |
| 1334 | sobol_engine_initialize_state_ | Math | Alpha | 5.5.0 | aten, pointwise, random | Initializes Sobol quasi-random number generator state with direction numbers.
This is a low-level operation that fills a (dimension, 30) state tensor with
pre-computed Sobol direction numbers used for generating low-discrepancy sequences. |
| 1335 | soft_margin_loss | NeuralNetwork | Beta | 5.3 | nn.functional, KernelGen | Compute the soft margin loss. |
| 1336 | soft_margin_loss_backward | Math | Alpha | 5.4 | aten, KernelGen | Backward pass for soft margin loss, a two-class classification logistic loss between input and target tensors. |
| 1337 | softmax | NeuralNetwork | Stable | 1.0 | aten, nn.functional | Apply a softmax function. |
| 1338 | softmax_backward | Reduction | Stable | 3.0 | aten, nn.functional | The backward version of softmax(). |
| 1339 | softmax_backward_out | Reduction | Stable | 3.0 | aten, nn.functional | A variant of softmax_backward(). |
| 1340 | softmax_out | NeuralNetwork | Stable | 1.0 | aten, nn.functional | Apply a softmax function, with given out. |
| 1341 | softplus | NeuralNetwork | Stable | 4.0 | aten, nn.functional, pointwise | Applies element-wise, the function Softplus. |
| 1342 | softplus_backward | NeuralNetwork | Alpha | 5.4 | aten, Activation, pointwise | The backward version of softplus(). |
| 1343 | softshrink | NeuralNetwork | Stable | 5.3 | aten, nn.functional, Activation, KernelGen | Applies the soft shrinkage function element-wise to an input tensor.
It is an activation function often used in signal processing and sparse representation,
such as image denoising. |
| 1344 | softshrink_backward | NeuralNetwork | Alpha | 5.5.0 | aten, nn.functional, Activation, KernelGen | Computes the gradient of the softshrink activation. Gradients flow through
only where the magnitude of the original input exceeds lambd; elsewhere
the gradient is zero. |
| 1345 | softshrink_out | NeuralNetwork | Stable | 5.3 | aten, nn.functional, Activation, KernelGen | This is a variant of softshrink that supports an output tensor. |
| 1346 | sort | Tensor | Stable | 2.2 | aten, skip_precision_check | Sorts the elements of the input tensor along a given dimension in ascending order by value. |
| 1347 | sort_stable | Tensor | Stable | 3.0 | aten, skip_precision_check | Sorts the elements of the input tensor along a given dimension in ascending order by value.
This is a variant of sort() where stable is set to True to preserve the order of equivalent elements. |
| 1348 | sparse_attn_triton | NeuralNetwork | Beta | 5.3 | fused, NoCPU | Sparse attention with attention-sink. |
| 1349 | sparse_mla_fwd_interface | DSA | Stable | 5.3 | fused | A generic interface for sparse MLA (Multi-head Latent Attention) for DeepSeek v3/v3.2.
It is currently not exposed as a standalone operator for use. |
| 1350 | sparse_sampled_addmm | BLAS | Alpha | 5.4 | aten | Computes alpha * (mat1 @ mat2) * spy(input) + beta * input, where input is a sparse CSR tensor
and spy(input) keeps only its sparsity pattern. The result shares the CSR pattern with input. |
| 1351 | sparse_sampled_addmm_out | BLAS | Alpha | 5.4 | aten | A variant of sparse_sampled_addmm that assigns the result to the provided sparse CSR out tensor. |
| 1352 | sparse_semi_structured_addmm | BLAS | Alpha | 5.4 | aten, KernelGen | Performs a matrix multiplication of the sparse semi-structured
(2:4 sparsity) matrices mat1 and mat2 with input added. |
| 1353 | sparse_semi_structured_linear | BLAS | Alpha | 5.5 | aten, KernelGen | Performs a semi-structured (2:4) sparse linear transformation
with optional bias and activation. |
| 1354 | sparse_semi_structured_mm | BLAS | Alpha | 5.4 | aten, KernelGen | Performs a sparse semi-structured matrix multiplication of a dense matrix with a 2:4 sparsity pattern against a dense matrix. |
| 1355 | spdiags | Math | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for _spdiags that builds a sparse matrix from diagonals. |
| 1356 | special_airy_ai | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the Airy function Ai(x) for each element of the input tensor. |
| 1357 | special_airy_ai_out | Math | Alpha | 5.4 | aten, pointwise, KernelGen | A variant of special_airy_ai with output saved to provided out. |
| 1358 | special_bessel_j0 | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the Bessel function of the first kind of order 0 for each element
of input. |
| 1359 | special_bessel_j1 | Math | Alpha | 5.4 | aten, KernelGen, pointwise | Computes the Bessel function of the first kind of order 1 for each element of input. |
| 1360 | special_bessel_y0 | Math | Alpha | 5.4 | aten, KernelGen, pointwise | Computes the Bessel function of the second kind of order 0 for each element of input. |
| 1361 | special_bessel_y1 | Math | Alpha | 5.4 | aten, KernelGen | Computes the Bessel function of the second kind of order 1 (Y_1(x)) for each element
in the input tensor. |
| 1362 | special_chebyshev_polynomial_t | Math | Alpha | 5.5 | aten, KernelGen | Computes the Chebyshev polynomial of the first kind
:math:T_{n}(\\text{input}). |
| 1363 | special_chebyshev_polynomial_t_out | Math | Alpha | 5.5 | aten, KernelGen | A variant of special_chebyshev_polynomial_t() with output saved to
provided out. |
| 1364 | special_chebyshev_polynomial_u | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the Chebyshev polynomial of the second kind U_n(x) for each element
of the input tensor. |
| 1365 | special_chebyshev_polynomial_v | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for special_chebyshev_polynomial_v. |
| 1366 | special_chebyshev_polynomial_w | Math | Alpha | 5.4 | aten, KernelGen | Computes the Chebyshev polynomial of the fourth kind
:math:W_{n}(\\text{input}). |
| 1367 | special_chebyshev_polynomial_w_out | Math | Alpha | 5.4 | aten, KernelGen | A variant of special_chebyshev_polynomial_w() with output saved to
provided out. |
| 1368 | special_digamma | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the digamma function (logarithmic derivative of the gamma function).
Alias for digamma; delegates to the digamma kernel. |
| 1369 | special_entr | Math | Alpha | 5.5 | aten, KernelGen | Computes the entropy function element-wise: entr(x) = -x * ln(x) for x > 0, 0 for x == 0, -inf for x < 0. |
| 1370 | special_erf | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the error function of input element-wise.
Alias for erf; delegates to the erf kernel. |
| 1371 | special_erfc | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the complementary error function. |
| 1372 | special_erfcx | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the scaled complementary error function for each element of input. |
| 1373 | special_erfinv | Math | Alpha | 5.4 | aten, KernelGen | Computes the inverse error function element-wise.
Maps values in (-1, 1) to the real line. |
| 1374 | special_erfinv_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of special_erfinv(). |
| 1375 | special_erfinv_out | Math | Alpha | 5.4 | aten, KernelGen | A variant of special_erfinv() that assigns the output to the out tensor. |
| 1376 | special_exp2 | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the base two exponential function of input element-wise.
Alias for exp2; delegates to the exp2 kernel. |
| 1377 | special_expit | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the expit (sigmoid) function element-wise. Returns 1 / (1 + exp(-x)). |
| 1378 | special_expm1 | Math | Alpha | 5.5 | aten, pointwise, KernelGen | Computes the exponential of the elements minus 1 of input.
Alias for expm1; delegates to the expm1 kernel. |
| 1379 | special_gammainc | Math | Alpha | 5.4 | aten, KernelGen | Computes the regularized lower incomplete gamma function P(a, x) element-wise. |
| 1380 | special_gammaincc | Math | Alpha | 5.4 | aten, KernelGen, pointwise | Computes the regularized upper incomplete gamma function Q(a, x) element-wise.
Out-of-place counterpart of igammac_; delegates to the igammac kernel. |
| 1381 | special_gammaln | Math | Alpha | 5.4 | aten, KernelGen | Computes the logarithm of the absolute value of the Gamma function on input. |
| 1382 | special_gammaln_out | Math | Alpha | 5.4 | aten, KernelGen | Out-of-place variant of special_gammaln that writes the result to the out tensor. |
| 1383 | special_hermite_polynomial_h | Math | Alpha | 5.1 | aten, KernelGen | Computes the physicist's Hermite polynomial H_n(x) of degree n at input. |
| 1384 | special_hermite_polynomial_he | Math | Alpha | 5.4 | aten, KernelGen | Probabilists' Hermite polynomial He_n(input). |
| 1385 | special_i0 | Math | Alpha | 5.5 | aten, pointwise, KernelGen | Computes the zeroth order modified Bessel function of the first kind
for each element of input. |
| 1386 | special_i0_out | Math | Alpha | 5.5 | aten, pointwise, KernelGen | A variant of special_i0() with output saved to provided out. |
| 1387 | special_i0e | Math | Stable | 5.3 | aten, pointwise, KernelGen | Computes the exponentially scaled zeroth order modified Bessel function
of the first kind for each element of input. |
| 1388 | special_i0e_out | Math | Stable | 5.3 | aten, pointwise, KernelGen | A variant of special_i0e() with output saved to provided out.. |
| 1389 | special_i1 | Math | Stable | 5.3 | aten, pointwise, KernelGen | Computes the modified Bessel function of the first kind of order 1 (I_1(x)) for each element
in the input tensor, designed for special mathematical functions. |
| 1390 | special_i1_out | Math | Stable | 5.3 | aten, pointwise, KernelGen | A variant of special_i1 that allows the output to be assigned to another tensor. |
| 1391 | special_i1e | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the exponentially scaled modified Bessel function of the first kind
of order 1, i1e(x) = i1(x) * exp(-|x|), for each element in the input tensor. |
| 1392 | special_i1e_out | Math | Alpha | 5.4 | aten, pointwise, KernelGen | A variant of special_i1e() that saves the output to the provided out tensor. |
| 1393 | special_laguerre_polynomial_l | Math | Alpha | 5.5 | aten, pointwise | Computes the Laguerre polynomial :math:L_n(x) element-wise for tensor
and scalar x/n overloads, including destination-passing variants. |
| 1394 | special_legendre_polynomial_p | Math | Alpha | 5.4 | aten, KernelGen | Computes the Legendre polynomial P_n(x) of degree n for each element in the input tensor,
designed for special mathematical functions. |
| 1395 | special_log1p | Math | Alpha | 5.4 | aten, KernelGen | Computes log(1 + x) for each element of the input tensor. |
| 1396 | special_log1p_out | Math | Alpha | 5.4 | aten, nn.functional, KernelGen | A variant of special.log1p that allows the output to be assigned to another tensor. |
| 1397 | special_log_ndtr | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the log of the cumulative distribution function of the standard
normal distribution (log_ndtr(x)) for each element in the input tensor. |
| 1398 | special_log_softmax | Math | Alpha | 5.4 | aten, nn.functional, KernelGen | Applies the log of the softmax function along a given dimension. |
| 1399 | special_logit | Math | Alpha | 5.4 | aten, KernelGen | Returns a new tensor with the logit of the elements of input.
Input is clamped to [eps, 1 - eps] when eps is not None. |
| 1400 | special_logit_out | Math | Alpha | 5.4 | aten, KernelGen | A variant of special_logit that allows the output to be assigned to another tensor. |
| 1401 | special_logsumexp | Reduction | Alpha | 5.4 | aten, KernelGen | Computes the natural logarithm of the sum of exponentials of each row
of the input tensor in the given dimension dim. |
| 1402 | special_modified_bessel_i0 | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the modified Bessel function of the first kind of order 0 (I_0(x)) for each element
in the input tensor, designed for special mathematical functions. |
| 1403 | special_modified_bessel_i0_out | Math | Alpha | 5.4 | aten, pointwise, KernelGen | A variant of special_modified_bessel_i0 that writes the modified Bessel
function of the first kind of order 0 (I_0(x)) into a preallocated output tensor. |
| 1404 | special_modified_bessel_i1 | Math | Alpha | 5.5.0 | aten, pointwise, KernelGen | Computes the modified Bessel function of the first kind of order 1
(I_1(x)) for each element of input. |
| 1405 | special_modified_bessel_i1_out | Math | Alpha | 5.5.0 | aten, pointwise, KernelGen | A variant of special_modified_bessel_i1() with output saved to
provided out. |
| 1406 | special_modified_bessel_k0 | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for special_modified_bessel_k0. |
| 1407 | special_modified_bessel_k0_out | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for special_modified_bessel_k0.out. |
| 1408 | special_modified_bessel_k1 | Math | Alpha | 5.4 | aten, KernelGen | Modified Bessel function of the second kind of order 1. |
| 1409 | special_modified_bessel_k1_out | Math | Alpha | 5.4 | aten, KernelGen | A variant of special_modified_bessel_k1 that allows the output to be assigned to another tensor. |
| 1410 | special_multigammaln | Math | Alpha | 5.4 | aten, KernelGen | Computes the multivariate log-gamma function for each element of the input.
Out-of-place counterpart of mvlgamma_; delegates to the mvlgamma kernel,
which supports orders p up to 12. |
| 1411 | special_ndtr | Math | Alpha | 5.4 | aten, KernelGen | Computes the standard normal cumulative distribution function (CDF). |
| 1412 | special_ndtri | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the argument x for which the area under the standard Gaussian
probability density function, integrated from minus infinity to x, equals
input. In other words it is the inverse of the standard normal CDF. |
| 1413 | special_round | Math | Alpha | 5.4 | aten, KernelGen | Rounds a tensor to the nearest integer, with ties rounding to the nearest
even value (banker's rounding). |
| 1414 | special_round_out | Math | Alpha | 5.4 | aten, KernelGen | A variant of special_round() with output saved to provided out. |
| 1415 | special_scaled_modified_bessel_k1 | Math | Alpha | 5.4 | aten, pointwise | Computes the scaled modified Bessel function of the first kind
of order 1 (scaled K_1(x) = exp(x)*K_1(x)) for each element in the input tensor. |
| 1416 | special_shifted_chebyshev_polynomial_t | Math | Alpha | 5.4 | aten, KernelGen | Computes the shifted Chebyshev polynomial of the first kind T_n^*(x)
for each pair of elements in x and n. |
| 1417 | special_shifted_chebyshev_polynomial_u | Math | Alpha | 5.4 | aten, KernelGen | Computes the shifted Chebyshev polynomial of the second kind U_n^*(x)
for each pair of elements in x and n. |
| 1418 | special_shifted_chebyshev_polynomial_u_ | Math | Alpha | 5.4 | aten, KernelGen | Inplace variant of special_shifted_chebyshev_polynomial_u. |
| 1419 | special_shifted_chebyshev_polynomial_v | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the shifted Chebyshev polynomial of the third kind V_n^*(x). |
| 1420 | special_shifted_chebyshev_polynomial_w | Math | Alpha | 5.4 | aten, KernelGen | Computes the shifted Chebyshev polynomial of the second kind W_n(x). |
| 1421 | special_sinc | Math | Alpha | 5.4 | aten, KernelGen | Computes sin(pi * x) / (pi * x) for each element of input. |
| 1422 | special_softmax | Math | Alpha | 5.4 | aten, reduction, KernelGen | Computes the softmax of input along dimension dim; alias of
torch.nn.functional.softmax exposed under torch.special. |
| 1423 | special_spherical_bessel_j0 | Math | Alpha | 5.5.0 | aten, KernelGen | Computes the spherical Bessel function of the first kind of order 0. |
| 1424 | special_xlog1py | Math | Alpha | 5.4 | aten, KernelGen | Computes x * log1p(y) for each element pair in the input tensors x and y. |
| 1425 | special_xlogy | Math | Alpha | 5.4 | aten, KernelGen | Computes x * log(y) for each element pair in the input tensors x and y. Returns 0 if x == 0. |
| 1426 | special_xlogy_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of special_xlogy(). |
| 1427 | special_zeta | Math | Alpha | 5.5 | aten, pointwise | Computes the Hurwitz zeta function element-wise for two tensor inputs. |
| 1428 | special_zeta_out | Math | Alpha | 5.5 | aten, pointwise | Tensor/tensor variant of special_zeta that writes to out. |
| 1429 | special_zeta_scalar_tensor | Math | Alpha | 5.5 | aten, pointwise | Variant of special_zeta whose first argument is a scalar. |
| 1430 | special_zeta_scalar_tensor_out | Math | Alpha | 5.5 | aten, pointwise | Scalar/tensor variant of special_zeta that writes to out. |
| 1431 | special_zeta_tensor_scalar | Math | Alpha | 5.5 | aten, pointwise | Variant of special_zeta whose second argument is a scalar. |
| 1432 | special_zeta_tensor_scalar_out | Math | Alpha | 5.5 | aten, pointwise | Tensor/scalar variant of special_zeta that writes to out. |
| 1433 | split_with_sizes | Tensor | Alpha | 5.4 | aten, KernelGen | Splits a tensor into sub-tensors along a given dimension,
where each split has a specified size. Returns views into the input. |
| 1434 | split_with_sizes_copy | Math | Alpha | 5.4 | aten, KernelGen | Splits a tensor into sub-tensors along a given dimension,
where each split has a specified size. Always returns copies. |
| 1435 | spsolve | LinearAlg | Alpha | 5.5 | aten, KernelGen | Solves a sparse linear system AX = B for a CSR matrix A via CSR-to-dense conversion and the FlagGems linalg_solve kernel. |
| 1436 | sqrt | Math | Stable | 4.0 | aten, pointwise | Returns a new tensor with the square-root of the elements of input. |
| 1437 | sqrt_ | Math | Stable | 4.0 | aten, pointwise | This is the in-place version of sqrt(). |
| 1438 | square | Math | Beta | 5.3 | aten, pointwise | Returns a new tensor with the square of the elements of input. |
| 1439 | square_ | Math | Beta | 5.3 | aten, pointwise | The inplace version of square. |
| 1440 | square_out | Math | Beta | 5.3 | aten, pointwise | A variant of square that assigns the output to the provided out. |
| 1441 | squeeze_copy | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for squeeze_copy. |
| 1442 | sspaddmm | Math | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for sspaddmm. |
| 1443 | sspaddmm_out | Math | Alpha | 5.5 | aten, KernelGen | A variant of sspaddmm() that writes the result into the out tensor. |
| 1444 | stack | Tensor | Stable | 2.2 | aten | Concatenates a sequence of tensors along a new dimension. |
| 1445 | stage_deepseek_v4_mega_moe_inputs | NeuralNetwork | Alpha | 5.4 | fused, DeepSeekV4, MoE | Stages DeepSeekV4 Mega-MoE inputs by quantizing hidden states to FP8
with UE8M0 scales and copying top-k indices and weights to output buffers. |
| 1446 | standard_gamma | Math | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for _standard_gamma. |
| 1447 | standard_gamma_grad | Math | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for _standard_gamma_grad. |
| 1448 | std | Reduction | Stable | 4.0 | aten | Calculates the standard deviation over the dimensions specified by dim.
dim can be a single dimension, list of dimensions, or None
to reduce over all dimensions. |
| 1449 | std_mean | Reduction | Alpha | 5.5 | aten, Reduction | Calculates the standard deviation and mean over all input elements. |
| 1450 | std_mean_correction | Reduction | Alpha | 5.5 | aten, Reduction | Calculates the standard deviation and mean over selected dimensions, using an optional degrees-of-freedom correction. |
| 1451 | std_mean_correction_names | Reduction | Alpha | 5.5 | aten, Reduction | Named-dimension variant of std_mean with an optional degrees-of-freedom correction. |
| 1452 | std_mean_correction_out | Reduction | Alpha | 5.5 | aten, Reduction | Out-tensor variant of std_mean with a degrees-of-freedom correction. |
| 1453 | std_mean_dim | Reduction | Alpha | 5.5 | aten, Reduction | Calculates the standard deviation and mean over selected dimensions, using the legacy unbiased argument. |
| 1454 | std_mean_names_dim | Reduction | Alpha | 5.5 | aten, Reduction | Named-dimension variant of std_mean using the legacy unbiased argument. |
| 1455 | stft | Math | Alpha | 5.5 | aten | Short-time Fourier transform with explicit vendor FFT execution. |
| 1456 | stft_center | Math | Alpha | 5.5 | aten | Short-time Fourier transform with configurable centered padding. |
| 1457 | sub | Math | Stable | 1.0 | aten, pointwise | Subtracts other, scaled by alpha, from the input tensor. |
| 1458 | sub_ | Math | Stable | 2.2 | aten, pointwise | Subtracts other, scaled by alpha, from the input tensor.
This is the in-place version. |
| 1459 | subtract | Math | Alpha | 5.4 | aten, KernelGen | Subtracts other, scaled by alpha, from input. |
| 1460 | subtract_ | Math | Alpha | 5.4 | aten, KernelGen | In-place version of subtract. Subtracts other, scaled by alpha, from input. |
| 1461 | sum | LinearAlg | Stable | 2.0 | aten, Reduction | Returns the sum of all elements in the input tensor. |
| 1462 | sum_dim | LinearAlg | Stable | 2.0 | aten, Reduction | Returns the sum of each row of the input tensor in the given dimension dim.
dim is a list of dimensions, reduce over all of them. |
| 1463 | sum_dim_out | LinearAlg | Stable | 3.0 | aten, Reduction | A variant of sum_dim() with the out argument. |
| 1464 | sum_out | LinearAlg | Stable | 3.0 | aten, Reduction | A variant of sum() with the out argument. |
| 1465 | sum_to_size | Math | Alpha | 5.4 | aten, KernelGen | Triton kernel implementation for sum_to_size. |
| 1466 | svd | Math | Alpha | 5.4 | aten | Computes the singular value decomposition returning (U, S, V) such that input = U diag(S) V^H. |
| 1467 | swiglu | NeuralNetwork | Stable | 5.0 | fused, Transformer | Swish-Gated Linear Unit, a variant of GLU with the Swish activation function. |
| 1468 | sym_constrain_range | Tensor | Alpha | 5.4 | aten, KernelGen | Constrains the range of a symbolic integer value. Used for torch.compile symbolic tracing to provide bounds information. |
| 1469 | sym_numel | Tensor | Alpha | 5.5 | aten, KernelGen | Returns the total number of elements of the input tensor. |
| 1470 | sym_size | Tensor | Alpha | 5.4 | aten, KernelGen | Returns the size of the input tensor as a list of integers.
This is a metadata operation with no computation and is used for
torch.compile symbolic tracing. |
| 1471 | sym_storage_offset | Tensor | Alpha | 5.4 | aten, KernelGen | Returns the storage offset of the input tensor as an integer. Used for torch.compile symbolic tracing. |
| 1472 | sym_stride | Tensor | Alpha | 5.4 | aten, KernelGen | Returns the stride of the input tensor as a tuple of integers. Used for torch.compile symbolic tracing. |
| 1473 | t_ | Tensor | Alpha | 5.5 | aten, KernelGen | Transpose a 2D tensor in-place. |
| 1474 | t_copy | Tensor | Stable | 5.3 | aten, KernelGen | Transpose a 2D tensor into a new tensor with contiguous memory layout. |
| 1475 | t_copy_out | Tensor | Stable | 5.3 | aten, KernelGen | A variant of t_copy() that allows the output to be assigned to the out tensor. |
| 1476 | take | Tensor | Alpha | 5.4 | aten, KernelGen | Returns a new tensor with the elements of input at the given flat
index. The input is treated as a flattened 1-D tensor and the result
takes the shape of index. Negative indices are supported. |
| 1477 | take_along_dim | Tensor | Alpha | 5.5 | aten, KernelGen | Selects values from input at the 1-dimensional indices along the
given dim. Reduces to a broadcasted gather; if dim is None the input
is treated as flattened to 1-D. |
| 1478 | take_along_dim_out | Tensor | Alpha | 5.5 | aten, KernelGen | Out-variant of take_along_dim that writes the gathered result into the
out tensor, resizing it if needed. |
| 1479 | take_out | Tensor | Alpha | 5.4 | aten, KernelGen | Out-variant of take. Writes the gathered elements into the out tensor,
resizing it to the shape of index if needed. |
| 1480 | tan | NeuralNetwork | Stable | 4.1 | aten, pointwise | Returns a new tensor with the tangent of the elements in the input tensor,
where each value in this input tensor is in radians. |
| 1481 | tan_ | NeuralNetwork | Stable | 4.1 | aten, pointwise, KernelGen | This is the in-place version of tan(). |
| 1482 | tanh | Math | Stable | 2.0 | aten, pointwise | Returns a new tensor with the hyperbolic tangent of the elements of input. |
| 1483 | tanh_ | Math | Stable | 2.2 | aten, pointwise | This is the in-place version of tanh(). |
| 1484 | tanh_backward | Math | Stable | 3.0 | aten, pointwise | This is the backward case for tanh(). |
| 1485 | te_rmsnorm_bwd | NeuralNetwork | Alpha | 5.4 | fused, Normalization | RMSNorm backward pass aligned with TransformerEngine's rmsnorm_bwd signature.
Computes gradients dx (w.r.t. input) and dgamma (w.r.t. weight). |
| 1486 | te_rmsnorm_fwd | NeuralNetwork | Alpha | 5.4 | fused, Normalization | RMSNorm forward pass aligned with TransformerEngine's rmsnorm_fwd signature.
Supports zero_centered_gamma, pre-allocated output tensor, and output dtype conversion.
Returns (output, None, rsigma). |
| 1487 | tensor_split_indices | Math | Alpha | 5.3 | aten, KernelGen | Splits a tensor into multiple sub-tensors at the given indices along a given dimension. |
| 1488 | tensor_split_sections | Math | Alpha | 5.3 | aten, KernelGen | Splits a tensor into multiple sub-tensors along a given dimension, using a number of sections. |
| 1489 | tensor_split_tensor_indices_or_sections | Math | Alpha | 5.3 | aten, KernelGen | Splits a tensor into multiple sub-tensors along a given dimension, using a tensor of split indices. |
| 1490 | tensordot | BLAS | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for tensordot. |
| 1491 | tensordot_out | BLAS | Alpha | 5.5 | aten, KernelGen | A variant of tensordot() that writes the result into the out tensor. |
| 1492 | thnn_differentiable_gru_cell_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Computes differentiable gradients for a fused GRU cell. |
| 1493 | thnn_differentiable_lstm_cell_backward | Math | Alpha | 5.5 | aten, KernelGen | Computes the differentiable backward pass for an LSTM cell, returning
gradients for the input gates, hidden gates, cell state, and optional biases. |
| 1494 | thnn_fused_gru_cell | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Computes the fused GRU cell forward pass and backward workspace. |
| 1495 | thnn_fused_gru_cell_backward | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Computes gradients for a fused GRU cell. |
| 1496 | thnn_fused_gru_cell_backward_out | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Writes fused GRU cell gradients to caller-provided tensors. |
| 1497 | thnn_fused_gru_cell_out | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Writes the fused GRU cell output and workspace to provided tensors. |
| 1498 | thnn_fused_lstm_cell | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Fused LSTM cell computation with optional input and hidden biases. |
| 1499 | thnn_fused_lstm_cell_backward | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Computes and duplicates the input, hidden, and bias gradients produced by
the fused LSTM cell backward implementation. |
| 1500 | thnn_fused_lstm_cell_backward_impl | Math | Alpha | 5.4 | aten, KernelGen | Computes gradients for the fused LSTM cell operation (_thnn_fused_lstm_cell). |
| 1501 | threshold | NeuralNetwork | Stable | 3.0 | aten, nn.functional, pointwise | Apply a threshold to each element of the input Tensor. |
| 1502 | threshold_ | Math | Alpha | 5.4 | aten, KernelGen | In-place version of threshold(). Thresholds each element of the input Tensor. |
| 1503 | threshold_backward | NeuralNetwork | Stable | 3.0 | aten, nn.functional, pointwise | This is the backward version for threshold. |
| 1504 | tile | Tensor | Stable | 2.1 | aten | Constructs a tensor by repeating the elements of input.
The dims argument specifies the number of repetitions in each dimension. |
| 1505 | to_copy | Tensor | Stable | 5.3 | aten, pointwise, skip_precision_check | Copies a tensor to a different dtype, layout, device, or memory format, exposed as the low-level _to_copy aten operator. |
| 1506 | top_k_per_row_decode | NeuralNetwork | Beta | 5.3 | fused, vLLM, DeepSeekV4, KernelGen | Triton top-K per row for DeepSeek V4 decode-phase token selection.
Radix-select based approach with three dispatch tiers for different vocab sizes. |
| 1507 | top_k_per_row_prefill | NeuralNetwork | Beta | 5.3 | fused, KernelGen | Triton top-K per row for DeepSeek V4 sparse attention prefill phase.
Replaces vLLM persistent_topk CUDA kernel with in-place masking + adaptive topk selection. |
| 1508 | topk | Tensor | Stable | 2.1 | aten, skip_precision_check | Returns the k largest elements of the given input tensor along a given dimension.
If dim is not given, the last dimension of the input is chosen.
If largest is False then the k smallest elements are returned. |
| 1509 | topk_softmax | MoE | Stable | 4.0 | fused, vLLM | Selects the k most likely next-token candicates, sets all others to zero,
and renormalize the prbabilities of these top candidates. |
| 1510 | topk_softplus_sqrt | MoE | Beta | 5.3 | fused, KernelGen, vLLM | Fused softplus + sqrt + top-k selection and optional renormalization
for MoE gating in models like DeepSeek-V3/V4. |
| 1511 | topk_w8a16_fp8 | Tensor | Alpha | 5.4 | NoCPU, Quantization | Returns the k largest (or smallest) elements of a group-wise FP8 E4M3FN/E5M2 tensor along the last dimension, dequantizing with per-group scales. |
| 1512 | trace | Reduction | Stable | 4.0 | aten | Returns the sum of the elements of the diagonal of the input 2-D matrix. |
| 1513 | trace_backward | BLAS | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for trace_backward. |
| 1514 | transform_bias_rescale_qkv | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for _transform_bias_rescale_qkv. |
| 1515 | transpose | Tensor | Alpha | 5.1 | aten, KernelGen | Returns a view of the original tensor with its two dimensions swapped.
This is a zero-copy view operation that swaps the sizes and strides of
the two specified dimensions. |
| 1516 | transpose_copy | Tensor | Alpha | 5.5 | aten | Returns a new contiguous tensor with the two specified dimensions swapped.
The result does not alias the input tensor. |
| 1517 | trapz | Math | Alpha | 5.5 | aten, KernelGen | Computes the trapezoidal rule along a dimension using constant spacing dx.
Integrates the input tensor along the specified dimension using the
trapezoidal rule with uniform spacing. |
| 1518 | tril | BLAS | Stable | 5.3 | aten, KernelGen | Returns the lower triangular part of an input matrix (or a batch of matrices) and
sets all other elements to zero. |
| 1519 | tril_ | BLAS | Beta | 5.3 | aten | The in-place version of tril(). |
| 1520 | tril_indices | Tensor | Alpha | 5.5 | aten | Returns the row and column coordinates of the lower-triangular part of a row by col matrix in row-major order. |
| 1521 | tril_out | BLAS | Beta | 5.3 | aten | A variant of tril() that explicitly assigns the output to the out parameter. |
| 1522 | trilinear | Math | Alpha | 5.5 | aten, KernelGen | Computes the trilinear product (3-way tensor product) via a Triton elementwise-product kernel followed by summation over sumdim. |
| 1523 | trilinear_out | Math | Alpha | 5.5 | aten, KernelGen | A variant of _trilinear() that explicitly assigns the output to the out parameter. |
| 1524 | triplet_margin_loss | NeuralNetwork | Alpha | 5.5 | aten, nn.functional, KernelGen | Triplet margin loss for learning embeddings |
| 1525 | triton_lighting_indexer_k_tiled_interface | NeuralNetwork | Alpha | 5.3 | fused, DSA | Part of FP8 MQA framework. It is currently not exposed as an operator for use. |
| 1526 | triu | BLAS | Stable | 1.0 | aten | Returns the upper triangular part of a matrix (2-D tensor) or batch of matrices input,
the other elements of the result tensor out are set to 0. |
| 1527 | triu_ | NeuralNetwork | Stable | 5.0 | aten | The in-place version of triu(). |
| 1528 | triu_indices | Tensor | Alpha | 5.5 | aten | Returns the row and column coordinates of the upper-triangular part of a row by col matrix in row-major order. |
| 1529 | true_divide | Math | Alpha | 5.4 | aten, KernelGen, pointwise | Performs element-wise true division between two tensors. |
| 1530 | true_divide_ | Math | Alpha | 5.4 | aten, KernelGen, pointwise | Performs element-wise true division in-place between two tensors. |
| 1531 | trunc | Math | Alpha | 5.4 | aten, KernelGen | Rounds each element of the input tensor to the nearest integer towards zero. |
| 1532 | trunc_ | Math | Alpha | 5.4 | aten, KernelGen | The in-place version of trunc(). |
| 1533 | trunc_divide | Math | Stable | 2.1 | aten | The div function with rounding_mode set to trunc. |
| 1534 | trunc_divide_ | Math | Stable | 2.1 | aten | The in-place version of trunc_divide. |
| 1535 | unbind | Tensor | Alpha | 5.4 | aten, KernelGen, skip_precision_check | Pure layout operation (unbind); returns zero-copy views sharing storage with the input. |
| 1536 | unbind_copy | Tensor | Alpha | 5.4 | aten, KernelGen | Removes a tensor dimension and returns a tuple of all slices along a given dimension as copies. |
| 1537 | underscore_linalg_det | LinearAlg | Alpha | 5.5.0 | aten, KernelGen | Computes the determinant of a square matrix (or a batch of square matrices), returning it together with the LU factorisation and pivots. |
| 1538 | underscore_sobol_engine_draw | Distribution | Alpha | 5.5.0 | aten, KernelGen | Generates quasi-random Sobol sequence points. XOR-based algorithm using Gray code for low-discrepancy sampling. |
| 1539 | underscore_sobol_engine_scramble_ | RandomSampling | Alpha | 5.5.0 | aten, KernelGen | Scrambles Sobol quasi-random number generator state using Owen scrambling. Performs in-place matrix multiplication in GF(2) (binary field) for each dimension. |
| 1540 | unflatten | Math | Alpha | 5.4 | aten, KernelGen | Expand a single dimension into multiple dimensions (inverse of flatten). |
| 1541 | unfold | Math | Alpha | 5.4 | aten, KernelGen | Return a view of the tensor with a sliding window along the given dimension. |
| 1542 | unfold_backward | NeuralNetwork | Stable | 5.0 | aten, nn.functional | An operator for calculating the gradient of the unfold operation during backpropagation.
It takes the gradient of the unfolded output and accumulates it back into
the original input shape, reversing sliding local block extraction and resolving overlaps. |
| 1543 | unfold_copy | Tensor | Alpha | 5.4 | aten, KernelGen | Returns a view of the original tensor which contains all slices of size from self tensor in the specified dimension with given step between two slices. |
| 1544 | uniform | Distribution | Alpha | 5.5 | aten, KernelGen, skip_precision_check | Returns a new tensor filled with numbers sampled from the continuous uniform distribution. |
| 1545 | uniform_ | Distribution | Stable | 2.1 | aten, skip_precision_check | Fills self tensor with numbers sampled from the continuous uniform distribution. |
| 1546 | unique2 | Tensor | Stable | 2.1 | aten | Returns the unique elements of the input tensor. This is an internal PyTorch function. |
| 1547 | unique_consecutive | Distribution | Beta | 5.3 | aten, KernelGen | Eliminates all but the first element from every consecutive group of equivalent elements. |
| 1548 | unique_dim | Tensor | Beta | 5.4 | aten | Returns the unique slices of the input tensor along a dimension. |
| 1549 | unpack_seq_triton | NeuralNetwork | Beta | 5.3 | fused, vLLM, DeepSeekV4 | Unpack a packed sequence tensor back to its original variable-length form. |
| 1550 | unsafe_chunk | Math | Alpha | 5.4 | aten, KernelGen | Split a tensor into a specified number of chunks along a given dimension. |
| 1551 | unsafe_index | Reduction | Beta | 5.4 | aten | Indexes input along each dimension with the given indices, matching
aten._unsafe_index. Unlike the safe index operator, it performs no
bounds checking and rejects bool / int8 masks. |
| 1552 | unsafe_index_put | Tensor | Beta | 5.5 | aten | Puts values from the tensor values into the tensor input using the indices specified
in indices (which is a tuple of Tensors), matching aten._unsafe_index_put. The
unsafe variant skips autograd history recording and assumes the caller passes valid
indices; it shares the semantics of index_put, including the accumulate flag. |
| 1553 | unsafe_masked_index | Math | Alpha | 5.4 | aten, KernelGen | Gathers elements from self at given indices where mask is True, filling unmasked positions with a scalar value. |
| 1554 | unsafe_masked_index_put_accumulate | Math | Alpha | 5.4 | aten, KernelGen | Reads values and indices tensors, performs masked scatter accumulation on
input tensor at specified indices where mask is True. The accumulate
variant uses atomic_add instead of replacement. |
| 1555 | unsafe_split_with_sizes | Tensor | Alpha | 5.4 | aten, KernelGen | Splits a tensor into sub-tensors along a given dimension, where each split
has a specified size. Returns views into the original tensor without safety
checks. |
| 1556 | unsafe_view | Tensor | Alpha | 5.4 | aten, KernelGen | Creates a new view of an existing tensor with a different shape without
performing safety checks, such as verifying if the tensor is contiguous or
if the reshape is valid. |
| 1557 | unsqueeze | Tensor | Alpha | 5.4 | aten, KernelGen | Returns a new tensor with a dimension of size one inserted at the specified position. |
| 1558 | unsqueeze_ | Tensor | Alpha | 5.4 | aten, KernelGen | In-place version of unsqueeze(). |
| 1559 | upsample_bicubic2d | NeuralNetwork | Stable | 5.0 | aten, Reduction | A variant of upsample() that has mode set to bicubic. |
| 1560 | upsample_bicubic2d_aa | NeuralNetwork | Stable | 2.2 | aten, Reduction | A variant of upsample() that has mode set to bicubic. |
| 1561 | upsample_bicubic2d_aa_backward | NeuralNetwork | Stable | 5.0 | aten, Reduction | A backward case for _upsample_bicubic2d_aa(). |
| 1562 | upsample_bicubic2d_backward | NeuralNetwork | Alpha | 5.4 | aten, Reduction | Computes non-antialiased bicubic interpolation gradients using deterministic gather. |
| 1563 | upsample_bicubic2d_backward_grad_input | NeuralNetwork | Alpha | 5.4 | aten, Reduction | Writes non-antialiased bicubic interpolation gradients to grad_input. |
| 1564 | upsample_bilinear2d | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | Upsamples the input, using bilinear mode.
The input has to be 4 dimensional, and the output_size is a tuple of 2 ints. |
| 1565 | upsample_bilinear2d_aa | NeuralNetwork | Alpha | 5.1 | aten, KernelGen | Upsamples the input, using bilinear mode with anti-aliasing. |
| 1566 | upsample_bilinear2d_aa_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | A backward case for _upsample_bilinear2d_aa(). |
| 1567 | upsample_bilinear2d_backward | NeuralNetwork | Alpha | 5.4 | aten, Reduction | Computes gradients of bilinear interpolation without anti-aliasing. |
| 1568 | upsample_bilinear2d_backward_grad_input | NeuralNetwork | Alpha | 5.4 | aten, Reduction | Writes bilinear interpolation gradients into a supplied tensor. |
| 1569 | upsample_lanczos2d_aa | NeuralNetwork | Alpha | 5.4 | aten, KernelGen, Reduction | Resizes a 4D image tensor with antialiased Lanczos-3 interpolation. |
| 1570 | upsample_lanczos2d_aa_backward | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Compute the input gradient for antialiased Lanczos-3 2D resizing. |
| 1571 | upsample_lanczos2d_aa_backward_grad_input | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Out variant of antialiased Lanczos-3 2D resize backward. |
| 1572 | upsample_lanczos2d_aa_out | NeuralNetwork | Alpha | 5.4 | aten, KernelGen, Reduction | An out variant of _upsample_lanczos2d_aa(). |
| 1573 | upsample_lanczos2d_aa_vec | NeuralNetwork | Alpha | 5.4 | aten, KernelGen, Reduction | A vector-parameter variant of _upsample_lanczos2d_aa(). |
| 1574 | upsample_linear1d | NeuralNetwork | Beta | 5.3 | aten | Upsamples the input, using linear mode.
The input has to be 3 dimensional, and the output_size is an optional tuple of ints. |
| 1575 | upsample_linear1d_backward | NeuralNetwork | Alpha | 5.4 | aten, Reduction | A backward case for upsample_linear1d(). |
| 1576 | upsample_nearest1d | NeuralNetwork | Stable | 5.0 | aten | Upsamples the input, using nearest neighbours' pixel values.
The input has to be 3 dimensional, and the output_size is an optional tuple of ints. |
| 1577 | upsample_nearest1d_backward | NeuralNetwork | Alpha | 5.5 | aten, KernelGen, Reduction | Triton kernel implementation for upsample_nearest1d_backward. |
| 1578 | upsample_nearest1d_backward_grad_input | NeuralNetwork | Alpha | 5.5 | aten, KernelGen, Reduction | A variant of upsample_nearest1d_backward() that writes the result into the grad_input tensor. |
| 1579 | upsample_nearest2d | NeuralNetwork | Stable | 2.2 | aten | Upsamples the input, using nearest neighbours' pixel values. The input has to be 4 dimensional.
The scales can be provided with scales_h and scales_w. |
| 1580 | upsample_nearest2d_backward | NeuralNetwork | Alpha | 5.4 | aten, Reduction | Deterministic backward for legacy 2D nearest-neighbor interpolation. |
| 1581 | upsample_nearest2d_backward_grad_input | NeuralNetwork | Alpha | 5.4 | aten, Reduction | Preallocated-output overload of upsample_nearest2d_backward. |
| 1582 | upsample_nearest3d | NeuralNetwork | Stable | 5.0 | aten | Performs 3D nearest-neighbor interpolation to increase the spatial size of volumetric data,
such as 5D tensors. It scales up inputs by copying values from the nearest pixel/voxel,
without calculating new values through linear interpolation. |
| 1583 | upsample_nearest3d_backward | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Triton kernel implementation for upsample_nearest3d_backward. |
| 1584 | upsample_nearest3d_backward_grad_input | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | An out variant of upsample_nearest3d_backward(). |
| 1585 | upsample_nearest_exact1d | NeuralNetwork | Beta | 5.0 | aten, Reduction | Increases the length of a 1D tensor using nearest-neighbor interpolation,
ensuring the output aligns with library-standard algorithms like PIL. |
| 1586 | upsample_nearest_exact1d_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen, Reduction | A backward case for _upsample_nearest_exact1d(). |
| 1587 | upsample_nearest_exact1d_backward_grad_input | NeuralNetwork | Alpha | 5.4 | aten, KernelGen, Reduction | An out variant of _upsample_nearest_exact1d_backward(). |
| 1588 | upsample_nearest_exact2d | Math | Stable | 5.3 | aten, KernelGen | Triton kernel implementation for _upsample_nearest_exact2d. |
| 1589 | upsample_nearest_exact2d_backward | NeuralNetwork | Alpha | 5.4 | aten, KernelGen | A backward case for _upsample_nearest_exact2d(). |
| 1590 | upsample_nearest_exact3d | NeuralNetwork | Alpha | 5.1 | aten, NeuralNetwork, KernelGen | Increases the depth, height, and width of a 3D tensor using nearest-neighbor interpolation,
ensuring the output aligns with library-standard algorithms like PIL. |
| 1591 | upsample_nearest_exact3d_backward | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | A backward case for _upsample_nearest_exact3d(). |
| 1592 | upsample_nearest_exact3d_backward_grad_input | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | A variant of _upsample_nearest_exact3d_backward() that writes into the provided grad_input tensor. |
| 1593 | upsample_trilinear3d | Math | Alpha | 5.4 | aten, KernelGen | Upsamples the input (NCDHW) using trilinear interpolation. |
| 1594 | upsample_trilinear3d_backward | NeuralNetwork | Alpha | 5.5 | aten, KernelGen | Computes the gradient of upsample_trilinear3d with respect to its input (NCDHW),
scattering the output gradient back to the eight source corner voxels. |
| 1595 | value_selecting_reduction_backward | Reduction | Alpha | 5.4 | aten, KernelGen | Computes the gradient of a value-selecting reduction (such as max.dim
or min.dim) by scattering the upstream gradient to the positions
given by the indices of the selected values in the original input. |
| 1596 | vander | Tensor | Alpha | 5.5 | aten, KernelGen | Generates a Vandermonde matrix from a 1-D input tensor. |
| 1597 | var | Tensor | Beta | 5.3 | aten, KernelGen | Calculates the variance over all dimensions. |
| 1598 | var_correction | Tensor | Beta | 5.3 | aten | A variant of the var() operator, with an optional correction for specifying
difference between the sample size and sample degrees of freedom. |
| 1599 | var_dim | Tensor | Beta | 5.3 | aten | Calculates the variance over the dimensions specified by dim. |
| 1600 | var_mean | LinearAlg | Stable | 2.0 | aten, Reduction | Calculates the variance and mean over the dimensions specified by dim. dim can be a single dimension,
list of dimensions, or None to reduce over all dimensions. |
| 1601 | vdot | BLAS | Stable | 2.2 | aten | Computes the dot product of two 1D vectors along a dimension. |
| 1602 | vector_norm | LinearAlg
NeuralNetwork | Stable | 2.0 | aten, Reduction | Computes a vector norm. |
| 1603 | view_as_complex | Tensor | Alpha | 5.4 | aten | Returns a view of the real input tensor as a complex tensor (zero-copy view operation). |
| 1604 | view_copy | Tensor | Alpha | 5.4 | aten, KernelGen | Returns a copy of the tensor with the specified shape.
Unlike view(), this always returns a new tensor rather than an alias. |
| 1605 | vsplit | Tensor | Alpha | 5.5 | aten, KernelGen | Split a tensor along the first axis (row-wise).
Each chunk is copied into a freshly allocated output by a Triton kernel. |
| 1606 | vstack | Tensor | Stable | 2.2 | aten | Stack tensors in sequence vertically (row wise). |
| 1607 | w8a8_block_fp8_matmul | BLAS | Alpha | 5.3 | vLLM | Performs matrix multiplication with block-wise quantization. |
| 1608 | weight_int4pack_mm | BLAS | Alpha | 5.4 | aten, KernelGen | Int4 packed weight matrix multiplication. Computes C = A @ dequant(W).T
where W is a byte-pair int4 packed uint8 tensor of shape (N, K//2).
Weights are pre-dequantized into float32 and then processed by a Triton
GEMM kernel. |
| 1609 | weight_int4pack_mm_with_scales_and_zeros | BLAS | Alpha | 5.4 | aten, KernelGen | Int4 quantized matrix multiplication with separate scales and zeros. Computes
C = matmul(A, W_deq) where W is a packed uint8 int4 weight matrix and A is
the activation matrix, using per-group scale and zero-point quantization. |
| 1610 | weight_int8pack_mm | BLAS | Alpha | 5.4 | aten, KernelGen | Performs int8 weight-only quantized matrix multiplication with per-channel scales. |
| 1611 | weight_norm | NeuralNetwork | Stable | 3.0 | fused | Reparameterizes a module's weight tensor by decoupling its magnitude (g)
from its direction (v). It is a hook that compute the actual weight before
each forward pass. |
| 1612 | weight_norm_differentiable_backward | NeuralNetwork | Alpha | 5.5 | aten, fused, KernelGen | Computes the differentiable gradients for the magnitude and direction
parameters of a weight-normalized tensor. |
| 1613 | weight_norm_interface | NeuralNetwork | Stable | 2.2 | aten, fused | Apply weight normalization to neural network layers, decoupling the magnitued
of a weight tensor from its direction. It is used to stabilize training, particularly
for models with small batch sizes. |
| 1614 | weight_norm_interface_backward | NeuralNetwork | Stable | 3.0 | aten, fused | Computes the gradients for weight normalization during the backward pass.
It calculates the necessary derivatives for updating both the magnitude (g)
and direction (v) parameters of a weight-normalized layer, based on gradients
received from the previous operation. |
| 1615 | where_self | Tensor | Stable | 2.1 | aten, pointwise | Returns a LongTensor. This operation is identical to torch.nonzero(condition, as_tuple=True). |
| 1616 | where_self_out | Tensor | Stable | 2.2 | aten, pointwise | This is a variant of where_self() with an argument out. |
| 1617 | wrapped_linear_prepack | Quantization | Alpha | 5.5 | aten, KernelGen | Quantizes and packs a linear weight and bias for the paired wrapped quantized linear operator. |
| 1618 | wrapped_quantized_linear_prepacked | Quantization | Alpha | 5.5 | aten, KernelGen | Applies a quantized linear operation using a weight produced by wrapped_linear_prepack. |
| 1619 | xlogy | Math | Beta | 5.4 | aten, pointwise | Computes input * log(other) element-wise, returning zero where input is zero (following PyTorch's xlogy semantics). |
| 1620 | xlogy_ | Math | Alpha | 5.4 | aten, KernelGen, pointwise | Computes x * log(y) element-wise in-place on x. |
| 1621 | xlogy_out | Math | Beta | 5.4 | aten, pointwise | A variant of xlogy that allows the output to be assigned to an out tensor. |
| 1622 | xlogy_scalar_tensor | Math | Beta | 5.4 | aten, pointwise | A variant of xlogy where input is a scalar. |
| 1623 | xlogy_scalar_tensor_out | Math | Beta | 5.4 | aten, pointwise | A variant of xlogy where input is a scalar and the output is assigned to an out tensor. |
| 1624 | xlogy_tensor_scalar | Math | Beta | 5.4 | aten, pointwise | A variant of xlogy where other is a scalar. |
| 1625 | xlogy_tensor_scalar_out | Math | Beta | 5.4 | aten, pointwise | A variant of xlogy where other is a scalar and the output is assigned to an out tensor. |
| 1626 | xor | Math | Alpha | 5.4 | aten, pointwise, KernelGen | Computes the bitwise XOR of input tensors or a tensor and a scalar (non-inplace). |
| 1627 | zero | Tensor | Stable | 5.3 | aten, KernelGen | Fills tensor with zeros. |
| 1628 | zero_ | Tensor | Stable | 5.0 | aten | Fills self tensor with zeros. |
| 1629 | zero_out | Tensor | Stable | 5.3 | aten, KernelGen | Fills tensor with zeros but assign the output to the out tensor. |
| 1630 | zeros | Tensor | Stable | 2.1 | aten, skip_precision_check | Returns a tensor filled with the scalar value 0, with the shape defined by
the variable argument size. |
| 1631 | zeros_like | Tensor | Stable | 2.1 | aten | Returns a tensor filled with the scalar value 0, with the same size as input. |