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

onnx/test/compose_test.py

@@ -24,25 +24,19 @@ from onnx import (
 
 
 def _load_model(m_def: str) -> ModelProto:
-    """
-    Parses a model from a string representation, including checking the model for correctness
-    """
+    """Parses a model from a string representation, including checking the model for correctness"""
     m = parser.parse_model(m_def)
     checker.check_model(m)
     return m
 
 
 def _prefixed(prefix: str, s: str) -> str:
-    """
-    Prefixes a string (if not empty)
-    """
+    """Prefixes a string (if not empty)"""
     return prefix + s if len(s) > 0 else s
 
 
 def _get_shape(value_info: ValueInfoProto) -> List[int]:
-    """
-    Returns a list of integers representing the shape of the provided ValueInfoProto
-    """
+    """Returns a list of integers representing the shape of the provided ValueInfoProto"""
     return [
         value_info.type.tensor_type.shape.dim[d].dim_value
         for d in range(len(value_info.type.tensor_type.shape.dim))
@@ -135,8 +129,7 @@ class TestComposeFunctions(unittest.TestCase):
         check_expectations(m1.graph, m2.graph, m3.graph)
 
     def test_case_connect_all_no_name_collision(self) -> None:
-        """
-        Tests a simple scenario where two models without overlapping names are merged by
+        """Tests a simple scenario where two models without overlapping names are merged by
         connecting all the outputs in the first models to all the inputs in the second model
         """
 
@@ -152,8 +145,7 @@ class TestComposeFunctions(unittest.TestCase):
         self._test_merge_models(M1_DEF, M2_DEF, io_map, check_expectations)
 
     def test_case_connect_same_output_twice(self) -> None:
-        """
-        Tests a scenario where we merge two models by connecting a single output in the first model
+        """Tests a scenario where we merge two models by connecting a single output in the first model
         to all the inputs in the second
         """
 
@@ -170,8 +162,7 @@ class TestComposeFunctions(unittest.TestCase):
         self._test_merge_models(M1_DEF, M2_DEF, io_map, check_expectations)
 
     def test_case_connect_same_output_drop_outputs(self) -> None:
-        """
-        Tests a scenario where we merge two models by connecting a single output in the first model
+        """Tests a scenario where we merge two models by connecting a single output in the first model
         to all the inputs in the second, while dropping the rest of the outputs in the first model
         """
 
@@ -190,11 +181,9 @@ class TestComposeFunctions(unittest.TestCase):
         )
 
     def test_case_connect_same_input_output_name(self) -> None:
-        """
-        Tests a scenario where we merge two models, where the inputs/outputs connected
+        """Tests a scenario where we merge two models, where the inputs/outputs connected
         are named exactly the same
         """
-
         m1_def = """
             <
                 ir_version: 7,
@@ -226,10 +215,7 @@ class TestComposeFunctions(unittest.TestCase):
         self._test_merge_models(m1_def, m2_def, io_map, check_expectations)
 
     def test_case_drop_inputs_outputs(self) -> None:
-        """
-        Tests a scenario where we merge two models, not including some of the inputs/outputs
-        """
-
+        """Tests a scenario where we merge two models, not including some of the inputs/outputs"""
         m1_def = """
             <
                 ir_version: 7,
@@ -268,11 +254,9 @@ class TestComposeFunctions(unittest.TestCase):
         )
 
     def test_case_name_collision_prefix(self) -> None:
-        """
-        Tests a scenario where we merge two models that have name collisions, but they
+        """Tests a scenario where we merge two models that have name collisions, but they
         are avoided by prefixing the models model.
         """
-
         m1_def = """
             <
                 ir_version: 7,
@@ -297,8 +281,7 @@ class TestComposeFunctions(unittest.TestCase):
         )
 
     def test_case_connect_partially_no_name_collision(self) -> None:
