Merge branch 'PaddlePaddle:develop' into tensorrt

Author: fangfangssj

README.md

@@ -98,11 +98,11 @@ Once you have packaged these extracted computation graphs, submit them to the Gr
 <table>
 <tr>
 <td align="center">
-    <img width="200" src="https://github.com/user-attachments/assets/eef90a3e-ce83-4757-94ea-b0c0757785f0" />
+    <img width="200" src="https://github.com/user-attachments/assets/3ea4794b-1aed-4096-bd1c-3184832b98f3" />
 </td>
 <td align="center">
     <img width="150" src="https://cdn.prod.website-files.com/6257adef93867e50d84d30e2/67d00cf7266d2c75571aebde_Example.svg" />
-    <p><a href="https://discord.gg/43XQ3tf7">Channel</a> is also available.</p>
+    <p><a href="https://discord.gg/FCZQVCkC">Channel</a> is also available.</p>
 </td>
 </tr>
 </table>

graph_net/paddle/test_compiler.py

@@ -124,15 +124,23 @@ def test_single_model(args):
     compiled_duration_box = DurationBox(-1)
     with naive_timer(compiled_duration_box, synchronizer_func):
         compiled_out = compiled_model(**input_dict)
+
     if isinstance(expected_out, paddle.Tensor):
         expected_out = [expected_out]
         compiled_out = [compiled_out]
     if isinstance(expected_out, list) or isinstance(expected_out, tuple):
+        for a, b in zip(expected_out, compiled_out):
+            if (a is None and b is not None) or (a is not None and b is None):
+                raise ValueError("Both expected_out and compiled_out must be not None.")
         expected_out = [
-            regular_item(item) for item in expected_out if np.array(item).size != 0
+            regular_item(item)
+            for item in expected_out
+            if item is not None and np.array(item).size != 0
         ]
         compiled_out = [
-            regular_item(item) for item in compiled_out if np.array(item).size != 0
+            regular_item(item)
+            for item in compiled_out
+            if item is not None and np.array(item).size != 0
         ]
     else:
         raise ValueError("Illegal return value.")

graph_net/paddle/utils.py

@@ -180,9 +180,10 @@ def replay_tensor(info):
     if "data" in info and info["data"] is not None:
         return paddle.reshape(info["data"], shape).to(dtype).to(device)
     elif dtype == paddle.int32 or dtype == paddle.int64:
-        # for some ops(binary_cross_entropy), label data can only be set 0 or 1.
         return paddle.cast(
-            paddle.randint(low=0, high=2, shape=shape, dtype="int64"),
+            paddle.randint(
+                low=min_value, high=max_value + 1, shape=shape, dtype="int64"
+            ),
             dtype,
         ).to(device)
     elif dtype == paddle.bool:
@@ -192,7 +193,6 @@ def replay_tensor(info):
         ).to(device)
     else:
         std = info["info"]["std"]
