onnx 1.15.0__cp311-cp311-win_amd64.whl → 1.16.1__cp311-cp311-win_amd64.whl

onnx/reference/ops/aionnxml/op_tree_ensemble.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import Callable
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class AggregationFunction(IntEnum):
+    AVERAGE = 0
+    SUM = 1
+    MIN = 2
+    MAX = 3
+
+
+class PostTransform(IntEnum):
+    NONE = 0
+    SOFTMAX = 1
+    LOGISTIC = 2
+    SOFTMAX_ZERO = 3
+    PROBIT = 4
+
+
+class Mode(IntEnum):
+    LEQ = 0
+    LT = 1
+    GTE = 2
+    GT = 3
+    EQ = 4
+    NEQ = 5
+    MEMBER = 6
+
+
+class Leaf:
+    def __init__(self, weight: float, target_id: int) -> None:
+        self.weight = weight
+        self.target_id = target_id
+
+    # Produce the weight and target index
+    def predict(self, x: np.ndarray) -> np.ndarray:
+        return np.array([self.weight, self.target_id])
+
+    def _print(self, prefix: list, indent: int = 0) -> None:
+        prefix.append(
+            " " * indent + f"Leaf WEIGHT: {self.weight}, TARGET: {self.target_id}\n"
+        )
+
+    def __repr__(self) -> str:
+        prefix = []
+        self._print(prefix)
+        return "".join(prefix)
+
+
+class Node:
+    compare: Callable[[float, float | set[float]], bool]
+    true_branch: Node | Leaf
+    false_branch: Node | Leaf
+    feature: int
+
+    def __init__(
+        self,
+        mode: Mode,
+        value: float | set[float],
+        feature: int,
+        missing_tracks_true: bool,
+    ) -> None:
+        if mode == Mode.LEQ:
+            self.compare = lambda x: x[feature].item() <= value or (
+                missing_tracks_true and np.isnan(x[feature].item())
+            )
+        elif mode == Mode.LT:
+            self.compare = lambda x: x[feature].item() < value or (
+                missing_tracks_true and np.isnan(x[feature].item())
+            )
+        elif mode == Mode.GTE:
+            self.compare = lambda x: x[feature].item() >= value or (
+                missing_tracks_true and np.isnan(x[feature].item())
+            )
+        elif mode == Mode.GT:
+            self.compare = lambda x: x[feature].item() > value or (
+                missing_tracks_true and np.isnan(x[feature].item())
+            )
+        elif mode == Mode.EQ:
+            self.compare = lambda x: x[feature].item() == value or (
+                missing_tracks_true and np.isnan(x[feature].item())
+            )
+        elif mode == Mode.NEQ:
+            self.compare = lambda x: x[feature].item() != value or (
+                missing_tracks_true and np.isnan(x[feature].item())
+            )
+        elif mode == Mode.MEMBER:
+            self.compare = lambda x: x[feature].item() in value or (
+                missing_tracks_true and np.isnan(x[feature].item())
+            )
+        self.mode = mode
+        self.value = value
+        self.feature = feature
+
+    def predict(self, x: np.ndarray) -> float:
+        if self.compare(x):
+            return self.true_branch.predict(x)
+        else:
+            return self.false_branch.predict(x)
+
+    def _print(self, prefix: list, indent: int = 0) -> None:
+        prefix.append(
+            " " * indent
+            + f"Node CMP: {self.mode}, SPLIT: {self.value}, FEATURE: {self.feature}\n"
+        )
+        self.true_branch._print(prefix, indent + 1)
+        self.false_branch._print(prefix, indent + 1)
+
+    def __repr__(self) -> str:
+        prefix = []
+        self._print(prefix)
+        return "".join(prefix)
+
+
+class TreeEnsemble(OpRunAiOnnxMl):
+    def _run(
+        self,
+        X,
+        nodes_splits,
+        nodes_featureids,
+        nodes_modes,
+        nodes_truenodeids,
+        nodes_falsenodeids,
+        nodes_trueleafs,
+        nodes_falseleafs,
+        leaf_targetids,
+        leaf_weights,
+        tree_roots,
+        post_transform=PostTransform.NONE,
+        aggregate_function=AggregationFunction.SUM,
+        nodes_hitrates=None,
+        nodes_missing_value_tracks_true=None,
+        membership_values=None,
+        n_targets=None,
+    ):
+        if membership_values is None:
+            # assert that no set membership ever appears
+            if any(mode == Mode.MEMBER for mode in nodes_modes):
+                raise ValueError(
+                    "Cannot have set membership node without specifying set members"
+                )
+        elif np.isnan(membership_values).sum() != sum(
+            int(mode == Mode.MEMBER) for mode in nodes_modes
+        ):
+            raise ValueError(
+                "Must specify membership values for all set membership nodes"
+            )
+
+        # Build each tree in the ensemble. Note that the tree structure is implicitly defined by following the true and false indices in
+        # `nodes_truenodeids` and `nodes_falsenodeids` to the leaves of each tree.
+        set_membership_iter = (
+            iter(membership_values) if membership_values is not None else None
+        )
+
+        def build_node(current_node_index, is_leaf) -> Node | Leaf:
+            if is_leaf:
+                return Leaf(
+                    leaf_weights[current_node_index], leaf_targetids[current_node_index]
+                )
+
+            if nodes_modes[current_node_index] == Mode.MEMBER:
+                # parse next sequence of set members
+                set_members = set()
+                while (set_member := next(set_membership_iter)) and not np.isnan(
+                    set_member
+                ):
+                    set_members.add(set_member)
+                node = Node(
+                    nodes_modes[current_node_index],
+                    set_members,
+                    nodes_featureids[current_node_index],
+                    (
+                        nodes_missing_value_tracks_true[current_node_index]
+                        if nodes_missing_value_tracks_true is not None
+                        else False
+                    ),
+                )
+            else:
+                node = Node(
+                    nodes_modes[current_node_index],
+                    nodes_splits[current_node_index],
+                    nodes_featureids[current_node_index],
+                    (
+                        nodes_missing_value_tracks_true[current_node_index]
+                        if nodes_missing_value_tracks_true is not None
+                        else False
+                    ),
+                )
+
+            # recurse true and false branches
+            node.true_branch = build_node(
+                nodes_truenodeids[current_node_index],
+                nodes_trueleafs[current_node_index],
+            )
+            node.false_branch = build_node(
+                nodes_falsenodeids[current_node_index],
+                nodes_falseleafs[current_node_index],
+            )
+            return node
+
+        trees = []
+        for root_index in tree_roots:
+            # degenerate case (tree == leaf)
+            is_leaf = (
+                nodes_trueleafs[root_index]
+                and nodes_falseleafs[root_index]
+                and nodes_truenodeids[root_index] == nodes_falsenodeids[root_index]
+            )
+            trees.append(build_node(root_index, is_leaf))
+
+        # predict each sample through tree
+        raw_values = [
+            np.apply_along_axis(tree.predict, axis=1, arr=X) for tree in trees
+        ]
+        weights, target_ids = zip(*[np.split(x, 2, axis=1) for x in raw_values])
+        weights = np.concatenate(weights, axis=1)
+        target_ids = np.concatenate(target_ids, axis=1).astype(np.int64)
+        if aggregate_function in (
+            AggregationFunction.SUM,
+            AggregationFunction.AVERAGE,
+        ):
+            result = np.zeros((len(X), n_targets), dtype=X.dtype)
+        elif aggregate_function == AggregationFunction.MIN:
+            result = np.full((len(X), n_targets), np.finfo(X.dtype).max)
+        elif aggregate_function == AggregationFunction.MAX:
+            result = np.full((len(X), n_targets), np.finfo(X.dtype).min)
+        else:
+            raise NotImplementedError(
+                f"aggregate_transform={aggregate_function!r} not supported yet."
+            )
+        for batch_num, (w, t) in enumerate(zip(weights, target_ids)):
+            weight = w.reshape(-1)
+            target_id = t.reshape(-1)
+            if aggregate_function == AggregationFunction.SUM:
+                for value, tid in zip(weight, target_id):
+                    result[batch_num, tid] += value
+            elif aggregate_function == AggregationFunction.AVERAGE:
+                for value, tid in zip(weight, target_id):
+                    result[batch_num, tid] += value / len(trees)
+            elif aggregate_function == AggregationFunction.MIN:
+                for value, tid in zip(weight, target_id):
+                    result[batch_num, tid] = min(result[batch_num, tid], value)
+            elif aggregate_function == AggregationFunction.MAX:
+                for value, tid in zip(weight, target_id):
+                    result[batch_num, tid] = max(result[batch_num, tid], value)
+            else:
+                raise NotImplementedError(
+                    f"aggregate_transform={aggregate_function!r} not supported yet."
+                )
+
+        return (result,)

