Update math_verifier.py

math_verifier.py

@@ -11,7 +11,6 @@ class MathReward:
         Args:
             use_reference_comparison: 是否使用参考答案进行推理过程比较
         """
-        # 编译正则表达式，强制要求 <think> 在前，<answer> 在后
         self.format_pattern = re.compile(r"<think>(.*?)</think>\s*<answer>(.*?)</answer>", re.DOTALL)
         self.use_reference_comparison = use_reference_comparison
         
@@ -58,7 +57,7 @@ class MathReward:
             # 匹配 浮点数 或 整数，忽略可能混杂的文字
             matches = re.findall(r"[-+]?\d*\.\d+|\d+", clean_text)
             if matches:
-                # 取最后一个作为最终答案（通常答案在最后）
+                # 取最后一个作为最终答案
                 return float(matches[-1])
                 
         except Exception as e:
@@ -77,28 +76,25 @@ class MathReward:
         
         quality_score = 0.0
         
-        # 1. 长度检查（基础）
+        # 长度检查
         length = len(think_content)
         if length >= 100:
             quality_score += 0.3
         elif length >= 50:
             quality_score += 0.15
         
-        # 2. 关键词检查（推理步骤标识）
+        # 关键词检查
         keyword_count = sum(1 for kw in self.reasoning_keywords if kw in think_content)
-        # 每出现一个关键词加分，最多加0.3分
         quality_score += min(keyword_count * 0.05, 0.3)
         
-        # 3. 数学表达式检查（是否包含计算过程）
-        # 匹配数学运算符或等式
+        # 数学表达式检查
         math_expressions = re.findall(r'\d+\s*[+\-*/×÷=]\s*\d+', think_content)
         if len(math_expressions) > 0:
             quality_score += 0.2
-            # 多个表达式说明推理更详细
             if len(math_expressions) >= 3:
                 quality_score += 0.1
         
-        # 4. 结构检查（是否有步骤分隔）
+        # 结构检查
         has_steps = bool(re.search(r'第\d+步|步骤\d+|^\d+[.、]', think_content, re.MULTILINE))
         if has_steps:
             quality_score += 0.1
@@ -114,8 +110,7 @@ class MathReward:
         """
         if not generated_reasoning or not reference_reasoning:
             return 0.0
-        
-        # 使用 difflib 的 SequenceMatcher 计算相似度
+
         similarity = SequenceMatcher(None, generated_reasoning, reference_reasoning).ratio()
         
         return similarity
@@ -137,77 +132,52 @@ class MathReward:
         
         for completion, gt in zip(completions, ground_truths):
             total_reward = 0.0
-            
-            # --- 1. 格式与结构检查 ---
             match = self.format_pattern.search(completion)
             
-            # 如果没有匹配到 <think>...</think><answer>...</answer> 结构
             if match is None:
-                # 格式严重错误，给予重罚
                 rewards.append(-2.0)
                 continue
-            
-            # 提取内容
+
             think_content = match.group(1).strip()
             answer_content = match.group(2).strip()
-            
-            # 格式正确的基础分
             total_reward += 0.6
-            
-            # --- 2. 思考过程质量检查 ---
             reasoning_quality = self.check_reasoning_quality(think_content)
             
             if reasoning_quality < 0.3:
-                # 推理过程质量太低（可能是敷衍或格式化）
                 total_reward -= 0.5
             else:
-                # 推理质量越高，奖励越多
-                total_reward += reasoning_quality * 1.0  # 最多1.0分
-            
-            # --- 3. 推理过程与参考对比（如果有参考） ---
+                total_reward += reasoning_quality * 1.0  
+
             if self.use_reference_comparison and 'reasoning' in gt:
                 reference_reasoning = gt['reasoning']
                 similarity = self.compute_reasoning_similarity(think_content, reference_reasoning)
-                
-                # 相似度奖励（最多0.5分）
-                # 注意：不要求完全一致，因为可能有多种正确推理方式
+
                 if similarity > 0.3:
                     total_reward += similarity * 0.5
             
-            # --- 4. 答案准确性检查（最重要） ---
+            #答案准确性检查---
             pred_val = self.parse_number(answer_content)
             gt_val = gt['answer_val']
             
             if pred_val is not None:
-                # 数值比较，允许 float 精度误差
                 if math.isclose(pred_val, gt_val, rel_tol=1e-4, abs_tol=1e-4):
-                    # 答对给予最高奖励
                     total_reward += 3.0
                 else:
-                    # 答错扣分
-                    # 根据误差大小调整惩罚
                     try:
                         relative_error = abs(pred_val - gt_val) / (abs(gt_val) + 1e-8)
                         if relative_error < 0.1:
-                            # 接近正确答案，轻微惩罚
                             total_reward -= 0.3
                         elif relative_error < 0.5:
-                            # 有一定误差
                             total_reward -= 0.8
                         else:
-                            # 完全错误
                             total_reward -= 1.5
                     except:
                         total_reward -= 1.5
             else:
-                # <answer> 标签内提取不到有效数字
                 total_reward -= 1.0
             
-            # --- 5. 一致性检查：推理过程中的数字应该与答案相关 ---
-            # 提取推理过程中出现的所有数字
             reasoning_numbers = re.findall(r'[-+]?\d*\.\d+|\d+', think_content)
             if reasoning_numbers and pred_val is not None:
-                # 检查答案是否出现在推理过程中
                 answer_in_reasoning = any(
                     math.isclose(float(num), pred_val, rel_tol=1e-3, abs_tol=1e-3)
                     for num in reasoning_numbers
@@ -220,17 +190,11 @@ class MathReward:
         return rewards
     
     def compute_metrics(self, completions, ground_truths):
-        """
-        计算详细的评估指标（用于分析）
-        
-        Returns:
-            dict: 包含各种指标的字典
-        """
         metrics = {
             'format_correct': 0,
             'reasoning_quality_avg': 0.0,
             'answer_correct': 0,
-            'answer_close': 0,  # 答案接近但不完全正确
+            'answer_close': 0,  
             'total': len(completions)
         }
         
@@ -245,11 +209,8 @@ class MathReward:
                 think_content = match.group(1).strip()
                 answer_content = match.group(2).strip()
                 
-                # 推理质量
                 quality = self.check_reasoning_quality(think_content)
                 quality_scores.append(quality)
-                
-                # 答案准确性
                 pred_val = self.parse_number(answer_content)
                 gt_val = gt['answer_val']
                 
@@ -262,7 +223,6 @@ class MathReward:
         if quality_scores:
             metrics['reasoning_quality_avg'] = sum(quality_scores) / len(quality_scores)
         
-        # 计算百分比
         metrics['format_correct_pct'] = metrics['format_correct'] / metrics['total'] * 100
         metrics['answer_correct_pct'] = metrics['answer_correct'] / metrics['total'] * 100
         metrics['answer_close_pct'] = metrics['answer_close'] / metrics['total'] * 100