fix: normalize explicit TSQA choice labels

Benchmark_eval/TSQA/_build/schema.py

@@ -162,7 +162,20 @@ _BOXED_RE = re.compile(r"\\boxed\s*\{([^{}]*)\}")
 _ANSWER_RE = re.compile(r"<answer>\s*(.*?)\s*</answer>", re.DOTALL | re.IGNORECASE)
 _THINK_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 _NUM_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
-_LETTER_RE = re.compile(r"\b([A-Ea-e])\b")  # MCQ up to 5 options (EngineMT uses a-e)
+_LETTER_RE = re.compile(r"\b([A-Ha-h])\b")
+_LEADING_CHOICE_RE = re.compile(
+    r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s*(?=$|\n))"
+)
+_EXPLICIT_CHOICE_RE = re.compile(
+    r"(?is)(?:\*{0,2})(?:(?:final|correct)\s+)?"
+    r"(?:answer|option|choice|conclusion)(?:\*{0,2})\s*"
+    r"(?:is\s*[:：]?|[:：])\s*(?:\*{0,2})(?:option\s+)?"
+    r"\(?\s*([A-Ha-h])\b"
+)
+_EXPLICIT_TRUE_FALSE_RE = re.compile(
+    r"(?is)(?:answer|conclusion|statement)\s*(?:is\s*[:：]?|[:：])\s*"
+    r"(true|false)\b"
+)
 
 
 def answer_block(text: str) -> str:
@@ -233,10 +246,12 @@ def parse_number(text: str) -> float | None:
 
 
 def parse_choice(text: str, options: list[str] | None = None) -> str | None:
-    """Strict choice extraction: \\boxed{} or <answer> tag only (no prose scraping).
+    """Extract an explicit choice without scraping arbitrary prose.
 
-    Order: \\boxed{} letter/option -> letter/option inside <answer>..</answer>.
-    Returns normalized letter (upper) or matched option text, else None.
+    Order: \\boxed{} -> <answer> -> leading option label -> explicit answer cue.
+    The two fallbacks accept unambiguous forms such as ``B) False``, a leading
+    bare ``B``, ``Final answer: B``, or ``Conclusion: B``. They deliberately do
+    not search for isolated letters elsewhere in prose.
     """
     boxed = extract_boxed(text)
     if boxed:
@@ -255,6 +270,27 @@ def parse_choice(text: str, options: list[str] | None = None) -> str | None:
             for opt in options:
                 if opt and opt.lower() in low:
                     return opt
+    leading = _LEADING_CHOICE_RE.match(text)
+    if leading:
+        return leading.group(1).upper()
+    explicit = list(_EXPLICIT_CHOICE_RE.finditer(text))
+    if explicit:
+        return explicit[-1].group(1).upper()
+    if options:
+        true_false_labels = {}
+        for option in options:
+            match = re.match(
+                r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s+)\s*"
+                r"(true|false)\b",
+                option,
+                re.IGNORECASE,
+            )
+            if match:
+                true_false_labels[match.group(2).lower()] = match.group(1).upper()
+        if len(true_false_labels) == 2:
+            tf_matches = list(_EXPLICIT_TRUE_FALSE_RE.finditer(text))
+            if tf_matches:
+                return true_false_labels[tf_matches[-1].group(1).lower()]
     return None
 
 

results/4level_grpo_min2/TSQA/_infer/score/schema.py

@@ -162,7 +162,20 @@ _BOXED_RE = re.compile(r"\\boxed\s*\{([^{}]*)\}")
 _ANSWER_RE = re.compile(r"<answer>\s*(.*?)\s*</answer>", re.DOTALL | re.IGNORECASE)
 _THINK_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 _NUM_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
-_LETTER_RE = re.compile(r"\b([A-Ea-e])\b")  # MCQ up to 5 options (EngineMT uses a-e)
+_LETTER_RE = re.compile(r"\b([A-Ha-h])\b")
+_LEADING_CHOICE_RE = re.compile(
+    r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s*(?=$|\n))"
+)
+_EXPLICIT_CHOICE_RE = re.compile(
+    r"(?is)(?:\*{0,2})(?:(?:final|correct)\s+)?"
+    r"(?:answer|option|choice|conclusion)(?:\*{0,2})\s*"
+    r"(?:is\s*[:：]?|[:：])\s*(?:\*{0,2})(?:option\s+)?"
+    r"\(?\s*([A-Ha-h])\b"
+)
+_EXPLICIT_TRUE_FALSE_RE = re.compile(
+    r"(?is)(?:answer|conclusion|statement)\s*(?:is\s*[:：]?|[:：])\s*"
+    r"(true|false)\b"
+)
 
 
 def answer_block(text: str) -> str:
@@ -233,10 +246,12 @@ def parse_number(text: str) -> float | None:
 
 
 def parse_choice(text: str, options: list[str] | None = None) -> str | None:
-    """Strict choice extraction: \\boxed{} or <answer> tag only (no prose scraping).
+    """Extract an explicit choice without scraping arbitrary prose.
 
-    Order: \\boxed{} letter/option -> letter/option inside <answer>..</answer>.
-    Returns normalized letter (upper) or matched option text, else None.
+    Order: \\boxed{} -> <answer> -> leading option label -> explicit answer cue.
+    The two fallbacks accept unambiguous forms such as ``B) False``, a leading
+    bare ``B``, ``Final answer: B``, or ``Conclusion: B``. They deliberately do
+    not search for isolated letters elsewhere in prose.
     """
     boxed = extract_boxed(text)
     if boxed:
