Upload consensus_fusion.py with huggingface_hub

consensus_fusion.py

@@ -7,26 +7,89 @@ try:
 except ImportError:
     MATH_VERIFY_AVAILABLE = False
 
+def _fix_sqrt(string: str) -> str:
+    if "\\sqrt" not in string: return string
+    splits = string.split("\\sqrt")
+    new_string = splits[0]
+    for split in splits[1:]:
+        if len(split) > 0 and split[0] != "{":
+            new_string += "\\sqrt{" + split[0] + "}" + split[1:]
+        else:
+            new_string += "\\sqrt" + split
+    return new_string
+
+def _fix_fracs(string: str) -> str:
+    substrs = string.split("\\frac")
+    new_str = substrs[0]
+    if len(substrs) > 1:
+        for substr in substrs[1:]:
+            new_str += "\\frac"
+            if len(substr) > 0 and substr[0] == "{":
+                new_str += substr
+            elif len(substr) >= 2:
+                new_str += "{" + substr[0] + "}{" + substr[1] + "}" + substr[2:]
+            else:
+                new_str += substr
+    return new_str
+
+def _fix_a_slash_b(string: str) -> str:
+    if "/" not in string or len(string.split("/")) != 2: return string
+    a, b = string.split("/")
+    try:
+        a_int = int(re.sub(r'[^0-9-]', '', a))
+        b_int = int(re.sub(r'[^0-9-]', '', b))
+        return f"\\frac{{{a_int}}}{{{b_int}}}"
+    except: return string
+
+def _strip_string(string: str) -> str:
+    string = string.replace("\n", "").replace("\\!", "").replace("\\\\", "\\")
+    string = string.replace("tfrac", "frac").replace("dfrac", "frac")
+    string = string.replace("\\left", "").replace("\\right", "")
+    string = string.replace("^{\\circ}", "").replace("^\\circ", "")
+    string = string.replace("\\$", "").replace("$", "")
+    string = string.replace("\\%", "").replace("\%", "")
+    if "sqrt" in string: string = _fix_sqrt(string)
+    string = string.replace(" ", "")
+    if "frac" in string: string = _fix_fracs(string)
+    if string == "0.5": string = "\\frac{1}{2}"
+    string = _fix_a_slash_b(string)
+    return string
+
+def find_math_answer(s: str) -> str:
+    s = s.lower()
+    if 'oxed{' in s:
+        try:
+            ans = re.findall(r'oxed{(.*)}', s, flags=re.S)[-1]
+            if '}' in ans and ('{' not in ans or ans.find('}') < ans.find('{')):
+                ans = ans.split('}')[0]
+            s = ans
+        except: pass
+    s = s.split('=')[-1].split('\\approx')[-1]
+    return _strip_string(s)
+
+def extract_choice(text: str) -> str:
+    """Extracts alphabet choice (A, B, C, D) from model response."""
+    patterns = [
+        r'the answer is \(([a-e])\)',
+        r'the answer is ([a-e])\.',
+        r'final answer: ([a-e])',
+        r'^\(([a-e])\)',
+        r'^([a-e])\n'
+    ]
+    for p in patterns:
+        match = re.search(p, text.lower())
+        if match: return match.group(1).upper()
+    return ""
+
 def _normalize_answer(ans: str) -> Any:
-    """Uses math_verify to parse the answer for robust comparison."""
+    """Uses advanced heuristics + math_verify to normalize answer."""
+    cleaned = find_math_answer(str(ans))
     if MATH_VERIFY_AVAILABLE:
         try:
-            return parse(str(ans))
+            return parse(cleaned)
         except:
-            return str(ans)
-    
-    # Legacy fallback
-    s = str(ans).strip()
-    s = re.sub(r'\$', '', s)
-    s = re.sub(r'\\(?:approx|approx|cdot|,|;|\s)', ' ', s)
-    s = s.replace("\\", "").replace("{", "").replace("}", "")
-    s = s.replace(" ", "").lower()
-    try:
-        f = float(s)
-        s = str(int(f)) if f == int(f) else str(round(f, 6))
-    except:
-        pass
-    return s
+            return cleaned
+    return cleaned
 
 def normalize_answers(answers: List[str]) -> Dict[str, List[int]]:
     """Group answers that are numerically/symbolically equivalent."""
@@ -129,6 +192,10 @@ def evaluate_consensus(
         conf_exp = res.get("Confidence Explanation", "")
         raw_ans = res.get("Answer", "N/A")
 
+        # Heuristic Bonus: Capture choices (A/B/C/D)
+        choice = extract_choice(str(raw_ans))
+        normalized_ans = choice if choice else _normalize_answer(raw_ans)
+        
         # Check if the agent itself marked this as divergent/hallucinating
         is_self_flagged = any(t in conf_exp.lower() for t in ["divergent", "wrong", "hallucin", "low confidence", "divergence"])
 
@@ -173,6 +240,7 @@ def evaluate_consensus(
         scores.append({
             "agent": agent_data["agent"],
             "raw_answer": raw_ans,
+            "normalized_answer": str(normalized_ans),
             "V_sym": round(v_sym, 3),
             "L_logic": round(l_logic, 3),
             "C_clf": round(c_clf, 3),