onnx 1.13.1__cp310-cp310-win32.whl → 1.14.1__cp310-cp310-win32.whl

onnx/backend/test/report/coverage.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 
 import csv
@@ -42,7 +44,7 @@ class NodeCoverage:
         if self.op_type is None:
             self.op_type = node.op_type
             assert self.op_type is not None
-            self.schema = defs.get_schema(self.op_type, node.domain)
+            self.schema = defs.get_schema(self.op_type, domain=node.domain)
 
         for attr in node.attribute:
             self.attr_coverages[attr.name].add(attr)
@@ -97,11 +99,7 @@ class Coverage:
     def report_text(self, writer: IO[str]) -> None:
         writer.write("---------- onnx coverage: ----------\n")
         writer.write(
-            "Operators (passed/loaded/total): {}/{}/{}\n".format(
-                len(self.buckets["passed"]),
-                len(self.buckets["loaded"]),
-                len(_all_schemas),
-            )
+            f"Operators (passed/loaded/total): {len(self.buckets['passed'])}/{len(self.buckets['loaded'])}/{len(_all_schemas)}\n"
         )
         writer.write("------------------------------------\n")
 
@@ -240,11 +238,7 @@ class Coverage:
                         for other_framework in other_frameworks:
                             existing_models[model][other_framework] = "Skipped!"
                     existing_models[model][str(backend)] = str(
-                        "{}/{} nodes covered: {}".format(
-                            num_covered,
-                            len(self.models[bucket][model].node_coverages),
-                            msg,
-                        )
+                        f"{num_covered}/{len(self.models[bucket][model].node_coverages)} nodes covered: {msg}"
                     )
             summaries.clear()
             if "Summary" in existing_models:
@@ -252,9 +246,9 @@ class Coverage:
                 del existing_models["Summary"]
             if str(backend) in summaries:
                 del summaries[str(backend)]
-            summaries[str(backend)] = "{}/{} model tests passed".format(
-                len(self.models["passed"]), num_models
-            )
+            summaries[
+                str(backend)
+            ] = f"{len(self.models['passed'])}/{num_models} model tests passed"
             summaries["Model"] = "Summary"
             for model in existing_models:  # type: ignore
                 existing_models[model]["Model"] = model

onnx/backend/test/runner/__init__.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 from __future__ import annotations
@@ -31,19 +33,19 @@ from urllib.request import urlretrieve
 import numpy as np
 
 import onnx
-from onnx import ModelProto, NodeProto, TypeProto, numpy_helper
+import onnx.reference
+from onnx import ONNX_ML, ModelProto, NodeProto, TypeProto, ValueInfoProto, numpy_helper
 from onnx.backend.base import Backend
-
-from ..case.test_case import TestCase
-from ..loader import load_model_tests
-from .item import TestItem
+from onnx.backend.test.case.test_case import TestCase
+from onnx.backend.test.loader import load_model_tests
+from onnx.backend.test.runner.item import TestItem
 
 
 class BackendIsNotSupposedToImplementIt(unittest.SkipTest):
     pass
 
 
-def retry_excute(times: int) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+def retry_execute(times: int) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
     assert times >= 1
 
     def wrapper(func: Callable[..., Any]) -> Callable[..., Any]:
@@ -133,7 +135,7 @@ class Runner:
                 for exclude in self._exclude_patterns:
                     if exclude.search(name):
                         item.func = unittest.skip(
-                            f'matched exclude pattern "{exclude.pattern}"'  # noqa: B907
+                            f'matched exclude pattern "{exclude.pattern}"'
                         )(item.func)
                 for xfail in self._xfail_patterns:
                     if xfail.search(name):
@@ -204,7 +206,7 @@ class Runner:
                     )
             else:
                 np.testing.assert_equal(outputs[i].dtype, ref_outputs[i].dtype)
-                if ref_outputs[i].dtype == object:
+                if ref_outputs[i].dtype == object:  # type: ignore[attr-defined]
                     np.testing.assert_array_equal(outputs[i], ref_outputs[i])
                 else:
                     np.testing.assert_allclose(
@@ -212,7 +214,7 @@ class Runner:
                     )
 
     @classmethod