@@ -255,6 +270,27 @@ def parse_choice(text: str, options: list[str] | None = None) -> str | None:
             for opt in options:
                 if opt and opt.lower() in low:
                     return opt
+    leading = _LEADING_CHOICE_RE.match(text)
+    if leading:
+        return leading.group(1).upper()
+    explicit = list(_EXPLICIT_CHOICE_RE.finditer(text))
+    if explicit:
+        return explicit[-1].group(1).upper()
+    if options:
+        true_false_labels = {}
+        for option in options:
+            match = re.match(
+                r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s+)\s*"
+                r"(true|false)\b",
+                option,
+                re.IGNORECASE,
+            )
+            if match:
+                true_false_labels[match.group(2).lower()] = match.group(1).upper()
+        if len(true_false_labels) == 2:
+            tf_matches = list(_EXPLICIT_TRUE_FALSE_RE.finditer(text))
+            if tf_matches:
+                return true_false_labels[tf_matches[-1].group(1).lower()]
     return None
 
 

results/ChatTS-14B/TSQA/_infer/score/schema.py

@@ -162,7 +162,20 @@ _BOXED_RE = re.compile(r"\\boxed\s*\{([^{}]*)\}")
 _ANSWER_RE = re.compile(r"<answer>\s*(.*?)\s*</answer>", re.DOTALL | re.IGNORECASE)
 _THINK_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 _NUM_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
-_LETTER_RE = re.compile(r"\b([A-Ea-e])\b")  # MCQ up to 5 options (EngineMT uses a-e)
+_LETTER_RE = re.compile(r"\b([A-Ha-h])\b")
+_LEADING_CHOICE_RE = re.compile(
+    r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s*(?=$|\n))"
+)
+_EXPLICIT_CHOICE_RE = re.compile(
+    r"(?is)(?:\*{0,2})(?:(?:final|correct)\s+)?"
+    r"(?:answer|option|choice|conclusion)(?:\*{0,2})\s*"
+    r"(?:is\s*[:：]?|[:：])\s*(?:\*{0,2})(?:option\s+)?"
+    r"\(?\s*([A-Ha-h])\b"
+)
+_EXPLICIT_TRUE_FALSE_RE = re.compile(
+    r"(?is)(?:answer|conclusion|statement)\s*(?:is\s*[:：]?|[:：])\s*"
+    r"(true|false)\b"
+)
 
 
 def answer_block(text: str) -> str:
@@ -233,10 +246,12 @@ def parse_number(text: str) -> float | None:
 
 
 def parse_choice(text: str, options: list[str] | None = None) -> str | None:
-    """Strict choice extraction: \\boxed{} or <answer> tag only (no prose scraping).
+    """Extract an explicit choice without scraping arbitrary prose.
 
