深度研究 Agent 训练项目

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

{
  "messages": [
    {
      "role": "system",
      "content": "你是拓业智询顾问，需要使用工具进行研究..."
    },
    {
      "role": "user",
      "content": "2024年小微企业贷款有哪些最新政策？"
    },
    {
      "role": "assistant",
      "content": "<think>需要搜索最新政策文件</think>\n<tool_call>{\"name\":\"search\",\"arguments\":{\"query\":\"2024小微企业贷款政策\"}}</tool_call>"
    },
    {
      "role": "tool_response",
      "content": "[1] 国家金融监督管理总局发布《关于做好2024年普惠金融工作的通知》..."
    },
    {
      "role": "assistant",
      "content": "<think>已获取关键信息，整理答案</think>\n<tool_call>{\"name\":\"finish\",\"arguments\":{\"answer\":\"根据[1]，2024年主要政策包括...\"}}</tool_call>"
    }
  ],
  "metadata": {
    "industry": "finance",
    "question_type": "policy",
    "num_steps": 2,
    "tools_used": ["search", "finish"],
    "has_citation": true
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

原始权重 W (frozen)
     ↓
W + ΔW = W + B × A
         ↑
     LoRA 矩阵（可训练，参数量极少）

rank=16 意味着：
  A: [d_model × 16]
  B: [16 × d_model]
  总参数量 << W 的参数量

1
2
3
4

<think>
这里是模型的内部推理过程，分析当前需要做什么
</think>
<tool_call>{"name": "工具名", "arguments": {"参数名": "参数值"}}</tool_call>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

行业维度：
  finance       → 金融/贷款/保险
  catering      → 餐饮连锁/食品安全
  startup       → 创业/融资/股权
  smart_transport → 智慧交通/网约车/物流

问题类型维度：
  policy       → 政策查询（"有什么补贴"）
  market       → 市场分析（"行业规模如何"）
  competitor   → 竞争对手（"竞品有哪些优劣势"）
  calculation  → 数据计算（"回本周期是多少"）
  risk         → 风险评估（"有什么潜在风险"）
  expansion    → 扩张建议（"如何开拓新市场"）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

train_project/
├── .env.example          # API 密钥配置模板
├── requirements.txt      # Python 依赖
├── README.md
│
├── docs/
│   ├── 操作手册.md       # 完整操作流程
│   └── 脚本说明.md       # 每个脚本的详细说明
│
├── data/
│   └── train_v3_1200_merged_clean.jsonl  # 训练数据 (1140 条)
│
├── src/
│   ├── data/
│   │   ├── schema_v2.py         # 数据格式定义 + 验证函数
│   │   └── seed_questions_v2.py # 48 条种子问题
│   ├── train/
│   │   └── data_loader_v2.py    # Dataset 类 + 统计分析
│   ├── eval/
│   │   └── agent_runner.py      # 推理 + 工具执行
│   └── tools/
│       ├── tool_definitions.py  # 工具 JSON Schema 定义
│       └── tool_executor.py     # 工具真实 API 调用
│
└── scripts/
    ├── 00_verify_env.py              # 环境检查
    ├── 02_train.py                   # LoRA 训练主脚本
    ├── synthesize_trajectories_v3.py # 数据合成（多线程）
    ├── validate_data_v2.py           # 数据质量验证
    ├── quick_eval.py                 # 快速格式评测
    ├── full_eval.py                  # 综合评测
    ├── build_format_boost.py         # 格式增强数据集
    ├── normalize_toolcall_json.py    # 工具调用格式标准化
    ├── expand_seeds_with_llm.py      # 种子问题扩充
    └── build_before_after_judged_set.py # 训练前后对比分析

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 1. 复制并填写 API 密钥
cp .env.example .env
# 编辑 .env，填入：
# DASHSCOPE_API_KEY=sk-xxx   (阿里云 LLM)
# BOCHA_API_KEY=xxx           (博查搜索)
# JINA_API_KEY=xxx            (Jina 网页读取)

# 2. 安装依赖
pip install -r requirements.txt

# 3. 验证环境
python scripts/00_verify_env.py

1
2
3
4
5
6
7
8
9

# 多线程合成轨迹（8线程，生成300条）
python scripts/synthesize_trajectories_v3.py \
    --num_samples 300 \
    --threads 8 \
    --output data/my_trajectories.jsonl

# 验证数据
python scripts/validate_data_v2.py \
    --input data/my_trajectories.jsonl

1
2
3
4

python scripts/02_train.py \
    --model_path ./models/Qwen3-1.7B \
    --data_path data/train_v3_1200_merged_clean.jsonl \
    --output_dir ./runs/

1
2
3
4
5
6
7
8
9

# 快速格式评测（只看<think>和<tool_call>格式是否正确）
python scripts/quick_eval.py \
    --base_model ./models/Qwen3-1.7B \
    --lora_path ./runs/latest/

# 综合评测（格式+工具选择+答案质量）
python scripts/full_eval.py \
    --base_model ./models/Qwen3-1.7B \
    --lora_path ./runs/latest/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# src/train/data_loader_v2.py
class DeepResearchDatasetV2(Dataset):
    def __getitem__(self, idx):
        messages = self.data[idx]["messages"]

        # 拼接所有消息，但只对 assistant 的部分计算 loss
        input_ids = []
        labels = []

        for msg in messages:
            tokens = tokenize(msg["content"])
            input_ids.extend(tokens)

            if msg["role"] == "assistant":
                labels.extend(tokens)  # 计算 loss
            else:
                labels.extend([-100] * len(tokens))  # 忽略 loss

        return {"input_ids": input_ids, "labels": labels}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# src/tools/tool_executor.py
class ToolExecutor:
    def execute(self, tool_name, arguments):
        if tool_name == "search":
            # 调用博查搜索 API
            return self._bocha_search(arguments["query"])
        elif tool_name == "visit":
            # 调用 Jina Reader 抓取网页
            return self._jina_visit(arguments["url"])
        elif tool_name == "calculator":
            # 安全执行数学表达式
            return str(eval(arguments["expression"]))
        elif tool_name == "finish":
            return arguments["answer"]  # 直接返回答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# scripts/synthesize_trajectories_v3.py 核心逻辑
def generate_trajectory(seed_question):
    """用 teacher model 生成一条完整轨迹"""
    messages = [system_prompt, user_question]

    for step in range(max_steps):  # 最多 4 步
        # 让 teacher model 决定下一步动作
        response = call_llm(messages)

        # 解析工具调用
        tool_call = parse_tool_call(response)

        if tool_call["name"] == "finish":
            break  # 结束

        # 执行真实工具调用
        tool_result = executor.execute(tool_call)

        # 将结果加入对话历史
        messages.append({"role": "tool_response", "content": tool_result})

    return validate_and_format(messages)

1
2
3
4

if msg["role"] == "assistant":
    labels.extend(tokens)
else:
    labels.extend([-100] * len(tokens))

1
2

我需要先搜索相关信息。
<tool_call>{"name": "search", "arguments": {"query": "2024年餐饮行业政策"}}</tool_call>