Delete gaia_test.py

gaia_test.py

@@ -1,895 +0,0 @@
-"""
-测试脚本：支持 validation 和 test 数据集，支持全量、增量、混合三种模式
-- 全量模式（full）：不管文件是否存在，都删除重新开始
-- 增量模式（incremental）：如果文件存在则增量，不存在则全量执行
-- 混合模式（hybrid）：第一次时全量（文件不存在），后面就增量（文件存在）
-"""
-import argparse
-import json
-import os
-import re
-import time
-import traceback
-from collections import OrderedDict
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from threading import Lock
-
-import pandas as pd
-import requests
-from datasets import load_dataset
-from huggingface_hub import snapshot_download, hf_hub_download
-from pathlib import Path
-import shutil
-
-# --- 1. 配置区 ---
-BASE_URL = "http://localhost:5173/api/v1"
-CHAT_URL = f"{BASE_URL}/sessions/chat"
-UPLOAD_URL = f"{BASE_URL}/files"
-HEADERS = {"Authorization": "Bearer hawk_YhCZLQYqtPOwOiEyEgeCNdfAFAbrHtTUxQvRiaOInyekgVgE"}
-DATA_PATH = "./gaia_data"
-REQUEST_TIMEOUT = 1800
-MAX_CONCURRENT = 2
-
-file_lock = Lock()
-
-# 全局变量，根据 split 类型动态设置
-dataset = None
-OUTPUT_FILE = None
-SUBMISSION_FILE = None
-SPLIT_TYPE = None  # "validation" 或 "test"
-
-
-def check_and_download_dataset_files():
-    """
-    检查并下载完整的 GAIA 数据集文件到本地目录（包含 validation 和 test 的所有文件）
-    
-    Returns:
-        bool: 如果文件已存在或下载成功返回 True，否则返回 False
-    """
-    base_target_dir = Path(DATA_PATH) / "2023"
-    validation_dir = base_target_dir / "validation"
-    test_dir = base_target_dir / "test"
-    
-    # 检查两个目录是否都存在且有文件
-    validation_files = list(validation_dir.glob("*")) if validation_dir.exists() else []
-    test_files = list(test_dir.glob("*")) if test_dir.exists() else []
-    
-    if validation_files and test_files:
-        print(f"✅ 检测到数据集文件已存在")
-        print(f"   validation 文件数: {len(validation_files)}")
-        print(f"   test 文件数: {len(test_files)}")
-        return True
-    
-    # 需要下载数据集文件
-    print(f"📥 开始下载完整的 GAIA 数据集文件...")
-    print(f"   目标目录: {base_target_dir}")
-    
-    try:
-        # 创建基础目录
-        base_target_dir.mkdir(parents=True, exist_ok=True)
-        
-        # 下载完整数据集到临时目录，然后复制到目标目录
-        print("   步骤 1/4: 正在从 Hugging Face 下载完整数据集...")
-        print("   提示: 下载进度会显示在下方，请耐心等待...")
-        download_start = time.time()
-        
-        # 使用 snapshot_download 下载完整数据集
-        cache_dir = snapshot_download(
-            repo_id="gaia-benchmark/GAIA",
-            repo_type="dataset",
-            local_dir=None,  # 使用默认缓存目录
-            resume_download=True
-        )
-        
-        download_duration = time.time() - download_start
-        print(f"   ✅ 数据集下载完成，耗时 {download_duration:.2f} 秒")
-        
-        cache_path = Path(cache_dir)
-        source_2023_dir = cache_path / "2023"
-        
-        if not source_2023_dir.exists():
-            print(f"   ❌ 错误: 缓存目录中未找到 2023 目录")
-            return False
-        
-        # 复制 validation 和 test 目录
-        print("   步骤 2/4: 正在复制 validation 文件...")
-        validation_source = source_2023_dir / "validation"
-        if validation_source.exists():
-            if validation_dir.exists():
-                shutil.rmtree(validation_dir)
-            shutil.copytree(validation_source, validation_dir)
-            validation_count = len(list(validation_dir.glob("*")))
-            print(f"   ✅ validation 文件复制完成，共 {validation_count} 个文件")
-        else:
-            print(f"   ⚠️  警告: 未找到 validation 目录")
-        
-        print("   步骤 3/4: 正在复制 test 文件...")
-        test_source = source_2023_dir / "test"
-        if test_source.exists():
-            if test_dir.exists():
-                shutil.rmtree(test_dir)
-            shutil.copytree(test_source, test_dir)
-            test_count = len(list(test_dir.glob("*")))
-            print(f"   ✅ test 文件复制完成，共 {test_count} 个文件")
-        else:
-            print(f"   ⚠️  警告: 未找到 test 目录")
-        
-        print("   步骤 4/4: 数据集文件准备完成！")
-        print(f"   目标目录: {base_target_dir}")
-        return True
-        
-    except Exception as e:
-        print(f"   ❌ 下载数据集文件时出错: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def build_ordered_record(task_id, question, level, agent_answer, duration, has_file,
-                         session_id=None, attachment_name=None, ground_truth=None, is_correct=None):
-    """
-    按照固定顺序构建记录字典，确保字段��序一致
-
-    Args:
-        task_id: 任务ID
-        question: 问题
-        level: 难度级别
-        agent_answer: Agent答案
-        duration: 执行时长
-        has_file: 是否有文件
-        session_id: 会话 ID
-        attachment_name: 附件名称（如果有附件）
-        ground_truth: 标准答案（仅validation数据集）
-        is_correct: 是否正确（仅validation数据集）
-
-    Returns:
-        OrderedDict: 按固定顺序排列的记录
-    """
-    record = OrderedDict()
-    record["task_id"] = task_id
-    record["question"] = question
-    record["level"] = level
-    record["duration"] = duration
-    record["has_file"] = has_file
-    # attachment_name: 如果有值就写入（即使 agent 出错也应该写入）
-    # 只要 attachment_name 不是 None 且不是空字符串，就写入
-    if attachment_name and attachment_name.strip():
-        record["attachment_name"] = attachment_name
-    # session_id: 如果有值就写入（如果 agent 出错可能为 None，不写入是合理的）
-    if session_id:
-        record["session_id"] = session_id
-    record["agent_answer"] = agent_answer
-    # validation 数据集特有字段
-    if ground_truth is not None:
-        record["ground_truth"] = ground_truth
-    if is_correct is not None:
-        record["is_correct"] = is_correct
-
-    return record
-
-
-def load_existing_results():
-    """
-    加载已有的测试结果文件
-    返回: dict, task_id -> 完整记录字典
-    """
-    if not os.path.exists(OUTPUT_FILE):
-        return {}
-
-    results = {}
-    try:
-        with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
-            for line in f:
-                if not line.strip():
-                    continue
-                try:
-                    data = json.loads(line)
-                    task_id = data.get("task_id")
-                    if task_id:
-                        results[task_id] = data
-                except json.JSONDecodeError:
-                    continue
-        print(f"✅ 已加载 {len(results)} 条历史记录")
-    except Exception as e:
-        print(f"⚠️  加载历史记录时出错: {e}")
-        return {}
-
-    return results
-
-
-def update_result_in_file(task_id, new_record):
-    """
-    更新 jsonl 文件中指定 task_id 的记录
-    使用临时文件方式，确保线程安全
-    """
-    if not os.path.exists(OUTPUT_FILE):
-        # 如果文件不存在，直接写入
-        with file_lock:
-            with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
-                f.write(json.dumps(new_record, ensure_ascii=False) + "\n")
-        return
-
-    # 读取所有记录，更新指定记录，写回文件
-    with file_lock:
-        temp_file = OUTPUT_FILE + ".tmp"
-        updated = False
-
-        try:
-            with open(OUTPUT_FILE, "r", encoding="utf-8") as f_in, \
-                    open(temp_file, "w", encoding="utf-8") as f_out:
-                for line in f_in:
-                    if not line.strip():
-                        continue
-                    try:
-                        data = json.loads(line)
-                        if data.get("task_id") == task_id:
-                            # 更新这条记录
-                            f_out.write(json.dumps(new_record, ensure_ascii=False) + "\n")
-                            updated = True
-                        else:
-                            # 保持原记录
-                            f_out.write(line)
-                    except json.JSONDecodeError:
-                        continue
-
-                # 如果没找到要更新的记录，追加新记录
-                if not updated:
-                    f_out.write(json.dumps(new_record, ensure_ascii=False) + "\n")
-
-            # 替换原文件
-            os.replace(temp_file, OUTPUT_FILE)
-        except Exception as e:
-            # 如果出错，删除临时文件
-            if os.path.exists(temp_file):
-                os.remove(temp_file)
-            raise e
-
-
-def upload_file(local_path):
-    """上传文件并返回符合接口要求的 file_id 和 filename"""
-    try:
-        if not os.path.exists(local_path):
-            print(f"❌ 本地文件不存在: {local_path}")
-            return None
-
-        with open(local_path, 'rb') as f:
-            files = {'file': f}
-            response = requests.post(UPLOAD_URL, headers=HEADERS, files=files, timeout=60)
-            response.raise_for_status()
-            res_data = response.json()
-
-            if res_data.get("code") == 0:
-                file_info = res_data.get("data", {})
-                return {
-                    "file_id": file_info.get("file_id"),
-                    "filename": file_info.get("filename")
-                }
-            else:
-                print(f"❌ 上传接口返回错误: {res_data.get('msg')}")
-    except Exception as e:
-        print(f"❌ 文件上传异常 ({os.path.basename(local_path)}): {e}")
-    return None
-
-
-def extract_answer(text):
-    """从文本中提取答案"""
-    if not text:
-        return ""
-    pattern = r"(?si)<\s*answer\s*>\s*(.*?)\s*</\s*answer\s*>"
-    match = re.search(pattern, text)
-    if match:
-        ans = match.group(1).strip()
-        return re.sub(r'^["\']|["\']$', '', ans)
-    backup_pattern = r"(?i)answer\s*is[:：]\s*(.*)"
-    backup_match = re.search(backup_pattern, text)
-    if backup_match:
-        return backup_match.group(1).strip().rstrip('.')
-    lines = [l.strip() for l in text.strip().split('\n') if l.strip()]
-    return lines[-1] if lines else text.strip()
-
-
-def call_my_agent_safe(question, attachments=None, task_id=None):
-    """
-    发送对话请求，包含附件数组
-    
-    Args:
-        question: 问题内容
-        attachments: 附件列表
-        task_id: 任务ID，用于确保会话隔离
-    
-    Returns:
-        tuple: (parsed_answer, session_id, raw_content)
-    """
-    guided_prompt = (
-        f"{question}\n\n Important Requirement: \nprovide the final answer (the answer only, without explanation) inside the tags in the following format: <answer>your answer</answer>"
-    )
-
-    payload = {
-        "message": guided_prompt,
-        "streaming": False,
-        "attachments": attachments if attachments else [],
-        "recycle_sandbox": True,
-        # 明确指定创建新会话，避免会话内容混乱
-        # 如果 API 支持 session_id 参数，设置为 null 表示创建新会话
-        # 如果不支持，则不传递 session_id 参数（当前做法）
-    }
-    
-    # 如果 API 支持，可以尝试以下方式之一来确保创建新会话：
-    # 1. payload["session_id"] = None  # 明确创建新会话
-    # 2. payload["new_session"] = True  # 如果 API 支持此参数
-    # 3. 在请求头中添加唯一标识
-    
-    if task_id:
-        # 添加 task_id 作为请求标识，帮助后端区分不同请求，确保会话隔离
-        payload["task_id"] = task_id
-    
-    # 在请求头中添加唯一标识，进一步确保请求隔离
-    # 如果后端支持，可以通过 X-Request-ID 或类似头部来区分请求
-    request_headers = HEADERS.copy()
-    if task_id:
-        # 添加 task_id 到请求头，帮助后端识别和隔离不同请求
-        request_headers["X-Task-ID"] = task_id
-
-    try:
-        response = requests.post(CHAT_URL, headers=request_headers, json=payload, timeout=(30, REQUEST_TIMEOUT))
-        response.raise_for_status()
-        res_data = response.json()
-        raw_content = (res_data.get("answer") or res_data.get("content") or res_data.get("response") or "").strip()
-        session_id = res_data.get("session_id")
-        parsed_answer = extract_answer(raw_content)
-        return parsed_answer, session_id, raw_content
-    except Exception as e:
-        error_traceback = traceback.format_exc()
-        return f"ERROR: {str(e)}", session_id, error_traceback
-
-
-def process_item(item, existing_results, mode):
-    """
-    处理单条数据：上传文件 -> 发起对话 -> 记录结果
-    hybrid + validation 模式下：如果记录已存在且 is_correct 为 true，则跳过 agent 调用，只刷新字段顺序
-    其他情况：所有记录都重新执行并刷新，确保字段顺序一致
-    （test 数据集没有 is_correct 字段，无法判断是否正确，所以总是重新执行）
-
-    Args:
-        item: 数据集项
-        existing_results: 已有结果字典
-        mode: 执行模式 ("full"、"incremental" 或 "hybrid")
-    """
-    task_id = item['task_id']
-    level = item.get('Level', 'Unknown')
-    question = item['Question']
-    file_name = item.get('file_name', "")
-
-    # hybrid + validation 模式下：如果记录已存在且成功，只刷新字段顺序，不调用 agent
-    # 只有 validation 数据集有 is_correct 字段，可以判断是否正确
-    if mode == "hybrid" and SPLIT_TYPE == "validation" and task_id in existing_results:
-        existing_record = existing_results[task_id]
-        if existing_record.get("is_correct", False):
-            # 已成功，只刷新字段顺序，不调用 agent
-            # 使用当前的 file_name 更新 attachment_name，确保数据一致性
-            current_has_file = bool(file_name)
-            current_attachment_name = file_name if file_name else None
-            record = build_ordered_record(
-                task_id=task_id,
-                question=existing_record.get("question", question),
-                level=existing_record.get("level", level),
-                agent_answer=existing_record.get("agent_answer", ""),
-                duration=existing_record.get("duration", 0),
-                has_file=current_has_file,
-                session_id=existing_record.get("session_id"),
-                attachment_name=current_attachment_name,
-                ground_truth=existing_record.get("ground_truth", ""),
-                is_correct=True
-            )
-            # 更新已有记录（刷新字段顺序）
-            update_result_in_file(task_id, record)
-            return task_id, True, "refreshed"
-
-    # 需要调用 agent 的情况（新记录、错误记录、或非 hybrid 模式）
-    attachments = []
-
-    # 1. 如果有文件，先执行上传
-    if file_name:
-        # 根据 split 类型选择不同的文件夹
-        folder = "validation" if SPLIT_TYPE == "validation" else "test"
-        local_file_path = os.path.abspath(os.path.join(DATA_PATH, "2023", folder, file_name))
-        upload_data = upload_file(local_file_path)
-        if upload_data:
-            attachments.append(upload_data)
-
-    # 2. 调用 Agent（传递 task_id 确保会话隔离）
-    start_time = time.time()
-    agent_answer, session_id, _ = call_my_agent_safe(question, attachments, task_id=task_id)
-    duration = time.time() - start_time
-
-    # 3. 构建记录（使用固定顺序）
-    if SPLIT_TYPE == "validation":
-        # validation 数据集：添加标准答案和正确性判断
-        ground_truth = str(item['Final answer']).strip()
-        clean_agent = str(agent_answer).lower().rstrip('.')
-        clean_gt = ground_truth.lower().rstrip('.')
-        is_correct = (clean_agent == clean_gt)
-        record = build_ordered_record(
-            task_id=task_id,
-            question=question,
-            level=level,
-            duration=round(duration, 2),
-            has_file=bool(file_name),
-            session_id=session_id,
-            attachment_name=file_name if file_name else None,
-            agent_answer=agent_answer,
-            ground_truth=ground_truth,
-            is_correct=is_correct
-        )
-        result_correct = is_correct
-    else:  # test 数据集：没有标准答案
-        record = build_ordered_record(
-            task_id=task_id,
-            question=question,
-            level=level,
-            duration=round(duration, 2),
-            has_file=bool(file_name),
-            session_id=session_id,
-            attachment_name=file_name if file_name else None,
-            agent_answer=agent_answer
-        )
-        result_correct = None
-
-    # 4. 更新或追加记录
-    if task_id in existing_results:
-        # 更新已有记录
-        update_result_in_file(task_id, record)
-        return task_id, result_correct, "updated"
-    else:
-        # 追加新记录
-        with file_lock:
-            with open(OUTPUT_FILE, "a", encoding="utf-8") as f:
-                f.write(json.dumps(record, ensure_ascii=False) + "\n")
-        return task_id, result_correct, "new"
-
-
-def generate_submission():
-    """
-    生成官网提交格式文件
-    GAIA 提交格式要求：
-    - 文件格式：JSONL（每行一个 JSON 对象）
-    - 必需字段：task_id, model_answer
-    - 编码：UTF-8
-    - test 数据集需要包含所有 285 个用例的答案
-    """
-    if not os.path.exists(OUTPUT_FILE):
-        print(f"⚠️  警告：结果文件 {OUTPUT_FILE} 不存在，无法生成提交文件")
-        return
-
-    # 读取所有结果并按 task_id 排序（确保顺序一致）
-    results = []
-    with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
-        for line in f:
-            if not line.strip():
-                continue
-            try:
-                data = json.loads(line)
-                if "task_id" in data and "agent_answer" in data:
-                    results.append(data)
-            except json.JSONDecodeError:
-                continue
-
-    if not results:
-        print(f"⚠️  警告：结果文件 {OUTPUT_FILE} 中没有有效数据")
-        return
-
-    # 按 task_id 排序，确保顺序一致
-    results.sort(key=lambda x: x.get("task_id", ""))
-
-    # 生成提交文件
-    with open(SUBMISSION_FILE, "w", encoding="utf-8") as f_out:
-        for data in results:
-            submission_data = {
-                "task_id": data["task_id"],
-                "model_answer": str(data["agent_answer"])
-            }
-            f_out.write(json.dumps(submission_data, ensure_ascii=False) + "\n")
-
-    print(f"✅ 提交文件已生成: {SUBMISSION_FILE} (共 {len(results)} 条记录)")
-
-    # test 数据集验证：检查是否包含所有用例
-    if SPLIT_TYPE == "test":
-        expected_count = 285
-        if len(results) < expected_count:
-            print(f"⚠️  警告：test 数据集应该有 {expected_count} 个用例，当前只有 {len(results)} 个")
-        else:
-            print(f"✅ test 数据集已包含 {len(results)} 个用例，符合提交要求")
-
-
-def get_current_accuracy():
-    """
-    获取当前的整体正确率（仅 validation 数据集）
-    
-    Returns:
-        float or None: 正确率（百分比），如果不是 validation 数据集或文件不存在则返回 None
-    """
-    # test 数据集没有标准答案，无法计算正确率
-    if SPLIT_TYPE != "validation":
-        return None
-    
-    if not os.path.exists(OUTPUT_FILE):
-        return None
-    
-    try:
-        results = []
-        with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
-            for line in f:
-                if not line.strip():
-                    continue
-                try:
-                    data = json.loads(line)
-                    results.append(data)
-                except json.JSONDecodeError:
-                    continue
-        
-        if not results:
-            return None
-        
-        total = len(results)
-        correct = sum(1 for r in results if r.get("is_correct", False))
-        accuracy = (correct / total * 100) if total > 0 else 0.0
-        return accuracy
-    except Exception:
-        return None
-
-
-def generate_report():
-    """生成统计成绩单（仅 validation 数据集有标准答案，才生成成绩单）"""
-    # test 数据集没有标准答案，不生成成绩单
-    if SPLIT_TYPE != "validation":
-        return
-
-    if not os.path.exists(OUTPUT_FILE):
-        return
-
-    results = [json.loads(line) for line in open(OUTPUT_FILE, "r", encoding="utf-8")]
-    df = pd.DataFrame(results)
-    total = len(df)
-    acc = (df['is_correct'].sum() / total) * 100
-
-    print("\n" + "=" * 50)
-    print(f"测试完成! 总数: {total} | 总准确率: {acc:.2f}%")
-    print("=" * 50)
-
-
-def run_test_concurrent(num_questions=200, mode="hybrid", split="validation", threads=MAX_CONCURRENT, target_task_id=None):
-    """
-    测试主函数
-
-    Args:
-        num_questions: 要执行的用例数量
-        mode: 执行模式
-            - "full": 全量模式，不管文件是否存在，都删除重新开始
-            - "incremental": 增量模式，如果文件存在则增量，不存在则全量执行
-            - "hybrid": 混合模式，第一次时全量（文件不存在），后面就增量（文件存在）
-            - "error": 错误模式，只重新执行 agent_answer 包含 ERROR 的记录
-        split: 数据集类型，"validation" 或 "test"
-        threads: 并发线程数
-        target_task_id: 可选，指定要运行的 task_id，如果指定则只运行该用例
-    """
-    global dataset, OUTPUT_FILE, SUBMISSION_FILE, SPLIT_TYPE
-
-    # 设置全局变量
-    SPLIT_TYPE = split
-
-    # 根据 split 类型设置输出文件名
-    if split == "validation":
-        OUTPUT_FILE = "validation_results.jsonl"
-        SUBMISSION_FILE = "validation_submission.jsonl"
-        print("📥 正在检查 GAIA 验证集数据...")
-    else:  # test
-        OUTPUT_FILE = "test_results.jsonl"
-        SUBMISSION_FILE = "test_submission.jsonl"
-        print("📥 正在检查 GAIA 测试集数据...")
-
-    # 1. 检查并下载完整数据集文件（如果需要，包含 validation 和 test 的所有文件）
-    print("\n【步骤 1/2】检查数据集文件...")
-    check_and_download_dataset_files()
-    
-    # 2. 加载数据集元数据（如果首次下载会显示下载进度）
-    print(f"\n【步骤 2/2】加载数据集元数据...")
-    print(f"   数据集: gaia-benchmark/GAIA (2023_all, split={split})")
-    print("   提示: 如果是首次下载，请耐心等待，下载进度会显示在下方...")
-    print("   如果已下载过，会直接从缓存加载，速度较快")
-    start_time = time.time()
-    dataset = load_dataset("gaia-benchmark/GAIA", "2023_all", split=split)
-    load_duration = time.time() - start_time
-    print(f"✅ 数据集元数据加载完成！共 {len(dataset)} 条记录，耗时 {load_duration:.2f} 秒\n")
-
-    # 1. 根据模式处理已有结果
-    file_exists = os.path.exists(OUTPUT_FILE)
-
-    if mode == "full":
-        # 全量模式：删除旧文件，从头开始
-        if file_exists:
-            os.remove(OUTPUT_FILE)
-            print("🔄 全量模式：已删除旧结果文件，从头开始执行")
-        existing_results = {}
-    elif mode == "incremental":
-        # 增量模式：如果文件存在则增量，不存在则全量执行
-        if file_exists:
-            existing_results = load_existing_results()
-            print(f"📋 增量模式：已加载 {len(existing_results)} 条历史记录")
-        else:
-            existing_results = {}
-            print("📋 增量模式：未找到历史记录，将全量执行")
-    elif mode == "error":
-        # 错误模式：只重新执行 agent_answer 包含 ERROR 的记录
-        if file_exists:
-            existing_results = load_existing_results()
-            print(f"📋 错误模式：已加载 {len(existing_results)} 条历史记录，将重新执行包含 ERROR 的记录")
-        else:
-            existing_results = {}
-            print("📋 错误模式：未找到历史记录，无法执行错误重试")
-    else:  # hybrid
-        # 混合模式：第一次时全量（文件不存在），后面就增量（文件存在）
-        if file_exists:
-            existing_results = load_existing_results()
-            print(f"📋 混合模式：检测到已有文件，进入增量模式（已加载 {len(existing_results)} 条历史记录）")
-        else:
-            existing_results = {}
-            print("📋 混合模式：首次执行，进入全量模式")
-
-    # 2. 筛选需要执行的用例
-    if target_task_id:
-        # 如果指定了 task_id，只运行该用例
-        print(f"🎯 指定运行 task_id: {target_task_id}")
-        tasks_to_run = []
-        found = False
-        for item in dataset:
-            if item['task_id'] == target_task_id:
-                tasks_to_run = [item]
-                found = True
-                break
-        if not found:
-            print(f"❌ 错误: 在 {split} 数据集中未找到 task_id: {target_task_id}")
-            return
-        num_to_run = 1
-    else:
-        # 正常模式，根据 num_questions 筛选
-        num_to_run = min(num_questions, len(dataset))
-        tasks_to_run = dataset.select(range(num_to_run))
-
-    # 统计需要执行的用例
-    tasks_to_execute = []
-    refresh_count = 0  # hybrid 模式下只刷新字段顺序的记录数
-    update_count = 0  # 需要重新调用 agent 的记录数
-    new_count = 0  # 新记录数
-    error_count = 0  # error 模式下包含 ERROR 的记录数
-
-    for item in tasks_to_run:
-        task_id = item['task_id']
-
-        if mode == "error":
-            # error 模式：只重新执行 agent_answer 包含 ERROR 的记录
-            if task_id in existing_results:
-                agent_answer = existing_results[task_id].get("agent_answer", "")
-                if agent_answer and "ERROR" in str(agent_answer):
-                    error_count += 1
-                    tasks_to_execute.append(item)
-            # 如果记录不存在或 agent_answer 不包含 ERROR，则跳过
-        else:
-            # 其他模式：正常处理
-            if task_id in existing_results:
-                # hybrid + validation 模式下：如果已成功，只刷新字段顺序
-                # test 数据集没有 is_correct 字段，无法判断是否正确，所以总是重新执行
-                if mode == "hybrid" and split == "validation":
-                    if existing_results[task_id].get("is_correct", False):
-                        refresh_count += 1
-                    else:
-                        update_count += 1
-                else:
-                    # 非 hybrid 模式，或 test 数据集：所有已有记录都需要重新执行
-                    update_count += 1
-            else:
-                new_count += 1
-            tasks_to_execute.append(item)
-
-    total_to_execute = len(tasks_to_execute)
-
-    print(f"\n📊 统计信息:")
-    print(f"   数据集: {split}")
-    print(f"   执行模式: {mode}")
-    if target_task_id:
-        print(f"   指定 task_id: {target_task_id}")
-    print(f"   总用例数: {num_to_run}")
-    if existing_results:
-        if mode == "error":
-            print(f"   需要执行: {total_to_execute} (包含 ERROR 的记录: {error_count})")
-        elif mode == "hybrid":
-            print(
-                f"   需要执行: {total_to_execute} (新用例: {new_count}, 刷新字段顺序: {refresh_count}, 重新测试: {update_count})")
-        else:
-            print(
-                f"   需要执行: {total_to_execute} (新用例: {new_count}, 刷新已有记录: {refresh_count + update_count})")
-    else:
-        print(f"   需要执行: {total_to_execute} (全量执行)")
-    print(f"🚀 开始测试 | 并发数: {threads} | 待执行: {total_to_execute}")
-
-    if total_to_execute == 0:
-        if mode == "error":
-            print("✅ 没有包含 ERROR 的记录，无需执行")
-        elif split == "validation":
-            print("✅ 所有用例已完成且正确，无需执行")
-        else:
-            print("✅ 所有用例已完成，无需执行")
-        generate_report()
-        generate_submission()
-        return
-
-    # 3. 并发执行
-    with ThreadPoolExecutor(max_workers=threads) as executor:
-        future_to_item = {executor.submit(process_item, item, existing_results, mode): item for item in
-                          tasks_to_execute}
-
-        done = 0
-        for future in as_completed(future_to_item):
-            done += 1
-            item = future_to_item[future]
-            tid = item['task_id']
-            try:
-                _, is_ok, status = future.result()
-                if status == "refreshed":
-                    status_icon = "🔄"
-                elif split == "validation":
-                    status_icon = "✅" if is_ok else "❌"
-                else:  # test
-                    status_icon = "✅"
-                
-                # 计算并显示当前整体正确率
-                accuracy_info = ""
-                if split == "validation":
-                    current_accuracy = get_current_accuracy()
-                    if current_accuracy is not None:
-                        accuracy_info = f" | 当前正确率: {current_accuracy:.2f}%"
-                
-                print(f"[{done}/{total_to_execute}] ID: {tid} | 状态: {status_icon} ({status}){accuracy_info}")
-            except Exception as e:
-                error_traceback = traceback.format_exc()
-                print(f"[{done}/{total_to_execute}] ID: {tid} 运行异常: {e}")
-                print(f"异常堆栈:\n{error_traceback}")
-
-    # 4. 生成报表
-    generate_report()
-    generate_submission()
-
-
-def print_help():
-    """打印详细的帮助信息"""
-    print("=" * 70)
-    print("GAIA 测试脚本 - 参数说明")
-    print("=" * 70)
-    print()
-    print("用法:")
-    print("  python gaia_test.py [参数]")
-    print()
-    print("参数说明:")
-    print()
-    print("  --split <类型>")
-    print("      数据集类型")
-    print("      可选值: validation, test")
-    print("      默认值: validation")
-    print("      说明:")
-    print("        - validation: 验证集，有标准答案，可以计算正确率")
-    print("        - test: 测试集，无标准答案，用于最终提交")
-    print()
-    print("  --mode <模式>")
-    print("      执行模式")
-    print("      可选值: full, incremental, hybrid, error")
-    print("      默认值: hybrid")
-    print("      说明:")
-    print("        - full: 全量模式，删除旧结果文件，从头开始执行")
-    print("        - incremental: 增量模式，如果文件存在则增量，不存在则全量执行")
-    print("        - hybrid: 混合模式（推荐），首次全量，后续增量")
-    print("                  在 hybrid 模式下，validation 数据集中已正确的记录")
-    print("                  只刷新字段顺序，不重新调用 agent")
-    print("        - error: 错误模式，只重新执行 agent_answer 包含 ERROR 的记录")
-    print()
-    print("  --num <数量>")
-    print("      要执行的用例数量")
-    print("      类型: 整数")
-    print("      默认值: 200")
-    print("      说明:")
-    print("        - test 数据集共 285 题，可以设置 --num 285 执行全部")
-    print("        - validation 数据集可以根据需要设置数量")
-    print()
-    print("  --threads <数量>")
-    print("      并发执行的线程数")
-    print("      类型: 整数")
-    print("      默认值: 2")
-    print("      说明:")
-    print("        - 根据服务器性能调整，过高可能导致服务器压力过大")
-    print("        - 建议范围: 1-4")
-    print()
-    print("  --task-id <task_id>")
-    print("      指定要运行的 task_id")
-    print("      类型: 字符串")
-    print("      默认值: 无（运行多个用例）")
-    print("      说明:")
-    print("        - 如果指定此参数，则只运行该 task_id 对应的用例")
-    print("        - 指定此参数时，--num 参数会被忽略")
-    print("        - 如果指定的 task_id 不存在，脚本会报错并退出")
-    print()
-    print("  -h, --help")
-    print("      显示此帮助信息并退出")
-    print()
-    print("示例:")
-    print("  # 使用默认参数（validation 数据集，hybrid 模式，200 题）")
-    print("  python gaia_test.py")
-    print()
-    print("  # 测试 test 数据集，执行全部 285 题")
-    print("  python gaia_test.py --split test --num 285")
-    print()
-    print("  # 使用 error 模式重新执行错误记录")
-    print("  python gaia_test.py --mode error")
-    print()
-    print("  # 使用全量模式，4 个并发线程")
-    print("  python gaia_test.py --mode full --threads 4")
-    print()
-    print("  # 运行指定的 task_id")
-    print("  python gaia_test.py --task-id c61d22de-5f6c-4958-a7f6-5e9707bd3466")
-    print()
-    print("=" * 70)
-    print("配置文件:")
-    print("  运行前请确保已正确配置 gaia_test.py 中的以下参数:")
-    print("    - BASE_URL: API 服务地址")
-    print("    - HEADERS: 认证 Token（必须修改）")
-    print("    - DATA_PATH: 数据文件路径")
-    print("    - REQUEST_TIMEOUT: 请求超时时间")
-    print("    - MAX_CONCURRENT: 最大并发数")
-    print("=" * 70)
-
-
-if __name__ == "__main__":
-    import sys
-    
-    # 检查是否有 -h 或 --help 参数
-    if "-h" in sys.argv or "--help" in sys.argv:
-        print_help()
-        sys.exit(0)
-    
-    parser = argparse.ArgumentParser(
-        description="GAIA 测试脚本（支持 validation 和 test 数据集，支持全量、增量、混合三种模式）",
-        formatter_class=argparse.RawDescriptionHelpFormatter
-    )
-    parser.add_argument(
-        "--split",
-        type=str,
-        choices=["validation", "test"],
-        default="validation",
-        help="数据集类型: 'validation' 验证集（有标准答案）、'test' 测试集（无标准答案，默认: validation）"
-    )
-    parser.add_argument(
-        "--mode",
-        type=str,
-        choices=["full", "incremental", "hybrid", "error"],
-        default="hybrid",
-        help="执行模式: 'full' 全量模式（删除旧文件重新执行）、'incremental' 增量模式（文件存在则增量，不存在则全量）、'hybrid' 混合模式（首次全量，后续增量，默认）、'error' 错误模式（只重新执行 agent_answer 包含 ERROR 的记录）"
-    )
-    parser.add_argument(
-        "--num",
-        type=int,
-        default=200,
-        help="要执行的用例数量（默认: 200，test 集共 285 题）"
-    )
-    parser.add_argument(
-        "--threads",
-        type=int,
-        default=MAX_CONCURRENT,
-        help="执行的并发数（默认: 2）"
-    )
-    parser.add_argument(
-        "--task-id",
-        type=str,
-        default=None,
-        help="指定要运行的 task_id，如果指定则只运行该用例（忽略 --num 参数）"
-    )
-
-    args = parser.parse_args()
-
-    run_test_concurrent(num_questions=args.num, mode=args.mode, split=args.split, threads=args.threads, target_task_id=args.task_id)