Merge branch 'develop' into Hackathon_9th_No_125

Author: lixinqi

graph_net/log2json.py

@@ -53,6 +53,9 @@ def parse_logs_to_json(log_file: str, output_dir: str):
                     "datatype": {},
                     "speedup": {},
                 },
+                "result": {
+                    "status": "unknown",
+                },
             }
             continue
 
@@ -102,16 +105,20 @@ def parse_logs_to_json(log_file: str, output_dir: str):
         result_status_match = patterns["result_status"].search(line)
         if result_status_match:
             status = result_status_match.group(1).strip()
+            data["result"]["status"] = status
             if status == "failed" and (i + 1) < len(lines):
                 error_reason_match = patterns["failure"].search(lines[i + 1])
                 if error_reason_match:
                     reason = error_reason_match.group(1).lower()
                     if "eager" in reason:
                         data["performance"]["failure"] = "eager"
+                        data["result"]["status"] = "eager_fail"
                     elif "compiled" in reason:
                         data["performance"]["failure"] = "compiled"
+                        data["result"]["status"] = "compile_fail"
                     else:
                         data["performance"]["failure"] = "other"
+                        data["result"]["status"] = "runtime_fail"
             continue
 
         speedup_match = patterns["speedup"].search(line)
@@ -141,6 +148,20 @@ def parse_logs_to_json(log_file: str, output_dir: str):
             # filename = f"{model_name}_{subgraph_name}_{compiler_name}.json"
             filepath = os.path.join(output_dir, filename)
 
+            # Build result field with status and speedup
+            if data["result"]["status"] == "success":
+                speedup_data = {}
+                if "e2e" in data["performance"]["speedup"]:
+                    speedup_data["e2e"] = {
+                        "mean": data["performance"]["speedup"]["e2e"]
+                    }
+                if "gpu" in data["performance"]["speedup"]:
+                    speedup_data["gpu"] = {
+                        "mean": data["performance"]["speedup"]["gpu"]
+                    }
+                if speedup_data:
+                    data["result"]["speedup"] = speedup_data
+
             with open(filepath, "w", encoding="utf-8") as f:
                 json.dump(data, f, indent=4)
 

graph_net/test/chain_naive_graph_decomposer_test.sh

@@ -20,4 +20,4 @@ EOF
 EXTRACTOR_CONFIG=$(echo $extractor_config_json_str | base64 -w 0)
 
 mkdir -p /tmp/naive_decompose_workspace
-python3 -m graph_net.torch.single_device_runner --model-path $GRAPH_NET_ROOT/../samples/$MODEL_PATH_IN_SAMPLES --enable-extract True --extract-name resnet18 --dump-graph-hash-key --extractor-config=$EXTRACTOR_CONFIG
+python3 -m graph_net.torch.single_device_runner --model-path $GRAPH_NET_ROOT/../samples/$MODEL_PATH_IN_SAMPLES --enable-extract True --extract-name resnet18 --dump-graph-hash-key --extractor-config=$EXTRACTOR_CONFIG