-    Order: \\boxed{} letter/option -> letter/option inside <answer>..</answer>.
-    Returns normalized letter (upper) or matched option text, else None.
+    Order: \\boxed{} -> <answer> -> leading option label -> explicit answer cue.
+    The two fallbacks accept unambiguous forms such as ``B) False``, a leading
+    bare ``B``, ``Final answer: B``, or ``Conclusion: B``. They deliberately do
+    not search for isolated letters elsewhere in prose.
     """
     boxed = extract_boxed(text)
     if boxed:
@@ -255,6 +270,27 @@ def parse_choice(text: str, options: list[str] | None = None) -> str | None:
             for opt in options:
                 if opt and opt.lower() in low:
                     return opt
+    leading = _LEADING_CHOICE_RE.match(text)
+    if leading:
+        return leading.group(1).upper()
+    explicit = list(_EXPLICIT_CHOICE_RE.finditer(text))
+    if explicit:
+        return explicit[-1].group(1).upper()
+    if options:
+        true_false_labels = {}
+        for option in options:
+            match = re.match(
+                r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s+)\s*"
+                r"(true|false)\b",
+                option,
+                re.IGNORECASE,
+            )
+            if match:
+                true_false_labels[match.group(2).lower()] = match.group(1).upper()
+        if len(true_false_labels) == 2:
+            tf_matches = list(_EXPLICIT_TRUE_FALSE_RE.finditer(text))
+            if tf_matches:
+                return true_false_labels[tf_matches[-1].group(1).lower()]
     return None
 
 

results/GPT-4o/TSQA/_infer/score/schema.py

@@ -162,7 +162,20 @@ _BOXED_RE = re.compile(r"\\boxed\s*\{([^{}]*)\}")
 _ANSWER_RE = re.compile(r"<answer>\s*(.*?)\s*</answer>", re.DOTALL | re.IGNORECASE)
 _THINK_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 _NUM_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
-_LETTER_RE = re.compile(r"\b([A-Ea-e])\b")  # MCQ up to 5 options (EngineMT uses a-e)
+_LETTER_RE = re.compile(r"\b([A-Ha-h])\b")
+_LEADING_CHOICE_RE = re.compile(
+    r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s*(?=$|\n))"
+)
+_EXPLICIT_CHOICE_RE = re.compile(
+    r"(?is)(?:\*{0,2})(?:(?:final|correct)\s+)?"
+    r"(?:answer|option|choice|conclusion)(?:\*{0,2})\s*"
+    r"(?:is\s*[:：]?|[:：])\s*(?:\*{0,2})(?:option\s+)?"
+    r"\(?\s*([A-Ha-h])\b"
+)
+_EXPLICIT_TRUE_FALSE_RE = re.compile(
+    r"(?is)(?:answer|conclusion|statement)\s*(?:is\s*[:：]?|[:：])\s*"
+    r"(true|false)\b"
+)
 
 
 def answer_block(text: str) -> str:
@@ -233,10 +246,12 @@ def parse_number(text: str) -> float | None:
 
 
 def parse_choice(text: str, options: list[str] | None = None) -> str | None:
-    """Strict choice extraction: \\boxed{} or <answer> tag only (no prose scraping).
+    """Extract an explicit choice without scraping arbitrary prose.
 
-    Order: \\boxed{} letter/option -> letter/option inside <answer>..</answer>.
-    Returns normalized letter (upper) or matched option text, else None.
+    Order: \\boxed{} -> <answer> -> leading option label -> explicit answer cue.
+    The two fallbacks accept unambiguous forms such as ``B) False``, a leading
+    bare ``B``, ``Final answer: B``, or ``Conclusion: B``. They deliberately do
+    not search for isolated letters elsewhere in prose.
     """
     boxed = extract_boxed(text)
     if boxed:
@@ -255,6 +270,27 @@ def parse_choice(text: str, options: list[str] | None = None) -> str | None:
             for opt in options:
                 if opt and opt.lower() in low:
                     return opt
+    leading = _LEADING_CHOICE_RE.match(text)
+    if leading:
+        return leading.group(1).upper()
+    explicit = list(_EXPLICIT_CHOICE_RE.finditer(text))
+    if explicit:
+        return explicit[-1].group(1).upper()
+    if options:
+        true_false_labels = {}
+        for option in options:
+            match = re.match(
+                r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s+)\s*"
+                r"(true|false)\b",
+                option,
+                re.IGNORECASE,
+            )
+            if match:
+                true_false_labels[match.group(2).lower()] = match.group(1).upper()
+        if len(true_false_labels) == 2:
+            tf_matches = list(_EXPLICIT_TRUE_FALSE_RE.finditer(text))
+            if tf_matches:
+                return true_false_labels[tf_matches[-1].group(1).lower()]
     return None
 
 

results/Qwen2.5-7B-Instruct/TSQA/_infer/score/schema.py

@@ -162,7 +162,20 @@ _BOXED_RE = re.compile(r"\\boxed\s*\{([^{}]*)\}")
 _ANSWER_RE = re.compile(r"<answer>\s*(.*?)\s*</answer>", re.DOTALL | re.IGNORECASE)
 _THINK_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 _NUM_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
-_LETTER_RE = re.compile(r"\b([A-Ea-e])\b")  # MCQ up to 5 options (EngineMT uses a-e)
+_LETTER_RE = re.compile(r"\b([A-Ha-h])\b")
+_LEADING_CHOICE_RE = re.compile(
+    r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s*(?=$|\n))"
+)
+_EXPLICIT_CHOICE_RE = re.compile(
+    r"(?is)(?:\*{0,2})(?:(?:final|correct)\s+)?"
+    r"(?:answer|option|choice|conclusion)(?:\*{0,2})\s*"
+    r"(?:is\s*[:：]?|[:：])\s*(?:\*{0,2})(?:option\s+)?"
+    r"\(?\s*([A-Ha-h])\b"
+)
+_EXPLICIT_TRUE_FALSE_RE = re.compile(
+    r"(?is)(?:answer|conclusion|statement)\s*(?:is\s*[:：]?|[:：])\s*"
+    r"(true|false)\b"
+)
 
 
 def answer_block(text: str) -> str:
@@ -233,10 +246,12 @@ def parse_number(text: str) -> float | None:
 
 
 def parse_choice(text: str, options: list[str] | None = None) -> str | None:
-    """Strict choice extraction: \\boxed{} or <answer> tag only (no prose scraping).
+    """Extract an explicit choice without scraping arbitrary prose.
 
-    Order: \\boxed{} letter/option -> letter/option inside <answer>..</answer>.
-    Returns normalized letter (upper) or matched option text, else None.
+    Order: \\boxed{} -> <answer> -> leading option label -> explicit answer cue.
+    The two fallbacks accept unambiguous forms such as ``B) False``, a leading
+    bare ``B``, ``Final answer: B``, or ``Conclusion: B``. They deliberately do
+    not search for isolated letters elsewhere in prose.
     """
     boxed = extract_boxed(text)
     if boxed:
@@ -255,6 +270,27 @@ def parse_choice(text: str, options: list[str] | None = None) -> str | None:
             for opt in options:
                 if opt and opt.lower() in low:
                     return opt
+    leading = _LEADING_CHOICE_RE.match(text)
+    if leading:
+        return leading.group(1).upper()
+    explicit = list(_EXPLICIT_CHOICE_RE.finditer(text))
+    if explicit:
+        return explicit[-1].group(1).upper()
+    if options:
+        true_false_labels = {}
+        for option in options:
+            match = re.match(
+                r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s+)\s*"
+                r"(true|false)\b",
+                option,
+                re.IGNORECASE,
+            )
+            if match:
+                true_false_labels[match.group(2).lower()] = match.group(1).upper()
+        if len(true_false_labels) == 2:
+            tf_matches = list(_EXPLICIT_TRUE_FALSE_RE.finditer(text))
+            if tf_matches:
+                return true_false_labels[tf_matches[-1].group(1).lower()]
     return None
 
 

results/Time-MQA-Mistral-7B/TSQA/_infer/score/schema.py

@@ -162,7 +162,20 @@ _BOXED_RE = re.compile(r"\\boxed\s*\{([^{}]*)\}")
 _ANSWER_RE = re.compile(r"<answer>\s*(.*?)\s*</answer>", re.DOTALL | re.IGNORECASE)
 _THINK_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 _NUM_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
-_LETTER_RE = re.compile(r"\b([A-Ea-e])\b")  # MCQ up to 5 options (EngineMT uses a-e)
+_LETTER_RE = re.compile(r"\b([A-Ha-h])\b")
+_LEADING_CHOICE_RE = re.compile(
+    r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s*(?=$|\n))"
+)
+_EXPLICIT_CHOICE_RE = re.compile(
+    r"(?is)(?:\*{0,2})(?:(?:final|correct)\s+)?"
+    r"(?:answer|option|choice|conclusion)(?:\*{0,2})\s*"
+    r"(?:is\s*[:：]?|[:：])\s*(?:\*{0,2})(?:option\s+)?"
+    r"\(?\s*([A-Ha-h])\b"
+)
+_EXPLICIT_TRUE_FALSE_RE = re.compile(
+    r"(?is)(?:answer|conclusion|statement)\s*(?:is\s*[:：]?|[:：])\s*"
+    r"(true|false)\b"
+)
 
 
 def answer_block(text: str) -> str:
@@ -233,10 +246,12 @@ def parse_number(text: str) -> float | None:
 
 
 def parse_choice(text: str, options: list[str] | None = None) -> str | None:
-    """Strict choice extraction: \\boxed{} or <answer> tag only (no prose scraping).
+    """Extract an explicit choice without scraping arbitrary prose.
 
-    Order: \\boxed{} letter/option -> letter/option inside <answer>..</answer>.
-    Returns normalized letter (upper) or matched option text, else None.
+    Order: \\boxed{} -> <answer> -> leading option label -> explicit answer cue.
+    The two fallbacks accept unambiguous forms such as ``B) False``, a leading
+    bare ``B``, ``Final answer: B``, or ``Conclusion: B``. They deliberately do
+    not search for isolated letters elsewhere in prose.
     """
     boxed = extract_boxed(text)
     if boxed:
@@ -255,6 +270,27 @@ def parse_choice(text: str, options: list[str] | None = None) -> str | None:
             for opt in options:
                 if opt and opt.lower() in low:
                     return opt
+    leading = _LEADING_CHOICE_RE.match(text)
+    if leading:
+        return leading.group(1).upper()
+    explicit = list(_EXPLICIT_CHOICE_RE.finditer(text))
+    if explicit:
+        return explicit[-1].group(1).upper()
+    if options:
+        true_false_labels = {}
+        for option in options:
+            match = re.match(
+                r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s+)\s*"
+                r"(true|false)\b",
+                option,
+                re.IGNORECASE,
+            )
+            if match:
+                true_false_labels[match.group(2).lower()] = match.group(1).upper()
+        if len(true_false_labels) == 2:
+            tf_matches = list(_EXPLICIT_TRUE_FALSE_RE.finditer(text))
+            if tf_matches:
+                return true_false_labels[tf_matches[-1].group(1).lower()]
     return None
 
 

