import logging import re import time from typing import Dict, Any, Optional, Union from internbootcamp.bootcamp.base import Basebootcamp from internbootcamp.libs.bbeh_multistep_arithmetic.bbeh_arithmetic_generator import BBEHArithmeticGenerator from internbootcamp.libs.bbeh_multistep_arithmetic.bbeh_arithmetic_solver import BBEHArithmeticSolver from internbootcamp.libs.bbeh_multistep_arithmetic.bbeh_arithmetic_validor import BBEHArithmeticVerifier def print_section(title: str, char: str = "=") -> None: """打印带有分隔线的章节标题""" width = 80 print(f"\n{char * width}") print(f"{title.center(width)}") print(f"{char * width}\n") def format_statistics(stats: Dict) -> str: """格式化统计信息""" output = [] output.append("总体统计:") output.append(f" 总测试案例: {stats['total_cases']}") output.append(f" 正确答案数: {stats['correct_answers']}") output.append(f" 总体成功率: {stats['success_rate']}%") output.append("\n按难度分类:") for diff in ['easy', 'medium', 'hard']: diff_stats = stats['by_difficulty'][diff] output.append( f" {diff.capitalize()}: {diff_stats['correct']}/{diff_stats['total']} ({diff_stats['success_rate']})") output.append("\n按表达式长度分类:") for length in ['short', 'medium', 'long']: length_stats = stats['by_expression_length'][length] output.append( f" {length.capitalize()}: {length_stats['correct']}/{length_stats['total']} ({length_stats['success_rate']})") output.append("\n运算符使用统计:") for op, op_stats in stats['by_operator'].items(): output.append(f" {op}: {op_stats['correct']}/{op_stats['total']} ({op_stats['success_rate']})") return "\n".join(output) def format_statistics(stats: Dict) -> str: """格式化统计信息""" output = [] output.append("总体统计:") output.append(f" 总测试案例: {stats['total_cases']}") output.append(f" 正确答案数: {stats['correct_answers']}") output.append(f" 总体成功率: {stats['success_rate']}%") output.append("\n按难度分类:") for diff in ['easy', 'medium', 'hard']: diff_stats = stats['by_difficulty'][diff] output.append( f" {diff.capitalize()}: {diff_stats['correct']}/{diff_stats['total']} ({diff_stats['success_rate']})") output.append("\n按表达式长度分类:") for length in ['short', 'medium', 'long']: length_stats = stats['by_expression_length'][length] output.append( f" {length.capitalize()}: {length_stats['correct']}/{length_stats['total']} ({length_stats['success_rate']})") output.append("\n运算符使用统计:") for op, op_stats in stats['by_operator'].items(): output.append(f" {op}: {op_stats['correct']}/{op_stats['total']} ({op_stats['success_rate']})") return "\n".join(output) class BBEHMultistepArithmeticV2bootcamp(Basebootcamp): # 继承Basebootcamp类以保持一致 verifier = BBEHArithmeticVerifier() def __init__(self, difficulty: str = "medium", timeout: int = 30, language: str = "zh"): """ 初始化BBEH算术训练场系统 Args: difficulty: 难度级别 ("easy", "medium", "hard") timeout: 求解超时时间（秒） language: 语言选择 ("en", "zh") """ self.generator = BBEHArithmeticGenerator() self.solver = BBEHArithmeticSolver() self.difficulty = difficulty self.timeout = timeout self.language = language self.logger = logging.getLogger(__name__) self.verification_details = {} # 添加验证详情存储 def case_generator(self, max_attempts: int = 5) -> Dict: """生成一个新的算术表达式案例""" # print(f"[开始] 生成{self.difficulty}难度的算术表达式") # print("-" * 40) for attempt in range(max_attempts): try: # print(f"[尝试 {attempt + 1}/{max_attempts}]") start_time = time.time() case = self.generator.generate_case(difficulty=self.difficulty) # 设置超时保护 solution = None while time.time() - start_time < self.timeout: solution = self.solver.solve(case["expression"]) if solution is not None: break time.sleep(0.1) if solution is None: # print("⚠️ 求解超时，重试中...") continue # 构建完整的案例 case["solution"] = solution case["language"] = self.language # generation_time = time.time() - start_time # print(f"✓ 成功生成表达式 (用时: {generation_time:.2f}s)") # print("-" * 40) return case except Exception as e: # print(f"❌ 错误: {str(e)}") # print("重试中...") continue # print("⚠️ 达到最大尝试次数，使用备用表达式") return self._generate_fallback_case() def prompt_func(self, identity: Dict) -> str: """生成提示文本""" if self.language == "zh": # 中文提示 statements = [ f"""你是一位精通算术的智能助手。请计算以下算术表达式： {identity['expression']} 表达式使用标准算术运算符 (+, -, *, /) 和自定义运算符 (><, ;, @, <>, [], #, !, ~, &, :, ][)。 自定义运算符说明： - >< 表示取最大值，例如：a >< b = max(a, b) - ; 表示连接，例如：a ; b = a * 10^(数字b的位数) + b - @ 表示平均值，例如：a @ b = (a + b) / 2 - <> 表示交换，例如：a <> b = b * 10^(数字a的位数) + a - [] 表示绝对差，例如：a [] b = |a - b| - # 表示取模，例如：a # b = a % b - ! 表示阶乘，例如：a ! = a的阶乘 - ~ 表示取反，例如：a ~ b = -a + b - & 表示数字和，例如：a & b = 各位数字之和 - : 表示乘方，例如：a : b = a^b - ][ 表示最小公倍数，例如：a ][ b = lcm(a, b) 其中，one=1, two=2, three=3, four=4, five=5, six=6, seven=7, eight=8, nine=9, ten=10 请提供准确的计算结果，以小数形式表示。 请仔细思考每一步计算，确保结果的精确性。""" ] else: # 英文提示 statements = [ f"""You are an intelligent assistant specialized in arithmetic. Please calculate the following arithmetic expression: {identity['expression']} The expression uses standard arithmetic operators (+, -, *, /) and custom operators (><, ;, @, <>, [], #, !, ~, &, :, ][). Custom operators explanation: - >< means maximum, e.g.: a >< b = max(a, b) - ; means concatenation, e.g.: a ; b = a * 10^(number of digits in b) + b - @ means average, e.g.: a @ b = (a + b) / 2 - <> means swap, e.g.: a <> b = b * 10^(number of digits in a) + a - [] means absolute difference, e.g.: a [] b = |a - b| - # means modulo, e.g.: a # b = a % b - ! means factorial, e.g.: a ! = factorial of a - ~ means negation, e.g.: a ~ b = -a + b - & means digit sum, e.g.: a & b = sum of all digits - : means power, e.g.: a : b = a^b - ][ means least common multiple, e.g.: a ][ b = lcm(a, b) Where one=1, two=2, three=3, four=4, five=5, six=6, seven=7, eight=8, nine=9, ten=10 Please provide the exact calculation result in decimal form. Think through each step carefully to ensure accuracy.""" ] instruction_following = """\nLet's think step by step and output the final answer with the following format: Final-answer: ```json 42.5 ```""" return statements[0] + instruction_following @classmethod def _verify_correction(cls, output: int, identity: Dict) -> float: """验证答案并评分""" try: if output is None: # print("❌ 错误: 无法从输出中提取答案") return 0.0 # 验证答案 # expected_answer = identity.get('solution', identity.get('answer')) is_correct = cls.verifier.verify_answer(identity, output) return is_correct except Exception as e: # print(f"❌ 错误: 验证过程中出现异常: {str(e)}") return 0.0 @classmethod def extract_output(cls, output: str) -> Optional[float]: """从输出中提取答案""" try: # 查找Python代码块 pattern = r"```json\s*([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)\s*```" match = re.search(pattern, output) if not match: # 尝试查找任何数字 pattern = r"Final-answer:.*?([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)" match = re.search(pattern, output) if not match: return None # 转换为浮点数 return float(match.group(1)) except (ValueError, AttributeError) as e: return None def _generate_fallback_case(self) -> Dict: """生成一个简单的后备案例""" expression = "(2 + 3) * 4" # 简单且保证可解的表达式 answer = 20.0 return { "expression": expression, "answer": answer, "solution": answer, "difficulty": "easy", "language": self.language, "is_fallback": True } def _count_operators(self, expression: str) -> Dict[str, int]: """统计表达式中的运算符使用情况""" operators = { '+': 0, '-': 0, '*': 0, '/': 0, '><': 0, ';': 0, '@': 0, '<>': 0, '[]': 0, '#': 0, '!': 0, '~': 0, '&': 0, ':': 0, '][': 0 } i = 0 while i < len(expression): # 检查两字符运算符 if i + 1 < len(expression): two_char = expression[i:i + 2] if two_char in operators: operators[two_char] += 1 i += 2 continue # 检查单字符运算符 if expression[i] in operators: operators[expression[i]] += 1 i += 1 return {op: count for op, count in operators.items() if count > 0} def get_statistics(self) -> Dict[str, Any]: """获取统计信息""" return self.verifier.get_statistics() def reset_statistics(self) -> None: """重置统计信息""" self.verifier.reset_statistics() def set_language(self, language: str) -> None: """设置语言""" if language in ["en", "zh"]: self.language = language else: raise ValueError("不支持的语言。请使用 'en' 或 'zh'。") def set_difficulty(self, difficulty: str) -> None: """设置难度级别""" if difficulty in ["easy", "medium", "hard"]: self.difficulty = difficulty else: raise ValueError("不支持的难度级别。请使用 'easy', 'medium', 或 'hard'。") def set_timeout(self, timeout: int) -> None: """设置超时时间""" if timeout > 0: self.timeout = timeout else: raise ValueError("超时时间必须为正数。") if __name__ == "__main__": # 设置日志 logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) try: print_section("BBEH算术表达式求解器") # 创建训练场实例 print_section("初始化系统", "-") bootcamp = BBEHMultistepArithmeticV2bootcamp( difficulty="medium", timeout=30, language="zh" ) print("✓ 系统初始化完成") # 生成测试案例 print_section("生成测试案例", "-") case = bootcamp.case_generator() print("生成的表达式:") print(f" 难度: {case['difficulty'].upper()}") print(f" 表达式: {case['expression']}") print(f" 预期答案: {case['solution']}") # 获取提示文本 print_section("生成提示文本", "-") prompt = bootcamp.prompt_func(case) print(prompt) # 测试答案验证 print_section("答案验证测试", "-") # 测试正确答案 print("[测试1] 验证正确答案") correct_output = f"Final-answer: ```json\n{case['solution']}\n```" score = bootcamp.verify_score(correct_output, case, short_penalty=False) print(f"验证结果: {'✓ 通过' if score == 1.0 else '✗ 失败'}") print(f"得分: {score}\n") # 测试错误答案 print("[测试2] 验证错误答案") wrong_output = f"Final-answer: ```json\n{case['solution']+1}\n```" score = bootcamp.verify_score(wrong_output, case, short_penalty=False) print(f"验证结果: {'✓ 通过' if score == 0.0 else '✗ 失败'}") print(f"得分: {score}") # 测试不同难度 print_section("不同难度测试", "-") for difficulty in ["easy", "medium", "hard"]: print(f"\n[{difficulty.upper()}]") bootcamp.set_difficulty(difficulty) case = bootcamp.case_generator() print(f"表达式: {case['expression']}") print(f"答案: {case['solution']}") # 获取统计信息 print_section("统计信息", "-") stats = bootcamp.get_statistics() print(format_statistics(stats)) # 测试总结 print_section("测试完成", "=") print(f"总测试用例数: {stats['total_cases']}") print(f"成功用例数: {stats['correct_answers']}") print(f"总体成功率: {stats['success_rate']}%") except Exception as e: logger.error(f"测试过程中出现错误: {str(e)}")