Generate opset23 with opgen (#2226)

Author: justinchuby

onnxscript/onnx_opset/__init__.py

@@ -39,6 +39,7 @@
 from onnxscript.onnx_opset._impl.opset20 import Opset20
 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.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
@@ -73,6 +74,7 @@
     "opset20",
     "opset21",
     "opset22",
+    "opset23",
     "opset_ai_onnx_ml1",
     "opset_ai_onnx_ml2",
     "opset_ai_onnx_ml3",
@@ -110,6 +112,7 @@
 opset20 = Opset20()
 opset21 = Opset21()
 opset22 = Opset22()
+opset23 = Opset23()
 opset_ai_onnx_ml1 = Opset_ai_onnx_ml1()
 opset_ai_onnx_ml2 = Opset_ai_onnx_ml2()
 opset_ai_onnx_ml3 = Opset_ai_onnx_ml3()
@@ -205,6 +208,10 @@
         "",
         22,
     ): opset22,
+    (
+        "",
+        23,
+    ): opset23,
     (
         "ai.onnx.ml",
         1,

onnxscript/onnx_opset/_impl/opset13.py

@@ -334,6 +334,8 @@ def Clip(
         Clip operator limits the given input within an interval. The interval is
         specified by the inputs 'min' and 'max'. They default to
         numeric_limits::lowest() and numeric_limits::max(), respectively.
+        When 'min' is greater than 'max', the clip operator sets all the 'input' values to
+        the value of 'max'. Thus, this is equivalent to 'Min(max, Max(input, min))'.
 
 
         Args:
@@ -875,7 +877,22 @@ def Gather(self, data: T_Gather, indices: Tind_Gather, *, axis: int = 0) -> T_Ga
         entries of the axis dimension of `data` (by default outer-most one as axis=0) indexed by `indices`, and concatenates
         them in an output tensor of rank q + (r - 1).
 
-        If `axis = 0`, let `k = indices[i_{0}, ..., i_{q-1}]`
+        It is an indexing operation that indexes into the input `data` along a single (specified) axis.
+        Each entry in `indices` produces a `r-1` dimensional slice of the input tensor.
+        The entire operation produces, conceptually, a `q`-dimensional tensor of `r-1` dimensional slices,
+        which is arranged into a `q + (r-1)`-dimensional tensor, with the `q` dimensions taking the
+        place of the original `axis` that is being indexed into.
+
+        The following few examples illustrate how `Gather` works for specific shapes of `data`,
+        `indices`, and given value of `axis`:
+        | data shape | indices shape | axis | output shape | output equation |
+        | --- | --- | --- | --- | --- |
+        | (P, Q) | ( )  (a scalar)   | 0 | (Q)       | output[q] = data[indices, q] |
+        | (P, Q, R) | ( )  (a scalar)   | 1 | (P, R)       | output[p, r] = data[p, indices, r] |
+        | (P, Q) | (R, S) | 0 | (R, S, Q) | output[r, s, q] = data[ [indices[r, s], q] |
+        | (P, Q) | (R, S) | 1 | (P, R, S) | output[p, r, s] = data[ p, indices[r, s]] |
+
+        More generally, if `axis = 0`, let `k = indices[i_{0}, ..., i_{q-1}]`
         then `output[i_{0}, ..., i_{q-1}, j_{0}, ..., j_{r-2}] = input[k , j_{0}, ..., j_{r-2}]`:
 
         ::

onnxscript/onnx_opset/_impl/opset18.py

@@ -169,12 +169,18 @@ def CenterCropPad(
 
         Center crop or pad an input to given dimensions.
 
-        The crop/pad dimensions can be specified for a subset of the `axes`. Non-specified dimensions will not be
-        cropped or padded.
+        The crop/pad dimensions can be specified for a subset of the `axes`; unspecified dimensions will remain unchanged.
 
-        If the input dimensions are bigger than the crop shape, a centered cropping window is extracted from the input.
-        If the input dimensions are smaller than the crop shape, the input is padded on each side equally,
-        so that the input is centered in the output.
+        If the input dimensions are larger than the target crop dimensions, a centered cropping window will be extracted
+        from the input. The starting value for the cropping window is rounded down, which means that if the difference
+        between the input shape and the crop shape is odd, the cropping window will be shifted half a pixel to the left
+        of the input center.
+
+        If the input dimensions are smaller than the target crop dimensions, the input will be padded equally on both sides
+        to center it in the output. In cases where the total number of padding pixels is odd, an additional pixel will be
+        added to the right side.
+
+        The padding value used is zero.
 
 
         Args:
@@ -286,65 +292,6 @@ def Col2Im(
             strides=strides,
         )
 
-    T_GroupNormalization = TypeVar("T_GroupNormalization", BFLOAT16, DOUBLE, FLOAT, FLOAT16)
-
-    def GroupNormalization(
-        self,
-        X: T_GroupNormalization,
-        scale: T_GroupNormalization,
-        bias: T_GroupNormalization,
-        *,
-        epsilon: float = 9.999999747378752e-06,
-        num_groups: int,
-    ) -> T_GroupNormalization:
-        r"""[🌐 GroupNormalization(18)](https://onnx.ai/onnx/operators/onnx__GroupNormalization.html#groupnormalization-18 "Online Documentation")
-
-
-        A GroupNormalization function. Carries out group normalization as described in
-        the paper https://arxiv.org/abs/1803.08494
-
-        This operator transforms input according to
-        ::
-
-            y = scale * (x - mean) / sqrt(variance + epsilon) + bias,
-
-
-        where the mean and variance are computed per instance per group of channels, and
-        `scale` and `bias` should be specified for each group of channels. The number of
-        groups `num_groups` should be divisible by the number of channels so that there are
-        an equal number of channels per group.
-
-        When the number of groups is the same as the number of channels, this operator is
-        equivalent to InstanceNormalization. When there is only one group, this operator
-        is equivalent to LayerNormalization.
-
-
-        Args:
-            X: (differentiable) Input data tensor. Dimensions for image cases are `(N x
-                C x H x W)`, where `N` is the batch size, `C` is the number of channels,
-                and `H` and `W` are the height and width of the data. Statistics are
-                computed for every group of channels over `C`, `H`, and `W`. For
-                non-image cases, the dimensions are in the form of `(N x C x D1 x D2 ...
-                Dn)`.
-
-            scale: (differentiable) Scale tensor of shape `(num_groups)`.
-
-            bias: (differentiable) Bias tensor of shape `(num_groups)`.
-
-            epsilon: The epsilon value to use to avoid division by zero.
-
-            num_groups: The number of groups of channels. It should be a divisor of the
-                number of channels `C`.
-        """
-
-        schema = get_schema("GroupNormalization", 18, "")
-        op = Op(self, "GroupNormalization", schema)
-        return op(
-            *self._prepare_inputs(schema, X, scale, bias),
-            epsilon=epsilon,
-            num_groups=num_groups,
-        )
-
     T_LpPool = TypeVar("T_LpPool", DOUBLE, FLOAT, FLOAT16)
 
     def LpPool(

onnxscript/onnx_opset/_impl/opset2.py

@@ -19,7 +19,6 @@
 
 from onnxscript.onnx_opset._impl.opset1 import Opset1
 from onnxscript.onnx_types import (
-    BFLOAT16,
     BOOL,
     COMPLEX64,
     COMPLEX128,
@@ -43,7 +42,7 @@ class Opset2(Opset1):
     def __new__(cls):
         return Opset.__new__(cls, "", 2)
 
-    T_GlobalLpPool = TypeVar("T_GlobalLpPool", BFLOAT16, DOUBLE, FLOAT, FLOAT16)
+    T_GlobalLpPool = TypeVar("T_GlobalLpPool", DOUBLE, FLOAT, FLOAT16)
 
     def GlobalLpPool(self, X: T_GlobalLpPool, *, p: int = 2) -> T_GlobalLpPool:
         r"""[🌐 GlobalLpPool(2)](https://onnx.ai/onnx/operators/onnx__GlobalLpPool.html#globallppool-2 "Online Documentation")

onnxscript/onnx_opset/_impl/opset21.py

@@ -422,7 +422,6 @@ def DequantizeLinear(
         must have the same shape, determining the quantization's granularity: a scalar for per-tensor/per-layer quantization,
         a 1-D tensor for per-axis quantization, or have a rank identical to the input for blocked quantization.
         See QuantizeLinear for details on quantization granularity.
-
         `x_zero_point` and `x` must have the same type. `x` and `y` must have the same shape. In the case of dequantizing
         `int32`, there's no zero point (zero point is supposed to be 0).
         `zero-point` is usually not used in the case of float8 types quantization, but the dequantization formula remains the same
@@ -535,7 +534,7 @@ def GroupNormalization(
 
 
         where the mean and variance are computed per instance per group of channels, and
-        `scale` and `bias` should be specified for each group of channels. The number of
+        `scale` and `bias` should be specified for each channel. The number of
         groups `num_groups` should be divisible by the number of channels so that there are
         an equal number of channels per group.
 
@@ -1340,20 +1339,16 @@ def QuantizeLinear(
         The linear quantization operator consumes a high-precision tensor, a scale, and a zero point to compute the
         low-precision/quantized tensor. The scale factor and zero point must have the same shape, determining the quantization
         granularity. The quantization formula is `y = saturate((x / y_scale) + y_zero_point)`.
-
         Saturation is done according to:
         - uint16: [0, 65535]
         - int16: [-32768, 32767]
         - uint8: [0, 255]
         - int8: [-128, 127]
         - uint4: [0, 15]
         - int4: [-8, 7]
-
         For `(x / y_scale)`, it rounds to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
-
         `y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 types, but the quantization
         formula remains the same for consistency, and the type of the attribute `y_zero_point` still determines the quantization type.
-
         There are three supported quantization granularities, determined by the shape of `y_scale`.
         In all cases, `y_zero_point` must have the same shape as `y_scale`.
         - Per-tensor (per-layer) quantization: `y_scale` is a scalar.

onnxscript/onnx_opset/_impl/opset22.py

@@ -989,7 +989,7 @@ def GlobalAveragePool(self, X: T_GlobalAveragePool) -> T_GlobalAveragePool:
         op = Op(self, "GlobalAveragePool", schema)
         return op(*self._prepare_inputs(schema, X))
 
-    T_GlobalLpPool = TypeVar("T_GlobalLpPool", DOUBLE, FLOAT, FLOAT16)
+    T_GlobalLpPool = TypeVar("T_GlobalLpPool", BFLOAT16, DOUBLE, FLOAT, FLOAT16)
 
     def GlobalLpPool(self, X: T_GlobalLpPool, *, p: int = 2) -> T_GlobalLpPool:
         r"""[🌐 GlobalLpPool(22)](https://onnx.ai/onnx/operators/onnx__GlobalLpPool.html#globallppool-22 "Online Documentation")