Use LSB-first nibble order in ConvertPrecision for u4/i4 types

evkotov · evkotov · commit 787f8bc0e1d2 · 2025-10-22T17:33:32.000+02:00
diff --git a/src/common/transformations/src/transformations/convert_precision.cpp b/src/common/transformations/src/transformations/convert_precision.cpp
@@ -14,6 +14,7 @@
 #include "openvino/pass/constant_folding.hpp"
 #include "openvino/pass/manager.hpp"
 #include "openvino/reference/convert.hpp"
+#include "openvino/core/type/element_iterator.hpp"
 #include "ov_ops/rms.hpp"
 #include "ov_ops/type_relaxed.hpp"
 #include "transformations/fp16_compression/align_mixed_fp32_fp16_types.hpp"
@@ -1290,7 +1291,7 @@ std::shared_ptr<Node> convert_low_precisions_int(std::shared_ptr<ov::op::v0::Con
     const auto size = shape_size(constant->get_shape());
     size_t src_idx(0), dst_idx(0), dst_off(0), src_off(0);
     if (src_type.bitwidth() < 8) {
-        src_off = 8 - src_type.bitwidth();
+        src_off = element::is_lsb_packed(src_type) ? 0 : (8 - src_type.bitwidth());
     }
 
     if (to.bitwidth() < 8) {
@@ -1342,11 +1343,21 @@ std::shared_ptr<Node> convert_low_precisions_int(std::shared_ptr<ov::op::v0::Con
         }
         // Calculate offsets and indexes
         if (src_type.bitwidth() < 8) {
-            if (src_off == 0) {
-                src_off = 8;
-                src_idx++;
+            if (element::is_lsb_packed(src_type)) {
+                // LSB-first: offset goes up 0 → 4 → next byte
+                src_off += src_type.bitwidth();
+                if (src_off >= 8) {
+                    src_off = 0;
+                    src_idx++;
+                }
+            } else {
+                // MSB-first: offset goes down 4 → 0 → next byte
+                if (src_off == 0) {
+                    src_off = 8;
+                    src_idx++;
+                }
+                src_off -= src_type.bitwidth();
             }
-            src_off -= src_type.bitwidth();
         } else {
             src_idx++;
         }
diff --git a/src/common/transformations/tests/utils/convert_precision.cpp b/src/common/transformations/tests/utils/convert_precision.cpp
@@ -1598,110 +1598,110 @@ TEST(TransformationTests, ConvertPrecision_ConstantConversion_BoolToU8) {
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToI8) {
-    constant_convert_test<uint8_t, int8_t>(element::u4, element::i8, std::vector<uint8_t>{171}, {10, 11});
+    constant_convert_test<uint8_t, int8_t>(element::u4, element::i8, std::vector<uint8_t>{171}, {11, 10});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToU8) {
-    constant_convert_test<uint8_t, uint8_t>(element::u4, element::u8, {171}, {10, 11});
+    constant_convert_test<uint8_t, uint8_t>(element::u4, element::u8, {171}, {11, 10});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToI8_2) {
-    constant_convert_test<uint8_t, int8_t>(element::u4, element::i8, {96}, {6, 0});
+    constant_convert_test<uint8_t, int8_t>(element::u4, element::i8, {96}, {0, 6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToU8_96) {
-    constant_convert_test<uint8_t, uint8_t>(element::u4, element::u8, {96}, {6, 0});
+    constant_convert_test<uint8_t, uint8_t>(element::u4, element::u8, {96}, {0, 6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU8) {
-    constant_convert_test<uint8_t, uint8_t>(element::i4, element::u8, {96}, {6, 0});
+    constant_convert_test<uint8_t, uint8_t>(element::i4, element::u8, {96}, {0, 6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI8) {
-    constant_convert_test<uint8_t, int8_t>(element::i4, element::i8, {96}, {6, 0});
+    constant_convert_test<uint8_t, int8_t>(element::i4, element::i8, {96}, {0, 6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU8_neg) {
-    constant_convert_test<uint8_t, uint8_t>(element::i4, element::u8, {171}, {250, 251});
+    constant_convert_test<uint8_t, uint8_t>(element::i4, element::u8, {171}, {251, 250});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI8_neg) {
-    constant_convert_test<uint8_t, int8_t>(element::i4, element::i8, {171}, {-6, -5});
+    constant_convert_test<uint8_t, int8_t>(element::i4, element::i8, {171}, {-5, -6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToI32) {
-    constant_convert_test<uint8_t, int32_t>(element::u4, element::i32, {171}, {10, 11});
+    constant_convert_test<uint8_t, int32_t>(element::u4, element::i32, {171}, {11, 10});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToU32) {
-    constant_convert_test<uint8_t, uint32_t>(element::u4, element::u32, {171}, {10, 11});
+    constant_convert_test<uint8_t, uint32_t>(element::u4, element::u32, {171}, {11, 10});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU32) {
-    constant_convert_test<uint8_t, uint32_t>(element::i4, element::u32, {96}, {6, 0});
+    constant_convert_test<uint8_t, uint32_t>(element::i4, element::u32, {96}, {0, 6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI32) {
-    constant_convert_test<uint8_t, int32_t>(element::i4, element::i32, {96}, {6, 0});
+    constant_convert_test<uint8_t, int32_t>(element::i4, element::i32, {96}, {0, 6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU32_neg) {
-    constant_convert_test<uint8_t, uint32_t>(element::i4, element::u32, {171}, {4294967290, 4294967291});
+    constant_convert_test<uint8_t, uint32_t>(element::i4, element::u32, {171}, {4294967291, 4294967290});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI32_neg) {
-    constant_convert_test<uint8_t, int32_t>(element::i4, element::i32, {171}, {-6, -5});
+    constant_convert_test<uint8_t, int32_t>(element::i4, element::i32, {171}, {-5, -6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToI16) {
-    constant_convert_test<uint8_t, int16_t>(element::u4, element::i16, {171}, {10, 11});
+    constant_convert_test<uint8_t, int16_t>(element::u4, element::i16, {171}, {11, 10});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToU16) {
-    constant_convert_test<uint8_t, uint16_t>(element::u4, element::u16, {171}, {10, 11});
+    constant_convert_test<uint8_t, uint16_t>(element::u4, element::u16, {171}, {11, 10});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU16) {
-    constant_convert_test<uint8_t, uint16_t>(element::i4, element::u16, {96}, {6, 0});
+    constant_convert_test<uint8_t, uint16_t>(element::i4, element::u16, {96}, {0, 6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI16) {
-    constant_convert_test<uint8_t, int16_t>(element::i4, element::i16, {96}, {6, 0});
+    constant_convert_test<uint8_t, int16_t>(element::i4, element::i16, {96}, {0, 6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU16_neg) {
-    constant_convert_test<uint8_t, uint16_t>(element::i4, element::u16, {171}, {65530, 65531});
+    constant_convert_test<uint8_t, uint16_t>(element::i4, element::u16, {171}, {65531, 65530});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI16_neg) {
-    constant_convert_test<uint8_t, int16_t>(element::i4, element::i16, {171}, {-6, -5});
+    constant_convert_test<uint8_t, int16_t>(element::i4, element::i16, {171}, {-5, -6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToI64) {
-    constant_convert_test<uint8_t, int64_t>(element::u4, element::i64, {171}, {10, 11});
+    constant_convert_test<uint8_t, int64_t>(element::u4, element::i64, {171}, {11, 10});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToU64) {
-    constant_convert_test<uint8_t, int64_t>(element::u4, element::u64, {171}, {10, 11});
+    constant_convert_test<uint8_t, int64_t>(element::u4, element::u64, {171}, {11, 10});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU64) {
-    constant_convert_test<uint8_t, uint64_t>(element::i4, element::u64, {96}, {6, 0});
+    constant_convert_test<uint8_t, uint64_t>(element::i4, element::u64, {96}, {0, 6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI64) {
-    constant_convert_test<uint8_t, int64_t>(element::i4, element::i64, {96}, {6, 0});
+    constant_convert_test<uint8_t, int64_t>(element::i4, element::i64, {96}, {0, 6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU64_neg) {
     constant_convert_test<uint8_t, uint64_t>(element::i4,
                                              element::u64,
                                              {171},
-                                             {18446744073709551610u, 18446744073709551611u});
+                                             {18446744073709551611u, 18446744073709551610u});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI64_neg) {
-    constant_convert_test<uint8_t, int64_t>(element::i4, element::i64, {171}, {-6, -5});
+    constant_convert_test<uint8_t, int64_t>(element::i4, element::i64, {171}, {-5, -6});
 }
 
 TEST(TransformationTests, ConvertPrecision_ConstantConversion_U1ToU8) {

Original file line number	Diff line number	Diff line change
`@@ -1598,110 +1598,110 @@ TEST(TransformationTests, ConvertPrecision_ConstantConversion_BoolToU8) {`
`1598`	`1598`	`}`
`1599`	`1599`
`1600`	`1600`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToI8) {`
`1601`		`- constant_convert_test<uint8_t, int8_t>(element::u4, element::i8, std::vector<uint8_t>{171}, {10, 11});`
	`1601`	`+ constant_convert_test<uint8_t, int8_t>(element::u4, element::i8, std::vector<uint8_t>{171}, {11, 10});`
`1602`	`1602`	`}`
`1603`	`1603`
`1604`	`1604`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToU8) {`
`1605`		`- constant_convert_test<uint8_t, uint8_t>(element::u4, element::u8, {171}, {10, 11});`
	`1605`	`+ constant_convert_test<uint8_t, uint8_t>(element::u4, element::u8, {171}, {11, 10});`
`1606`	`1606`	`}`
`1607`	`1607`
`1608`	`1608`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToI8_2) {`
`1609`		`- constant_convert_test<uint8_t, int8_t>(element::u4, element::i8, {96}, {6, 0});`
	`1609`	`+ constant_convert_test<uint8_t, int8_t>(element::u4, element::i8, {96}, {0, 6});`
`1610`	`1610`	`}`
`1611`	`1611`
`1612`	`1612`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToU8_96) {`
`1613`		`- constant_convert_test<uint8_t, uint8_t>(element::u4, element::u8, {96}, {6, 0});`
	`1613`	`+ constant_convert_test<uint8_t, uint8_t>(element::u4, element::u8, {96}, {0, 6});`
`1614`	`1614`	`}`
`1615`	`1615`
`1616`	`1616`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU8) {`
`1617`		`- constant_convert_test<uint8_t, uint8_t>(element::i4, element::u8, {96}, {6, 0});`
	`1617`	`+ constant_convert_test<uint8_t, uint8_t>(element::i4, element::u8, {96}, {0, 6});`
`1618`	`1618`	`}`
`1619`	`1619`
`1620`	`1620`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI8) {`
`1621`		`- constant_convert_test<uint8_t, int8_t>(element::i4, element::i8, {96}, {6, 0});`
	`1621`	`+ constant_convert_test<uint8_t, int8_t>(element::i4, element::i8, {96}, {0, 6});`
`1622`	`1622`	`}`
`1623`	`1623`
`1624`	`1624`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU8_neg) {`
`1625`		`- constant_convert_test<uint8_t, uint8_t>(element::i4, element::u8, {171}, {250, 251});`
	`1625`	`+ constant_convert_test<uint8_t, uint8_t>(element::i4, element::u8, {171}, {251, 250});`
`1626`	`1626`	`}`
`1627`	`1627`
`1628`	`1628`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI8_neg) {`
`1629`		`- constant_convert_test<uint8_t, int8_t>(element::i4, element::i8, {171}, {-6, -5});`
	`1629`	`+ constant_convert_test<uint8_t, int8_t>(element::i4, element::i8, {171}, {-5, -6});`
`1630`	`1630`	`}`
`1631`	`1631`
`1632`	`1632`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToI32) {`
`1633`		`- constant_convert_test<uint8_t, int32_t>(element::u4, element::i32, {171}, {10, 11});`
	`1633`	`+ constant_convert_test<uint8_t, int32_t>(element::u4, element::i32, {171}, {11, 10});`
`1634`	`1634`	`}`
`1635`	`1635`
`1636`	`1636`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToU32) {`
`1637`		`- constant_convert_test<uint8_t, uint32_t>(element::u4, element::u32, {171}, {10, 11});`
	`1637`	`+ constant_convert_test<uint8_t, uint32_t>(element::u4, element::u32, {171}, {11, 10});`
`1638`	`1638`	`}`
`1639`	`1639`
`1640`	`1640`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU32) {`
`1641`		`- constant_convert_test<uint8_t, uint32_t>(element::i4, element::u32, {96}, {6, 0});`
	`1641`	`+ constant_convert_test<uint8_t, uint32_t>(element::i4, element::u32, {96}, {0, 6});`
`1642`	`1642`	`}`
`1643`	`1643`
`1644`	`1644`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI32) {`
`1645`		`- constant_convert_test<uint8_t, int32_t>(element::i4, element::i32, {96}, {6, 0});`
	`1645`	`+ constant_convert_test<uint8_t, int32_t>(element::i4, element::i32, {96}, {0, 6});`
`1646`	`1646`	`}`
`1647`	`1647`
`1648`	`1648`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU32_neg) {`
`1649`		`- constant_convert_test<uint8_t, uint32_t>(element::i4, element::u32, {171}, {4294967290, 4294967291});`
	`1649`	`+ constant_convert_test<uint8_t, uint32_t>(element::i4, element::u32, {171}, {4294967291, 4294967290});`
`1650`	`1650`	`}`
`1651`	`1651`
`1652`	`1652`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI32_neg) {`
`1653`		`- constant_convert_test<uint8_t, int32_t>(element::i4, element::i32, {171}, {-6, -5});`
	`1653`	`+ constant_convert_test<uint8_t, int32_t>(element::i4, element::i32, {171}, {-5, -6});`
`1654`	`1654`	`}`
`1655`	`1655`
`1656`	`1656`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToI16) {`
`1657`		`- constant_convert_test<uint8_t, int16_t>(element::u4, element::i16, {171}, {10, 11});`
	`1657`	`+ constant_convert_test<uint8_t, int16_t>(element::u4, element::i16, {171}, {11, 10});`
`1658`	`1658`	`}`
`1659`	`1659`
`1660`	`1660`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToU16) {`
`1661`		`- constant_convert_test<uint8_t, uint16_t>(element::u4, element::u16, {171}, {10, 11});`
	`1661`	`+ constant_convert_test<uint8_t, uint16_t>(element::u4, element::u16, {171}, {11, 10});`
`1662`	`1662`	`}`
`1663`	`1663`
`1664`	`1664`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU16) {`
`1665`		`- constant_convert_test<uint8_t, uint16_t>(element::i4, element::u16, {96}, {6, 0});`
	`1665`	`+ constant_convert_test<uint8_t, uint16_t>(element::i4, element::u16, {96}, {0, 6});`
`1666`	`1666`	`}`
`1667`	`1667`
`1668`	`1668`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI16) {`
`1669`		`- constant_convert_test<uint8_t, int16_t>(element::i4, element::i16, {96}, {6, 0});`
	`1669`	`+ constant_convert_test<uint8_t, int16_t>(element::i4, element::i16, {96}, {0, 6});`
`1670`	`1670`	`}`
`1671`	`1671`
`1672`	`1672`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU16_neg) {`
`1673`		`- constant_convert_test<uint8_t, uint16_t>(element::i4, element::u16, {171}, {65530, 65531});`
	`1673`	`+ constant_convert_test<uint8_t, uint16_t>(element::i4, element::u16, {171}, {65531, 65530});`
`1674`	`1674`	`}`
`1675`	`1675`
`1676`	`1676`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI16_neg) {`
`1677`		`- constant_convert_test<uint8_t, int16_t>(element::i4, element::i16, {171}, {-6, -5});`
	`1677`	`+ constant_convert_test<uint8_t, int16_t>(element::i4, element::i16, {171}, {-5, -6});`
`1678`	`1678`	`}`
`1679`	`1679`
`1680`	`1680`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToI64) {`
`1681`		`- constant_convert_test<uint8_t, int64_t>(element::u4, element::i64, {171}, {10, 11});`
	`1681`	`+ constant_convert_test<uint8_t, int64_t>(element::u4, element::i64, {171}, {11, 10});`
`1682`	`1682`	`}`
`1683`	`1683`
`1684`	`1684`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_U4ToU64) {`
`1685`		`- constant_convert_test<uint8_t, int64_t>(element::u4, element::u64, {171}, {10, 11});`
	`1685`	`+ constant_convert_test<uint8_t, int64_t>(element::u4, element::u64, {171}, {11, 10});`
`1686`	`1686`	`}`
`1687`	`1687`
`1688`	`1688`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU64) {`
`1689`		`- constant_convert_test<uint8_t, uint64_t>(element::i4, element::u64, {96}, {6, 0});`
	`1689`	`+ constant_convert_test<uint8_t, uint64_t>(element::i4, element::u64, {96}, {0, 6});`
`1690`	`1690`	`}`
`1691`	`1691`
`1692`	`1692`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI64) {`
`1693`		`- constant_convert_test<uint8_t, int64_t>(element::i4, element::i64, {96}, {6, 0});`
	`1693`	`+ constant_convert_test<uint8_t, int64_t>(element::i4, element::i64, {96}, {0, 6});`
`1694`	`1694`	`}`
`1695`	`1695`
`1696`	`1696`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToU64_neg) {`
`1697`	`1697`	`constant_convert_test<uint8_t, uint64_t>(element::i4,`
`1698`	`1698`	`element::u64,`
`1699`	`1699`	`{171},`
`1700`		`- {18446744073709551610u, 18446744073709551611u});`
	`1700`	`+ {18446744073709551611u, 18446744073709551610u});`
`1701`	`1701`	`}`
`1702`	`1702`
`1703`	`1703`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_I4ToI64_neg) {`
`1704`		`- constant_convert_test<uint8_t, int64_t>(element::i4, element::i64, {171}, {-6, -5});`
	`1704`	`+ constant_convert_test<uint8_t, int64_t>(element::i4, element::i64, {171}, {-5, -6});`
`1705`	`1705`	`}`
`1706`	`1706`
`1707`	`1707`	`TEST(TransformationTests, ConvertPrecision_ConstantConversion_U1ToU8) {`