onnx 1.18.0__cp313-cp313-macosx_12_0_universal2.whl → 1.19.1rc1__cp313-cp313-macosx_12_0_universal2.whl

onnx/reference/ops/op_rotary_embedding.py

@@ -42,26 +42,28 @@ def rotary_embedding(
 
     # Retrieve sin and cos caches using position ids
     if position_ids is not None:
-        cos = cos_cache[
+        cos_cache = cos_cache[
             position_ids
-        ]  # Shape: [batch_size, sequence_length, head_size/2]
-        sin = sin_cache[
+        ]  # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+        sin_cache = sin_cache[
             position_ids
-        ]  # Shape: [batch_size, sequence_length, head_size/2]
-    else:
-        cos = cos_cache
-        sin = sin_cache
-    cos = cos[
-        :, :, :rotary_embedding_dim_half
-    ]  # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
-    sin = sin[
-        :, :, :rotary_embedding_dim_half
-    ]  # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
-    cos = np.expand_dims(
-        cos, axis=2
+        ]  # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+
+    # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+    if cos_cache.shape[-1] != rotary_embedding_dim_half:
+        raise ValueError(
+            f"Last dimension of cos cache ({cos_cache.shape[-1]}) does not match rotary_embedding_dim/2 ({rotary_embedding_dim_half})."
+        )
+    if sin_cache.shape[-1] != rotary_embedding_dim_half:
+        raise ValueError(
+            f"Last dimension of sin cache ({sin_cache.shape[-1]}) does not match rotary_embedding_dim/2 ({rotary_embedding_dim_half})."
+        )
+
+    cos_cache = np.expand_dims(
+        cos_cache, axis=2
     )  # Shape: [batch_size, sequence_length, 1, rotary_embedding_dim/2]
-    sin = np.expand_dims(
-        sin, axis=2
+    sin_cache = np.expand_dims(
+        sin_cache, axis=2
     )  # Shape: [batch_size, sequence_length, 1, rotary_embedding_dim/2]
 
     # Either divide the input in halves or interleave (based on interleaved attribute)
@@ -72,8 +74,8 @@ def rotary_embedding(
         x1, x2 = np.split(x_rotate, 2, axis=-1)
 
     # Calculate real and imaginary values
-    real = (cos * x1) - (sin * x2)
-    imag = (sin * x1) + (cos * x2)
+    real = (cos_cache * x1) - (sin_cache * x2)
+    imag = (sin_cache * x1) + (cos_cache * x2)
 
     # Inserted rotated embeddings back to the original input
     if interleaved:
@@ -114,4 +116,4 @@ class RotaryEmbedding(OpRun):
                 rotary_embedding_dim=rotary_embedding_dim,
                 num_heads=num_heads,
             ),
-        )  # type: ignore
+        )

onnx/reference/ops/op_round.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Round(OpRunUnaryNum):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (np.round(x).astype(x.dtype),)

onnx/reference/ops/op_scan.py

@@ -9,20 +9,20 @@ from onnx.reference.op_run import OpRun
 
 
 class Scan(OpRun):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRun.__init__(self, onnx_node, run_params)
-        if not hasattr(self.body, "run"):  # type: ignore
+        if not hasattr(self.body, "run"):
             raise RuntimeError(
-                f"Parameter 'body' must have a method 'run', type {type(self.body)}."  # type: ignore
+                f"Parameter 'body' must have a method 'run', type {type(self.body)}."
             )
         self.input_directions_ = [
             (
                 0
-                if self.scan_input_directions is None  # type: ignore
-                or i >= len(self.scan_input_directions)  # type: ignore
+                if self.scan_input_directions is None
+                or i >= len(self.scan_input_directions)
                 else self.scan_input_directions[i]
-            )  # type: ignore
-            for i in range(self.num_scan_inputs)  # type: ignore
+            )
+            for i in range(self.num_scan_inputs)
         ]
         max_dir_in = max(self.input_directions_)
         if max_dir_in != 0:
@@ -32,28 +32,28 @@ class Scan(OpRun):
         self.input_axes_ = [
             (
                 0
-                if self.scan_input_axes is None or i >= len(self.scan_input_axes)  # type: ignore
+                if self.scan_input_axes is None or i >= len(self.scan_input_axes)
                 else self.scan_input_axes[i]
-            )  # type: ignore
-            for i in range(self.num_scan_inputs)  # type: ignore
+            )
+            for i in range(self.num_scan_inputs)
         ]
         max_axe_in = max(self.input_axes_)
         if max_axe_in != 0:
             raise RuntimeError("Scan is not implemented for other input axes than 0.")
