onnx 1.17.0__cp311-cp311-win32.whl → 1.19.0__cp311-cp311-win32.whl

onnx/reference/ops/op_batch_normalization.py

@@ -23,7 +23,7 @@ def _batchnorm_test_mode(
     mean = mean.reshape(-1, *dim_ones)
     var = var.reshape(-1, *dim_ones)
     y = s * (x - mean) / np.sqrt(var + epsilon) + bias
-    return y.astype(x.dtype)  # type: ignore
+    return y.astype(x.dtype)
 
 
 def _batchnorm_training_mode(
@@ -41,7 +41,7 @@ def _batchnorm_training_mode(
     output_mean = mean * momentum + saved_mean * (1 - momentum)
     output_var = var * momentum + saved_var * (1 - momentum)
     y = _batchnorm_test_mode(x, s, bias, saved_mean, saved_var, epsilon=epsilon)
-    return (  # type: ignore
+    return (
         y.astype(x.dtype),
         saved_mean.astype(x.dtype),
         saved_var.astype(x.dtype),
@@ -62,7 +62,7 @@ class BatchNormalization_6(OpRun):
         is_test=None,
         momentum=None,
         spatial=None,  # noqa: ARG002
-    ):  # type: ignore
+    ):
         if is_test:
             res = _batchnorm_test_mode(x, scale, bias, mean, var, epsilon=epsilon)
         else:
@@ -73,7 +73,7 @@ class BatchNormalization_6(OpRun):
 
 
 class BatchNormalization_9(OpRun):
-    def _run(self, x, scale, bias, mean, var, epsilon=None, momentum=None):  # type: ignore
+    def _run(self, x, scale, bias, mean, var, epsilon=None, momentum=None):
         if momentum is None:
             res = _batchnorm_test_mode(x, scale, bias, mean, var, epsilon=epsilon)
             return (res,)
@@ -89,10 +89,10 @@ class BatchNormalization_9(OpRun):
 
 
 class BatchNormalization_14(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self, x, scale, bias, mean, var, epsilon=None, momentum=None, training_mode=None
     ):
-        if training_mode == 0:  # type: ignore
+        if training_mode == 0:
             res = _batchnorm_test_mode(x, scale, bias, mean, var, epsilon=epsilon)
             return (res,)
         res, __, _, output_mean, output_var = _batchnorm_training_mode(

onnx/reference/ops/op_bernoulli.py

@@ -8,7 +8,7 @@ from onnx.reference.ops._op_common_random import _CommonRandom
 
 
 class Bernoulli(_CommonRandom):
-    def _run(self, x, dtype=None, seed=None):  # type: ignore
+    def _run(self, x, dtype=None, seed=None):
         if dtype is None:
             dtype = np_dtype_to_tensor_dtype(x.dtype)
         dtype = self._dtype(x, dtype=dtype, dtype_first=True)

onnx/reference/ops/op_bitshift.py

@@ -9,9 +9,9 @@ from onnx.reference.ops._op import OpRunBinaryNumpy
 
 
 class BitShift(OpRunBinaryNumpy):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRunBinaryNumpy.__init__(self, np.right_shift, onnx_node, run_params)
-        if self.direction not in ("LEFT", "RIGHT"):  # type: ignore
-            raise ValueError(f"Unexpected value for direction ({self.direction!r}).")  # type: ignore
-        if self.direction == "LEFT":  # type: ignore
+        if self.direction not in ("LEFT", "RIGHT"):
+            raise ValueError(f"Unexpected value for direction ({self.direction!r}).")
+        if self.direction == "LEFT":
             self.numpy_fct = np.left_shift

onnx/reference/ops/op_bitwise_and.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunBinary
 
 
 class BitwiseAnd(OpRunBinary):
-    def _run(self, x, y):  # type: ignore
+    def _run(self, x, y):
         return (np.bitwise_and(x, y),)

onnx/reference/ops/op_bitwise_or.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunBinary
 
 
 class BitwiseOr(OpRunBinary):
-    def _run(self, x, y):  # type: ignore
+    def _run(self, x, y):
         return (np.bitwise_or(x, y),)

onnx/reference/ops/op_bitwise_xor.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunBinary
 
 
 class BitwiseXor(OpRunBinary):
-    def _run(self, x, y):  # type: ignore
+    def _run(self, x, y):
         return (np.bitwise_xor(x, y),)

onnx/reference/ops/op_blackman_window.py

@@ -17,7 +17,7 @@ class BlackmanWindow(_CommonWindow):
     See `blackman_window <https://pytorch.org/docs/stable/generated/torch.blackman_window.html>`_
     """
 
-    def _run(self, size, output_datatype=None, periodic=None):  # type: ignore
+    def _run(self, size, output_datatype=None, periodic=None):
         ni, N_1 = np.arange(size), size
         if periodic == 0:
             N_1 = N_1 - 1

onnx/reference/ops/op_cast.py

@@ -5,139 +5,45 @@ from __future__ import annotations
 
 import numpy as np
 
-from onnx import subbyte
-from onnx._custom_element_types import (
-    bfloat16,
-    float8e4m3fn,
-    float8e4m3fnuz,
-    float8e5m2,
-    float8e5m2fnuz,
-    int4,
-    uint4,
-)
-from onnx.helper import (
-    float32_to_bfloat16,
-    float32_to_float8e4m3,
-    float32_to_float8e5m2,
-    tensor_dtype_to_np_dtype,
-)
-from onnx.numpy_helper import (
-    bfloat16_to_float32,
-    float8e4m3_to_float32,
-    float8e5m2_to_float32,
-)
-from onnx.onnx_pb import TensorProto
+import onnx
 from onnx.reference.op_run import OpRun
 
 
-def cast_to(x, to, saturate):  # noqa: PLR0911
-    if x.dtype == bfloat16 and x.dtype.descr[0][0] == "bfloat16":
-        if to == TensorProto.BFLOAT16:
-            return x
-        xr = x.ravel()
-        xf = np.empty(xr.shape[0], dtype=np.float32)
-        for i in range(xr.shape[0]):
-            el = bfloat16_to_float32(xr[i])
-            xf[i] = el
-        dtype = tensor_dtype_to_np_dtype(to)
-        return xf.astype(dtype).reshape(x.shape)
-
-    f8 = {
-        (float8e4m3fn, "e4m3fn", TensorProto.FLOAT8E4M3FN): float8e4m3_to_float32,
-        (
-            float8e4m3fnuz,
-            "e4m3fnuz",
-            TensorProto.FLOAT8E4M3FNUZ,
-        ): lambda *args: float8e4m3_to_float32(*args, uz=True),
-        (float8e5m2, "e5m2", TensorProto.FLOAT8E5M2): float8e5m2_to_float32,
-        (
-            float8e5m2fnuz,
-            "e5m2fnuz",
-            TensorProto.FLOAT8E5M2FNUZ,
-        ): lambda *args: float8e5m2_to_float32(*args, fn=True, uz=True),
-    }
-
-    for (dt, st, proto_type), cvt in f8.items():
-        if x.dtype == dt and x.dtype.descr[0][0] == st:
-            if to == proto_type:
-                return x
-            xr = x.ravel()
-            xf = np.empty(xr.shape[0], dtype=np.float32)
-            for i in range(xr.shape[0]):
-                el = cvt(xr[i])
-                xf[i] = el
-            dtype = tensor_dtype_to_np_dtype(to)
-            return xf.astype(dtype).reshape(x.shape)
-
-    if to == TensorProto.BFLOAT16:
-        xf = x.astype(np.float32).ravel()
-        y = np.empty(xf.shape, dtype=bfloat16).ravel()
-        for i in range(y.shape[0]):
-            el = float32_to_bfloat16(xf[i], truncate=True)  # type: ignore[assignment]
-            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
-            # This operator preduces a tensor with the same shape for INT4.
-            return y.reshape(x.shape)
-
-    f8back = {
-        TensorProto.FLOAT8E4M3FN: (
-            float8e4m3fn,
-            lambda *args: float32_to_float8e4m3(*args, saturate=saturate),
-        ),
-        TensorProto.FLOAT8E4M3FNUZ: (
-            float8e4m3fnuz,
-            lambda *args: float32_to_float8e4m3(*args, uz=True, saturate=saturate),
-        ),
-        TensorProto.FLOAT8E5M2: (
-            float8e5m2,
-            lambda *args: float32_to_float8e5m2(*args, saturate=saturate),
-        ),
-        TensorProto.FLOAT8E5M2FNUZ: (
-            float8e5m2fnuz,
-            lambda *args: float32_to_float8e5m2(
-                *args, fn=True, uz=True, saturate=saturate
-            ),
-        ),
-    }
-    for dt, (npdt, cvt) in f8back.items():
-        if to == dt:
-            xf = x.astype(np.float32).ravel()
-            y = np.empty(xf.shape, dtype=npdt).ravel()
-            for i in range(y.shape[0]):
-                el = cvt(xf[i])  # type: ignore[assignment]
-                y[i] = el
-            return y.reshape(x.shape)
-
-    if to == TensorProto.STRING:
+def cast_to(
+    x: np.ndarray, to: onnx.TensorProto.DataType, saturate: bool, round_mode: str = "up"
+):
+    if to == onnx.TensorProto.STRING:
         return x.astype(np.str_)
 
-    dtype = tensor_dtype_to_np_dtype(to)
+    dtype = onnx.helper.tensor_dtype_to_np_dtype(to)
+    if (
+        to
+        in {
+            onnx.TensorProto.FLOAT8E4M3FN,
+            onnx.TensorProto.FLOAT8E4M3FNUZ,
+            onnx.TensorProto.FLOAT8E5M2,
+            onnx.TensorProto.FLOAT8E5M2FNUZ,
+        }
+        and saturate
+    ):
+        return onnx.numpy_helper.saturate_cast(x, dtype)
+
+    if to == onnx.TensorProto.FLOAT8E8M0:
+        return onnx.numpy_helper.to_float8e8m0(x, saturate, round_mode).astype(dtype)
+
     return x.astype(dtype)
 
 
 class Cast_1(OpRun):
-    def _run(self, x, to=None):  # type: ignore
-        return (cast_to(x, to, saturate=True),)
+    def _run(self, x, to=None):
+        return (cast_to(x, to, saturate=True, round_mode="up"),)
 
 
 class Cast_19(OpRun):
-    def _run(self, x, to=None, saturate=None):  # type: ignore
-        return (cast_to(x, to, saturate),)
+    def _run(self, x, to=None, saturate=None):
+        return (cast_to(x, to, saturate, round_mode="up"),)
+
+
+class Cast_24(OpRun):
+    def _run(self, x, to=None, saturate=None, round_mode=None):
+        return (cast_to(x, to, saturate, round_mode),)

onnx/reference/ops/op_cast_like.py

@@ -4,46 +4,19 @@
 from __future__ import annotations
 
 from onnx.helper import np_dtype_to_tensor_dtype
-from onnx.onnx_pb import TensorProto
 from onnx.reference.op_run import OpRun
-from onnx.reference.ops.op_cast import (
-    bfloat16,
-    cast_to,
-    float8e4m3fn,
-    float8e4m3fnuz,
-    float8e5m2,
-    float8e5m2fnuz,
-    int4,
-    uint4,
-)
-
-
-def _cast_like(x, y, saturate):
-    if y.dtype == bfloat16 and y.dtype.descr[0][0] == "bfloat16":
-        # np.uint16 == np.uint16 is True as well as np.uint16 == bfloat16
-        to = TensorProto.BFLOAT16
-    elif y.dtype == float8e4m3fn and y.dtype.descr[0][0] == "e4m3fn":
-        to = TensorProto.FLOAT8E4M3FN
-    elif y.dtype == float8e4m3fnuz and y.dtype.descr[0][0] == "e4m3fnuz":
-        to = TensorProto.FLOAT8E4M3FNUZ
-    elif y.dtype == float8e5m2 and y.dtype.descr[0][0] == "e5m2":
-        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),)
+from onnx.reference.ops.op_cast import cast_to
+
+
+def _cast_like(x, y, saturate: bool):
+    return (cast_to(x, np_dtype_to_tensor_dtype(y.dtype), saturate),)
 
 
 class CastLike_15(OpRun):
-    def _run(self, x, y):  # type: ignore
+    def _run(self, x, y):
         return _cast_like(x, y, True)
 
 
 class CastLike_19(OpRun):
-    def _run(self, x, y, saturate=None):  # type: ignore
+    def _run(self, x, y, saturate=False):
         return _cast_like(x, y, saturate)

onnx/reference/ops/op_ceil.py

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

onnx/reference/ops/op_celu.py

@@ -11,9 +11,9 @@ from onnx.reference.op_run import OpRun
 def _vcelu1(x: np.ndarray, alpha: float = 1.0) -> np.ndarray:
     positive_input = np.maximum(0, x)
     negative_input = np.minimum(0, alpha * (np.exp(x / alpha) - 1))
-    return positive_input + negative_input  # type: ignore
+    return positive_input + negative_input
 
 
 class Celu(OpRun):
-    def _run(self, x, alpha=None):  # type: ignore
+    def _run(self, x, alpha=None):
         return (_vcelu1(x, alpha).astype(x.dtype),)

onnx/reference/ops/op_center_crop_pad.py

@@ -9,8 +9,8 @@ from onnx.reference.op_run import OpRun
 
 
 class CenterCropPad(OpRun):
-    def _run(self, input_data, shape, axes=None):  # type: ignore
-        axes = axes or self.axes  # type: ignore
+    def _run(self, input_data, shape, axes=None):
+        axes = axes or self.axes
         input_rank = len(input_data.shape)
         if axes is None:
             axes = list(range(input_rank))

onnx/reference/ops/op_clip.py

@@ -12,12 +12,12 @@ class Clip_6(OpRun):
     def _run(self, data, min=None, max=None):  # type: ignore  # noqa: A002
         amin = min
         amax = max
-        res = data if amin is amax is None else np.clip(data, amin, amax)  # type: ignore
+        res = data if amin is amax is None else np.clip(data, amin, amax)
         return (res,) if res.dtype == data.dtype else (res.astype(data.dtype),)
 
 
 class Clip_11(OpRun):
-    def _run(self, data, *minmax):  # type: ignore
+    def _run(self, data, *minmax):
         le = len(minmax)
         amin = minmax[0] if le > 0 else None
         amax = minmax[1] if le > 1 else None

onnx/reference/ops/op_col2im.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 from onnx.reference.ops._op_common_indices import _get_indices, _is_out
 
 
-def _col2im_shape_check_2d(X, output_shape, kernel_shape, dilations, pads, strides):  # type: ignore
+def _col2im_shape_check_2d(X, output_shape, kernel_shape, dilations, pads, strides):
     output_height, output_width = output_shape
     kernel_height, kernel_width = kernel_shape
     dilation_height, dilation_width = dilations
@@ -64,7 +64,7 @@ def _col2im_shape_check_2d(X, output_shape, kernel_shape, dilations, pads, strid
 
 def _col2im_naive_implementation_2d(
     res, image_shape, kernel_shape, dilations, pads, strides
-):  # type: ignore
+):
     # source: https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/im2col.h
 
     n_dims = len(pads) // 2
@@ -107,7 +107,7 @@ def _col2im_naive_implementation_2d(
     return data_im.reshape(image_shape)
 
 
-def _col2im_shape_check(X, output_shape, kernel_shape, dilations, pads, strides):  # type: ignore
+def _col2im_shape_check(X, output_shape, kernel_shape, dilations, pads, strides):
     n_input_plane = X.shape[0]
 
     kernel_size = np.prod(kernel_shape)
@@ -146,7 +146,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`."""
     n_dims = len(pads) // 2
     new_pads = np.array([(pads[i], pads[i + n_dims]) for i in range(n_dims)])
@@ -187,7 +187,7 @@ def col2im_naive_implementation(
 class Col2Im(OpRun):
     def _run(
         self, data, image_shape, block_shape, dilations=None, pads=None, strides=None
-    ):  # type: ignore
+    ):
         if dilations is None:
             dilations = [1 for s in image_shape]
         if pads is None:
@@ -197,7 +197,7 @@ class Col2Im(OpRun):
 
         bl = np.prod(block_shape)
         C = data.shape[1] // bl
-        data = data.reshape(data.shape[:1] + (C,) + (bl,) + data.shape[2:])
+        data = data.reshape((*data.shape[:1], C, bl, *data.shape[2:]))
 
         ks = tuple(block_shape)
         res = None
@@ -210,4 +210,4 @@ class Col2Im(OpRun):
                     new_shape = data.shape[:2] + out.shape
                     res = np.empty(new_shape, dtype=data.dtype)
                 res[n, c, ...] = out
-        return (res,)  # type: ignore
+        return (res,)

onnx/reference/ops/op_compress.py

@@ -9,5 +9,5 @@ from onnx.reference.op_run import OpRun
 
 
 class Compress(OpRun):
-    def _run(self, x, condition, axis=None):  # type: ignore
-        return (np.compress(condition, x, axis=axis),)  # type: ignore
+    def _run(self, x, condition, axis=None):
+        return (np.compress(condition, x, axis=axis),)

onnx/reference/ops/op_concat.py

@@ -12,11 +12,11 @@ class Concat(OpRun):
     def _preprocess(self, a: np.ndarray, axis: int) -> np.ndarray:
         if len(a.shape) == 0:
             raise RuntimeError(f"Concat: one input has an empty shape: {a!r}.")
-        if axis >= len(a.shape):  # type: ignore
-            new_shape = a.shape + (1,) * (axis + 1 - len(a.shape))  # type: ignore
+        if axis >= len(a.shape):
+            new_shape = a.shape + (1,) * (axis + 1 - len(a.shape))
             return a.reshape(new_shape)
         return a
 
-    def _run(self, *args, axis=None):  # type: ignore
+    def _run(self, *args, axis=None):
         targs = tuple(self._preprocess(a, axis) for a in args)
-        return (np.concatenate(targs, axis),)  # type: ignore
+        return (np.concatenate(targs, axis),)

onnx/reference/ops/op_concat_from_sequence.py

@@ -12,15 +12,19 @@ from onnx.reference.op_run import OpRun
 
 def _concat_from_sequence(seq: list[Any], axis: int, new_axis: int = 0) -> np.ndarray:
     if new_axis == 1:
-        seq2 = [s[..., np.newaxis] for s in seq]
-        res = np.concatenate(seq2, axis=-1)
+        if axis == -1:
+            seq2 = [s[..., np.newaxis] for s in seq]
+            res = np.concatenate(seq2, axis=-1)
+        else:
+            seq2 = [np.expand_dims(s, axis) for s in seq]
+            res = np.concatenate(seq2, axis=axis)
     else:
         res = np.concatenate(seq, axis=axis)
-    return res  # type: ignore
+    return res
 
 
 class ConcatFromSequence(OpRun):
-    def _run(self, seq, axis=None, new_axis=None):  # type: ignore
+    def _run(self, seq, axis=None, new_axis=None):
         if seq is None:
             raise RuntimeError("A sequence cannot be null.")
         res = _concat_from_sequence(seq, axis, new_axis=new_axis)

onnx/reference/ops/op_constant.py

@@ -5,63 +5,31 @@ from __future__ import annotations
 
 import numpy as np
 
-from onnx._custom_element_types import (
-    bfloat16,
-    float8e4m3fn,
-    float8e4m3fnuz,
-    float8e5m2,
-    float8e5m2fnuz,
-    int4,
-    uint4,
-)
 from onnx.reference.op_run import OpRun, RefAttrName
 
 
-def _check_dtype(val):  # type: ignore
-    a = val.dtype
-    if not isinstance(a, np.dtype) and a not in {
-        bfloat16,
-        float8e4m3fn,
-        float8e4m3fnuz,
-        float8e5m2,
-        float8e5m2fnuz,
-        uint4,
-        int4,
-        np.int8,
-        np.uint8,
-        np.float16,
-        np.float32,
-        np.float64,
-        np.int32,
-        np.int64,
-        np.int16,
-        np.uint16,
-        np.uint32,
-        np.bool_,
-        np.str_,
-        np.uint64,
-        bool,
-        str,
-    }:
+def _check_dtype(val):
+    dtype = val.dtype
+    if not isinstance(dtype, np.dtype):
         raise TypeError(
-            f"Type ({a}, {type(a)}) is not a numpy type (operator 'Constant')"
+            f"Type ({dtype}, {type(dtype)}) is not a numpy type (operator 'Constant')"
         )
 
 
 class ConstantCommon(OpRun):
-    def _check(self, cst):  # type: ignore
+    def _check(self, cst):
         if isinstance(cst, tuple):
             raise TypeError(f"Unexpected type {type(cst)} for a constant.")
         return cst
 
 
 class Constant_1(ConstantCommon):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         ConstantCommon.__init__(self, onnx_node, run_params)
-        self.cst = self.value  # type: ignore
+        self.cst = self.value
         _check_dtype(self.cst)
 
-    def _run(self, **overridden_attributes):  # type: ignore
+    def _run(self, **overridden_attributes):
         if overridden_attributes and (
             len(overridden_attributes) > 1
             or "value" not in overridden_attributes
@@ -74,20 +42,20 @@ class Constant_1(ConstantCommon):
 
 
 class Constant_9(Constant_1):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         Constant_1.__init__(self, onnx_node, run_params)
 
 
 class Constant_11(ConstantCommon):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         ConstantCommon.__init__(self, onnx_node, run_params)
         if getattr(self, "sparse_value", None) is None:
-            self.cst = self.value  # type: ignore
+            self.cst = self.value
         else:
-            self.cst = self.sparse_value  # type: ignore
+            self.cst = self.sparse_value
         _check_dtype(self.cst)
 
-    def _run(self, **overridden_attributes):  # type: ignore
+    def _run(self, **overridden_attributes):
         if overridden_attributes and (
             len(overridden_attributes) > 1
             or "value" not in overridden_attributes
@@ -100,15 +68,15 @@ class Constant_11(ConstantCommon):
 
 
 class Constant_12(ConstantCommon):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         ConstantCommon.__init__(self, onnx_node, run_params)
-        if hasattr(self, "sparse_value") and self.sparse_value is not None:  # type: ignore
+        if hasattr(self, "sparse_value") and self.sparse_value is not None:
             self.cst_name = "sparse_value"
-            self.cst = self.sparse_value  # type: ignore
+            self.cst = self.sparse_value
             self.cst_convert = lambda v: v
-        elif hasattr(self, "value") and self.value is not None:  # type: ignore
-            self.cst_name = "value"  # type: ignore
-            self.cst = self.value if isinstance(self.value, RefAttrName) else self.value  # type: ignore
+        elif hasattr(self, "value") and self.value is not None:
+            self.cst_name = "value"
+            self.cst = self.value
             self.cst_convert = lambda v: v
         else:
             for attr, np_dtype in {
@@ -119,15 +87,13 @@ class Constant_12(ConstantCommon):
                 "value_string": np.str_,
                 "value_strings": np.str_,
             }.items():
-                if hasattr(self, attr) and getattr(self, attr) is not None:  # type: ignore
+                if hasattr(self, attr) and getattr(self, attr) is not None:
                     self.cst_name = attr
                     v = getattr(self, attr)
                     self.cst = (
-                        v  # type: ignore
-                        if isinstance(v, RefAttrName)  # type: ignore
-                        else np.array(v, dtype=np_dtype)  # type: ignore
+                        v if isinstance(v, RefAttrName) else np.array(v, dtype=np_dtype)
                     )
-                    self.cst_convert = lambda v, np_dtype=np_dtype: np.array(  # type: ignore
+                    self.cst_convert = lambda v, np_dtype=np_dtype: np.array(
                         v, dtype=np_dtype
                     )
                     break
@@ -136,7 +102,7 @@ class Constant_12(ConstantCommon):
                 f"No constant is defined for operator 'Constant', outputs are {onnx_node.output}."
             )
 
-    def _run(self, **overridden_attributes):  # type: ignore
+    def _run(self, **overridden_attributes):
         if self.has_linked_attribute:
             if overridden_attributes is None:
                 raise RuntimeError(