graph_net/test/decomposer_validator_test.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+GRAPH_NET_ROOT=$(python3 -c "import graph_net; import os; print(os.path.dirname(graph_net.__file__))")
+
+if [ -z "$GRAPH_NET_DECOMPOSE_PATH" ]; then
+    GRAPH_NET_DECOMPOSE_PATH="$(pwd)/graphnet_decompose"
+fi
+
+MODEL_PATH_IN_SAMPLES=/timm/resnet18
+MODEL_NAME=$(basename "$MODEL_PATH_IN_SAMPLES")
+OUTPUT_DIR="${GRAPH_NET_DECOMPOSE_PATH:-$(pwd)}"
+cp -r "$GRAPH_NET_ROOT/../samples/$MODEL_PATH_IN_SAMPLES" "$OUTPUT_DIR/"
+
+extractor_config_json_str=$(cat <<EOF
+{
+    "custom_extractor_path": "$GRAPH_NET_ROOT/torch/naive_graph_decomposer.py",
+    "custom_extractor_config": {
+        "output_dir": "$OUTPUT_DIR/${MODEL_NAME}_decomposed",
+        "split_positions": [8, 16, 32],
+        "group_head_and_tail": true,
+        "chain_style": true
+    }
+}
+EOF
+)
+EXTRACTOR_CONFIG=$(echo $extractor_config_json_str | base64 -w 0)
+python3 -m graph_net.torch.single_device_runner --model-path $GRAPH_NET_ROOT/../samples/$MODEL_PATH_IN_SAMPLES --enable-extract True --extract-name $MODEL_NAME --dump-graph-hash-key --extractor-config=$EXTRACTOR_CONFIG
+
+FILE_PATH=$GRAPH_NET_DECOMPOSE_PATH/decomposer
+mkdir -p "$(dirname "$FILE_PATH/log.log")"
+MODEL_PATH="$GRAPH_NET_DECOMPOSE_PATH/$MODEL_NAME"
+
+python -m graph_net.torch.test_compiler \
+    --model-path $MODEL_PATH \
+    --compiler range_decomposer_validator \
+    --device cuda > "$FILE_PATH/log.log" 2>&1
+
+python -m graph_net.log2json \
+    --log-file "$FILE_PATH/log.log" \
+    --output-dir "$FILE_PATH/JSON_results/"
+
+python -m graph_net.plot_ESt \
+    --benchmark-path "$FILE_PATH/JSON_results/" \
+    --output-dir "$FILE_PATH"
+
+echo "=================================================="
+echo "Results saved in: $FILE_PATH/ES_result.png"
+echo ""
+echo "IMPORTANT: Please verify if the curve in ES_result.png is a straight line"
+echo "If the curve is NOT a straight line, please check the log file: $FILE_PATH/log.log"
+echo "=================================================="

graph_net/test/naive_graph_decomposer_test.sh

@@ -21,4 +21,4 @@ EOF
 EXTRACTOR_CONFIG=$(echo $extractor_config_json_str | base64 -w 0)
 
 mkdir -p /tmp/naive_decompose_workspace
-python3 -m graph_net.torch.single_device_runner --model-path $GRAPH_NET_ROOT/../samples/$MODEL_PATH_IN_SAMPLES --enable-extract True --extract-name resnet18 --dump-graph-hash-key --extractor-config=$EXTRACTOR_CONFIG
+python3 -m graph_net.torch.single_device_runner --model-path $GRAPH_NET_ROOT/../samples/$MODEL_PATH_IN_SAMPLES --enable-extract True --extract-name resnet18 --dump-graph-hash-key --extractor-config=$EXTRACTOR_CONFIG

graph_net/torch/backend/range_decomposer_validator_backend.py

@@ -0,0 +1,76 @@
+import torch
+import torch.nn as nn
+import os
+import sys
+import inspect
+import importlib.util
+import itertools
+from typing import List, Tuple, Dict, Any, Callable
+
+
+class ComposedModel(nn.Module):
+    def __init__(self, subgraph: List[nn.Module]):
+        super().__init__()
+        self.subgraphs = nn.ModuleList(subgraph)
+
+    def forward(self, **kwargs):
+        subgraph_intput = {
+            key.replace("L", "l_l", 1): value
+            for key, value in kwargs.items()
+            if key.startswith("L")
+        }
+
+        output = None
+        for subgraph in self.subgraphs:
+            if output is None:
+                output = subgraph(**subgraph_intput)
+            else:
+                output = subgraph(*output)
+
+        return output
+
+
+class RangeDecomposerValidatorBackend:
+    def _load_model_instance(self, path: str, device: str) -> torch.nn.Module:
+        class_name = "GraphModule"
+        model_file = os.path.join(path, "model.py")
+
+        spec = importlib.util.spec_from_file_location(class_name, model_file)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        ModelClass = getattr(module, class_name)
+        instance = ModelClass().to(device)
+        return instance
+
+    def __call__(self, model: torch.nn.Module) -> torch.nn.Module:
+        model_file_path = model.__class__.__graph_net_file_path__
+        model_dir = os.path.dirname(model_file_path)
+        decomposed_parent_dir = model_dir + "_decomposed"
+        subgraph_paths = []
+        for name in sorted(os.listdir(decomposed_parent_dir)):
+            full_path = os.path.join(decomposed_parent_dir, name)
+            if os.path.isdir(full_path) and name[-1].isdigit():
+                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()
+
+    def synchronize(self):
+        if torch.cuda.is_available():
+            torch.cuda.synchronize()