onnx 1.17.0__cp310-cp310-macosx_12_0_universal2.whl → 1.19.0__cp310-cp310-macosx_12_0_universal2.whl

onnx/reference/ops/op_flatten.py

@@ -9,8 +9,8 @@ from onnx.reference.ops._op import OpRunUnary
 
 
 class Flatten(OpRunUnary):
-    def _run(self, x, axis=None):  # type: ignore
-        i = axis or self.axis  # type: ignore
+    def _run(self, x, axis=None):
+        i = axis or self.axis
         shape = x.shape
         new_shape = (1, -1) if i == 0 else (np.prod(shape[:i]).astype(int), -1)
-        return (x.reshape(new_shape),)  # type: ignore
+        return (x.reshape(new_shape),)

onnx/reference/ops/op_floor.py

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

onnx/reference/ops/op_gather.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Gather(OpRun):
-    def _run(self, x, indices, axis=None):  # type: ignore
+    def _run(self, x, indices, axis=None):
         if not x.flags["C_CONTIGUOUS"]:
             x = np.ascontiguousarray(x)
         if not indices.flags["C_CONTIGUOUS"]:

onnx/reference/ops/op_gather_elements.py

@@ -37,7 +37,7 @@ def gather_numpy(self: np.ndarray, dim: int, index: np.ndarray) -> np.ndarray:
 
 
 class GatherElements(OpRun):
-    def _run(self, data, indices, axis=None):  # type: ignore
+    def _run(self, data, indices, axis=None):
         if indices.size == 0:
             return (np.empty((0,), dtype=data.dtype),)
         try:

onnx/reference/ops/op_gathernd.py

@@ -43,7 +43,7 @@ def _gather_nd_impl(
 
     # Flatten 'data' to array of shape
     # (batch_dim_size, data.shape[batch_dimes:]).
-    reshaped_data = data.reshape((batch_dims_size,) + data.shape[batch_dims:])
+    reshaped_data = data.reshape((batch_dims_size, *data.shape[batch_dims:]))
 
     # Gather each scalar value from 'data'.
     for batch_dim in range(reshaped_indices.shape[0]):
@@ -54,5 +54,5 @@ def _gather_nd_impl(
 
 
 class GatherND(OpRun):
-    def _run(self, data, indices, batch_dims=None):  # type: ignore
-        return _gather_nd_impl(data, indices, batch_dims)  # type: ignore
+    def _run(self, data, indices, batch_dims=None):
+        return _gather_nd_impl(data, indices, batch_dims)

onnx/reference/ops/op_gemm.py

@@ -8,28 +8,28 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def _gemm00(a, b, c, alpha, beta):  # type: ignore
+def _gemm00(a, b, c, alpha, beta):
     o = np.dot(a, b) * alpha
     if c is not None and beta != 0:
         o += c * beta
     return o
 
 
-def _gemm01(a, b, c, alpha, beta):  # type: ignore
+def _gemm01(a, b, c, alpha, beta):
     o = np.dot(a, b.T) * alpha
     if c is not None and beta != 0:
         o += c * beta
     return o
 
 
-def _gemm10(a, b, c, alpha, beta):  # type: ignore
+def _gemm10(a, b, c, alpha, beta):
     o = np.dot(a.T, b) * alpha
     if c is not None and beta != 0:
         o += c * beta
     return o
 
 
-def _gemm11(a, b, c, alpha, beta):  # type: ignore
+def _gemm11(a, b, c, alpha, beta):
     o = np.dot(a.T, b.T) * alpha
     if c is not None and beta != 0:
         o += c * beta
@@ -47,7 +47,7 @@ class Gemm_6(OpRun):
         transA=None,
         transB=None,
         broadcast=None,
-    ):  # type: ignore
+    ):
         if broadcast == 0:
             if transA:
                 _meth = _gemm11 if transB else _gemm10
@@ -69,7 +69,7 @@ class Gemm_6(OpRun):
 
 
 class Gemm_7(OpRun):