onnx/reference/ops/aionnxml/op_tree_ensemble_helper.py

@@ -59,9 +59,7 @@ class TreeEnsemble:
         return "\n".join(rows)
 
     def leaf_index_tree(self, X: np.ndarray, tree_id: int) -> int:
-        """
-        Computes the leaf index for one tree.
-        """
+        """Computes the leaf index for one tree."""
         index = self.root_index[tree_id]
         while self.atts.nodes_modes[index] != "LEAF":  # type: ignore
             x = X[self.atts.nodes_featureids[index]]  # type: ignore
@@ -95,9 +93,7 @@ class TreeEnsemble:
         return index
 
     def leave_index_tree(self, X: np.ndarray) -> np.ndarray:
-        """
-        Computes the leave index for all trees.
-        """
+        """Computes the leave index for all trees."""
         if len(X.shape) == 1:
             X = X.reshape((1, -1))
         outputs = []

onnx/reference/ops/aionnxml/op_tree_ensemble_regressor.py

@@ -10,9 +10,7 @@ from onnx.reference.ops.aionnxml.op_tree_ensemble_helper import TreeEnsemble
 
 
 class TreeEnsembleRegressor(OpRunAiOnnxMl):
-    """
-    `nodes_hitrates` and `nodes_hitrates_as_tensor` are not used.
-    """
+    """`nodes_hitrates` and `nodes_hitrates_as_tensor` are not used."""
 
     def _run(  # type: ignore
         self,
@@ -97,8 +95,10 @@ class TreeEnsembleRegressor(OpRunAiOnnxMl):
                 )
         if aggregate_function == "AVERAGE":
             res /= n_trees
