code Fix 4

修复了枚举逻辑和映射逻辑，按照新的映射逻辑修复了容忍度判断

Author: 3619117923

graph_net/default_positive_tolerance_interpretation.py

@@ -8,28 +8,24 @@ class DefaultErrorEnum(IntEnum):
     Values correspond to the minimum tolerance level required.
     """
 
-    kAccuracyViolation = 1
-    kValueTypeOrMetaMismatch = 3
-    kExecutionFailed = 3
-    kCompilationFailed = 3
+    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.kExecutionFailed
+            return cls.kRuntimeFailure
 
         etype = base_error_type.lower()
 
         if "accuracy" in etype:
             return cls.kAccuracyViolation
 
-        if any(x in etype for x in ["nan", "inf", "type_mismatch", "shape_mismatch"]):
-            return cls.kValueTypeOrMetaMismatch
-
         if "compile_fail" in etype:
             return cls.kCompilationFailed
 
-        return cls.kExecutionFailed
+        return cls.kRuntimeFailure
 
 
 class DefaultPositiveToleranceInterpretation(PositiveToleranceInterpretation):
@@ -46,24 +42,17 @@ def type_name(self) -> str:
         return "default"
 
     def get_errno(self, error_type: str) -> int:
-        if not error_type:
-            return 2
-        etype = error_type.lower()
-        if "accuracy" in etype:
-            return 1
-        if "compile_fail" in etype:
-            return 3
-        return 2
+        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 {
-            1: 1,  # Accuracy -> t >= 1
-            2: 3,  # Runtime  -> t >= 3
-            3: 3,  # Compile  -> t >= 3
+            DefaultErrorEnum.kAccuracyViolation.value: 1,
+            DefaultErrorEnum.kRuntimeFailure.value: 3,
+            DefaultErrorEnum.kCompilationFailed.value: 3,
         }
 
     def is_error_tolerated(self, tolerance: int, base_error_code: str) -> bool:
@@ -72,8 +61,17 @@ def is_error_tolerated(self, tolerance: int, base_error_code: str) -> bool:
         if base_error_code in ["eager_fail", "reference_fail"]:
             return False
 
-        try:
-            error_level = DefaultErrorEnum.get_error_enum(base_error_code)
-            return tolerance >= error_level.value
-        except (ValueError, KeyError):
-            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/mismatch_extended_positive_tolerance_interpretation.py

@@ -45,17 +45,7 @@ def type_name(self) -> str:
         return "mismatch_extended"
 
     def get_errno(self, error_type: str) -> int:
-        if not error_type:
-            return 3
-        etype = error_type.lower()
-
-        if "accuracy" in etype:
-            return 1
-        if any(k in etype for k in ["nan", "inf", "type_mismatch", "shape_mismatch"]):
-            return 2
-        if "compile_fail" in etype:
-            return 4
-        return 3
+        return MismatchExtendedErrorEnum.get_error_enum(error_type).value
 
     def get_error_type(self, errno: int) -> str:
         mapping = {
@@ -67,15 +57,31 @@ def get_error_type(self, errno: int) -> str:
         return mapping.get(errno, "unknown_error")
 
     def get_tolerance_mapping(self) -> dict[int, int]:
-        return {1: 1, 2: 2, 3: 3, 4: 4}
+        return {
+            MismatchExtendedErrorEnum.kAccuracyViolation.value: 1,
+            MismatchExtendedErrorEnum.kValueTypeOrMetaMismatch.value: 2,
+            MismatchExtendedErrorEnum.kExecutionFailed.value: 3,
+            MismatchExtendedErrorEnum.kCompilationFailed.value: 4,
+        }
 
     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
-        try:
-            error_level = MismatchExtendedErrorEnum.get_error_enum(base_error_code)
-            return tolerance >= error_level.value
-        except (ValueError, KeyError):
-            return False
+
+        error_enum = MismatchExtendedErrorEnum.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:
+        """
+        Extended mode defines 4 levels of errors:
+        1: Accuracy
+        2: Type/Shape/NaN
+        3: Runtime
+        4: Compilation
+        """
+        return len(MismatchExtendedErrorEnum)

graph_net/positive_tolerance_interpretation.py

@@ -40,3 +40,14 @@ def is_error_tolerated(self, tolerance: int, base_error_code: str) -> bool:
         Replaces the old 'fake_perf_degrad' logic.
         """
         raise NotImplementedError
+
+    @abstractmethod
+    def num_errno_enum_values(self) -> int:
+        """
+        Return the number of defined error categories (or the maximum errno).
+
+        Example:
+            - Default: returns 3 (Accuracy, Runtime, Compile)
+            - MismatchExtended: returns 4 (Accuracy, Data, Runtime, Compile)
+        """
+        raise NotImplementedError

graph_net/samples_statistics.py

@@ -155,6 +155,7 @@ def calculate_pi(
 
 def resolve_errno_tolerance(
     errno2count: dict[Union[int, str], int],
+    positive_tolerance_interpretation: PositiveToleranceInterpretation,
     errno_tolerance_overrides: Optional[dict[Union[int, str], int]] = None,
 ) -> dict[Union[int, str], int]:
     """
@@ -176,12 +177,20 @@ def resolve_errno_tolerance(
     """
     errno_tolerance_overrides = errno_tolerance_overrides or {}
 
-    def tolerance_for(errno: Union[int, str]) -> int:
-        if errno in errno_tolerance_overrides:
-            return errno_tolerance_overrides[errno]
+    base_mapping = positive_tolerance_interpretation.get_tolerance_mapping()
+
+    def tolerance_for(err_key: Union[int, str]) -> int:
+        if err_key in errno_tolerance_overrides:
+            return errno_tolerance_overrides[err_key]
 
-        if isinstance(errno, int):
-            return 1 if errno == 1 else 3
+        errno_id = None
+        if isinstance(err_key, int):
+            errno_id = err_key
+        elif isinstance(err_key, str):
+            errno_id = positive_tolerance_interpretation.get_errno(err_key)
+
+        if errno_id is not None and errno_id in base_mapping:
+            return base_mapping[errno_id]
 
         return 999
 
@@ -310,7 +319,9 @@ def calculate_es_components_values(
         errno_to_tolerance, positive_tolerance_interpretation
     )
 
-    errno2tolerance = resolve_errno_tolerance(errno2count, errno_to_tolerance)
+    errno2tolerance = resolve_errno_tolerance(
+        errno2count, positive_tolerance_interpretation, errno_to_tolerance
+    )
 
     def pi_value4errno(errno: Union[int, str]) -> float:
         return pi.get(errno, 0.0)

graph_net/verify_aggregated_params.py

@@ -13,14 +13,11 @@ def determine_tolerances(
     positive_tolerance_interpretation: PositiveToleranceInterpretation,
 ) -> range:
     """Determine tolerance range based on observed errno categories."""
-    # Currently errno categories are 1=accuracy, 2=runtime, 3=compile.
-    # Keep logic data-driven for future extension.
-    mapping = positive_tolerance_interpretation.get_tolerance_mapping()
-
-    if not mapping:
-        max_errno = 3
+    if samples:
+        max_errno = len(samples)
     else:
-        max_errno = max(mapping.keys())
+        max_errno = positive_tolerance_interpretation.num_errno_enum_values()
+
     return range(-10, max_errno + 2)