[reward] fix: restore timeout in math_verify via ProcessPoolExecutor

verl/utils/reward_score/math_verify.py

@@ -12,34 +12,56 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import multiprocessing
+import threading
+from concurrent.futures import ProcessPoolExecutor
+from concurrent.futures import TimeoutError as FuturesTimeoutError
+
 try:
     from math_verify.errors import TimeoutException
-    from math_verify.grader import verify
-    from math_verify.parser import ExprExtractionConfig, LatexExtractionConfig, parse
 except ImportError:
+
+    class TimeoutException(Exception):
+        pass
+
     print("To use Math-Verify, please install it first by running `pip install math-verify`.")
 
-_GOLD_TARGETS = (LatexExtractionConfig(),)
-_PRED_TARGETS = (ExprExtractionConfig(), LatexExtractionConfig())
+_pool = None
+_pool_lock = threading.Lock()
 
 
-def compute_score(model_output: str, ground_truth: str, timeout_score: float = 0) -> float:
-    ret_score = 0.0
+def _get_pool():
+    global _pool
+    if _pool is None:
+        with _pool_lock:
+            if _pool is None:
+                _pool = ProcessPoolExecutor(max_workers=4, mp_context=multiprocessing.get_context("spawn"))
+    return _pool
 
-    # Wrap the ground truth in \boxed{} format for verification
+
+def _verify_in_subprocess(ground_truth_boxed: str, model_output: str) -> float:
+    """Run math_verify in a subprocess where signal.alarm() works."""
+    from math_verify.grader import verify
+    from math_verify.parser import ExprExtractionConfig, LatexExtractionConfig, parse
+
+    gold_targets = (LatexExtractionConfig(),)
+    pred_targets = (ExprExtractionConfig(), LatexExtractionConfig())
+
+    extracted_gold = parse(ground_truth_boxed, gold_targets)
+    extracted_pred = parse(model_output, pred_targets)
+    if extracted_gold and extracted_pred:
+        return max(1.0 if any(verify(g, p) for g in extracted_gold) else 0.0 for p in extracted_pred)
+    return 0.0
+
+
+def compute_score(model_output: str, ground_truth: str, timeout_score: float = 0, timeout: float = 30.0) -> float:
+    ret_score = 0.0
     ground_truth_boxed = "\\boxed{" + ground_truth + "}"
     try:
-        # Use parsing_timeout=None and timeout_seconds=None to disable
-        # signal.alarm() which crashes in non-main threads (Ray workers).
-        extracted_gold = parse(ground_truth_boxed, _GOLD_TARGETS, parsing_timeout=None)
-        extracted_pred = parse(model_output, _PRED_TARGETS, parsing_timeout=None)
-        if extracted_gold and extracted_pred:
-            ret_score = max(
-                1.0 if any(verify(g, p, timeout_seconds=None) for g in extracted_gold) else 0.0 for p in extracted_pred
-            )
-    except TimeoutException:
+        future = _get_pool().submit(_verify_in_subprocess, ground_truth_boxed, model_output)
+        ret_score = future.result(timeout=timeout)
+    except (FuturesTimeoutError, TimeoutException):
         ret_score = timeout_score
-    except Exception:
-        pass
-
+    except Exception as e:
+        print(f"Error in math_verify compute_score: {e}")
     return ret_score