onnx 1.15.0__cp311-cp311-win_amd64.whl → 1.16.1__cp311-cp311-win_amd64.whl

onnx/test/model_container_refeval_test.py

@@ -0,0 +1,139 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import tempfile
+import unittest
+
+import numpy as np
+import numpy.testing as npt
+
+import onnx
+import onnx.helper
+import onnx.model_container
+import onnx.numpy_helper
+import onnx.reference
+
+
+def _linear_regression():
+    X = onnx.helper.make_tensor_value_info("X", onnx.TensorProto.FLOAT, [None, None])
+    Y = onnx.helper.make_tensor_value_info("Y", onnx.TensorProto.FLOAT, [None])
+    graph = onnx.helper.make_graph(
+        [
+            onnx.helper.make_node("MatMul", ["X", "A"], ["XA"]),
+            onnx.helper.make_node("MatMul", ["XA", "B"], ["XB"]),
+            onnx.helper.make_node("MatMul", ["XB", "C"], ["Y"]),
+        ],
+        "mm",
+        [X],
+        [Y],
+        [
+            onnx.numpy_helper.from_array(
+                np.arange(9).astype(np.float32).reshape((-1, 3)), name="A"
+            ),
+            onnx.numpy_helper.from_array(
+                (np.arange(9) * 100).astype(np.float32).reshape((-1, 3)),
+                name="B",
+            ),
+            onnx.numpy_helper.from_array(
+                (np.arange(9) + 10).astype(np.float32).reshape((-1, 3)),
+                name="C",
+            ),
+        ],
+    )
+    onnx_model = onnx.helper.make_model(graph)
+    onnx.checker.check_model(onnx_model)
+    return onnx_model
+
+
+def _large_linear_regression():
+    X = onnx.helper.make_tensor_value_info("X", onnx.TensorProto.FLOAT, [None, None])
+    Y = onnx.helper.make_tensor_value_info("Y", onnx.TensorProto.FLOAT, [None])
+    graph = onnx.helper.make_graph(
+        [
+            onnx.helper.make_node("MatMul", ["X", "A"], ["XA"]),
+            onnx.helper.make_node("MatMul", ["XA", "B"], ["XB"]),
+            onnx.helper.make_node("MatMul", ["XB", "C"], ["Y"]),
+        ],
+        "mm",
+        [X],
+        [Y],
+        [
+            onnx.model_container.make_large_tensor_proto(
+                "#loc0", "A", onnx.TensorProto.FLOAT, (3, 3)
+            ),
+            onnx.numpy_helper.from_array(
+                np.arange(9).astype(np.float32).reshape((-1, 3)), name="B"
+            ),
+            onnx.model_container.make_large_tensor_proto(
+                "#loc1", "C", onnx.TensorProto.FLOAT, (3, 3)
+            ),
+        ],
+    )
+    onnx_model = onnx.helper.make_model(graph)
+    large_model = onnx.model_container.make_large_model(
+        onnx_model.graph,
+        {
+            "#loc0": (np.arange(9) * 100).astype(np.float32).reshape((-1, 3)),
+            "#loc1": (np.arange(9) + 10).astype(np.float32).reshape((-1, 3)),
+        },
+    )
+    large_model.check_model()
+    return large_model
+
+
+class TestLargeOnnxReferenceEvaluator(unittest.TestCase):
+    def common_check_reference_evaluator(self, container):
+        X = np.arange(9).astype(np.float32).reshape((-1, 3))
+        ref = onnx.reference.ReferenceEvaluator(container)
+        got = ref.run(None, {"X": X})
+        expected = np.array(
+            [
+                [945000, 1015200, 1085400],
+                [2905200, 3121200, 3337200],
+                [4865400, 5227200, 5589000],
+            ],
+            dtype=np.float32,
+        )
+        npt.assert_allclose(expected, got[0])
+
+    def test_large_onnx_no_large_initializer(self):
+        model_proto = _linear_regression()
+        large_model = onnx.model_container.make_large_model(model_proto.graph)
+        self.common_check_reference_evaluator(large_model)
+        with self.assertRaises(ValueError):
+            large_model["#anymissingkey"]
+
+        with tempfile.TemporaryDirectory() as temp:
+            filename = os.path.join(temp, "model.onnx")
+            large_model.save(filename)
+            copy = onnx.model_container.ModelContainer()
+            copy.load(filename)
+            self.common_check_reference_evaluator(copy)
+
+    def test_large_one_weight_file(self):
+        large_model = _large_linear_regression()
+        self.common_check_reference_evaluator(large_model)
+        with tempfile.TemporaryDirectory() as temp:
+            filename = os.path.join(temp, "model.onnx")
+            large_model.save(filename, True)
+            copy = onnx.model_container.ModelContainer()
+            copy.load(filename)
+            loaded_model = onnx.load_model(filename, load_external_data=True)
+            self.common_check_reference_evaluator(loaded_model)
+
+    def test_large_multi_files(self):
+        large_model = _large_linear_regression()
+        self.common_check_reference_evaluator(large_model)
+        with tempfile.TemporaryDirectory() as temp:
+            filename = os.path.join(temp, "model.onnx")
+            large_model.save(filename, False)
+            copy = onnx.load_model(filename)
+            self.common_check_reference_evaluator(copy)
+            loaded_model = onnx.load_model(filename, load_external_data=True)
+            self.common_check_reference_evaluator(loaded_model)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

