onnx 1.13.1__cp38-cp38-win32.whl → 1.14.1__cp38-cp38-win32.whl

onnx/backend/test/case/node/lppool.py

@@ -0,0 +1,279 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.backend.test.case.node.pool_op_common import (
+    get_output_shape,
+    get_pad_shape,
+    pool,
+)
+
+
+class LpPool(Base):
+    @staticmethod
+    def export_lppool_1d_default() -> None:
+        """
+        input_shape: [1, 3, 32]
+        output_shape: [1, 3, 31]
+        """
+        p = 3
+        kernel_shape = [2]
+        strides = [1]
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=kernel_shape,
+            strides=strides,
+            p=p,
+        )
+        x = np.random.randn(1, 3, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides)
+        padded = x
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, [0], "LPPOOL", p=p)
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_1d_default")
+
+    @staticmethod
+    def export_lppool_2d_default() -> None:
+        """
+        input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 31, 31]
+        """
+        p = 4
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            p=p,
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (2, 2)
+        strides = (1, 1)
+        out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides)
+        padded = x
+        y = pool(
+            padded, x_shape, kernel_shape, strides, out_shape, (0, 0), "LPPOOL", p=p
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_default")
+
+    @staticmethod
+    def export_lppool_3d_default() -> None:
+        """
+        input_shape: [1, 3, 32, 32, 32]
+        output_shape: [1, 3, 31, 31, 31]
+        """
+        p = 3
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2, 2],
+            p=p,
+        )
+        x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = [2, 2, 2]
+        strides = [1, 1, 1]
+        out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides)
+        padded = x
+        y = pool(
+            padded, x_shape, kernel_shape, strides, out_shape, [0, 0, 0], "LPPOOL", p=p
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_3d_default")
+
+    @staticmethod
+    def export_lppool_2d_same_upper() -> None:
+        """
+        input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 32, 32]
+        pad_shape: [1, 1] -> [0, 1, 0, 1] by axis
+        """
+        p = 2
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            auto_pad="SAME_UPPER",
+            p=p,
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (2, 2)
+        strides = (1, 1)
+        out_shape = get_output_shape("SAME_UPPER", x_shape[2:], kernel_shape, strides)
+        pad_shape = get_pad_shape(
+            "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape
+        )
+        pad_top = pad_shape[0] // 2
+        pad_bottom = pad_shape[0] - pad_top
+        pad_left = pad_shape[1] // 2
+        pad_right = pad_shape[1] - pad_left
+        padded = np.pad(
+            x,
+            ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+            mode="constant",
+            constant_values=0,
+        )
+        y = pool(
+            padded, x_shape, kernel_shape, strides, out_shape, pad_shape, "LPPOOL", p=p
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_upper")
+
+    @staticmethod
+    def export_lppool_2d_same_lower() -> None:
+        """
+        input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 32, 32]
+        pad_shape: [1, 1] -> [1, 0, 1, 0] by axis
+        """
+        p = 4
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            auto_pad="SAME_LOWER",
+            p=p,
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (2, 2)
+        strides = (1, 1)
+        out_shape = get_output_shape("SAME_LOWER", x_shape[2:], kernel_shape, strides)
+        pad_shape = get_pad_shape(
+            "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape
+        )
+        pad_bottom = pad_shape[0] // 2
+        pad_top = pad_shape[0] - pad_bottom
+        pad_right = pad_shape[1] // 2
+        pad_left = pad_shape[1] - pad_right
+        padded = np.pad(
+            x,
+            ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+            mode="constant",
+            constant_values=0,
+        )
+        y = pool(
+            padded, x_shape, kernel_shape, strides, out_shape, pad_shape, "LPPOOL", p=p
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_lower")
+
+    @staticmethod
+    def export_lppool_2d_pads() -> None:
+        """
+        input_shape: [1, 3, 28, 28]
+        output_shape: [1, 3, 30, 30]
+        pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+        """
+        p = 3
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            pads=[2, 2, 2, 2],
+            p=p,
+        )
+        x = np.random.randn(1, 3, 28, 28).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (3, 3)
+        strides = (1, 1)
+        pad_bottom = pad_top = pad_right = pad_left = 2
+        pad_shape = [pad_top + pad_bottom, pad_left + pad_right]
+        out_shape = get_output_shape(
+            "VALID", np.add(x_shape[2:], pad_shape), kernel_shape, strides
+        )
+        padded = np.pad(
+            x,
+            ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+            mode="constant",
+            constant_values=0,
+        )
+        y = pool(
+            padded, x_shape, kernel_shape, strides, out_shape, pad_shape, "LPPOOL", p=p
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_pads")
+
+    @staticmethod
+    def export_lppool_2d_strides() -> None:
+        """
+        input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 10, 10]
+        """
+        p = 2
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[5, 5],
+            strides=[3, 3],
+            p=p,
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (5, 5)
+        strides = (3, 3)
+        out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides)
+        padded = x
+        y = pool(
+            padded, x_shape, kernel_shape, strides, out_shape, (0, 0), "LPPOOL", p=p
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_strides")
+
+    @staticmethod
+    def export_lppool_2d_dilations() -> None:
+        """
+        input_shape: [1, 1, 4, 4]
+        output_shape: [1, 1, 2, 2]
+        """
+        p = 2
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            strides=[1, 1],
+            dilations=[2, 2],
+            p=p,
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        y = np.array(
+            [
+                [
+                    [
+                        [14.560219778561036, 16.24807680927192],
+                        [21.633307652783937, 23.49468024894146],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_dilations")

onnx/backend/test/case/node/lrn.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import math
@@ -5,9 +7,8 @@ import math
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class LRN(Base):

onnx/backend/test/case/node/lstm.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 from typing import Any, Tuple
@@ -5,12 +7,11 @@ from typing import Any, Tuple
 import numpy as np
 
 import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
-from ..base import Base
-from . import expect
 
-
-class LSTM_Helper:
+class LSTMHelper:
     def __init__(self, **params: Any) -> None:
         # LSTM Input Names
         X = "X"
@@ -31,7 +32,7 @@ class LSTM_Helper:
         self.num_directions = params[W].shape[0]
 
         if self.num_directions == 1:
-            for k in params.keys():
+            for k in params:
                 if k != X:
                     params[k] = np.squeeze(params[k], axis=0)
 
@@ -145,7 +146,7 @@ class LSTM(Base):
             (1, number_of_gates * hidden_size, hidden_size)
         ).astype(np.float32)
 
-        lstm = LSTM_Helper(X=input, W=W, R=R)
+        lstm = LSTMHelper(X=input, W=W, R=R)
         _, Y_h = lstm.step()
         expect(
             node,
@@ -187,7 +188,7 @@ class LSTM(Base):
         R_B = np.zeros((1, number_of_gates * hidden_size)).astype(np.float32)
         B = np.concatenate((W_B, R_B), 1)
 
-        lstm = LSTM_Helper(X=input, W=W, R=R, B=B)
+        lstm = LSTMHelper(X=input, W=W, R=R, B=B)
         _, Y_h = lstm.step()
         expect(
             node,
@@ -230,7 +231,7 @@ class LSTM(Base):
             np.float32
         )
 
-        lstm = LSTM_Helper(
+        lstm = LSTMHelper(
             X=input, W=W, R=R, B=B, P=P, initial_c=init_c, initial_h=init_h
         )
         _, Y_h = lstm.step()
@@ -266,7 +267,7 @@ class LSTM(Base):
             (1, number_of_gates * hidden_size, hidden_size)
         ).astype(np.float32)
 
-        lstm = LSTM_Helper(X=input, W=W, R=R, layout=layout)
+        lstm = LSTMHelper(X=input, W=W, R=R, layout=layout)
         Y, Y_h = lstm.step()
         expect(
             node,

onnx/backend/test/case/node/matmul.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class MatMul(Base):

onnx/backend/test/case/node/matmulinteger.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class MatMulInteger(Base):

onnx/backend/test/case/node/max.py

@@ -1,12 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from ..utils import all_numeric_dtypes
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.backend.test.case.utils import all_numeric_dtypes
 
 
 class Max(Base):

onnx/backend/test/case/node/maxpool.py

@@ -1,12 +1,17 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
-from .pool_op_common import get_output_shape, get_pad_shape, pool
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.backend.test.case.node.pool_op_common import (
+    get_output_shape,
+    get_pad_shape,
+    pool,
+)
 
 
 class MaxPool(Base):

onnx/backend/test/case/node/maxunpool.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class MaxUnpool(Base):

onnx/backend/test/case/node/mean.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class Mean(Base):

onnx/backend/test/case/node/meanvariancenormalization.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class MeanVarianceNormalization(Base):

onnx/backend/test/case/node/melweightmatrix.py

@@ -1,12 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
-
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class MelWeightMatrix(Base):

onnx/backend/test/case/node/min.py

@@ -1,12 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from ..utils import all_numeric_dtypes
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.backend.test.case.utils import all_numeric_dtypes
 
 
 class Min(Base):

onnx/backend/test/case/node/mish.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class Mish(Base):

onnx/backend/test/case/node/mod.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class Mod(Base):

onnx/backend/test/case/node/momentum.py

@@ -1,13 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN
 
-from ..base import Base
-from . import expect
-
 
 def apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta):  # type: ignore
     # Add gradient of regularization term.

onnx/backend/test/case/node/mul.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class Mul(Base):

onnx/backend/test/case/node/neg.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class Neg(Base):

onnx/backend/test/case/node/negativeloglikelihoodloss.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 def compute_negative_log_likelihood_loss(input, target, weight=None, reduction="mean", ignore_index=None):  # type: ignore

onnx/backend/test/case/node/nonmaxsuppression.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class NonMaxSuppression(Base):

onnx/backend/test/case/node/nonzero.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class NonZero(Base):

onnx/backend/test/case/node/not.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class Not(Base):