-        """
-        Tests a scenario where two models without overlapping names are merged by
+        """Tests a scenario where two models without overlapping names are merged by
         connecting some outputs from the first model to some inputs in the second.
         The remaining inputs/outputs should be present in the combined model
         """
@@ -337,9 +320,7 @@ class TestComposeFunctions(unittest.TestCase):
         self.assertRaises(ValueError, compose.merge_models, m1, m2, io_map=io_map)
 
     def test_error_wrong_input_output_name(self) -> None:
-        """
-        Tests that providing a non existing output/input name in the io_map argument produces an error.
-        """
+        """Tests that providing a non existing output/input name in the io_map argument produces an error."""
         m1, m2 = _load_model(M1_DEF), _load_model(M2_DEF)
 
         self.assertRaises(
@@ -526,33 +507,23 @@ class TestComposeFunctions(unittest.TestCase):
                     self.assertEqual(_prefixed(prefix, n0.name), n1.name)
 
     def test_add_prefix_nodes(self) -> None:
-        """
-        Tests renaming nodes only
-        """
+        """Tests renaming nodes only"""
         self._test_add_prefix(rename_nodes=True)
 
     def test_add_prefix_edges(self) -> None:
-        """
-        Tests prefixing nodes edges. This will also rename inputs/outputs, since the names are shared
-        """
+        """Tests prefixing nodes edges. This will also rename inputs/outputs, since the names are shared"""
         self._test_add_prefix(rename_edges=True)
 
     def test_add_prefix_inputs(self) -> None:
-        """
-        Tests prefixing graph inputs only. Relevant node edges should be renamed as well
-        """
+        """Tests prefixing graph inputs only. Relevant node edges should be renamed as well"""
         self._test_add_prefix(rename_inputs=True)
 
     def test_add_prefix_outputs(self) -> None:
-        """
-        Tests prefixing graph outputs only. Relevant node edges should be renamed as well
-        """
+        """Tests prefixing graph outputs only. Relevant node edges should be renamed as well"""
         self._test_add_prefix(rename_outputs=True)
 
     def test_add_prefix_attribute_subgraph(self) -> None:
-        """
-        Tests prefixing attribute's subgraph. Relevant subgraph should be renamed as well
-        """
+        """Tests prefixing attribute's subgraph. Relevant subgraph should be renamed as well"""
         C = helper.make_tensor_value_info("C", TensorProto.BOOL, [1])
         X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, 1])
         Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [None, 1])
@@ -597,20 +568,15 @@ class TestComposeFunctions(unittest.TestCase):
                             self.assertEqual(_prefixed(prefix, output_n0), output_n1)
 
     def test_add_prefix_all(self) -> None:
-        """
-        Tests prefixing all names in the graph
-        """
+        """Tests prefixing all names in the graph"""
         self._test_add_prefix(True, True, True, True, True, True)
 
     def test_add_prefix_inplace(self) -> None:
-        """
-        Tests prefixing inplace
-        """
+        """Tests prefixing inplace"""
         self._test_add_prefix(inplace=True)
 
     def test_expand_out_dim(self) -> None:
-        """
-        Tests expanding output dimensions. The resulting graph should have the same output names,
+        """Tests expanding output dimensions. The resulting graph should have the same output names,
         but with one more dimension at the specified index.
         """
         m1 = _load_model(M1_DEF)
@@ -768,46 +734,34 @@ class TestComposeFunctions(unittest.TestCase):
         self.assertEqual(0, len(overlap))
 
     def test_overlapping_input_names(self) -> None:
-        """
-        Tests error checking when the name of the inputs overlaps
-        """
+        """Tests error checking when the name of the inputs overlaps"""
         self._test_overlapping_names(inputs0=["i0", "i1"], inputs1=["i1", "i2"])
 
     def test_overlapping_output_names(self) -> None:
-        """
-        Tests error checking when the name of the output overlaps
-        """
+        """Tests error checking when the name of the output overlaps"""
         self._test_overlapping_names(outputs0=["o0", "o1"], outputs1=["o1", "o2"])
 
     def test_overlapping_value_info_names(self) -> None:
-        """
-        Tests error checking when the name of value_info entries overlaps
-        """
+        """Tests error checking when the name of value_info entries overlaps"""
         self._test_overlapping_names(
             value_info0=["vi0", "vi1"], value_info1=["vi1", "vi2"]
         )
 
     def test_overlapping_initializer_names(self) -> None:
-        """
-        Tests error checking when the name of initializer entries overlaps
-        """
+        """Tests error checking when the name of initializer entries overlaps"""
         self._test_overlapping_names(
             initializer0=["init0", "init1"], initializer1=["init1", "init2"]
         )
 
     def test_overlapping_sparse_initializer_names(self) -> None:
-        """
-        Tests error checking when the name of sparse_initializer entries overlaps
-        """
+        """Tests error checking when the name of sparse_initializer entries overlaps"""
         self._test_overlapping_names(
             sparse_initializer0=["sparse_init0", "sparse_init1"],
             sparse_initializer1=["sparse_init1", "sparse_init2"],
         )
 
     def test_overlapping_function_names(self) -> None:
-        """
-        Tests error checking when the name of local function entries overlaps
-        """
+        """Tests error checking when the name of local function entries overlaps"""
         ops = [helper.make_opsetid("", 10), helper.make_opsetid("local", 10)]
 
         def _make_function(
@@ -944,9 +898,7 @@ class TestComposeFunctions(unittest.TestCase):
         )
 
     def test_merge_drop_unnecessary_initializers_and_value_info(self) -> None:
-        """
-        Tests automatic removal of initializers when merging graphs
-        """
+        """Tests automatic removal of initializers when merging graphs"""
         ops = [helper.make_opsetid("", 10)]
 
         g = GraphProto()

onnx/test/cpp/inliner_test.cc

@@ -34,7 +34,7 @@ static void InlineFunctions(ModelProto& model, const char* input, const inliner:
     inliner::InlineLocalFunctions(model, true);
   // std::cout << "After inlining:\n" << ProtoToString(model) << "\n";
 
-  // The following will ensure basic sanity checks hold after inlining, including
+  // The following will ensure basic safety checks hold after inlining, including
   // absence of duplicate names (multiple assignments to same name).
   checker::check_model(model, true, true);
 }
@@ -80,6 +80,46 @@ square (x) => (y) {
   ASSERT_EQ(num_functions, 0);
 }
 
+// Test that inlining processes subgraphs.
+TEST(FunctionInliner, SubgraphTest) {
+  const char* code = R"ONNX(
+<
+  ir_version: 8,
+  opset_import: [ "" : 10, "local" : 1 ]
+>
+agraph (bool cond, float[N] X) => (float[N] Y)
+{
+  Y = If (cond) <
+    then_branch = then_graph () => (y) {
+        y = local.square (X)
+    },
+    else_branch = else_graph () => (y) {
+        y = local.square (X)
+    }
+  >
+}
+
+<
+  opset_import: [ "" : 10 ],
+  domain: "local",
+  doc_string: "Function square."
+>
+square (x) => (y) {
+  y = Mul (x, x)
+}
+)ONNX";
+
+  ModelProto model;
+  InlineFunctions(model, code);
+  auto& if_node = model.graph().node(0);
+  auto& graph1 = if_node.attribute(0).g();
+  ASSERT_EQ(graph1.node(0).op_type(), "Mul");
+  auto& graph2 = if_node.attribute(1).g();
+  ASSERT_EQ(graph2.node(0).op_type(), "Mul");
+  auto num_functions = model.functions_size();
+  ASSERT_EQ(num_functions, 0);
+}
+
 TEST(FunctionInliner, Nested) {
   const char* code = R"ONNX(
 <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
@@ -132,6 +172,41 @@ foo (x) => (y) {
   InlineFunctions(model, code);
 }
 
+TEST(FunctionInliner, ValueInfoPropagation) {
+  const char* code = R"ONNX(
+<ir_version: 10, opset_import: [ "" : 17, "local" : 1 ]>
+agraph (float[N] X) => (float[N] Y)
+{
+  result = local.foo (X)
+  Y = Abs (result)
+}
+
+<opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+foo (x) => (y)
+<float[N] temp> {
+  temp = Add(x, x)
+  y = Neg (temp)
+}
+)ONNX";
+
+  ModelProto model;
+  InlineFunctions(model, code);
+  // Check that valueinfo is propagated fron function to main graph.
+  auto& graph = model.graph();
+  auto& temp_new_name = graph.node(0).output(0);
+  auto& valueinfos = graph.value_info();
+  for (auto& valueinfo : valueinfos) {
+    if (valueinfo.name() == temp_new_name) {
+      ASSERT_TRUE(valueinfo.has_type());
+      ASSERT_TRUE(valueinfo.type().has_tensor_type());
+      ASSERT_TRUE(valueinfo.type().tensor_type().has_shape());
+      ASSERT_TRUE(valueinfo.type().tensor_type().shape().dim_size() == 1);
+      return;
+    }
+  }
+  ASSERT_TRUE(false) << "ValueInfo not found";
+}
+
 TEST(FunctionInliner, TwoCallsToSameFunction) {
   const char* code = R"ONNX(
 <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>

onnx/test/cpp/ir_test.cc

@@ -0,0 +1,60 @@
+// Copyright (c) ONNX Project Contributors
+
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <iostream>
+
+#include "gtest/gtest.h"
+#include "onnx/common/ir.h"
+#include "onnx/common/ir_pb_converter.h"
+#include "onnx/defs/printer.h"
+
+namespace ONNX_NAMESPACE {
+namespace Test {
+
+static bool IsValidIdentifier(const std::string& name) {
+  if (name.empty()) {
+    return false;
+  }
+  if (!isalpha(name[0]) && name[0] != '_') {
+    return false;
+  }
+  for (size_t i = 1; i < name.size(); ++i) {
+    if (!isalnum(name[i]) && name[i] != '_') {
+      return false;
+    }
+  }
+  return true;
+}
+
+TEST(IR, ValidIdentifierTest) {
+  Graph* g = new Graph();
+  g->setName("test");
+  Value* x = g->addInput();
+  x->setUniqueName("x");
+  x->setElemType(ONNX_NAMESPACE::TensorProto_DataType_FLOAT);
+  x->setSizes({Dimension("M"), Dimension("N")});
+  Node* node1 = g->create(kNeg, 1);
+  node1->addInput(x);
+  g->appendNode(node1);
+  Value* temp1 = node1->outputs()[0];
+  Node* node2 = g->create(kNeg, 1);
+  node2->addInput(temp1);
+  g->appendNode(node2);
+  Value* y = node2->outputs()[0];
+  g->registerOutput(y);
+
+  ModelProto model;
+  ExportModelProto(&model, std::shared_ptr<Graph>(g));
+
+  for (auto& node : model.graph().node()) {
+    for (auto& name : node.output()) {
+      EXPECT_TRUE(IsValidIdentifier(name));
+    }
+  }
+}
+
+} // namespace Test
+} // namespace ONNX_NAMESPACE

onnx/test/cpp/parser_test.cc

@@ -363,6 +363,86 @@ f (y, z) => (w)
   EXPECT_EQ(fp.opset_import_size(), 1);
 }
 
+TEST(ParserTest, FunctionValueInfoTest) {
+  const char* code = R"ONNX(
+<
+  opset_import: [ "" : 10 ],
+  domain: "ai.onnx.ml",
+  doc_string: "A function test case."
+>
+f (float[N] y, float[N] z) => (float[N] w)
+{
+    x = Add(y, z)
+    w = Mul(x, y)
+}
+)ONNX";
+
+  FunctionProto fp;
+  Parse(fp, code);
+
+  EXPECT_EQ(fp.input_size(), 2);
+  EXPECT_EQ(fp.output_size(), 1);
+  ASSERT_EQ(fp.value_info_size(), 3);
+  EXPECT_EQ(fp.value_info(0).name(), "y");
+  EXPECT_EQ(fp.value_info(1).name(), "z");
+  EXPECT_EQ(fp.value_info(2).name(), "w");
+}
+
+TEST(ParserTest, FunctionValueInfoTest2) {
+  const char* code = R"ONNX(
+<
+  opset_import: [ "" : 10 ],
+  domain: "ai.onnx.ml",
+  doc_string: "A function test case."
+>
+f (float[N] y, float[N] z) => (float[N] w)
+<float[N] x>
+{
+    x = Add(y, z)
+    w = Mul(x, y)
+}
+)ONNX";
+
+  FunctionProto fp;
+  Parse(fp, code);
+
+  EXPECT_EQ(fp.input_size(), 2);
+  EXPECT_EQ(fp.value_info_size(), 4);
+  ASSERT_EQ(fp.output_size(), 1);
+  EXPECT_EQ(fp.value_info(0).name(), "y");
+  EXPECT_EQ(fp.value_info(1).name(), "z");
+  EXPECT_EQ(fp.value_info(2).name(), "w");
+  EXPECT_EQ(fp.value_info(3).name(), "x");
+}
+
+TEST(ParserTest, FunctionValueInfoTest3) {
+  const char* code = R"ONNX(
+<
+  opset_import: [ "" : 10 ],
+  domain: "ai.onnx.ml",
+  doc_string: "A function test case."
+>
+f (float[N] y, z) => (float[N] w)
+<float[N] x, float[N] t>
+{
+    x = Add(y, z)
+    t = Add(x, x)
+    w = Mul(t, y)
+}
+)ONNX";
+
+  FunctionProto fp;
+  Parse(fp, code);
+
+  EXPECT_EQ(fp.input_size(), 2);
+  ASSERT_EQ(fp.value_info_size(), 4);
+  EXPECT_EQ(fp.output_size(), 1);
+  EXPECT_EQ(fp.value_info(0).name(), "y");
+  EXPECT_EQ(fp.value_info(1).name(), "w");
+  EXPECT_EQ(fp.value_info(2).name(), "x");
+  EXPECT_EQ(fp.value_info(3).name(), "t");
+}
+
 TEST(ParserTest, InitializerTest) {
   const char* code = R"ONNX(
 agraph (float y = {1.0}, float[N] z) => (float[N] w)
@@ -557,5 +637,31 @@ TEST(ParserTest, TypesModelTest2) {
   CheckModel(code);
 }
 
+TEST(ParserTest, ExternalDataTest) {
+  const char* code = R"ONNX(
+agraph (float y = {1.0}, float[N] z) => (w) <
+    float[3, 2] m1 = ["location": "weight_1.bin", "offset": "17"],
+    float[2, 1] m2 = {1.0, 2.0}
+>
+{
+    x = Add(y, z)
+    m = Mul(m1, m1)
+}
+)ONNX";
+
+  GraphProto graph;
+  Parse(graph, code);
+
+  EXPECT_EQ(graph.input_size(), 2);
+  EXPECT_EQ(graph.output_size(), 1);
+  EXPECT_EQ(graph.initializer_size(), 3); // m1, m2
+  EXPECT_EQ(graph.value_info_size(), 0); // x
+  EXPECT_EQ(graph.initializer().Get(1).data_location(), TensorProto_DataLocation::TensorProto_DataLocation_EXTERNAL);
+  EXPECT_EQ(graph.initializer().Get(1).external_data().Get(0).key(), "location");
+  EXPECT_EQ(graph.initializer().Get(1).external_data().Get(0).value(), "weight_1.bin");
+  EXPECT_EQ(graph.initializer().Get(1).external_data().Get(1).key(), "offset");
+  EXPECT_EQ(graph.initializer().Get(1).external_data().Get(1).value(), "17");
+}
+
 } // namespace Test
 } // namespace ONNX_NAMESPACE

onnx/test/function_test.py

@@ -25,8 +25,7 @@ class TestFunction(unittest.TestCase):
             )
 
     def test_extract_model_with_local_function(self) -> None:
-        r"""
-        #   1. build a model with graph below. extract models with output combinations
+        r"""#   1. build a model with graph below. extract models with output combinations
         #   2. validate extracted models' local functions
         #
         # model graph:
@@ -53,7 +52,6 @@ class TestFunction(unittest.TestCase):
         #                c
         #
         """
