onnxscript 0.7.2.dev20260701__tar.gz → 0.7.2.dev20260710__tar.gz

{onnxscript-0.7.2.dev20260701/onnxscript.egg-info → onnxscript-0.7.2.dev20260710}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnxscript
-Version: 0.7.2.dev20260701
+Version: 0.7.2.dev20260710
 Summary: Naturally author ONNX functions and models using a subset of Python
 Author-email: Microsoft Corporation <onnx@microsoft.com>
 License: MIT License
@@ -27,7 +27,7 @@ License: MIT License
         
 Project-URL: Homepage, https://microsoft.github.io/onnxscript/
 Project-URL: Repository, https://github.com/microsoft/onnxscript
-Project-URL: Commit, https://github.com/microsoft/onnxscript/tree/c210193a0f45375c6eb7311a7371a8905124c992
+Project-URL: Commit, https://github.com/microsoft/onnxscript/tree/e6fad72c99db6a5639ab8ee9bd9c04c9039c1cb0
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{onnxscript-0.7.2.dev20260701 → onnxscript-0.7.2.dev20260710}/onnxscript/function_libs/torch_lib/ops/core.py

@@ -8218,7 +8218,7 @@ def _aten_remainder(self: TTensor, other: TTensor, integer: bool) -> TTensor:
     return op.Sub(self, op.Mul(rounded_quotient, other))
 
 
-@torch_op("aten::remainder.Tensor", trace_only=True)
+@torch_op(("aten::remainder.Tensor", "prims::remainder"), trace_only=True)
 def aten_remainder(self: TTensor, other: TTensor) -> TTensor:
     """remainder.Tensor(Tensor self, Tensor other) -> Tensor"""
 

{onnxscript-0.7.2.dev20260701 → onnxscript-0.7.2.dev20260710}/onnxscript/function_libs/torch_lib/ops/nn.py

