┌─────────────────────────────────────────────────────────┐
│                    FunReason Framework                   │
├─────────────────────────────────────────────────────────┤
│                                                          │
│  ┌──────────────────────┐    ┌──────────────────────┐  │
│  │   FCDR Pipeline      │───▶│   SRML Training      │  │
│  │  (数据质量保证)        │    │  (训练优化方法)        │  │
│  └──────────────────────┘    └──────────────────────┘  │
│           ▲                            │                │
│           │                            ▼                │
│           └────── Self-Refinement ──────┘               │
│                   (迭代提升)                             │
└─────────────────────────────────────────────────────────┘

# 原始xLAM数据集的典型问题

问题类型1: CoT推理错误
User: "查询北京明天的天气"
CoT: <think>用户想查天气，应该调用get_news函数...</think>  # ❌ 逻辑跳跃
Result: [get_news(city="北京")]  # ❌ 函数选错

问题类型2: 参数错误
User: "发邮件给张三"
Result: [send_email(to="张三")]  # ❌ 应该是邮箱地址

问题类型3: 格式错误
Result: [get_weather('city'="北京")]  # ❌ 参数名不应加引号

统计发现 (Table 1):
CoT部分平均token:    350.74 (中位数248)
Result部分平均token:   31.07 (中位数27)
比例: 约 11:1

影响: 传统SFT会让模型"夸夸其谈但执行不准"

                    ┌──────────────┐
                    │ 输入：xLAM-cot│
                    └───────┬──────┘
                            │
                    ┌───────▼──────────┐
                    │ Stage 1: 是FC吗? │
                    └───────┬──────────┘
                            │ Yes
                    ┌───────▼──────────────┐
                    │ Stage 2: 能用工具解决?│
                    └───────┬──────────────┘
                            │ Yes
                    ┌───────▼──────────────┐
                    │ Stage 3: CoT推理对吗?│
                    └───────┬──────────────┘
                            │ Yes
                    ┌───────▼──────────────┐
                    │ Stage 4: 函数名参数对?│◄─┐
                    └───────┬──────────────┘  │
                            │ Yes              │Regenerate
                    ┌───────▼──────────────┐  │
                    │ Stage 5: 格式对吗?   │──┘
                    └───────┬──────────────┘
                            │ Yes
                    ┌───────▼──────────────┐
                    │ 保存到FCDR数据集     │
                    └──────────────────────┘

注: Stage 1-3不通过 → Drop
    Stage 4-5不通过 → Regenerate

# Prompt结构（简化版）
prompt = f"""
判断以下内容是function_tool调用还是普通回复：
常见格式：[func_name(param1=value1, param2=value2)]

输入：{reference_answer}
输出：<think>...</think><judge>True/False</judge>
"""

# QwQ-32B处理
response = qwq_model.generate(prompt)
is_function_call = parse_judge_tag(response)

if not is_function_call:
    save_as_dialogue_data()  # 保存为普通对话数据
    return

输入1: "[get_weather(city='北京')]"
输出: <think>符合function call格式</think><judge>True</judge>

输入2: "今天北京天气不错，温度15度"
输出: <think>这是普通回复</think><judge>False</judge>

def check_query_tool_match(query, tools, reference_answer):
    """
    检查三个关键点：
    1. 工具列表中是否有相关功能的函数
    2. 查询中是否包含足够的参数信息
    3. 参数值能否从query中提取
    """

    prompt = f"""
    分析以下内容：
    1. 函数名能从候选工具中找到吗？
    2. 参数值能从查询中分析出来吗？

    User Query: {query}
    Candidate Tools: {tools}
    Reference Answer: {reference_answer}

    输出：<think>...</think><judge>True/False</judge>
    """

    result = qwq_model.generate(prompt)
    return parse_judge(result)

Query: "查北京天气"
Tools: [get_weather(city, date), send_email(to, content)]
Reference: [get_weather(city="北京")]
→ ✅ 工具有get_weather，参数city能从query提取

Query: "帮我订机票"
Tools: [get_weather(city), send_email(to, content)]
Reference: [book_flight(from, to, date)]
→ ❌ 工具列表中没有订票功能 → Drop

Query: "发邮件"
Tools: [send_email(to, content)]
Reference: [send_email(to="unknown@example.com", content="...")]
→ ❌ query中没有收件人信息，reference硬编码了地址 → Drop