-        self.input_names = self.body.input_names  # type: ignore
-        self.output_names = self.body.output_names  # type: ignore
+        self.input_names = self.body.input_names
+        self.output_names = self.body.output_names
 
-    def _common_run_shape(self, *args):  # type: ignore
-        num_loop_state_vars = len(args) - self.num_scan_inputs  # type: ignore
+    def _common_run_shape(self, *args):
+        num_loop_state_vars = len(args) - self.num_scan_inputs
         num_scan_outputs = len(args) - num_loop_state_vars
 
         output_directions = [
             (
                 0
-                if self.scan_output_directions is None  # type: ignore
-                or i >= len(self.scan_output_directions)  # type: ignore
+                if self.scan_output_directions is None
+                or i >= len(self.scan_output_directions)
                 else self.scan_output_directions[i]
-            )  # type: ignore
+            )
             for i in range(num_scan_outputs)
         ]
         max_dir_out = max(output_directions)
@@ -64,16 +64,16 @@ class Scan(OpRun):
         output_axes = [
             (
                 0
-                if self.scan_output_axes is None or i >= len(self.scan_output_axes)  # type: ignore
+                if self.scan_output_axes is None or i >= len(self.scan_output_axes)
                 else self.scan_output_axes[i]
-            )  # type: ignore
+            )
             for i in range(num_scan_outputs)
         ]
         max_axe_out = max(output_axes)
         if max_axe_out != 0:
             raise RuntimeError("Scan is not implemented for other output axes than 0.")
 
-        state_names_in = self.input_names[: self.num_scan_inputs]  # type: ignore
+        state_names_in = self.input_names[: self.num_scan_inputs]
         state_names_out = self.output_names[: len(state_names_in)]
         scan_names_in = self.input_names[num_loop_state_vars:]
         scan_names_out = self.output_names[num_loop_state_vars:]
@@ -124,7 +124,7 @@ class Scan(OpRun):
         ) = self._common_run_shape(*args)
 
         max_iter = args[num_loop_state_vars].shape[self.input_axes_[0]]
-        results = [[] for _ in scan_names_out]  # type: ignore
+        results = [[] for _ in scan_names_out]
 
         for it in range(max_iter):
             inputs = dict(zip(state_names_in, states))
@@ -133,10 +133,10 @@ class Scan(OpRun):
             )
 
             try:
-                outputs_list = self._run_body(inputs)  # type: ignore
+                outputs_list = self._run_body(inputs)
             except TypeError as e:
                 raise TypeError(
-                    f"Unable to call 'run' for type '{type(self.body)}'."  # type: ignore
+                    f"Unable to call 'run' for type '{type(self.body)}'."
                 ) from e
 
             outputs = dict(zip(self.output_names, outputs_list))

onnx/reference/ops/op_scatter_elements.py

