operators.yaml

# Copyright 2026 FlagOS Contributors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

ops:
  - id: _reshape_alias
    description: |
      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.
    for:
      - _reshape_alias
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: abs
    description: |
      Computes the absolute value of each element in `input`.
      This is a simple wrapper of the existing torch `abs` operator.
    for:
      - abs
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '1.0'
  - id: abs_
    description: |
      The in-place version of `abs()`, which is a simple wrapper of the Torch `abs` operator.
    for:
      - abs_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: absolute
    description: |
      This is an alias for `abs()` with the low-level operations implemented
      by invoking low-level Torch operators.
    for:
      - absolute
    labels:
      - aaten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: acos
    description: Returns a new tensor with the arccosine (in radians) of each element in `input`.
    for:
      - acos
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '5.0'
  - id: acosh
    description: Triton kernel implementation for acosh.
    for:
      - acosh
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: acosh_
    description: The in-place version of `acosh()`.
    for:
      - acosh_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: act_quant_triton
    description: This is a fused operator.
    for:
      - None
    labels:
      - fused
    kind:
      - Quantization
    stages:
      - beta: '5.3'
  - id: adaptive_avg_pool2d
    description: |
      Apply a 2D adaptive average pooling over an input signal composed of several input planes.
    for:
      - _adaptive_avg_pool2d
    labels:
      - aten
      - nn.functional
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: adaptive_avg_pool2d_backward
    description: |
      Computes the gradient of two-dimensional adaptive average pooling with
      respect to the input tensor.
    for:
      - _adaptive_avg_pool2d_backward
    labels:
      - aten
      - KernelGen
      - reduction
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: adaptive_max_pool3d_backward
    description: |
      Computes the gradient for adaptive max pooling 3D.
    for:
      - adaptive_max_pool3d_backward
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: add
    description: |
      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.
    for:
      - add.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '1.0'
    cpp: '4.0'
  - id: add_
    description: The in-place version of `add()`.
    for:
      - add_.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: add_relu
    description: Triton kernel implementation for _add_relu.
    for:
      - _add_relu.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: add_rms_norm
    description: |
      Add two inputs element-wise and apply Root Mean Square Layer Normalization.
    for:
      - add_rms_norm
    labels:
      - aten
      - KernelGen
      - Normalization
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: addbmm
    description: |
      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).
    for:
      - addbmm
    labels:
      - aten
      - KernelGen
    kind:
      - LinearAlg
    stages:
      - alpha: '5.4'
  - id: addcdiv
    description: |
      Performs the element-wise division of `tensor1` by `tensor2`, multiplies the result
      by the scalar `value` and adds it to `input`.
    for:
      - addcdiv
    labels:
      - aten
      - pointwise
    kind:
      - LinearAlg
    stages:
      - stable: '4.0'
  - id: addcdiv_
    description: |
      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`.
    for:
      - addcdiv_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.1'
  - id: addcdiv_out
    description: |
      A variant of `addcdiv()` that assigns the output to the given `out` parameter..
    for:
      - addcdiv.out
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - LinearAlg
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: addcmul
    description: |
      Performs the element-wise multiplication of `tensor1` by `tensor2`,
      multiplies the result by the scalar `value` and adds it to `input`.
    for:
      - addcmul
    labels:
      - aten
      - pointwise
    kind:
      - LinearAlg
    stages:
      - stable: '4.0'
  - id: addcmul_
    description: |
      The in-place version of `addcmul()`.
    for:
      - addcmul_
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - LinearAlg
    stages:
      - alpha: '5.4'
  - id: addcmul_out
    description: |
      A variant of `addcmul` that allows the output to be assigned to `out`.
    for:
      - addcmul.out
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - LinearAlg
    stages:
      - alpha: '5.0'
      - beta: '5.3'
  - id: addmm
    description: |
      Performs a matrix multiplication of the matrices `mat1` and `mat2`.
      The matrix `input` is added to the final result.
    for:
      - addmm
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '1.0'
    cpp: '4.0'
  - id: addmm_
    description: |
      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.
    for:
      - addmm_
    labels:
      - aten
      - KernelGen
    kind:
      - BLAS
    stages:
      - alpha: '5.4'
  - id: addmm_dtype
    description: |
      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.
    for:
      - addmm.dtype
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - beta: '5.3'
  - id: addmm_dtype_out
    description: A variant of `addmm_dtype()` that allows the output to be saved to the provided `out` parameter.
    for:
      - addmm.dtype_out
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - beta: '5.3'
  - id: addmm_out
    description: |
      A variant of `addmm` that assigns to the output to the provided `out` parameter.
    for:
      - addmm.out
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '4.0'
  - id: addmv
    description: |
      Performs a matrix-vector product of the matrix `mat` and the vector `vec`.
      The vector `input` is added to the final result.
    for:
      - addmv
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '4.0'
  - id: addmv_out
    description: |
      Performs a matrix-vector product of the matrix `mat` and the vector `vec`.
      The vector `input` is added to the final result.
    for:
      - addmv.out
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '4.0'
  - id: addr
    description: |
      Performs the outer-product of vectors `vec1` and `vec2`
      and adds it to the matrix `input`.
    for:
      - addr
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '4.0'
  - id: addr_
    description: |
      In-place version of addr. Performs the outer-product of vectors `vec1` and `vec2`
      and adds it to the matrix `input` in-place.
    for:
      - addr_
    labels:
      - aten
      - KernelGen
    kind:
      - BLAS
    stages:
      - stable: '4.0'
  - id: affine_grid_generator
    description: |
      Generates a 2D or 3D flow field (sampling grid), given a batch of affine matrices theta.
    for:
      - affine_grid_generator
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Tensor
    stages:
      - alpha: '5.3'
  - id: alias
    description: Return a view tensor sharing the same storage (zero-copy alias).
    for:
      - alias
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: alias_copy
    description: |
      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.
    for:
      - alias_copy
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: alias_copy_out
    description: A variant of `alias_copy()` that assigns the output to the `out` tensor.
    for:
      - alias_copy.out
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: all
    description: Tests if all elements in input evaluate to True.
    for:
      - all
    labels:
      - aten
      - Reduction
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: all_dim
    description: |
      For each row of `input` in the given dimension `dim`, returns True if all elements
      in the row evaluate to True and False otherwise.
    for:
      - all.dim
    labels:
      - aten
      - Reduction
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: all_dims
    description: A variant of `all`.
    for:
      - all.dims
    labels:
      - aten
      - Reduction
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: allclose
    description: |
      This function checks if `input` and `other` satisfy a condition specified via
      `atol` and `rtol` elementwise, for all elements of `input` and `other`.
    for:
      - allclose
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.1'
  - id: alpha_dropout
    description: |
      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.
    for:
      - alpha_dropout
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: amax
    description: Returns the maximum value of each slice of the `input` tensor in the given dimension(s) `dim`.
    for:
      - amax
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '2.0'
  - id: amin
    description: Returns the minimum value of each row of the input tensor in the given dimension dim.
    for:
      - amin
    labels:
      - aten
      - KernelGen
    kind:
      - Reduction
    stages:
      - alpha: '5.4'
  - id: amin_
    description: The in-place version of amin, returns the minimum value of each row in the given dimension.
    for:
      - amin_
    labels:
      - aten
      - KernelGen
    kind:
      - Reduction
    stages:
      - alpha: '5.4'
  - id: aminmax
    description: |
      Computes the minimum and maximum values of the `input` tensor.
    for:
      - aminmax
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: amp_foreach_non_finite_check_and_unscale_
    description: |
      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.
    for:
      - _amp_foreach_non_finite_check_and_unscale_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: and_scalar
    description: |
      Computes the bitwise AND operation through the tensor dunder method with a scalar operand.
    for:
      - __and__.Scalar
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.4'
  - id: and_tensor
    description: |
      Computes the bitwise AND operation through the tensor dunder method with tensor operands.
    for:
      - __and__.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.4'
  - id: angle
    description: Computes the element-wise angle (in radians) of the given `input` tensor.
    for:
      - angle
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '3.0'
  - id: any
    description: Tests if any element in `input` evaluates to True.
    for:
      - any
    labels:
      - aten
      - Reduction
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: any_dim
    description: For each row of `input` in the given dimension `dim`, returns True if any element in the row evaluate to True and False otherwise.
    for:
      - any.dim
    labels:
      - aten
      - Reduction
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: any_dims
    description: |
      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.
    for:
      - any.dims
    labels:
      - aten
      - Reduction
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: apply_repetition_penalties
    description: |
      Modifies logit tensors in place to penalize tokens that have already appeared in the generated sequence.
    for:
      - _C.apply_repetition_penalties_
    labels:
      - fused
      - vLLM
    kind:
      - NeuralNetwork
    stages:
      - stable: '5.0'
  - id: apply_rotary_pos_emb
    description: |
      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.
    for:
      - apply_rotary_pos_emb
    labels:
      - fused
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.0'
  - id: arange
    description: |
      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.
    for:
      - arange
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.1'
  - id: arange_start
    description: A variant of `arange`, with `start` and/or `step` specified.
    for:
      - arange.start
    labels:
      - aten
    kind:
      - tensor
    stages:
      - stable: '2.1'
  - id: arange_start_step
    description: A variant of `arange`, with `start` and/or `step` specified.
    for:
      - arange_start_step
    labels:
      - aten
    kind:
      - tensor
    stages:
      - stable: '2.1'
  - id: arccos
    description: Returns a new tensor with the arccosine of the elements of `input`.
    for:
      - arccos
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: arccos_
    description: The in-place version of `arccos()`.
    for:
      - arccos_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: arccosh
    description: Returns a new tensor with the inverse hyperbolic cosine of the elements of `input`.
    for:
      - arccosh
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: arccosh_
    description: |
      Computes the element-wise inverse hyperbolic cosine of a given input tensor.
      This is an in-place version.
    for:
      - arccosh_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: arccosh_out
    description: A variant of `arccosh` that allows the output to be assigned to the `out` tensor.
    for:
      - arccosh.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: arcsin
    description: Returns a new tensor with the arcsine of the elements of input.
    for:
      - arcsin
      - arcsin.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: arcsin_
    description: The in-place version of `arcsin()`.
    for:
      - arcsin_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: arcsin_out
    description: A variant of `arcsin` that allows the output to be assigned to the `out` tensor.
    for:
      - arcsin.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: arcsinh
    description: Performs an element-wise inverse hyperbolic sine computation on the given tensor.
    for:
      - arcsinh
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.4'
  - id: arcsinh_
    description: The in-place version of `arcsinh()`.
    for:
      - arcsinh_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.4'
  - id: arcsinh_out
    description: A variant of `arcsinh` that allows the output to be assigned to the `out` tensor.
    for:
      - arcsinh.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.4'
  - id: arctan
    description: |
      Returns a new tensor with the element-wise inverse tangent (arctangent) of the input tensor.
    for:
      - arctan
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: arctan2
    description: Computes the element-wise arctangent of `input` / `other`. Alias for `atan2`.
    for:
      - arctan2
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: arctan2_
    description: |
      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`.
    for:
      - arctan2_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: arctan_
    description: |
      Computes the element-wise inverse tangent (arctangent) of a given input tensor.
      This is an in-place version.
    for:
      - arctan_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: arctanh_
    description: |
      Computes the element-wise inverse hyperbolic tangent of a given input tensor.
      This is an in-place version.
    for:
      - arctanh_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.4'
  - id: argmax
    description: Returns the indices of the maximum value of all elements in the `input` tensor.
    for:
      - argmax
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '2.0'
    cpp: '4.0'
  - id: argmin
    description: Returns the indices of the minimum value(s) of the flattened tensor or along a dimension.
    for:
      - argmin
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '2.2'
  - id: argsort
    description: Sorting/selection operator (argsort).
    for:
      - argsort
    labels:
      - skip_precision_check
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: as_strided_copy
    description: |
      Creates a contiguous copy of an `as_strided` view of the input tensor.
    for:
      - as_strided_copy
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: as_strided_copy_out
    description: A variant of `as_strided_copy()` that assigns the output to the `out` tensor.
    for:
      - as_strided_copy.out
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: asin
    description: Returns a new tensor with the arcsine of the elements of input.
    for:
      - asin
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: asin_
    description: The in-place version of `asin()`.
    for:
      - asin_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: asinh
    description: Returns a new tensor with the inverse hyperbolic sine of the elements of input.
    for:
      - asinh
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: asinh_
    description: Computes the inverse hyperbolic sine for each element of a tensor in-place.
    for:
      - asinh_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: assert_async
    description: |
      A utility used to perform data-dependent assertions on GPU tensors
      without triggering an immediate, performance-heavy GPU-to-CPU synchronization.
    for:
      - _assert_async
    labels:
      - utility
    kind:
      - Tensor
    stages:
      - stable: '5.3'
  - id: atan
    description: Returns a new tensor with the arctangent of the elements (in radians) in the `input` tensor.
    for:
      - atan
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '4.0'
  - id: atan2
    description: |
      Computes the element-wise arc tangent of `input/other(y/x)`,
      returning angles in radians between `-PI` and `PI`.
    for:
      - atan2
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '5.3'
  - id: atan2_out
    description: |
      A variant of `atan2` that allows the output to be saved into `out`.
    for:
      - atan2.out
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: atan_
    description: The in-place version of `atan()`.
    for:
      - atan_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '4.0'
  - id: atanh
    description: Triton kernel implementation for atanh.
    for:
      - atanh
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: atanh_
    description: The in-place version of `atanh()`.
    for:
      - atanh_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: avg_pool2d
    description: |
      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.
    for:
      - avg_pool2d
    labels:
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - stable: '4.1'
  - id: avg_pool2d_backward
    description: The backward version of `avg_pool2d()`.
    for:
      - avg_pool2d_backward
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - stable: '4.1'
  - id: avg_pool3d
    description: |
      Applies 3D average-pooling operation in `kD \times kH \times kW` regions by step size
      `sD \times sH \times sW` steps.
    for:
      - avg_pool3d
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: avg_pool3d_backward
    description: This is the backward version of `avg_pool3d()`.
    for:
      - avg_pool3d_backward
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.3'
  - id: baddbmm
    description: |
      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.
    for:
      - baddbmm
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '4.1'
  - id: baddbmm_out
    description: This is a variant of `baddbmm()`.
    for:
      - baddbmm.out
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - beta: '5.3'
  - id: batch_norm
    description: An internal operator used for implementing the `BatchNorm` functionality.
    for:
      - native_batch_norm
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: batch_norm_backward
    description: The backward version of `batch_norm()`.
    for:
      - native_batch_norm_backward
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: batch_norm_no_update
    description: Applies Batch Normalization using precomputed running statistics without updating running_mean/running_var.
    for:
      - _batch_norm_no_update
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: beam_search_score
    description: Computes beam search scores by adding cumulative log probabilities with new token scores.
    for:
      - beam_search_score
    labels:
      - KernelGen
      - fused
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: beam_search_score_
    description: In-place version of beam search score computation.
    for:
      - beam_search_score_
    labels:
      - KernelGen
      - fused
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: bernoulli
    description: |
      Draws binary random numbers (0 or 1) from a Bernoulli distribution with per-element probabilities.
    for:
      - bernoulli
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: bernoulli_
    description: Draws binary random numbers (0 or 1) from a Bernoulli distribution.
    for:
      - bernoulli_.float
    labels:
      - aten
      - skip_precision_check
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: bf16_paged_mqa_logits
    description: |
      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.
    for:
      - bf16_paged_mqa_logits
    labels:
      - fused
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: binary_cross_entropy_backward
    description: Computes the gradient of binary cross entropy loss with respect to the input, with optional per-element weight.
    for:
      - binary_cross_entropy_backward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: binary_cross_entropy_with_logits
    description: Compute the binary cross entropy loss with logits.
    for:
      - binary_cross_entropy_with_logits
    labels:
      - nn.functional
      - KernelGen
      - aten
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: bincount
    description: Count the frequency of each value in an array of non-negative integers.
    for:
      - bincount
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Reduction
    stages:
      - stable: '5.0'
  - id: bitwise_and_scalar
    description: Computes the bitwise AND of `input` and `other` scalar.
    for:
      - bitwise_and.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: bitwise_and_scalar_
    description: The in-place, scalar version of `bitwise_and()`.
    for:
      - bitwise_and_.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: bitwise_and_scalar_tensor
    description: A variant of `bitwise_and()`.
    for:
      - bitwise_and.Scalar_Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: bitwise_and_tensor
    description: The Tensor method version of `bitwise_and()`.
    for:
      - bitwise_and.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: bitwise_and_tensor_
    description: The in-place, Tensor method version of `bitwise_and()`.
    for:
      - bitwise_and_.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: bitwise_left_shift
    description: Computes the left arithmetic shift of `input` by `other` bits.
    for:
      - bitwise_left_shift
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '4.0'
  - id: bitwise_left_shift_
    description: The in-place version of `bitwise_left_shift()`.
    for:
      - bitwise_left_shift_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: bitwise_not
    description: Computes the bitwise NOT of the given `input` tensor.
    for:
      - bitwise_not
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: bitwise_not_
    description: The in-place version of `bitwise_not()`.
    for:
      - bitwise_not_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: bitwise_or_scalar
    description: Computes the bitwise OR of scalars `input` and `other`.
    for:
      - bitwise_or.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: bitwise_or_scalar_
    description: The in-place version of `bitwise_or_scalar`.
    for:
      - bitwise_or_.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: bitwise_or_scalar_tensor
    description: Computes the bitwise OR of `input` and `other`.
    for:
      - bitwise_or.Scalar_Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: bitwise_or_tensor
    description: Computes the bitwise OR of `input` and `other`, this is the Tensor method variant.
    for:
      - bitwise_or.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: bitwise_or_tensor_
    description: The in-place version of `bitwise_or_tensor()`.
    for:
      - bitwise_or_.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: bitwise_right_shift
    description: Computes the right arithmetic shift of `input` by `other` bits.
    for:
      - bitwise_right_shift
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '4.0'
  - id: bitwise_right_shift_
    description: The in-place version of `bitwise_right_shift()`.
    for:
      - bitwise_right_shift_
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: bitwise_xor_scalar
    description: Computes the bitwise XOR of tensor `input` and scalar `other`.
    for:
      - bitwise_xor.Scalar
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: bitwise_xor_scalar_
    description: The in-place version of `bitwise_xor_scalar()`.
    for:
      - bitwise_xor_.Scalar
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: bitwise_xor_scalar_tensor
    description: Computes the bitwise XOR of scalar `input` and tensor `other`.
    for:
      - bitwise_xor.Scalar_Tensor
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: bitwise_xor_tensor
    description: Computes the element-wise bitwise XOR of tensor `input` and tensor `other`.
    for:
      - bitwise_xor.Tensor
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: bitwise_xor_tensor_
    description: The in-place version of `bitwise_xor_tensor()`.
    for:
      - bitwise_xor_.Tensor
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: block_diag
    description: |
      Creates a block diagonal matrix from provided tensors. Each input tensor
      forms a diagonal block in the output, with zeros elsewhere.
    for:
      - block_diag
    labels:
      - aten
      - KernelGen
    kind:
      - LinearAlg
    stages:
      - alpha: '5.4'
  - id: bmm
    description: Performs a batch matrix-matrix product of matrices stored in `input` and `mat2`.
    for:
      - bmm
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '1.0'
    cpp: '4.0'
  - id: bmm_out
    description: |
      Performs a batch matrix-matrix product of matrices stored in `input` and `mat2`.
      This is a variant of `bmm` with `out` specified.
    for:
      - bmm.out
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '5.0'
    cpp: '4.0'
  - id: broadcast_tensors
    description: >-
      Broadcasts the given tensors to a common shape according to
      broadcasting semantics, returning a list of tensors.
    for:
      - broadcast_tensors
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: broadcast_to
    description: Broadcasts input to the shape size. Equivalent to calling input.expand(size).
    for:
      - broadcast_to
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: bucket_sort_topk
    description: A wrapper of the TLE version and the Triton version bucket-sort topk operation.
    for:
      - None
    labels:
      - fused
      - DSA
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: bucketize
    description: Returns the indices of the buckets to which each input value belongs.
    for:
      - bucketize.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: cat
    description: Concatenates the given sequence of tensors in tensors in the given dimension.
    for:
      - cat
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
    cpp: '4.0'
  - id: cat_out
    description: A variant of `cat` that assigns the result to the provided `out` parameter.
    for:
      - cat.out
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
    cpp: '4.0'
  - id: cauchy
    description: Draws random numbers from a Cauchy distribution.
    for:
      - cauchy.float
    labels:
      - aten
    kind:
      - Distribution
    stages:
      - beta: '5.3'
  - id: cauchy_
    description: Fills the tensor with numbers drawn from the Cauchy distribution.
    for:
      - cauchy_.float
    labels:
      - aten
    kind:
      - Distribution
    stages:
      - beta: '5.3'
  - id: cdist_backward
    description: |
      Computes the backward pass for the batched pairwise distance (cdist) computation,
      computing the gradient with respect to the input tensors.
    for:
      - _cdist_backward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: cdist_forward
    description: |
      Computes the batched pairwise distance (cdist) between two collections of row vectors,
      supporting p=2.0 (L2 norm).
    for:
      - _cdist_forward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: ceil
    description: |
      Returns a new tensor with the ceil of the elements of `input`, the smallest integer greater than
      or equal to each element.
    for:
      - ceil
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '5.0'
  - id: ceil_
    description: The in-place version of `ceil()`.
    for:
      - ceil_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '5.0'
  - id: ceil_out
    description: A variant of `ceil()` with `out` specified.
    for:
      - ceil.out
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '5.0'
  - id: celu
    description: |
      Applies the quantized CELU (Continuously Differentiable Exponential Linear Unit)
      activation function element-wise.
    for:
      - celu
    labels:
      - aten
      - nn.functional
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '4.0'
  - id: celu_
    description: The in-place version of `celu()`.
    for:
      - celu_
    labels:
      - aten
      - nn.functional
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '4.0'
  - id: channel_shuffle
    description: Divides the channels into groups and rearranges each group.
    for:
      - channel_shuffle
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: cholesky_inverse
    description: Compute inverse of symmetric positive-definite matrix from Cholesky factor.
    for:
      - cholesky_inverse
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: chunk
    description: Split a tensor into a specific number of chunks along a given dimension.
    for:
      - chunk
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: chunk_cat
    description: Triton kernel implementation for _chunk_cat.
    for:
      - _chunk_cat
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: chunk_gated_delta_rule_fwd
    description: |
      The forward case for `ChunkGatedDeltaRuleFunction` with Flash Linear Attention (FLA).
    for:
      - chunk_gated_delta_rule_fwd
    labels:
      - fused
      - FLA
    kind:
      - Attention
    stages:
      - alpha: '5.0'
      - beta: '5.3'
  - id: clamp
    description: Clamps all elements in `input` into the range `[min, max]`.
    for:
      - clamp
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: clamp_
    description: The in-place version of `clamp()`.
    for:
      - clamp_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: clamp_max
    description: |
      Clamps all elements in `input` to be smaller or equal `max`.
    for:
      - clamp_max
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: clamp_max_
    description: |
      The in-place version of `clamp_max()`.
    for:
      - clamp_max_
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: clamp_min
    description: A variant of `clamp()` with `min` set to `min`.
    for:
      - clamp_min
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '4.0'
  - id: clamp_min_
    description: The in-place version of `clamp_()`.
    for:
      - clamp_min_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '4.0'
  - id: clamp_tensor
    description: The tensor version of `clamp()`.
    for:
      - clamp.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: clamp_tensor_
    description: The in-place, tensor version of `clamp()`.
    for:
      - clamp_.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: clip
    description: This is identical to `clamp()`.
    for:
      - clip_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: clip_
    description: This is identical to `clamp_()`.
    for:
      - clip_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: clone
    description: Pure layout/memory operation (clone).
    for:
      - clone
    labels:
      - KernelGen
      - aten
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: col2im
    description: |
      Rearranges column blocks back into a multidimensional tensor (inverse of im2col).
    for:
      - col2im
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: combine_topk_swa_indices
    description: |
      Combines compressed top-k sparse attention indices with sliding-window attention indices
      for DeepSeekV4 attention.
    for:
      - vllm.v1.attention.ops.deepseek_v4_ops.combine_topk_swa_indices
    labels:
      - fused
      - Attention
      - vLLM
      - DeepSeekV4
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: compute_global_topk_indices_and_lens
    description: |
      Converts local top-k sparse attention indices to global KV-cache indices and computes
      valid top-k lengths for DeepSeekV4 attention.
    for:
      - vllm.v1.attention.ops.deepseek_v4_ops.compute_global_topk_indices_and_lens
    labels:
      - fused
      - Attention
      - vLLM
      - DeepSeekV4
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: concat
    description: An alias of `cat()`.
    for:
      - concat
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: concat_and_cache_mla
    description: |
      Writes the latent and RoPE value into KV cache for Multi-head Latent Attention forward case.
    for:
      - _C_cache_ops.concat_and_cache_mla
    labels:
      - fused
      - MLA
    kind:
      - Attention
    stages:
      - beta: '3.0'
  - id: concatenate
    description: An alias of `cat()`.
    for:
      - concatenate
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.3'
  - id: conj
    description: |
      Computes the element-wise conjugate of a complex tensor.
      For non-complex tensors, returns the input unchanged.
    for:
      - _conj
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: conj_physical
    description: |
      Computes the element-wise conjugate of the given `input` tensor.
      If `input` has a non-complex dtype, this function just returns `input`.
    for:
      - conj_physical
    labels:
      - aten
    kind:
      - LinearAlg
    stages:
      - beta: '5.3'
  - id: constant_pad_nd
    description: |
      Pads the input tensor boundaries with a constant value.
      This is an IR representation, not a public API.
    for:
      - constant_pad_nd
    labels:
      - aten
      - IR
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: contiguous
    description: |
      Returns a contiguous in memory tensor containing the same data as `self` tensor.
    for:
      - contiguous
    labels:
      - aten
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - alpha: '2.2'
      - removed: '4.1'
    cpp: '4.0'
  - id: conv1d
    description: Applies a 1D convolution over a quantized 1D input composed of several input planes.
    for:
      - conv1d
    labels:
      - aten
    kind:
      - Convolution
    stages:
      - stable: '4.2'
  - id: conv1d_padding
    description: Applies a 1D convolution over a quantized 1D input composed of several input planes.
    for:
      - conv1d.padding
    labels:
      - aten
    kind:
      - Convolution
    stages:
      - stable: '4.2'
  - id: conv2d
    description: Applies a 2D convolution over a quantized 2D input composed of several input planes.
    for:
      - conv2d
    labels:
      - aten
    kind:
      - Convolution
    stages:
      - stable: '4.2'
  - id: conv2d_padding
    description: Applies a 2D convolution over a quantized 2D input composed of several input planes.
    for:
      - conv2d.padding
    labels:
      - aten
    kind:
      - Convolution
    stages:
      - stable: '4.2'
  - id: conv3d
    description: Applies a 3D convolution over a quantized 3D input composed of several input planes.
    for:
      - conv3d
    labels:
      - aten
    kind:
      - Convolution
    stages:
      - stable: '4.2'
  - id: conv3d_padding
    description: Applies a 3D convolution over a quantized 3D input composed of several input planes.
    for:
      - conv3d.padding
    labels:
      - aten
    kind:
      - Convolution
    stages:
      - stable: '4.2'
  - id: conv_depthwise2d
    description: A depthwise convolution for the conv2d neural network function.
    for:
      - _conv_depthwise2d
    labels:
      - aten
      - Convolution
      - NoCPU
    kind:
      - NeuralNetwork
    stages:
      - beta: '2.2'
      - stable: '5.3'
  - id: conv_transpose1d
    description: |
      Applies a 1D transposed convolution operator over an input image composed of several input planes.
    for:
      - conv_transpose1d
    labels:
      - aten
      - KernelGen
    kind:
      - Convolution
    stages:
      - beta: '5.3'
  - id: conv_transpose2d
    description: |
      Applies a 2D transposed convolution operator over an input image composed of several input planes.
    for:
      - conv_transpose2d
    labels:
      - aten
      - KernelGen
    kind:
      - Convolution
    stages:
      - alpha: '5.3'
  - id: convert_weight_to_int4pack
    description: Converts a weight tensor to int4 packed format.
    for:
      - _convert_weight_to_int4pack
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: copy
    description: |
      As a wrapper of `copy_`, this operator copies elements from `src` to `out`
      using given template for shapes.
    for:
      - copy
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - beta: '4.2'
      - stable: '5.3'
  - id: copy_
    description: Copies the elements from `src` into `self` tensor and returns `self`.
    for:
      - copy_
    condition:
      - var: torch.version
        op: ge
        val: '2.4'
    labels:
      - aten
      - pointwise
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - stable: '4.1'
  - id: copysign
    description: |
      Create a new floating-point tensor with the magnitude of input and the sign of other, elementwise.
    for:
      - copysign
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: copysign_
    description: Triton kernel implementation for copysign_.
    for:
      - copysign_.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: copysign_out
    description: |
      A variant of `copysign` that allows the output to be saved into `out`.
    for:
      - copysign.out
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: cos
    description: Returns a new tensor with the cosine of the elements of `input` given in radians.
    for:
      - cos
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: cos_
    description: The in-place version of `cos()`.
    for:
      - cos_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: cosh
    description: Returns a new tensor with the hyperbolic cosine of the elements of `input`.
    for:
      - cosh
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '5.3'
  - id: cosh_
    description: This is the in-place version of `cosh()`.
    for:
      - cosh_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '5.3'
  - id: cosh_out
    description: This is an variant of `cosh()` that assigns the output to the provided `out`.
    for:
      - cosh.out
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '5.3'
  - id: count_nonzero
    description: |
      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.
    for:
      - count_nonzero
    labels:
      - aten
      - Reduction
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: cp_gather_indexer_k_quant_cache
    description: This is a fused operator that gathers FP8 K cache values and scales.
    for:
      - None
    labels:
      - fused
      - vLLM
    kind:
      - Quantization
    stages:
      - beta: '5.3'
  - id: cross_entropy_loss
    description: Computes the cross entropy loss between input logits and target.
    for:
      - CrossEntropyLoss
    labels:
      - fused
      - Reduction
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.0'
      - removed: '3.0'
  - id: cudnn_attention_forward
    description: |
      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.
    for:
      - _cudnn_attention_forward
    labels:
      - aten
      - NoCPU
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.5'
  - id: cudnn_batch_norm_backward
    description: Triton kernel implementation for cudnn_batch_norm_backward.
    for:
      - cudnn_batch_norm_backward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: cudnn_convolution
    description: |
      A wrapper for cuDNN convolution backend.
    for:
      - cudnn_convolution
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: cummax
    description: |
      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`.
    for:
      - cummax
    labels:
      - aten
      - Reduction
    kind:
      - Math
    stages:
      - stable: '3.0'
  - id: cummin
    description: |
      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`.
    for:
      - cummin
    labels:
      - aten
      - Reduction
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: cumprod
    description: Returns the cumulative product of elements of `input` in the dimension `dim`.
    for:
      - cumprod
    labels:
      - aten
      - Reduction
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: cumprod_
    description: This is the in-place version of `cumprod()`.
    for:
      - cumprod_
    labels:
      - aten
      - Reduction
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: cumsum
    destination: Returns the cumulative sum of elements of `input` in the dimension `dim`.
    for:
      - cumsum
    labels:
      - aten
    kind:
      - LinearAlg
    stages:
      - stable: '1.0'
  - id: cumsum_out
    destination: |
      Returns the cumulative sum of elements of `input` in the dimension `dim`.
      It is a variant of `cumsum()`.
    for:
      - cumsum.out
    labels:
      - aten
    kind:
      - Reduction
    stages:
      - stable: '3.0'
  - id: cutlass_scaled_mm
    for:
      - cutlass_scaled_mm_sm_90
    labels:
      - fused
      - vLLM
    kind:
      - LinearAlg
    stages:
      - beta: '5.0'
  - id: deg2rad
    description: Converts angles from degrees to radians.
    for:
      - deg2rad
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: deg2rad_
    description: In-place version of deg2rad.
    for:
      - deg2rad_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: deg2rad_out
    description: Out-of-place variant of deg2rad with pre-allocated output tensor.
    for:
      - deg2rad.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: dequantize
    description: >
      Returns an fp32 Tensor by dequantizing a quantized Tensor.
    for:
      - dequantize
      - dequantize.self
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: dequantize_and_gather_k_cache
    description: |
      Dequantizes FP8 K-cache entries and gathers them into a BF16 tensor for DeepSeekV4 attention.
    for:
      - vllm.v1.attention.ops.deepseek_v4_ops.dequantize_and_gather_k_cache
    labels:
      - fused
      - Attention
      - vLLM
      - DeepSeekV4
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: dgeglu
    description: |
      Gaussian Error Gated Linear Unit with GELU activation instead of sigmoid function.
      This is for the backward case.
    for:
      - dgeglu
    labels:
      - fused
      - Transformer
    kind:
      - NeuralNetwork
    stages:
      - alpha: '4.2'
      - beta: '5.0'
      - stable: '5.0'
  - id: diag
    description: |
      - 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`.
    for:
      - diag
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: diag_embed
    description: |
      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.
    for:
      - diag_embed
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: diagonal_backward
    description: |
      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()`.
    for:
      - diagonal_backward
    labels:
      - aten
      - pointwise
    kind:
      - LinearAlg
    stages:
      - stable: '2.2'
  - id: diagonal_copy
    description: |
      Performs the same operation as torch.diagonal, but all output tensors
      are freshly created instead of aliasing the input.
    for:
      - diagonal_copy
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: diagonal_scatter
    description: Scatter source values into the diagonal of a tensor with optional offset.
    for:
      - diagonal_scatter
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: diff
    description: |
      Computes the n-th forward difference along the given dimension.
    for:
      - diff
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: digamma
    description: |
      Computes the digamma function, which is the logarithmic derivative of the Gamma function.
    for:
      - digamma
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: digamma_
    description: |
      Computes the in-place digamma function, which is the logarithmic derivative of the Gamma function.
    for:
      - diagmma_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: dispatch_fused_moe_kernel
    description: |
      Accelerates neural network training by combining token routing (dispatch/all-to-all communication),
      expert computation (GEMM), and result aggregation into a single GPU kernel.
    for:
      - dispatch_fused_moe_kernel
    labels:
      - fused
      - Activation
      - vLLM
    kind:
      - MoE
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: div_mode
    description: |
      Divides each element of the `input` by the corresponding element of `other`.
      An optional `rounding_mode` can be specified.
    for:
      - div.Scalar_mode
      - div.Tensor_mode
      - divide.Scalar_mode
      - divide.Tensor_mode
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '1.0'
  - id: div_mode_
    description: The in-place version of `div_mode()`.
    for:
      - div_.Scalar_mode
      - div_.Tensor_mode
      - divide_.Scalar_mode
      - divide_.Tensor_mode
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: div_out
    description: This is an variant of `div()` with an `out` argument.
    for:
      - div.out
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '4.2'
  - id: div_scalar
    description: This is the scalar version of `div()`.
    for:
      - div.Scalar
      - divide.Scalar
      - true_divide.Scalar
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.1'
  - id: div_scalar_
    description: This is the in-place version of `div_scalar()`.
    for:
      - div_.Scalar
      - divide_Scalar
      - true_divide_.Scalar
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.1'
  - id: div_tensor
    description: |
      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`.
    for:
      - div.Tensor
      - divide.Tensor
      - true_divide.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.1'
  - id: div_tensor_
    description: This is the in-place version of `div_tensor()`.
    for:
      - div_.Tensor
      - divide_.Tensor
      - true_divide_.Tensor
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.1'
  - id: dot
    description: Computes the dot product of two 1D tensors.
    for:
      - dot
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '3.0'
  - id: dreglu
    description: |
      Rectified Gated Linear Unit is a variant of GLU that uses ReLU instead of
      the sigmoid function for gating. This is the backward case.
    for:
      - dreglu
    labels:
      - fused
      - Transformer
    kind:
      - NeuralNetwork
    stages:
      - alpha: '4.2'
      - beta: '5.3'
  - id: dropout
    description: An internal IR for implementing `torch.nn.functional.dropout`.
    for:
      - native_dropout
    labels:
      - aten
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - stable: '1.0'
  - id: dropout_backward
    description: The backward case of `dropout()`.
    for:
      - native_dropout_backward
    labels:
      - aten
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: dswiglu
    description: |
      Swish-Gated Linear Unit, a variant of GLU with the Swish activation function.
      This is for the backward case.
    for:
      - dswiglu
    labels:
      - fused
      - Transformer
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.0'
      - beta: '5.3'
  - id: dunder_ior_scalar
    description: The scalar version of `dunder_ior_tensor`.
    for:
      - __ior__.Scalar
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: dunder_ior_tensor
    description: The in-place version of bitwise or operation for tensor and scalar.
    for:
      - __ior__.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: dunder_or_scalar
    description: The scalar version of `dunder_or_tensor`.
    for:
      - __or__.Scalar
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: dunder_or_tensor
    description: The in-place version of bitwise or operation for tensor and scalar.
    for:
      - __or__.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: efficient_attention_backward
    description: |
      Backward kernel for FlashAttention, computing gradients of queries, keys, values, and attention outputs efficiently.
    for:
      - _efficient_attention_backward
    labels:
      - aten
      - NoCPU
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.4'
  - id: einsum
    description: |
      Sums the product of the elements of the input `operands` along dimensions specified using a notation
      based on the Einstein summation convention.
    for:
      - einsum
    labels:
      - aten
      - KernelGen
    kind:
      - Reduction
    stages:
      - alpha: '5.3'
  - id: elu
    description: Apply the Exponential Linear Unit (ELU) function element-wise.
    for:
      - elu
    labels:
      - aten
      - nn.functional
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: elu_
    description: The in-place version of `elu()`.
    for:
      - elu_
    labels:
      - aten
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '4.0'
  - id: elu_backward
    description: The backward version of `elu()`.
    for:
      - elu_backward
    labels:
      - aten
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '4.0'
  - id: embedding
    description: |
      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`.
    for:
      - embedding
    labels:
      - aten
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.1'
    cpp: '4.0'
  - id: embedding_backward
    description: The backward version of `embedding()`.
    for:
      - embedding_backward
    labels:
      - aten
      - NoCPU
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: embedding_bag_dense_backward
    description: |
      Computes the gradient for the backward pass of embedding_bag in dense mode.
    for:
      - _embedding_bag_dense_backward
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: embedding_bag_per_sample_weights_backward
    description: |
      Triton kernel implementation for _embedding_bag_per_sample_weights_backward.
    for:
      - _embedding_bag_per_sample_weights_backward
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: embedding_dense_backward
    description: Calculates the gradient of the weight matrix for a dense embedding layer during backpropagation.
    for:
      - embedding_dense_backward
    labels:
      - aten
      - NoCPU
    kind:
      - NeuralNetwork
    stages:
      - stable: '5.0'
  - id: empty
    description: Tensor factory operator — verifies dtype inference for newly allocated tensors.
    for:
      - empty
    labels:
      - aten
      - KernelGen
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: eq
    description: Computes element-wise equality.
    for:
      - eq.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: eq_
    description: The in-place version of `eq()`.
    for:
      - eq_.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: eq_scalar
    description: Computes equality between scalars.
    for:
      - eq.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: eq_scalar_
    description: The scalar version of `eq_()`.
    for:
      - eq_.Scalar
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: equal
    description: Returns True if two tensors have the same size and elements, False otherwise.
    for:
      - equal
    labels:
      - aten
      - Reduction
    kind:
      - Math
    stages:
      - stable: '5.0'
  - id: erf
    description: Computes the error function of `input`.
    for:
      - erf
    labels:
      - aten
      - pointwise
    kind:
      - Science
    stages:
      - stable: '2.1'
  - id: erf_
    description: The in-place version of `erf()`.
    for:
      - erf_
    labels:
      - aten
      - pointwise
    kind:
      - Science
    stages:
      - stable: '2.2'
  - id: erfc
    description: Computes the complementary error function.
    for:
      - erfc
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: erfc_
    description: In-place version of `erfc`.
    for:
      - erfc_
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: erfinv
    description: Computes the inverse error function of `input`.
    for:
      - erfinv
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: erfinv_
    description: The in-place version of `erfinv()`.
    for:
      - erfinv_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: euclidean_dist
    description: |
      Computes pairwise Euclidean distances between rows of two 2D tensors.
    for:
      - _euclidean_dist
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: exp
    description: Returns a new tensor with the exponential of the elements of the input tensor `input`.
    for:
      - exp
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '1.0'
  - id: exp2
    description: Computes the base two exponential function of `input`.
    for:
      - exp2
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '4.0'
  - id: exp2_
    description: The in-place version of `exp2()`.
    for:
      - exp2_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '4.0'
  - id: exp_
    description: The in-place version of `exp()`.
    for:
      - exp_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: exp_out
    description: A variant of `exp2()`, with `out` specified.
    for:
      - exp.out
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '4.1'
  - id: expand
    description: Pure layout operation (expand).
    for:
      - expand
    labels:
      - aten
      - KernelGen
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: expand_
    description: Pure layout operation (expand, in-place).
    for:
      - expand_
    labels:
      - aten
      - KernelGen
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: expand_as
    description: Expand tensor to the same size as another tensor (view operation).
    for:
      - expand_as
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: expm1
    description: Computes the exponential of the elements minus 1 of `input`.
    for:
      - expm1
    labels:
      - aten
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: expm1_
    description: The inplace version of `expm1`.
    for:
      - expm1_
    labels:
      - aten
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: expm1_out
    description: A variant of `expm1` that saves the output to the specified `out`.
    for:
      - expm1.out
    labels:
      - aten
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: exponential_
    description: Fills `self` tensor with elements drawn from a PDF (probability density function).
    for:
      - exponential_
    labels:
      - aten
      - skip_precision_check
    kind:
      - Distribution
    stages:
      - stable: '2.1'
    cpp: '4.0'
  - id: eye
    description: Returns a 2-D tensor with ones on the diagonal and zeros elsewhere.
    for:
      - eye
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '3.0'
  - id: eye_m
    description: |
      Triton-based implementation of `torch.eye_m(n, m)`, using 2D tiles to split the matrix into blocks.
    for:
      - eye.m
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '3.0'
  - id: feature_dropout
    description: |
      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.
    for:
      - feature_dropout
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.3'
  - id: feature_dropout_
    description: The in-place version of `feature_dropout()`.
    for:
      - feature_dropout_
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.3'
  - id: fill_scalar
    description: Fills a scalar with the specified value.
    for:
      - fill.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - stable: '2.2'
    cpp: '4.0'
  - id: fill_scalar_
    description: The in-place version of `fill_scalar()`.
    for:
      - fill_.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - stable: '2.2'
    cpp: '4.0'
  - id: fill_scalar_out
    description: A variant of `fill_scalar()` that assigns the output to an `out` tensor.
    for:
      - fill.Scalar_out
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Tensor
    stages:
      - stable: '5.0'
  - id: fill_tensor
    description: Fills a tensor with the specified value.
    for:
      - fill.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - stable: '2.2'
    cpp: '4.0'
  - id: fill_tensor_
    description: The in-place version of `fill_tensor()`.
    for:
      - fill_.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - stable: '2.2'
    cpp: '4.0'
  - id: fill_tensor_out
    description: A variant of `fill_tensor()` that assigns the output to an `out` tensor.
    for:
      - fill.Tensor_out
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Tensor
    stages:
      - stable: '5.0'
  - id: fix
    description: "fix operator"
    for:
      - fix
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: fix_
    description: |
      In-place version of fix. Truncates each element toward zero
      (floor for non-negative values, ceil for negative values).
      Integer tensors are left unchanged.
    for:
      - fix_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: flatten
    description: Flatten a contiguous range of dimensions into a single dimension (view operation).
    for:
      - flatten.using_ints
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: flash_attention_backward
    description: |
      Backward kernel for FlashAttention, computing gradients of queries, keys, values, and attention outputs efficiently.
    for:
      - _flash_attention_backward
    labels:
      - aten
      - NoCPU
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.4'
  - id: _flash_attention_forward
    description: Run the canonical FlashAttention forward operator.
    for:
      - _flash_attention_forward
    labels:
      - aten
      - NoCPU
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: flash_attention_forward
    labels:
      - aten
      - NoCPU
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: flash_attn_varlen_func
    description: |
      Compute attention for sequences of variable lengths within a single batch.
      Eliminating the need for padding.
    for:
      - flash_attn_varlen_func
    labels:
      - aten
      - Attention
      - FlashAttention
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.1'
    cpp: '4.0'
  - id: flash_attn_varlen_opt_func
    description: A variant of `flash_attn_varlen_func` that has `lse` as an optional parameter.
    for:
      - flash_attn_varlen_func
    labels:
      - aten
      - Attention
      - FlashAttention
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: flash_mla
    description: A variant of Multi-head Latent Attention (MLA).
    for:
      - triton_mla._forward_decode
    labels:
      - fused
      - Attention
      - vLLM
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: flash_mla_sparse_fwd
    description: Part of the FlashMLA.
    for:
      - vllm.v1.attention.backends.mla.flashmla_sparse
    labels:
      - fused
      - Attention
      - vLLM
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.3'
  - id: flip
    description: Reverse the order of an n-D tensor along given axis in dims.
    for:
      - filp
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - stable: '2.1'
  - id: float_power_
    description: Triton kernel implementation for float_power_.
    for:
      - float_power_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: floor
    description: |
      Performs an element-wise floor operation, rounding each element of a tensor
      down to the nearest integer less than or equal to itself.
    for:
      - floor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: floor_
    description: |
      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.
    for:
      - floor_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: floor_divide_scalar
    description: Computes `input` divided by `other`, elementwise, and floors the result.
    for:
      - floor_divide.Scalar
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.1'
  - id: floor_divide_scalar_
    description: Computes `input` divided by `other`, elementwise, and floors the result.
    for:
      - floor_divide_Scalar
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: floor_divide_tensor
    description: Computes `input` divided by `other`, elementwise, and floors the result.
    for:
      - floor_divide
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.1'
  - id: floor_divide_tensor_
    description: Computes `input` divided by `other`, elementwise, and floors the result.
    for:
      - floor_divide_.Tensor
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: floor_out
    description: |
      Performs an element-wise floor operation with output tensor, rounding each element
      down to the nearest integer less than or equal to itself.
    for:
      - floor.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: fmax
    description: |
      Computes the element-wise maximum of input and other, ignoring NaNs.
    for:
      - fmax
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: fmax_out
    description: |
      Computes the element-wise maximum of input and other, ignoring NaNs (out variant).
    for:
      - fmax.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: fmin
    description: |
      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.
    for:
      - fmin
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: fmin_out
    description: A variant of `fmin()` that assigns the output to the `out` tensor.
    for:
      - fmin.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: fmod_
    description: In-place remainder of division (fmod_), computes element-wise remainder with truncation toward zero.
    for:
      - fmod_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: fmod_scalar
    description: |
      Computes the element-wise remainder of division of input by a scalar divisor.
    for:
      - fmod.Scalar
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: fmod_scalar_
    description: |
      In-place version of fmod with a scalar divisor.
    for:
      - fmod_.Scalar
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: fmod_tensor
    description: |
      Computes the element-wise remainder of division of input by a tensor divisor.
    for:
      - fmod.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: fmod_tensor_
    description: |
      In-place version of fmod with a tensor divisor.
    for:
      - fmod_.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: fp8_fp4_mega_moe
    description: |
      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.
    for:
      - flag_gems.fused.fp8_fp4_mega_moe
      - vllm.third_party.deep_gemm.fp8_fp4_mega_moe
    labels:
      - fused
      - vLLM
      - Triton
    kind:
      - MoE
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: fp8_fp4_mqa_logits
    description: |
      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.
    for:
      - vllm.utils.deep_gemm.fp8_fp4_mqa_logits
    labels:
      - fused
      - vLLM
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.1'
  - id: fp8_fp4_paged_mqa_logits
    description: |
      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.
    for:
      - vllm.utils.deep_gemm.fp8_fp4_paged_mqa_logits
    labels:
      - fused
      - vLLM
      - DeepSeekV4
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: fp8_mqa_logits
    description: |
      For each token in the given E4M3 tensor, iterate all tokens from two other given tensors,
      calculate the logit.
    for:
      - vllm.utils.deep_gemm.fp8_mqa_logits
    labels:
      - fused
      - vLLM
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: frac
    description: Computes the fractional part of each element, returning x - trunc(x).
    for:
      - frac
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: frac_
    description: In-place fractional part computation, returning x - trunc(x).
    for:
      - frac_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: fractional_max_pool2d
    description: |
      Applies 2D fractional max pooling over an input signal composed of several input planes.
    for:
      - fractional_max_pool2d
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: fractional_max_pool2d_backward
    description: |
      Computes the gradient of fractional_max_pool2d.
    for:
      - fractional_max_pool2d_backward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: full
    description: |
      Creates a tensor of size `size` filled with `fill_value`.
      The tensor's dtype is inferred from `fill_value`.
    for:
      - full
    labels:
      - aten
      - pointwise
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - stable: '2.1'
  - id: full_like
    description: Returns a tensor with the same size as `input` filled with `fill_value`.
    for:
      - full_like
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - stable: '2.1'
  - id: functional_sym_constrain_range
    description: |
      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.
    for:
      - _functional_sym_constrain_range
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: functional_sym_constrain_range_for_size
    description: |
      A low-level function used in symbolic shape analysis to restrict the possible numerical range
      (min/max) of an unbacked symbolic integer.
    for:
      - _functional_sym_constrain_range_for_size
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.0'
  - id: fused_adam
    description: Fused Adam optimizer step with optional AdamW weight decay, AMSGrad, and gradient maximize support.
    for:
      - _fused_adam
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: fused_adam_
    description: The in-place version of `fused_adam()`.
    for:
      - _fused_adam_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: fused_add_rms_norm
    for:
      - add_rms_norm
    labels:
      - fused
      - Normalization
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.0'
    cpp: '4.0'
  - id: fused_rms_norm
    description: Fused RMS normalization returning the normalized output and inverse RMS.
    for:
      - _fused_rms_norm
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: fused_deepseek_v4_qnorm_rope_kv_rope_insert
    description: |
      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.
    for:
      - fused_deepseek_v4_qnorm_rope_kv_rope_insert
    labels:
      - fused
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: fused_deepseek_v4_qnorm_rope_kv_rope_quant_insert
    description: |
      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.
    for:
      - torch.ops._C.fused_deepseek_v4_qnorm_rope_kv_rope_quant_insert
    labels:
      - fused
      - vLLM
      - DeepSeekV4
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: fused_experts_impl
    description: An implementation of fused MoE.
    for:
      - vllm.model_executor.layers.fused_moe.fused_moe.fused_experts_impl
    labels:
      - fused
      - vLLM
      - MoE
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: fused_indexer_q_rope_quant
    description: |
      Applies RoPE to sparse indexer Q, quantizes it to FP8 or MXFP4, and folds
      indexer weights for DeepSeekV4 attention.
    for:
      - vllm.v1.attention.ops.deepseek_v4_ops.fused_indexer_q_rope_quant
    labels:
      - fused
      - Attention
      - vLLM
      - DeepSeekV4
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.4'
  - id: fused_moe
    description: The generic interface for fused MoE.
    for:
      - vllm.model_executor.layers.fused_moe.fused_moe.fused_experts_impl
    labels:
      - fused
      - vLLM
      - MoE
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: fused_q_kv_rmsnorm
    description: |
      Applies RMSNorm to Q and KV tensors in a single fused kernel for DeepSeekV4 attention.
    for:
      - vllm.v1.attention.ops.deepseek_v4_ops.fused_q_kv_rmsnorm
    labels:
      - fused
      - Attention
      - vLLM
      - DeepSeekV4
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: fused_recurrent_gated_delta_rule_fwd
    description: |
      The forward case for `fused_recurrent_gated_delta_rule` used in Flash Linear Attention (FLA).
    for:
      - fused_recurrent_gated_delta_rule_fwd
    labels:
      - fused
      - FLA
    kind:
      - Attention
    stages:
      - alpha: '5.0'
      - beta: '5.3'
  - id: gather
    description: Gathers values along an axis specified by `dim`.
    for:
      - gather
    labels:
      - aten
      - Reduction
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: gather_backward
    description: The backward version of `gather()`.
    for:
      - gather_backward
    labels:
      - aten
      - Reduction
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: gather_block_quantized
    description: Triton kernel implementation for gather_block_quantized.
    for:
      - gather_block_quantized
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: gcd
    description: Computes the element-wise greatest common divisor (GCD) of `input` and `other`.
    for:
      - gcd
    labels:
      - aten
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: gcd_out
    description: A variant of `gcd()` that allows the output to be assigned to the specified `out`.
    for:
      - gcd.out
    labels:
      - aten
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: gcd_
    description: |
      Computes the element-wise greatest common divisor (GCD) of `input` and `other` in-place.
    for:
      - gcd_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: ge
    description: Computes `input` is greater or equal to `other` element-wise.
    for:
      - ge.Tensor
      - greater_equal.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: ge_scalar
    description: The scalar version of `ge()`.
    for:
      - ge.Scalar
      - greater_equal.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: geglu
    description: Gaussian Error Gated Linear Unit with GELU activation instead of sigmoid function.
    for:
      - geglu
    labels:
      - fused
      - Activation
      - Transformer
    kind:
      - NeuralNetwork
    stages:
      - alpha: '4.2'
      - beta: '5.3'
  - id: gelu
    description: |
      Apply Cumulative Distribution Function for Gaussian Distribution function element-wise.
    for:
      - gelu
    labels:
      - aten
      - pointwise
      - Activation
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - stable: '1.0'
  - id: gelu_
    description: The in-place version of `gelu()`.
    for:
      - gelu_
    labels:
      - aten
      - Activation
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: gelu_and_mul
    description: An activation function for GeGLU.
    for:
      - GeluAndMul
    labels:
      - fused
      - pointwise
      - Activation
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.0'
  - id: gelu_backward
    description: The backward version of `gelu()`.
    for:
      - gelu_backward
    labels:
      - aten
      - Activation
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: geometric
    description: Draws random numbers from a geometric distribution.
    for:
      - geometric.float
    labels:
      - aten
    kind:
      - Distribution
    stages:
      - beta: '5.1'
  - id: geometric_
    description: Fills self tensor with elements drawn from the geometric distribution.
    for:
      - geometric_.float
    labels:
      - aten
    kind:
      - Distribution
    stages:
      - beta: '5.1'
  - id: get_paged_mqa_logits_metadata
    description: Build scheduling metadata for paged MQA logits.
    for:
      - vllm.utils.deep_gemm.get_paged_mqa_logits_metadata
    labels:
      - vLLM
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: get_scheduler_metadata
    description: |
      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.
    for:
      - get_scheduler_metadata
    labels:
      - NoCPU
      - vLLM
    kind:
      - Attention
    stages:
      - stable: '4.0'
  - id: glu
    description: Gated Linear Unit activation for modulating the output of a linear transformation with a gate.
    for:
      - glu
    labels:
      - aten
      - Activation
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: glu_backward
    description: The backward version of `glu()`.
    for:
      - glu_backward
    labels:
      - aten
      - Activation
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '4.0'
  - id: greater
    description: Test if input is greater than `other` elementwise.
    for:
      - greater.Tensor
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '5.3'
  - id: greater_equal_
    description: The in-place version of `greater_equal()`, which is an alias for `ge()`.
    for:
      - greater_equal_.Tensor
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: greater_out
    description: A variant of `greater` that saves the output to the specified `out`.
    for:
      - greater.out
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '5.3'
  - id: greater_scalar
    description: A variant of `greater` for scalar variables.
    for:
      - greater.Scalar
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '5.3'
  - id: greater_scalar_out
    description: A variant of `greater_out` that saves the output to the specified `out`.
    for:
      - greater.Scalar_out
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '5.3'
  - id: grid_sample
    description: |
      Given an `input` and a flow-field `grid`, computes the `output` using `input` values and
      pixel locations from `grid`.
    for:
      - nn.functional.grid_sample
    labels:
      - aten
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.3'
  - id: group_norm
    description: An internal IR for applying Group Normalization for last certain number of dimensions.
    for:
      - native_group_norm
    labels:
      - aten
      - Reduction
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.0'
  - id: group_norm_backward
    description: The backward case for `group_norm()`.
    for:
      - native_group_norm_backward
    labels:
      - aten
      - Reduction
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: grouped_mm
    description: |
      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.
    for:
      - _grouped_mm
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - beta: '5.3'
  - id: grouped_topk
    description: |
      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.
    for:
      - _moe_C.grouped_topk
    labels:
      - fused
      - NoCPU
      - vLLM
    kind:
      - MoE
    stages:
      - stable: '5.0'
  - id: gt
    description: Computes that `input` is greater than `other` element-wise.
    for:
      - gt.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: gt_scalar
    description: The scalar version of `gt()`.
    for:
      - gt.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: gt_scalar_
    description: In-place version of gt for scalar comparison, computes element-wise greater-than with a scalar storing result in input.
    for:
      - gt_.Scalar
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: gt_tensor_
    description: In-place version of gt for tensor comparison, computes element-wise greater-than with a tensor storing result in input.
    for:
      - gt_.Tensor
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: hardshrink
    description: |
      Applies the hard shrinkage function element-wise: returns x if |x| > lambd, else 0.
    for:
      - hardshrink
    labels:
      - aten
      - pointwise
      - nn.functional
      - Activation
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: hardshrink_out
    description: |
      Out-variant of hardshrink. Writes the element-wise result into the `out` tensor.
    for:
      - hardshrink.out
    labels:
      - aten
      - pointwise
      - nn.functional
      - Activation
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: hardsigmoid
    description: |
      An activation function that provides a piecewise linear approximation of the standard sigmoid function,
      mapping inputs to a range between 0 and 1.
    for:
      - hardsigmoid
    labels:
      - aten
      - pointwise
      - nn.functional
      - Activation
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
  - id: hardsigmoid_out
    description: |
      A variant of `hardsigmoid` that supports an output tensor to receive the result.
    for:
      - hardsigmoid.out
    labels:
      - aten
      - pointwise
      - nn.functional
      - Activation
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
  - id: hardsigmoid_
    description: |
      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.
    for:
      - hardsigmoid_
    labels:
      - aten
      - pointwise
      - KernelGen
      - Activation
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: hardswish_
    description: |
      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.
    for:
      - hardswish_
    labels:
      - aten
      - pointwise
      - KernelGen
      - Activation
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
  - id: hardtanh_
    description: |
      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.
    for:
      - hardtanh_
    labels:
      - aten
      - pointwise
      - Activation
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: hc_head_fused_kernel
    description: |
      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.
    for:
      - mhc_head_fused_kernel
    labels:
      - fused
      - vLLM
      - DSA
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.2'
      - stable: '5.3'
  - id: hc_split_sinkhorn_forward
    description: |
      Computes a differentiable approximation of the Wasserstein distance (Optimal Transport)
      between two probability distributions or point clouds.
    for:
      - None
    labels:
      - fused
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: heaviside_
    description: |
      In-place version of heaviside. For each element: 0 if x < 0, 1 if x > 0,
      and the corresponding `values` element if x == 0.
    for:
      - heaviside_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: histc
    description: |
      Computes the histogram of a tensor, binning each element into equal-width bins.
    for:
      - histc
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: hstack
    description: |
      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.
    for:
      - hstack
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: huber_loss
    description: |
      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.
    for:
      - huber_loss
    labels:
      - aten
      - KernelGen
      - Loss
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: huber_loss_out
    description: |
      Out-variant of huber_loss. Writes the computed loss into the `out` tensor.
    for:
      - huber_loss.out
    labels:
      - aten
      - KernelGen
      - Loss
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: hypot
    description: |
      Given the legs of a right triangle, return its hypotenuse.
      The shapes of both input tensors must be broadcastable.
    for:
      - hypot
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: hypot_out
    description: |
      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.
    for:
      - hypot.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: hypot_
    description: |
      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`.
    for:
      - hypot_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: i0
    description: |
      Computes the modified Bessel function of the first kind of order zero element-wise for a given input tensor.
    for:
      - i0
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: i0_
    description: The inplace version of `i0`.
    for:
      - i0_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: i0_out
    description: A variant of `i0` that assigns the output to the `out` tensor.
    for:
      - i0.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: igamma_
    description: In-place computation of the regularized lower incomplete gamma function.
    for:
      - igamma_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: igammac_
    description: |
      In-place version of igammac. Computes the regularized upper incomplete gamma function complement.
    for:
      - igammac_
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: ilshift
    description: Computes the in-place bitwise left shift of `self` by `other` bits.
    for:
      - __ilshift__.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: im2col
    description: Extracts sliding local blocks from a batched input tensor.
    for:
      - im2col
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: index
    description: |
      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.
    for:
      - index.Tensor
    labels:
      - aten
    kind:
      - Reduction
    stages:
      - alpha: '3.0'
      - beta: '4.0'
      - stable: '4.2'
  - id: index_add
    description: |
      Accumulate the elements of `alpha` times `source` into the `input` tensor
      by adding to the indices in the order given in `index`.
    for:
      - index_add
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: index_add_
    description: The in-place version of `index_add()`.
    for:
      - index_add_
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '4.0'
  - id: index_copy
    description: |
      Copies the elements from `source` into `input` at the positions specified by
      `index` along the given `dim`.
    for:
      - index_copy
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: index_copy_
    description: The in-place version of `index_copy()`.
    for:
      - index_copy_
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: index_put
    description: |
      Puts values from the tensor `values` into the tensor `input` using the indices specified
      in `indices` (which is a tuple of Tensors).
    for:
      - index_put
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: index_put_
    description: The in-place version of `index_put()`.
    for:
      - index_put_
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '3.0'
  - id: index_put_impl
    description: An internal C++ function that handles the heavy lifting for placing values into a tensor at specific indices.
    for:
      - _index_put_impl_
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: index_reduce_
    description: |
      Accumulates the elements of `source` into `input` at the indices specified
      by `index` along `dim`, using `prod`, `mean`, `amax`, or `amin` reduction.
    for:
      - index_reduce_
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.4'
  - id: index_select
    description: |
      Returns a new tensor which indexes the `input` tensor along dimension `dim`
      using the entries in `index`.
    for:
      - index_select
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.1'
  - id: index_select_backward
    description: Backward of index_select. Accumulates gradients into the output at positions specified by the index.
    for:
      - index_select_backward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: indexer_k_quant_and_cache
    description: This is a fused operator that quantizes K tensors and writes them into the FP8 KV cache.
    for:
      - None
    labels:
      - fused
      - vLLM
    kind:
      - Quantization
    stages:
      - beta: '5.3'
  - id: inplace_fused_experts
    description: This operator writes output directly to `hidden_states`.
    for:
      - inplace_fused_experts
    labels:
      - fused
      - Activation
      - vLLM
    kind:
      - MoE
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: instance_norm
    description: |
      Apply Instance Normalization independently for each channel in every data sample within a batch.
    for:
      - instance_norm
    labels:
      - fused
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
      - removed: '3.0'
      - beta: '5.3'
  - id: irshift
    description: Triton kernel implementation for __irshift__.
    for:
      - __irshift__.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: is_all_true
    description: The low-level implementation for checking if all elements in a tensor are True.
    for:
      - _is_all_true
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: is_nonzero
    description: Returns True if the single-element input tensor is not equal to zero.
    for:
      - is_nonzero
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: isclose
    description: |
      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`.
    for:
      - isclose
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.1'
  - id: isfinite
    description: Returns a new tensor with boolean elements representing if each element is finite or not.
    for:
      - isfinite
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.1'
  - id: isin
    description: |
      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.
    for:
      - isin.Tensor_Tensor
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: isin_scalar_tensor
    description: A variant of `isin()`.
    for:
      - isin.Scalar_Tensor
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: isin_tensor_scalar
    description: A variant of `isin()`.
    for:
      - isin.Tensor_Scalar
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: isinf
    description: Tests if each element of `input` is infinite (positive or negative infinity) or not.
    for:
      - isinf
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: isnan
    description: Returns a new tensor with boolean elements representing if each element of `input` is NaN or not.
    for:
      - isnan
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: isneginf
    description: Tests if each element of `input` is negative infinity or not.
    for:
      - isneginf
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Math
    stages:
      - stable: '5.3'
  - id: isneginf_out
    description: A variant of `isneginf` that saves the output to the specified `out`.
    for:
      - isneginf.out
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Math
    stages:
      - stable: '5.3'
  - id: isposinf
    description: Tests if each element of input is positive infinity or not.
    for:
      - isposinf
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: jagged_to_padded_dense_forward
    description: |
      Converts a jagged (variable-length) tensor to a padded dense tensor.
    for:
      - _jagged_to_padded_dense_forward
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: kron
    description: Computes the Kronecker product of `input` and `other`.
    for:
      - kron
    labels:
      - aten
    kind:
      - LinearAlg
    stages:
      - stable: '2.2'
  - id: kthvalue
    description: Returns the kth smallest element of the given input tensor along a given dimension.
    for:
      - kthvalue
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: layer_norm
    description: An internal IR for applying Layer Normalization for last certain number of dimensions.
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - stable: '1.0'
  - id: layer_norm_backward
    description: The backward case for `layer_norm()`.
    for:
      - native_layer_norm_backward
    labels:
      - aten
    kind:
      - Reduction
    stages:
      - stable: '3.0'
  - id: lcm
    description: Compute the element-wise least common multiple of input tensors.
    for:
      - lcm
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Pointwise
    stages:
      - alpha: '5.4'
  - id: lcm_
    description: Compute the element-wise least common multiple of input tensors, storing result in-place.
    for:
      - lcm_
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Pointwise
    stages:
      - alpha: '5.4'
  - id: le
    description: Computes that `input` is less than or equal to `other` element-wise.
    for:
      - le.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: le_
    description: The in-place version of `le()`.
    for:
      - le_.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: le_scalar
    description: The scalar version of `le()`.
    for:
      - le.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: le_scalar_
    description: The scalar version of `le_()`.
    for:
      - le_.Scalar
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: leaky_relu
    description: Applies the LeakyReLU function element-wise.
    for:
      - leaky_relu
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: leaky_relu_
    description: The in-place version of `leaky_relu()`.
    for:
      - leaky_relu_
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: leaky_relu_out
    description: A variant of `leaky_relu()`.
    for:
      - leaky_relu.out
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: lerp_scalar
    description: The scalar version of `lerp()`.
    for:
      - lerp.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - LinearAlg
    stages:
      - stable: '3.0'
  - id: lerp_scalar_
    description: The in-place, scalar version of `lerp()`.
    for:
      - lerp_.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - LinearAlg
    stages:
      - stable: '3.0'
  - id: lerp_tensor
    description: |
      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.
    for:
      - lerp.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - LinearAlg
    stages:
      - stable: '3.0'
  - id: lerp_tensor_
    description: The in-place version of `lerp()`.
    for:
      - lerp_.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - LinearAlg
    stages:
      - stable: '3.0'
  - id: less_
    description: The in-place version of `less()`.
    for:
      - less_.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: less_scalar_
    description: The scalar version of `less_()`.
    for:
      - less_.Scalar
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: less_equal
    description: Computes element-wise less-than-or-equal-to comparison.
    for:
      - less_equal.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: less_equal_scalar
    description: Computes less-than-or-equal-to comparison with a scalar.
    for:
      - less_equal.Scalar
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: less_equal_
    description: The in-place version of `less_equal()`.
    for:
      - less_equal_.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: less_equal_scalar_
    description: The scalar version of `less_equal_()`.
    for:
      - less_equal_.Scalar
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: lgamma
    description: Computes the logarithm of the gamma function on input.
    for:
      - lgamma
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: lgamma_
    description: In-place version of lgamma().
    for:
      - lgamma_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: lift
    description: |
      Returns self tensor. Used within compiled graphs to lift
      tensors out of the graph or modify autograd metadata.
    for:
      - lift
      - lift.out
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: lift_out
    description: |
      Out-of-place variant of lift that copies self to the out tensor.
    for:
      - lift_out
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: lift_fresh
    description: |
      Returns a fresh tensor holding the same values as the input, used to
      lift constants into a compiled graph.
    for:
      - lift_fresh
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: lift_fresh_copy
    description: |
      Creates a new, independent copy of a tensor within a compiled graph.
    for:
      - lift_fresh_copy
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: linalg_ldl_solve
    description: Triton kernel implementation for linalg_ldl_solve.
    for:
      - linalg_ldl_solve
    labels:
      - aten
      - KernelGen
    kind:
      - LinearAlg
    stages:
      - alpha: '5.4'
  - id: linalg_cholesky
    description: |-
      Computes the Cholesky decomposition of a symmetric positive-definite matrix A
      or for batches of symmetric positive-definite matrices.
    for:
      - linalg_cholesky
    labels:
      - aten
      - KernelGen
    kind:
      - LinearAlg
      - BLAS
    stages:
      - alpha: '5.4'
  - id: cholesky_solve
    description: |-
      Solves a system of linear equations with a symmetric positive-definite matrix
      using its Cholesky factorization.
    for:
      - cholesky_solve
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - alpha: '5.4'
  - id: cholesky_solve_out
    description: |-
      Solves a system of linear equations with a symmetric positive-definite matrix
      using its Cholesky factorization.
    for:
      - cholesky_solve.out
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - alpha: '5.4'
  - id: linalg_eigvals
    description: Computes the eigenvalues of a square matrix.
    for:
      - _linalg_eigvals
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: linalg_ldl_factor
    description: |
      Computes the compact LDL factorization of a Hermitian or symmetric matrix.
    for:
      - linalg_ldl_factor
    labels:
      - aten
      - KernelGen
    kind:
      - LinearAlg
    stages:
      - alpha: '5.4'
  - id: linalg_ldl_factor_ex
    description: |
      Computes the LDL factorization with pivot information for a symmetric or Hermitian matrix.
    for:
      - linalg.ldl_factor_ex
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: linalg_lstsq
    description: |-
      Computes the least-squares solution (gels driver) to A X = B for full-rank
      over- or underdetermined systems, including batches, via Householder TSQR.
    for:
      - linalg_lstsq
    labels:
      - aten
    kind:
      - LinearAlg
      - BLAS
  - id: linalg_lu_factor
    description: |
      Computes a compact representation of the LU factorization with partial pivoting of a matrix.
    for:
      - linalg.lu_factor
    labels:
      - aten
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: linalg_lu_factor_out
    description: |
      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.
    for:
      - linalg.lu_factor.out
    labels:
      - aten
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: linalg_lu_factor_ex
    description: |
      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.
    for:
      - linalg.lu_factor_ex
    labels:
      - aten
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: linalg_lu_factor_ex_out
    description: |
      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.
    for:
      - linalg.lu_factor_ex.out
    labels:
      - aten
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: linalg_slogdet
    description: |
      Computes the sign and natural logarithm of the absolute value of the determinant of a square matrix using LU decomposition with partial pivoting.
    for:
      - linalg.slogdet
    labels:
      - aten
      - KernelGen
    kind:
      - LinearAlg
    stages:
      - alpha: '5.4'
  - id: linalg_svdvals
    description: Computes the singular values of a matrix.
    for:
      - linalg_svdvals
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: linear
    description: |
      Applies a linear transformation to the incoming data: y = x @ W^T + b.
    for:
      - linear
    labels:
      - aten
      - KernelGen
    kind:
      - BLAS
    stages:
      - alpha: '5.4'
  - id: linear_backward
    description: Triton kernel implementation for linear_backward.
    for:
      - linear_backward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: linspace
    description: |
      Creates a one-dimensional tensor of size `steps` whose values are evenly spaced from `start` to `end`, inclusive.
    for:
      - linspace
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: log
    description: Returns a new tensor with the natural logarithm of the elements of `input`.
    for:
      - log
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: log_
    description: The in-place version of `log()`. Computes the natural logarithm of each element in the input tensor in-place.
    for:
      - log_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: log10
    description: Returns a new tensor with the logarithm to the base 10 of the elements of `input`.
    for:
      - log10
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: log10_
    description: The in-place version of `log10()`.
    for:
      - log10_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: log10_out
    description: A variant of `log10()` that assigns the output to the provided `out`.
    for:
      - log10_out
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: log1p
    description: |
      Computes the natural logarithm of `1+x(y_i=log_e(x_i+1))` for each element in the input tensor.
    for:
      - log1p
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: log1p_
    description: |
      Computes the natural logarithm of `1+x(y_i=log_e(x_i+1))` for each element in the input tensor in-place.
    for:
      - log1p_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: log2
    description: Returns a new tensor with the logarithm to the base 2 of the elements of `input`.
    for:
      - log2
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: log2_
    description: The in-place version of `log2()`.
    for:
      - log2_
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: log_normal_
    description: "Fills the tensor with log-normal samples parameterized by mean and standard deviation, in-place."
    for:
      - log_normal_
    labels:
      - aten
      - KernelGen
    kind:
      - Distribution
    stages:
      - alpha: '5.1'
  - id: log_sigmoid
    description: Applies the Logsigmoid function element-wise.
    for:
      - LogSigmoid
    labels:
      - aten
      - pointwise
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: log_sigmoid_forward
    description: >
      Computes the output and buffer for the log-sigmoid function, used in autograd backward pass.
    for:
      - log_sigmoid_forward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: log_softmax
    description: An internal IR for applying a softmax followed by a logarithm.
    for:
      - _log_softmax
    labels:
      - aten
      - Reduction
    kind:
      - NeuralNetwork
    stages:
      - alpha: '2.0'
      - stable: '3.0'
  - id: log_softmax_backward_data
    description: |
      Computes the gradient of the input tensor with respect to a `log_softmax` operation
      during backpropagation.
    for:
      - _log_softmax_backward_data
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.0'
      - beta: '5.3'
  - id: log_softmax_backward_data_out
    description: |
      A variant of `_log_softmax_backward_data` that assigns the output to the `out` tensor.
    for:
      - _log_softmax_backward_data.out
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.0'
      - beta: '5.3'
  - id: log_softmax_out
    description: An internal IR for applying a softmax followed by a logarithm.
    for:
      - _log_softmax.out
    labels:
      - aten
      - Reduction
    kind:
      - NeuralNetwork
    stages:
      - alpha: '2.0'
      - stable: '3.0'
  - id: logaddexp2
    description: Computes the element-wise base-2 logarithm of the sum of base-2 exponentiations of two input tensors.
    for:
      - logaddexp2
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.4'
  - id: logaddexp2_out
    description: A variant of `logaddexp2` that allows the output to be assigned to an `out` tensor.
    for:
      - logaddexp2.out
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.4'
  - id: lu_unpack
    description: Unpacks the LU decomposition returned by `lu_factor` into separate permutation matrix P, lower triangular L, and upper triangular U.
    for:
      - lu_unpack
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: lu_unpack_out
    description: Out-of-place variant of lu_unpack that writes results into pre-allocated output tensors.
    for:
      - lu_unpack.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: unsafe_chunk
    description: Split a tensor into a specified number of chunks along a given dimension.
    for:
      - unsafe_chunk
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: xlogy
    description: Computes `input * log(other)` element-wise, returning zero where `input` is zero (following PyTorch's `xlogy` semantics).
    for:
      - xlogy.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.4'
  - id: xlogy_out
    description: A variant of `xlogy` that allows the output to be assigned to an `out` tensor.
    for:
      - xlogy.OutTensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.4'
  - id: xlogy_tensor_scalar
    description: A variant of `xlogy` where `other` is a scalar.
    for:
      - xlogy.Scalar_Other
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.4'
  - id: xlogy_tensor_scalar_out
    description: A variant of `xlogy` where `other` is a scalar and the output is assigned to an `out` tensor.
    for:
      - xlogy.OutScalar_Other
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.4'
  - id: xlogy_scalar_tensor
    description: A variant of `xlogy` where `input` is a scalar.
    for:
      - xlogy.Scalar_Self
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.4'
  - id: xlogy_scalar_tensor_out
    description: A variant of `xlogy` where `input` is a scalar and the output is assigned to an `out` tensor.
    for:
      - xlogy.OutScalar_Self
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.4'
  - id: logaddexp
    description: Computes the element-wise logarithm of the sum of the exponentials of two input tensors.
    for:
      - logaddexp
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: logaddexp_out
    description: A variant of `logaddexp` that allows the output to be assigned to an `out` tensor.
    for:
      - logaddexp.out
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: logcumsumexp
    description: Triton kernel implementation for logcumsumexp.
    for:
      - logcumsumexp
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: logcumsumexp_out
    description: |
      A variant of `logcumsumexp` that allows the output to be assigned to an `out` tensor.
    for:
      - logcumsumexp.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: logical_and
    description: |
      Computes the element-wise logical AND of the given `input` tensors.
      Zeros are treated as False and nonzeros are treated as True.
    for:
      - logical_and
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: logical_and_
    description: The in-place version of `logical_and()`.
    for:
      - logical_and_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '5.0'
  - id: logical_not
    description: Computes the element-wise logical NOT of the given `input` tensor.
    for:
      - logical_not
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: logical_not_
    description: In-place version of logical_not. Computes the element-wise logical NOT.
    for:
      - logical_not_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: logical_or
    description: Computes the element-wise logical OR of the given input tensors.
    for:
      - logical_or
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: logical_or_
    description: The in-place version of `logical_or()`.
    for:
      - logical_or_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '5.0'
  - id: logical_xor
    description: Computes the element-wise logical XOR of the given input tensors.
    for:
      - logical_xor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: logical_xor_
    description: The in-place version of `logical_xor()`.
    for:
      - logical_xor_
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: logit
    description: |
      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.
    for:
      - logit
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - LinearAlg
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: logit_
    description: The in-place version of `logit()`.
    for:
      - logit_
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - LinearAlg
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: logit_out
    description: |
      A variant of `logit` that allows the output to be assigned to another tensor.
    for:
      - logit.out
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - LinearAlg
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: logspace
    description: |
      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`.
    for:
      - logspace
    labels:
      - aten
    kind:
      - tensor
    stages:
      - stable: '4.0'
  - id: logsumexp
    description: |
      Computes the log of the sum of exponentials of elements in the input tensor along given dimensions.
    for:
      - logsumexp
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: lshift
    description: Triton kernel implementation for __lshift__.
    for:
      - __lshift__
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: lstm
    description: Triton kernel implementation for lstm.
    for:
      - aten.lstm
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: lt
    description: Computes that `input` is less than `other` element-wise.
    for:
      - less.Tensor
      - lt.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: lt_
    description: The in-place version of `lt()`.
    for:
      - lt_.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: lt_scalar
    description: The scalar version of `lt`.
    for:
      - less.Scalar
      - lt.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: lt_scalar_
    description: The scalar version of `lt_()`.
    for:
      - lt_.Scalar
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: make_dep_token
    description: |
      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.
    for:
      - _make_dep_token
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: margin_ranking_loss
    description: Compute the margin ranking loss.
    for:
      - margin_ranking_loss
    labels:
      - aten
      - nn.functional
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.0'
      - beta: '5.3'
  - id: masked_fill
    description: Fills elements of given tensor with `value` where `mask` is True.
    for:
      - masked_fill.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - alpha: '2.1'
      - stable: '2.2'
  - id: masked_fill_
    description: The in-place version of `masked_fill()`.
    for:
      - masked_fill_.Tensor
    labels:
      - aten
      - pointwise
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: masked_fill_scalar
    description: Fills elements of given tensor with `value` where `mask` is True.
    for:
      - masked_fill.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - alpha: '2.1'
      - stable: '2.2'
  - id: masked_fill_scalar_
    description: The in-place version of `masked_fill()`.
    for:
      - masked_fill_.Scalar
    labels:
      - aten
      - pointwise
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: masked_scale
    description: The low-level implementation for computing input multiplied by scale with masking.
    for:
      - _masked_scale
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: masked_scatter
    description: Copies elements from `source` into the given tensor at positions where the `mask` is True.
    for:
      - masked_scatter
    labels:
      - aten
    kind:
      - tensor
    stages:
      - stable: '4.2'
  - id: masked_scatter_
    description: The in-place version of `masked_scatter()`.
    for:
      - masked_scatter_
    labels:
      - aten
    kind:
      - tensor
    stages:
      - stable: '4.2'
  - id: masked_select
    description: |
      Returns a new 1-D tensor which indexes the `input` tensor according to
      the boolean mask `mask` which is a BoolTensor.
    for:
      - masked_select
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.1'
  - id: matmul_bias_activation
    description: Fused matrix multiplication with bias addition and ReLU activation.
    for:
      - matmul_bias_activation
    labels:
      - KernelGen
    kind:
      - BLAS
    stages:
      - alpha: '5.4'
  - id: matmuladd
    description: Computes matrix multiplication followed by bias addition.
    for:
      - matmuladd
    labels:
      - fused
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: max
    description: Returns the maximum value of all elements in the `input` tensor.
    for:
      - max
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '2.0'
    cpp: '4.0'
  - id: max_dim
    description: |
      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).
    for:
      - max.dim
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '2.0'
    cpp: '4.0'
  - id: max_pool2d_backward
    description: |
      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.
    for:
      - max_pool2d_backward
    labels:
      - aten
    kind:
      - IR
    stages:
      - stable: '4.0'
  - id: max_pool2d_with_indices
    description: |
      Applies a 2D max pooling over an input signal composed of several input planes.
      This is an IR representation rather than a public API.
    for:
      - max_pool2d_with_indices
    labels:
      - aten
    kind:
      - IR
    stages:
      - stable: '4.0'
  - id: max_pool2d_with_indices_backward
    description: |
      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.
    for:
      - max_pool2d_with_indices_backward
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: max_pool3d_backward
    description: The backward version of `max_pool2d_with_indices()`.
    for:
      - nn.functional.max_pool3d
    labels:
      - aten
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: max_pool3d_with_indices
    description: Applies a 3D max pooling over an input signal composed of several input planes.
    for:
      - nn.functional.max_pool3d
    labels:
      - aten
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: max_unpool2d
    description: Computes a partial inverse of `MaxPool2d`.
    for:
      - max_unpool2d
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: max_unpool3d
    description: Triton kernel implementation for max_unpool3d.
    for:
      - max_unpool3d
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: maximum
    description: Computes the element-wise maximum of `input` and `other`.
    for:
      - maximum
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.1'
  - id: mean
    description: Returns the mean value of all elements in the `input` tensor. Input must be floating point or complex.
    for:
      - mean
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '1.0'
  - id: mean_dim
    description: |
      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.
    for:
      - mean.dim
    labels:
      - aten
    kind:
      - Reduction
    stages:
      - stable: '2.0'
  - id: median
    description: Returns the median of the values in `input`.
    for:
      - median
    labels:
      - aten
      - KernelGen
      - Reduction
    kind:
      - LinearAlg
    stages:
      - beta: '5.4'
  - id: median_dim
    description: |
      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.
    for:
      - median.dim
    labels:
      - aten
      - KernelGen
      - Reduction
    kind:
      - LinearAlg
    stages:
      - beta: '5.4'
  - id: median_dim_values
    description: A variant of `median_dim()` with the `out` argument.
    for:
      - median.dim_values
    labels:
      - aten
      - KernelGen
      - Reduction
    kind:
      - LinearAlg
    stages:
      - beta: '5.4'
  - id: median_out
    description: A variant of `median()` with the `out` argument.
    for:
      - median.out
    labels:
      - aten
      - KernelGen
      - Reduction
    kind:
      - LinearAlg
    stages:
      - beta: '5.4'
  - id: mhc_bwd
    description: |
      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.
    for:
      - mhc_bwd
    labels:
      - fused
      - vLLM
      - DSA
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: mhc_post
    description: Triton implementation of mHC Post operator (optimized v3).
    for:
      - mhc_post
    labels:
      - fused
      - vLLM
      - DSA
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: mhc_pre
    description: Triton implementation of mHC Pre operator (optimized v2).
    for:
      - vllm.model_executor.layers.mhc.mhc_pre
    labels:
      - fused
      - vLLM
      - DSA
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: min
    description: Returns the minimum value of all elements in the `input` tensor.
    for:
      - min
    labels:
      - aten
      - Reduction
    kind:
      - Tensor
    stages:
      - stable: '2.0'
  - id: min_dim
    description: |
      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).
    for:
      - min.dim
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '2.0'
  - id: minimum
    description: Computes the element-wise minimum of `input` and `other`.
    for:
      - minimum
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.1'
  - id: miopen_batch_norm_backward
    description: Triton kernel implementation for miopen_batch_norm_backward.
    for:
      - miopen_batch_norm_backward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: mish
    description: Applies the Mish activation function element-wise.
    for:
      - mish
    labels:
      - aten
      - KernelGen
      - pointwise
      - Activation
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: mish_
    description: The in-place version of `mish()`.
    for:
      - mish_
    labels:
      - aten
      - KernelGen
      - pointwise
      - Activation
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: mish_backward
    description: |
      Computes the gradient of Mish activation with respect to the input.
    for:
      - mish_backward
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: mm
    description: Performs a matrix multiplication of the two input matrices.
    for:
      - mm
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '1.0'
    cpp: '4.0'
  - id: mm_out
    description: A variant of `mm()` with `out` specified.
    for:
      - mm.out
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '3.0'
    cpp: '4.0'
  - id: mode
    description: 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.
    for:
      - mode
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - beta: '5.3'
  - id: moe_align_block_size_triton
    description: |
      Aligns the token distribution across experts to be compatible with block size
      for matrix multiplication.
    for:
      - _moe_C.align_block_size
    labels:
      - fused
      - Reduction
      - vLLM
    kind:
      - MoE
    stages:
      - beta: '4.0'
      - stable: '4.2'
  - id: moe_sum
    description: |
      An implementation of Mixture of Experts (MoE) with sum-based aggregation
      instead of the more common weighted average.
    for:
      - _moe_C.moe_sum
    labels:
      - fused
      - Reduction
      - vLLM
    kind:
      - MoE
    stages:
      - stable: '4.2'
  - id: mse_loss
    description: Compute the element-wise mean squared error, with optional weighting.
    for:
      - mse_loss
    labels:
      - aten
      - pointwise
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: mse_loss_backward
    description: Compute the gradient of mean squared error loss with respect to the input.
    for:
      - mse_loss_backward
    labels:
      - aten
      - NeuralNetwork
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: mul
    description: Multiplies `input` by `other`.
    for:
      - mul.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '1.0'
  - id: mul_
    description: The in-place version of `mul()`.
    for:
      - mul_.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: multinomial
    description: |
      Returns a tensor where each row contains `num_samples` indices sampled
      from the multinomial probability distribution located in the corresponding row
      of tensor `input`.
    for:
      - multinomial
    labels:
      - aten
      - skip_precision_check
    kind:
      - Distribution
    stages:
      - stable: '2.1'
  - id: multiply_
    description: In-place multiplication using Triton kernel (alias for mul_). Supports tensor-tensor and tensor-scalar operations.
    for:
      - multiply_
      - multiply_.Scalar
      - multiply_.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: mv
    description: Performs a matrix-vector product of the matrix `input` and the vector `vec`.
    for:
      - mv
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '2.0'
  - id: mvlgamma_
    description: Computes the multivariate log-gamma function in-place for each element of the input tensor.
    for:
      - mvlgamma_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: nan_to_num
    description: |
      Replaces `NaN`, positive infinity, and negative infinity values in `input`
      with the values specified by `nan`, `posinf`, and `neginf`, respectively.
    for:
      - nan_to_num
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '3.0'
  - id: nanmedian
    description: Returns the median of the values in `input`, ignoring `NaN` values.
    for:
      - nanmedian
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - beta: '5.4'
  - id: nanmedian_dim
    description: |
      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.
    for:
      - nanmedian.dim
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - beta: '5.4'
  - id: nanmedian_dim_values
    description: A variant of `nanmedian_dim()` with the `out` argument.
    for:
      - nanmedian.dim_values
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - beta: '5.4'
  - id: nanmedian_out
    description: A variant of `nanmedian()` with the `out` argument.
    for:
      - nanmedian.out
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - beta: '5.4'
  - id: nansum
    description: |
      Returns the sum of all elements in the `input` tensor, treating `NaN` values as zero.
      Supports global reduction and reduction along specified dimensions.
    for:
      - nansum
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - beta: '5.4'
  - id: nansum_out
    description: |
      A variant of `nansum()` with the `out` argument.
    for:
      - nansum.out
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - beta: '5.4'
  - id: narrow
    description: Pure layout operation (narrow); returns a zero-copy view sharing storage with the input.
    for:
      - narrow
    labels:
      - aten
      - KernelGen
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: narrow_copy
    description: Triton kernel implementation for narrow_copy.
    for:
      - narrow_copy
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: native_batch_norm_legit_functional
    description: >
      Functional version of batch normalization that returns the saved mean and
      inverse standard deviation, along with updated running estimates.
    for:
      - _native_batch_norm_legit_functional
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: native_layer_norm
    description: Apply native layer normalization using the existing implementation.
    for:
      - native_layer_norm
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: ne
    description: Computes that `input` is not equal to `other` element-wise.
    for:
      - ne.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: ne_scalar
    description: The scalar version of `ne()`.
    for:
      - ne.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: neg
    description: Returns a new tensor with the negative of the elements of `input`.
    for:
      - neg
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: neg_
    description: The in-place version of `neg()`.
    for:
      - neg_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: negative
    description: "negative operator"
    for:
      - negative
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: nested_view_from_buffer_copy
    description: |
      Creates a nested tensor from a flat buffer using component sizes, strides,
      and offsets, with a Metax backend specialization.
    for:
      - _nested_view_from_buffer_copy
    labels:
      - aten
      - KernelGen
      - Metax
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: new_full
    description: |
      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.
    for:
      - new_full.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: new_ones
    description: |
      Returns a Tensor of size `size` filled with 1, with the
      same `torch.dtype` and `torch.device` as the input tensor.
    for:
      - new_ones
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: nextafter
    description: Return the next floating-point value after input towards other, elementwise.
    for:
      - nextafter
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: nextafter_
    description: |
      Returns the next representable floating-point value from `input` toward
      `other`, elementwise. In-place version of `nextafter`.
    for:
      - nextafter_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: nll_loss2d_backward
    description: |
      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.
    for:
      - nll_loss2d_backward
    labels:
      - aten
      - IR
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: nll_loss2d_forward
    description: |
      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.
    for:
      - nll_loss2d_forward
    labels:
      - aten
      - IR
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: nll_loss_backward
    description: Compute the negative log likelihood loss. This is the backward case.
    for:
      - nll_loss_backward
    labels:
      - aten
      - IR
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: nll_loss_forward
    description: Compute the negative log likelihood loss. This is the forward case.
    for:
      - nll_loss_forward
    labels:
      - aten
      - IR
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: nll_loss_nd_backward
    description: |
      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.
    for:
      - nll_loss_nd_backward
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - stable: '5.0'
  - id: nll_loss_nd_forward
    description: |
      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.
    for:
      - nll_loss_nd_forward
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - stable: '5.0'
  - id: nonzero
    description: |
      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.
    for:
      - nonzero
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.1'
    cpp: '4.0'
  - id: nonzero_numpy
    description: |
      Returns a tuple of 1-D tensors, one for each dimension, containing the indices of
      the nonzero elements in the input tensor (NumPy-style).
    for:
      - nonzero_numpy
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.3'
  - id: nonzero_static
    description: |
      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`.
    for:
      - nonzero_static
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: nonzero_static_out
    description: |
      A variant of `nonzero_static` that writes the fixed-size result to `out`.
    for:
      - nonzero_static.out
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: norm
    description: |
      Computes the norm of vectors, matrices, and tensors.
    for:
      - norm
    labels:
      - aten
      - KernelGen
      - reduction
    kind:
      - Reduction
    stages:
      - alpha: '5.4'
  - id: norm_scalar
    description: A variant of `norm` that computes the norm over all elements.
    for:
      - norm.Scalar
    labels:
      - aten
      - KernelGen
      - reduction
    kind:
      - Reduction
    stages:
      - alpha: '5.4'
  - id: norm_scalaropt_dim
    description: A variant of `norm` that computes the norm along specified dimensions.
    for:
      - norm.ScalarOpt_dim
    labels:
      - aten
      - KernelGen
      - reduction
    kind:
      - Reduction
    stages:
      - alpha: '5.4'
  - id: normal_
    description: Random sampling operator (normal_).
    for:
      - normal_
    labels:
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - alpha: '5.3'
  - id: normal_float_float_
    description: |
      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`.
    for:
      - normal_
    labels:
      - aten
      - pointwise
      - skip_precision_check
    kind:
      - Distribution
    stages:
      - stable: '5.0'
  - id: normal_float_tensor
    description: |
      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`.
    for:
      - normal.float_Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Distribution
    stages:
      - stable: '2.1'
  - id: normal_tensor_float
    description: |
      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`.
    for:
      - normal.Tensor_float
    labels:
      - aten
      - pointwise
    kind:
      - Distribution
    stages:
      - stable: '2.1'
  - id: normal_tensor_tensor
    description: |
      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`.
    for:
      - normal.Tensor_Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Distribution
    stages:
      - stable: '2.1'
  - id: normed_cumsum
    description: |
      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.
    for:
      - normed_cumsum
    labels:
      - aten
    kind:
      - Reduction
    stages:
      - stable: '2.1'
  - id: not_equal
    description: |
      Computes the element-wise logical NOT EQUAL of the given input tensors.
    for:
      - not_equal.Tensor
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Logic
    stages:
      - alpha: '5.4'
  - id: not_equal_scalar
    description: |
      Computes the element-wise logical NOT EQUAL comparing a tensor to a scalar.
    for:
      - not_equal.Scalar
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Logic
    stages:
      - alpha: '5.4'
  - id: one_hot
    description: |
      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.
    for:
      - one_hot
    labels:
      - aten
      - nn.functional
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - stable: '5.0'
  - id: ones
    description: |
      Returns a tensor filled with the scalar value 1, with the shape defined
      by the variable argument `size`.
    for:
      - ones
    labels:
      - aten
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - stable: '2.1'
  - id: ones_like
    description: Returns a tensor filled with the scalar value 1, with the same size as `input`.
    for:
      - ones_like
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.1'
  - id: outer
    description: |
      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`.
    for:
      - outer.Tensor
    labels:
      - fused
    kind:
      - BLAS
    stages:
      - stable: '2.0'
  - id: outplace_fused_experts
    description: This operator allocates and returns a new output tensor.
    for:
      - outplace_fused_experts
    labels:
      - fused
      - Activation
      - vLLM
    kind:
      - MoE
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: pack_seq_triton
    description: Pack variable-length token sequences into a padded batched tensor.
    for:
      - pack_seq_triton
    labels:
      - fused
      - vLLM
      - DeepSeekV4
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: pad
    description: This pads a tenor using the specified mode.
    for:
      - pad
    labels:
      - aten
      - pointwise
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.1'
  - id: pairwise_distance
    description: |
      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.
    for:
      - pairwise_distance
    labels:
      - aten
      - nn.functional
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: pdist
    description: |
      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.
    for:
      - pdist
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: pdist_backward
    description: Computes the gradient of pairwise distance computation.
    for:
      - _pdist_backward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: per_token_group_quant_fp8
    description: |
      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.
    for:
      - _C.per_token_group_fp8_quant
    labels:
      - NoCPU
      - vLLM
    kind:
      - Quantization
    stages:
      - alpha: '4.2'
      - beta: '5.3'
  - id: pdist_forward
    description: Computes the pairwise distance between rows of a matrix.
    for:
      - _pdist_forward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: permute_copy
    description: Creates and returns a copy of x with permuted dimensions.
    for:
      - permute_copy
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: pixel_shuffle
    description: Rearranges elements in a tensor to a new tensor of different shape.
    for:
      - pixel_shuffle
    labels:
      - aten
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: pixel_unshuffle
    description: |
      Rearranges elements from a low-resolution feature map with many channels
      into a higher-resolution feature map with fewer channels.
    for:
      - pixel_unshuffle
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: pixel_unshuffle_out
    description: A variant of `pixel_unshuffle` that assigns the output to the `out` tensor.
    for:
      - pixel_unshuffle.out
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
  - id: poisson
    description: |
      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`.
    for:
      - poisson
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: polar
    description: |
      Constructs a complex tensor whose elements are Cartesian coordinates corresponding to
      the polar coordinates with absolute value `abs` and angle `angle`.
    for:
      - polar
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '3.0'
  - id: polygamma
    description: |
      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.
    for:
      - polygamma
    labels:
      - aten
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: polygamma_
    description: The in-place version of `polygamma()`.
    for:
      - polygamma_
    labels:
      - aten
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: polygamma_out
    description: A variant of `polygamma` that allows the output to be assigned to the `out` tensor.
    for:
      - polygamma.out
    labels:
      - aten
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: pow_scalar
    description: |
      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.
    for:
      - pow.Scalar
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '1.0'
  - id: pow_tensor_scalar
    description: |
      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.
    for:
      - pow.Tensor_Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '1.0'
  - id: pow_tensor_scalar_
    description: This is the in-place version of `pow_tensor_scalar()`.
    for:
      - pow_.Scalar
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: pow_tensor_tensor
    description: |
      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.
    for:
      - pow.Tensor_Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '1.0'
  - id: pow_tensor_tensor_
    description: This is the in-place version of `pow_tensor_tensor()`.
    for:
      - pow_.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: prelu
    description: |
      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.
    for:
      - prelu
    labels:
      - aten
      - Activation
      - pointwise
      - nn.functional
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: prelu_kernel
    description: |
      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.
    for:
      - _prelu_kernel
    labels:
      - aten
      - Activation
      - pointwise
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: prelu_kernel_backward
    description: |
      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.
    for:
      - _prelu_kernel_backward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.1'
  - id: prod
    description: Returns the product of all elements in the `input` tensor.
    for:
      - prod
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '2.0'
  - id: prod_dim_int
    description: Returns the product of each row of the `input` tensor in the given dimension `dim`.
    for:
      - prod.dim_int
    kind:
      - Reduction
    stages:
      - stable: '2.0'
    labels:
      - aten
  - id: quantile
    description: Computes the q-th quantiles of each row of the `input` tensor along the dimension `dim`.
    for:
      - quantile
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: rad2deg
    description: |
      Converts each element from angles in radians to degrees.
    for:
      - rad2deg
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: rad2deg_
    description: |
      In-place version of rad2deg.
    for:
      - rad2deg_
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: rand
    description: Returns a tensor filled with random numbers from a uniform distribution on the interval `[0,1)`.
    for:
      - rand
    labels:
      - aten
    kind:
      - Distribution
    stages:
      - stable: '2.1'
  - id: rand_like
    description: |
      Returns a tensor with the same size as `input` that is filled with random numbers
      from a uniform distribution on the interval `[0,1)`.
    for:
      - rand_like
    labels:
      - aten
    kind:
      - Distribution
    stages:
      - stable: '2.1'
  - id: randint
    description: Returns a tensor filled with random integers generated uniformly between low (inclusive) and high (exclusive).
    for:
      - randint
    labels:
      - aten
      - KernelGen
    kind:
      - Distribution
    stages:
      - stable: '5.1'
  - id: randint_like
    description: |
      Returns a tensor with the same size as `input` that is filled with random integers
      generated uniformly between `0` (inclusive) and `high` (exclusive).
    for:
      - randint_like
    labels:
      - aten
      - KernelGen
    kind:
      - Distribution
    stages:
      - alpha: '5.4'
  - id: randn
    description: |
      Returns a tensor filled with random numbers from a normal distribution with mean 0
      and variance 1 (also called the standard normal distribution).
    for:
      - randn
    labels:
      - aten
    kind:
      - Distribution
    stages:
      - stable: '2.1'
  - id: randn_like
    description: |
      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.
    for:
      - randn_like
    labels:
      - aten
    kind:
      - Distribution
    stages:
      - stable: '2.1'
  - id: random_
    description: Random sampling operator (random_).
    for:
      - random_
    labels:
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - alpha: '5.1'
  - id: randperm
    description: Returns a random permutation of integers from `0` to `n - 1`.
    for:
      - randperm
    labels:
      - aten
      - skip_precision_check
    kind:
      - Distribution
    stages:
      - stable: '2.2'
  - id: range
    description: |
      Returns a 1-D tensor of size `floor(end - start) + 1` with values from `start` to
      `end` with step `1`.
    for:
      - range
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: reciprocal
    description: Returns a new tensor with the reciprocal of the elements of `input`.
    for:
      - reciprocal
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '1.0'
  - id: reciprocal_
    description: This is the in-place version of `reciprocal()`.
    for:
      - reciprocal_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: reflection_pad1d
    description: |
      Pads the input 3D or 2D tensor (typically representing signals or sequences)
      by reflecting the boundary values at the edges.
    for:
      - reflection_pad1d
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: reflection_pad1d_backward
    description: Computes the gradient of reflection_pad1d with respect to the input tensor.
    for:
      - reflection_pad1d_backward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: reflection_pad1d_out
    description: A variant of `reflection_pad1d` that assigns the output to `out` tensor.
    for:
      - reflection_pad1d.out
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: reflection_pad2d
    description: |
      Pads the input 3D or 2D tensor (typically representing signals or sequences)
      by reflecting the boundary values at the both edges.
    for:
      - reflection_pad2d
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: reflection_pad2d_out
    description: A variant of `reflection_pad2d` that assigns the output to `out` tensor.
    for:
      - reflection_pad2d.out
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: reflection_pad2d_backward
    description: Computes the gradient of reflection_pad2d with respect to the input tensor.
    for:
      - reflection_pad2d_backward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: reflection_pad3d
    description: |
      Pads the input 5D tensor by reflecting the boundary values at both edges
      along the last three spatial dimensions (depth, height, width).
    for:
      - reflection_pad3d
      - reflection_pad3d.out
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: reflection_pad3d_backward
    description: Computes the gradient of reflection_pad3d with respect to the input tensor.
    for:
      - reflection_pad3d_backward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.1'
  - id: reglu
    description: |
      Rectified Gated Linear Unit is a variant of GLU that uses ReLU instead of the sigmoid function for gating.
    for:
      - reglu
    labels:
      - fused
      - Transformer
    kind:
      - NeuralNetwork
    stages:
      - alpha: '4.2'
      - beta: '5.3'
  - id: relu
    description: Apply the RELU (Rectified Linear Unit) activation function element-wise.
    for:
      - relu
    labels:
      - aten
      - Activation
      - pointwise
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - stable: '1.0'
  - id: relu6
    description: |
      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.
    for:
      - relu6
    labels:
      - aten
      - pointwise
      - Activation
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: relu_
    description: This is the in-place version of `relu()`.
    for:
      - relu_
    labels:
      - aten
      - pointwise
      - Activation
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: remainder
    description: |
      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`.
    for:
      - remainder
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: remainder_scalar
    description: |
      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`.
    for:
      - remainder.Scalar
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: remainder_scalar_
    description: This is the in-place version of `remainder()`.
    for:
      - remainder_.Scalar
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: remainder_scalar_tensor
    description: |
      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`.
    for:
      - remainder.Scalar_Tensor
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: remainder_tensor
    description: |
      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`.
    for:
      - remainder.Tensor
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: remainder_tensor_
    description: This is the in-place version of `remainder()`.
    for:
      - remainder_.Tensor
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: renorm
    description: >
      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.

    for:
      - renorm
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: renorm_
    description: The in-place version of `renorm()`.
    for:
      - renorm_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: repeat
    description: Repeats this tensor along the specified dimensions.
    for:
      - repeat
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.1'
  - id: repeat_interleave_self_int
    description: Repeats elements of a tensor. The number of repetitions is specified as an integer `repeats`.
    for:
      - repeat_interleave.self_int
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: repeat_interleave_self_tensor
    description: |
      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.
    for:
      - repeat_interleave.self_Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: repeat_interleave_tensor
    description: Repeats 0 `repeats[0]` times, 1 `repeats[1]` times, 2 `repeats[2]` times, etc.
    for:
      - repeat_interleave.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: replication_pad1d
    description: Pads the edge of a 1D input tensor by repeating the boundary values.
    for:
      - replication_pad1d
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.0'
      - stable: '5.4'
  - id: replication_pad1d_out
    description: A variant of `replication_pad1d` that assigns the output to the `out` tensor.
    for:
      - replication_pad1d.out
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.0'
      - stable: '5.4'
  - id: replication_pad2d
    description: Pads the edge of a 2D input tensor by repeating the boundary values.
    for:
      - replication_pad2d
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: replication_pad2d_out
    description: A variant of `replication_pad2d` that assigns the output to the `out` tensor.
    for:
      - replication_pad2d.out
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: replication_pad3d
    description: Pads the edge of a 3D input tensor by repeating the boundary values.
    for:
      - replication_pad3d
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.0'
      - beta: '5.3'
  - id: replication_pad3d_backward
    description: |
      Accumulates output gradients into the clamped input positions used by
      three-dimensional replication padding.
    for:
      - replication_pad3d_backward
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: reshape_and_cache
    description: Store the key/value token states into the pre-allcated kv_cache buffers of paged attention.
    for:
      - reshape_and_cache
    labels:
      - fused
      - vLLM
    kind:
      - Attention
    stages:
      - stable: '3.0'
  - id: reshape_and_cache_flash
    description: Store the key/value token states into the pre-allcated kv_cache buffers of paged attention.
    for:
      - reshape_and_cache_flash
    labels:
      - fused
    kind:
      - Attention
    stages:
      - stable: '3.0'
    cpp: '4.0'
  - id: resize
    description: Resizes the input tensor to the specified size.
    for:
      - resize
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: resize_
    description: The in-place version of `resize()`.
    for:
      - resize_
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: resize_as
    description: Triton kernel implementation for resize_as.
    for:
      - resize_as
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: resize_as_
    description: The in-place version of `resize_as()`.
    for:
      - resize_as_
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: resize_output
    description: |
      Resizes tensor output storage and copies overlapping elements.
    for:
      - _resize_output
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: resolve_conj
    description: |
      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.
    for:
      - resolve_conj
    labels:
      - aten
    kind:
      - Science
    stages:
      - stable: '2.1'
  - id: resolve_neg
    description: |
      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.
    for:
      - resolve_neg
    labels:
      - aten
    kind:
      - Science
    stages:
      - stable: '2.1'
  - id: rms_norm
    description: |
      Apply Root Mean Square Layer Normalization over a mini-batch of inputs.
    for:
      - RMSNorm
    labels:
      - aten
      - nn.functional
      - Reduction
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.0'
    cpp: '4.0'
  - id: rnn_relu
    description: Triton kernel implementation for rnn_relu.
    for:
      - rnn_relu
    labels:
      - aten
      - KernelGen
      - NoCPU
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: roll
    description: |
      Roll the tensor input along the given dimension(s). Elements that are shifted beyond the last position
      are re-introduced at the first position.
    for:
      - roll
    labels:
      - aten
      - KernelGen
    kind:
      - BLAS
    stages:
      - beta: '5.3'
  - id: rot90
    description: Triton kernel implementation for rot90.
    for:
      - rot90
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: round
    description: Rounds elements of input to the nearest integer.
    for:
      - round
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: round_
    description: The inplace version of `round`.
    for:
      - round_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: round_out
    description: A variant of `round` that assigns the output to the specifiec `out`.
    for:
      - round.out
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: rrelu_with_noise_backward
    description: |
      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.
    for:
      - rrelu_with_noise_backward
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
  - id: rrelu_with_noise_functional
    description: |
      Triton kernel implementation for rrelu_with_noise_functional.
    for:
      - rrelu_with_noise_functional
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: rsqrt
    description: Returns a new tensor with the reciprocal of the square-root of each of the elements of `input`.
    for:
      - rsqrt
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '1.0'
  - id: rsqrt_
    description: The in-place version of `rsqrt()`.
    for:
      - rsqrt_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: rsub_scalar
    description: Substracts `other`, scaled by `alpha`, from `input`. This is the scalar version.
    for:
      - rsub.Scalar
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: rsub_tensor
    description: Substracts `other`, scaled by `alpha`, from `input`. This is the tensor version.
    for:
      - rsub.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: rwkv_ka_fusion
    description: |
      Merges, aligns, and enhances features from different data sources or spatial directions
      using the efficient, linear-time RWKV framework.
    for:
      - rwkv_ka_fusion
    labels:
      - fused
    kind:
      - RWKV
    stages:
      - stable: '4.1'
    cpp: '4.0'
  - id: rwkv_mm_sparsity
    description: Optimized, lossless sparse matrix multiplication in RWKV-7 models.
    for:
      - rwkv_mm_sparsity
    labels:
      - fused
    kind:
      - RWKV
    stages:
      - stable: '4.1'
    cpp: '4.0'
  - id: safe_softmax
    description: |
      Apply a softmax function. Note this version may not be functional.
    for:
      - _safe_softmax
    labels:
      - aten
      - IR
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.3'
  - id: scaled_dot_product_attention
    description: |
      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.
    for:
      - scaled_dot_product_attention
    labels:
      - nn.functional
      - Attention
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: scaled_dot_product_attention_backward
    description: The backward case for `scaled_dot_product_attention`.
    for:
      - scaled_dot_product_attention_backward
    labels:
      - nn.functional
      - Attention
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: scaled_dot_product_attention_forward
    description: The forward case for `scaled_dot_product_attention`.
    for:
      - scaled_dot_product_attention_forward
    labels:
      - nn.functional
      - Attention
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: scaled_dot_product_cudnn_attention_backward
    description: |
      Backward kernel for FlashAttention, computing gradients of queries, keys, values, and attention outputs efficiently.
    for:
      - _scaled_dot_product_cudnn_attention_backward
    labels:
      - aten
      - NoCPU
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.4'
  - id: scaled_dot_product_efficient_attention_backward
    description: |
      Backward kernel for FlashAttention, computing gradients of queries, keys, values, and attention outputs efficiently.
    for:
      - _scaled_dot_product_efficient_attention_backward
    labels:
      - aten
      - NoCPU
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.4'
  - id: scaled_dot_product_flash_attention
    description: Run the scaled dot product FlashAttention forward operation.
    for:
      - _scaled_dot_product_flash_attention
    labels:
      - aten
      - NoCPU
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: scaled_dot_product_flash_attention_backward
    description: |
      Backward kernel for FlashAttention, computing gradients of queries, keys, values, and attention outputs efficiently.
    for:
      - _scaled_dot_product_flash_attention_backward
    labels:
      - aten
      - NoCPU
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.4'
  - id: scaled_dot_product_fused_attention_overrideable
    description: >
      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.
    for:
      - _scaled_dot_product_fused_attention_overrideable
    labels:
      - aten
      - Attention
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: scaled_grouped_mm
    description: |
      Performs grouped matrix multiplication with row-wise and column-wise scaling,
      commonly used by quantized Mixture-of-Experts (MoE) workloads.
    for:
      - _scaled_grouped_mm
    labels:
      - MoE
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.4'
  - id: scaled_mm
    description: |
      Performs a scaled matrix multiplication. The result of `self @ mat2` is
      multiplied by `scale_a` and `scale_b`, then an optional bias is added.
    for:
      - _scaled_mm
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - beta: '5.4'
  - id: scaled_mm_out
    description: A variant of `_scaled_mm` that writes the result into `out`.
    for:
      - _scaled_mm.out
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - beta: '5.4'
  - id: scaled_softmax_backward
    description: |
      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.
    for:
      - scaled_softmax_backward
    labels:
      - aten
    kind:
      - Reduction
    stages:
      - stable: '4.2'
  - id: scaled_softmax_forward
    description: |
      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.
    for:
      - scaled_softmax_forward
    labels:
      - aten
    kind:
      - Reduction
    stages:
      - stable: '4.2'
  - id: scatter_add
    description: |
      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.
    for:
      - scatter_add
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: scatter_add_
    description: |
      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`.
    for:
      - scatter_add_
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '4.2'
  - id: scatter_reduce
    description: |
      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`.
    for:
      - scatter.reduce
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: scatter_reduce_
    description: This is the in-place version of `scatter_reduce()`.
    for:
      - scatter_.reduce
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - stable: '3.0'
  - id: scatter_reduce_two_
    description: |
      A specific low-level ATen operator primarily encountered during model compilation
      or when using advanced backends like TensorRT or MPS.
    for:
      - scatter_reduce_.two
    labels:
      - aten
      - KernelGen
    kind:
      - Reduction
    stages:
      - alpha: '5.3'
  - id: scatter_src
    description: |
      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`.
    for:
      - scatter.src
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: scatter_src_
    description: This is the in-place version of `scatter_src()`.
    for:
      - scatter_.src
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '3.0'
  - id: searchsorted
    description: |
      Finds insertion indices for tensor values in sorted innermost-dimension boundaries.
    for:
      - searchsorted.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.4'
  - id: searchsorted_out
    description: A variant of `searchsorted.Tensor` that assigns the result to `out`.
    for:
      - searchsorted.Tensor_out
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.4'
  - id: searchsorted_scalar
    description: |
      Finds insertion indices for a scalar value in one-dimensional sorted boundaries.
    for:
      - searchsorted.Scalar
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.4'
  - id: searchsorted_scalar_out
    description: A variant of `searchsorted.Scalar` that assigns the result to `out`.
    for:
      - searchsorted.Scalar_out
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.4'
  - id: segment_reduce
    description: |
      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.
    for:
      - segment_reduce
    labels:
      - aten
    kind:
      - Reduction
    stages:
      - beta: '5.4'
  - id: segment_reduce_backward
    description: Computes gradients for `segment_reduce` with lengths or offsets based segment definitions.
    for:
      - _segment_reduce_backward
    labels:
      - aten
    kind:
      - Reduction
    stages:
      - beta: '5.4'
  - id: segment_reduce_backward_out
    description: |
      A variant of `_segment_reduce_backward` that assigns the gradient input to the `out` tensor.
    for:
      - _segment_reduce_backward.out
    labels:
      - aten
    kind:
      - Reduction
    stages:
      - beta: '5.4'
  - id: segment_reduce_out
    description: |
      A variant of `segment_reduce` that assigns the reduced segments to the `out` tensor.
    for:
      - segment_reduce.out
    labels:
      - aten
    kind:
      - Reduction
    stages:
      - beta: '5.4'
  - id: select_backward
    description: Calculate the gradient during the backward pass in the neural network.
    for:
      - select_backward
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: select_scatter
    description: |
      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.
    for:
      - select_scatter
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: selu
    description: |
      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.
    for:
      - selu
    labels:
      - aten
      - pointwise
      - nn.functional
      - Activation
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: selu_
    description: |
      This is the in-place version of `selu`.
    for:
      - selu_
    labels:
      - aten
      - pointwise
      - Activation
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: sgn
    description: |
      Computes the sign of each element in the input tensor, element-wise.
      This function extends `sign()` to complex tensors.
    for:
      - sgn
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: sgn_
    description: |
      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.
    for:
      - sgn_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: sgn_out
    description: |
      Writes the element-wise sign of the input tensor to the `out` tensor.
      This function extends `sign()` to complex tensors.
    for:
      - sgn.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: scalar_tensor
    description: |
      Creates a 0-dimensional (scalar) tensor from a Python numeric value.
      The tensor's dtype can be specified, otherwise inferred from the input value.
    for:
      - scalar_tensor
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: sigmoid
    description: Computes the expit (also known as the logistic sigmoid function) of the elements of `input`.
    for:
      - sigmoid
    labels:
      - aten
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.0'
  - id: sigmoid_
    description: The in-place version of `sigmoid()`.
    for:
      - sigmoid_
    labels:
      - aten
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: sigmoid_backward
    description: The backward version of `sigmoid()`.
    for:
      - sigmoid_backward
    labels:
      - aten
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: sign
    description: |
      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).
    for:
      - sign
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: sign_out
    description: |
      Out-variant of sign. Writes the element-wise sign to the `out` tensor.
    for:
      - sign.out
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: signbit
    description: Tests if each element of `input` has its sign bit set or not.
    for:
      - signbit
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: signbit_out
    description: A variant of `signbit` that assigns the output to `out`.
    for:
      - signbit.out
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: silu
    description: |
      SiLU (Sigmoid Linear Unit), a simple approximation of ReLU but
      without any discontinuity of the first derivative.
    for:
      - silu
    labels:
      - aten
      - pointwise
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - stable: '1.0'
  - id: silu_
    description: The in-place version of `silu()`.
    for:
      - silu_
    labels:
      - aten
      - nn.functional
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: silu_and_mul
    description: A custom operator in vLLM as activation function for SwiGLU.
    for:
      - silu_and_mul
    labels:
      - fused
      - pointwise
      - vLLM
    kind:
      - Activation
    stages:
      - stable: '2.0'
  - id: silu_and_mul_out
    description: A variant of `silu_and_mul` with an extra `out` argument.
    for:
      - silu_and_mul.out
    labels:
      - fused
      - pointwise
      - vLLM
    kind:
      - Activation
    stages:
      - stable: '2.0'
  - id: silu_and_mul_with_clamp
    description: A custom operator in vLLM as activation function for SwiGLU.
    for:
      - silu_and_mul_with_clamp
    labels:
      - fused
      - pointwise
      - vLLM
    kind:
      - Activation
    stages:
      - stable: '5.3'
  - id: silu_and_mul_with_clamp_out
    description: A variant of `silu_and_mul_with_clamp` with an extra `out` argument.
    for:
      - silu_and_mul_with_clamp.out
    labels:
      - fused
      - pointwise
      - vLLM
    kind:
      - Activation
    stages:
      - stable: '5.3'
  - id: silu_backward
    description: A variant of `silu()` for backward case.
    for:
      - silu_backward
    labels:
      - aten
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: sin
    description: |
      Returns a new tensor with the sine of the elements in the `input` tensor,
      where each value in this input tensor is in radians.
    for:
      - sin
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: sin_
    description: The in-place version of `sin()`.
    for:
      - sin_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: sinc
    description: |
      Computes the normalized sinc function `sin(π·x) / (π·x)` for each element of the input.
    for:
      - sinc
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: sinc_
    description: The in-place version of `sinc()`.
    for:
      - sinc_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: sinh
    description: |
      Computes the hyperbolic sine (e^x - e^{-x}) / 2 element-wise.
    for:
      - sinh
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: sinh_
    description: |
      Computes the hyperbolic sine `(e^x-e^{-x})/2` of each element in a tensor.
      This is an in-place version.
    for:
      - sinh_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: skip_layer_norm
    description: |
      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.
    for:
      - skip_layer_norm
    labels:
      - fused
      - Transformer
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.0'
  - id: slice_backward
    description: |
      An automatic differentiation (autograd) function that computes the gradient of a tensor slicing operation
      (`tensor[start:end]`) during backpropagation.
    for:
      - slice_backward
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - stable: '5.0'
  - id: slice_scatter
    description: |
      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.
    for:
      - slice_scatter
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: smooth_l1_loss
    description: Compute the smooth L1 loss between input and target tensors.
    for:
      - smooth_l1_loss
    labels:
      - aten
      - pointwise
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.3'
  - id: smooth_l1_loss_backward
    description: Compute the gradient of smooth L1 loss with respect to the input tensor.
    for:
      - smooth_l1_loss_backward
    labels:
      - aten
      - pointwise
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.3'
  - id: soft_margin_loss
    description: Compute the soft margin loss.
    for:
      - soft_margin_loss
    labels:
      - nn.functional
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: soft_margin_loss_backward
    description: >
      Backward pass for soft margin loss, a two-class classification
      logistic loss between input and target tensors.
    for:
      - soft_margin_loss_backward
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: softmax
    description: Apply a softmax function.
    for:
      - _softmax
    labels:
      - aten
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - stable: '1.0'
    cpp: '4.0'
  - id: softmax_backward
    description: The backward version of `softmax()`.
    for:
      - _softmax_backward_data
    labels:
      - aten
      - nn.functional
    kind:
      - Reduction
    stages:
      - stable: '3.0'
  - id: softmax_backward_out
    description: A variant of `softmax_backward()`.
    for:
      - _softmax_backward_data_out
    labels:
      - aten
      - nn.functional
    kind:
      - Reduction
    stages:
      - stable: '3.0'
  - id: softmax_out
    description: Apply a softmax function, with given `out`.
    for:
      - _softmax.out
    labels:
      - aten
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - stable: '1.0'
  - id: softplus
    description: Applies element-wise, the function Softplus.
    for:
      - softplus
    labels:
      - aten
      - nn.functional
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '4.0'
  - id: softplus_backward
    description: The backward version of `softplus()`.
    for:
      - softplus_backward
    labels:
      - aten
      - Activation
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: softshrink
    description: |
      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.
    for:
      - softshrink
    labels:
      - aten
      - nn.functional
      - Activation
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: softshrink_out
    description: |
      This is a variant of `softshrink` that supports an output tensor.
    for:
      - softshrink.out
    labels:
      - aten
      - nn.functional
      - Activation
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: sort
    description: Sorts the elements of the `input` tensor along a given dimension in ascending order by value.
    for:
      - sort
    labels:
      - aten
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: sort_stable
    description: |
      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.
    for:
      - sort.stable
    labels:
      - aten
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - stable: '3.0'
  - id: sparse_attn_triton
    description: Sparse attention with attention-sink.
    for:
      - None
    labels:
      - fused
      - NoCPU
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: sparse_mla_fwd_interface
    description: |
      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.
    for:
      - sparse_mla_fwd
    labels:
      - fused
    kind:
      - DSA
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: sparse_semi_structured_mm
    description: >
      Performs a sparse semi-structured matrix multiplication of a dense matrix
      with a 2:4 sparsity pattern against a dense matrix.
    for:
      - _sparse_semi_structured_mm
    labels:
      - aten
      - KernelGen
    kind:
      - BLAS
  - id: special_bessel_j1
    description: |
      Computes the Bessel function of the first kind of order 1 for each element of input.
    for:
      - special_bessel_j1
    labels:
      - aten
      - KernelGen
      - pointwise
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_airy_ai
    description: |
      Computes the Airy function Ai(x) for each element of the input tensor.
    for:
      - special_airy_ai
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_airy_ai_out
    description: |
      A variant of `special_airy_ai` with output saved to provided `out`.
    for:
      - special_airy_ai.out
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_bessel_j0
    description: |
      Computes the Bessel function of the first kind of order 0 for each element
      of `input`.
    for:
      - special.bessel_j0
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_chebyshev_polynomial_u
    description: |
      Computes the Chebyshev polynomial of the second kind U_n(x) for each element
      of the input tensor.
    for:
      - special_chebyshev_polynomial_u
      - special_chebyshev_polynomial_u.n_scalar
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_chebyshev_polynomial_v
    description: |
      Triton kernel implementation for special_chebyshev_polynomial_v.
    for:
      - special_chebyshev_polynomial_v
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_chebyshev_polynomial_w
    description: |
      Computes the Chebyshev polynomial of the fourth kind
      :math:`W_{n}(\\text{input})`.
    for:
      - special.chebyshev_polynomial_w
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_chebyshev_polynomial_w_out
    description: |
      A variant of `special_chebyshev_polynomial_w()` with output saved to
      provided `out`.
    for:
      - special.chebyshev_polynomial_w.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_scaled_modified_bessel_k1
    description: |
      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.
    for:
      - special.scaled_modified_bessel_k1
      - special.scaled_modified_bessel_k1.out
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_digamma
    description: |
      Computes the digamma function (logarithmic derivative of the gamma function).
      Alias for digamma; delegates to the digamma kernel.
    for:
      - special_digamma
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_erfcx
    description: |
      Computes the scaled complementary error function for each element of input.
    for:
      - special.erfcx
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_erfinv
    description: |
      Computes the inverse error function element-wise.
      Maps values in (-1, 1) to the real line.
    for:
      - special_erfinv
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_erfinv_
    description: The in-place version of `special_erfinv()`.
    for:
      - special_erfinv_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_erfc
    description: Computes the complementary error function.
    for:
      - special_erfc
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_erfinv_out
    description: A variant of `special_erfinv()` that assigns the output to the `out` tensor.
    for:
      - special_erfinv.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_gammainc
    description: |
      Computes the regularized lower incomplete gamma function P(a, x) element-wise.
    for:
      - special.gammainc
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_gammaln
    description: Computes the logarithm of the absolute value of the Gamma function on input.
    for:
      - special.gammaln
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_gammaln_out
    description: Out-of-place variant of special_gammaln that writes the result to the out tensor.
    for:
      - special.gammaln.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_hermite_polynomial_h
    description: |
      Computes the physicist's Hermite polynomial H_n(x) of degree n at input.
    for:
      - special_hermite_polynomial_h
    kind:
      - Math
    labels:
      - aten
      - KernelGen
    stages:
      - alpha: '5.1'
  - id: special_i0e
    description: |
      Computes the exponentially scaled zeroth order modified Bessel function
      of the first kind for each element of `input`.
    for:
      - special_i0e
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: special_i0e_out
    description: |
      A variant of `special_i0e()` with output saved to provided `out`..
    for:
      - special_i0e.out
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: special_i1
    description: |
      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.
    for:
      - special_i1
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: special_i1_out
    description: A variant of `special_i1` that allows the output to be assigned to another tensor.
    for:
      - special_i1.out
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: special_legendre_polynomial_p
    description: |
      Computes the Legendre polynomial P_n(x) of degree n for each element in the input tensor,
      designed for special mathematical functions.
    for:
      - special.legendre_polynomial_p
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_log_softmax
    description: |
      Applies the log of the softmax function along a given dimension.
    for:
      - special.log_softmax
  - id: special_log1p
    description: Computes log(1 + x) for each element of the input tensor.
    for:
      - special_log1p
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_log1p_out
    description: A variant of `special.log1p` that allows the output to be assigned to another tensor.
    for:
      - special_log1p.out
    labels:
      - aten
      - nn.functional
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_modified_bessel_k0
    description: Triton kernel implementation for special_modified_bessel_k0.
    for:
      - special_modified_bessel_k0
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_modified_bessel_k0_out
    description: Triton kernel implementation for special_modified_bessel_k0.out.
    for:
      - special_modified_bessel_k0.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_modified_bessel_k1
    description: Modified Bessel function of the second kind of order 1.
    for:
      - special_modified_bessel_k1
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_modified_bessel_k1_out
    description: A variant of `special_modified_bessel_k1` that allows the output to be assigned to another tensor.
    for:
      - special_modified_bessel_k1.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_round
    description: |
      Rounds a tensor to the nearest integer, with ties rounding to the nearest
      even value (banker's rounding).
    for:
      - special.round
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_round_out
    description: |
      A variant of `special_round()` with output saved to provided `out`.
    for:
      - special.round.out
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_shifted_chebyshev_polynomial_u
    description: |
      Computes the shifted Chebyshev polynomial of the second kind U_n^*(x)
      for each pair of elements in `x` and `n`.
    for:
      - special_shifted_chebyshev_polynomial_u
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_shifted_chebyshev_polynomial_u_
    description: |
      Inplace variant of `special_shifted_chebyshev_polynomial_u`.
    for:
      - special_shifted_chebyshev_polynomial_u_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
  - id: special_shifted_chebyshev_polynomial_w
    kind:
      - Math
    labels:
      - aten
      - KernelGen
    description: |
      Computes the shifted Chebyshev polynomial of the second kind W_n(x).
    for:
      - special.shifted_chebyshev_polynomial_w
    stages:
      - alpha: '5.4'
  - id: special_shifted_chebyshev_polynomial_v
    description: |
      Computes the shifted Chebyshev polynomial of the third kind V_n^*(x).
    for:
      - special_shifted_chebyshev_polynomial_v
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_sinc
    description: Computes sin(pi * x) / (pi * x) for each element of `input`.
    for:
      - special.sinc
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_xlog1py
    description: |
      Computes `x * log1p(y)` for each element pair in the input tensors `x` and `y`.
    for:
      - special.xlog1py
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: special_logsumexp
    description: |
      Computes the natural logarithm of the sum of exponentials of each row
      of the input tensor in the given dimension `dim`.
    for:
      - special.logsumexp
    labels:
      - aten
      - KernelGen
    kind:
      - Reduction
    stages:
      - alpha: '5.4'
  - id: split_with_sizes_copy
    description: |
      Splits a tensor into sub-tensors along a given dimension,
      where each split has a specified size. Always returns copies.
    for:
      - split_with_sizes_copy
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: sqrt
    description: Returns a new tensor with the square-root of the elements of `input`.
    for:
      - sqrt
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '4.0'
  - id: sqrt_
    description: This is the in-place version of `sqrt()`.
    for:
      - sqrt_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '4.0'
  - id: square
    description: Returns a new tensor with the square of the elements of input.
    for:
      - square
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: square_
    description: The inplace version of `square`.
    for:
      - square_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: square_out
    description: A variant of `square` that assigns the output to the provided `out`.
    for:
      - square.out
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - beta: '5.3'
  - id: squeeze_copy
    description: Triton kernel implementation for squeeze_copy.
    for:
      - squeeze_copy
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: stack
    description: Concatenates a sequence of tensors along a new dimension.
    for:
      - stack
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: stage_deepseek_v4_mega_moe_inputs
    description: |
      Stages DeepSeekV4 Mega-MoE inputs by quantizing hidden states to FP8
      with UE8M0 scales and copying top-k indices and weights to output buffers.
    for:
      - stage_deepseek_v4_mega_moe_inputs
    labels:
      - fused
      - DeepSeekV4
      - MoE
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: std
    description: |
      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.
    for:
      - std.correction
    labels:
      - aten
    kind:
      - Reduction
    stages:
      - stable: '4.0'
  - id: sub
    description: Subtracts `other`, scaled by `alpha`, from the `input` tensor.
    for:
      - sub.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '1.0'
  - id: sub_
    description: |
      Subtracts `other`, scaled by `alpha`, from the `input` tensor.
      This is the in-place version.
    for:
      - sub_.Tensor
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: subtract
    description: Subtracts `other`, scaled by `alpha`, from `input`.
    for:
      - subtract.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: subtract_
    description: In-place version of subtract. Subtracts other, scaled by alpha, from input.
    for:
      - subtract_.Tensor
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: sum
    description: Returns the sum of all elements in the `input` tensor.
    for:
      - sum
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '2.0'
    cpp: '4.0'
  - id: sum_dim
    description: |
      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.
    for:
      - sum.dim_IntList
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '2.0'
    cpp: '4.0'
  - id: sum_dim_out
    description: A variant of `sum_dim()` with the `out` argument.
    for:
      - sum.IntList_out
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '3.0'
    cpp: '4.0'
  - id: sum_out
    description: A variant of `sum()` with the `out` argument.
    for:
      - sum.out
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '3.0'
    cpp: '4.0'
  - id: swiglu
    description: Swish-Gated Linear Unit, a variant of GLU with the Swish activation function.
    for:
      - swiglu
    labels:
      - fused
      - Transformer
    kind:
      - NeuralNetwork
    stages:
      - stable: '5.0'
  - id: sym_stride
    description: Returns the stride of the input tensor as a tuple of integers. Used for torch.compile symbolic tracing.
    for:
      - sym_stride
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: t_copy
    description: Transpose a 2D tensor into a new tensor with contiguous memory layout.
    for:
      - t_copy
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: t_copy_out
    description: A variant of `t_copy()` that allows the output to be assigned to the `out` tensor.
    for:
      - t_copy.out
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: take
    description: |
      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.
    for:
      - take
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: take_out
    description: |
      Out-variant of take. Writes the gathered elements into the `out` tensor,
      resizing it to the shape of `index` if needed.
    for:
      - take.out
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: tan
    description: |
      Returns a new tensor with the tangent of the elements in the `input` tensor,
      where each value in this `input` tensor is in radians.
    for:
      - tan
    labels:
      - aten
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '4.1'
  - id: tan_
    description: This is the in-place version of `tan()`.
    for:
      - tan_
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - stable: '4.1'
  - id: tanh
    description: Returns a new tensor with the hyperbolic tangent of the elements of `input`.
    for:
      - tanh
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.0'
  - id: tanh_
    description: This is the in-place version of `tanh()`.
    for:
      - tanh_
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '2.2'
  - id: tanh_backward
    description: This is the backward case for `tanh()`.
    for:
      - tanh_backward
    labels:
      - aten
      - pointwise
    kind:
      - Math
    stages:
      - stable: '3.0'
  - id: te_rmsnorm_bwd
    description: |
      RMSNorm backward pass aligned with TransformerEngine's rmsnorm_bwd signature.
      Computes gradients dx (w.r.t. input) and dgamma (w.r.t. weight).
    for:
      - te_rmsnorm_bwd
    labels:
      - fused
      - Normalization
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: te_rmsnorm_fwd
    description: |
      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).
    for:
      - te_rmsnorm_fwd
    labels:
      - fused
      - Normalization
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: tensor_split
    description: |
      Splits a tensor into multiple sub-tensors along a given dimension,
      using either a number of sections or a list of split indices.
    for:
      - tensor_split
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.3'
  - id: thnn_fused_lstm_cell
    description: Fused LSTM cell computation with optional input and hidden biases.
    for:
      - _thnn_fused_lstm_cell
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: thnn_fused_lstm_cell_backward_impl
    description: |
      Computes gradients for the fused LSTM cell operation (_thnn_fused_lstm_cell).
    for:
      - _thnn_fused_lstm_cell_backward_impl
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: threshold
    description: Apply a threshold to each element of the input Tensor.
    for:
      - threshold
    labels:
      - aten
      - nn.functional
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: threshold_
    description: >
      In-place version of threshold(). Thresholds each element of the input Tensor.
    for:
      - threshold_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: threshold_backward
    description: This is the backward version for `threshold`.
    for:
      - threshold_backward
    labels:
      - aten
      - nn.functional
      - pointwise
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: tile
    description: |
      Constructs a tensor by repeating the elements of `input`.
      The `dims` argument specifies the number of repetitions in each dimension.
    for:
      - tile
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.1'
  - id: to_copy
    for:
      - _to_copy
    condition:
      - var: torch.version
        op: ge
        val: '2.4'
    labels:
      - aten
      - pointwise
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - beta: '4.1'
      - stable: '5.3'
  - id: top_k_per_row_decode
    description: |
      Triton top-K per row for DeepSeek V4 decode-phase token selection.
      Radix-select based approach with three dispatch tiers for different vocab sizes.
    for:
      - None
    labels:
      - fused
      - vLLM
      - DeepSeekV4
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: top_k_per_row_prefill
    description: |
      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.
    for:
      - None
    labels:
      - fused
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: topk
    description: |
      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.
    for:
      - topk
    labels:
      - aten
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - stable: '2.1'
    cpp: '4.0'
  - id: topk_softmax
    description: |
      Selects the k most likely next-token candicates, sets all others to zero,
      and renormalize the prbabilities of these top candidates.
    for:
      - _moe_C.topk_softmax
    labels:
      - fused
      - vLLM
    kind:
      - MoE
    stages:
      - stable: '4.0'
  - id: topk_softplus_sqrt
    description: |
      Fused softplus + sqrt + top-k selection and optional renormalization
      for MoE gating in models like DeepSeek-V3/V4.
    for:
      - topk_softplus_sqrt
    labels:
      - fused
      - KernelGen
      - vLLM
    kind:
      - MoE
    stages:
      - beta: '5.3'
  - id: trace
    description: Returns the sum of the elements of the diagonal of the input 2-D matrix.
    for:
      - trace
    labels:
      - aten
    kind:
      - Reduction
    stages:
      - stable: '4.0'
  - id: transpose
    description: |
      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.
    for:
      - transpose.int
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.1'
  - id: tril
    description: |
      Returns the lower triangular part of an input matrix (or a batch of matrices) and
      sets all other elements to zero.
    for:
      - tril
    labels:
      - aten
      - KernelGen
    kind:
      - BLAS
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: tril_
    description: |
      The in-place version of `tril()`.
    for:
      - tril_
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - beta: '5.3'
  - id: tril_out
    description: |
      A variant of `tril()` that explicitly assigns the output to the `out` parameter.
    for:
      - tril.out
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - beta: '5.3'
  - id: triton_lighting_indexer_k_tiled_interface
    description: Part of FP8 MQA framework. It is currently not exposed as an operator for use.
    for:
      - None
    labels:
      - fused
      - DSA
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.3'
  - id: triu
    description: |
      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.
    for:
      - triu
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '1.0'
  - id: triu_
    description: The in-place version of `triu()`.
    for:
      - triu_
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - stable: '5.0'
  - id: trunc
    description: Rounds each element of the input tensor to the nearest integer towards zero.
    for:
      - trunc
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: trunc_
    description: The in-place version of `trunc()`.
    for:
      - trunc_
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: trunc_divide
    description: The `div` function with rounding_mode set to `trunc`.
    for:
      - div
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.1'
  - id: trunc_divide_
    description: The in-place version of `trunc_divide`.
    for:
      - div
    labels:
      - aten
    kind:
      - Math
    stages:
      - stable: '2.1'
  - id: unbind
    description: Pure layout operation (unbind); returns zero-copy views sharing storage with the input.
    for:
      - unbind.int
    labels:
      - aten
      - KernelGen
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: unbind_copy
    description: Removes a tensor dimension and returns a tuple of all slices along a given dimension as copies.
    for:
      - unbind_copy
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: unfold
    description: Return a view of the tensor with a sliding window along the given dimension.
    for:
      - unfold
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: unfold_backward
    description: |
      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.
    for:
      - unfold_backward
    labels:
      - aten
      - nn.functional
    kind:
      - NeuralNetwork
    stages:
      - stable: '5.0'
  - id: unfold_copy
    description: >
      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.

    for:
      - unfold_copy
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: uniform_
    description: Fills `self` tensor with numbers sampled from the continuous uniform distribution.
    for:
      - uniform_
    labels:
      - aten
      - skip_precision_check
    kind:
      - Distribution
    stages:
      - stable: '2.1'
  - id: unique2
    description: Returns the unique elements of the input tensor. This is an internal PyTorch function.
    for:
      - _unique2
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.1'
  - id: unique_consecutive
    description: Eliminates all but the first element from every consecutive group of equivalent elements.
    for:
      - unique_consecutive
    labels:
      - aten
      - KernelGen
    kind:
      - Distribution
    stages:
      - beta: '5.3'
  - id: unique_dim
    description: Returns the unique slices of the input tensor along a dimension.
    for:
      - unique_dim
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - beta: '5.4'
  - id: unpack_seq_triton
    description: Unpack a packed sequence tensor back to its original variable-length form.
    for:
      - unpack_seq_triton
    labels:
      - fused
      - vLLM
      - DeepSeekV4
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.3'
  - id: unsqueeze
    description: Returns a new tensor with a dimension of size one inserted at the specified position.
    for:
      - unsqueeze
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: unsqueeze_
    description: In-place version of `unsqueeze()`.
    for:
      - unsqueeze_
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: unsafe_masked_index
    description: Gathers elements from self at given indices where mask is True, filling unmasked positions with a scalar value.
    for:
      - _unsafe_masked_index
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: unsafe_masked_index_put_accumulate
    description: |
      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.
    for:
      - _unsafe_masked_index_put_accumulate
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: unsafe_view
    description: |
      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.
    for:
      - _unsafe_view
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: upsample_bicubic2d
    description: A variant of `upsample()` that has `mode` set to `bicubic`.
    for:
      - upsample_bicubic2d
    labels:
      - aten
      - Reduction
    kind:
      - NeuralNetwork
    stages:
      - stable: '5.0'
  - id: upsample_bicubic2d_aa
    description: A variant of `upsample()` that has `mode` set to `bicubic`.
    for:
      - _upsample_bicubic2d_aa
    labels:
      - aten
      - Reduction
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: upsample_bicubic2d_aa_backward
    description: A backward case for `_upsample_bicubic2d_aa()`.
    for:
      - _upsample_bicubic2d_aa_backward
    labels:
      - aten
      - Reduction
    kind:
      - NeuralNetwork
    stages:
      - stable: '5.0'
  - id: upsample_bilinear2d_aa
    description: Upsamples the input, using bilinear mode with anti-aliasing.
    for:
      - _upsample_bilinear2d_aa
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.1'
  - id: upsample_linear1d
    description: |
      Upsamples the `input`, using linear mode.
      The input has to be 3 dimensional, and the `output_size` is an optional tuple of ints.
    for:
      - upsample_linear1d
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.0'
      - beta: '5.3'
  - id: upsample_linear1d_backward
    description: A backward case for `upsample_linear1d()`.
    for:
      - upsample_linear1d_backward
    labels:
      - aten
      - Reduction
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: upsample_nearest1d
    description: |
      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.
    for:
      - upsample_nearest1d
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - stable: '5.0'
  - id: upsample_nearest2d
    description: |
      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`.
    for:
      - upsample_nearest2d
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: upsample_nearest3d
    description: |
      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.
    for:
      - upsample_nearest3d
    labels:
      - aten
    kind:
      - NeuralNetwork
    stages:
      - stable: '5.0'
  - id: upsample_nearest_exact1d
    description: |
      Increases the length of a 1D tensor using nearest-neighbor interpolation,
      ensuring the output aligns with library-standard algorithms like PIL.
    for:
      - _upsample_nearest_exact1d
    labels:
      - aten
      - Reduction
    kind:
      - NeuralNetwork
    stages:
      - beta: '5.0'
  - id: upsample_nearest_exact2d
    description: Triton kernel implementation for _upsample_nearest_exact2d.
    for:
      - _upsample_nearest_exact2d
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - stable: '5.3'
  - id: upsample_nearest_exact2d_backward
    description: A backward case for `_upsample_nearest_exact2d()`.
    for:
      - _upsample_nearest_exact2d_backward
    labels:
      - aten
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.4'
  - id: upsample_nearest_exact3d
    description: |
      Increases the depth, height, and width of a 3D tensor using nearest-neighbor interpolation,
      ensuring the output aligns with library-standard algorithms like PIL.
    for:
      - _upsample_nearest_exact3d
    labels:
      - aten
      - NeuralNetwork
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - alpha: '5.1'
  - id: upsample_trilinear3d
    description: Upsamples the input (NCDHW) using trilinear interpolation.
    for:
      - upsample_trilinear3d
    labels:
      - aten
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: var
    description: Calculates the variance over all dimensions.
    for:
      - var
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: var_correction
    description: |
      A variant of the `var()` operator, with an optional `correction` for specifying
      difference between the sample size and sample degrees of freedom.
    for:
      - var.correction
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: var_dim
    description: Calculates the variance over the dimensions specified by dim.
    for:
      - var.dim
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - beta: '5.3'
  - id: var_mean
    description: |
      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.
    for:
      - var_mean.correction
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
    stages:
      - stable: '2.0'
  - id: vdot
    description: Computes the dot product of two 1D vectors along a dimension.
    for:
      - vdot
    labels:
      - aten
    kind:
      - BLAS
    stages:
      - stable: '2.2'
  - id: vector_norm
    description: Computes a vector norm.
    for:
      - linalg.vector_norm
    labels:
      - aten
      - Reduction
    kind:
      - LinearAlg
      - NeuralNetwork
    stages:
      - stable: '2.0'
  - id: view_copy
    description: |
      Returns a copy of the tensor with the specified shape.
      Unlike view(), this always returns a new tensor rather than an alias.
    for:
      - view_copy
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - alpha: '5.4'
  - id: vstack
    description: Stack tensors in sequence vertically (row wise).
    for:
      - vstack
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.2'
  - id: w8a8_block_fp8_matmul
    description: Performs matrix multiplication with block-wise quantization.
    for:
      - vllm.model_executor.layers.quantization.utils.fp8_utils.w8a8_block_fp8_matmul
    labels:
      - vLLM
    kind:
      - BLAS
    stages:
      - alpha: '5.3'
  - id: _weight_norm
    description: |
      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.
    for:
      - _weight_norm
    labels:
      - aten
      - fused
      - KernelGen
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: weight_norm
    description: |
      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.
    for:
      - weight_norm
    labels:
      - fused
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: weight_norm_interface
    description: |
      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.
    for:
      - _weight_norm_interface
    labels:
      - aten
      - fused
    kind:
      - NeuralNetwork
    stages:
      - stable: '2.2'
  - id: weight_norm_interface_backward
    description: |
      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.
    for:
      - _weight_norm_interface_backward
    labels:
      - aten
      - fused
    kind:
      - NeuralNetwork
    stages:
      - stable: '3.0'
  - id: where_self
    description: |
      Returns a LongTensor. This operation is identical to `torch.nonzero(condition, as_tuple=True)`.
    for:
      - where.self
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - stable: '2.1'
  - id: where_self_out
    description: This is a variant of `where_self()` with an argument `out`.
    for:
      - where.self_out
    labels:
      - aten
      - pointwise
    kind:
      - Tensor
    stages:
      - alpha: '2.1'
      - stable: '2.2'
  - id: zero
    description: Fills tensor with zeros.
    for:
      - zero.Tensor_out
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: zero_
    description: Fills `self` tensor with zeros.
    for:
      - zero_.Tensor
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '5.0'
  - id: zero_out
    description: Fills tensor with zeros but assign the output to the `out` tensor.
    for:
      - zero.Tensor_out
    labels:
      - aten
      - KernelGen
    kind:
      - Tensor
    stages:
      - beta: '5.0'
      - stable: '5.3'
  - id: xor__
    description: |
      Computes the bitwise XOR of input tensors or a tensor and a scalar.
    for:
      - __xor__
      - __xor__.Tensor
      - __xor__.Scalar
      - __ixor__.Tensor
      - __ixor__.Scalar
    labels:
      - aten
      - pointwise
      - KernelGen
    kind:
      - Math
    stages:
      - alpha: '5.4'
  - id: zeros
    description: |
      Returns a tensor filled with the scalar value 0, with the shape defined by
      the variable argument `size`.
    for:
      - zeros
    labels:
      - aten
      - skip_precision_check
    kind:
      - Tensor
    stages:
      - stable: '2.1'
    cpp: '4.0'
  - id: zeros_like
    description: Returns a tensor filled with the scalar value 0, with the same size as `input`.
    for:
      - zeros_like
    labels:
      - aten
    kind:
      - Tensor
    stages:
      - stable: '2.1'