-    def _run(self, a, b, c=None, alpha=None, beta=None, transA=None, transB=None):  # type: ignore
+    def _run(self, a, b, c=None, alpha=None, beta=None, transA=None, transB=None):
         if transA:
             _meth = _gemm11 if transB else _gemm10
         else:

onnx/reference/ops/op_global_average_pool.py

@@ -13,9 +13,9 @@ def _global_average_pool(x: np.ndarray) -> np.ndarray:
     y = np.average(x, axis=axis)
     for _ in axis:
         y = np.expand_dims(y, -1)
-    return y  # type: ignore
+    return y
 
 
 class GlobalAveragePool(OpRun):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (_global_average_pool(x).astype(x.dtype),)

onnx/reference/ops/op_global_max_pool.py

@@ -13,10 +13,10 @@ def _global_max_pool(x: np.ndarray) -> np.ndarray:
     y = x.max(axis=tuple(range(spatial_shape, spatial_shape + 2)))
     for _ in range(spatial_shape):
         y = np.expand_dims(y, -1)
-    return y  # type: ignore
+    return y
 
 
 class GlobalMaxPool(OpRun):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         res = _global_max_pool(x)
         return (res,)

onnx/reference/ops/op_greater.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunBinaryComparison
 
 
 class Greater(OpRunBinaryComparison):
-    def _run(self, a, b):  # type: ignore
+    def _run(self, a, b):
         return (np.greater(a, b),)

onnx/reference/ops/op_greater_or_equal.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunBinaryComparison
 
 
 class GreaterOrEqual(OpRunBinaryComparison):
-    def _run(self, a, b):  # type: ignore
+    def _run(self, a, b):
         return (np.greater_equal(a, b),)

onnx/reference/ops/op_grid_sample.py

@@ -13,7 +13,7 @@ from onnx.reference.ops.op_resize import _get_all_coords
 
 class GridSample(OpRun):
     # https://github.com/pytorch/pytorch/blob/v2.0.0/aten/src/ATen/native/GridSampler.h#L26
-    def _gs_denormalize(self, n, length: int, align_corners: bool):  # type: ignore
+    def _gs_denormalize(self, n, length: int, align_corners: bool):
         # n is the normalized coordinate (float)
         # x is the unormalized coordinate (float)
         if align_corners:
@@ -49,7 +49,7 @@ class GridSample(OpRun):
             x[i] = self._gs_denormalize(n=v, length=dim, align_corners=align_corners)
         return x
 
-    def _gs_reflect(self, x, x_min, x_max):  # type: ignore
+    def _gs_reflect(self, x, x_min, x_max):
         """Reflect by the near border till within the borders
         Use float for borders to avoid potential issues with integer T
         """
@@ -73,7 +73,7 @@ class GridSample(OpRun):
                 fx = x_min + r
         return fx
 
