Operator List#

No.	Name	Kind	Stage	Since	Labels	Description
1	`_adaptive_avg_pool3d_backward`	NeuralNetwork	Alpha	5.1	aten, KernelGen, reduction	Computes the gradient of 3D adaptive average pooling.
2	`_flash_attention_forward`	NeuralNetwork	Alpha	5.4	aten, NoCPU, KernelGen	Run the canonical FlashAttention forward operator.
3	`_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.
4	`_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.
5	`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.
6	`abs_`	Math	Stable	2.2	aten, pointwise	The in-place version of `abs()`, which is a simple wrapper of the Torch `abs` operator.
7	`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.
8	`absolute_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `absolute()`.
9	`acos`	Math	Stable	5.0	aten, pointwise	Returns a new tensor with the arccosine (in radians) of each element in `input`.
10	`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.
11	`acosh`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for acosh.
12	`acosh_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `acosh()`.
13	`act_quant_triton`	Quantization	Beta	5.3	fused	This is a fused operator.
14	`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.
15	`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.
16	`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.
17	`adaptive_avg_pool3d_backward`	NeuralNetwork	Alpha	5.1	aten, KernelGen, reduction	Computes the gradient of 3D adaptive average pooling.
18	`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.
19	`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.
20	`adaptive_max_pool3d_backward`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Computes the gradient for adaptive max pooling 3D.
21	`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.
22	`add_`	Math	Stable	2.2	aten, pointwise	The in-place version of `add()`.
23	`add_relu`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for _add_relu.
24	`add_relu_`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for the in-place `_add_relu_()`.
25	`add_rms_norm`	NeuralNetwork	Alpha	5.4	aten, KernelGen, Normalization	Add two inputs element-wise and apply Root Mean Square Layer Normalization.
26	`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).
27	`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).
28	`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`.
29	`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`.
30	`addcdiv_out`	LinearAlg	Stable	5.3	aten, pointwise, KernelGen	A variant of `addcdiv()` that assigns the output to the given `out` parameter..
31	`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`.
32	`addcmul_`	LinearAlg	Alpha	5.4	aten, pointwise, KernelGen	The in-place version of `addcmul()`.
33	`addcmul_out`	LinearAlg	Beta	5.3	aten, pointwise, KernelGen	A variant of `addcmul` that allows the output to be assigned to `out`.
34	`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.
35	`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.
36	`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.
37	`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.
38	`addmm_out`	BLAS	Stable	4.0	aten	A variant of `addmm` that assigns to the output to the provided `out` parameter.
39	`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.
40	`addmv_`	BLAS	Alpha	5.4	aten, KernelGen	Performs matrix-vector product with accumulation in-place.
41	`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.
42	`addr`	BLAS	Stable	4.0	aten	Performs the outer-product of vectors `vec1` and `vec2` and adds it to the matrix `input`.
43	`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.
44	`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.
45	`alias`	Math	Alpha	5.4	aten, KernelGen	Return a view tensor sharing the same storage (zero-copy alias).
46	`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.
47	`alias_copy_out`	Tensor	Stable	5.3	aten, KernelGen	A variant of `alias_copy()` that assigns the output to the `out` tensor.
48	`all`	Math	Stable	2.0	aten, Reduction	Tests if all elements in input evaluate to True.
49	`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.
50	`all_dims`	Math	Stable	2.0	aten, Reduction	A variant of `all`.
51	`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`.
52	`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.
53	`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.
54	`amax`	LinearAlg	Stable	2.0	aten, Reduction	Returns the maximum value of each slice of the `input` tensor in the given dimension(s) `dim`.
55	`amin`	Reduction	Alpha	5.4	aten, KernelGen	Returns the minimum value of each row of the input tensor in the given dimension dim.
56	`amin_`	Reduction	Alpha	5.4	aten, KernelGen	The in-place version of amin, returns the minimum value of each row in the given dimension.
57	`aminmax`	Tensor	Beta	5.3	aten	Computes the minimum and maximum values of the `input` tensor.
58	`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.
59	`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.
60	`and_scalar`	Math	Beta	5.4	aten, KernelGen	Computes the bitwise AND operation through the tensor dunder method with a scalar operand.
61	`and_tensor`	Math	Beta	5.4	aten, KernelGen	Computes the bitwise AND operation through the tensor dunder method with tensor operands.
62	`angle`	Math	Stable	3.0	aten, pointwise	Computes the element-wise angle (in radians) of the given `input` tensor.
63	`any`	Math	Stable	2.0	aten, Reduction	Tests if any element in `input` evaluates to True.
64	`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.
65	`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.
66	`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.
67	`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.
68	`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.
69	`arange_start`	tensor	Stable	2.1	aten	A variant of `arange`, with `start` and/or `step` specified.
70	`arange_start_step`	tensor	Stable	2.1	aten	A variant of `arange`, with `start` and/or `step` specified.
71	`arccos`	Math	Alpha	5.4	aten, KernelGen	Returns a new tensor with the arccosine of the elements of `input`.
72	`arccos_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `arccos()`.
73	`arccosh`	Math	Alpha	5.4	aten, KernelGen	Returns a new tensor with the inverse hyperbolic cosine of the elements of `input`.
74	`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.
75	`arccosh_out`	Math	Alpha	5.4	aten, KernelGen	A variant of `arccosh` that allows the output to be assigned to the `out` tensor.
76	`arcsin`	Math	Alpha	5.4	aten, KernelGen	Returns a new tensor with the arcsine of the elements of input.
77	`arcsin_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `arcsin()`.
78	`arcsin_out`	Math	Alpha	5.4	aten, KernelGen	A variant of `arcsin` that allows the output to be assigned to the `out` tensor.
79	`arcsinh`	Math	Stable	5.4	aten, KernelGen	Performs an element-wise inverse hyperbolic sine computation on the given tensor.
80	`arcsinh_`	Math	Stable	5.4	aten, KernelGen	The in-place version of `arcsinh()`.
81	`arcsinh_out`	Math	Stable	5.4	aten, KernelGen	A variant of `arcsinh` that allows the output to be assigned to the `out` tensor.
82	`arctan`	Math	Alpha	5.4	aten, KernelGen	Returns a new tensor with the element-wise inverse tangent (arctangent) of the input tensor.
83	`arctan2`	Math	Alpha	5.4	aten, KernelGen	Computes the element-wise arctangent of `input` / `other`. Alias for `atan2`.
84	`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`.
85	`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.
86	`arctanh`	Math	Alpha	5.4	aten, KernelGen	Computes the element-wise inverse hyperbolic tangent of a given input tensor.
87	`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.
88	`arctanh_out`	Math	Alpha	5.4	aten, KernelGen	A variant of `arctanh` that assigns the output to the provided `out` parameter.
89	`argmax`	LinearAlg	Stable	2.0	aten, Reduction	Returns the indices of the maximum value of all elements in the `input` tensor.
90	`argmin`	LinearAlg	Stable	2.2	aten, Reduction	Returns the indices of the minimum value(s) of the flattened tensor or along a dimension.
91	`argsort`	Tensor	Alpha	5.4	skip_precision_check, KernelGen	Sorting/selection operator (argsort).
92	`as_strided_copy`	Tensor	Beta	5.3	aten, KernelGen	Creates a contiguous copy of an `as_strided` view of the input tensor.
93	`as_strided_copy_out`	Tensor	Beta	5.3	aten, KernelGen	A variant of `as_strided_copy()` that assigns the output to the `out` tensor.
94	`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.
95	`asin`	Math	Alpha	5.4	aten, KernelGen	Returns a new tensor with the arcsine of the elements of input.
96	`asin_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `asin()`.
97	`asinh`	Math	Alpha	5.3	aten, KernelGen	Returns a new tensor with the inverse hyperbolic sine of the elements of input.
98	`asinh_`	Math	Stable	5.3	aten, KernelGen	Computes the inverse hyperbolic sine for each element of a tensor in-place.
99	`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.
100	`atan`	Math	Stable	4.0	aten, pointwise	Returns a new tensor with the arctangent of the elements (in radians) in the `input` tensor.
101	`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`.
102	`atan2_`	Math	Alpha	5.4	aten, KernelGen, pointwise	Computes the element-wise arctangent of input/other in-place.
103	`atan2_out`	Math	Beta	5.3	aten, pointwise	A variant of `atan2` that allows the output to be saved into `out`.
104	`atan_`	Math	Stable	4.0	aten, pointwise	The in-place version of `atan()`.
105	`atanh`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for atanh.
106	`atanh_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `atanh()`.
107	`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.
108	`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.
109	`avg_pool2d_backward`	NeuralNetwork	Stable	4.1	aten	The backward version of `avg_pool2d()`.
110	`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.
111	`avg_pool3d_backward`	NeuralNetwork	Alpha	5.3	aten	This is the backward version of `avg_pool3d()`.
112	`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.
113	`baddbmm_`	BLAS	Alpha	5.4	aten, KernelGen	Performs batched matrix-matrix product with accumulation in-place.
114	`baddbmm_out`	BLAS	Beta	5.3	aten	This is a variant of `baddbmm()`.
115	`batch_norm`	NeuralNetwork	Stable	3.0	aten	An internal operator used for implementing the `BatchNorm` functionality.
116	`batch_norm_backward`	NeuralNetwork	Stable	3.0	aten	The backward version of `batch_norm()`.
117	`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.
118	`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.
119	`batch_norm_no_update`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Applies Batch Normalization using precomputed running statistics without updating running_mean/running_var.
120	`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.
121	`beam_search_score`	Math	Alpha	5.4	KernelGen, fused	Computes beam search scores by adding cumulative log probabilities with new token scores.
122	`beam_search_score_`	Math	Alpha	5.4	KernelGen, fused	In-place version of beam search score computation.
123	`bernoulli`	Tensor	Alpha	5.4	aten, KernelGen	Draws binary random numbers (0 or 1) from a Bernoulli distribution with per-element probabilities.
124	`bernoulli_`	Tensor	Beta	5.3	aten, skip_precision_check, KernelGen	Draws binary random numbers (0 or 1) from a Bernoulli distribution.
125	`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.
126	`bilinear`	BLAS	Alpha	5.4	aten, KernelGen	Applies a bilinear transformation to the incoming data: y = x1^T A x2 + b.
127	`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.
128	`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.
129	`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.
130	`binary_cross_entropy_with_logits`	NeuralNetwork	Alpha	5.4	nn.functional, KernelGen, aten	Compute the binary cross entropy loss with logits.
131	`bincount`	Reduction	Stable	5.0	aten, pointwise, KernelGen	Count the frequency of each value in an array of non-negative integers.
132	`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`.
133	`binomial_out`	Math	Alpha	5.4	aten, KernelGen	A variant of binomial() that writes the result into the out tensor.
134	`bitwise_and_scalar`	Math	Stable	2.0	aten, pointwise	Computes the bitwise AND of `input` and `other` scalar.
135	`bitwise_and_scalar_`	Math	Stable	2.2	aten, pointwise	The in-place, scalar version of `bitwise_and()`.
136	`bitwise_and_scalar_tensor`	Math	Stable	2.0	aten, pointwise	A variant of `bitwise_and()`.
137	`bitwise_and_tensor`	Math	Stable	2.0	aten, pointwise	The Tensor method version of `bitwise_and()`.
138	`bitwise_and_tensor_`	Math	Stable	2.2	aten, pointwise	The in-place, Tensor method version of `bitwise_and()`.
139	`bitwise_left_shift`	Math	Stable	4.0	aten, pointwise	Computes the left arithmetic shift of `input` by `other` bits.
140	`bitwise_left_shift_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `bitwise_left_shift()`.
141	`bitwise_not`	Math	Stable	2.0	aten, pointwise	Computes the bitwise NOT of the given `input` tensor.
142	`bitwise_not_`	Math	Stable	2.2	aten, pointwise	The in-place version of `bitwise_not()`.
143	`bitwise_or_scalar`	Math	Stable	2.0	aten, pointwise	Computes the bitwise OR of scalars `input` and `other`.
144	`bitwise_or_scalar_`	Math	Stable	2.2	aten, pointwise	The in-place version of `bitwise_or_scalar`.
145	`bitwise_or_scalar_tensor`	Math	Stable	2.0	aten, pointwise	Computes the bitwise OR of `input` and `other`.
146	`bitwise_or_tensor`	Math	Stable	2.0	aten, pointwise	Computes the bitwise OR of `input` and `other`, this is the Tensor method variant.
147	`bitwise_or_tensor_`	Math	Stable	2.2	aten, pointwise	The in-place version of `bitwise_or_tensor()`.
148	`bitwise_right_shift`	Math	Stable	4.0	aten, pointwise	Computes the right arithmetic shift of `input` by `other` bits.
149	`bitwise_right_shift_`	Math	Alpha	5.4	aten, KernelGen, pointwise	The in-place version of `bitwise_right_shift()`.
150	`bitwise_xor_scalar`	Math	Alpha	5.4	aten, pointwise, KernelGen	Computes the bitwise XOR of tensor `input` and scalar `other`.
151	`bitwise_xor_scalar_`	Math	Alpha	5.4	aten, pointwise, KernelGen	The in-place version of `bitwise_xor_scalar()`.
152	`bitwise_xor_scalar_tensor`	Math	Alpha	5.4	aten, pointwise, KernelGen	Computes the bitwise XOR of scalar `input` and tensor `other`.
153	`bitwise_xor_tensor`	Math	Alpha	5.4	aten, pointwise, KernelGen	Computes the element-wise bitwise XOR of tensor `input` and tensor `other`.
154	`bitwise_xor_tensor_`	Math	Alpha	5.4	aten, pointwise, KernelGen	The in-place version of `bitwise_xor_tensor()`.
155	`blackman_window`	Math	Alpha	5.4	aten, KernelGen	Computes the Blackman window function.
156	`blackman_window_periodic`	Math	Alpha	5.4	aten, KernelGen	A variant of blackman_window() that takes an explicit periodic flag.
157	`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.
158	`bmm`	BLAS	Stable	1.0	aten	Performs a batch matrix-matrix product of matrices stored in `input` and `mat2`.
159	`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.
160	`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.
161	`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.
162	`broadcast_to`	Tensor	Alpha	5.4	aten, KernelGen	Broadcasts input to the shape size. Equivalent to calling input.expand(size).
163	`bucket_sort_topk`	NeuralNetwork	Beta	5.3	fused, DSA	A wrapper of the TLE version and the Triton version bucket-sort topk operation.
164	`bucketize`	Math	Alpha	5.4	aten, KernelGen	Returns the indices of the buckets to which each input value belongs.
165	`cat`	Tensor	Stable	2.2	aten	Concatenates the given sequence of tensors in tensors in the given dimension.
166	`cat_out`	Tensor	Stable	2.2	aten	A variant of `cat` that assigns the result to the provided `out` parameter.
167	`cauchy`	Distribution	Beta	5.3	aten	Draws random numbers from a Cauchy distribution.
168	`cauchy_`	Distribution	Beta	5.3	aten	Fills the tensor with numbers drawn from the Cauchy distribution.
169	`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.
170	`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.
171	`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).
172	`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.
173	`ceil_`	Math	Stable	5.0	aten, pointwise	The in-place version of `ceil()`.
174	`ceil_out`	Math	Stable	5.0	aten, pointwise	A variant of `ceil()` with `out` specified.
175	`celu`	NeuralNetwork	Stable	4.0	aten, nn.functional, pointwise	Applies the quantized CELU (Continuously Differentiable Exponential Linear Unit) activation function element-wise.
176	`celu_`	NeuralNetwork	Stable	4.0	aten, nn.functional, pointwise	The in-place version of `celu()`.
177	`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.
178	`channel_shuffle`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Divides the channels into groups and rearranges each group.
179	`cholesky_inverse`	Math	Alpha	5.4	aten, KernelGen	Compute inverse of symmetric positive-definite matrix from Cholesky factor.
180	`cholesky_solve`	BLAS	Alpha	5.4	aten	Solves a system of linear equations with a symmetric positive-definite matrix using its Cholesky factorization.
181	`cholesky_solve_helper`	Math	Alpha	5.4	aten, KernelGen	Solves a positive-definite linear system using its lower- or upper-triangular Cholesky factor.
182	`cholesky_solve_out`	BLAS	Alpha	5.4	aten	Solves a system of linear equations with a symmetric positive-definite matrix using its Cholesky factorization.
183	`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.
184	`chunk`	Math	Alpha	5.4	aten, KernelGen	Split a tensor into a specific number of chunks along a given dimension.
185	`chunk_cat`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for _chunk_cat.
186	`chunk_gated_delta_rule_fwd`	Attention	Beta	5.3	fused, FLA	The forward case for `ChunkGatedDeltaRuleFunction` with Flash Linear Attention (FLA).
187	`clamp`	Math	Stable	2.0	aten, pointwise	Clamps all elements in `input` into the range `[min, max]`.
188	`clamp_`	Math	Stable	2.2	aten, pointwise	The in-place version of `clamp()`.
189	`clamp_max`	Math	Alpha	5.4	aten, KernelGen, pointwise	Clamps all elements in `input` to be smaller or equal `max`.
190	`clamp_max_`	Math	Alpha	5.4	aten, KernelGen, pointwise	The in-place version of `clamp_max()`.
191	`clamp_min`	Math	Stable	4.0	aten, pointwise	A variant of `clamp()` with `min` set to `min`.
192	`clamp_min_`	Math	Stable	4.0	aten, pointwise	The in-place version of `clamp_()`.
193	`clamp_tensor`	Math	Stable	2.0	aten, pointwise	The tensor version of `clamp()`.
194	`clamp_tensor_`	Math	Stable	2.2	aten, pointwise	The in-place, tensor version of `clamp()`.
195	`clip`	Math	Beta	5.3	aten, KernelGen	This is identical to `clamp()`.
196	`clip_`	Math	Beta	5.3	aten, KernelGen	This is identical to `clamp_()`.
197	`clone`	Tensor	Alpha	5.4	KernelGen, aten, skip_precision_check	Pure layout/memory operation (clone).
198	`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.
199	`col2im`	Math	Alpha	5.3	aten, KernelGen	Rearranges column blocks back into a multidimensional tensor (inverse of im2col).
200	`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.
201	`column_stack_out`	Tensor	Alpha	5.4	aten, KernelGen	A variant of column_stack() that writes the result into the out tensor.
202	`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.
203	`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.
204	`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`.
205	`compute_linear_combination_out`	BLAS	Alpha	5.4	aten, KernelGen	A variant of `_compute_linear_combination()` that writes the result into the `out` tensor.
206	`concat`	Tensor	Alpha	5.4	aten, KernelGen	An alias of `cat()`.
207	`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.
208	`concatenate`	Tensor	Alpha	5.3	aten, KernelGen	An alias of `cat()`.
209	`conj`	Math	Alpha	5.4	aten, KernelGen	Computes the element-wise conjugate of a complex tensor. For non-complex tensors, returns the input unchanged.
210	`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.
211	`conj_copy_out`	Math	Alpha	5.4	aten, KernelGen	A variant of `_conj_copy()` that writes the result into the `out` tensor.
212	`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`.
213	`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`.
214	`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.
215	`contiguous`	Tensor	Removed	4.1	aten, skip_precision_check	Returns a contiguous in memory tensor containing the same data as `self` tensor.
216	`conv1d`	Convolution	Stable	4.2	aten	Applies a 1D convolution over a quantized 1D input composed of several input planes.
217	`conv1d_padding`	Convolution	Stable	4.2	aten	Applies a 1D convolution over a quantized 1D input composed of several input planes.
218	`conv2d`	Convolution	Stable	4.2	aten	Applies a 2D convolution over a quantized 2D input composed of several input planes.
219	`conv2d_padding`	Convolution	Stable	4.2	aten	Applies a 2D convolution over a quantized 2D input composed of several input planes.
220	`conv3d`	Convolution	Stable	4.2	aten	Applies a 3D convolution over a quantized 3D input composed of several input planes.
221	`conv3d_padding`	Convolution	Stable	4.2	aten	Applies a 3D convolution over a quantized 3D input composed of several input planes.
222	`conv_depthwise2d`	NeuralNetwork	Stable	5.3	aten, Convolution, NoCPU	A depthwise convolution for the conv2d neural network function.
223	`conv_tbc_backward`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for conv_tbc_backward.
224	`conv_transpose1d`	Convolution	Beta	5.3	aten, KernelGen	Applies a 1D transposed convolution operator over an input image composed of several input planes.
225	`conv_transpose2d`	Convolution	Alpha	5.3	aten, KernelGen	Applies a 2D transposed convolution operator over an input image composed of several input planes.
226	`conv_transpose3d`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Applies a 3D transposed convolution operator over an input volume composed of several input planes.
227	`convert_weight_to_int4pack`	Math	Alpha	5.4	aten, KernelGen	Converts a weight tensor to int4 packed format.
228	`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`.
229	`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.
230	`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.
231	`copy_`	Tensor	Stable	4.1	aten, pointwise, skip_precision_check	Copies the elements from `src` into `self` tensor and returns `self`.
232	`copysign`	Tensor	Beta	5.3	aten, pointwise	Create a new floating-point tensor with the magnitude of input and the sign of other, elementwise.
233	`copysign_`	Math	Alpha	5.3	aten, KernelGen	Triton kernel implementation for copysign_.
234	`copysign_out`	Tensor	Beta	5.3	aten, pointwise	A variant of `copysign` that allows the output to be saved into `out`.
235	`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.
236	`cos`	Math	Stable	2.0	aten, pointwise	Returns a new tensor with the cosine of the elements of `input` given in radians.
237	`cos_`	Math	Stable	2.2	aten, pointwise	The in-place version of `cos()`.
238	`cosh`	Math	Stable	5.3	aten, pointwise	Returns a new tensor with the hyperbolic cosine of the elements of `input`.
239	`cosh_`	Math	Stable	5.3	aten, pointwise	This is the in-place version of `cosh()`.
240	`cosh_out`	Math	Stable	5.3	aten, pointwise	This is an variant of `cosh()` that assigns the output to the provided `out`.
241	`cosine_embedding_loss`	NeuralNetwork	Alpha	5.4	aten, nn.functional, KernelGen	Compute the cosine embedding loss.
242	`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.
243	`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.
244	`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.
245	`cross_entropy_loss`	NeuralNetwork	Removed	3.0	fused, Reduction	Computes the cross entropy loss between input logits and target.
246	`ctc_loss`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Connectionist Temporal Classification loss for sequence-to-sequence models.
247	`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.
248	`cudnn_batch_norm_backward`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for cudnn_batch_norm_backward.
249	`cudnn_convolution`	NeuralNetwork	Beta	5.3	aten, KernelGen	A wrapper for cuDNN convolution backend.
250	`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.
251	`cudnn_rnn_backward`	Math	Alpha	5.4	aten, 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.
252	`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`.
253	`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.
254	`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)`.
255	`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`.
256	`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.
257	`cumprod`	Math	Beta	5.3	aten, Reduction	Returns the cumulative product of elements of `input` in the dimension `dim`.
258	`cumprod_`	Math	Beta	5.3	aten, Reduction	This is the in-place version of `cumprod()`.
259	`cumsum`	LinearAlg	Stable	1.0	aten
260	`cumsum_`	Reduction	Alpha	5.4	aten, KernelGen	In-place version of cumsum.
261	`cumsum_out`	Reduction	Stable	3.0	aten
262	`cumulative_trapezoid`	Reduction	Alpha	5.4	aten, KernelGen	Cumulatively integrate y using the composite trapezoidal rule with uniform spacing dx along the given dimension.
263	`cutlass_scaled_mm`	LinearAlg	Beta	5.0	fused, vLLM
264	`deg2rad`	Math	Alpha	5.4	aten, KernelGen	Converts angles from degrees to radians.
265	`deg2rad_`	Math	Alpha	5.4	aten, KernelGen	In-place version of deg2rad.
266	`deg2rad_out`	Math	Alpha	5.4	aten, KernelGen	Out-of-place variant of deg2rad with pre-allocated output tensor.
267	`dequantize`	Math	Alpha	5.4	aten, KernelGen	Returns an fp32 Tensor by dequantizing a quantized Tensor.
268	`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.
269	`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.
270	`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`.
271	`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.
272	`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()`.
273	`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.
274	`diagonal_scatter`	Math	Alpha	5.4	aten, KernelGen	Scatter source values into the diagonal of a tensor with optional offset.
275	`diff`	Math	Beta	5.3	aten, KernelGen	Computes the n-th forward difference along the given dimension.
276	`digamma`	Math	Alpha	5.3	aten, KernelGen	Computes the digamma function, which is the logarithmic derivative of the Gamma function.
277	`digamma_`	Math	Stable	5.3	aten, KernelGen	Computes the in-place digamma function, which is the logarithmic derivative of the Gamma function.
278	`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.
279	`dist`	Math	Alpha	5.4	aten, Reduction	Computes the p-norm distance between two tensors.
280	`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.
281	`div_mode_`	Math	Stable	2.2	aten, pointwise	The in-place version of `div_mode()`.
282	`div_out`	Math	Stable	4.2	aten	This is an variant of `div()` with an `out` argument.
283	`div_scalar`	Math	Stable	2.1	aten	This is the scalar version of `div()`.
284	`div_scalar_`	Math	Stable	2.1	aten	This is the in-place version of `div_scalar()`.
285	`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`.
286	`div_tensor_`	Math	Stable	2.1	aten	This is the in-place version of `div_tensor()`.
287	`divide`	Math	Alpha	5.4	aten, pointwise, KernelGen	An alias of `div()` for element-wise division.
288	`dot`	BLAS	Stable	3.0	aten	Computes the dot product of two 1D tensors.
289	`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.
290	`dropout`	NeuralNetwork	Stable	1.0	aten, nn.functional	An internal IR for implementing `torch.nn.functional.dropout`.
291	`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.
292	`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.
293	`dunder_ior_scalar`	Math	Beta	5.3	aten, KernelGen	The scalar version of `dunder_ior_tensor`.
294	`dunder_ior_tensor`	Math	Beta	5.3	aten, KernelGen	The in-place version of bitwise or operation for tensor and scalar.
295	`dunder_or_scalar`	Math	Beta	5.3	aten, KernelGen	The scalar version of `dunder_or_tensor`.
296	`dunder_or_tensor`	Math	Beta	5.3	aten, KernelGen	The in-place version of bitwise or operation for tensor and scalar.
297	`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.
298	`efficient_attention_backward`	NeuralNetwork	Beta	5.4	aten, NoCPU	Backward kernel for FlashAttention, computing gradients of queries, keys, values, and attention outputs efficiently.
299	`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.
300	`elu`	NeuralNetwork	Stable	2.2	aten, nn.functional, pointwise	Apply the Exponential Linear Unit (ELU) function element-wise.
301	`elu_`	NeuralNetwork	Stable	4.0	aten, pointwise	The in-place version of `elu()`.
302	`elu_backward`	NeuralNetwork	Stable	4.0	aten, pointwise	The backward version of `elu()`.
303	`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`.
304	`embedding_backward`	NeuralNetwork	Stable	3.0	aten, NoCPU	The backward version of `embedding()`.
305	`embedding_bag_dense_backward`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Computes the gradient for the backward pass of embedding_bag in dense mode.
306	`embedding_bag_per_sample_weights_backward`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Triton kernel implementation for _embedding_bag_per_sample_weights_backward.
307	`embedding_dense_backward`	NeuralNetwork	Stable	5.0	aten, NoCPU	Calculates the gradient of the weight matrix for a dense embedding layer during backpropagation.
308	`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.
309	`empty`	Tensor	Alpha	5.4	aten, KernelGen, skip_precision_check	Tensor factory operator — verifies dtype inference for newly allocated tensors.
310	`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.
311	`eq`	Math	Stable	2.0	aten, pointwise	Computes element-wise equality.
312	`eq_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `eq()`.
313	`eq_scalar`	Math	Stable	2.0	aten, pointwise	Computes equality between scalars.
314	`eq_scalar_`	Math	Alpha	5.4	aten, KernelGen	The scalar version of `eq_()`.
315	`equal`	Math	Stable	5.0	aten, Reduction	Returns True if two tensors have the same size and elements, False otherwise.
316	`erf`	Science	Stable	2.1	aten, pointwise	Computes the error function of `input`.
317	`erf_`	Science	Stable	2.2	aten, pointwise	The in-place version of `erf()`.
318	`erfc`	Math	Alpha	5.4	aten, pointwise, KernelGen	Computes the complementary error function.
319	`erfc_`	Math	Alpha	5.4	aten, pointwise, KernelGen	In-place version of `erfc`.
320	`erfinv`	Math	Alpha	5.4	aten, KernelGen	Computes the inverse error function of `input`.
321	`erfinv_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `erfinv()`.
322	`euclidean_dist`	Math	Alpha	5.3	aten, KernelGen, pointwise	Computes pairwise Euclidean distances between rows of two 2D tensors.
323	`exp`	Math	Stable	1.0	aten, pointwise	Returns a new tensor with the exponential of the elements of the input tensor `input`.
324	`exp2`	Math	Stable	4.0	aten, pointwise	Computes the base two exponential function of `input`.
325	`exp2_`	Math	Stable	4.0	aten, pointwise	The in-place version of `exp2()`.
326	`exp_`	Math	Stable	2.2	aten, pointwise	The in-place version of `exp()`.
327	`exp_out`	Math	Stable	4.1	aten, pointwise	A variant of `exp2()`, with `out` specified.
328	`expand`	Tensor	Alpha	5.4	aten, KernelGen, skip_precision_check	Pure layout operation (expand).
329	`expand_`	Tensor	Alpha	5.4	aten, KernelGen, skip_precision_check	Pure layout operation (expand, in-place).
330	`expand_as`	Math	Alpha	5.4	aten, KernelGen	Expand tensor to the same size as another tensor (view operation).
331	`expand_copy`	Math	Alpha	5.4	aten, KernelGen	Returns a copy of the input tensor expanded by broadcasting singleton dimensions.
332	`expm1`	Math	Beta	5.3	aten	Computes the exponential of the elements minus 1 of `input`.
333	`expm1_`	Math	Beta	5.3	aten	The inplace version of `expm1`.
334	`expm1_out`	Math	Beta	5.3	aten	A variant of `expm1` that saves the output to the specified `out`.
335	`exponential`	Distribution	Alpha	5.4	aten, skip_precision_check	Returns a new tensor with elements drawn from an exponential PDF (probability density function).
336	`exponential_`	Distribution	Stable	2.1	aten, skip_precision_check	Fills `self` tensor with elements drawn from a PDF (probability density function).
337	`eye`	LinearAlg	Stable	3.0	aten, Reduction	Returns a 2-D tensor with ones on the diagonal and zeros elsewhere.
338	`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.
339	`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]`.
340	`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.
341	`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.
342	`fake_quantize_per_channel_affine`	Quantization	Alpha	5.4	aten, pointwise, KernelGen	Applies fake quantization per channel with affine parameters (scale and zero_point).
343	`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.
344	`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.
345	`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.
346	`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.
347	`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.
348	`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.
349	`feature_dropout_`	NeuralNetwork	Alpha	5.3	aten, KernelGen	The in-place version of `feature_dropout()`.
350	`fft_irfftn`	Math	Alpha	5.4	aten, KernelGen	Computes the N-dimensional inverse of torch.fft.rfftn.
351	`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.
352	`fill_mem_eff_dropout_mask_`	NeuralNetwork	Alpha	5.4	aten, 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`.
353	`fill_scalar`	Tensor	Stable	2.2	aten, pointwise	Fills a scalar with the specified value.
354	`fill_scalar_`	Tensor	Stable	2.2	aten, pointwise	The in-place version of `fill_scalar()`.
355	`fill_scalar_out`	Tensor	Stable	5.0	aten, pointwise, KernelGen	A variant of `fill_scalar()` that assigns the output to an `out` tensor.
356	`fill_tensor`	Tensor	Stable	2.2	aten, pointwise	Fills a tensor with the specified value.
357	`fill_tensor_`	Tensor	Stable	2.2	aten, pointwise	The in-place version of `fill_tensor()`.
358	`fill_tensor_out`	Tensor	Stable	5.0	aten, pointwise, KernelGen	A variant of `fill_tensor()` that assigns the output to an `out` tensor.
359	`fix`	Math	Alpha	5.4	aten, KernelGen	fix operator
360	`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.
361	`flash_attention_backward`	NeuralNetwork	Beta	5.4	aten, NoCPU	Backward kernel for FlashAttention, computing gradients of queries, keys, values, and attention outputs efficiently.
362	`flash_attention_forward`	NeuralNetwork	Stable	3.0	aten, NoCPU
363	`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.
364	`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.
365	`flash_mla`	NeuralNetwork	Stable	3.0	fused, Attention, vLLM	A variant of Multi-head Latent Attention (MLA).
366	`flash_mla_sparse_fwd`	NeuralNetwork	Alpha	5.3	fused, Attention, vLLM	Part of the FlashMLA.
367	`flatten`	Math	Alpha	5.4	aten, KernelGen	Flatten a contiguous range of dimensions into a single dimension (view operation).
368	`flip`	Tensor	Stable	2.1	aten, pointwise	Reverse the order of an n-D tensor along given axis in dims.
369	`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.
370	`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.
371	`float_power_`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for float_power_.
372	`float_power_scalar_tensor`	Math	Alpha	5.4	aten, KernelGen	Computes a scalar base raised element-wise to tensor exponents in float64.
373	`float_power_scalar_tensor_out`	Math	Alpha	5.4	aten, KernelGen	Out variant of float_power.Scalar.
374	`float_power_tensor_scalar`	Math	Alpha	5.4	aten, KernelGen	Raises tensor elements to a scalar exponent in float64.
375	`float_power_tensor_scalar_out`	Math	Alpha	5.4	aten, KernelGen	Out variant of float_power.Tensor_Scalar.
376	`float_power_tensor_tensor`	Math	Alpha	5.4	aten, KernelGen	Raises tensor elements to tensor exponents in float64 with broadcasting.
377	`float_power_tensor_tensor_out`	Math	Alpha	5.4	aten, KernelGen	Out variant of float_power.Tensor_Tensor.
378	`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.
379	`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.
380	`floor_divide_scalar`	Math	Stable	2.1	aten	Computes `input` divided by `other`, elementwise, and floors the result.
381	`floor_divide_scalar_`	Math	Stable	2.2	aten	Computes `input` divided by `other`, elementwise, and floors the result.
382	`floor_divide_tensor`	Math	Stable	2.1	aten	Computes `input` divided by `other`, elementwise, and floors the result.
383	`floor_divide_tensor_`	Math	Stable	2.2	aten	Computes `input` divided by `other`, elementwise, and floors the result.
384	`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.
385	`fmax`	Math	Alpha	5.4	aten, KernelGen	Computes the element-wise maximum of input and other, ignoring NaNs.
386	`fmax_out`	Math	Alpha	5.4	aten, KernelGen	Computes the element-wise maximum of input and other, ignoring NaNs (out variant).
387	`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.
388	`fmin_out`	Math	Stable	5.3	aten, KernelGen	A variant of `fmin()` that assigns the output to the `out` tensor.
389	`fmod_`	Math	Alpha	5.4	aten, KernelGen	In-place remainder of division (fmod_), computes element-wise remainder with truncation toward zero.
390	`fmod_scalar`	Math	Alpha	5.3	aten, KernelGen	Computes the element-wise remainder of division of input by a scalar divisor.
391	`fmod_scalar_`	Math	Alpha	5.3	aten, KernelGen	In-place version of fmod with a scalar divisor.
392	`fmod_tensor`	Math	Alpha	5.3	aten, KernelGen	Computes the element-wise remainder of division of input by a tensor divisor.
393	`fmod_tensor_`	Math	Alpha	5.3	aten, KernelGen	In-place version of fmod with a tensor divisor.
394	`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.
395	`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.
396	`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.
397	`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.
398	`frac`	Math	Alpha	5.4	aten, KernelGen	Computes the fractional part of each element, returning x - trunc(x).
399	`frac_`	Math	Alpha	5.4	aten, KernelGen	In-place fractional part computation, returning x - trunc(x).
400	`fractional_max_pool2d`	Math	Alpha	5.4	aten, KernelGen	Applies 2D fractional max pooling over an input signal composed of several input planes.
401	`fractional_max_pool2d_backward`	Math	Alpha	5.4	aten, KernelGen	Computes the gradient of fractional_max_pool2d.
402	`frexp`	Math	Alpha	5.4	aten, KernelGen	Return mantissa and exponent of input, such that x = mantissa * 2^exponent, with mantissa in (-1, 1).
403	`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`.
404	`full_like`	Tensor	Stable	2.1	aten, pointwise	Returns a tensor with the same size as `input` filled with `fill_value`.
405	`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.
406	`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.
407	`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.
408	`fused_adam`	Math	Alpha	5.4	aten, KernelGen	Fused Adam optimizer step with optional AdamW weight decay, AMSGrad, and gradient maximize support.
409	`fused_adam_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `fused_adam()`.
410	`fused_add_rms_norm`	NeuralNetwork	Stable	2.0	fused, Normalization
411	`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.
412	`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.
413	`fused_experts_impl`	NeuralNetwork	Beta	5.3	fused, vLLM, MoE	An implementation of fused MoE.
414	`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.
415	`fused_moe`	NeuralNetwork	Beta	5.3	fused, vLLM, MoE	The generic interface for fused MoE.
416	`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.
417	`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.
418	`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).
419	`fused_rms_norm`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Fused RMS normalization returning the normalized output and inverse RMS.
420	`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.
421	`gather`	Tensor	Stable	2.2	aten, Reduction	Gathers values along an axis specified by `dim`.
422	`gather_backward`	Tensor	Stable	2.2	aten, Reduction	The backward version of `gather()`.
423	`gather_block_quantized`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for gather_block_quantized.
424	`gcd`	Math	Beta	5.3	aten	Computes the element-wise greatest common divisor (GCD) of `input` and `other`.
425	`gcd_`	Math	Alpha	5.4	aten, KernelGen	Computes the element-wise greatest common divisor (GCD) of `input` and `other` in-place.
426	`gcd_out`	Math	Beta	5.3	aten	A variant of `gcd()` that allows the output to be assigned to the specified `out`.
427	`ge`	Math	Stable	2.0	aten, pointwise	Computes `input` is greater or equal to `other` element-wise.
428	`ge_scalar`	Math	Stable	2.0	aten, pointwise	The scalar version of `ge()`.
429	`geglu`	NeuralNetwork	Beta	5.3	fused, Activation, Transformer	Gaussian Error Gated Linear Unit with GELU activation instead of sigmoid function.
430	`gelu`	NeuralNetwork	Stable	1.0	aten, pointwise, Activation, nn.functional	Apply Cumulative Distribution Function for Gaussian Distribution function element-wise.
431	`gelu_`	NeuralNetwork	Stable	2.2	aten, Activation, pointwise	The in-place version of `gelu()`.
432	`gelu_and_mul`	NeuralNetwork	Stable	2.0	fused, pointwise, Activation	An activation function for GeGLU.
433	`gelu_backward`	NeuralNetwork	Stable	3.0	aten, Activation, pointwise	The backward version of `gelu()`.
434	`geometric`	Distribution	Beta	5.1	aten	Draws random numbers from a geometric distribution.
435	`geometric_`	Distribution	Beta	5.1	aten	Fills self tensor with elements drawn from the geometric distribution.
436	`get_paged_mqa_logits_metadata`	NeuralNetwork	Beta	5.3	vLLM	Build scheduling metadata for paged MQA logits.
437	`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.
438	`glu`	NeuralNetwork	Stable	3.0	aten, Activation, pointwise	Gated Linear Unit activation for modulating the output of a linear transformation with a gate.
439	`glu_backward`	NeuralNetwork	Stable	4.0	aten, Activation, pointwise	The backward version of `glu()`.
440	`greater`	Math	Stable	5.3	aten	Test if input is greater than `other` elementwise.
441	`greater_equal_`	Math	Alpha	5.4	aten, pointwise, KernelGen	The in-place version of `greater_equal()`, which is an alias for `ge()`.
442	`greater_out`	Math	Stable	5.3	aten	A variant of `greater` that saves the output to the specified `out`.
443	`greater_scalar`	Math	Stable	5.3	aten	A variant of `greater` for scalar variables.
444	`greater_scalar_out`	Math	Stable	5.3	aten	A variant of `greater_out` that saves the output to the specified `out`.
445	`grid_sample`	NeuralNetwork	Alpha	5.3	aten, nn.functional	Given an `input` and a flow-field `grid`, computes the `output` using `input` values and pixel locations from `grid`.
446	`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.
447	`grid_sampler_3d_backward`	Math	Alpha	5.4	aten, KernelGen	Backward pass for 3D grid sampling with bilinear/nearest interpolation and multiple padding modes.
448	`group_norm`	NeuralNetwork	Stable	2.0	aten, Reduction	An internal IR for applying Group Normalization for last certain number of dimensions.
449	`group_norm_backward`	NeuralNetwork	Stable	3.0	aten, Reduction	The backward case for `group_norm()`.
450	`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.
451	`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.
452	`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.
453	`gru_data`	NeuralNetwork	Beta	5.4	aten	Gated recurrent unit (GRU) over packed-sequence data.
454	`gt`	Math	Stable	2.0	aten, pointwise	Computes that `input` is greater than `other` element-wise.
455	`gt_scalar`	Math	Stable	2.0	aten, pointwise	The scalar version of `gt()`.
456	`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.
457	`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.
458	`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.
459	`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.
460	`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.
461	`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.
462	`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`.
463	`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.
464	`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.
465	`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.
466	`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`.
467	`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.
468	`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.
469	`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.
470	`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.
471	`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.
472	`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.
473	`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.
474	`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.
475	`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.
476	`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.
477	`histc`	Math	Alpha	5.3	aten, KernelGen	Computes the histogram of a tensor, binning each element into equal-width bins.
478	`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.
479	`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.
480	`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.
481	`huber_loss_out`	NeuralNetwork	Alpha	5.4	aten, KernelGen, Loss	Out-variant of huber_loss. Writes the computed loss into the `out` tensor.
482	`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.
483	`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`.
484	`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.
485	`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.
486	`i0_`	Math	Stable	5.3	aten, KernelGen	The inplace version of `i0`.
487	`i0_out`	Math	Stable	5.3	aten, KernelGen	A variant of `i0` that assigns the output to the `out` tensor.
488	`igamma`	Math	Alpha	5.4	aten, KernelGen	Computes the regularized lower incomplete gamma function element-wise.
489	`igamma_`	Math	Alpha	5.4	aten, KernelGen	In-place computation of the regularized lower incomplete gamma function.
490	`igammac`	Math	Alpha	5.4	aten	Computes the regularized upper incomplete gamma function Q(a, x) element-wise.
491	`igammac_`	Math	Alpha	5.4	aten, KernelGen, pointwise	In-place version of igammac. Computes the regularized upper incomplete gamma function complement.
492	`igammac_out`	Math	Alpha	5.4	aten	Out-of-place variant of igammac that writes the result to the out tensor.
493	`ilshift`	Math	Alpha	5.4	aten, KernelGen	Computes the in-place bitwise left shift of `self` by `other` bits.
494	`im2col`	Math	Alpha	5.4	aten, KernelGen	Extracts sliding local blocks from a batched input tensor.
495	`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.
496	`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`.
497	`index_add_`	Tensor	Stable	4.0	aten	The in-place version of `index_add()`.
498	`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`.
499	`index_copy_`	Tensor	Beta	5.3	aten, KernelGen	The in-place version of `index_copy()`.
500	`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`.
501	`index_fill_`	Tensor	Alpha	5.4	aten	The in-place version of `index_fill()`.
502	`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).
503	`index_put_`	Tensor	Stable	3.0	aten	The in-place version of `index_put()`.
504	`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.
505	`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.
506	`index_select`	Tensor	Stable	2.1	aten	Returns a new tensor which indexes the `input` tensor along dimension `dim` using the entries in `index`.
507	`index_select_backward`	Math	Alpha	5.4	aten, KernelGen	Backward of index_select. Accumulates gradients into the output at positions specified by the index.
508	`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.
509	`inplace_fused_experts`	MoE	Stable	5.3	fused, Activation, vLLM	This operator writes output directly to `hidden_states`.
510	`instance_norm`	NeuralNetwork	Beta	5.3	fused	Apply Instance Normalization independently for each channel in every data sample within a batch.
511	`irshift`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for irshift.
512	`is_all_true`	Tensor	Beta	5.3	aten, pointwise, KernelGen	The low-level implementation for checking if all elements in a tensor are True.
513	`is_nonzero`	Math	Alpha	5.4	aten, KernelGen	Returns True if the single-element input tensor is not equal to zero.
514	`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`.
515	`isfinite`	Math	Stable	2.1	aten, pointwise	Returns a new tensor with boolean elements representing if each element is finite or not.
516	`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.
517	`isin_scalar_tensor`	Tensor	Stable	2.2	aten	A variant of `isin()`.
518	`isin_tensor_scalar`	Tensor	Stable	2.2	aten	A variant of `isin()`.
519	`isinf`	Math	Stable	2.0	aten, pointwise	Tests if each element of `input` is infinite (positive or negative infinity) or not.
520	`isnan`	Math	Stable	2.0	aten, pointwise	Returns a new tensor with boolean elements representing if each element of `input` is NaN or not.
521	`isneginf`	Math	Stable	5.3	aten, KernelGen, pointwise	Tests if each element of `input` is negative infinity or not.
522	`isneginf_out`	Math	Stable	5.3	aten, KernelGen, pointwise	A variant of `isneginf` that saves the output to the specified `out`.
523	`isposinf`	Math	Alpha	5.4	aten, KernelGen	Tests if each element of input is positive infinity or not.
524	`ixor`	Math	Alpha	5.4	aten, pointwise, KernelGen	Computes the bitwise XOR of input tensors or a tensor and a scalar (inplace).
525	`jagged_to_padded_dense_forward`	Tensor	Alpha	5.4	aten, KernelGen	Converts a jagged (variable-length) tensor to a padded dense tensor.
526	`kron`	LinearAlg	Stable	2.2	aten	Computes the Kronecker product of `input` and `other`.
527	`kthvalue`	Tensor	Alpha	5.4	aten, KernelGen	Returns the kth smallest element of the given input tensor along a given dimension.
528	`layer_norm`	NeuralNetwork	Stable	1.0	aten	An internal IR for applying Layer Normalization for last certain number of dimensions.
529	`layer_norm_backward`	Reduction	Stable	3.0	aten	The backward case for `layer_norm()`.
530	`lcm`	Pointwise	Alpha	5.4	aten, pointwise, KernelGen	Compute the element-wise least common multiple of input tensors.
531	`lcm_`	Pointwise	Alpha	5.4	aten, pointwise, KernelGen	Compute the element-wise least common multiple of input tensors, storing result in-place.
532	`le`	Math	Stable	2.0	aten, pointwise	Computes that `input` is less than or equal to `other` element-wise.
533	`le_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `le()`.
534	`le_scalar`	Math	Stable	2.0	aten, pointwise	The scalar version of `le()`.
535	`le_scalar_`	Math	Alpha	5.4	aten, KernelGen	The scalar version of `le_()`.
536	`leaky_relu`	NeuralNetwork	Beta	5.3	aten	Applies the LeakyReLU function element-wise.
537	`leaky_relu_`	NeuralNetwork	Beta	5.3	aten	The in-place version of `leaky_relu()`.
538	`leaky_relu_backward`	NeuralNetwork	Beta	5.3	aten, pointwise	A variant of `leaky_relu()` for backward case.
539	`leaky_relu_out`	NeuralNetwork	Beta	5.3	aten	A variant of `leaky_relu()`.
540	`lerp_scalar`	LinearAlg	Stable	3.0	aten, pointwise	The scalar version of `lerp()`.
541	`lerp_scalar_`	LinearAlg	Stable	3.0	aten, pointwise	The in-place, scalar version of `lerp()`.
542	`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.
543	`lerp_tensor_`	LinearAlg	Stable	3.0	aten, pointwise	The in-place version of `lerp()`.
544	`less_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `less()`.
545	`less_equal`	Math	Alpha	5.4	aten, KernelGen	Computes element-wise less-than-or-equal-to comparison.
546	`less_equal_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `less_equal()`.
547	`less_equal_scalar`	Math	Alpha	5.4	aten, KernelGen	Computes less-than-or-equal-to comparison with a scalar.
548	`less_equal_scalar_`	Math	Alpha	5.4	aten, KernelGen	The scalar version of `less_equal_()`.
549	`less_scalar_`	Math	Alpha	5.4	aten, KernelGen	The scalar version of `less_()`.
550	`lgamma`	Math	Alpha	5.4	aten, KernelGen	Computes the logarithm of the gamma function on input.
551	`lgamma_`	Math	Alpha	5.4	aten, KernelGen	In-place version of lgamma().
552	`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.
553	`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.
554	`lift_fresh_copy`	Tensor	Stable	5.3	aten, KernelGen	Creates a new, independent copy of a tensor within a compiled graph.
555	`lift_out`	Tensor	Alpha	5.4	aten, KernelGen	Out-of-place variant of lift that copies self to the out tensor.
556	`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.
557	`linalg_cross`	LinearAlg	Alpha	5.4	aten	Computes the cross product of two 3-dimensional vectors along a specified dimension.
558	`linalg_cross_out`	LinearAlg	Alpha	5.4	aten	A variant of `linalg_cross` that allows the output to be assigned to `out`.
559	`linalg_det`	LinearAlg	Alpha	5.4	aten	Computes the determinant of a square matrix via LU decomposition with partial pivoting.
560	`linalg_det_out`	LinearAlg	Alpha	5.4	aten	A variant of linalg_det that writes the determinant to the provided out tensor.
561	`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.
562	`linalg_eigvals`	Math	Alpha	5.4	aten, KernelGen	Computes the eigenvalues of a square matrix.
563	`linalg_householder_product`	Math	Alpha	5.4	aten, KernelGen	Compute the matrix product of Householder matrices from QR decomposition.
564	`linalg_ldl_factor`	LinearAlg	Alpha	5.4	aten, KernelGen	Computes the compact LDL factorization of a Hermitian or symmetric matrix.
565	`linalg_ldl_factor_ex`	Math	Alpha	5.4	aten, KernelGen	Computes the LDL factorization with pivot information for a symmetric or Hermitian matrix.
566	`linalg_ldl_solve`	LinearAlg	Alpha	5.4	aten, KernelGen	Triton kernel implementation for linalg_ldl_solve.
567	`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.
568	`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).
569	`linalg_lu_factor`	Math	Alpha	5.4	aten	Computes a compact representation of the LU factorization with partial pivoting of a matrix.
570	`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.
571	`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.
572	`linalg_lu_factor_out`	Math	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.
573	`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.
574	`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.
575	`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.
576	`linalg_matrix_norm`	LinearAlg	Alpha	5.4	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.
577	`linalg_matrix_power`	LinearAlg	Beta	5.4	aten	Computes the n-th power of a square matrix using binary exponentiation.
578	`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.
579	`linalg_matrix_rank`	LinearAlg	Beta	5.4	aten	Computes the numerical rank of a matrix or a batch of matrices.
580	`linalg_matrix_rank_atol_rtol_float`	LinearAlg	Beta	5.4	aten	Computes numerical matrix rank using optional scalar absolute and relative tolerances.
581	`linalg_matrix_rank_atol_rtol_float_out`	LinearAlg	Beta	5.4	aten	Computes numerical matrix rank using scalar tolerances and an output tensor.
582	`linalg_matrix_rank_atol_rtol_tensor`	LinearAlg	Beta	5.4	aten	Computes numerical matrix rank using optional tensor absolute and relative tolerances.
583	`linalg_matrix_rank_atol_rtol_tensor_out`	LinearAlg	Beta	5.4	aten	Computes numerical matrix rank using tensor tolerances and an output tensor.
584	`linalg_matrix_rank_out`	LinearAlg	Beta	5.4	aten	Computes numerical matrix rank using a scalar tolerance and an output tensor.
585	`linalg_matrix_rank_out_tol_tensor`	LinearAlg	Beta	5.4	aten	Computes numerical matrix rank using a tensor tolerance and an output tensor.
586	`linalg_matrix_rank_tol_tensor`	LinearAlg	Beta	5.4	aten	Computes numerical matrix rank using a positional tensor tolerance.
587	`linalg_matrix_sqrth`	LinearAlg	Alpha	5.4	aten, KernelGen	Computes the principal square root of a symmetric or Hermitian positive-definite matrix.
588	`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.
589	`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.
590	`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.
591	`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.
592	`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.
593	`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.
594	`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.
595	`linalg_svd`	BLAS	Alpha	5.4	aten, KernelGen	Computes the singular value decomposition (SVD) of a matrix.
596	`linalg_svdvals`	Math	Alpha	5.4	aten, KernelGen	Computes the singular values of a matrix.
597	`linalg_vecdot`	Math	Alpha	5.4	aten	Computes the dot product of two vectors along a specified dimension.
598	`linalg_vecdot_out`	Math	Alpha	5.4	aten	Computes the dot product of two vectors along a specified dimension.
599	`linear`	BLAS	Alpha	5.4	aten, KernelGen	Applies a linear transformation to the incoming data: y = x @ W^T + b.
600	`linear_backward`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for linear_backward.
601	`linspace`	Tensor	Stable	2.2	aten	Creates a one-dimensional tensor of size `steps` whose values are evenly spaced from `start` to `end`, inclusive.
602	`list_to_tensor`		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.
603	`log`	Math	Stable	2.2	aten, pointwise	Returns a new tensor with the natural logarithm of the elements of `input`.
604	`log10`	Math	Beta	5.3	aten, pointwise	Returns a new tensor with the logarithm to the base 10 of the elements of `input`.
605	`log10_`	Math	Beta	5.3	aten, pointwise	The in-place version of `log10()`.
606	`log10_out`	Math	Beta	5.3	aten, pointwise	A variant of `log10()` that assigns the output to the provided `out`.
607	`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.
608	`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.
609	`log2`	Math	Alpha	5.4	aten, pointwise, KernelGen	Returns a new tensor with the logarithm to the base 2 of the elements of `input`.
610	`log2_`	Math	Alpha	5.4	aten, pointwise, KernelGen	The in-place version of `log2()`.
611	`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.
612	`log_normal`	Distribution	Beta	5.4	aten, skip_precision_check	Returns a new tensor with log-normal samples parameterized by mean and standard deviation.
613	`log_normal_`	Distribution	Alpha	5.1	aten, KernelGen	Fills the tensor with log-normal samples parameterized by mean and standard deviation, in-place.
614	`log_sigmoid`	NeuralNetwork	Stable	2.2	aten, pointwise, nn.functional	Applies the Logsigmoid function element-wise.
615	`log_sigmoid_backward`	NeuralNetwork	Alpha	5.4	aten, pointwise	Computes the input gradient of the Logsigmoid function.
616	`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.
617	`log_sigmoid_forward`	Math	Alpha	5.4	aten, KernelGen	Computes the output and buffer for the log-sigmoid function, used in autograd backward pass.
618	`log_softmax`	NeuralNetwork	Stable	3.0	aten, Reduction	An internal IR for applying a softmax followed by a logarithm.
619	`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.
620	`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.
621	`log_softmax_out`	NeuralNetwork	Stable	3.0	aten, Reduction	An internal IR for applying a softmax followed by a logarithm.
622	`logaddexp`	Math	Stable	5.3	aten, pointwise, KernelGen	Computes the element-wise logarithm of the sum of the exponentials of two input tensors.
623	`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.
624	`logaddexp2_out`	Math	Beta	5.4	aten, pointwise	A variant of `logaddexp2` that allows the output to be assigned to an `out` tensor.
625	`logaddexp_out`	Math	Stable	5.3	aten, pointwise, KernelGen	A variant of `logaddexp` that allows the output to be assigned to an `out` tensor.
626	`logcumsumexp`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for logcumsumexp.
627	`logcumsumexp_out`	Math	Alpha	5.4	aten, KernelGen	A variant of `logcumsumexp` that allows the output to be assigned to an `out` tensor.
628	`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.
629	`logical_and_`	Math	Stable	5.0	aten, pointwise	The in-place version of `logical_and()`.
630	`logical_not`	Math	Stable	2.2	aten, pointwise	Computes the element-wise logical NOT of the given `input` tensor.
631	`logical_not_`	Math	Alpha	5.4	aten, KernelGen	In-place version of logical_not. Computes the element-wise logical NOT.
632	`logical_or`	Math	Stable	2.2	aten, pointwise	Computes the element-wise logical OR of the given input tensors.
633	`logical_or_`	Math	Stable	5.0	aten, pointwise	The in-place version of `logical_or()`.
634	`logical_xor`	Math	Stable	2.2	aten, pointwise	Computes the element-wise logical XOR of the given input tensors.
635	`logical_xor_`	Math	Alpha	5.4	aten, KernelGen, pointwise	The in-place version of `logical_xor()`.
636	`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.
637	`logit_`	LinearAlg	Stable	5.3	aten, pointwise, KernelGen	The in-place version of `logit()`.
638	`logit_backward`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for logit_backward.
639	`logit_out`	LinearAlg	Stable	5.3	aten, pointwise, KernelGen	A variant of `logit` that allows the output to be assigned to another tensor.
640	`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`.
641	`logsumexp`	Math	Alpha	5.3	aten, KernelGen	Computes the log of the sum of exponentials of elements in the input tensor along given dimensions.
642	`lshift`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for lshift.
643	`lstm`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Triton kernel implementation for lstm.
644	`lt`	Math	Stable	2.0	aten, pointwise	Computes that `input` is less than `other` element-wise.
645	`lt_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `lt()`.
646	`lt_scalar`	Math	Stable	2.0	aten, pointwise	The scalar version of `lt`.
647	`lt_scalar_`	Math	Alpha	5.4	aten, KernelGen	The scalar version of `lt_()`.
648	`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.
649	`lu_unpack_out`	Math	Alpha	5.4	aten, KernelGen	Out-of-place variant of lu_unpack that writes results into pre-allocated output tensors.
650	`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.
651	`margin_ranking_loss`	NeuralNetwork	Beta	5.3	aten, nn.functional, KernelGen	Compute the margin ranking loss.
652	`masked_fill`	Tensor	Stable	2.2	aten, pointwise	Fills elements of given tensor with `value` where `mask` is True.
653	`masked_fill_`	Tensor	Stable	2.2	aten, pointwise, skip_precision_check	The in-place version of `masked_fill()`.
654	`masked_fill_scalar`	Tensor	Stable	2.2	aten, pointwise	Fills elements of given tensor with `value` where `mask` is True.
655	`masked_fill_scalar_`	Tensor	Stable	2.2	aten, pointwise, skip_precision_check	The in-place version of `masked_fill()`.
656	`masked_scale`	Tensor	Alpha	5.4	aten, KernelGen, pointwise	The low-level implementation for computing input multiplied by scale with masking.
657	`masked_scatter`	tensor	Stable	4.2	aten	Copies elements from `source` into the given tensor at positions where the `mask` is True.
658	`masked_scatter_`	tensor	Stable	4.2	aten	The in-place version of `masked_scatter()`.
659	`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).
660	`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.
661	`matmul_bias_activation`	BLAS	Alpha	5.4	KernelGen	Fused matrix multiplication with bias addition and ReLU activation.
662	`matmuladd`	Math	Alpha	5.4	fused, KernelGen	Computes matrix multiplication followed by bias addition.
663	`matrix_exp_backward`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for matrix_exp_backward.
664	`max`	LinearAlg	Stable	2.0	aten, Reduction	Returns the maximum value of all elements in the `input` tensor.
665	`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).
666	`max_pool1d`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Triton kernel implementation for max_pool1d.
667	`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.
668	`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.
669	`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.
670	`max_pool3d_backward`	NeuralNetwork	Beta	5.3	aten, nn.functional	The backward version of `max_pool2d_with_indices()`.
671	`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.
672	`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.
673	`max_unpool2d`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Computes a partial inverse of `MaxPool2d`.
674	`max_unpool3d`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for max_unpool3d.
675	`maximum`	Math	Stable	2.1	aten, pointwise	Computes the element-wise maximum of `input` and `other`.
676	`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.
677	`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.
678	`median`	LinearAlg	Beta	5.4	aten, KernelGen, Reduction	Returns the median of the values in `input`.
679	`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.
680	`median_dim_values`	LinearAlg	Beta	5.4	aten, KernelGen, Reduction	A variant of `median_dim()` with the `out` argument.
681	`median_out`	LinearAlg	Beta	5.4	aten, KernelGen, Reduction	A variant of `median()` with the `out` argument.
682	`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.
683	`mhc_post`	NeuralNetwork	Beta	5.3	fused, vLLM, DSA	Triton implementation of mHC Post operator (optimized v3).
684	`mhc_pre`	NeuralNetwork	Beta	5.3	fused, vLLM, DSA	Triton implementation of mHC Pre operator (optimized v2).
685	`min`	Tensor	Stable	2.0	aten, Reduction	Returns the minimum value of all elements in the `input` tensor.
686	`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).
687	`minimum`	Math	Stable	2.1	aten, pointwise	Computes the element-wise minimum of `input` and `other`.
688	`miopen_batch_norm_backward`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for miopen_batch_norm_backward.
689	`mish`	NeuralNetwork	Alpha	5.4	aten, KernelGen, pointwise, Activation	Applies the Mish activation function element-wise.
690	`mish_`	NeuralNetwork	Alpha	5.4	aten, KernelGen, pointwise, Activation	The in-place version of `mish()`.
691	`mish_backward`	NeuralNetwork	Alpha	5.4	aten, KernelGen, pointwise	Computes the gradient of Mish activation with respect to the input.
692	`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.
693	`mm`	BLAS	Stable	1.0	aten	Performs a matrix multiplication of the two input matrices.
694	`mm_out`	BLAS	Stable	3.0	aten	A variant of `mm()` with `out` specified.
695	`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.
696	`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.
697	`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.
698	`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.
699	`mse_loss`	NeuralNetwork	Stable	2.2	aten, pointwise, nn.functional	Compute the element-wise mean squared error, with optional weighting.
700	`mse_loss_backward`	NeuralNetwork	Alpha	5.4	aten, NeuralNetwork, KernelGen	Compute the gradient of mean squared error loss with respect to the input.
701	`mul`	Math	Stable	1.0	aten, pointwise	Multiplies `input` by `other`.
702	`mul_`	Math	Stable	2.2	aten, pointwise	The in-place version of `mul()`.
703	`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`.
704	`multiply`	Math	Alpha	5.4	aten, KernelGen	Multiplies input by other element-wise (out-of-place alias for mul).
705	`multiply_`	Math	Alpha	5.4	aten, KernelGen	In-place multiplication using Triton kernel (alias for mul_). Supports tensor-tensor and tensor-scalar operations.
706	`mv`	BLAS	Stable	2.0	aten	Performs a matrix-vector product of the matrix `input` and the vector `vec`.
707	`mvlgamma`	Math	Alpha	5.4	aten, KernelGen	Computes the multivariate log-gamma function element-wise (out-of-place).
708	`mvlgamma_`	Math	Alpha	5.4	aten, KernelGen	Computes the multivariate log-gamma function in-place for each element of the input tensor.
709	`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.
710	`nan_to_num_`	Math	Alpha	5.4	aten, KernelGen, pointwise	Replaces NaN, positive infinity, and negative infinity values in input in-place.
711	`nanmedian`	LinearAlg	Beta	5.4	aten, Reduction	Returns the median of the values in `input`, ignoring `NaN` values.
712	`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.
713	`nanmedian_dim_values`	LinearAlg	Beta	5.4	aten, Reduction	A variant of `nanmedian_dim()` with the `out` argument.
714	`nanmedian_out`	LinearAlg	Beta	5.4	aten, Reduction	A variant of `nanmedian()` with the `out` argument.
715	`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.
716	`nansum_out`	LinearAlg	Beta	5.4	aten, Reduction	A variant of `nansum()` with the `out` argument.
717	`narrow`	Tensor	Alpha	5.4	aten, KernelGen, skip_precision_check	Pure layout operation (narrow); returns a zero-copy view sharing storage with the input.
718	`narrow_copy`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for narrow_copy.
719	`native_batch_norm`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Apply native batch normalization using the existing implementation.
720	`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.
721	`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.
722	`native_batch_norm_legit_no_stats`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Batch normalization without persistent running statistics.
723	`native_batch_norm_legit_no_stats_out`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Out variant of batch normalization without running statistics.
724	`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.
725	`native_batch_norm_legit_out`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Out variant of batch normalization with running statistics.
726	`native_dropout_backward`	NeuralNetwork	Stable	3.0	aten, nn.functional	The backward case of `dropout()`.
727	`native_group_norm`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Apply native group normalization using the existing implementation.
728	`native_layer_norm`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Apply native layer normalization using the existing implementation.
729	`ne`	Math	Stable	2.0	aten, pointwise	Computes that `input` is not equal to `other` element-wise.
730	`ne_`	Math	Alpha	5.4	aten, KernelGen, pointwise	Computes element-wise not-equal comparison in-place.
731	`ne_scalar`	Math	Stable	2.0	aten, pointwise	The scalar version of `ne()`.
732	`neg`	Math	Stable	2.0	aten, pointwise	Returns a new tensor with the negative of the elements of `input`.
733	`neg_`	Math	Stable	2.2	aten, pointwise	The in-place version of `neg()`.
734	`negative`	Math	Alpha	5.4	aten, KernelGen	negative operator
735	`negative_`	Math	Alpha	5.4	aten, KernelGen	Computes the negative of input in-place.
736	`nested_from_padded_tensor`	Tensor	Alpha	5.4	aten, KernelGen	Constructs a nested tensor from a padded tensor and offsets.
737	`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.
738	`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.
739	`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.
740	`nested_view_from_jagged`	Tensor	Alpha	5.4	aten, 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.
741	`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.
742	`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.
743	`nextafter`	Math	Alpha	5.4	aten, KernelGen	Return the next floating-point value after input towards other, elementwise.
744	`nextafter_`	Math	Alpha	5.4	aten, pointwise	Returns the next representable floating-point value from `input` toward `other`, elementwise. In-place version of `nextafter`.
745	`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.
746	`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.
747	`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.
748	`nll_loss_backward`	NeuralNetwork	Stable	2.2	aten, IR	Compute the negative log likelihood loss. This is the backward case.
749	`nll_loss_forward`	NeuralNetwork	Stable	2.2	aten, IR	Compute the negative log likelihood loss. This is the forward case.
750	`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.
751	`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.
752	`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.
753	`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).
754	`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`.
755	`nonzero_static_out`	Tensor	Alpha	5.4	aten	A variant of `nonzero_static` that writes the fixed-size result to `out`.
756	`norm`	Reduction	Alpha	5.4	aten, KernelGen, reduction	Computes the norm of vectors, matrices, and tensors.
757	`norm_scalar`	Reduction	Alpha	5.4	aten, KernelGen, reduction	A variant of `norm` that computes the norm over all elements.
758	`norm_scalaropt_dim`	Reduction	Alpha	5.4	aten, KernelGen, reduction	A variant of `norm` that computes the norm along specified dimensions.
759	`normal_`	Tensor	Alpha	5.3	skip_precision_check	Random sampling operator (normal_).
760	`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`.
761	`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`.
762	`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`.
763	`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`.
764	`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.
765	`not_equal`	Logic	Alpha	5.4	aten, KernelGen, pointwise	Computes the element-wise logical NOT EQUAL of the given input tensors.
766	`not_equal_`	Logic	Alpha	5.4	aten, KernelGen, pointwise	Computes element-wise not-equal comparison in-place.
767	`not_equal_scalar`	Logic	Alpha	5.4	aten, KernelGen, pointwise	Computes the element-wise logical NOT EQUAL comparing a tensor to a scalar.
768	`nuclear_norm`	Math	Alpha	5.4	aten, KernelGen	Computes the nuclear norm (sum of singular values) of a matrix.
769	`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.
770	`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`.
771	`ones_like`	Tensor	Stable	2.1	aten	Returns a tensor filled with the scalar value 1, with the same size as `input`.
772	`ormqr`	LinearAlg	Alpha	5.4	aten, KernelGen	Computes the matrix-matrix multiplication of a product of Householder matrices with a general matrix.
773	`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`.
774	`outplace_fused_experts`	MoE	Stable	5.3	fused, Activation, vLLM	This operator allocates and returns a new output tensor.
775	`pack_seq_triton`	NeuralNetwork	Beta	5.3	fused, vLLM, DeepSeekV4	Pack variable-length token sequences into a padded batched tensor.
776	`pad`	NeuralNetwork	Stable	2.1	aten, pointwise, nn.functional	This pads a tenor using the specified mode.
777	`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.
778	`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.
779	`pdist_backward`	Math	Alpha	5.4	aten, KernelGen	Computes the gradient of pairwise distance computation.
780	`pdist_forward`	Math	Alpha	5.4	aten, KernelGen	Computes the pairwise distance between rows of a matrix.
781	`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.
782	`permute_copy`	Tensor	Alpha	5.4	aten, KernelGen	Creates and returns a copy of x with permuted dimensions.
783	`pixel_shuffle`	NeuralNetwork	Stable	5.3	aten, nn.functional	Rearranges elements in a tensor to a new tensor of different shape.
784	`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.
785	`pixel_unshuffle_out`	NeuralNetwork	Beta	5.0	aten, KernelGen	A variant of `pixel_unshuffle` that assigns the output to the `out` tensor.
786	`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`.
787	`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`.
788	`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.
789	`polygamma_`	Math	Alpha	5.4	aten	The in-place version of `polygamma()`.
790	`polygamma_out`	Math	Alpha	5.4	aten	A variant of `polygamma` that allows the output to be assigned to the `out` tensor.
791	`post_layer_norm_residual`	NeuralNetwork	Beta	5.4	fused	Fuses LayerNorm followed by a residual addition.
792	`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.
793	`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.
794	`pow_tensor_scalar_`	Math	Stable	2.2	aten, pointwise	This is the in-place version of `pow_tensor_scalar()`.
795	`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.
796	`pow_tensor_tensor_`	Math	Stable	2.2	aten, pointwise	This is the in-place version of `pow_tensor_tensor()`.
797	`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.
798	`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.
799	`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.
800	`prod`	LinearAlg	Stable	2.0	aten, Reduction	Returns the product of all elements in the `input` tensor.
801	`prod_dim_int`	Reduction	Stable	2.0	aten	Returns the product of each row of the `input` tensor in the given dimension `dim`.
802	`quantile`	Tensor	Stable	2.2	aten	Computes the q-th quantiles of each row of the `input` tensor along the dimension `dim`.
803	`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.
804	`rad2deg`	Math	Alpha	5.3	aten, KernelGen, pointwise	Converts each element from angles in radians to degrees.
805	`rad2deg_`	Math	Alpha	5.3	aten, KernelGen, pointwise	In-place version of rad2deg.
806	`rand`	Distribution	Stable	2.1	aten	Returns a tensor filled with random numbers from a uniform distribution on the interval `[0,1)`.
807	`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)`.
808	`randint`	Distribution	Stable	5.1	aten, KernelGen	Returns a tensor filled with random integers generated uniformly between low (inclusive) and high (exclusive).
809	`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).
810	`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).
811	`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.
812	`random_`	Tensor	Alpha	5.1	skip_precision_check	Random sampling operator (random_).
813	`randperm`	Distribution	Stable	2.2	aten, skip_precision_check	Returns a random permutation of integers from `0` to `n - 1`.
814	`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`.
815	`reciprocal`	Math	Stable	1.0	aten, pointwise	Returns a new tensor with the reciprocal of the elements of `input`.
816	`reciprocal_`	Math	Stable	2.2	aten, pointwise	This is the in-place version of `reciprocal()`.
817	`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.
818	`reflection_pad1d_backward`	Math	Alpha	5.3	aten, KernelGen	Computes the gradient of reflection_pad1d with respect to the input tensor.
819	`reflection_pad1d_out`	NeuralNetwork	Stable	5.3	aten, pointwise, KernelGen	A variant of `reflection_pad1d` that assigns the output to `out` tensor.
820	`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.
821	`reflection_pad2d_backward`	Math	Alpha	5.4	aten, KernelGen	Computes the gradient of reflection_pad2d with respect to the input tensor.
822	`reflection_pad2d_out`	NeuralNetwork	Stable	5.3	aten, pointwise, KernelGen	A variant of `reflection_pad2d` that assigns the output to `out` tensor.
823	`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).
824	`reflection_pad3d_backward`	Math	Alpha	5.1	aten, KernelGen	Computes the gradient of reflection_pad3d with respect to the input tensor.
825	`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.
826	`relu`	NeuralNetwork	Stable	1.0	aten, Activation, pointwise, nn.functional	Apply the RELU (Rectified Linear Unit) activation function element-wise.
827	`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.
828	`relu_`	NeuralNetwork	Stable	2.2	aten, pointwise, Activation	This is the in-place version of `relu()`.
829	`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`.
830	`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`.
831	`remainder_scalar_`	Math	Stable	2.2	aten	This is the in-place version of `remainder()`.
832	`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`.
833	`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`.
834	`remainder_tensor_`	Math	Stable	2.2	aten	This is the in-place version of `remainder()`.
835	`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.
836	`renorm_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `renorm()`.
837	`repeat`	Tensor	Stable	2.1	aten	Repeats this tensor along the specified dimensions.
838	`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`.
839	`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.
840	`repeat_interleave_tensor`	Tensor	Stable	2.2	aten, pointwise	Repeats 0 `repeats[0]` times, 1 `repeats[1]` times, 2 `repeats[2]` times, etc.
841	`replication_pad1d`	Tensor	Stable	5.4	aten, KernelGen	Pads the edge of a 1D input tensor by repeating the boundary values.
842	`replication_pad1d_out`	Tensor	Stable	5.4	aten, KernelGen	A variant of `replication_pad1d` that assigns the output to the `out` tensor.
843	`replication_pad2d`	Tensor	Alpha	5.4	aten, KernelGen	Pads the edge of a 2D input tensor by repeating the boundary values.
844	`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.
845	`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.
846	`replication_pad2d_out`	Tensor	Alpha	5.4	aten, KernelGen	A variant of `replication_pad2d` that assigns the output to the `out` tensor.
847	`replication_pad3d`	NeuralNetwork	Beta	5.3	aten	Pads the edge of a 3D input tensor by repeating the boundary values.
848	`replication_pad3d_backward`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Accumulates output gradients into the clamped input positions used by three-dimensional replication padding.
849	`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.
850	`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.
851	`resize`	Tensor	Alpha	5.4	aten, KernelGen	Resizes the input tensor to the specified size.
852	`resize_`	Tensor	Alpha	5.4	aten, KernelGen	The in-place version of `resize()`.
853	`resize_as`	Tensor	Alpha	5.4	aten, KernelGen	Triton kernel implementation for resize_as.
854	`resize_as_`	Tensor	Alpha	5.4	aten, KernelGen	The in-place version of `resize_as()`.
855	`resize_output`	Math	Alpha	5.3	aten, KernelGen	Resizes tensor output storage and copies overlapping elements.
856	`resize_output_`	Math	Alpha	5.4	aten, KernelGen	Resizes the output tensor in-place to the given size.
857	`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.
858	`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.
859	`rms_norm`	NeuralNetwork	Stable	2.0	aten, nn.functional, Reduction	Apply Root Mean Square Layer Normalization over a mini-batch of inputs.
860	`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.
861	`rnn_relu`	Math	Alpha	5.4	aten, KernelGen, NoCPU	Triton kernel implementation for rnn_relu.
862	`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.
863	`rot90`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for rot90.
864	`round`	Math	Beta	5.3	aten, pointwise	Rounds elements of input to the nearest integer.
865	`round_`	Math	Beta	5.3	aten, pointwise	The inplace version of `round`.
866	`round_out`	Math	Beta	5.3	aten, pointwise	A variant of `round` that assigns the output to the specifiec `out`.
867	`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.
868	`rrelu_with_noise_functional`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for rrelu_with_noise_functional.
869	`rshift`	Math	Alpha	5.4	aten, pointwise, KernelGen	Applies a bitwise right shift to an integer tensor with a tensor or scalar shift value.
870	`rshift_out`	Math	Alpha	5.4	aten, pointwise, KernelGen	A variant of `rshift()` that assigns the output to the given `out` parameter.
871	`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`.
872	`rsqrt_`	Math	Stable	2.2	aten, pointwise	The in-place version of `rsqrt()`.
873	`rsub_scalar`	Math	Alpha	5.3	aten, KernelGen	Substracts `other`, scaled by `alpha`, from `input`. This is the scalar version.
874	`rsub_tensor`	Math	Alpha	5.3	aten, KernelGen	Substracts `other`, scaled by `alpha`, from `input`. This is the tensor version.
875	`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.
876	`rwkv_mm_sparsity`	RWKV	Stable	4.1	fused	Optimized, lossless sparse matrix multiplication in RWKV-7 models.
877	`safe_softmax`	NeuralNetwork	Alpha	5.3	aten, IR, KernelGen	Apply a softmax function. Note this version may not be functional.
878	`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.
879	`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.
880	`scaled_dot_product_attention_backward`	NeuralNetwork	Stable	2.2	nn.functional, Attention	The backward case for `scaled_dot_product_attention`.
881	`scaled_dot_product_attention_forward`	NeuralNetwork	Stable	2.2	nn.functional, Attention	The forward case for `scaled_dot_product_attention`.
882	`scaled_dot_product_attention_math`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Computes scaled dot-product attention using the math-based implementation.
883	`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.
884	`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.
885	`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.
886	`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.
887	`scaled_dot_product_flash_attention`	NeuralNetwork	Alpha	5.4	aten, NoCPU, KernelGen	Run the scaled dot product FlashAttention forward operation.
888	`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.
889	`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.
890	`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.
891	`scaled_mm`	BLAS	Beta	5.4	aten	Performs a scaled matrix multiplication. The result of `self @ mat2` is multiplied by `scale_a` and `scale_b`, then an optional bias is added.
892	`scaled_mm_out`	BLAS	Beta	5.4	aten	A variant of `_scaled_mm` that writes the result into `out`.
893	`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.
894	`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.
895	`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.
896	`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`.
897	`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`.
898	`scatter_reduce_`	Tensor	Stable	3.0	aten, KernelGen	This is the in-place version of `scatter_reduce()`.
899	`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.
900	`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`.
901	`scatter_src_`	Tensor	Stable	3.0	aten	This is the in-place version of `scatter_src()`.
902	`searchsorted`	Tensor	Beta	5.4	aten, KernelGen	Finds insertion indices for tensor values in sorted innermost-dimension boundaries.
903	`searchsorted_out`	Tensor	Beta	5.4	aten, KernelGen	A variant of `searchsorted.Tensor` that assigns the result to `out`.
904	`searchsorted_scalar`	Tensor	Beta	5.4	aten, KernelGen	Finds insertion indices for a scalar value in one-dimensional sorted boundaries.
905	`searchsorted_scalar_out`	Tensor	Beta	5.4	aten, KernelGen	A variant of `searchsorted.Scalar` that assigns the result to `out`.
906	`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.
907	`segment_reduce_backward`	Reduction	Beta	5.4	aten	Computes gradients for `segment_reduce` with lengths or offsets based segment definitions.
908	`segment_reduce_backward_out`	Reduction	Beta	5.4	aten	A variant of `_segment_reduce_backward` that assigns the gradient input to the `out` tensor.
909	`segment_reduce_out`	Reduction	Beta	5.4	aten	A variant of `segment_reduce` that assigns the reduced segments to the `out` tensor.
910	`select_backward`	NeuralNetwork	Beta	5.3	aten	Calculate the gradient during the backward pass in the neural network.
911	`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.
912	`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.
913	`selu_`	NeuralNetwork	Stable	5.3	aten, pointwise, Activation, KernelGen	This is the in-place version of `selu`.
914	`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.
915	`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.
916	`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.
917	`sigmoid`	NeuralNetwork	Stable	2.0	aten, pointwise	Computes the expit (also known as the logistic sigmoid function) of the elements of `input`.
918	`sigmoid_`	NeuralNetwork	Stable	2.2	aten, pointwise	The in-place version of `sigmoid()`.
919	`sigmoid_backward`	NeuralNetwork	Stable	3.0	aten, pointwise	The backward version of `sigmoid()`.
920	`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).
921	`sign_out`	Math	Alpha	5.4	aten, KernelGen, pointwise	Out-variant of sign. Writes the element-wise sign to the `out` tensor.
922	`signbit`	Tensor	Beta	5.3	aten, pointwise	Tests if each element of `input` has its sign bit set or not.
923	`signbit_out`	Tensor	Beta	5.3	aten, pointwise	A variant of `signbit` that assigns the output to `out`.
924	`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.
925	`silu_`	NeuralNetwork	Stable	2.2	aten, nn.functional, pointwise	The in-place version of `silu()`.
926	`silu_and_mul`	Activation	Stable	2.0	fused, pointwise, vLLM	A custom operator in vLLM as activation function for SwiGLU.
927	`silu_and_mul_out`	Activation	Stable	2.0	fused, pointwise, vLLM	A variant of `silu_and_mul` with an extra `out` argument.
928	`silu_and_mul_with_clamp`	Activation	Stable	5.3	fused, pointwise, vLLM	A custom operator in vLLM as activation function for SwiGLU.
929	`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.
930	`silu_backward`	NeuralNetwork	Stable	3.0	aten, pointwise	A variant of `silu()` for backward case.
931	`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.
932	`sin_`	Math	Stable	2.2	aten, pointwise	The in-place version of `sin()`.
933	`sinc`	Math	Alpha	5.4	aten, KernelGen	Computes the normalized sinc function `sin(π·x) / (π·x)` for each element of the input.
934	`sinc_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `sinc()`.
935	`sinh`	Math	Alpha	5.4	aten, KernelGen	Computes the hyperbolic sine (e^x - e^{-x}) / 2 element-wise.
936	`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.
937	`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.
938	`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.
939	`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.
940	`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.
941	`smooth_l1_loss`	NeuralNetwork	Alpha	5.3	aten, pointwise, nn.functional	Compute the smooth L1 loss between input and target tensors.
942	`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.
943	`soft_margin_loss`	NeuralNetwork	Beta	5.3	nn.functional, KernelGen	Compute the soft margin loss.
944	`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.
945	`softmax`	NeuralNetwork	Stable	1.0	aten, nn.functional	Apply a softmax function.
946	`softmax_backward`	Reduction	Stable	3.0	aten, nn.functional	The backward version of `softmax()`.
947	`softmax_backward_out`	Reduction	Stable	3.0	aten, nn.functional	A variant of `softmax_backward()`.
948	`softmax_out`	NeuralNetwork	Stable	1.0	aten, nn.functional	Apply a softmax function, with given `out`.
949	`softplus`	NeuralNetwork	Stable	4.0	aten, nn.functional, pointwise	Applies element-wise, the function Softplus.
950	`softplus_backward`	NeuralNetwork	Alpha	5.4	aten, Activation, pointwise	The backward version of `softplus()`.
951	`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.
952	`softshrink_out`	NeuralNetwork	Stable	5.3	aten, nn.functional, Activation, KernelGen	This is a variant of `softshrink` that supports an output tensor.
953	`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.
954	`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.
955	`sparse_attn_triton`	NeuralNetwork	Beta	5.3	fused, NoCPU	Sparse attention with attention-sink.
956	`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.
957	`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.
958	`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.
959	`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.
960	`sparse_semi_structured_mm`	BLAS	aten, KernelGen	Performs a sparse semi-structured matrix multiplication of a dense matrix with a 2:4 sparsity pattern against a dense matrix.
961	`special_airy_ai`	Math	Alpha	5.4	aten, pointwise, KernelGen	Computes the Airy function Ai(x) for each element of the input tensor.
962	`special_airy_ai_out`	Math	Alpha	5.4	aten, pointwise, KernelGen	A variant of `special_airy_ai` with output saved to provided `out`.
963	`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`.
964	`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.
965	`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.
966	`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.
967	`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.
968	`special_chebyshev_polynomial_v`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for special_chebyshev_polynomial_v.
969	`special_chebyshev_polynomial_w`	Math	Alpha	5.4	aten, KernelGen	Computes the Chebyshev polynomial of the fourth kind :math:`W_{n}(\\text{input})`.
970	`special_chebyshev_polynomial_w_out`	Math	Alpha	5.4	aten, KernelGen	A variant of `special_chebyshev_polynomial_w()` with output saved to provided `out`.
971	`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.
972	`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.
973	`special_erfc`	Math	Alpha	5.4	aten, pointwise, KernelGen	Computes the complementary error function.
974	`special_erfcx`	Math	Alpha	5.4	aten, pointwise, KernelGen	Computes the scaled complementary error function for each element of input.
975	`special_erfinv`	Math	Alpha	5.4	aten, KernelGen	Computes the inverse error function element-wise. Maps values in (-1, 1) to the real line.
976	`special_erfinv_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `special_erfinv()`.
977	`special_erfinv_out`	Math	Alpha	5.4	aten, KernelGen	A variant of `special_erfinv()` that assigns the output to the `out` tensor.
978	`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.
979	`special_expit`	Math	Alpha	5.4	aten, pointwise, KernelGen	Computes the expit (sigmoid) function element-wise. Returns 1 / (1 + exp(-x)).
980	`special_gammainc`	Math	Alpha	5.4	aten, KernelGen	Computes the regularized lower incomplete gamma function P(a, x) element-wise.
981	`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.
982	`special_gammaln`	Math	Alpha	5.4	aten, KernelGen	Computes the logarithm of the absolute value of the Gamma function on input.
983	`special_gammaln_out`	Math	Alpha	5.4	aten, KernelGen	Out-of-place variant of special_gammaln that writes the result to the out tensor.
984	`special_hermite_polynomial_h`	Math	Alpha	5.1	aten, KernelGen	Computes the physicist's Hermite polynomial H_n(x) of degree n at input.
985	`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`.
986	`special_i0e_out`	Math	Stable	5.3	aten, pointwise, KernelGen	A variant of `special_i0e()` with output saved to provided `out`..
987	`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.
988	`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.
989	`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.
990	`special_i1e_out`	Math	Alpha	5.4	aten, pointwise, KernelGen	A variant of `special_i1e()` that saves the output to the provided `out` tensor.
991	`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.
992	`special_log1p`	Math	Alpha	5.4	aten, KernelGen	Computes log(1 + x) for each element of the input tensor.
993	`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.
994	`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.
995	`special_log_softmax`	Math	Alpha	5.4	aten, nn.functional, KernelGen	Applies the log of the softmax function along a given dimension.
996	`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.
997	`special_logit_out`	Math	Alpha	5.4	aten, KernelGen	A variant of `special_logit` that allows the output to be assigned to another tensor.
998	`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`.
999	`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.
1000	`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.
1001	`special_modified_bessel_k0`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for special_modified_bessel_k0.
1002	`special_modified_bessel_k0_out`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for special_modified_bessel_k0.out.
1003	`special_modified_bessel_k1`	Math	Alpha	5.4	aten, KernelGen	Modified Bessel function of the second kind of order 1.
1004	`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.
1005	`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.
1006	`special_ndtr`	Math	Alpha	5.4	aten, KernelGen	Computes the standard normal cumulative distribution function (CDF).
1007	`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.
1008	`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).
1009	`special_round_out`	Math	Alpha	5.4	aten, KernelGen	A variant of `special_round()` with output saved to provided `out`.
1010	`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.
1011	`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`.
1012	`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`.
1013	`special_shifted_chebyshev_polynomial_u_`	Math	aten, KernelGen	Inplace variant of `special_shifted_chebyshev_polynomial_u`.
1014	`special_shifted_chebyshev_polynomial_v`	Math	Alpha	5.4	aten, pointwise, KernelGen	Computes the shifted Chebyshev polynomial of the third kind V_n^*(x).
1015	`special_shifted_chebyshev_polynomial_w`	Math	Alpha	5.4	aten, KernelGen	Computes the shifted Chebyshev polynomial of the second kind W_n(x).
1016	`special_sinc`	Math	Alpha	5.4	aten, KernelGen	Computes sin(pi * x) / (pi * x) for each element of `input`.
1017	`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`.
1018	`special_xlog1py`	Math	Alpha	5.4	aten, KernelGen	Computes `x * log1p(y)` for each element pair in the input tensors `x` and `y`.
1019	`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`.
1020	`special_xlogy_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `special_xlogy()`.
1021	`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.
1022	`sqrt`	Math	Stable	4.0	aten, pointwise	Returns a new tensor with the square-root of the elements of `input`.
1023	`sqrt_`	Math	Stable	4.0	aten, pointwise	This is the in-place version of `sqrt()`.
1024	`square`	Math	Beta	5.3	aten, pointwise	Returns a new tensor with the square of the elements of input.
1025	`square_`	Math	Beta	5.3	aten, pointwise	The inplace version of `square`.
1026	`square_out`	Math	Beta	5.3	aten, pointwise	A variant of `square` that assigns the output to the provided `out`.
1027	`squeeze_copy`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for squeeze_copy.
1028	`stack`	Tensor	Stable	2.2	aten	Concatenates a sequence of tensors along a new dimension.
1029	`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.
1030	`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.
1031	`sub`	Math	Stable	1.0	aten, pointwise	Subtracts `other`, scaled by `alpha`, from the `input` tensor.
1032	`sub_`	Math	Stable	2.2	aten, pointwise	Subtracts `other`, scaled by `alpha`, from the `input` tensor. This is the in-place version.
1033	`subtract`	Math	Alpha	5.4	aten, KernelGen	Subtracts `other`, scaled by `alpha`, from `input`.
1034	`subtract_`	Math	Alpha	5.4	aten, KernelGen	In-place version of subtract. Subtracts other, scaled by alpha, from input.
1035	`sum`	LinearAlg	Stable	2.0	aten, Reduction	Returns the sum of all elements in the `input` tensor.
1036	`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.
1037	`sum_dim_out`	LinearAlg	Stable	3.0	aten, Reduction	A variant of `sum_dim()` with the `out` argument.
1038	`sum_out`	LinearAlg	Stable	3.0	aten, Reduction	A variant of `sum()` with the `out` argument.
1039	`sum_to_size`	Math	Alpha	5.4	aten, KernelGen	Triton kernel implementation for sum_to_size.
1040	`swiglu`	NeuralNetwork	Stable	5.0	fused, Transformer	Swish-Gated Linear Unit, a variant of GLU with the Swish activation function.
1041	`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.
1042	`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.
1043	`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.
1044	`t_copy`	Tensor	Stable	5.3	aten, KernelGen	Transpose a 2D tensor into a new tensor with contiguous memory layout.
1045	`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.
1046	`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.
1047	`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.
1048	`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.
1049	`tan_`	NeuralNetwork	Stable	4.1	aten, pointwise, KernelGen	This is the in-place version of `tan()`.
1050	`tanh`	Math	Stable	2.0	aten, pointwise	Returns a new tensor with the hyperbolic tangent of the elements of `input`.
1051	`tanh_`	Math	Stable	2.2	aten, pointwise	This is the in-place version of `tanh()`.
1052	`tanh_backward`	Math	Stable	3.0	aten, pointwise	This is the backward case for `tanh()`.
1053	`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).
1054	`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).
1055	`tensor_split`	Math	Alpha	5.3	aten, KernelGen	Splits a tensor into multiple sub-tensors along a given dimension, using either a number of sections or a list of split indices.
1056	`thnn_differentiable_gru_cell_backward`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Computes differentiable gradients for a fused GRU cell.
1057	`thnn_fused_lstm_cell`	NeuralNetwork	Alpha	5.4	aten, KernelGen	Fused LSTM cell computation with optional input and hidden biases.
1058	`thnn_fused_lstm_cell_backward_impl`	Math	Alpha	5.4	aten, KernelGen	Computes gradients for the fused LSTM cell operation (_thnn_fused_lstm_cell).
1059	`threshold`	NeuralNetwork	Stable	3.0	aten, nn.functional, pointwise	Apply a threshold to each element of the input Tensor.
1060	`threshold_`	Math	Alpha	5.4	aten, KernelGen	In-place version of threshold(). Thresholds each element of the input Tensor.
1061	`threshold_backward`	NeuralNetwork	Stable	3.0	aten, nn.functional, pointwise	This is the backward version for `threshold`.
1062	`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.
1063	`to_copy`	Tensor	Stable	5.3	aten, pointwise, skip_precision_check
1064	`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.
1065	`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.
1066	`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.
1067	`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.
1068	`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.
1069	`topk_w8a16_fp8`	Tensor	Alpha	5.4	NoCPU, Quantization	Returns the k largest (or smallest) elements of a group-wise FP8 E5M2 tensor along the last dimension, dequantizing with per-group scales.
1070	`trace`	Reduction	Stable	4.0	aten	Returns the sum of the elements of the diagonal of the input 2-D matrix.
1071	`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.
1072	`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.
1073	`tril_`	BLAS	Beta	5.3	aten	The in-place version of `tril()`.
1074	`tril_out`	BLAS	Beta	5.3	aten	A variant of `tril()` that explicitly assigns the output to the `out` parameter.
1075	`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.
1076	`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.
1077	`triu_`	NeuralNetwork	Stable	5.0	aten	The in-place version of `triu()`.
1078	`true_divide`	Math	Alpha	5.4	aten, KernelGen, pointwise	Performs element-wise true division between two tensors.
1079	`true_divide_`	Math	Alpha	5.4	aten, KernelGen, pointwise	Performs element-wise true division in-place between two tensors.
1080	`trunc`	Math	Alpha	5.4	aten, KernelGen	Rounds each element of the input tensor to the nearest integer towards zero.
1081	`trunc_`	Math	Alpha	5.4	aten, KernelGen	The in-place version of `trunc()`.
1082	`trunc_divide`	Math	Stable	2.1	aten	The `div` function with rounding_mode set to `trunc`.
1083	`trunc_divide_`	Math	Stable	2.1	aten	The in-place version of `trunc_divide`.
1084	`unbind`	Tensor	Alpha	5.4	aten, KernelGen, skip_precision_check	Pure layout operation (unbind); returns zero-copy views sharing storage with the input.
1085	`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.
1086	`unflatten`	Math	Alpha	5.4	aten, KernelGen	Expand a single dimension into multiple dimensions (inverse of flatten).
1087	`unfold`	Math	Alpha	5.4	aten, KernelGen	Return a view of the tensor with a sliding window along the given dimension.
1088	`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.
1089	`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.
1090	`uniform_`	Distribution	Stable	2.1	aten, skip_precision_check	Fills `self` tensor with numbers sampled from the continuous uniform distribution.
1091	`unique2`	Tensor	Stable	2.1	aten	Returns the unique elements of the input tensor. This is an internal PyTorch function.
1092	`unique_consecutive`	Distribution	Beta	5.3	aten, KernelGen	Eliminates all but the first element from every consecutive group of equivalent elements.
1093	`unique_dim`	Tensor	Beta	5.4	aten	Returns the unique slices of the input tensor along a dimension.
1094	`unpack_seq_triton`	NeuralNetwork	Beta	5.3	fused, vLLM, DeepSeekV4	Unpack a packed sequence tensor back to its original variable-length form.
1095	`unsafe_chunk`	Math	Alpha	5.4	aten, KernelGen	Split a tensor into a specified number of chunks along a given dimension.
1096	`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.
1097	`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.
1098	`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.
1099	`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.
1100	`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.
1101	`unsqueeze`	Tensor	Alpha	5.4	aten, KernelGen	Returns a new tensor with a dimension of size one inserted at the specified position.
1102	`unsqueeze_`	Tensor	Alpha	5.4	aten, KernelGen	In-place version of `unsqueeze()`.
1103	`upsample_bicubic2d`	NeuralNetwork	Stable	5.0	aten, Reduction	A variant of `upsample()` that has `mode` set to `bicubic`.
1104	`upsample_bicubic2d_aa`	NeuralNetwork	Stable	2.2	aten, Reduction	A variant of `upsample()` that has `mode` set to `bicubic`.
1105	`upsample_bicubic2d_aa_backward`	NeuralNetwork	Stable	5.0	aten, Reduction	A backward case for `_upsample_bicubic2d_aa()`.
1106	`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.
1107	`upsample_bilinear2d_aa`	NeuralNetwork	Alpha	5.1	aten, KernelGen	Upsamples the input, using bilinear mode with anti-aliasing.
1108	`upsample_bilinear2d_aa_backward`	NeuralNetwork	Alpha	5.4	aten, KernelGen	A backward case for `_upsample_bilinear2d_aa()`.
1109	`upsample_lanczos2d_aa`	NeuralNetwork	Alpha	5.4	aten, KernelGen, Reduction	Resizes a 4D image tensor with antialiased Lanczos-3 interpolation.
1110	`upsample_lanczos2d_aa_out`	NeuralNetwork	Alpha	5.4	aten, KernelGen, Reduction	An out variant of `_upsample_lanczos2d_aa()`.
1111	`upsample_lanczos2d_aa_vec`	NeuralNetwork	Alpha	5.4	aten, KernelGen, Reduction	A vector-parameter variant of `_upsample_lanczos2d_aa()`.
1112	`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.
1113	`upsample_linear1d_backward`	NeuralNetwork	Alpha	5.4	aten, Reduction	A backward case for `upsample_linear1d()`.
1114	`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.
1115	`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`.
1116	`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.
1117	`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.
1118	`upsample_nearest_exact1d_backward`	NeuralNetwork	Alpha	5.4	aten, KernelGen, Reduction	A backward case for `_upsample_nearest_exact1d()`.
1119	`upsample_nearest_exact1d_backward_grad_input`	NeuralNetwork	Alpha	5.4	aten, KernelGen, Reduction	An out variant of `_upsample_nearest_exact1d_backward()`.
1120	`upsample_nearest_exact2d`	Math	Stable	5.3	aten, KernelGen	Triton kernel implementation for _upsample_nearest_exact2d.
1121	`upsample_nearest_exact2d_backward`	NeuralNetwork	Alpha	5.4	aten, KernelGen	A backward case for `_upsample_nearest_exact2d()`.
1122	`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.
1123	`upsample_trilinear3d`	Math	Alpha	5.4	aten, KernelGen	Upsamples the input (NCDHW) using trilinear interpolation.
1124	`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.
1125	`var`	Tensor	Beta	5.3	aten, KernelGen	Calculates the variance over all dimensions.
1126	`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.
1127	`var_dim`	Tensor	Beta	5.3	aten	Calculates the variance over the dimensions specified by dim.
1128	`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.
1129	`vdot`	BLAS	Stable	2.2	aten	Computes the dot product of two 1D vectors along a dimension.
1130	`vector_norm`	LinearAlg NeuralNetwork	Stable	2.0	aten, Reduction	Computes a vector norm.
1131	`view_as_complex`	Tensor	Alpha	5.4	aten	Returns a view of the real input tensor as a complex tensor (zero-copy view operation).
1132	`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.
1133	`vstack`	Tensor	Stable	2.2	aten	Stack tensors in sequence vertically (row wise).
1134	`w8a8_block_fp8_matmul`	BLAS	Alpha	5.3	vLLM	Performs matrix multiplication with block-wise quantization.
1135	`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.
1136	`weight_int8pack_mm`	BLAS	Alpha	5.4	aten, KernelGen	Performs int8 weight-only quantized matrix multiplication with per-channel scales.
1137	`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.
1138	`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.
1139	`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.
1140	`where_self`	Tensor	Stable	2.1	aten, pointwise	Returns a LongTensor. This operation is identical to `torch.nonzero(condition, as_tuple=True)`.
1141	`where_self_out`	Tensor	Stable	2.2	aten, pointwise	This is a variant of `where_self()` with an argument `out`.
1142	`xlogy`	Math	Beta	5.4	aten, pointwise	Computes `input * log(other)` element-wise, returning zero where `input` is zero (following PyTorch's `xlogy` semantics).
1143	`xlogy_`	Math	Alpha	5.4	aten, KernelGen, pointwise	Computes x * log(y) element-wise in-place on x.
1144	`xlogy_out`	Math	Beta	5.4	aten, pointwise	A variant of `xlogy` that allows the output to be assigned to an `out` tensor.
1145	`xlogy_scalar_tensor`	Math	Beta	5.4	aten, pointwise	A variant of `xlogy` where `input` is a scalar.
1146	`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.
1147	`xlogy_tensor_scalar`	Math	Beta	5.4	aten, pointwise	A variant of `xlogy` where `other` is a scalar.
1148	`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.
1149	`xor`	Math	Alpha	5.4	aten, pointwise, KernelGen	Computes the bitwise XOR of input tensors or a tensor and a scalar (non-inplace).
1150	`zero`	Tensor	Stable	5.3	aten, KernelGen	Fills tensor with zeros.
1151	`zero_`	Tensor	Stable	5.0	aten	Fills `self` tensor with zeros.
1152	`zero_out`	Tensor	Stable	5.3	aten, KernelGen	Fills tensor with zeros but assign the output to the `out` tensor.
1153	`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`.
1154	`zeros_like`	Tensor	Stable	2.1	aten	Returns a tensor filled with the scalar value 0, with the same size as `input`.