+
+        # Convention is to add base_values after aggregate function
         if base_values is not None:
-            res[:, :] = np.array(base_values).reshape((1, -1))
+            res[:, :] += np.array(base_values).reshape((1, -1))
 
         if post_transform in (None, "NONE"):
             return (res,)

onnx/reference/ops/experimental/_op_list.py

@@ -21,16 +21,23 @@ def _build_registered_operators() -> (
 
 
 def load_op(
-    domain: str, op_type: str, version: Union[None, int], custom: Any = None
+    domain: str,
+    op_type: str,
+    version: Union[None, int],
+    custom: Any = None,
+    evaluator_cls: TOptional[type] = None,
 ) -> Any:
-    """
-    Loads the implemented for a specified operator.
+    """Loads the implemented for a specified operator.
+
+    Args:
+        domain: domain
+        op_type: oprator type
+        version: requested version
+        custom: custom implementation (like a function)
+        evaluator_cls: unused
 
-    :param domain: domain
-    :param op_type: oprator type
-    :param version: requested version
-    :param custom: custom implementation (like a function)
-    :return: class
+    Returns:
+        class
     """
     global _registered_operators  # noqa: PLW0603
     if _registered_operators is None:

onnx/reference/ops/op_blackman_window.py

@@ -9,13 +9,12 @@ from onnx.reference.ops._op_common_window import _CommonWindow
 
 
 class BlackmanWindow(_CommonWindow):
-    """
-    Returns
-    :math:`\\omega_n = 0.42 - 0.5 \\cos \\left( \\frac{2\\pi n}{N-1} \\right) +
-    0.08 \\cos \\left( \\frac{4\\pi n}{N-1} \\right)`
+    r"""Blankman windowing function.
+
+    Returns :math:`\\omega_n = 0.42 - 0.5 \\cos \\left( \\frac{2\\pi n}{N-1} \\right) + 0.08 \\cos \\left( \\frac{4\\pi n}{N-1} \\right)`
     where *N* is the window length.
-    See `blackman_window
-    <https://pytorch.org/docs/stable/generated/torch.blackman_window.html>`_
+
+    See `blackman_window <https://pytorch.org/docs/stable/generated/torch.blackman_window.html>`_
     """
 
     def _run(self, size, output_datatype=None, periodic=None):  # type: ignore

onnx/reference/ops/op_cast.py

@@ -5,6 +5,7 @@
 
 import numpy as np
 
+from onnx import subbyte
 from onnx.helper import (
     float32_to_bfloat16,
     float32_to_float8e4m3,
@@ -23,6 +24,8 @@ from onnx.reference.custom_element_types import (
     float8e4m3fnuz,
     float8e5m2,
     float8e5m2fnuz,
+    int4,
+    uint4,
 )
 from onnx.reference.op_run import OpRun
 
@@ -74,6 +77,25 @@ def cast_to(x, to, saturate):  # noqa: PLR0911
             y[i] = el
         return y.reshape(x.shape)
 
+    i4 = [
+        (uint4, "uint4", TensorProto.UINT4, False),
+        (int4, "int4", TensorProto.INT4, True),
+    ]
+    for np_type, np_desc, tensor_type, signed in i4:
+        if x.dtype == np_type and x.dtype.descr[0][0] == np_desc:
+            if to == tensor_type:
+                return x
+            to_type = tensor_dtype_to_np_dtype(to)
+            return x.astype(to_type)
+
+        if to == tensor_type:
+            xf = x.astype(np.float32).ravel()
+            y = np.empty(xf.shape, dtype=np_type).ravel()
+            for i in range(y.shape[0]):
+                el = subbyte.float32_to_4bit_unpacked(xf[i], signed=signed)
+                y[i] = el
+            return y.reshape(x.shape)
+
     f8back = {
         TensorProto.FLOAT8E4M3FN: (
             float8e4m3fn,

onnx/reference/ops/op_cast_like.py

@@ -13,6 +13,8 @@ from onnx.reference.ops.op_cast import (
     float8e4m3fnuz,
     float8e5m2,
     float8e5m2fnuz,
+    int4,
+    uint4,
 )
 
 
@@ -28,6 +30,10 @@ def _cast_like(x, y, saturate):
         to = TensorProto.FLOAT8E5M2
     elif y.dtype == float8e5m2fnuz and y.dtype.descr[0][0] == "e5m2fnuz":
         to = TensorProto.FLOAT8E5M2FNUZ
+    elif y.dtype == uint4 and y.dtype.descr[0][0] == "uint4":
+        to = TensorProto.UINT4
+    elif y.dtype == int4 and y.dtype.descr[0][0] == "int4":
+        to = TensorProto.INT4
     else:
         to = np_dtype_to_tensor_dtype(y.dtype)  # type: ignore
     return (cast_to(x, to, saturate),)

onnx/reference/ops/op_clip.py

@@ -9,12 +9,10 @@ from onnx.reference.op_run import OpRun
 
 
 class Clip_6(OpRun):
-    def _run(self, data, min=None, max=None):  # type: ignore
+    def _run(self, data, min=None, max=None):  # type: ignore  # noqa: A002
         amin = min
         amax = max
-        if amin is amax is None:
-            return (data,)
-        res = np.clip(data, amin, amax)  # type: ignore
+        res = data if amin is amax is None else np.clip(data, amin, amax)  # type: ignore
         return (res,) if res.dtype == data.dtype else (res.astype(data.dtype),)
 
 
@@ -23,7 +21,6 @@ class Clip_11(OpRun):
         le = len(minmax)
         amin = minmax[0] if le > 0 else None
         amax = minmax[1] if le > 1 else None
-        if amin is amax is None:
-            return (data,)
-        res = np.clip(data, amin, amax)
-        return (res,) if res.dtype == data.dtype else (res.astype(data.dtype),)
+        res = data if amin is amax is None else np.clip(data, amin, amax)
+        res = (res,) if res.dtype == data.dtype else (res.astype(data.dtype),)
+        return res

onnx/reference/ops/op_col2im.py

@@ -143,9 +143,7 @@ def _col2im_shape_check(X, output_shape, kernel_shape, dilations, pads, strides)
 
 
 def col2im_naive_implementation(data, image_shape, kernel_shape, dilations, pads, strides):  # type: ignore
-    """
-    Naive implementation for `col2im`.
-    """
+    """Naive implementation for `col2im`."""
     n_dims = len(pads) // 2
     new_pads = np.array([(pads[i], pads[i + n_dims]) for i in range(n_dims)])
     _col2im_shape_check(data, image_shape, kernel_shape, dilations, new_pads, strides)

onnx/reference/ops/op_constant.py

@@ -11,6 +11,8 @@ from onnx.reference.custom_element_types import (
     float8e4m3fnuz,
     float8e5m2,
     float8e5m2fnuz,
+    int4,
+    uint4,
 )
 from onnx.reference.op_run import OpRun, RefAttrName
 
@@ -23,6 +25,8 @@ def _check_dtype(val):  # type: ignore
         float8e4m3fnuz,
         float8e5m2,
         float8e5m2fnuz,
+        uint4,
+        int4,
         np.int8,
         np.uint8,
         np.float16,
@@ -128,7 +132,9 @@ class Constant_12(ConstantCommon):
                     )
                     break
         if not hasattr(self, "cst_name"):
-            raise AttributeError("No constant is defined for operator 'Constant'.")
+            raise AttributeError(
+                f"No constant is defined for operator 'Constant', outputs are {onnx_node.output}."
+            )
 
     def _run(self, **overridden_attributes):  # type: ignore
         if self.has_linked_attribute:

onnx/reference/ops/op_dequantize_linear.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 
-from typing import Optional, Tuple
+from typing import Optional
 
 import numpy as np
 
@@ -15,39 +15,31 @@ from onnx.reference.custom_element_types import (
     float8e4m3fnuz,
     float8e5m2,
     float8e5m2fnuz,
+    int4,
+    uint4,
 )
 from onnx.reference.op_run import OpRun
+from onnx.reference.ops.op_quantize_linear import reshape_input
 
 
-class DequantizeLinear(OpRun):
+class _CommonDequantizeLinear(OpRun):
     def get_x_type(self, x: np.ndarray) -> int:
+        tensor_dtype = None
         if x.dtype == float8e4m3fn and x.dtype.descr[0][0] == "e4m3fn":
-            return TensorProto.FLOAT8E4M3FN
-        if x.dtype == float8e4m3fnuz and x.dtype.descr[0][0] == "e4m3fnuz":
-            return TensorProto.FLOAT8E4M3FNUZ
-        if x.dtype == float8e5m2 and x.dtype.descr[0][0] == "e5m2":
-            return TensorProto.FLOAT8E5M2
-        if x.dtype == float8e5m2fnuz and x.dtype.descr[0][0] == "e5m2fnuz":
-            return TensorProto.FLOAT8E5M2FNUZ
-        return np_dtype_to_tensor_dtype(x.dtype)
-
-    @staticmethod
-    def reshape_input(
-        value: np.ndarray, shape: Tuple[int, ...], axis: Optional[int]
-    ) -> np.ndarray:
-        if axis is None:
-            raise ValueError("axis cannot be None.")
-        if len(value.shape) == 0:
-            return value
-        dims = [1] * len(shape)
-        try:
-            dims[axis] = value.size
-        except IndexError as e:
-            raise IndexError(
-                f"axis is out of boundary, axis={axis}, "
-                f"value.shape={value.shape}, shape={shape}."
-            ) from e
-        return value.reshape(tuple(dims))
+            tensor_dtype = TensorProto.FLOAT8E4M3FN
+        elif x.dtype == float8e4m3fnuz and x.dtype.descr[0][0] == "e4m3fnuz":
+            tensor_dtype = TensorProto.FLOAT8E4M3FNUZ
+        elif x.dtype == float8e5m2 and x.dtype.descr[0][0] == "e5m2":
+            tensor_dtype = TensorProto.FLOAT8E5M2
+        elif x.dtype == float8e5m2fnuz and x.dtype.descr[0][0] == "e5m2fnuz":
+            tensor_dtype = TensorProto.FLOAT8E5M2FNUZ
+        elif x.dtype == uint4 and x.dtype.descr[0][0] == "uint4":
+            tensor_dtype = TensorProto.UINT4
+        elif x.dtype == int4 and x.dtype.descr[0][0] == "int4":
+            tensor_dtype = TensorProto.INT4
+        else:
+            tensor_dtype = np_dtype_to_tensor_dtype(x.dtype)
+        return tensor_dtype
 
     def _run(
         self,
@@ -55,35 +47,33 @@ class DequantizeLinear(OpRun):
         x_scale: np.ndarray,
         x_zero_point: Optional[np.ndarray] = None,
         axis: Optional[int] = None,
+        block_size: Optional[int] = None,
     ):  # type: ignore
-        if len(x_scale.shape) > 1:
-            raise RuntimeError("Input 2 must be a vector or a number.")
-
         x_type = self.get_x_type(x)
-        f8_type = x_type in {
+        fp8_type = x_type in {
             TensorProto.FLOAT8E4M3FN,
             TensorProto.FLOAT8E4M3FNUZ,
             TensorProto.FLOAT8E5M2,
             TensorProto.FLOAT8E5M2FNUZ,
         }
-        if x_zero_point is not None and not f8_type:
+        if x_zero_point is not None and not fp8_type:
             zero_type = self.get_x_type(x_zero_point)
             if x_type != zero_type:
-                raise RuntimeError(
+                raise ValueError(
                     f"Type mismatch {x_type} != {zero_type} in DequantizeLinear."
                 )
 
-            dx = x.astype(np.float32) - DequantizeLinear.reshape_input(
-                x_zero_point, x.shape, axis
+            dx = x.astype(np.float32) - reshape_input(
+                x_zero_point, x.shape, axis, block_size
             )
         else:
-            if f8_type and x_zero_point is not None:
+            if fp8_type and x_zero_point is not None:
                 u_x_zero_point = x_zero_point.astype(np.uint8)
                 umi = u_x_zero_point.min()
                 uma = u_x_zero_point.max()
                 if umi != uma or umi != np.uint8(0):
-                    raise RuntimeError(
-                        "x_zero_point is not null but should be zero for float 8 types."
+                    raise ValueError(
+                        "x_zero_point is not null but should be zero for float8 types."
                     )
             if x_type == TensorProto.FLOAT8E4M3FN:
                 dx = float8e4m3_to_float32(x)
@@ -95,5 +85,18 @@ class DequantizeLinear(OpRun):
                 dx = float8e5m2_to_float32(x, fn=True, uz=True)
             else:
                 dx = x.astype(np.float32)
-        y = dx * DequantizeLinear.reshape_input(x_scale, x.shape, axis)
+        y = dx * reshape_input(x_scale, x.shape, axis, block_size)
         return (y.astype(x_scale.dtype),)
+
+
+class DequantizeLinear_19(_CommonDequantizeLinear):
+    def _run(self, x, x_scale, x_zero_point=None, axis=None):
+        if len(x_scale.shape) > 1:
+            raise ValueError("Input 2 must be a vector or a number.")
+        return super()._run(x, x_scale, x_zero_point, axis)
+
+
+class DequantizeLinear_21(_CommonDequantizeLinear):
+    def _run(self, *args, axis=None, block_size=None):  # type: ignore
+        # args: x, y_scale, zero_point
+        return super()._run(*args, axis=axis, block_size=block_size)  # type: ignore

onnx/reference/ops/op_det.py

@@ -10,4 +10,4 @@ from onnx.reference.op_run import OpRun
 
 class Det(OpRun):
     def _run(self, x):  # type: ignore
-        return (np.linalg.det(x),)
+        return (np.array(np.linalg.det(x)),)

onnx/reference/ops/op_dynamic_quantize_linear.py

@@ -27,6 +27,6 @@ class DynamicQuantizeLinear(OpRun):
         y = np.clip(np.rint(x / y_scale) + zpi, qmin, qmax)
         return (
             y.astype(dtype),
-            y_scale.astype(x.dtype),
-            zpi.astype(dtype),
+            np.array(y_scale.astype(x.dtype)),
+            np.array(zpi.astype(dtype)),
         )

onnx/reference/ops/op_grid_sample.py

@@ -51,8 +51,7 @@ class GridSample(OpRun):
         return x
 
     def _gs_reflect(self, x, x_min, x_max):  # type: ignore
-        """
-        Reflect by the near border till within the borders
+        """Reflect by the near border till within the borders
         Use float for borders to avoid potential issues with integer T
         """
         fx = x
@@ -76,8 +75,7 @@ class GridSample(OpRun):
         return fx
 
     def _gs_get_cubic_coeffs(self, x, coeffs):  # type: ignore
-        """
-        Calculate cubic convolution interpolation coefficients
+        """Calculate cubic convolution interpolation coefficients
         ROBERT G. KEYS https://ieeexplore.ieee.org/document/1163711
         Use float to avoid potential issues with integer.
         """

onnx/reference/ops/op_hamming_window.py

@@ -9,12 +9,9 @@ from onnx.reference.ops._op_common_window import _CommonWindow
 
 
 class HammingWindow(_CommonWindow):
-    """
-    Returns
-    :math:`\\omega_n = \\alpha - \\beta \\cos \\left( \\frac{\\pi n}{N-1} \\right)`
-    where *N* is the window length.
-    See `hamming_window
-    <https://pytorch.org/docs/stable/generated/torch.hamming_window.html>`_.
+    r"""Returns :math:`\\omega_n = \\alpha - \\beta \\cos \\left( \\frac{\\pi n}{N-1} \\right)` where *N* is the window length.
+
+    See `hamming_window <https://pytorch.org/docs/stable/generated/torch.hamming_window.html>`_.
     `alpha=0.54, beta=0.46`
     """