-    def _gs_get_cubic_coeffs(self, x, coeffs):  # type: ignore
+    def _gs_get_cubic_coeffs(self, x, coeffs):
         """Calculate cubic convolution interpolation coefficients
         ROBERT G. KEYS https://ieeexplore.ieee.org/document/1163711
         Use float to avoid potential issues with integer.
@@ -96,7 +96,7 @@ class GridSample(OpRun):
         coeffs[0] = 1 - x
         coeffs[1] = x
 
-    def _gs_bicubic_interpolate(self, p, x, y):  # type: ignore
+    def _gs_bicubic_interpolate(self, p, x, y):
         v = np.empty((4,), dtype=p.dtype)
         coeffs = np.empty((4,), dtype=p.dtype)
         self._gs_get_cubic_coeffs(x, coeffs)
@@ -197,14 +197,14 @@ class GridSample(OpRun):
             padding_mode=padding_mode,
         )
 
-    def _clamp(self, val, lo, hi):  # type: ignore
+    def _clamp(self, val, lo, hi):
         if val < lo:
             return lo
         if val > hi:
             return hi
         return val
 
-    def _pixel_at_ndarray(self, ndarray, x: list, border, padding_mode):  # type: ignore
+    def _pixel_at_ndarray(self, ndarray, x: list, border, padding_mode):
         # boarder: [x_1_min, x_2_min, ..., x_1_max, x_2_max, ...]
         num_dims = ndarray.ndim
         assert num_dims == len(x) == int(len(border) / 2)
@@ -235,7 +235,7 @@ class GridSample(OpRun):
             padding_mode=padding_mode,
         )
 
-    def _pixel_at_array(self, array, i: int, border, padding_mode):  # type: ignore
+    def _pixel_at_array(self, array, i: int, border, padding_mode):
         assert array.ndim == 1
         d = array.shape[0]
         if padding_mode == "zeros":
@@ -289,9 +289,9 @@ class GridSample(OpRun):
     def _run(self, X, grid, mode=None, padding_mode=None, align_corners=None):
         # This implementation supports GridSample arbitrary dimensions.
 
-        mode = mode or self.mode  # type: ignore
-        padding_mode = padding_mode or self.padding_mode  # type: ignore
-        align_corners = align_corners or self.align_corners  # type: ignore
+        mode = mode or self.mode
+        padding_mode = padding_mode or self.padding_mode
+        align_corners = align_corners or self.align_corners
 
         x_dims = X.shape
         grid_dims = grid.shape

onnx/reference/ops/op_gru.py

@@ -9,18 +9,18 @@ from onnx.reference.op_run import OpRun
 
 
 class CommonGRU(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)
         self.number_of_gates = 3
 
-    def f(self, x):  # type: ignore
+    def f(self, x):
         return 1 / (1 + np.exp(-x))
 
-    def g(self, x):  # type: ignore
+    def g(self, x):
         return np.tanh(x)
 
-    def _step(self, X, R, B, W, H_0, num_directions):  # type: ignore
+    def _step(self, X, R, B, W, H_0, num_directions):
         seq_length = X.shape[0]
         hidden_size = H_0.shape[-1]
         batch_size = X.shape[1]
@@ -52,7 +52,7 @@ class CommonGRU(OpRun):
                 + r * (np.dot(H_t, np.transpose(r_h)) + r_bh)
                 + w_bh
             )
-            h = h_linear if self.linear_before_reset else h_default  # type: ignore
+            h = h_linear if self.linear_before_reset else h_default
             H = (1 - z) * h + z * H_t
             h_list.append(H)
             H_t = H
@@ -61,7 +61,7 @@ class CommonGRU(OpRun):
         if num_directions == 1:
             Y[:, 0, :, :] = concatenated
 
-        if self.layout == 0:  # type: ignore
+        if self.layout == 0:
             Y_h = Y[-1]
         else:
             Y = np.transpose(Y, [2, 0, 1, 3])
@@ -69,7 +69,7 @@ class CommonGRU(OpRun):
 
         return Y, Y_h
 
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         W,
@@ -128,5 +128,5 @@ class CommonGRU(OpRun):
 
 
 class GRU(CommonGRU):
-    def __init__(self, onnx_node, run_params):  # type: ignore
-        CommonGRU.__init__(self, onnx_node, run_params)  # type: ignore
+    def __init__(self, onnx_node, run_params):
+        CommonGRU.__init__(self, onnx_node, run_params)

onnx/reference/ops/op_hamming_window.py

@@ -15,7 +15,7 @@ class HammingWindow(_CommonWindow):
     `alpha=0.54, beta=0.46`
     """
 
-    def _run(self, size, output_datatype=None, periodic=None):  # type: ignore
+    def _run(self, size, output_datatype=None, periodic=None):
         ni, N_1 = self._begin(size, periodic, output_datatype)
         alpha = 25.0 / 46.0
         beta = 1 - alpha

onnx/reference/ops/op_hann_window.py