-
         # function common
         func_domain = "local"
         func_opset_imports = [onnx.helper.make_opsetid("", 14)]

onnx/test/helper_test.py

@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 
+import itertools
 import random
 import struct
 import unittest
@@ -11,6 +12,7 @@ from typing import Any, List, Tuple
 import numpy as np
 import parameterized
 import pytest
+import version_utils
 
 from onnx import (
     AttributeProto,
@@ -25,6 +27,7 @@ from onnx import (
     helper,
     numpy_helper,
 )
+from onnx.reference.op_run import to_array_extended
 
 
 class TestHelperAttributeFunctions(unittest.TestCase):
@@ -403,11 +406,13 @@ class TestHelperNodeFunctions(unittest.TestCase):
         test([("", 18)], 8)
         test([("", 19)], 9)
         test([("", 20)], 9)
+        test([("", 21)], 10)
         # standard opset can be referred to using empty-string or "ai.onnx"
         test([("ai.onnx", 9)], 4)
         test([("ai.onnx.ml", 2)], 6)
         test([("ai.onnx.ml", 3)], 8)
         test([("ai.onnx.ml", 4)], 9)
+        test([("ai.onnx.ml", 5)], 10)
         test([("ai.onnx.training", 1)], 7)
         # helper should pick *max* IR version required from all opsets specified.
         test([("", 10), ("ai.onnx.ml", 2)], 6)
@@ -486,10 +491,13 @@ class TestHelperTensorFunctions(unittest.TestCase):
 
     def test_make_float8e4m3fnuz_tensor(self) -> None:
         y = helper.make_tensor(
-            "zero_point", TensorProto.FLOAT8E4M3FNUZ, [5], [0, 0.5, 1, 50000, 10.1]
+            "zero_point",
+            TensorProto.FLOAT8E4M3FNUZ,
+            [7],
+            [0, 0.5, 1, 50000, 10.1, -0.00001, 0.00001],
         )
         ynp = numpy_helper.to_array(y)
-        expected = np.array([0, 0.5, 1, 240, 10], dtype=np.float32)
+        expected = np.array([0, 0.5, 1, 240, 10, 0, 0], dtype=np.float32)
         np.testing.assert_equal(expected, ynp)
 
     def test_make_float8e5m2_tensor(self) -> None:
@@ -502,10 +510,13 @@ class TestHelperTensorFunctions(unittest.TestCase):
 
     def test_make_float8e5m2fnuz_tensor(self) -> None:
         y = helper.make_tensor(
-            "zero_point", TensorProto.FLOAT8E5M2FNUZ, [5], [0, 0.5, 1, 50000, 96]
+            "zero_point",
+            TensorProto.FLOAT8E5M2FNUZ,
+            [7],
+            [0, 0.5, 1, 50000, 96, -0.0000001, 0.0000001],
         )
         ynp = numpy_helper.to_array(y)
-        expected = np.array([0, 0.5, 1, 49152, 96], dtype=np.float32)
+        expected = np.array([0, 0.5, 1, 49152, 96, 0, 0], dtype=np.float32)
         np.testing.assert_equal(expected, ynp)
 
     def test_make_bfloat16_tensor_raw(self) -> None:
@@ -626,6 +637,51 @@ class TestHelperTensorFunctions(unittest.TestCase):
         ynp = numpy_helper.to_array(y)
         np.testing.assert_equal(expected, ynp)
 
+    @parameterized.parameterized.expand(
+        itertools.product(
+            (TensorProto.UINT4, TensorProto.INT4),
+            ((5, 4, 6), (4, 6, 5), (3, 3), (1,), (2**10,)),
+        )
+    )
+    @unittest.skipIf(
+        version_utils.numpy_older_than("1.22.0"),
+        "The test requires numpy 1.22.0 or later",
+    )
+    def test_make_4bit_tensor(self, dtype, dims) -> None:
+        type_range = {
+            TensorProto.UINT4: (0, 15),
+            TensorProto.INT4: (-8, 7),
+        }
+        data = np.random.randint(
+            type_range[dtype][0], high=type_range[dtype][1] + 1, size=dims
+        )
+        y = helper.make_tensor("y", dtype, data.shape, data)
+        ynp = to_array_extended(y)
+        np.testing.assert_equal(data, ynp)
+
+    @parameterized.parameterized.expand(
+        itertools.product(
+            (TensorProto.UINT4, TensorProto.INT4), ((5, 4, 6), (4, 6, 5), (3, 3), (1,))
+        )
+    )
+    def test_make_4bit_raw_tensor(self, dtype, dims) -> None:
+        type_range = {
+            TensorProto.UINT4: (0, 15),
+            TensorProto.INT4: (-8, 7),
+        }
+        data = np.random.randint(
+            type_range[dtype][0], high=type_range[dtype][1] + 1, size=dims
+        )
+        packed_data = helper.pack_float32_to_4bit(
+            data, signed=(dtype == TensorProto.INT4)
+        )
+
+        y = helper.make_tensor(
+            "packed_int4", dtype, dims, packed_data.tobytes(), raw=True
+        )
+        ynp = numpy_helper.to_array(y)
+        np.testing.assert_equal(data, ynp)
+
     def test_make_sparse_tensor(self) -> None:
         values = [1.1, 2.2, 3.3, 4.4, 5.5]
         values_tensor = helper.make_tensor(
@@ -820,6 +876,8 @@ class TestPrintableGraph(unittest.TestCase):
             TensorProto.FLOAT8E4M3FNUZ,
             TensorProto.FLOAT8E5M2,
             TensorProto.FLOAT8E5M2FNUZ,
+            TensorProto.UINT4,
+            TensorProto.INT4,
             TensorProto.STRING,
             TensorProto.COMPLEX64,
             TensorProto.COMPLEX128,
@@ -850,6 +908,8 @@ def test_make_tensor_vals(tensor_dtype: int) -> None:
             TensorProto.FLOAT8E4M3FNUZ,
             TensorProto.FLOAT8E5M2,
             TensorProto.FLOAT8E5M2FNUZ,
+            TensorProto.UINT4,
+            TensorProto.INT4,
         }
     ],
     ids=lambda tensor_dtype: helper.tensor_dtype_to_string(tensor_dtype),