-        # return paddle.randn(shape).to(dtype).to(device) * std * 1e-3 + 1e-2
         return (
             paddle.uniform(shape, dtype="float32", min=min_value, max=max_value)
             .to(dtype)

graph_net/paddle/validate.py

@@ -66,13 +66,13 @@ def main(args):
     params.update(inputs)
     state_dict = {k: utils.replay_tensor(v) for k, v in params.items()}
 
-    y = model(**state_dict)[0]
+    y = model(**state_dict)
 
-    print(np.argmin(y), np.argmax(y))
+    # print(np.argmin(y), np.argmax(y))
     if isinstance(y, paddle.Tensor):
         print(y.shape)
     elif isinstance(y, list) or isinstance(y, tuple):
-        print(y[0].shape if isinstance(y[0], paddle.tensor) else y[0])
+        print(y[0].shape if isinstance(y[0], paddle.Tensor) else y[0])
     else:
         raise ValueError("Illegal return value.")
 

graph_net/test/rp_expr_parser_test.py

@@ -0,0 +1,118 @@
+import unittest
+from graph_net.torch.rp_expr import Tokenize
+from graph_net.torch.rp_expr.rp_expr_passes import (
+    FlattenTokenListPass,
+    FoldTokensPass,
+    RecursiveFoldTokensPass,
+    FoldIfTokenIdGreatEqualPass,
+)
+from graph_net.torch.rp_expr.nested_range import Range, Tree
+from graph_net.torch.rp_expr.rp_expr_parser import RpExprParser
+from graph_net.torch.rp_expr.rp_expr_util import (
+    MakeNestedIndexRangeFromLetsListTokenRpExpr,
+)
+
+
+class TestTokenize(unittest.TestCase):
+    """Tests tokenization of primitive ID lists into symbolic token sequences."""
+
+    def test_simple(self):
+        primitive_id_lists = [list(range(10 + i)) for i in range(5)]
+        token_list, id_allocator, _ = Tokenize(primitive_id_lists)
+        self.assertEqual(len(token_list.tensors), len(primitive_id_lists))
+
+
+class TestFlattenTokenListPass(unittest.TestCase):
+    """Tests flattening of nested token structures into linear sequences."""
+
+    def test_simple(self):
+        base = 10
+        size = 5
+        primitive_id_lists = [list(range(base + i)) for i in range(size)]
+        token_list, id_allocator, _ = Tokenize(primitive_id_lists)
+        rp_expr_pass = FlattenTokenListPass(id_allocator)
+        success, flattened_rp_expr_pass = rp_expr_pass(token_list)
+        self.assertTrue(success)
+        self.assertEqual(id_allocator.NextTokenId(), base + 2 * size - 1)
+
+
+class TestFoldTokensPass(unittest.TestCase):
+    """Tests folding of the most frequent contiguous token pattern into a single symbol."""
+
+    def test_simple(self):
+        base = 3
+        size = 3
+        primitive_id_lists = [list(range(base + i)) for i in range(size)]
+        token_list, id_allocator, _ = Tokenize(primitive_id_lists)
+        flatten_pass = FlattenTokenListPass(id_allocator)
+        _, flattened_rp_expr = flatten_pass(token_list)
+        fold_pass = FoldTokensPass(id_allocator)
+        success, fold_rp_expr = fold_pass(flattened_rp_expr.flattened_tensor)
+        self.assertTrue(success)
+        input = flattened_rp_expr.flattened_tensor.tensor.numpy().tolist()
+        pattern = fold_rp_expr.symbol_token_tensors[0].numpy().tolist()
+        replacement = fold_rp_expr.symbol_token_ids[0]
+        output = fold_rp_expr.body_rp_expr.tensor.numpy().tolist()
+        self.assertEqual(input, [3, 4, 5, 1, 3, 4, 5, 6, 2, 3, 4, 5, 6, 7])
+        self.assertEqual(pattern, [3, 4, 5])
+        self.assertEqual(replacement, 8)
+        self.assertEqual(output, [8, 1, 8, 6, 2, 8, 6, 7])
+
+
+class TestRecursiveFoldTokensPass(unittest.TestCase):
+    """Tests recursive folding of repeated patterns at multiple levels of nesting."""
+
+    def test_simple(self):
+        base = 3
+        size = 3
+        primitive_id_lists = [list(range(base + i)) for i in range(size)]
+        token_list, id_allocator, _ = Tokenize(primitive_id_lists)
+        flatten_pass = FlattenTokenListPass(id_allocator)
+        _, flattened_rp_expr = flatten_pass(token_list)
+        fold_pass = RecursiveFoldTokensPass(id_allocator)
+        success, fold_rp_expr = fold_pass(flattened_rp_expr.flattened_tensor)
+        self.assertTrue(success)
+        input = flattened_rp_expr.flattened_tensor.tensor.numpy().tolist()
+        pattern = [x.numpy().tolist() for x in fold_rp_expr.symbol_token_tensors]
+        replacement = fold_rp_expr.symbol_token_ids
+        output = fold_rp_expr.body_rp_expr.tensor.numpy().tolist()
+        self.assertEqual(input, [3, 4, 5, 1, 3, 4, 5, 6, 2, 3, 4, 5, 6, 7])
+        self.assertEqual(pattern, [[3, 4, 5], [8, 6]])
+        self.assertEqual(replacement, [8, 9])
+        self.assertEqual(output, [8, 1, 9, 2, 9, 7])
+
+
+class TestFoldIfTokenIdGreatEqualPass(unittest.TestCase):
+    """Tests conditional folding only for tokens with ID greater than or equal to a threshold."""
+
+    def test_simple(self):
+        base = 3
+        size = 3
+        primitive_id_lists = [list(range(base + i)) for i in range(size)]
+        token_list, id_allocator, _ = Tokenize(primitive_id_lists)
+        flatten_pass = FlattenTokenListPass(id_allocator)
+        _, flattened_rp_expr = flatten_pass(token_list)
+        fold_pass = RecursiveFoldTokensPass(id_allocator)
+        success, fold_rp_expr = fold_pass(flattened_rp_expr.flattened_tensor)
+        self.assertTrue(success)
+        threshold_fold_pass = FoldIfTokenIdGreatEqualPass(
+            id_allocator=id_allocator,
+            threshold_start_token_id=len(primitive_id_lists),
+        )
+        success, threshold_fold_rp_expr = threshold_fold_pass(fold_rp_expr.body_rp_expr)
+        self.assertTrue(success)
+        input = fold_rp_expr.body_rp_expr.tensor.numpy().tolist()
+        pattern = [
+            x.numpy().tolist() for x in threshold_fold_rp_expr.symbol_token_tensors
+        ]
+        replacement = threshold_fold_rp_expr.symbol_token_ids
+        self.assertEqual(len(threshold_fold_rp_expr.body_rp_expr), 3)
+        output = [x.numpy().tolist() for x in threshold_fold_rp_expr.body_rp_expr]
+        self.assertEqual(input, [8, 1, 9, 2, 9, 7])
+        self.assertEqual(pattern, [[9, 7]])
+        self.assertEqual(replacement, [10])
+        self.assertEqual(output, [[8], [9], [10]])
+
+
+if __name__ == "__main__":
+    unittest.main()

graph_net/torch/rp_expr/__init__.py

@@ -0,0 +1,22 @@
+from .rp_expr import Tokenize
+from .rp_expr_parser import RpExprParser
+from .nested_range import Range, Tree
+from .rp_expr_util import MakeNestedIndexRangeFromLetsListTokenRpExpr
+from .rp_expr_passes import (
+    FlattenTokenListPass,
+    FoldTokensPass,
+    RecursiveFoldTokensPass,
+    FoldIfTokenIdGreatEqualPass,
+)
+
+__all__ = [
+    "Tokenize",
+    "RpExprParser",
+    "Range",
+    "Tree",
+    "MakeNestedIndexRangeFromLetsListTokenRpExpr",
+    "FlattenTokenListPass",
+    "FoldTokensPass",
+    "RecursiveFoldTokensPass",
+    "FoldIfTokenIdGreatEqualPass",
+]