Merge branch 'develop' into opt_saved_results

Author: Xreki

graph_net/analysis_util.py

@@ -3,6 +3,8 @@
 import sys
 from scipy.stats import gmean
 from graph_net.config.datatype_tolerance_config import get_precision
+from graph_net.positive_tolerance_interpretation import PositiveToleranceInterpretation
+from graph_net.verify_aggregated_params import determine_tolerances
 
 
 def detect_sample_status(log_text: str) -> str:
@@ -293,38 +295,24 @@ def get_correctness(dtype: str, t: int, correctness_data: dict, index: int) -> b
     return False
 
 
-def fake_perf_degrad(tolerance, error_code, type="default") -> str:
+def fake_perf_degrad(
+    tolerance,
+    error_code,
+    positive_tolerance_interpretation: PositiveToleranceInterpretation,
+) -> str:
     """
     Judge current correctness based on tolerance t and status.
+    Refactored to delegate logic to PositiveToleranceInterpretation classes.
     """
-    if type == "default":
-        if tolerance >= 3:
-            return "correct"
-        elif error_code == "accuracy" and tolerance >= 1:
-            return "correct"
-        else:
-            return error_code
-    elif type == "extended":
-        if (
-            error_code == "compile_fail" or error_code == "runtime_fail"
-        ) and tolerance >= 4:
-            return "correct"
-        elif error_code == "eager_fail" and tolerance >= 3:
-            return "correct"
-        elif (
-            error_code == "shape_mismatch" or error_code == "type_mismatch"
-        ) and tolerance >= 2:
-            return "correct"
-        elif error_code == "accuracy" and tolerance >= 1:
-            return "correct"
-        else:
-            return error_code
-    else:
-        raise NotImplementedError
+    if positive_tolerance_interpretation.is_error_tolerated(tolerance, error_code):
+        return "correct"
+
+    return error_code
 
 
 def calculate_scores(
     samples: list,
+    positive_tolerance_interpretation: PositiveToleranceInterpretation,
     p: float = 0,
     b: float = 0.1,
     type: str = "ESt",
@@ -339,7 +327,10 @@ def calculate_scores(
 
     scores = {}
 
-    for tolerance in range(-10, 5):
+    strategy = positive_tolerance_interpretation
+    tolerances = determine_tolerances(samples, positive_tolerance_interpretation)
+
+    for tolerance in tolerances:
         rectified_speedups = []
         rectified_speedups_fake_degrad = []
 
@@ -373,12 +364,10 @@ def calculate_scores(
                     )
             else:
                 if not is_correct_at_t1[idx]:
-                    current_correctness = fake_perf_degrad(
+                    is_tolerated = strategy.is_error_tolerated(
                         tolerance, fail_type_at_t1[idx]
                     )
-                    rec_speedup_fake_degrad = (
-                        1 if current_correctness == "correct" else b
-                    )
+                    rec_speedup_fake_degrad = 1 if is_tolerated else b
                 else:
                     rec_speedup_fake_degrad = (
                         speedup_at_t1[idx] ** (p + 1)

graph_net/bash_templates/model_path_handler_sh.txt

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+GRAPH_NET_ROOT=$(python3 -c "import graph_net; import os; print(os.path.dirname(os.path.dirname(graph_net.__file__)))")
+
+python3 -m graph_net.model_path_handler \
+    --model-path-list "customize_your_model_path_list" \
+    --handler-config $(base64 -w 0 <<EOF
+{
+    "handler_path": "$GRAPH_NET_ROOT/graph_net/customize_your_sample_pass.py",
+    "handler_class_name": "customize_your_class_name",
+    "handler_config": {
+        "resume": true,
+        "model_path_prefix": "/customize_your_model_path_prefix",
+        "output_dir": "/customize_your_output_file"
+    }
+}
+EOF
+)

graph_net/config/get_fusible_subgraph_sample_list.txt

@@ -0,0 +1,100 @@
+samples/timm/crossvit_small_240.in1k
+samples/timm/poolformerv2_s12.sail_in1k
+samples/timm/regnety_080.pycls_in1k
+samples/timm/dla46x_c.in1k
+samples/timm/mobilenetv1_100.ra4_e3600_r224_in1k
+samples/timm/efficientnetv2_rw_s.ra2_in1k
+samples/timm/vit_base_patch16_rope_ape_224.naver_in1k
+samples/timm/fastvit_t8.apple_dist_in1k
+samples/timm/test_byobnet.r160_in1k
+samples/timm/mambaout_base.in1k
+samples/timm/davit_small
+samples/timm/resnet61q.ra2_in1k
+samples/timm/coat_tiny
+samples/timm/regnetx_004.pycls_in1k
+samples/timm/convnextv2_large.fcmae
+samples/timm/regnety_640.seer
+samples/timm/repvit_m1_1.dist_300e_in1k
+samples/timm/tinynet_d.in1k
+samples/timm/resnetrs270.tf_in1k
+samples/timm/cait_m48_448
+samples/timm/legacy_seresnet50.in1k
+samples/timm/tinynet_a.in1k
+samples/timm/convnext_small.fb_in1k
+samples/timm/vit_huge_patch14_clip_quickgelu_224.dfn5b
+samples/timm/dpn131.mx_in1k
+samples/timm/convnextv2_large.fcmae_ft_in1k
+samples/timm/convnextv2_small
+samples/timm/repvit_m1.dist_in1k
+samples/timm/cs3darknet_s
+samples/timm/resnet50d.a1_in1k
+samples/timm/dm_nfnet_f6
+samples/timm/coatnet_1_rw_224
+samples/timm/lcnet_050.ra2_in1k
+samples/timm/efficientnet_em.ra2_in1k
+samples/timm/dpn48b
+samples/timm/semnasnet_075.rmsp_in1k
+samples/timm/skresnet34.ra_in1k
+samples/timm/crossvit_15_dagger_240.in1k
+samples/timm/mnasnet_100.rmsp_in1k
+samples/timm/mobilenetv3_rw.rmsp_in1k
+samples/timm/xception65p.ra3_in1k
+samples/timm/coatnet_0_rw_224
+samples/timm/eca_nfnet_l3
+samples/timm/deit3_base_patch16_224.fb_in1k
+samples/timm/mambaout_base_short_rw.sw_e500_in1k
+samples/timm/mobilenetv4_conv_small.e1200_r224_in1k
+samples/timm/xception71.tf_in1k
+samples/timm/dla60.in1k
+samples/timm/repghostnet_130.in1k
+samples/timm/mambaout_base_plus_rw.sw_e150_in12k
+samples/timm/poolformerv2_s36.sail_in1k
+samples/timm/deit3_huge_patch14_224.fb_in1k
+samples/timm/vit_base_patch32_clip_224.datacompxl
+samples/timm/poolformer_m48.sail_in1k
+samples/timm/regnety_006.pycls_in1k
+samples/timm/starnet_s4.in1k
+samples/timm/poolformer_m36.sail_in1k
+samples/timm/vit_huge_patch14_gap_224.in1k_ijepa
+samples/timm/efficientnet_b3.ra2_in1k
+samples/timm/mobilenetv3_large_150d.ra4_e3600_r256_in1k
+samples/timm/hgnetv2_b0.ssld_stage1_in22k_in1k
+samples/timm/convnextv2_huge.fcmae
+samples/timm/davit_huge
+samples/timm/regnetx_004_tv.tv2_in1k
+samples/timm/dla34.in1k
+samples/timm/convnext_xlarge.fb_in22k
+samples/timm/resmlp_12_224.fb_dino
+samples/timm/fasternet_t1.in1k
+samples/timm/resnetblur50.bt_in1k
+samples/timm/res2net50d.in1k
+samples/timm/vit_base_patch32_224.augreg_in1k
+samples/timm/mambaout_base_wide_rw.sw_e500_in1k
+samples/timm/vgg19_bn.tv_in1k
+samples/timm/vit_small_patch16_rope_ape_224.naver_in1k
+samples/timm/hardcorenas_b.miil_green_in1k
+samples/timm/vgg16.tv_in1k
+samples/timm/xception41p.ra3_in1k
+samples/timm/efficientnet_lite0.ra_in1k
+samples/timm/regnetv_064.ra3_in1k
+samples/timm/regnety_320.pycls_in1k
+samples/timm/convnext_pico.d1_in1k
+samples/timm/repvit_m1_0.dist_300e_in1k
+samples/timm/resnet50c.gluon_in1k
+samples/timm/mobileone_s4.apple_in1k
+samples/timm/ghostnet_100.in1k
+samples/timm/deit_base_distilled_patch16_384
+samples/timm/dpn68b.mx_in1k
+samples/timm/dla60_res2next
+samples/timm/resnet101d.gluon_in1k
+samples/timm/eva02_large_patch14_clip_224.merged2b
+samples/timm/fasternet_m.in1k
+samples/timm/mobilenetv2_110d.ra_in1k
+samples/timm/regnetx_064.pycls_in1k
+samples/timm/cspresnet50.ra_in1k
+samples/timm/resmlp_24_224.fb_dino
+samples/timm/mobileone_s3.apple_in1k
+samples/timm/mobileone_s2.apple_in1k
+samples/timm/res2net101d
+samples/timm/hardcorenas_f.miil_green_in1k
+samples/timm/hrnet_w18_ssld.paddle_in1k

graph_net/config/small_sample_list_for_get_fusible_subgraph.txt

@@ -0,0 +1,10 @@
+#samples/timm/crossvit_small_240.in1k
+#samples/timm/poolformerv2_s12.sail_in1k
+#samples/timm/regnety_080.pycls_in1k
+#samples/timm/dla46x_c.in1k
+#samples/timm/mobilenetv1_100.ra4_e3600_r224_in1k
+samples/timm/efficientnetv2_rw_s.ra2_in1k
+samples/timm/vit_base_patch16_rope_ape_224.naver_in1k
+#samples/timm/fastvit_t8.apple_dist_in1k
+#samples/timm/test_byobnet.r160_in1k
+#samples/timm/mambaout_base.in1k

graph_net/default_positive_tolerance_interpretation.py

@@ -0,0 +1,77 @@
+from enum import IntEnum
+
+from graph_net.positive_tolerance_interpretation import PositiveToleranceInterpretation
+
+
+class DefaultErrorEnum(IntEnum):
+    """
+    Values correspond to the minimum tolerance level required.
+    """
+
+    kAccuracyViolation = 1  # Accuracy
+    kRuntimeFailure = 2  # Includes Runtime, NaN, Inf, TypeMismatch, etc.
+    kCompilationFailed = 3  # Compile Failure
+
+    @classmethod
+    def get_error_enum(cls, base_error_type: str) -> "DefaultErrorEnum":
+        if not base_error_type:
+            return cls.kRuntimeFailure
+
+        etype = base_error_type.lower()
+
+        if "accuracy" in etype:
+            return cls.kAccuracyViolation
+
+        if "compile_fail" in etype:
+            return cls.kCompilationFailed
+
+        return cls.kRuntimeFailure
+
+
+class DefaultPositiveToleranceInterpretation(PositiveToleranceInterpretation):
+    """
+    Legacy interpretation:
+    - t=1: Accuracy errors tolerated.
+    - t=3: Runtime/Compilation errors tolerated.
+    """
+
+    def __init__(self, *argc, **kwargs):
+        super().__init__(*argc, **kwargs)
+
+    def type_name(self) -> str:
+        return "default"
+
+    def get_errno(self, error_type: str) -> int:
+        return DefaultErrorEnum.get_error_enum(error_type).value
+
+    def get_error_type(self, errno: int) -> str:
+        mapping = {1: "accuracy", 2: "runtime_fail", 3: "compile_fail"}
+        return mapping.get(errno, "unknown_error")
+
+    def get_tolerance_mapping(self) -> dict[int, int]:
+        return {
+            DefaultErrorEnum.kAccuracyViolation.value: 1,
+            DefaultErrorEnum.kRuntimeFailure.value: 3,
+            DefaultErrorEnum.kCompilationFailed.value: 3,
+        }
+
+    def is_error_tolerated(self, tolerance: int, base_error_code: str) -> bool:
+        if base_error_code == "correct":
+            return True
+        if base_error_code in ["eager_fail", "reference_fail"]:
+            return False
+
+        error_enum = DefaultErrorEnum.get_error_enum(base_error_code)
+        mapping = self.get_tolerance_mapping()
+        required_threshold = mapping.get(error_enum.value, 999)
+
+        return tolerance >= required_threshold
+
+    def num_errno_enum_values(self) -> int:
+        """
+        Default mode defines 3 levels of errors:
+        1: Accuracy
+        2: Runtime (Generic)
+        3: Compilation
+        """
+        return len(DefaultErrorEnum)

graph_net/graph_net_json_file_util.py

@@ -1,17 +1,61 @@
-from pathlib import Path
 import json
+from pathlib import Path
 
 kDimensionGeneralizationPasses = "dimension_generalization_passes"
+kDataTypeGeneralizationPasses = "data_type_generalization_passes"
 kSymbolicDimensionReifier = "symbolic_dimension_reifier"
 
+# Fields for dtype generalization metadata
+kDtypeGeneralizationTargetDtype = "dtype_generalization_target_dtype"
+kDtypeGeneralizationPrecision = "dtype_generalization_precision"
+kDtypeGeneralizationGenerated = "dtype_generalization_generated"
+
 
 def read_json(model_path):
+    """
+    Read JSON from graph_net.json file.
+
+    Args:
+        model_path: Path to model directory
+
+    Returns:
+        Dictionary containing JSON data
+    """
     graph_net_json_file_path = Path(f"{model_path}/graph_net.json")
     return json.loads(graph_net_json_file_path.read_text())
 
 
 def update_json(model_path, field, value):
-    graph_net_json_file_path = Path(f"{model_path}/graph_net.json")
-    graph_net_json = json.loads(graph_net_json_file_path.read_text())
+    """
+    Update a single field in graph_net.json.
+
+    Args:
+        model_path: Path to model directory or graph_net.json file
+        field: Field name to update
+        value: Value to set
+    """
+    if isinstance(model_path, (str, Path)):
+        model_path = Path(model_path)
+        # If it's a file path, use it directly; otherwise assume it's a directory
+        if model_path.suffix == ".json":
+            graph_net_json_file_path = model_path
+        else:
+            graph_net_json_file_path = model_path / "graph_net.json"
+    else:
+        graph_net_json_file_path = Path(f"{model_path}/graph_net.json")
+
+    # Read existing JSON
+    if graph_net_json_file_path.exists():
+        with open(graph_net_json_file_path, "r") as f:
+            graph_net_json = json.load(f)
+    else:
+        graph_net_json = {}
+
+    # Update field
     graph_net_json[field] = value
-    graph_net_json_file_path.write_text(json.dumps(graph_net_json, indent=4))
+
+    # Atomic write: write to temp file then rename
+    temp_path = graph_net_json_file_path.with_suffix(".json.tmp")
+    with open(temp_path, "w") as f:
+        json.dump(graph_net_json, f, indent=4)
+    temp_path.replace(graph_net_json_file_path)