def verify_cot_quality(cot, reference_fc):
    """
    1. 起点检查：推理是否从合理的位置开始
    2. 步骤检查：每一步是否紧密跟随上一步
    3. 终点检查：最后一步是否指向正确答案
    """

    checks = {
        'start_valid': check_reasoning_start(cot),
        'steps_coherent': check_step_connections(cot),
        'conclusion_correct': check_final_step(cot, reference_fc)
    }

    return all(checks.values())

Query: "检索一个长度至少7个字符的动词变位词"
CoT:
<think>
1. 用户需要一个词，所以要调用词典相关函数
2. 要求是"动词变位"，参数verbeconjugue应该为True
3. 要求"长度至少7"，参数minlong应该设为'7'
4. 需要定义，参数avecdef设为True
→ 应该调用get_random_word函数
</think>
Reference: [get_random_word(verbeconjugue=True, minlong='7', avecdef=True)]

验证结果:
✅ 起点：从"用户需要词"开始，合理
✅ 连贯：每步都基于上一步和需求推进
✅ 终点：正确导出函数和所有参数
→ Pass

Query: "查北京天气"
CoT:
<think>
1. 用户想知道天气
2. 应该搜索新闻
3. 调用get_news函数
</think>
Reference: [get_news(city="北京")]

验证结果:
✅ 起点：从"天气"开始，合理
❌ 连贯：步骤2跳跃到"新闻"，逻辑断裂
❌ 终点：导出了错误函数
→ Drop

def verify_and_fix_function(query, tools, reference_fc):
    """
    1. 函数名是否在tools中？
    2. 参数名是否匹配函数定义？
    3. 参数值类型是否正确？
    4. 参数值是否合理？
    """

    prompt = f"""
    检查function call的函数名和参数:
    1. 函数名是否正确？
    2. 参数是否都有效？

    若有问题，生成修正后的function call。

    Query: {query}
    Tools: {tools}
    Reference FC: {reference_fc}

    输出:
    <think>...</think>
    <judge>True/False</judge>
    <NewFC>[修正后的函数调用]</NewFC>
    """

    response = qwq_model.generate(prompt)
    is_valid, corrected_fc = parse_response(response)

    return corrected_fc if not is_valid else reference_fc

Reference: [get_weather(location="北京")]
Tools定义: get_weather(city: str, date: str)

QwQ-32B分析:
<think>
工具定义中参数名是city，不是location
应该修正为city
</think>
<judge>False</judge>
<NewFC>[get_weather(city="北京")]</NewFC>

→ 自动修正并保存

Reference: [set_alarm(time=8)]
Tools定义: set_alarm(time: str)  # 要求格式"HH:MM"

QwQ-32B分析:
<think>
time参数应该是字符串格式"08:00"
当前是整数8，需要转换
</think>
<judge>False</judge>
<NewFC>[set_alarm(time="08:00")]</NewFC>

→ 修正类型并保存

Reference: [get_weather(city="北京")]
Tools定义: get_weather(city: str, date: str = "today")

QwQ-32B分析:
<think>
date是可选参数，有默认值"today"
当前未提供date，但有默认值可用
可以接受
</think>
<judge>True</judge>

→ 直接通过

# 正确格式规范
CORRECT_FORMAT = """
[func_name(param_name=param_value, ...)]

关键规则:
1. 参数名(param_name)不加引号
2. 字符串参数值(param_value)加双引号
3. 数字/布尔值不加引号
4. 多个函数用逗号分隔
"""

# 常见错误格式
WRONG_FORMATS = [
    '[func("param_name"="value")]',      # ❌ 参数名加了引号
    "[func(param_name='value')]",        # ❌ 应该用双引号
    '[func(param_name=value)]',          # ❌ 字符串值漏了引号
]

输入:
[getPrivacyViolationRisk("data"="personal_info", "purpose"="marketing")]

QwQ-32B修正:
<think>
参数名data和purpose不应该加引号
参数值是字符串，保留双引号
</think>
<judge>False</judge>
<NewFC>[getPrivacyViolationRisk(data="personal_info", purpose="marketing")]</NewFC>

→ 修正保存

输入:
[get_weather(city='北京', date='today')]

QwQ-32B修正:
<think>
应该统一使用双引号
</think>
<judge>False</judge>
<NewFC>[get_weather(city="北京", date="today")]</NewFC>