@@ -14,7 +14,7 @@ class HannWindow(_CommonWindow):
     See `hann_window <https://pytorch.org/docs/stable/generated/torch.hann_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 = self._begin(size, periodic, output_datatype)
         res = np.sin(ni * np.pi / N_1) ** 2
         return self._end(size, res, output_datatype)

onnx/reference/ops/op_hard_sigmoid.py

@@ -9,8 +9,8 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class HardSigmoid(OpRunUnaryNum):
-    def _run(self, x, alpha=None, beta=None):  # type: ignore
-        alpha = alpha or self.alpha  # type: ignore
-        beta = beta or self.beta  # type: ignore
-        y = np.maximum(0, np.minimum(1, x * alpha + beta))
+    def _run(self, x, alpha=None, beta=None):
+        alpha = alpha or self.alpha
+        beta = beta or self.beta
+        y = np.maximum(0, np.minimum(1, x * alpha + beta)).astype(x.dtype)
         return (y,)

onnx/reference/ops/op_hardmax.py

@@ -9,14 +9,16 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Hardmax(OpRunUnaryNum):
-    def _run(self, x, axis=None):  # type: ignore
-        axis = axis or self.axis  # type: ignore
-        x_argmax = np.argmax(x, axis=axis)  # type: ignore
+    def _run(self, x, axis=None):
+        axis = axis or self.axis
+        if x.size == 0:
+            return (x,)
+        x_argmax = np.argmax(x, axis=axis)
         y = np.zeros_like(x)
         np.put_along_axis(
             y,
             np.expand_dims(x_argmax, axis=axis),
             1,
-            axis=axis,  # type: ignore
+            axis=axis,
         )
         return (y,)

onnx/reference/ops/op_identity.py

@@ -7,7 +7,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Identity(OpRun):
-    def _run(self, a):  # type: ignore
+    def _run(self, a):
         if a is None:
             return (None,)
         return (a.copy(),)

onnx/reference/ops/op_if.py

@@ -4,13 +4,16 @@
 
 from __future__ import annotations
 
-import numpy as np
+from typing import TYPE_CHECKING
 
 from onnx.reference.op_run import OpRun
 
+if TYPE_CHECKING:
+    import numpy as np
+
 
 class If(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 "opsets" not in self.run_params:
             raise KeyError("run_params must contains key 'opsets'.")
@@ -39,16 +42,16 @@ class If(OpRun):
             raise ValueError(
                 f"Operator If ({self.onnx_node.name!r}) expects a single element as condition, but the size of 'cond' is {len(cond)}."
             )
-        cond_ = cond.item(0)
+        cond_ = cond.item()
         if cond_:
             self._log("  -- then> {%r}", context)
-            outputs = self._run_then_branch(context, attributes=attributes)  # type: ignore
+            outputs = self._run_then_branch(context, attributes=attributes)
             self._log("  -- then<")
             final = tuple(outputs)
             branch = "then"
         else:
             self._log("  -- else> {%r}", context)
-            outputs = self._run_else_branch(context, attributes=attributes)  # type: ignore
+            outputs = self._run_else_branch(context, attributes=attributes)
             self._log("  -- else<")
             final = tuple(outputs)
             branch = "else"
@@ -59,7 +62,7 @@ class If(OpRun):
             )
         for i, f in enumerate(final):
             if f is None:
-                br = self.then_branch if branch == "then" else self.else_branch  # type: ignore
+                br = self.then_branch if branch == "then" else self.else_branch
                 names = br.output_names
                 inits = [i.name for i in br.obj.graph.initializer]
                 raise RuntimeError(

onnx/reference/ops/op_image_decoder.py

@@ -12,9 +12,9 @@ from onnx.reference.op_run import OpRun
 
 
 class ImageDecoder(OpRun):
-    def _run(self, encoded: np.ndarray, pixel_format="RGB") -> tuple[np.ndarray]:  # type: ignore
+    def _run(self, encoded: np.ndarray, pixel_format="RGB") -> tuple[np.ndarray]:
         try:
-            import PIL.Image
+            import PIL.Image  # noqa: PLC0415
         except ImportError as e:
             raise ImportError(
                 "Pillow must be installed to use the reference implementation of the ImageDecoder operator"

onnx/reference/ops/op_instance_normalization.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class InstanceNormalization(OpRun):
-    def _run(self, x, s, bias, epsilon=None):  # type: ignore
+    def _run(self, x, s, bias, epsilon=None):
         dims_x = len(x.shape)
         axis = tuple(range(2, dims_x))
         mean = np.mean(x, axis=axis, keepdims=True)

onnx/reference/ops/op_isinf.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class IsInf(OpRun):
-    def _run(self, data, detect_negative=None, detect_positive=None):  # type: ignore
+    def _run(self, data, detect_negative=None, detect_positive=None):
         if detect_negative:
             if detect_positive:
                 return (np.isinf(data),)

onnx/reference/ops/op_isnan.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunUnary
 
 
 class IsNaN(OpRunUnary):
-    def _run(self, data):  # type: ignore
+    def _run(self, data):
         return (np.isnan(data),)

onnx/reference/ops/op_layer_normalization.py

@@ -26,7 +26,7 @@ def _layer_normalization(
     reduction_shape = X_shape[0:axis] + (1,) * unsqueezed_rank
 
     # Parameter used to convert N-D tensor layer
-    # normalization to equivalent 2-D matirx operations.
+    # normalization to equivalent 2-D matrix operations.
     row_number = 1
     col_number = 1
     for i in range(X_rank):
@@ -65,7 +65,7 @@ def _layer_normalization(
 
 
 class LayerNormalization(OpRun):
-    def _run(self, X, Scale, B=None, axis=None, epsilon=None, stash_type=None):  # type: ignore
+    def _run(self, X, Scale, B=None, axis=None, epsilon=None, stash_type=None):
         if stash_type != 1:
             raise NotImplementedError(
                 f"LayerNormalization not implemented for stash_type={stash_type} != 1."

onnx/reference/ops/op_leaky_relu.py

@@ -3,18 +3,21 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-import numpy as np
+from typing import TYPE_CHECKING
 
 from onnx.reference.ops._op import OpRunUnaryNum
 
+if TYPE_CHECKING:
+    import numpy as np
+
 
 def _leaky_relu(x: np.ndarray, alpha: float) -> np.ndarray:
     sign = (x > 0).astype(x.dtype)
     sign -= ((sign - 1) * alpha).astype(x.dtype)
-    return x * sign  # type: ignore
+    return x * sign
 
 
 class LeakyRelu(OpRunUnaryNum):
-    def _run(self, x, alpha=None):  # type: ignore
-        alpha = alpha or self.alpha  # type: ignore
+    def _run(self, x, alpha=None):
+        alpha = alpha or self.alpha
         return (_leaky_relu(x, alpha).astype(x.dtype),)

onnx/reference/ops/op_less.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunBinaryComparison
 
 
 class Less(OpRunBinaryComparison):
-    def _run(self, a, b):  # type: ignore
+    def _run(self, a, b):
         return (np.less(a, b),)

onnx/reference/ops/op_less_or_equal.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunBinaryComparison
 
 
 class LessOrEqual(OpRunBinaryComparison):
-    def _run(self, a, b):  # type: ignore
+    def _run(self, a, b):
         return (np.less_equal(a, b),)

onnx/reference/ops/op_log.py

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

onnx/reference/ops/op_log_softmax.py

@@ -9,7 +9,7 @@ from onnx.reference.ops.op_softmax import Softmax
 
 
 class LogSoftmax(Softmax):
-    def _run(self, X):  # type: ignore
+    def _run(self, X):
         Y = Softmax._run(self, X)[0]
         np.log(Y, out=Y)
         return (Y,)

onnx/reference/ops/op_loop.py

@@ -9,15 +9,15 @@ from onnx.reference.op_run import OpRun
 
 
 class Loop(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 "opsets" not in self.run_params:
             raise KeyError("run_params must contains key 'opsets'.")
         if "verbose" not in run_params:
             raise KeyError("run_params must contains key 'verbose'.")
-        self.output_index = {n: i for i, n in enumerate(self.body.output_names)}  # type: ignore
-        self.N = len(self.body.input_names) - 2  # type: ignore
-        self.K = len(self.body.output_names) - self.N - 1  # type: ignore
+        self.output_index = {n: i for i, n in enumerate(self.body.output_names)}
+        self.N = len(self.body.input_names) - 2
+        self.K = len(self.body.output_names) - self.N - 1
 
     def need_context(self) -> bool:
         """The operator Loop needs to know all results produced
@@ -27,7 +27,7 @@ class Loop(OpRun):
         """
         return True
 
-    def _run(self, M, cond, *args, context=None, body=None, attributes=None):  # type: ignore
+    def _run(self, M, cond, *args, context=None, body=None, attributes=None):
         if args:
             v_initial = args[0]
             args = args[1:]
@@ -35,9 +35,9 @@ class Loop(OpRun):
             v_initial = None
         if M is not None and not hasattr(M, "dtype"):
             raise TypeError(f"M must be empty or an array but its type is {type(M)}.")
-        body = self.body  # type: ignore
+        body = self.body
         loop_inputs = body.input_names
-        inputs = {name: None for name in loop_inputs}
+        inputs = dict.fromkeys(loop_inputs)
         if v_initial is not None:
             inputs[loop_inputs[2]] = v_initial
         cond_name = body.output_names[0]
@@ -50,17 +50,17 @@ class Loop(OpRun):
             for a in context:
                 inputs[a] = context[a]
 
-        k_carried_away = [[] for i in range(self.K)]  # type: ignore
+        k_carried_away = [[] for i in range(self.K)]
         it = 0
         while cond and (M is None or it < M):
             self._log("  -- loop> {%r}", context)
             if len(body.input_names) > 0 and body.input_names[0] is not None:
                 inputs[body.input_names[0]] = np.array(
                     it, dtype=None if M is None else M.dtype
-                )  # type: ignore
+                )
             if len(body.input_names) > 1 and body.input_names[1] is not None:
                 inputs[body.input_names[1]] = cond
-            outputs = self._run_body(inputs, attributes=attributes)  # type: ignore
+            outputs = self._run_body(inputs, attributes=attributes)
             if self.K > 0:
                 for k in range(self.K):
                     k_carried_away[k].append(outputs[-self.K + k])

onnx/reference/ops/op_lp_normalization.py

@@ -9,9 +9,9 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class LpNormalization(OpRunUnaryNum):
-    def _run(self, x, axis=None, p=None):  # type: ignore
-        axis = axis or self.axis  # type: ignore
-        p = p or self.p  # type: ignore
-        norm = np.power(np.power(x, p).sum(axis=axis), 1.0 / p)  # type: ignore
-        norm = np.expand_dims(norm, axis)  # type: ignore
+    def _run(self, x, axis=None, p=None):
+        axis = axis or self.axis
+        p = p or self.p
+        norm = np.power(np.power(x, p).sum(axis=axis), 1.0 / p)
+        norm = np.expand_dims(norm, axis)
         return ((x / norm).astype(x.dtype),)

onnx/reference/ops/op_lp_pool.py

@@ -9,7 +9,7 @@ from onnx.reference.ops.op_pool_common import CommonPool
 
 
 class LpPool(CommonPool):
-    def _run(  # type: ignore
+    def _run(
         self,
         x,
         auto_pad=None,

onnx/reference/ops/op_lrn.py

@@ -11,15 +11,15 @@ from onnx.reference.op_run import OpRun
 
 
 class LRN(OpRun):
-    def _run(self, x, alpha=None, beta=None, bias=None, size=None):  # type: ignore
+    def _run(self, x, alpha=None, beta=None, bias=None, size=None):
         if len(x.shape) != 4:
             raise RuntimeError(
                 f"LRN only applies on 4D tensors but shape is {x.shape!r}."
             )
         square_sum = np.zeros(x.shape).astype(x.dtype)
         minc = x.shape[1]
-        c1 = int(math.floor((size - 1) / 2))
-        c2 = int(math.ceil((size - 1) / 2)) + 1
+        c1 = math.floor((size - 1) / 2)
+        c2 = math.ceil((size - 1) / 2) + 1
         for c in range(x.shape[0]):
             begin = max(0, c - c1)
             end = min(minc, c + c2)