@@ -1835,7 +1835,7 @@ def aten_scaled_dot_product_attention(
     if is_causal:
         attn_mask = _causal_attention_mask(query, key)
 
-    if enable_gqa:
+    if enable_gqa and query.shape[1] != key.shape[1]:
         key, value = _attention_repeat_kv_for_group_query(query, key, value)
 
     if attn_mask is None:

{onnxscript-0.7.2.dev20260701 → onnxscript-0.7.2.dev20260710}/onnxscript/onnx_opset/__init__.py

@@ -39,11 +39,15 @@ from onnxscript.onnx_opset._impl.opset21 import Opset21
 from onnxscript.onnx_opset._impl.opset22 import Opset22
 from onnxscript.onnx_opset._impl.opset23 import Opset23
 from onnxscript.onnx_opset._impl.opset24 import Opset24
+from onnxscript.onnx_opset._impl.opset25 import Opset25
+from onnxscript.onnx_opset._impl.opset26 import Opset26
+from onnxscript.onnx_opset._impl.opset27 import Opset27
 from onnxscript.onnx_opset._impl.opset_ai_onnx_ml1 import Opset_ai_onnx_ml1
 from onnxscript.onnx_opset._impl.opset_ai_onnx_ml2 import Opset_ai_onnx_ml2
 from onnxscript.onnx_opset._impl.opset_ai_onnx_ml3 import Opset_ai_onnx_ml3
 from onnxscript.onnx_opset._impl.opset_ai_onnx_ml4 import Opset_ai_onnx_ml4
 from onnxscript.onnx_opset._impl.opset_ai_onnx_ml5 import Opset_ai_onnx_ml5
+from onnxscript.onnx_opset._impl.opset_ai_onnx_preview1 import Opset_ai_onnx_preview1
 from onnxscript.values import Opset
 
 __all__ = [
@@ -72,11 +76,15 @@ __all__ = [
     "opset22",
     "opset23",
     "opset24",
+    "opset25",
+    "opset26",
+    "opset27",
     "opset_ai_onnx_ml1",
     "opset_ai_onnx_ml2",
     "opset_ai_onnx_ml3",
     "opset_ai_onnx_ml4",
     "opset_ai_onnx_ml5",
+    "opset_ai_onnx_preview1",
 ]
 
 
@@ -110,11 +118,15 @@ opset21 = Opset21()
 opset22 = Opset22()
 opset23 = Opset23()
 opset24 = Opset24()
+opset25 = Opset25()
+opset26 = Opset26()
+opset27 = Opset27()
 opset_ai_onnx_ml1 = Opset_ai_onnx_ml1()
 opset_ai_onnx_ml2 = Opset_ai_onnx_ml2()
 opset_ai_onnx_ml3 = Opset_ai_onnx_ml3()
 opset_ai_onnx_ml4 = Opset_ai_onnx_ml4()
 opset_ai_onnx_ml5 = Opset_ai_onnx_ml5()
+opset_ai_onnx_preview1 = Opset_ai_onnx_preview1()
 all_opsets: Mapping[Tuple[str, int], Opset] = {
     (
         "",
@@ -212,6 +224,18 @@ all_opsets: Mapping[Tuple[str, int], Opset] = {
         "",
         24,
     ): opset24,
+    (
+        "",
+        25,
+    ): opset25,
+    (
+        "",
+        26,
+    ): opset26,
+    (
+        "",
+        27,
+    ): opset27,
     (
         "ai.onnx.ml",
         1,
@@ -232,4 +256,8 @@ all_opsets: Mapping[Tuple[str, int], Opset] = {
         "ai.onnx.ml",
         5,
     ): opset_ai_onnx_ml5,
+    (
+        "ai.onnx.preview",
+        1,
+    ): opset_ai_onnx_preview1,
 }

{onnxscript-0.7.2.dev20260701 → onnxscript-0.7.2.dev20260710}/onnxscript/onnx_opset/_impl/opset1.py

@@ -2118,6 +2118,9 @@ class Opset1(Opset):
 
 
         Given a matrix, apply Lp-normalization along the provided axis.
+        The output is computed as: `output = input / Lp_norm(input, axis)`.
+        When the Lp norm is zero (i.e., all elements along the axis are zero),
+        the output is defined to be zero to avoid division by zero.
 
 
         Args:
@@ -4036,9 +4039,16 @@ class Opset1(Opset):
         r"""[🌐 Transpose(1)](https://onnx.ai/onnx/operators/onnx__Transpose.html#transpose-1 "Online Documentation")
 
 
-        Transpose the input tensor similar to numpy.transpose. For example, when
-        perm=(1, 0, 2), given an input tensor of shape (1, 2, 3), the output shape
-        will be (2, 1, 3).
+        Returns a transpose of the input tensor. (Similar to `numpy.transpose`).
+        The optional attribute `perm` must be a permutation of the dimensions of
+        the input tensor. Axis `i` of the output tensor corresponds to the axis
+        `perm[i]` of the input tensor.
+        For example, when perm=(1, 0, 2), given an input tensor of shape (1, 2, 3),
+        the output shape will be (2, 1, 3).
+        When perm=(1, 2, 0), given an input tensor of shape (1, 2, 3),
+        the output shape will be (2, 3, 1).
+        If the attribute `perm` is omitted, its default value is `(n-1, ..., 0)`,
+        where `n` is the rank of the input tensor.
 
 
         Args:

{onnxscript-0.7.2.dev20260701 → onnxscript-0.7.2.dev20260710}/onnxscript/onnx_opset/_impl/opset10.py

@@ -539,6 +539,7 @@ class Opset10(Opset9):
 
         Filter out boxes that have high intersection-over-union (IOU) overlap with previously selected boxes.
         Bounding boxes with score less than score_threshold are removed. Bounding box format is indicated by attribute center_point_box.
+        Boxes are suppressed if their IOU with a previously selected box is strictly greater than iou_threshold (i.e., boxes with IOU exactly equal to the threshold are kept).
         Note that this algorithm is agnostic to where the origin is in the coordinate system and more generally is invariant to
         orthogonal transformations and translations of the coordinate system; thus translating or reflections of the coordinate system
         result in the same boxes being selected by the algorithm.

{onnxscript-0.7.2.dev20260701 → onnxscript-0.7.2.dev20260710}/onnxscript/onnx_opset/_impl/opset11.py

@@ -846,7 +846,7 @@ class Opset11(Opset10):
         ::
 
             intermediate_zero_point = qmin - min(x)/y_scale
-            y_zero_point = cast(round(saturate(itermediate_zero_point)))
+            y_zero_point = cast(round(saturate(intermediate_zero_point)))
 
 
 
@@ -1586,7 +1586,7 @@ class Opset11(Opset10):
         1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
            be referenced in the inputs of the loop.
         2) Any values computed in the loop body that needs to be used in a subsequent
-           iteration or after the loop are modelled using a pair of variables in the loop-body,
+           iteration or after the loop are modeled using a pair of variables in the loop-body,
            consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
            These are referred to as loop-carried dependences. The loop operation node
            supplies the input value of the input variable for the first iteration, and
@@ -1901,6 +1901,7 @@ class Opset11(Opset10):
 
         Filter out boxes that have high intersection-over-union (IOU) overlap with previously selected boxes.
         Bounding boxes with score less than score_threshold are removed. Bounding box format is indicated by attribute center_point_box.
+        Boxes are suppressed if their IOU with a previously selected box is strictly greater than iou_threshold (i.e., boxes with IOU exactly equal to the threshold are kept).
         Note that this algorithm is agnostic to where the origin is in the coordinate system and more generally is invariant to
         orthogonal transformations and translations of the coordinate system; thus translating or reflections of the coordinate system
         result in the same boxes being selected by the algorithm.
@@ -1920,7 +1921,8 @@ class Opset11(Opset10):
                 Default to 0, which means no output.
 
             iou_threshold: (optional) Float representing the threshold for deciding
-                whether boxes overlap too much with respect to IOU. It is scalar. Value
+                whether boxes overlap too much with respect to IOU. Boxes with IoU
+                strictly greater than this threshold are suppressed. It is scalar. Value
                 range [0, 1]. Default to 0.
 
             score_threshold: (optional) Float representing the threshold for deciding
@@ -2190,15 +2192,12 @@ class Opset11(Opset10):
         up to `limit` (exclusive).
 
         The number of elements in the output of range is computed as below:
-
         ::
 
             number_of_elements = max( ceil( (limit - start) / delta ) , 0 )
 
 
-
         The pseudocode determining the contents of the output is shown below:
-
         ::
 
             for(int i=0; i<number_of_elements; ++i) {
@@ -2206,18 +2205,14 @@ class Opset11(Opset10):
             }
 
 
-
-        Example 1
-
+        Example 1:
         ::
 
             Inputs: start = 3, limit = 9, delta = 3
             Output: [3, 6]
 
 
-
-        Example 2
-
+        Example 2:
         ::
 
             Inputs: start = 10, limit = 4, delta = -2
@@ -3130,7 +3125,7 @@ class Opset11(Opset10):
             output = np.copy(data)
             update_indices = indices.shape[:-1]
             for idx in np.ndindex(update_indices):
-                output[indices[idx]] = updates[idx]
+                output[tuple(indices[idx])] = updates[idx]
 
         The order of iteration in the above loop is not specified.
         In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].

{onnxscript-0.7.2.dev20260701 → onnxscript-0.7.2.dev20260710}/onnxscript/onnx_opset/_impl/opset13.py

@@ -590,6 +590,8 @@ class Opset13(Opset12):
 
         This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check `Broadcasting in ONNX <https://github.com/onnx/onnx/blob/master/docs/Broadcasting.md>`_.
 
+        For integer inputs, the result is computed using truncating division (rounding toward zero).
+
 
         Args:
             A: (differentiable) First operand.
@@ -700,21 +702,7 @@ class Opset13(Opset12):
         op = Op(self, "Equal", schema)
         return op(*self._prepare_inputs(schema, A, B))
 
-    T_Erf = TypeVar(
-        "T_Erf",
-        BFLOAT16,
-        DOUBLE,
-        FLOAT,
-        FLOAT16,
-        INT16,
-        INT32,
-        INT64,
-        INT8,
-        UINT16,
-        UINT32,
-        UINT64,
-        UINT8,
-    )
+    T_Erf = TypeVar("T_Erf", BFLOAT16, DOUBLE, FLOAT, FLOAT16)
 
     def Erf(self, input: T_Erf) -> T_Erf:
         r"""[🌐 Erf(13)](https://onnx.ai/onnx/operators/onnx__Erf.html#erf-13 "Online Documentation")
@@ -1741,7 +1729,7 @@ class Opset13(Opset12):
         1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
            be referenced in the inputs of the loop.
         2) Any values computed in the loop body that needs to be used in a subsequent
-           iteration or after the loop are modelled using a pair of variables in the loop-body,
+           iteration or after the loop are modeled using a pair of variables in the loop-body,
            consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
            These are referred to as loop-carried dependences. The loop operation node
            supplies the input value of the input variable for the first iteration, and
@@ -2810,17 +2798,22 @@ class Opset13(Opset12):
                 which to reduce. The default is to reduce over empty axes. When axes is
                 empty (either not provided or explicitly empty), behavior depends on
                 'noop_with_empty_axes': reduction over all axes if
-                'noop_with_empty_axes' is false, or no reduction is applied if
-                'noop_with_empty_axes' is true (but other operations will be performed).
-                Accepted range is [-r, r-1] where r = rank(data).
+                'noop_with_empty_axes' is false, and reduction over the empty set of
+                axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1]
+                where r = rank(data).
 
             keepdims: Keep the reduced dimension or not, default 1 means keep reduced
                 dimension.
 
             noop_with_empty_axes: Defines behavior when axes is not provided or is
-                empty. If false (default), reduction happens over all axes. If true, no
-                reduction is applied, but other operations will be performed. For
-                example, ReduceSumSquare acts as a vanilla Square.
+                empty. If false (default), reduction happens over all axes (similar to
+                the case when `axis=None` in numpy). If true, reduction happens over an
+                empty set of axes (similar to the case when `axis=()` in numpy). Note
+                that reduction over an empty set of axes means that the reduction step
+                behaves like a no-op (identity function), but composite-reduction
+                operators will still perform the non-reduction steps as needed. Thus,
+                ReduceLogSum returns the Log of input tensor, and ReduceSumSquare
+                returns the Square of the input tensor, in this case.
         """
 
         schema = get_schema("ReduceSum", 13, "")
@@ -3246,7 +3239,7 @@ class Opset13(Opset12):
             output = np.copy(data)
             update_indices = indices.shape[:-1]
             for idx in np.ndindex(update_indices):
-                output[indices[idx]] = updates[idx]
+                output[tuple(indices[idx])] = updates[idx]
 
         The order of iteration in the above loop is not specified.
         In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
@@ -3943,9 +3936,16 @@ class Opset13(Opset12):
         r"""[🌐 Transpose(13)](https://onnx.ai/onnx/operators/onnx__Transpose.html#transpose-13 "Online Documentation")
 
 
-        Transpose the input tensor similar to numpy.transpose. For example, when
-        perm=(1, 0, 2), given an input tensor of shape (1, 2, 3), the output shape
-        will be (2, 1, 3).
+        Returns a transpose of the input tensor. (Similar to `numpy.transpose`).
+        The optional attribute `perm` must be a permutation of the dimensions of
+        the input tensor. Axis `i` of the output tensor corresponds to the axis
+        `perm[i]` of the input tensor.
+        For example, when perm=(1, 0, 2), given an input tensor of shape (1, 2, 3),
+        the output shape will be (2, 1, 3).
+        When perm=(1, 2, 0), given an input tensor of shape (1, 2, 3),
+        the output shape will be (2, 3, 1).
+        If the attribute `perm` is omitted, its default value is `(n-1, ..., 0)`,
+        where `n` is the rank of the input tensor.
 
 
         Args:

{onnxscript-0.7.2.dev20260701 → onnxscript-0.7.2.dev20260710}/onnxscript/onnx_opset/_impl/opset14.py

@@ -257,6 +257,7 @@ class Opset14(Opset13):
 
         This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check `Broadcasting in ONNX <https://github.com/onnx/onnx/blob/master/docs/Broadcasting.md>`_.
 
+        For integer inputs, the result is computed using truncating division (rounding toward zero).
         (Opset 14 change): Extend supported types to include uint8, int8, uint16, and int16.
 
 

{onnxscript-0.7.2.dev20260701 → onnxscript-0.7.2.dev20260710}/onnxscript/onnx_opset/_impl/opset16.py

@@ -566,7 +566,7 @@ class Opset16(Opset15):
         1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
            be referenced in the inputs of the loop.
         2) Any values computed in the loop body that needs to be used in a subsequent
-           iteration or after the loop are modelled using a pair of variables in the loop-body,
+           iteration or after the loop are modeled using a pair of variables in the loop-body,
            consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
            These are referred to as loop-carried dependences. The loop operation node
            supplies the input value of the input variable for the first iteration, and
@@ -1117,7 +1117,7 @@ class Opset16(Opset15):
             output = np.copy(data)
             update_indices = indices.shape[:-1]
             for idx in np.ndindex(update_indices):
-                output[indices[idx]] = updates[idx]
+                output[tuple(indices[idx])] = updates[idx]
         The order of iteration in the above loop is not specified.
         In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
         This ensures that the output value does not depend on the iteration order.
@@ -1130,12 +1130,12 @@ class Opset16(Opset15):
             output = np.copy(data)
             update_indices = indices.shape[:-1]
             for idx in np.ndindex(update_indices):
-                output[indices[idx]] += updates[idx]
+                output[tuple(indices[idx])] += updates[idx]
         When `reduction` is set to "mul", `output` is calculated as follows:
             output = np.copy(data)
             update_indices = indices.shape[:-1]
             for idx in np.ndindex(update_indices):
-                output[indices[idx]] *= updates[idx]
+                output[tuple(indices[idx])] *= updates[idx]
         This operator is the inverse of GatherND.
         Example 1:
         ::

{onnxscript-0.7.2.dev20260701 → onnxscript-0.7.2.dev20260710}/onnxscript/onnx_opset/_impl/opset17.py

@@ -121,8 +121,10 @@ class Opset17(Opset16):
             dft_length: (optional, non-differentiable) The length of the signal as a
                 scalar. If greater than the axis dimension, the signal will be
                 zero-padded up to dft_length. If less than the axis dimension, only the
-                first dft_length values will be used as the signal. It's an optional
-                value.
+                first dft_length values will be used as the signal. If not provided, the
+                default dft_length = signal_dim_axis, except for the IRFFT case
+                (onesided=1, inverse=1), in which case the default dft_length is 2 *
+                (signal_dim_axis - 1). It's an optional value.
 
             axis: The axis on which to perform the DFT. By default this value is set to
                 1, which corresponds to the first dimension after the batch index.
@@ -134,13 +136,13 @@ class Opset17(Opset16):
                 default this value is set to 0, which corresponds to false.
 
             onesided: If onesided is 1, only values for w in [0, 1, 2, ...,
-                floor(n_fft/2) + 1] are returned because the real-to-complex Fourier
-                transform satisfies the conjugate symmetry, i.e., X[m, w] = X[m,
-                n_fft-w]*. Note if the input or window tensors are complex, then
-                onesided output is not possible. Enabling onesided with real inputs
-                performs a Real-valued fast Fourier transform (RFFT). When invoked with
-                real or complex valued input, the default value is 0. Values can be 0 or
-                1.
+                floor(n_fft/2) + 1] are used or returned because the real-to-complex
+                Fourier transform satisfies the conjugate symmetry, i.e., X[m, w] = X[m,
+                n_fft-w]*. When onesided=1 and inverse=0 (forward DFT), only real input
+                is supported and a one-sided complex spectrum is returned (RFFT). When
+                onesided=1 and inverse=1 (inverse DFT), only complex input is supported
+                and a full real signal is returned (IRFFT). When invoked with real or
+                complex valued input, the default value is 0. Values can be 0 or 1.
         """
 
         schema = get_schema("DFT", 17, "")