-    @retry_excute(3)
+    @retry_execute(3)
     def download_model(
         cls, model_test: TestCase, model_dir: str, models_dir: str
     ) -> None:
@@ -223,20 +225,14 @@ class Runner:
             download_file.close()
             assert model_test.url
             print(
-                "Start downloading model {} from {}".format(
-                    model_test.model_name, model_test.url
-                )
+                f"Start downloading model {model_test.model_name} from {model_test.url}"
             )
             urlretrieve(model_test.url, download_file.name)
             print("Done")
             with tarfile.open(download_file.name) as t:
                 t.extractall(models_dir)
         except Exception as e:
-            print(
-                "Failed to prepare data for model {}: {}".format(
-                    model_test.model_name, e
-                )
-            )
+            print(f"Failed to prepare data for model {model_test.model_name}: {e}")
             raise
         finally:
             os.remove(download_file.name)
@@ -281,9 +277,7 @@ class Runner:
             device_test_name = f"{test_name}_{device.lower()}"
             if device_test_name in self._test_items[category]:
                 raise ValueError(
-                    'Duplicated test name "{}" in category "{}"'.format(
-                        device_test_name, category
-                    )
+                    f'Duplicated test name "{device_test_name}" in category "{category}"'
                 )
 
             @unittest.skipIf(  # type: ignore
@@ -297,11 +291,7 @@ class Runner:
                 except BackendIsNotSupposedToImplementIt as e:
                     # hacky verbose reporting
                     if "-v" in sys.argv or "--verbose" in sys.argv:
-                        print(
-                            "Test {} is effectively skipped: {}".format(
-                                device_test_name, e
-                            )
-                        )
+                        print(f"Test {device_test_name} is effectively skipped: {e}")
 
             self._test_items[category][device_test_name] = TestItem(
                 device_test_func, report_item
@@ -310,17 +300,76 @@ class Runner:
         for device in devices:
             add_device_test(device)
 
+    @staticmethod
+    def generate_dummy_data(
+        x: ValueInfoProto, seed: int = 0, name: str = "", random: bool = False
+    ) -> np.ndarray:
+        """
+        Generates a random tensor based on the input definition.
+        """
+        if not x.type.tensor_type:
+            raise NotImplementedError(
+                f"Input expected to have tensor type. "
+                f"Unable to generate random data for model {name!r} and input {x}."
+            )
+        if x.type.tensor_type.elem_type != 1:
+            raise NotImplementedError(
+                f"Currently limited to float tensors. "
+                f"Unable to generate random data for model {name!r} and input {x}."
+            )
+        shape = tuple(
+            d.dim_value if d.HasField("dim_value") else 1
+            for d in x.type.tensor_type.shape.dim
+        )
+        if random:
+            gen = np.random.default_rng(seed=seed)
+            return gen.random(shape, np.float32)
+        n = np.prod(shape)
+        return (np.arange(n).reshape(shape) / n).astype(np.float32)
+
     def _add_model_test(self, model_test: TestCase, kind: str) -> None:
         # model is loaded at runtime, note sometimes it could even
         # never loaded if the test skipped
         model_marker: List[Optional[Union[ModelProto, NodeProto]]] = [None]
 
         def run(test_self: Any, device: str) -> None:
-            if model_test.model_dir is None:
-                model_dir = self.prepare_model_data(model_test)
+            if model_test.url is not None and model_test.url.startswith(
+                "onnx/backend/test/data/light/"
+            ):
+                # testing local files
+                model_pb_path = os.path.normpath(
+                    os.path.join(
+                        os.path.dirname(__file__),
+                        "..",
+                        "..",
+                        "..",
+                        "..",
+                        model_test.url,
+                    )
+                )
+                if not os.path.exists(model_pb_path):
+                    raise FileNotFoundError(f"Unable to find model {model_pb_path!r}.")
+                onnx_home = os.path.expanduser(
+                    os.getenv("ONNX_HOME", os.path.join("~", ".onnx"))
+                )
+                models_dir = os.getenv(
+                    "ONNX_MODELS", os.path.join(onnx_home, "models", "light")
+                )
+                model_dir: str = os.path.join(models_dir, model_test.model_name)
+                if not os.path.exists(model_dir):
+                    os.makedirs(model_dir)
+                use_dummy = True
             else:
-                model_dir = model_test.model_dir
-            model_pb_path = os.path.join(model_dir, "model.onnx")
+                if model_test.model_dir is None:
+                    model_dir = self.prepare_model_data(model_test)
+                else:
+                    model_dir = model_test.model_dir
+                model_pb_path = os.path.join(model_dir, "model.onnx")
+                use_dummy = False
+
+            if not ONNX_ML and "ai_onnx_ml" in model_dir:
+                return
+
             model = onnx.load(model_pb_path)
             model_marker[0] = model
             if (
@@ -329,18 +378,76 @@ class Runner:
                 and not self.backend.is_compatible(model)
             ):
                 raise unittest.SkipTest("Not compatible with backend")
+
             prepared_model = self.backend.prepare(model, device)
             assert prepared_model is not None
 
-            # TODO after converting all npz files to protobuf, we can delete this.
-            for test_data_npz in glob.glob(os.path.join(model_dir, "test_data_*.npz")):
-                test_data = np.load(test_data_npz, encoding="bytes")
-                inputs = list(test_data["inputs"])
-                outputs = list(prepared_model.run(inputs))
-                ref_outputs = test_data["outputs"]
-                self.assert_similar_outputs(
-                    ref_outputs, outputs, rtol=model_test.rtol, atol=model_test.atol
-                )
+            if use_dummy:
+                # When the backend test goes through a test involving a
+                # model stored in onnx/backend/test/data/light,
+                # this function generates expected output coming from
+                # from ReferenceEvaluator run with random inputs.
+                # A couple of models include many Conv operators and the
+                # python implementation is slow (such as test_bvlc_alexnet).
+                with open(model_pb_path, "rb") as f:
+                    onx = onnx.load(f)
+
+                test_data_set = os.path.join(model_dir, "test_data_set_0")
+                if not os.path.exists(test_data_set):
+                    os.mkdir(test_data_set)
+                feeds = {}
+                inits = set(i.name for i in onx.graph.initializer)
+                n_input = 0
+                inputs = []
+                for i in range(len(onx.graph.input)):
+                    if onx.graph.input[i].name in inits:
+                        continue
+                    name = os.path.join(test_data_set, f"input_{n_input}.pb")
+                    inputs.append(name)
+                    n_input += 1
+                    x = onx.graph.input[i]
+                    value = self.generate_dummy_data(
+                        x, seed=0, name=model_test.model_name, random=False
+                    )
+                    feeds[x.name] = value
+                    with open(name, "wb") as f:
+                        f.write(onnx.numpy_helper.from_array(value).SerializeToString())
+
+                # loads expected output if any available
+                prefix = os.path.splitext(model_pb_path)[0]
+                expected_outputs = []
+                for i in range(len(onx.graph.output)):
+                    name = f"{prefix}_output_{i}.pb"
+                    if os.path.exists(name):
+                        expected_outputs.append(name)
+                        continue
+                    expected_outputs = None
+                    break
+
+                if expected_outputs is None:
+                    ref = onnx.reference.ReferenceEvaluator(onx)
+                    outputs = ref.run(None, feeds)
+                    for i, o in enumerate(outputs):
+                        name = os.path.join(test_data_set, f"output_{i}.pb")
+                        with open(name, "wb") as f:
+                            f.write(onnx.numpy_helper.from_array(o).SerializeToString())
+                else:
+                    for i, o in enumerate(expected_outputs):
+                        name = os.path.join(test_data_set, f"output_{i}.pb")
+                        shutil.copy(o, name)
+            else:
+                # TODO after converting all npz files to protobuf, we can delete this.
+                for test_data_npz in glob.glob(
+                    os.path.join(model_dir, "test_data_*.npz")
+                ):
+                    test_data = np.load(test_data_npz, encoding="bytes")
+                    inputs = list(test_data["inputs"])
+                    outputs = list(prepared_model.run(inputs))
+                    ref_outputs = test_data["outputs"]
+                    self.assert_similar_outputs(
+                        ref_outputs, outputs, rtol=model_test.rtol, atol=model_test.atol
+                    )
+
             for test_data_dir in glob.glob(os.path.join(model_dir, "test_data_set*")):
                 inputs = []
                 inputs_num = len(glob.glob(os.path.join(test_data_dir, "input_*.pb")))
@@ -382,7 +489,7 @@ class Runner:
             elif model_type_proto.HasField("optional_type"):
                 optional = onnx.OptionalProto()
                 optional.ParseFromString(protobuf_content)
-                target_list.append(numpy_helper.to_optional(optional))
+                target_list.append(numpy_helper.to_optional(optional))  # type: ignore[arg-type]
             else:
                 print(
                     "Loading proto of that specific type (Map/Sparse Tensor) is currently not supported"

onnx/backend/test/runner/item.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import dataclasses

onnx/backend/test/stat_coverage.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python
 
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import os
@@ -12,10 +14,7 @@ from onnx.backend.test.runner import Runner
 
 
 def is_ml(schemas: Sequence[defs.OpSchema]) -> bool:
-    for s in schemas:
-        if s.domain == "ai.onnx.ml":
-            return True
-    return False
+    return any(s.domain == "ai.onnx.ml" for s in schemas)
 
 
 def gen_outlines(f: IO[Any], ml: bool) -> None:
@@ -91,13 +90,9 @@ def gen_node_test_coverage(
     f.write("## Summary\n")
     if num_common:
         f.write(
-            "Node tests have covered {}/{} ({:.2f}%, {} generators excluded) "
-            "common operators.\n\n".format(
-                len(common_covered),
-                num_common,
-                (len(common_covered) / float(num_common) * 100),
-                len(common_generator),
-            )
+            f"Node tests have covered {len(common_covered)}/{num_common} "
+            f"({len(common_covered) / float(num_common) * 100:.2f}%, {len(common_generator)} "
+            f"generators excluded) common operators.\n\n"
         )
     else:
         f.write("Node tests have covered 0/0 (N/A) common operators. \n\n")
@@ -128,15 +123,13 @@ def gen_node_test_coverage(
     for t in titles:
         f.write(f"* [{t[9:]}](#{t[9:].lower().replace(' ', '-')})\n")
     f.write("\n")
-    for t, l in zip(titles, all_lists):
+    for t, l in zip(titles, all_lists):  # noqa: E741
         f.write(f"## {t}\n")
         for s in l:
             f.write(f"### {s}")
             if s in node_tests:
                 f.write(
-                    "\nThere are {} test cases, listed as following:\n".format(
-                        len(node_tests[s])
-                    )
+                    f"\nThere are {len(node_tests[s])} test cases, listed as following:\n"
                 )
                 for summary, code in sorted(node_tests[s]):
                     f.write("<details>\n")
@@ -165,8 +158,17 @@ def gen_model_test_coverage(
     attrs: Dict[str, Dict[str, List[Any]]] = dict()
     model_paths: List[Any] = []
     for rt in load_model_tests(kind="real"):
-        model_dir = Runner.prepare_model_data(rt)
-        model_paths.append(os.path.join(model_dir, "model.onnx"))
+        if rt.url.startswith("onnx/backend/test/data/light/"):
+            # testing local files
+            model_name = os.path.normpath(
+                os.path.join(os.path.dirname(__file__), "..", "..", "..", rt.url)
+            )
+            if not os.path.exists(model_name):
+                raise FileNotFoundError(f"Unable to find model {model_name!r}.")
+            model_paths.append(model_name)
+        else:
+            model_dir = Runner.prepare_model_data(rt)
+            model_paths.append(os.path.join(model_dir, "model.onnx"))
     model_paths.sort()
     model_written = False
     for model_pb_path in model_paths:
@@ -224,12 +226,9 @@ def gen_model_test_coverage(
                         if attr.graphs not in attrs[node.op_type][attr.name]:
                             attrs[node.op_type][attr.name].append(attr.graphs)
         f.write(
-            "\n{} has {} nodes. Of these, {} are covered by node tests ({}%)\n\n\n".format(
-                model.graph.name,
-                num_covered,
-                len(model.graph.node),
-                100.0 * float(num_covered) / float(len(model.graph.node)),
-            )
+            f"\n{model.graph.name} has {num_covered} nodes. "
+            f"Of these, {len(model.graph.node)} are covered by node tests "
+            f"({100.0 * float(num_covered) / float(len(model.graph.node))}%)\n\n\n"
         )
         # Iterate through attrs, print
         f.write("<details>\n")
@@ -238,9 +237,7 @@ def gen_model_test_coverage(
             f.write("<details>\n")
             # Get total number of attributes for node schema
             f.write(
-                "<summary>{}: {} out of {} attributes covered</summary>\n\n".format(
-                    op, len(attrs[op].keys()), len(schema_dict[op].attributes)
-                )
+                f"<summary>{op}: {len(attrs[op])} out of {len(schema_dict[op].attributes)} attributes covered</summary>\n\n"
             )
             for attribute in sorted(schema_dict[op].attributes):
                 if attribute in attrs[op]:

onnx/bin/__init__.py

@@ -1 +1,3 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0

onnx/bin/checker.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import argparse

onnx/checker.cc

@@ -1,6 +1,6 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- */
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
 
 #include "onnx/checker.h"
 #include "onnx/common/file_utils.h"
@@ -151,8 +151,8 @@ void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) {
               "' points outside the directory");
         }
         std::wstring data_path = path_join(utf8str_to_wstring(ctx.get_model_dir()), relative_path);
-        struct _stat buff;
-        if (_wstat(data_path.c_str(), &buff) != 0) {
+        struct _stat64 buff;
+        if (_wstat64(data_path.c_str(), &buff) != 0) {
           fail_check(
               "Data of TensorProto ( tensor name: ",
               tensor.name(),
@@ -183,9 +183,14 @@ void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) {
               "' points outside the directory");
         }
         std::string data_path = path_join(ctx.get_model_dir(), relative_path);
-        // use stat to check whether the file exists
-        struct stat buffer;
+        // use stat64 to check whether the file exists
+#if defined(__APPLE__) || defined(__wasm__)
+        struct stat buffer; // APPLE does not have stat64
         if (stat((data_path).c_str(), &buffer) != 0) {
+#else
+        struct stat64 buffer; // All POSIX except APPLE have stat64
+        if (stat64((data_path).c_str(), &buffer) != 0) {
+#endif
           fail_check(
               "Data of TensorProto ( tensor name: ",
               tensor.name(),
@@ -257,6 +262,10 @@ void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) {
       case TensorProto::BOOL:
       case TensorProto::FLOAT16:
       case TensorProto::BFLOAT16:
+      case TensorProto::FLOAT8E4M3FN:
+      case TensorProto::FLOAT8E4M3FNUZ:
+      case TensorProto::FLOAT8E5M2:
+      case TensorProto::FLOAT8E5M2FNUZ:
         check_field(int32_data);
         break;
 
@@ -622,7 +631,14 @@ void check_node(const NodeProto& node, const CheckerContext& ctx, const LexicalS
   }
   auto domain_version = dit->second;
 
+  // for ops referencing local functions, there is no schema to verify it.
+  // will add a check to verify consistency between these ops and local functions.
+  std::unordered_set<std::string> seen_attr_names{};
   for (const auto& attr : node.attribute()) {
+    if (!seen_attr_names.insert(attr.name()).second) {
+      fail_check("Attribute '", attr.name(), "' appeared multiple times.");
+    };
+
     check_attribute(attr, ctx, lex_ctx);
   }
 
@@ -831,7 +847,7 @@ void check_opset_compatibility(
     fail_check(
         "Opset import for domain " + node.domain() + " in function op " + node.op_type() +
         "is not compatible with the version imported by model. FunctionOp imports version " +
-        ONNX_NAMESPACE::to_string(func_opset_version) + "whereas model imports version " +
+        ONNX_NAMESPACE::to_string(func_opset_version) + " whereas model imports version " +
         ONNX_NAMESPACE::to_string(model_opset_version));
   }
 }
@@ -960,7 +976,7 @@ void check_model(const ModelProto& model, CheckerContext& ctx) {
     fail_check("The model does not have an ir_version set properly.");
   }
   if (model.ir_version() > IR_VERSION) {
-    fail_check("Your model ir_version is higher than the checker's.");
+    fail_check("Your model ir_version ", model.ir_version(), " is higher than the checker's (", IR_VERSION, ").");
   }
   if (model.metadata_props_size() > 1) {
     std::unordered_set<std::string> keys;
@@ -994,6 +1010,7 @@ void check_model(const ModelProto& model, CheckerContext& ctx) {
 
   if (ctx.get_ir_version() >= 0x00000008) {
     check_model_local_functions(model, ctx, lex_ctx);
+    // TODO: check consistency between local functions and ops referencing it.
   }
 }
 

onnx/checker.h

@@ -1,6 +1,6 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- */
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 

onnx/checker.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 """onnx checker
 
@@ -7,22 +9,24 @@ proto is legal.
 
 import functools
 import sys
-from typing import Any, Callable, Type, TypeVar, Union, cast
+from typing import Any, Callable, Optional, Type, TypeVar, Union, cast
 
 from google.protobuf.message import Message
 
 import onnx.defs
-import onnx.onnx_cpp2py_export.checker as C
+import onnx.onnx_cpp2py_export.checker as C  # noqa: N812
 import onnx.shape_inference
 from onnx import (
     IR_VERSION,
     AttributeProto,
+    FunctionProto,
     GraphProto,
     ModelProto,
     NodeProto,
     SparseTensorProto,
     TensorProto,
     ValueInfoProto,
+    helper,
 )
 
 # Limitation of single protobuf file is 2GB
@@ -50,9 +54,7 @@ def _create_checker(proto_type: Type[Message]) -> Callable[[FuncType], FuncType]
         def checker(proto: Message, ctx: C.CheckerContext = DEFAULT_CONTEXT) -> Any:
             if not isinstance(proto, proto_type):
                 raise RuntimeError(
-                    "You cannot pass an object that is not of type {}".format(
-                        proto_type.__name__
-                    )
+                    f"You cannot pass an object that is not of type {proto_type.__name__}"
                 )
             return getattr(C, py_func.__name__)(proto.SerializeToString(), ctx)
 
@@ -85,6 +87,21 @@ def check_node(node: NodeProto, ctx: C.CheckerContext = DEFAULT_CONTEXT) -> None
     pass
 
 
+def check_function(
+    function: FunctionProto, ctx: Optional[C.CheckerContext] = None
+) -> None:
+    if ctx is None:
+        ctx = C.CheckerContext()
+        ctx.ir_version = helper.find_min_ir_version_for(
+            list(function.opset_import), True
+        )
+        function_opset_dic = {}
+        for domain_version in function.opset_import:
+            function_opset_dic[domain_version.domain] = domain_version.version
+        ctx.opset_imports = function_opset_dic
+    C.check_function(function.SerializeToString(), ctx)
+
+
 @_create_checker(GraphProto)
 def check_graph(graph: GraphProto, ctx: C.CheckerContext = DEFAULT_CONTEXT) -> None:
     pass

onnx/common/array_ref.h

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/common/assertions.cc

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/common/assertions.h

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/common/common.h

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/common/constants.h

@@ -1,6 +1,6 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- */
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 

onnx/common/file_utils.h

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -23,4 +25,4 @@ void LoadProtoFromPath(const std::string proto_path, T& proto) {
         "Unable to parse proto from file: ", proto_path, ". Please check if it is a valid protobuf file of proto. ");
   }
 }
-} // namespace ONNX_NAMESPACE
+} // namespace ONNX_NAMESPACE