results/Time-MQA-Qwen-2.5-7B/TSQA/_infer/score/schema.py

@@ -162,7 +162,20 @@ _BOXED_RE = re.compile(r"\\boxed\s*\{([^{}]*)\}")
 _ANSWER_RE = re.compile(r"<answer>\s*(.*?)\s*</answer>", re.DOTALL | re.IGNORECASE)
 _THINK_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 _NUM_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
-_LETTER_RE = re.compile(r"\b([A-Ea-e])\b")  # MCQ up to 5 options (EngineMT uses a-e)
+_LETTER_RE = re.compile(r"\b([A-Ha-h])\b")
+_LEADING_CHOICE_RE = re.compile(
+    r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s*(?=$|\n))"
+)
+_EXPLICIT_CHOICE_RE = re.compile(
+    r"(?is)(?:\*{0,2})(?:(?:final|correct)\s+)?"
+    r"(?:answer|option|choice|conclusion)(?:\*{0,2})\s*"
+    r"(?:is\s*[:：]?|[:：])\s*(?:\*{0,2})(?:option\s+)?"
+    r"\(?\s*([A-Ha-h])\b"
+)
+_EXPLICIT_TRUE_FALSE_RE = re.compile(
+    r"(?is)(?:answer|conclusion|statement)\s*(?:is\s*[:：]?|[:：])\s*"
+    r"(true|false)\b"
+)
 
 
 def answer_block(text: str) -> str:
@@ -233,10 +246,12 @@ def parse_number(text: str) -> float | None:
 
 
 def parse_choice(text: str, options: list[str] | None = None) -> str | None:
-    """Strict choice extraction: \\boxed{} or <answer> tag only (no prose scraping).
+    """Extract an explicit choice without scraping arbitrary prose.
 
-    Order: \\boxed{} letter/option -> letter/option inside <answer>..</answer>.
-    Returns normalized letter (upper) or matched option text, else None.
+    Order: \\boxed{} -> <answer> -> leading option label -> explicit answer cue.
+    The two fallbacks accept unambiguous forms such as ``B) False``, a leading
+    bare ``B``, ``Final answer: B``, or ``Conclusion: B``. They deliberately do
+    not search for isolated letters elsewhere in prose.
     """
     boxed = extract_boxed(text)
     if boxed:
@@ -255,6 +270,27 @@ def parse_choice(text: str, options: list[str] | None = None) -> str | None:
             for opt in options:
                 if opt and opt.lower() in low:
                     return opt
+    leading = _LEADING_CHOICE_RE.match(text)
+    if leading:
+        return leading.group(1).upper()
+    explicit = list(_EXPLICIT_CHOICE_RE.finditer(text))
+    if explicit:
+        return explicit[-1].group(1).upper()
+    if options:
+        true_false_labels = {}
+        for option in options:
+            match = re.match(
+                r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s+)\s*"
+                r"(true|false)\b",
+                option,
+                re.IGNORECASE,
+            )
+            if match:
+                true_false_labels[match.group(2).lower()] = match.group(1).upper()
+        if len(true_false_labels) == 2:
+            tf_matches = list(_EXPLICIT_TRUE_FALSE_RE.finditer(text))
+            if tf_matches:
+                return true_false_labels[tf_matches[-1].group(1).lower()]
     return None
 
 

results/joint_grpo_min2/TSQA/_infer/score/schema.py

@@ -162,7 +162,20 @@ _BOXED_RE = re.compile(r"\\boxed\s*\{([^{}]*)\}")
 _ANSWER_RE = re.compile(r"<answer>\s*(.*?)\s*</answer>", re.DOTALL | re.IGNORECASE)
 _THINK_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 _NUM_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
-_LETTER_RE = re.compile(r"\b([A-Ea-e])\b")  # MCQ up to 5 options (EngineMT uses a-e)
+_LETTER_RE = re.compile(r"\b([A-Ha-h])\b")
+_LEADING_CHOICE_RE = re.compile(
+    r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s*(?=$|\n))"
+)
+_EXPLICIT_CHOICE_RE = re.compile(
+    r"(?is)(?:\*{0,2})(?:(?:final|correct)\s+)?"
+    r"(?:answer|option|choice|conclusion)(?:\*{0,2})\s*"
+    r"(?:is\s*[:：]?|[:：])\s*(?:\*{0,2})(?:option\s+)?"
+    r"\(?\s*([A-Ha-h])\b"
+)
+_EXPLICIT_TRUE_FALSE_RE = re.compile(
+    r"(?is)(?:answer|conclusion|statement)\s*(?:is\s*[:：]?|[:：])\s*"
+    r"(true|false)\b"
+)
 
 
 def answer_block(text: str) -> str:
@@ -233,10 +246,12 @@ def parse_number(text: str) -> float | None:
 
 
 def parse_choice(text: str, options: list[str] | None = None) -> str | None:
-    """Strict choice extraction: \\boxed{} or <answer> tag only (no prose scraping).
+    """Extract an explicit choice without scraping arbitrary prose.
 
-    Order: \\boxed{} letter/option -> letter/option inside <answer>..</answer>.
-    Returns normalized letter (upper) or matched option text, else None.
+    Order: \\boxed{} -> <answer> -> leading option label -> explicit answer cue.
+    The two fallbacks accept unambiguous forms such as ``B) False``, a leading
+    bare ``B``, ``Final answer: B``, or ``Conclusion: B``. They deliberately do
+    not search for isolated letters elsewhere in prose.
     """
     boxed = extract_boxed(text)
     if boxed:
@@ -255,6 +270,27 @@ def parse_choice(text: str, options: list[str] | None = None) -> str | None:
             for opt in options:
                 if opt and opt.lower() in low:
                     return opt
+    leading = _LEADING_CHOICE_RE.match(text)
+    if leading:
+        return leading.group(1).upper()
+    explicit = list(_EXPLICIT_CHOICE_RE.finditer(text))
+    if explicit:
+        return explicit[-1].group(1).upper()
+    if options:
+        true_false_labels = {}
+        for option in options:
+            match = re.match(
+                r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s+)\s*"
+                r"(true|false)\b",
+                option,
+                re.IGNORECASE,
+            )
+            if match:
+                true_false_labels[match.group(2).lower()] = match.group(1).upper()
+        if len(true_false_labels) == 2:
+            tf_matches = list(_EXPLICIT_TRUE_FALSE_RE.finditer(text))
+            if tf_matches:
+                return true_false_labels[tf_matches[-1].group(1).lower()]
     return None
 
 

results/joint_sft/TSQA/_infer/score/schema.py

@@ -162,7 +162,20 @@ _BOXED_RE = re.compile(r"\\boxed\s*\{([^{}]*)\}")
 _ANSWER_RE = re.compile(r"<answer>\s*(.*?)\s*</answer>", re.DOTALL | re.IGNORECASE)
 _THINK_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 _NUM_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
-_LETTER_RE = re.compile(r"\b([A-Ea-e])\b")  # MCQ up to 5 options (EngineMT uses a-e)
+_LETTER_RE = re.compile(r"\b([A-Ha-h])\b")
+_LEADING_CHOICE_RE = re.compile(
+    r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s*(?=$|\n))"
+)
+_EXPLICIT_CHOICE_RE = re.compile(
+    r"(?is)(?:\*{0,2})(?:(?:final|correct)\s+)?"
+    r"(?:answer|option|choice|conclusion)(?:\*{0,2})\s*"
+    r"(?:is\s*[:：]?|[:：])\s*(?:\*{0,2})(?:option\s+)?"
+    r"\(?\s*([A-Ha-h])\b"
+)
+_EXPLICIT_TRUE_FALSE_RE = re.compile(
+    r"(?is)(?:answer|conclusion|statement)\s*(?:is\s*[:：]?|[:：])\s*"
+    r"(true|false)\b"
+)
 
 
 def answer_block(text: str) -> str:
@@ -233,10 +246,12 @@ def parse_number(text: str) -> float | None:
 
 
 def parse_choice(text: str, options: list[str] | None = None) -> str | None:
-    """Strict choice extraction: \\boxed{} or <answer> tag only (no prose scraping).
+    """Extract an explicit choice without scraping arbitrary prose.
 
