Merge branch 'develop' of github.com:PaddlePaddle/GraphNet into develop

Author: lixinqi

graph_net/model_path_handler.py

@@ -1,4 +1,5 @@
 import argparse
+import traceback
 from graph_net.imp_util import load_module
 import logging
 import sys
@@ -52,6 +53,9 @@ def handle_model_path_list_in_current_process(handler, args):
         except KeyboardInterrupt:
             print("KeyboardInterrupt")
             return
+        except Exception:
+            print("------------[model_path_handler failed]------------", flush=True)
+            traceback.print_exc()
 
 
 def handle_model_path_list_in_subprocess(args):

graph_net/test/dev_model_list/validation_error_model_list.txt

@@ -0,0 +1,12 @@
+samples/torchgeometric/RECT_L
+samples/transformers-auto-model/bge-small-en-v1.5
+samples/transformers-auto-model/distilbert_distilbert-base-multilingual-cased
+samples/transformers-auto-model/OFA-Sys_chinese-clip-vit-large-patch14
+samples/transformers-auto-model/opus-mt-ase-es
+samples/transformers-auto-model/opus-mt-en-gv
+samples/transformers-auto-model/opus-mt-en-phi
+samples/transformers-auto-model/opus-mt-en-sal
+samples/transformers-auto-model/opus-mt-en-tw
+samples/transformers-auto-model/opus-mt-fi-niu
+samples/transformers-auto-model/opus-mt-tc-bible-big-deu_eng_fra_por_spa-bat
+samples/transformers-auto-model/opus-mt-tc-bible-big-gmw-deu_eng_fra_por_spa

graph_net/test/naive_decomposer_and_post_extract_process_test.sh

@@ -1,5 +1,4 @@
 #!/bin/bash
-# bash graph_net/test/naive_decomposer_and_post_extract_process_test.sh
 
 GRAPH_NET_ROOT=$(python3 -c "import graph_net; import os; print(
 os.path.dirname(graph_net.__file__))")

graph_net/test/typical_sequence_decomposer_test.sh

@@ -2,13 +2,35 @@
 
 GRAPH_NET_ROOT=$(python3 -c "import graph_net; import os; print(os.path.dirname(os.path.dirname(graph_net.__file__)))")
 DECOMPOSE_PATH=/tmp/decompose_workspace
+# DECOMPOSE_PATH=$GRAPH_NET_ROOT/decompose_test_level5_100
 
 mkdir -p "$DECOMPOSE_PATH"
 
-model_list="$GRAPH_NET_ROOT/graph_net/config/small100_torch_samples_list.txt"
+# model_list="$GRAPH_NET_ROOT/graph_net/config/small100_torch_samples_list.txt"
+model_list="$GRAPH_NET_ROOT/graph_net/test/dev_model_list/validation_error_model_list.txt"
+
+op_names_extractor_config_json_str=$(cat <<EOF
+{
+    "handler_path": "$GRAPH_NET_ROOT/graph_net/torch/typical_sequence_split_points.py",
+    "handler_class_name": "OpNamesExtractor",
+    "handler_config": {
+        "resume": true,
+        "model_path_prefix": "$GRAPH_NET_ROOT",
+        "output_dir": "$DECOMPOSE_PATH"
+    }
+}
+EOF
+)
+OP_NAMES_EXTRACTOR_CONFIG=$(echo $op_names_extractor_config_json_str | base64 -w 0)
+
+python3 -m graph_net.model_path_handler \
+    --model-path-list $model_list \
+    --handler-config=$OP_NAMES_EXTRACTOR_CONFIG \
 
 python3 -m graph_net.torch.typical_sequence_split_points \
+    --enable-resume \
     --model-list "$model_list" \
+    --op-names-path-prefix "$DECOMPOSE_PATH" \
     --device "cuda" \
     --window-size 10 \
     --fold-policy default \