@@ -8,7 +8,7 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def scatter_elements(data, indices, updates, axis=0, reduction=None):  # type: ignore
+def scatter_elements(data, indices, updates, axis=0, reduction=None):
     """Scatter elements.
 
     ::
@@ -109,6 +109,6 @@ def scatter_elements(data, indices, updates, axis=0, reduction=None):  # type: i
 
 
 class ScatterElements(OpRun):
-    def _run(self, data, indices, updates, axis=None, reduction=None):  # type: ignore
+    def _run(self, data, indices, updates, axis=None, reduction=None):
         res = scatter_elements(data, indices, updates, axis=axis, reduction=reduction)
         return (res,)

onnx/reference/ops/op_scatternd.py

@@ -8,7 +8,7 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def _scatter_nd_impl(data, indices, updates, reduction=None):  # type: ignore
+def _scatter_nd_impl(data, indices, updates, reduction=None):
     output = np.copy(data)
     for i in np.ndindex(indices.shape[:-1]):
         if reduction == "add":
@@ -25,6 +25,6 @@ def _scatter_nd_impl(data, indices, updates, reduction=None):  # type: ignore
 
 
 class ScatterND(OpRun):
-    def _run(self, data, indices, updates, reduction=None):  # type: ignore
+    def _run(self, data, indices, updates, reduction=None):
         y = _scatter_nd_impl(data, indices, updates, reduction=reduction)
         return (y,)

onnx/reference/ops/op_selu.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Selu(OpRun):
-    def _run(self, x, alpha=None, gamma=None):  # type: ignore
+    def _run(self, x, alpha=None, gamma=None):
         return (
             (np.where(x > 0, x, np.exp(x) * alpha - alpha) * gamma).astype(x.dtype),
         )

onnx/reference/ops/op_sequence_at.py

@@ -7,5 +7,5 @@ from onnx.reference.op_run import OpRun
 
 
 class SequenceAt(OpRun):
-    def _run(self, seq, index):  # type: ignore
+    def _run(self, seq, index):
         return (seq[index],)

onnx/reference/ops/op_sequence_construct.py

@@ -7,5 +7,5 @@ from onnx.reference.op_run import OpRun
 
 
 class SequenceConstruct(OpRun):
-    def _run(self, *data):  # type: ignore
+    def _run(self, *data):
         return (list(data),)

onnx/reference/ops/op_sequence_erase.py

@@ -7,7 +7,7 @@ from onnx.reference.op_run import OpRun
 
 
 class SequenceErase(OpRun):
-    def _run(self, S, ind=None):  # type: ignore
+    def _run(self, S, ind=None):
         if ind is None:
             ind = -1
         else:

onnx/reference/ops/op_sequence_insert.py

@@ -38,7 +38,7 @@ def sequence_insert_reference_implementation(
 
 
 class SequenceInsert(OpRun):
-    def _run(self, S, T, ind=None):  # type: ignore
+    def _run(self, S, T, ind=None):
         if ind is None:
             res = sequence_insert_reference_implementation(S, T)
         elif isinstance(ind, int):

onnx/reference/ops/op_sequence_length.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class SequenceLength(OpRun):
-    def _run(self, input_sequence):  # type: ignore
+    def _run(self, input_sequence):
         if not isinstance(input_sequence, list):
             raise TypeError(
                 f"input_sequence must be a list not {type(input_sequence)}."

onnx/reference/ops/op_sequence_map.py

@@ -7,7 +7,7 @@ from onnx.reference.op_run import OpRun
 
 
 class SequenceMap(OpRun):
-    def _run(self, input_sequence, *additional_inputs, body=None, attributes=None):  # type: ignore
+    def _run(self, input_sequence, *additional_inputs, body=None, attributes=None):
         if len(additional_inputs) == 1 and isinstance(additional_inputs[0], list):
             res = None
             for obj1, obj2 in zip(input_sequence, additional_inputs[0]):
@@ -18,7 +18,7 @@ class SequenceMap(OpRun):
                 else:
                     for s, i in zip(res, r):
                         s.append(i)
-            return tuple(res)  # type: ignore
+            return tuple(res)
 
         feeds = dict(zip(body.input_names[1:], additional_inputs))
         res = None
@@ -30,4 +30,4 @@ class SequenceMap(OpRun):
             else:
                 for s, i in zip(res, r):
                     s.append(i)
-        return tuple(res)  # type: ignore
+        return tuple(res)

onnx/reference/ops/op_shape.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Shape_1(OpRun):
-    def _run(self, data):  # type: ignore
+    def _run(self, data):
         return (np.array(data.shape, dtype=np.int64),)
 
 
@@ -23,12 +23,12 @@ class Shape_15(Shape_1):
                 return (0, n + end)
             return (0, end)
         if end is None or np.isnan(end):
-            return (start, n)  # type: ignore
+            return (start, n)
         if end < 0:
-            return (start, n + end)  # type: ignore
-        return (start, end)  # type: ignore
+            return (start, n + end)
+        return (start, end)
 
-    def _run(self, data, end=None, start=None):  # type: ignore
+    def _run(self, data, end=None, start=None):
         ab = self._interval(len(data.shape), start=start, end=end)
         if ab is None:
             return (np.array(data.shape, dtype=np.int64),)

onnx/reference/ops/op_shrink.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Shrink(OpRun):
-    def _run(self, x, bias=None, lambd=None):  # type: ignore
+    def _run(self, x, bias=None, lambd=None):
         return (
             np.where(
                 x < -lambd,

onnx/reference/ops/op_sigmoid.py

@@ -8,18 +8,18 @@ import numpy as np
 from onnx.reference.ops._op import OpRunUnaryNum
 
 
-def sigmoid(x):  # type: ignore
+def sigmoid(x):
     if x > 0:
         return 1 / (1 + np.exp(-x))
     return np.exp(x) / (1 + np.exp(x))
 
 
 class Sigmoid(OpRunUnaryNum):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRunUnaryNum.__init__(self, onnx_node, run_params)
         self.vf = np.vectorize(sigmoid)
 
-    def _run(self, X):  # type: ignore
+    def _run(self, X):
         if len(X.shape) == 0:
             return (sigmoid(X).astype(X.dtype),)
         if X.size == 0:

onnx/reference/ops/op_sign.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Sign(OpRunUnaryNum):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (np.sign(x),)

onnx/reference/ops/op_sin.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Sin(OpRunUnaryNum):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (np.sin(x),)

onnx/reference/ops/op_sinh.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Sinh(OpRunUnaryNum):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (np.sinh(x),)

onnx/reference/ops/op_size.py

@@ -9,5 +9,5 @@ from onnx.reference.op_run import OpRun
 
 
 class Size(OpRun):
-    def _run(self, data):  # type: ignore
+    def _run(self, data):
         return (np.array(data.size, dtype=np.int64),)

onnx/reference/ops/op_slice.py

@@ -42,7 +42,7 @@ def _slice(
             for s, e, a, d in zip(starts, ends, axes, steps):
                 slices[a] = slice(s, e, d)
     try:
-        return data[tuple(slices)]  # type: ignore
+        return data[tuple(slices)]
     except TypeError as e:  # pragma: no cover
         raise TypeError(
             f"Unable to extract slice {slices!r} for shape {data.shape!r}."
@@ -50,18 +50,18 @@ def _slice(
 
 
 class SliceCommon(OpRun):
-    def _run(self, data, starts, ends, axes=None, steps=None):  # type: ignore
+    def _run(self, data, starts, ends, axes=None, steps=None):
         res = _slice(data, starts, ends, axes, steps)
         return (res,)
 
 
 class Slice_10(SliceCommon):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         SliceCommon.__init__(self, onnx_node, run_params)
 
 
 class Slice_1(SliceCommon):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         SliceCommon.__init__(self, onnx_node, run_params)
         for f in ["starts", "ends", "steps", "axes"]:
             if not hasattr(self, f):
@@ -69,5 +69,5 @@ class Slice_1(SliceCommon):
             if getattr(self, f) is not None and len(getattr(self, f)) == 0:
                 setattr(self, f, None)
 
-    def _run(self, data, axes=None, ends=None, starts=None):  # type: ignore
+    def _run(self, data, axes=None, ends=None, starts=None):
         return SliceCommon._run(self, data, starts, ends, axes)

onnx/reference/ops/op_softmax.py

@@ -9,9 +9,9 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Softmax(OpRunUnaryNum):
-    def _run(self, X, axis=None):  # type: ignore
-        axis = axis or self.axis  # type: ignore
-        tmp = X - X.max(axis=axis, keepdims=1)  # type: ignore
+    def _run(self, X, axis=None):
+        axis = axis or self.axis
+        tmp = X - X.max(axis=axis, keepdims=1)
         Y = np.exp(tmp)
-        Y /= Y.sum(axis=axis, keepdims=1)  # type: ignore
+        Y /= Y.sum(axis=axis, keepdims=1)
         return (Y.astype(X.dtype),)

onnx/reference/ops/op_softmax_cross_entropy_loss.py

@@ -8,7 +8,7 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def softmaxcrossentropy(  # type: ignore
+def softmaxcrossentropy(
     x, target, weight=None, reduction="mean", ignore_index=None, get_log_prob=None
 ):
     input_shape = x.shape
@@ -82,8 +82,8 @@ def softmaxcrossentropy(  # type: ignore
 
 
 class SoftmaxCrossEntropyLoss(OpRun):
-    def _run(self, x, target, weight=None, ignore_index=None, reduction=None):  # type: ignore
-        n_outputs = len(self.onnx_node.output)  # type: ignore
+    def _run(self, x, target, weight=None, ignore_index=None, reduction=None):
+        n_outputs = len(self.onnx_node.output)
         return softmaxcrossentropy(
             x,
             target,

onnx/reference/ops/op_softplus.py

@@ -9,8 +9,8 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Softplus(OpRunUnaryNum):
-    def _run(self, X):  # type: ignore
-        tmp = np.exp(X).astype(X.dtype)
+    def _run(self, X):
+        tmp = np.asarray(np.exp(X), dtype=X.dtype)
         tmp += 1
         np.log(tmp, out=tmp)
         return (tmp,)

onnx/reference/ops/op_softsign.py

@@ -9,7 +9,7 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Softsign(OpRunUnaryNum):
-    def _run(self, X):  # type: ignore
+    def _run(self, X):
         tmp = np.abs(X)
         tmp += 1
         np.divide(X, tmp, out=tmp)

onnx/reference/ops/op_space_to_depth.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class SpaceToDepth(OpRun):
-    def _run(self, data, blocksize=None):  # type: ignore
+    def _run(self, data, blocksize=None):
         if len(data.shape) != 4:
             raise RuntimeError(f"Unexpected shape {data.shape!r}.")
         b, C, H, W = data.shape

onnx/reference/ops/op_split.py

@@ -7,11 +7,11 @@ from onnx.reference.op_run import OpRun
 
 
 class CommonSplit(OpRun):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRun.__init__(self, onnx_node, run_params)
         self.n_outputs = len(onnx_node.output)
 
-    def common_run(self, mat, split, axis, num_outputs):  # type: ignore
+    def common_run(self, mat, split, axis, num_outputs):
         n_outputs = num_outputs or self.n_outputs
         if split is None:
             if mat.shape[axis] % n_outputs == 0:
@@ -20,21 +20,21 @@ class CommonSplit(OpRun):
             else:
                 div = mat.shape[axis] // n_outputs + 1
                 split = [div] * n_outputs
-                split[-1] += mat.shape[axis] - sum(split)  # type: ignore
+                split[-1] += mat.shape[axis] - sum(split)
 
         sli = [slice(0, s) for s in mat.shape]
         res = []
         pos = 0
         for spl in split:
-            sli[axis] = slice(pos, pos + spl)  # type: ignore
+            sli[axis] = slice(pos, pos + spl)
             pos += spl
             res.append(mat[tuple(sli)])
         return tuple(res)
 
 
 class Split_2(CommonSplit):
-    def _run(self, mat, axis=None, split=None):  # type: ignore
-        return self.common_run(mat, split, axis=axis, num_outputs=None)  # type: ignore
+    def _run(self, mat, axis=None, split=None):
+        return self.common_run(mat, split, axis=axis, num_outputs=None)
 
 
 class Split_11(Split_2):
@@ -42,10 +42,10 @@ class Split_11(Split_2):
 
 
 class Split_13(CommonSplit):
-    def _run(self, mat, split=None, axis=None):  # type: ignore
+    def _run(self, mat, split=None, axis=None):
         return self.common_run(mat, split, axis=axis, num_outputs=None)
 
 
 class Split_18(CommonSplit):
-    def _run(self, mat, split=None, axis=None, num_outputs=None):  # type: ignore
+    def _run(self, mat, split=None, axis=None, num_outputs=None):
         return self.common_run(mat, split, axis=axis, num_outputs=num_outputs)

onnx/reference/ops/op_split_to_sequence.py

@@ -33,7 +33,7 @@ class SplitToSequence(OpRun):
         res = []
         pos = 0
         for spl in split_length:
-            sli[axis] = slice(pos, pos + spl)  # type: ignore
+            sli[axis] = slice(pos, pos + spl)
             pos += spl
             res.append(mat[tuple(sli)])
         return res

onnx/reference/ops/op_sqrt.py

@@ -11,7 +11,7 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Sqrt(OpRunUnaryNum):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         with catch_warnings():
             simplefilter("ignore")
             return (np.sqrt(x).astype(x.dtype),)

onnx/reference/ops/op_squeeze.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Squeeze_1(OpRun):
-    def _run(self, data, axes=None):  # type: ignore
+    def _run(self, data, axes=None):
         if isinstance(axes, np.ndarray):
             axes = tuple(axes)
         elif axes in [[], ()]:
@@ -30,11 +30,11 @@ class Squeeze_11(Squeeze_1):
 
 
 class Squeeze_13(OpRun):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRun.__init__(self, onnx_node, run_params)
         self.axes = None
 
-    def _run(self, data, axes=None):  # type: ignore
+    def _run(self, data, axes=None):
         if axes is not None:
             if hasattr(axes, "__iter__"):
                 sq = np.squeeze(data, axis=tuple(axes))