-    Order: \\boxed{} letter/option -> letter/option inside <answer>..</answer>.
-    Returns normalized letter (upper) or matched option text, else None.
+    Order: \\boxed{} -> <answer> -> leading option label -> explicit answer cue.
+    The two fallbacks accept unambiguous forms such as ``B) False``, a leading
+    bare ``B``, ``Final answer: B``, or ``Conclusion: B``. They deliberately do
+    not search for isolated letters elsewhere in prose.
     """
     boxed = extract_boxed(text)
     if boxed:
@@ -255,6 +270,27 @@ def parse_choice(text: str, options: list[str] | None = None) -> str | None:
             for opt in options:
                 if opt and opt.lower() in low:
                     return opt
+    leading = _LEADING_CHOICE_RE.match(text)
+    if leading:
+        return leading.group(1).upper()
+    explicit = list(_EXPLICIT_CHOICE_RE.finditer(text))
+    if explicit:
+        return explicit[-1].group(1).upper()
+    if options:
+        true_false_labels = {}
+        for option in options:
+            match = re.match(
+                r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s+)\s*"
+                r"(true|false)\b",
+                option,
+                re.IGNORECASE,
+            )
+            if match:
+                true_false_labels[match.group(2).lower()] = match.group(1).upper()
+        if len(true_false_labels) == 2:
+            tf_matches = list(_EXPLICIT_TRUE_FALSE_RE.finditer(text))
+            if tf_matches:
+                return true_false_labels[tf_matches[-1].group(1).lower()]
     return None
 
 

results/joint_sft_14B/TSQA/_infer/score/schema.py

@@ -162,7 +162,20 @@ _BOXED_RE = re.compile(r"\\boxed\s*\{([^{}]*)\}")
 _ANSWER_RE = re.compile(r"<answer>\s*(.*?)\s*</answer>", re.DOTALL | re.IGNORECASE)
 _THINK_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 _NUM_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
-_LETTER_RE = re.compile(r"\b([A-Ea-e])\b")  # MCQ up to 5 options (EngineMT uses a-e)
+_LETTER_RE = re.compile(r"\b([A-Ha-h])\b")
+_LEADING_CHOICE_RE = re.compile(
+    r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s*(?=$|\n))"
+)
+_EXPLICIT_CHOICE_RE = re.compile(
+    r"(?is)(?:\*{0,2})(?:(?:final|correct)\s+)?"
+    r"(?:answer|option|choice|conclusion)(?:\*{0,2})\s*"
+    r"(?:is\s*[:：]?|[:：])\s*(?:\*{0,2})(?:option\s+)?"
+    r"\(?\s*([A-Ha-h])\b"
+)
+_EXPLICIT_TRUE_FALSE_RE = re.compile(
+    r"(?is)(?:answer|conclusion|statement)\s*(?:is\s*[:：]?|[:：])\s*"
+    r"(true|false)\b"
+)
 
 
 def answer_block(text: str) -> str:
@@ -233,10 +246,12 @@ def parse_number(text: str) -> float | None:
 
 
 def parse_choice(text: str, options: list[str] | None = None) -> str | None:
-    """Strict choice extraction: \\boxed{} or <answer> tag only (no prose scraping).
+    """Extract an explicit choice without scraping arbitrary prose.
 
-    Order: \\boxed{} letter/option -> letter/option inside <answer>..</answer>.
-    Returns normalized letter (upper) or matched option text, else None.
+    Order: \\boxed{} -> <answer> -> leading option label -> explicit answer cue.
+    The two fallbacks accept unambiguous forms such as ``B) False``, a leading
+    bare ``B``, ``Final answer: B``, or ``Conclusion: B``. They deliberately do
+    not search for isolated letters elsewhere in prose.
     """
     boxed = extract_boxed(text)
     if boxed:
@@ -255,6 +270,27 @@ def parse_choice(text: str, options: list[str] | None = None) -> str | None:
             for opt in options:
                 if opt and opt.lower() in low:
                     return opt
+    leading = _LEADING_CHOICE_RE.match(text)
+    if leading:
+        return leading.group(1).upper()
+    explicit = list(_EXPLICIT_CHOICE_RE.finditer(text))
+    if explicit:
+        return explicit[-1].group(1).upper()
+    if options:
+        true_false_labels = {}
+        for option in options:
+            match = re.match(
+                r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s+)\s*"
+                r"(true|false)\b",
+                option,
+                re.IGNORECASE,
+            )
+            if match:
+                true_false_labels[match.group(2).lower()] = match.group(1).upper()
+        if len(true_false_labels) == 2:
+            tf_matches = list(_EXPLICIT_TRUE_FALSE_RE.finditer(text))
+            if tf_matches:
+                return true_false_labels[tf_matches[-1].group(1).lower()]
     return None
 
 

results/ts-align-bk-joint-grpo-min2/TSQA/_infer/score/schema.py

@@ -162,7 +162,20 @@ _BOXED_RE = re.compile(r"\\boxed\s*\{([^{}]*)\}")
 _ANSWER_RE = re.compile(r"<answer>\s*(.*?)\s*</answer>", re.DOTALL | re.IGNORECASE)
 _THINK_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 _NUM_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
-_LETTER_RE = re.compile(r"\b([A-Ea-e])\b")  # MCQ up to 5 options (EngineMT uses a-e)
+_LETTER_RE = re.compile(r"\b([A-Ha-h])\b")
+_LEADING_CHOICE_RE = re.compile(
+    r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s*(?=$|\n))"
+)
+_EXPLICIT_CHOICE_RE = re.compile(
+    r"(?is)(?:\*{0,2})(?:(?:final|correct)\s+)?"
+    r"(?:answer|option|choice|conclusion)(?:\*{0,2})\s*"
+    r"(?:is\s*[:：]?|[:：])\s*(?:\*{0,2})(?:option\s+)?"
+    r"\(?\s*([A-Ha-h])\b"
+)
+_EXPLICIT_TRUE_FALSE_RE = re.compile(
+    r"(?is)(?:answer|conclusion|statement)\s*(?:is\s*[:：]?|[:：])\s*"
+    r"(true|false)\b"
+)
 
 
 def answer_block(text: str) -> str:
@@ -233,10 +246,12 @@ def parse_number(text: str) -> float | None:
 
 
 def parse_choice(text: str, options: list[str] | None = None) -> str | None:
-    """Strict choice extraction: \\boxed{} or <answer> tag only (no prose scraping).
+    """Extract an explicit choice without scraping arbitrary prose.
 