@@ -20,6 +42,7 @@ decompose_config_json_str=$(cat <<EOF
     "handler_path": "$GRAPH_NET_ROOT/graph_net/torch/graph_decomposer.py",
     "handler_class_name": "RangeDecomposerExtractor",
     "handler_config": {
+        "resume": true,
         "model_path_prefix": "$GRAPH_NET_ROOT",
         "output_dir": "$DECOMPOSE_PATH",
         "split_results_path": "$DECOMPOSE_PATH/split_results.json",
@@ -34,10 +57,10 @@ DECOMPOSE_CONFIG=$(echo $decompose_config_json_str | base64 -w 0)
 python3 -m graph_net.model_path_handler \
     --model-path-list $model_list \
     --handler-config=$DECOMPOSE_CONFIG \
-    --use-subprocess
 
 test_compiler_config_json_str=$(cat <<EOF
 {
+    "model_path_prefix": "$GRAPH_NET_ROOT",
     "decomposed_root": "$DECOMPOSE_PATH"
 }
 EOF
@@ -50,8 +73,8 @@ python3 -m graph_net.torch.test_compiler \
     --device cuda \
     --config $TEST_COMPILER_CONFIG \
     --model-path-prefix $GRAPH_NET_ROOT \
-    > "$DECOMPOSE_PATH/validation.log" 2>&1
+    2>&1 | tee "$DECOMPOSE_PATH/validation.log"
 
 python3 -m graph_net.plot_ESt \
     --benchmark-path "$DECOMPOSE_PATH/validation.log" \
-    --output-dir "$DECOMPOSE_PATH"
+    --output-dir "$DECOMPOSE_PATH"

graph_net/torch/backend/range_decomposer_validator_backend.py

@@ -1,27 +1,41 @@
 import torch
+import inspect
 import torch.nn as nn
 import os
 import importlib.util
 from typing import List
 
 
 class ComposedModel(nn.Module):
-    def __init__(self, subgraph: List[nn.Module]):
+    def __init__(self, subgraphs: List[nn.Module]):
         super().__init__()
-        self.subgraphs = nn.ModuleList(subgraph)
+        self.subgraphs = nn.ModuleList(subgraphs)
 
     def forward(self, **kwargs):
         output = None
         for i, subgraph in enumerate(self.subgraphs):
-            print(f"{i=} subgraph begin")
             if output is None:
-                output = subgraph(**kwargs)
+                output = subgraph(**self._convert_inputs(subgraph, kwargs))
             else:
                 output = subgraph(*output)
-            print(f"{i=} subgraph end")
 
         return output
 
+    def _convert_inputs(self, subgraph, input_kwargs):
+        input_keywords = set(name for name, _ in input_kwargs.items())
+        sub_graph_arg_names = set(inspect.signature(subgraph.forward).parameters)
+        assert (
+            len(sub_graph_arg_names - input_keywords) == 0
+        ), f"{(sub_graph_arg_names - input_keywords)=}"
+        for remainder in input_keywords - sub_graph_arg_names:
+            assert remainder.startswith("s")
+            assert remainder[1:].isdigit()
+        return {
+            name: value
+            for name, value in input_kwargs.items()
+            if name in sub_graph_arg_names
+        }
+
 
 class RangeDecomposerValidatorBackend:
     def _load_model_instance(self, path: str, device: str) -> torch.nn.Module:
@@ -36,40 +50,56 @@ def _load_model_instance(self, path: str, device: str) -> torch.nn.Module:
         instance = ModelClass().to(device)
         return instance
 
-    def _make_config(self, decomposed_root, decomposed_model_name_suffix="_decomposed"):
+    def _make_config(
+        self,
+        model_path_prefix: str,
+        decomposed_root: str,
+        decomposed_dentry: str = "_decomposed",
+    ):
         return {
+            "model_path_prefix": model_path_prefix,
             "decomposed_root": decomposed_root,
-            "decomposed_model_name_suffix": decomposed_model_name_suffix,
+            "decomposed_dentry": decomposed_dentry,
         }
 
+    def _get_rel_model_path(self, model_path) -> str:
+        model_path = os.path.realpath(model_path)
+        model_path_prefix = os.path.realpath(self.config["model_path_prefix"])
+        assert model_path.startswith(model_path_prefix)
+        rel_model_path = model_path[len(model_path_prefix) :]
+        if rel_model_path.startswith("/"):
+            rel_model_path = rel_model_path[1:]
+        assert not rel_model_path.startswith("/")
+        return rel_model_path
+
+    def _get_model_name_order(self, name):
+        lst = name.split("_")
+        if not (len(lst) > 0):
+            return -1
+        if not (lst[-1].isdigit()):
+            return -1
+        return int(lst[-1])
+
     def __call__(self, model: torch.nn.Module) -> torch.nn.Module:
         config = self._make_config(**self.config)
-        model_file_path = model.__class__.__graph_net_file_path__
-        model_dir = os.path.dirname(model_file_path)
-        model_name = os.path.basename(model_dir)
+        model_path = os.path.dirname(model.__class__.__graph_net_file_path__)
+        rel_model_path = self._get_rel_model_path(model_path)
         decomposed_parent_dir = os.path.join(
-            config["decomposed_root"], f"{model_name}_decomposed"
+            config["decomposed_root"], rel_model_path, config["decomposed_dentry"]
         )
         subgraph_paths = []
-        for name in sorted(os.listdir(decomposed_parent_dir)):
+        dentries = os.listdir(decomposed_parent_dir)
+        for name in sorted(dentries, key=self._get_model_name_order):
             full_path = os.path.join(decomposed_parent_dir, name)
-            if os.path.isdir(full_path) and name[-1].isdigit():
+            if os.path.isdir(full_path) and self._get_model_name_order(name) >= 0:
                 subgraph_paths.append(full_path)
 
-        print(
-            f"[RangeDecomposerValidatorBackend] Found subgraphs: {[os.path.basename(p) for p in subgraph_paths]}"
-        )
-
         device = model.__class__.__graph_net_device__
         subgraph_instances = []
 
         for path in subgraph_paths:
             instance = self._load_model_instance(path, device)
             subgraph_instances.append(instance)
-            dir_name = os.path.basename(path)
-            print(
-                f"[RangeDecomposerValidatorBackend] Loaded and instantiated '{dir_name}'"
-            )
 
         composed_model = ComposedModel(subgraph_instances)
         return composed_model.eval()

graph_net/torch/fx_graph_parse_util.py

@@ -113,7 +113,8 @@ def _get_name_pattern2replacement(names_from_signature, names_from_placeholder):
 
 
 def _rename_placeholder(name, pattern2replacement):
-    assert name[:2] == "L_" or name[:2] == "l_", f"{name=}"
+    if not (name[:2] == "L_" or name[:2] == "l_"):
+        return name
     name = name[2:]
     if name[0] == "l":
         name = "L" + name[1:]
@@ -122,19 +123,28 @@ def _rename_placeholder(name, pattern2replacement):
     return name
 
 
-def parse_sole_graph_module(module, inputs):
+def parse_sole_graph_module_without_varify(module, inputs):
     traced_module = None
     traced_sample_inputs = None
 
     def my_backend(gm, sample_inputs):
         nonlocal traced_module
-        traced_module = gm
         nonlocal traced_sample_inputs
+        assert traced_module is None
+        assert traced_sample_inputs is None
+        traced_module = gm
         traced_sample_inputs = sample_inputs
         return gm.forward
 
     torch.compile(module, backend=my_backend)(*inputs)
     assert traced_module is not None
+    return traced_module, traced_sample_inputs
+
+
+def parse_sole_graph_module(module, inputs):
+    traced_module, traced_sample_inputs = parse_sole_graph_module_without_varify(
+        module, inputs
+    )
 
     def get_input_names_from_signature():
         return inspect.signature(module.forward).parameters