onnx 1.18.0__cp310-cp310-win_amd64.whl → 1.19.1rc1__cp310-cp310-win_amd64.whl

onnx/reference/ops/_op_common_pool.py

@@ -35,7 +35,7 @@ def _get_pad_shape(
             f"kernel_spatial_shape={kernel_spatial_shape!r}, "
             f"strides_spatial={strides_spatial!r}."
         )
-    return tuple(pad_shape)  # type: ignore
+    return tuple(pad_shape)
 
 
 def _get_output_shape_no_ceil(
@@ -58,7 +58,7 @@ def _get_output_shape_no_ceil(
                     / float(strides_spatial[i])
                 )
             )
-    return tuple(out_shape)  # type: ignore
+    return tuple(out_shape)
 
 
 def _get_output_shape(
@@ -75,11 +75,11 @@ def _get_output_shape(
         )
     else:
         round_fct = np.ceil if ceil_mode else np.floor
-        out_shape = [0] * len(input_spatial_shape)  # type: ignore
+        out_shape = [0] * len(input_spatial_shape)
         if auto_pad in ("SAME_UPPER", "SAME_LOWER"):
             for i in range(len(input_spatial_shape)):
-                out_shape[i] = int(  # type: ignore
-                    round_fct(float(input_spatial_shape[i]) / float(strides_spatial[i]))  # type: ignore
+                out_shape[i] = int(
+                    round_fct(float(input_spatial_shape[i]) / float(strides_spatial[i]))
                 )
         elif auto_pad == "VALID":
             if pad_shape is None:
@@ -88,8 +88,8 @@ def _get_output_shape(
                     "'VALID' and ceil_mode is 1."
                 )
             for i in range(len(input_spatial_shape)):
-                out_shape[i] = int(  # type: ignore
-                    round_fct(  # type: ignore
+                out_shape[i] = int(
+                    round_fct(
                         float(
                             input_spatial_shape[i]
                             + pad_shape[i]
@@ -113,7 +113,7 @@ def _get_output_shape(
             f"kernel_spatial_shape={kernel_spatial_shape!r}, "
             f"strides_spatial={strides_spatial!r}, ceil_mode={ceil_mode!r}."
         )
-    return tuple(out_shape)  # type: ignore
+    return tuple(out_shape)
 
 
 def _pool(
@@ -138,16 +138,16 @@ def _pool(
             f"Pooling type {pooling_type!r} does not support. Should be AVG, MAX."
         )
     spatial_size = len(x_shape) - 2
-    y = np.zeros([x_shape[0], x_shape[1], *list(out_shape)])  # type: ignore
+    y = np.zeros([x_shape[0], x_shape[1], *list(out_shape)])
     if indices:
         z = np.full(y.shape, fill_value=-1, dtype=np.int64)
     round_fct = np.ceil if ceil_mode else np.floor
 
-    def loop_range():  # type: ignore
+    def loop_range():
         return [
             range(
                 int(
-                    round_fct(  # type: ignore
+                    round_fct(
                         float(x_shape[i + 2] + pad_shape[i] - kernel_shape[i])
                         / float(strides_shape[i])
                         + 1
@@ -157,7 +157,7 @@ def _pool(
             for i in range(spatial_size)
         ]
 
-    for shape in itertools.product(range(x_shape[0]), range(x_shape[1]), *loop_range()):  # type: ignore
+    for shape in itertools.product(range(x_shape[0]), range(x_shape[1]), *loop_range()):
         window = padded[shape[0], shape[1]]
         listi = [
             range(
@@ -189,17 +189,17 @@ def _pool(
                     window_vals_min[np.isnan(window_vals_min)] = no_nan.min()
                 arg = np.argmax(window_vals_min)
                 coordinates = _get_indices(arg, out_shape)
-                delta = shape[2:] - pads[:, 0]  # type: ignore
+                delta = shape[2:] - pads[:, 0]
                 coordinates += delta
                 new_arg = _get_index(coordinates, x_shape[2:])
                 z[shape] = new_arg
     if indices:
-        return y.astype(padded.dtype), z  # type: ignore
-    return y.astype(padded.dtype)  # type: ignore
+        return y.astype(padded.dtype), z
+    return y.astype(padded.dtype)
 
 
 class CommonPool(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self,
         pooling_type,
         count_include_pad,
@@ -250,9 +250,9 @@ class CommonPool(OpRun):
                 kernel_shape,
                 strides,
                 pad_shape,
-                ceil_mode,  # type: ignore
+                ceil_mode,
             )
-            pad_shape = _get_pad_shape(  # type: ignore
+            pad_shape = _get_pad_shape(
                 auto_pad, x_shape, kernel_shape, strides, out_shape
             )
             if auto_pad == "SAME_LOWER":
@@ -278,7 +278,7 @@ class CommonPool(OpRun):
                 kernel_shape,
                 strides,
                 pad_shape,
-                ceil_mode,  # type: ignore
+                ceil_mode,
             )
 
         n_dims = len(pads) // 2
@@ -289,11 +289,11 @@ class CommonPool(OpRun):
             kernel_shape,
             strides,
             out_shape,
-            pad_shape,  # type: ignore
+            pad_shape,
             pooling_type,
             count_include_pad=count_include_pad,
             ceil_mode=ceil_mode,
-            indices=len(self.output) > 1,  # type: ignore
+            indices=len(self.output) > 1,
             pads=new_pads,
         )
         if isinstance(res, tuple):

onnx/reference/ops/_op_common_random.py

@@ -10,22 +10,22 @@ from onnx.reference.op_run import OpRun
 
 
 class _CommonRandom(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 hasattr(self, "shape") and len(self.shape) == 0:  # type: ignore
+        if hasattr(self, "shape") and len(self.shape) == 0:
             raise ValueError(  # pragma: no cover
                 f"shape cannot be empty for operator {self.__class__.__name__}."
             )
 
     @staticmethod
-    def numpy_type(dtype):  # type: ignore
+    def numpy_type(dtype):
         return tensor_dtype_to_np_dtype(dtype)
 
     @staticmethod
-    def _dtype(*data, dtype=None, dtype_first=False):  # type: ignore
+    def _dtype(*data, dtype=None, dtype_first=False):
         numpy_type = _CommonRandom.numpy_type(dtype)
         if dtype_first and numpy_type is not None:
-            if dtype != 0:  # type: ignore
+            if dtype != 0:
                 return numpy_type
             if data:
                 return data[0].dtype
@@ -47,9 +47,9 @@ class _CommonRandom(OpRun):
         return res
 
     @staticmethod
-    def _get_state(seed):  # type: ignore
-        if seed is None or np.isnan(seed):  # type: ignore
+    def _get_state(seed):
+        if seed is None or np.isnan(seed):
             state = np.random.RandomState()
         else:
-            state = np.random.RandomState(seed=int(seed))  # type: ignore
+            state = np.random.RandomState(seed=int(seed))
         return state

onnx/reference/ops/_op_common_window.py

@@ -11,7 +11,7 @@ from onnx.reference.op_run import OpRun
 
 class _CommonWindow(OpRun):
     @staticmethod
-    def _begin(size, periodic, output_datatype):  # type: ignore
+    def _begin(size, periodic, output_datatype):
         dtype = tensor_dtype_to_np_dtype(output_datatype)
         if periodic == 1:
             N_1 = size

onnx/reference/ops/_op_list.py

@@ -1,7 +1,6 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
-# pylint: disable=C0415,R0912,R0913,R0914,R0915,W0611,W0603
 """Every class imported in this module defines an implementation of
 an operator of the main domain. Any class name uses `_` to specify a
 version defined in a specific opset. The class name without `_`
@@ -13,6 +12,246 @@ did not change the implementation.
 
 from __future__ import annotations
 
+__all__ = [
+    "load_op",
+    "Abs",
+    "Acos",
+    "Acosh",
+    "Add",
+    "AffineGrid",
+    "And",
+    "ArgMax_1",
+    "ArgMax_12",
+    "ArgMin_1",
+    "ArgMin_12",
+    "Asin",
+    "Asinh",
+    "Atan",
+    "Atanh",
+    "Attention",
+    "AttributeHasValue",
+    "AveragePool_1",
+    "AveragePool_7",
+    "AveragePool_11",
+    "AveragePool_19",
+    "BatchNormalization_6",
+    "BatchNormalization_9",
+    "BatchNormalization_14",
+    "Bernoulli",
+    "BitShift",
+    "BitwiseAnd",
+    "BitwiseNot",
+    "BitwiseOr",
+    "BitwiseXor",
+    "BlackmanWindow",
+    "Cast_1",
+    "Cast_19",
+    "Cast_24",
+    "CastLike_15",
+    "CastLike_19",
+    "Ceil",
+    "Celu",
+    "CenterCropPad",
+    "Clip_6",
+    "Clip_11",
+    "Col2Im",
+    "Compress",
+    "Concat",
+    "ConcatFromSequence",
+    "Constant_1",
+    "Constant_9",
+    "Constant_11",
+    "Constant_12",
+    "ConstantOfShape",
+    "Conv",
+    "ConvInteger",
+    "ConvTranspose",
+    "Cos",
+    "Cosh",
+    "CumSum",
+    "DeformConv",
+    "DepthToSpace",
+    "DequantizeLinear_19",
+    "DequantizeLinear_21",
+    "Det",
+    "DFT_17",
+    "DFT_20",
+    "Div",
+    "Dropout_7",
+    "Dropout_12",
+    "DynamicQuantizeLinear",
+    "Einsum",
+    "Elu",
+    "Equal",
+    "Erf",
+    "Exp",
+    "Expand",
+    "EyeLike",
+    "Flatten",
+    "Floor",
+    "Gather",
+    "GatherElements",
+    "GatherND",
+    "Gemm_6",
+    "Gemm_7",
+    "GlobalAveragePool",
+    "GlobalMaxPool",
+    "Greater",
+    "GreaterOrEqual",
+    "GridSample",
+    "GRU",
+    "HammingWindow",
+    "HannWindow",
+    "HardSigmoid",
+    "Hardmax",
+    "Identity",
+    "If",
+    "ImageDecoder",
+    "InstanceNormalization",
+    "IsInf",
+    "IsNaN",
+    "LayerNormalization",
+    "LeakyRelu",
+    "Less",
+    "LessOrEqual",
+    "Log",
+    "LogSoftmax",
+    "Loop",
+    "LpNormalization",
+    "LpPool",
+    "LRN",
+    "LSTM",
+    "MatMul",
+    "MatMulInteger",
+    "Max",
+    "MaxPool",
+    "MaxUnpool",
+    "Mean",
+    "MelWeightMatrix",
+    "Min",
+    "Mod",
+    "Mul",
+    "Neg",
+    "NegativeLogLikelihoodLoss",
+    "NonMaxSuppression",
+    "NonZero",
+    "Not",
+    "OneHot",
+    "Optional",
+    "OptionalGetElement",
+    "OptionalHasElement",
+    "Or",
+    "Pad_1",
+    "Pad_2",
+    "Pad_11",
+    "Pad_18",
+    "Pow",
+    "PRelu",
+    "QLinearConv",
+    "QLinearMatMul",
+    "QuantizeLinear_10",
+    "QuantizeLinear_19",
+    "QuantizeLinear_21",
+    "RandomNormal",
+    "RandomNormalLike",
+    "RandomUniform",
+    "RandomUniformLike",
+    "Range",
+    "Reciprocal",
+    "ReduceL1_1",
+    "ReduceL1_18",
+    "ReduceL2_1",
+    "ReduceL2_18",
+    "ReduceLogSum_1",
+    "ReduceLogSum_18",
+    "ReduceLogSumExp_1",
+    "ReduceLogSumExp_18",
+    "ReduceMax_1",
+    "ReduceMax_18",
+    "ReduceMean_1",
+    "ReduceMean_18",
+    "ReduceMin_1",
+    "ReduceMin_18",
+    "ReduceProd_1",
+    "ReduceProd_18",
+    "ReduceSum_1",
+    "ReduceSum_13",
+    "ReduceSumSquare_1",
+    "ReduceSumSquare_18",
+    "RegexFullMatch",
+    "Relu",
+    "Reshape_5",
+    "Reshape_14",
+    "Resize",
+    "ReverseSequence",
+    "RMSNormalization",
+    "RNN_7",
+    "RNN_14",
+    "RoiAlign",
+    "RotaryEmbedding",
+    "Round",
+    "Scan",
+    "ScatterElements",
+    "ScatterND",
+    "Selu",
+    "SequenceAt",
+    "SequenceConstruct",
+    "SequenceEmpty",
+    "SequenceErase",
+    "SequenceInsert",
+    "SequenceLength",
+    "SequenceMap",
+    "Shape_1",
+    "Shape_15",
+    "Shrink",
+    "Sigmoid",
+    "Sign",
+    "Sin",
+    "Sinh",
+    "Size",
+    "Slice_1",
+    "Slice_10",
+    "Softmax",
+    "SoftmaxCrossEntropyLoss",
+    "Softplus",
+    "Softsign",
+    "Swish",
+    "SpaceToDepth",
+    "Split_2",
+    "Split_11",
+    "Split_13",
+    "Split_18",
+    "SplitToSequence",
+    "Sqrt",
+    "Squeeze_1",
+    "Squeeze_11",
+    "Squeeze_13",
+    "STFT",
+    "StringConcat",
+    "StringNormalizer",
+    "StringSplit",
+    "Sub",
+    "Sum",
+    "Tan",
+    "Tanh",
+    "TensorScatter",
+    "TfIdfVectorizer",
+    "ThresholdedRelu",
+    "Tile",
+    "TopK_1",
+    "TopK_10",
+    "TopK_11",
+    "Transpose",
+    "Trilu",
+    "Unique",
+    "Unsqueeze_1",
+    "Unsqueeze_11",
+    "Unsqueeze_13",
+    "Upsample",
+    "Where",
+    "Xor",
+]
+
 import textwrap
 from typing import Any
 
@@ -58,7 +297,7 @@ from onnx.reference.ops.op_bitwise_not import BitwiseNot
 from onnx.reference.ops.op_bitwise_or import BitwiseOr
 from onnx.reference.ops.op_bitwise_xor import BitwiseXor
 from onnx.reference.ops.op_blackman_window import BlackmanWindow
-from onnx.reference.ops.op_cast import Cast_1, Cast_19
+from onnx.reference.ops.op_cast import Cast_1, Cast_19, Cast_24
 from onnx.reference.ops.op_cast_like import CastLike_15, CastLike_19
 from onnx.reference.ops.op_ceil import Ceil
 from onnx.reference.ops.op_celu import Celu
@@ -228,8 +467,10 @@ from onnx.reference.ops.op_string_normalizer import StringNormalizer
 from onnx.reference.ops.op_string_split import StringSplit
 from onnx.reference.ops.op_sub import Sub
 from onnx.reference.ops.op_sum import Sum
+from onnx.reference.ops.op_swish import Swish
 from onnx.reference.ops.op_tan import Tan
 from onnx.reference.ops.op_tanh import Tanh
+from onnx.reference.ops.op_tensor_scatter import TensorScatter
 from onnx.reference.ops.op_tfidf_vectorizer import TfIdfVectorizer
 from onnx.reference.ops.op_thresholded_relu import ThresholdedRelu
 from onnx.reference.ops.op_tile import Tile
@@ -261,13 +502,13 @@ def load_op(
 
     Args:
         domain: domain
-        op_type: oprator type
+        op_type: operator type
         version: requested version
         custom: custom implementation (like a function)
         node: used if no implementation was found and the operator
-            defines a function which is context dependant
+            defines a function which is context dependent
         input_types: used if no implementation was found and the
-            operator defines a function which is context dependant
+            operator defines a function which is context dependent
         expand: use the function implemented in the schema instead of
             its reference implementation
         evaluator_cls: evaluator to use
@@ -281,37 +522,37 @@ def load_op(
         _registered_operators = _build_registered_operators()  # type: ignore[assignment]
     assert _registered_operators is not None
     if custom is not None:
-        return lambda *args: OpFunction(*args, impl=custom)  # type: ignore
+        return lambda *args: OpFunction(*args, impl=custom)
     if version is None:
         version = onnx_opset_version()
     if domain != "":
         raise ValueError(f"Domain must be '' not {domain!r}.")
-    if op_type in _registered_operators and not expand:  # type: ignore
+    if op_type in _registered_operators and not expand:
         found = True
     else:
         # maybe the operator can be replaced by a function
         try:
-            schema = get_schema(op_type, version, domain)  # type: ignore
+            schema = get_schema(op_type, version, domain)
         except SchemaError:
             raise NotImplementedError(
                 f"No registered schema for operator {op_type!r} "
                 f"and domain {domain!r}. Did you recompile the sources after updating the repository?"
             ) from None
-        if schema.has_function:  # type: ignore
-            body = schema.function_body  # type: ignore
+        if schema.has_function:
+            body = schema.function_body
             assert evaluator_cls is not None, (
                 f"evaluator_cls must be specified to implement operator {op_type!r} from domain {domain!r}"
             )
             sess = evaluator_cls(body)
-            return lambda *args, sess=sess: OpFunction(*args, impl=sess)  # type: ignore
-        if schema.has_context_dependent_function:  # type: ignore
+            return lambda *args, sess=sess: OpFunction(*args, impl=sess)
+        if schema.has_context_dependent_function:
             if node is None or input_types is None:
                 raise RuntimeContextError(
                     f"No registered implementation for operator {op_type!r} "
                     f"and domain {domain!r}, the operator has a context dependent function. "
                     f"but argument node or input_types is not defined (input_types={input_types})."
                 )
-            body = schema.get_context_dependent_function(  # type: ignore
+            body = schema.get_context_dependent_function(
                 node.SerializeToString(), [it.SerializeToString() for it in input_types]
             )
             proto = FunctionProto()
@@ -320,13 +561,13 @@ def load_op(
                 f"evaluator_cls must be specified to evaluate function {proto.name!r}"
             )
             sess = evaluator_cls(proto)
-            return lambda *args, sess=sess: OpFunction(*args, impl=sess)  # type: ignore
+            return lambda *args, sess=sess: OpFunction(*args, impl=sess)
         found = False
     if not found:
-        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))  # type: ignore
-        has_function = schema.has_function if schema else None  # type: ignore
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
+        has_function = schema.has_function if schema else None
         has_context_dependent_function = (
-            schema.has_context_dependent_function if schema else None  # type: ignore
+            schema.has_context_dependent_function if schema else None
         )
         raise RuntimeImplementationError(
             f"No registered implementation for operator {op_type!r} "
@@ -359,7 +600,7 @@ def load_op(
             )
         cl = impl[best]
     if cl is None:
-        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))  # type: ignore
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
         raise ValueError(
             f"Not registered implementation for operator {op_type!r}, "
             f"domain {domain!r}, and {version!r} in\n{available}"

onnx/reference/ops/aionnx_preview_training/__init__.py

@@ -3,5 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
+__all__ = ["load_op", "OpRunTraining"]
+
 from onnx.reference.ops.aionnx_preview_training._op_list import load_op
 from onnx.reference.ops.aionnx_preview_training._op_run_training import OpRunTraining

onnx/reference/ops/aionnx_preview_training/_op_list.py

@@ -3,6 +3,13 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
+__all__ = [
+    "load_op",
+    "Adagrad",
+    "Adam",
+    "Momentum",
+]
+
 import textwrap
 from typing import Any
 
@@ -27,7 +34,7 @@ def load_op(
 
     Args:
         domain: domain
-        op_type: oprator type
+        op_type: operator type
         version: requested version
         custom: custom implementation (like a function)
 
@@ -38,11 +45,11 @@ def load_op(
     if _registered_operators is None:
         _registered_operators = _build_registered_operators()
     if custom is not None:
-        return lambda *args: OpFunction(*args, impl=custom)  # type: ignore
+        return lambda *args: OpFunction(*args, impl=custom)
     if domain != "ai.onnx.preview.training":
         raise ValueError(f"Domain must be '' not {domain!r}.")
     if op_type not in _registered_operators:
-        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))  # type: ignore
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
         raise NotImplementedError(
             f"No registered implementation for operator {op_type!r} "
             f"and domain {domain!r} in\n{available}"
@@ -71,7 +78,7 @@ def load_op(
             )
         cl = impl[best]
     if cl is None:
-        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))  # type: ignore
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
         raise ValueError(
             f"Not registered implementation for operator {op_type!r}, "
             f"domain {domain!r}, and {version!r} in\n{available}"

onnx/reference/ops/aionnx_preview_training/op_adagrad.py

@@ -8,7 +8,7 @@ import numpy as np
 from onnx.reference.ops.aionnx_preview_training._op_run_training import OpRunTraining
 
 
-def _apply_adagrad(r, t, x, g, h, norm_coefficient, epsilon, decay_factor):  # type: ignore
+def _apply_adagrad(r, t, x, g, h, norm_coefficient, epsilon, decay_factor):
     # Compute adjusted learning-rate.
     r_ = r / (1 + t * decay_factor)
     # Add gradient of regularization term.
@@ -23,9 +23,9 @@ def _apply_adagrad(r, t, x, g, h, norm_coefficient, epsilon, decay_factor):  # t
 
 
 class Adagrad(OpRunTraining):
-    def _run(self, *data, decay_factor=None, epsilon=None, norm_coefficient=None):  # type: ignore
+    def _run(self, *data, decay_factor=None, epsilon=None, norm_coefficient=None):
         if len(data) == 5:
-            return self._run1(  # type: ignore
+            return self._run1(
                 *data,
                 decay_factor=decay_factor,
                 epsilon=epsilon,
@@ -35,7 +35,7 @@ class Adagrad(OpRunTraining):
         xs = []
         hs = []
         for i in range(n):
-            a, b = self._run1(  # type: ignore
+            a, b = self._run1(
                 *data[:2],
                 data[2 + i],
                 data[2 + n + i],
@@ -50,7 +50,7 @@ class Adagrad(OpRunTraining):
 
     def _run1(
         self, r, t, x, g, h, decay_factor=None, epsilon=None, norm_coefficient=None
-    ):  # type: ignore
+    ):
         x_new, h_new = _apply_adagrad(
             r,
             t,
@@ -59,6 +59,6 @@ class Adagrad(OpRunTraining):
             h,
             norm_coefficient,
             epsilon,
-            decay_factor,  # type: ignore
+            decay_factor,
         )
         return x_new, h_new