-    Order: \\boxed{} letter/option -> letter/option inside <answer>..</answer>.
-    Returns normalized letter (upper) or matched option text, else None.
+    Order: \\boxed{} -> <answer> -> leading option label -> explicit answer cue.
+    The two fallbacks accept unambiguous forms such as ``B) False``, a leading
+    bare ``B``, ``Final answer: B``, or ``Conclusion: B``. They deliberately do
+    not search for isolated letters elsewhere in prose.
     """
     boxed = extract_boxed(text)
     if boxed:
@@ -255,6 +270,27 @@ def parse_choice(text: str, options: list[str] | None = None) -> str | None:
             for opt in options:
                 if opt and opt.lower() in low:
                     return opt
+    leading = _LEADING_CHOICE_RE.match(text)
+    if leading:
+        return leading.group(1).upper()
+    explicit = list(_EXPLICIT_CHOICE_RE.finditer(text))
+    if explicit:
+        return explicit[-1].group(1).upper()
+    if options:
+        true_false_labels = {}
+        for option in options:
+            match = re.match(
+                r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s+)\s*"
+                r"(true|false)\b",
+                option,
+                re.IGNORECASE,
+            )
+            if match:
+                true_false_labels[match.group(2).lower()] = match.group(1).upper()
+        if len(true_false_labels) == 2:
+            tf_matches = list(_EXPLICIT_TRUE_FALSE_RE.finditer(text))
+            if tf_matches:
+                return true_false_labels[tf_matches[-1].group(1).lower()]
     return None
 
 

results/ts-align/TSQA/_infer/score/schema.py

@@ -162,7 +162,20 @@ _BOXED_RE = re.compile(r"\\boxed\s*\{([^{}]*)\}")
 _ANSWER_RE = re.compile(r"<answer>\s*(.*?)\s*</answer>", re.DOTALL | re.IGNORECASE)
 _THINK_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 _NUM_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
-_LETTER_RE = re.compile(r"\b([A-Ea-e])\b")  # MCQ up to 5 options (EngineMT uses a-e)
+_LETTER_RE = re.compile(r"\b([A-Ha-h])\b")
+_LEADING_CHOICE_RE = re.compile(
+    r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s*(?=$|\n))"
+)
+_EXPLICIT_CHOICE_RE = re.compile(
+    r"(?is)(?:\*{0,2})(?:(?:final|correct)\s+)?"
+    r"(?:answer|option|choice|conclusion)(?:\*{0,2})\s*"
+    r"(?:is\s*[:：]?|[:：])\s*(?:\*{0,2})(?:option\s+)?"
+    r"\(?\s*([A-Ha-h])\b"
+)
+_EXPLICIT_TRUE_FALSE_RE = re.compile(
+    r"(?is)(?:answer|conclusion|statement)\s*(?:is\s*[:：]?|[:：])\s*"
+    r"(true|false)\b"
+)
 
 
 def answer_block(text: str) -> str:
@@ -233,10 +246,12 @@ def parse_number(text: str) -> float | None:
 
 
 def parse_choice(text: str, options: list[str] | None = None) -> str | None:
-    """Strict choice extraction: \\boxed{} or <answer> tag only (no prose scraping).
+    """Extract an explicit choice without scraping arbitrary prose.
 
-    Order: \\boxed{} letter/option -> letter/option inside <answer>..</answer>.
-    Returns normalized letter (upper) or matched option text, else None.
+    Order: \\boxed{} -> <answer> -> leading option label -> explicit answer cue.
+    The two fallbacks accept unambiguous forms such as ``B) False``, a leading
+    bare ``B``, ``Final answer: B``, or ``Conclusion: B``. They deliberately do
+    not search for isolated letters elsewhere in prose.
     """
     boxed = extract_boxed(text)
     if boxed:
@@ -255,6 +270,27 @@ def parse_choice(text: str, options: list[str] | None = None) -> str | None:
             for opt in options:
                 if opt and opt.lower() in low:
                     return opt
+    leading = _LEADING_CHOICE_RE.match(text)
+    if leading:
+        return leading.group(1).upper()
+    explicit = list(_EXPLICIT_CHOICE_RE.finditer(text))
+    if explicit:
+        return explicit[-1].group(1).upper()
+    if options:
+        true_false_labels = {}
+        for option in options:
+            match = re.match(
+                r"^\s*\(?\s*([A-Ha-h])(?:\s*\)|\s*[.:\-]|\s+)\s*"
+                r"(true|false)\b",
+                option,
+                re.IGNORECASE,
+            )
+            if match:
+                true_false_labels[match.group(2).lower()] = match.group(1).upper()
+        if len(true_false_labels) == 2:
+            tf_matches = list(_EXPLICIT_TRUE_FALSE_RE.finditer(text))
+            if tf_matches:
+                return true_false_labels[tf_matches[-1].group(1).lower()]
     return None