onnx/test/model_container_test.py

@@ -0,0 +1,136 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import tempfile
+import unittest
+
+import numpy as np
+
+import onnx
+import onnx.external_data_helper as ext_data
+import onnx.helper
+import onnx.model_container
+import onnx.numpy_helper
+
+
+def _linear_regression():
+    X = onnx.helper.make_tensor_value_info("X", onnx.TensorProto.FLOAT, [None, None])
+    Y = onnx.helper.make_tensor_value_info("Y", onnx.TensorProto.FLOAT, [None])
+    graph = onnx.helper.make_graph(
+        [
+            onnx.helper.make_node("MatMul", ["X", "A"], ["XA"]),
+            onnx.helper.make_node("MatMul", ["XA", "B"], ["XB"]),
+            onnx.helper.make_node("MatMul", ["XB", "C"], ["Y"]),
+        ],
+        "mm",
+        [X],
+        [Y],
+        [
+            onnx.numpy_helper.from_array(
+                np.arange(9).astype(np.float32).reshape((-1, 3)), name="A"
+            ),
+            onnx.numpy_helper.from_array(
+                (np.arange(9) * 10).astype(np.float32).reshape((-1, 3)),
+                name="B",
+            ),
+            onnx.numpy_helper.from_array(
+                (np.arange(9) * 10).astype(np.float32).reshape((-1, 3)),
+                name="C",
+            ),
+        ],
+    )
+    onnx_model = onnx.helper.make_model(graph)
+    onnx.checker.check_model(onnx_model)
+    return onnx_model
+
+
+def _large_linear_regression():
+    X = onnx.helper.make_tensor_value_info("X", onnx.TensorProto.FLOAT, [None, None])
+    Y = onnx.helper.make_tensor_value_info("Y", onnx.TensorProto.FLOAT, [None])
+    graph = onnx.helper.make_graph(
+        [
+            onnx.helper.make_node("MatMul", ["X", "A"], ["XA"]),
+            onnx.helper.make_node("MatMul", ["XA", "B"], ["XB"]),
+            onnx.helper.make_node("MatMul", ["XB", "C"], ["Y"]),
+        ],
+        "mm",
+        [X],
+        [Y],
+        [
+            onnx.model_container.make_large_tensor_proto(
+                "#loc0", "A", onnx.TensorProto.FLOAT, (3, 3)
+            ),
+            onnx.numpy_helper.from_array(
+                np.arange(9).astype(np.float32).reshape((-1, 3)), name="B"
+            ),
+            onnx.model_container.make_large_tensor_proto(
+                "#loc1", "C", onnx.TensorProto.FLOAT, (3, 3)
+            ),
+        ],
+    )
+    onnx_model = onnx.helper.make_model(graph)
+    large_model = onnx.model_container.make_large_model(
+        onnx_model.graph,
+        {
+            "#loc0": (np.arange(9) * 100).astype(np.float32).reshape((-1, 3)),
+            "#loc1": (np.arange(9) + 10).astype(np.float32).reshape((-1, 3)),
+        },
+    )
+    large_model.check_model()
+    return large_model
+
+
+class TestLargeOnnx(unittest.TestCase):
+    def test_large_onnx_no_large_initializer(self):
+        model_proto = _linear_regression()
+        assert isinstance(model_proto, onnx.ModelProto)
+        large_model = onnx.model_container.make_large_model(model_proto.graph)
+        assert isinstance(large_model, onnx.model_container.ModelContainer)
+        with tempfile.TemporaryDirectory() as temp:
+            filename = os.path.join(temp, "model.onnx")
+            large_model.save(filename)
+            copy = onnx.model_container.ModelContainer()
+            with self.assertRaises(RuntimeError):
+                assert copy.model_proto
+            copy.load(filename)
+            assert copy.model_proto is not None
+            onnx.checker.check_model(copy.model_proto)
+
+    def test_large_one_weight_file(self):
+        large_model = _large_linear_regression()
+        assert isinstance(large_model, onnx.model_container.ModelContainer)
+        with tempfile.TemporaryDirectory() as temp:
+            filename = os.path.join(temp, "model.onnx")
+            saved_proto = large_model.save(filename, True)
+            assert isinstance(saved_proto, onnx.ModelProto)
+            copy = onnx.model_container.ModelContainer()
+            copy.load(filename)
+            copy.check_model()
+            loaded_model = onnx.load_model(filename, load_external_data=True)
+            onnx.checker.check_model(loaded_model)
+
+    def test_large_multi_files(self):
+        large_model = _large_linear_regression()
+        assert isinstance(large_model, onnx.model_container.ModelContainer)
+        with tempfile.TemporaryDirectory() as temp:
+            filename = os.path.join(temp, "model.onnx")
+            saved_proto = large_model.save(filename, False)
+            assert isinstance(saved_proto, onnx.ModelProto)
+            copy = onnx.load_model(filename)
+            onnx.checker.check_model(copy)
+            for tensor in ext_data._get_all_tensors(copy):
+                if ext_data.uses_external_data(tensor):
+                    tested = 0
+                    for ext in tensor.external_data:
+                        if ext.key == "location":  # type: ignore[attr-defined]
+                            assert os.path.exists(ext.value)
+                            tested += 1
+                    self.assertEqual(tested, 1)
+            loaded_model = onnx.load_model(filename, load_external_data=True)
+            onnx.checker.check_model(loaded_model)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