→ 修正保存

输入:
[set_volume(level="50")]

QwQ-32B修正:
<think>
level是数字类型，不应该加引号
</think>
<judge>False</judge>
<NewFC>[set_volume(level=50)]</NewFC>

→ 修正保存

GPT-4o:
✅ 推理能力强
❌ 闭源，无法完全控制
❌ API调用成本高（60K样本 × 5阶段）

Claude-3.5:
✅ 推理能力强
❌ 闭源
❌ 成本高

QwQ-32B:
✅ 开源可控
✅ 推理能力足够（见Table 2: 78.70%）
✅ 可本地部署（vLLM）
✅ 成本可控

# 1. 明确的输出格式要求
prompt_template = """
<think>思考过程</think>
<judge>True/False</judge>
<NewFC>[修正结果]</NewFC>  # 仅Stage 4-5需要
"""

# 2. 具体的评判标准
"""
✅ 给出正面和负面示例
✅ 列出明确的检查点
✅ 说明边界情况处理
"""

# 3. 结构化的输入
"""
分块提供：Query、Tools、Reference
使用标签：<query>、<tools>、<refFC>

Judge whether the function names and parameters meet requirements:

1) Check if function names and parameter values are correct
2) If valid, output <judge>True</judge>
3) If invalid, output <judge>False</judge> and provide corrected version

Output format:
<think>analysis process</think>
<judge>True/False</judge>
<NewFC>[corrected_function_call]</NewFC>

Input:
User query: <query>查北京天气</query>
Candidate tools: <tools>
{
  "get_weather": {
    "parameters": {
      "city": {"type": "string", "required": true},
      "date": {"type": "string", "default": "today"}
    }
  }
}
</tools>
Reference FC: <refFC>[get_weather(location="北京")]</refFC>

class FCDRPipeline:
    def __init__(self, model="QwQ-32B"):
        self.model = load_model(model)
        self.stats = {
            'input': 0,
            'stage1_drop': 0,
            'stage2_drop': 0,
            'stage3_drop': 0,
            'stage4_regenerate': 0,
            'stage5_regenerate': 0,
            'output': 0
        }

    def process(self, data):
        self.stats['input'] = len(data)

        # Stage 1: Response Identification
        data = [d for d in data if self.stage1(d)]
        self.stats['stage1_drop'] = self.stats['input'] - len(data)

        # Stage 2: Query & Tool Identification
        data = [d for d in data if self.stage2(d)]
        self.stats['stage2_drop'] = self.stats['input'] - len(data)

        # Stage 3: CoT Identification
        data = [d for d in data if self.stage3(d)]
        self.stats['stage3_drop'] = self.stats['input'] - len(data)

        # Stage 4: Function & Parameter (with regenerate)
        data = [self.stage4_fix(d) for d in data]

        # Stage 5: Format (with regenerate)
        data = [self.stage5_fix(d) for d in data]

        self.stats['output'] = len(data)
        return data

    def report(self):
        print(f"""
        输入: {self.stats['input']}
        Stage 1 丢弃: {self.stats['stage1_drop']}
        Stage 2 丢弃: {self.stats['stage2_drop']}
        Stage 3 丢弃: {self.stats['stage3_drop']}
        Stage 4 修正: {self.stats['stage4_regenerate']}
        Stage 5 修正: {self.stats['stage5_regenerate']}
        最终输出: {self.stats['output']}
        保留率: {self.stats['output']/self.stats['input']*100:.1f}%
        """)

输入: 60,000 samples (xLAM-cot)

Stage 1: ~2% drop     → 58,800 samples
Stage 2: ~5% drop     → 55,860 samples  
Stage 3: ~8% drop     → 51,391 samples
Stage 4: ~10% regen   → 51,391 samples (修正约5,139个)
Stage 5: ~5% regen    → 51,391 samples (修正约2,570个)

最终输出: ~60,000 samples (FunReason-FCDR)
注：Stage 4-5修正后补齐到60K

# 一个典型的训练样本
sample = {
    "think": "<think>...</think>",  # 350 tokens
    "result": "[func()]"             # 31 tokens
}

# 传统Cross-Entropy Loss
total_tokens = 350 + 31 = 381
L_total = (1/381) × Σ[-log P(token)]

# 问题：350个"think" tokens的loss贡献远大于31个"result" tokens
# 导致梯度更新主要优化推理部分，而函数调用部分被"淹没"

传统SFT隐含权重:
w_think = N_think / N_all = 350 / 381 ≈ 0.92
w_result = N_result / N_all = 31 / 381 ≈ 0.08

影响:
- 模型学会生成"看起来合理"的长推理
- 但对函数调用的准确性关注不足
- 类似于"夸夸其谈但不办实事"

L_total = (1/N_all) × Σ[i=1 to N_all] -log P(y_i | y_<i, x)

L_total = (1/N_all) × [
    Σ[i=1 to N_t] -log P(y_i | y_<i, x)           # Think部分
    + Σ[i=N_t+1 to N_all] -log P(y_i | y_<i, x)   # Result部分
]

L_total = (N_t/N_all) × (1/N_t) × Σ[i=1 to N_t] -log P(...)
        + (N_f/N_all) × (1/N_f) × Σ[i=N_t+1 to N_all] -log P(...)

       = w_t × L_think + w_f × L_result

L_MSL = α × L_think + β × L_result

约束: α + β = 1, α,β ∈ [0,1]

传统SFT: 权重由数据决定 (α≈0.92, β≈0.08)
SRML:    权重由设计者决定 (α可调节)

∂L_MSL/∂θ_think = α × ∂L_think/∂θ

传统SFT: 系数为 0.92
SRML:    系数为 α (可调，通常0.5-0.7)

∂L_MSL/∂θ_result = β × ∂L_result/∂θ

传统SFT: 系数为 0.08
SRML:    系数为 β (可调，通常0.3-0.5)

α=0.1: 67.5%  # β太大，过度关注result，推理不足
α=0.2: 69.0%
α=0.3: 70.5%
α=0.4: 71.2%
α=0.5: 71.8%  # ← 最优点
α=0.6: 71.7%
α=0.7: 71.5%
α=0.8: 70.0%
α=0.9: 68.5%  # 接近传统SFT，result权重过低

α=0.1: 65.0%
α=0.3: 68.0%
α=0.5: 71.5%  # ← 最优点
α=0.7: 71.0%
α=0.9: 67.0%

传统SFT隐含α值：0.92
FunReason最优α值：0.5-0.7

改进幅度：
Qwen: 68.5% → 71.8% (+3.3%)
Llama: 67.0% → 71.5% (+4.5%)

def recommend_alpha(N_think_mean, N_result_mean):
    """
    基于token统计推荐α值
    """
    ratio = N_think_mean / N_result_mean  # xLAM约为11:1

    if ratio > 10:
        # 极度不平衡，需要大幅调整
        alpha = 0.5
    elif ratio > 5:
        # 中度不平衡
        alpha = 0.6
    else:
        # 轻度不平衡
        alpha = 0.7

    return alpha

# xLAM case
alpha = recommend_alpha(350.74, 31.07)  # 返回 0.5

import torch
import torch.nn as nn

class MultiscaleLoss(nn.Module):
    def __init__(self, alpha=0.5):
        super().__init__()
        self.alpha = alpha
        self.beta = 1 - alpha
        self.ce_loss = nn.CrossEntropyLoss(reduction='none')

    def forward(self, logits, labels, think_mask):
        """
        Args:
            logits: [batch, seq_len, vocab_size]
            labels: [batch, seq_len]
            think_mask: [batch, seq_len] # 1表示think部分，0表示result
        """
        # 计算逐token的loss
        token_loss = self.ce_loss(
            logits.view(-1, logits.size(-1)), 
            labels.view(-1)
        ).view(labels.size())

        # 分离think和result的loss
        think_loss = (token_loss * think_mask).sum() / think_mask.sum()
        result_loss = (token_loss * (1-think_mask)).sum() / (1-think_mask).sum()

        # 多尺度加权
        total_loss = self.alpha * think_loss + self.beta * result_loss

        return total_loss, {
            'think_loss': think_loss.item(),
            'result_loss': result_loss.item(),
            'total_loss': total_loss.item()
        }

# 使用示例
loss_fn = MultiscaleLoss(alpha=0.5)
loss, metrics = loss_fn(logits, labels, think_mask)

def create_mask_from_tokens(input_ids, tokenizer):
    """
    假设格式: <think>...</think>\n[func()]
    """
    think_start_id = tokenizer.convert_tokens_to_ids('<think>')
    think_end_id = tokenizer.convert_tokens_to_ids('</think>')

    mask = torch.zeros_like(input_ids)
    in_think = False

    for i, token_id in enumerate(input_ids):
        if token_id == think_start_id:
            in_think = True
        elif token_id == think_end_id:
            in_think = False

        if in_think:
            mask[i] = 1

    return mask

def create_mask_from_positions(seq_len, think_end_pos):
    """
    think_end_pos: CoT结束位置
    """
    mask = torch.zeros(seq_len)
    mask[:think_end_pos] = 1  # 前think_end_pos个token为think
    return mask

def train_with_srml(model, dataloader, alpha=0.5, epochs=3):
    loss_fn = MultiscaleLoss(alpha=alpha)
    optimizer = torch.optim.AdamW(model.parameters(), lr=4e-5)

    for epoch in range(epochs):
        for batch in dataloader:
            # 前向传播
            logits = model(batch['input_ids'])

            # 计算SRML loss
            loss, metrics = loss_fn(
                logits, 
                batch['labels'], 
                batch['think_mask']
            )

            # 反向传播
            loss.backward()
            optimizer.step()
            optimizer.zero_grad()

            # 记录metrics
            if step % 100 == 0:
                print(f"Epoch {epoch}, Step {step}")
                print(f"  Think Loss: {metrics['think_loss']:.4f}")
                print(f"  Result Loss: {metrics['result_loss']:.4f}")
                print(f"  Total Loss: {metrics['total_loss']:.4f}")

┌──────────────────────────────────────────────────┐
│              Self-Refinement Loop                │
└──────────────────────────────────────────────────┘

Round 0: 初始训练
  xLAM原始数据 → [用QwQ生成CoT] → xLAM-cot
  ↓
  [FCDR清洗] → FunReason-FCDR-60K
  ↓
  [SRML训练] → Model_v1

Round 1: 自我精炼
  xLAM原始数据 → [Model_v1生成CoT] → Model_v1-cot
  ↓
  [FCDR清洗] → FunReason-FCDR-v2
  ↓
  [SRML训练] → Model_v2

Round 2+: 持续迭代
  ...可以继续，但论文只做了1轮

1. 初始模型已经学会基本的function calling
2. 让模型生成 → 暴露模型的弱点
3. FCDR识别并修正 → 针对性改进
4. 再次训练 → 强化正确行为

类比: 学生做题 → 老师批改 → 学生订正 → 再次练习

Qwen2.5-Coder-7B:
- 初始训练(FCDR-SFT):  81.94%
- +SRML:                83.66% (+1.72%)
- +Self-Refinement:     (论文未单独测试，但整体pipeline有效)

def self_refinement_loop(base_model, xlam_data, num_rounds=2):
    """
    自我精炼训练循环
    """
    current_model = base_model

    for round_idx in range(num_rounds):
        print(f"\n=== Self-Refinement Round {round_idx} ===")

        # Step 1: 用当前模型生成CoT
        cot_data = []
        for sample in xlam_data:
            cot = current_model.generate_cot(
                query=sample['query'],
                tools=sample['tools']
            )
            cot_data.append({
                'query': sample['query'],
                'tools': sample['tools'],
                'cot': cot,
                'reference': sample['answer']
            })

        # Step 2: FCDR清洗
        fcdr_pipeline = FCDRPipeline()
        refined_data = fcdr_pipeline.process(cot_data)
        print(f"FCDR保留率: {len(refined_data)/len(cot_data)*100:.1f}%")

        # Step 3: SRML训练
        current_model = train_with_srml(
            model=current_model,
            data=refined_data,
            alpha=0.5,
            epochs=3
        )

        # Step 4: 评估
        score = evaluate_on_bfcl(current_model)
        print(f"Round {round_idx} BFCL Score: {score:.2f}%")

    return current_model

FCDR: 提供高质量数据 → 减少噪声
SRML: 平衡优化目标 → 提高效率

1 + 1 > 2 的效果

# 劣质数据 + SRML
数据: CoT逻辑错误，但格式正确
SRML: 仍会学习错误的推理模式
结果: 损失函数平衡了，但学习了错误知识

# 优质数据 + SRML  
数据: FCDR清洗过，CoT和Result都正确
SRML: 在正确知识上做平衡优化
结果: 事半功倍

# 优质数据 + 传统SFT
数据: FCDR清洗过的高质量数据
传统SFT: 过度关注think部分
结果: 浪费了result部分的高质量标注

# 优质数据 + SRML
数据: FCDR清洗过的高质量数据
SRML: 充分利用think和result
结果: 数据价值最大化

# 强化学习范式
reward = execution_success + format_correctness
policy_gradient = ∇log P(action) × reward

# 监督学习范式
loss = α × L_think + β × L_result

Tool-N1-7B (xLAM-RL): 82.01%
FunReason-7B:         83.66% (+1.65%)

结论: SFT配合好的数据和loss可以超越RL

# 只计算response部分的loss
mask = create_response_mask(input_ids)
loss = CrossEntropyLoss(logits[mask], labels[mask])

Loss Masking:  [思考过程不算loss] + [结果部分算loss]
SRML:          [思考过程loss×0.5] + [结果部分loss×0.5]

区别: SRML不完全丢弃think的学习，只是降低权重

# 统计你的数据集
def analyze_dataset(dataset):
    think_tokens = []
    result_tokens = []

    for sample in dataset:
        think_len = count_tokens(sample['reasoning'])
        result_len = count_tokens(sample['function_call'])

        think_tokens.append(think_len)
        result_tokens.append(result_len)

    print(f"Think平均: {np.mean(think_tokens):.1f}")
    print(f"Result平均: {np.mean(result_tokens):.1f}")
    print(f"比例: {np.mean(think_tokens)/np.mean(result_tokens):.1f}:1")

ratio = mean_think_tokens / mean_result_tokens

if ratio > 10:
    alpha = 0.5
elif ratio > 5:
    alpha = 0.6
elif ratio > 2:
    alpha = 0.7
else:
    alpha = 0.8  # 轻微不平衡，接近传统SFT

# 如果没有QwQ-32B，可以用其他模型
def simple_fcdr(data, model="gpt-4o-mini"):
    """
    简化的3阶段清洗:
    1. 格式检查（规则）
    2. 参数检查（规则）
    3. 逻辑检查（LLM）
    """
    cleaned = []

    for sample in data:
        # Stage 1: 格式检查（纯规则）
        if not check_format(sample['function_call']):
            sample = fix_format(sample)

        # Stage 2: 参数检查（规则+schema）
        if not check_parameters(sample, schema):
            sample = fix_parameters(sample, schema)

        # Stage 3: 逻辑检查（用LLM）
        if not llm_verify_logic(sample, model):
            continue  # 逻辑不通就丢弃

        cleaned.append(sample)

    return cleaned

# 完整训练脚本
model = load_base_model("Qwen2.5-7B-Instruct")

# FCDR清洗
cleaned_data = simple_fcdr(raw_data)

# SRML训练
alpha = 0.5  # 根据Step 1结果调整
trained_model = train_with_srml(
    model=model,
    data=cleaned_data,
    alpha=alpha,
    epochs=3,
    lr=4e-5
)

# 评估
score = evaluate(trained_model, test_set)

# 适用场景: 数据质量已经较好
# 节省: FCDR的计算成本

alpha = 0.5  # 根据token统计确定
model = train_with_srml(model, data, alpha)

# 适用场景: token比例还算平衡(ratio<5)
# 节省: 不需要修改训练代码

cleaned_data = fcdr_pipeline.process(data)
model = train_standard_sft(model, cleaned_data)

# FCDR简化: 只用Stage 4+5（格式和参数修正）
# SRML简化: 固定α=0.5，不做消融

quick_cleaned = format_and_param_check(data)
model = train_with_srml(model, quick_cleaned, alpha=0.5)

def dynamic_alpha(epoch, total_epochs):
    """
    早期: 更关注think（学习推理）
    后期: 更关注result（精确执行）
    """
    # 线性衰减
    alpha = 0.7 - 0.2 * (epoch / total_epochs)
    # epoch 0: α=0.7, β=0.3
    # epoch final: α=0.5, β=0.5
    return alpha

def difficulty_weighted_loss(loss, difficulty):
    """
    difficulty: 样本难度(0-1)
    简单样本: 降低权重
    困难样本: 提高权重
    """
    weight = 0.5 + 0.5 * difficulty
    return loss * weight

L_total = α × L_think 
        + β × L_result 
        + γ × L_code  # 额外的代码生成任务