onnx/test/model_inference_test.py

@@ -26,6 +26,28 @@ class TestModelInference(unittest.TestCase):
             elem_type = tensor_type.elem_type
             self.assertEqual(elem_type, expected_elem_type)
 
+    def _check_inference_error(self, model_text: str):
+        """Check that the model inference raises an InferenceError."""
+        model = onnx.parser.parse_model(model_text)
+        with self.assertRaises(onnx.shape_inference.InferenceError):
+            onnx.shape_inference.infer_shapes(model, True, True)
+
+    def test_unknown_op(self):
+        """Test that model inference handles unknown ops.
+        This special treatment is to support custom ops.
+        See comments in shape inference code for details.
+        """
+        model = """
+            <ir_version: 7, opset_import: [ "" : 17]>
+            agraph (float[N] x) => (y)
+            {
+                y = SomeUnknownOp (x)
+            }
+        """
+        # No output types are inferred for unknown ops.
+        # But ensure that the inference does not fail.
+        self._check(model)
+
     def test_mi_basic(self):
         """Test that model inference infers model output type."""
         model = """
@@ -222,6 +244,28 @@ class TestModelInference(unittest.TestCase):
         """
         self._check(model, onnx.TensorProto.INT32, onnx.TensorProto.FLOAT)
 
+    def test_mi_overloaded_function(self):
+        """Test use of functions."""
+        model = """
+            <ir_version: 10, opset_import: [ "" : 17, "local" : 1]>
+            agraph (float[N] x) => (y, z)
+            {
+                y = local.cast:to_int32 (x)
+                z = local.cast:to_int64 (x)
+            }
+            <opset_import: [ "" : 17 ], domain: "local", overload: "to_int32">
+            cast (x) => (y)
+            {
+                y = Cast<to=6> (x)
+            }
+            <opset_import: [ "" : 17 ], domain: "local", overload: "to_int64">
+            cast (x) => (y)
+            {
+                y = Cast<to=7> (x)
+            }
+        """
+        self._check(model, onnx.TensorProto.INT32, onnx.TensorProto.INT64)
+
 
 if __name__ == "__main__":
     unittest.main()