GEPA类比神经网络

GEPA类比神经网络

本文档通过深度类比神经网络，帮助理解 GEPA 的训练算法。

核心概念对应表

完整训练流程对比

神经网络训练 (梯度下降)

┌─────────────────────────────────────────────────────────────────────────┐
│                    神经网络训练 (梯度下降)                                │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  1. 前向传播                                                             │
│     ┌──────────┐    ┌──────────┐    ┌──────────┐                       │
│     │ 输入 x   │ →  │  f(W,x)  │ →  │ 预测 ŷ   │                       │
│     └──────────┘    └──────────┘    └──────────┘                       │
│                            ↓                                            │
│  2. 计算 Loss                                                   │
│     L = Loss(ŷ, y_true)                                                 │
│                            ↓                                            │
│  3. 反向传播 (计算梯度)                                                   │
│     ∇W = ∂L/∂W  ←── "为什么会失败" (数学上的"为什么")                    │
│                            ↓                                            │
│  4. 参数更新                                                             │
│     W_new = W_old - α · ∇W                                             │
│                            ↓                                            │
│  5. 重复直到收敛                                                         │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

GEPA 训练 (反思进化)

┌─────────────────────────────────────────────────────────────────────────┐
│                    GEPA 训练 (反思进化)                                   │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  1. 执行评估                                                             │
│     ┌──────────┐    ┌──────────┐    ┌──────────┐                       │
│     │ 输入 x   │ →  │ f(p,x)   │ →  │ 输出 ŷ   │                       │
│     └──────────┘    │(prompt)  │    └──────────┘                       │
│                     └──────────┘                                        │
│                            ↓                                            │
│  2. 计算分数 (注意：越高越好)                                            │
│     score = evaluate(ŷ, y_true)  [0.0 ~ 1.0]                            │
│                            ↓                                            │
│  3. 反思 (LLM 分析)                                                      │
│     feedback = LLM("分析这些失败案例", trajectories)  ← "为什么会失败"   │
│                            ↓        (文本上的"为什么")                   │
│  4. 参数更新 (Prompt 突变)                                               │
│     p_new = LLM("基于反馈改进", p_old, feedback)                         │
│                            ↓                                            │
│  5. 接受/拒绝 & 更新 Pareto 前沿                                        │
│                            ↓                                            │
│  6. 重复直到预算用完                                                     │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

详细阶段对比

阶段 1: 参数表示

# 神经网络
weights = {
    'W1': np.array([[0.2, 0.8], [0.5, 0.3]]),  # 连续值
    'b1': np.array([0.1, -0.3]),
    'W2': np.array([[0.7, 0.2]]),
    'b2': np.array([0.05])
}

# GEPA
candidate = {
    'system_prompt': "You are a helpful assistant...",  # 离散文本
    'user_prompt': "Please answer the question..."
}

关键差异：

• 神经网络：连续、可微、数值优化
• GEPA：离散、不可微、语义搜索

阶段 2: 梯度 vs 反思

# 神经网络：解析梯度
def compute_gradient(loss, weights):
    """数学上的梯度：∂L/∂W"""
    gradient = autograd.grad(loss, weights)
    return gradient  # 例如: [0.02, -0.15, 0.08, ...]
    # 告诉你："权重 W[0,0] 增加一点会让 loss 减小"

# GEPA：文本反思
def make_reflective_dataset(candidate, eval_batch):
    """LLM 的反思：为什么会失败"""
    return {
        "system_prompt": [
            {
                "Inputs": "问题: 1+1=?",
                "Generated Outputs": "答案是3",
                "Feedback": "错误！正确答案是2。问题很简单但模型答错了。"
            },
            {
                "Inputs": "问题: 2+2=?",
                "Generated Outputs": "答案是5",
                "Feedback": "错误！正确答案是4。模型在简单计算上出错。"
            }
        ]
    }
    # 告诉你："prompt 需要强调仔细计算"

关键差异：

• 神经网络：精确数值梯度
• GEPA：语义文本反馈

阶段 3: 参数更新

# 神经网络：梯度下降
def update_weights(weights, gradient, learning_rate):
    new_weights = {}
    for key in weights:
        new_weights[key] = weights[key] - learning_rate * gradient[key]
    return new_weights
    # W ← W - α·∇L

# GEPA：LLM 突变
def propose_new_texts(candidate, reflective_dataset):
    prompt = f"""
    当前 prompt: {candidate['system_prompt']}

    反思数据: {reflective_dataset}

    请基于以上反馈，提出改进的 prompt。
    """
    new_prompt = reflection_lm(prompt)  # LLM 生成
    return {"system_prompt": new_prompt}
    # p ← reflect(p, feedback)

关键差异：

• 神经网络：确定性数值更新
• GEPA：探索性语义搜索

阶段 4: Loss vs Score

# 神经网络：最小化 Loss
def compute_loss(predictions, labels):
    # Cross Entropy Loss
    loss = -np.sum(labels * np.log(predictions))
    return loss  # 越小越好

# GEPA：最大化 Score
def compute_score(response, answer):
    # 字符串匹配
    is_correct = answer in response
    return 1.0 if is_correct else 0.0  # 越大越好

# 等价转换
def gepa_loss(scores):
    """将 score 转换为 loss (越小越好)"""
    return -sum(scores)

前向传播对比

神经网络

def forward_pass(x, weights):
    # 1. 线性变换
    z1 = np.dot(weights['W1'], x) + weights['b1']
    # 2. 激活函数
    a1 = relu(z1)
    # 3. 输出层
    z2 = np.dot(weights['W2'], a1) + weights['b2']
    # 4. 输出
    y_pred = softmax(z2)
    return y_pred

GEPA

def evaluate(candidate, batch, llm):
    # 1. 构建消息
    messages = [
        {"role": "system", "content": candidate['system_prompt']},
        {"role": "user", "content": batch['input']}
    ]
    # 2. LLM 调用 (前向传播) ✅
    response = llm.generate(messages)
    # 3. 评估 (规则判断) ❌
    score = evaluator(response, batch['answer'])
    return score, response

反向传播对比

神经网络

def backward_pass(loss, weights):
    # 1. 计算梯度
    gradient = autograd.grad(loss, weights)
    # 2. 返回梯度
    return gradient

GEPA

def reflect(candidate, eval_batch, reflection_llm):
    # 1. 构建反思数据
    reflective_dataset = make_reflective_dataset(eval_batch)
    # 2. LLM 反思 (反向传播) ✅
    prompt = f"""
    分析以下失败案例并改进 prompt:

    当前 prompt: {candidate}
    失败案例: {reflective_dataset}
    """
    new_candidate = reflection_llm(prompt)
    return new_candidate

关键差异总结

为什么 GEPA 有效？

1. LLM 的语义理解

神经网络: ∇L = [0.02, -0.15, ...]
         ↓
      难以解释

GEPA: "模型在简单计算上出错，需要强调仔细计算"
      ↓
      人类可理解

2. 全局搜索能力

神经网络: 梯度下降 (局部)
         ↓
      可能陷入局部最优

GEPA: LLM 生成 (全局)
      ↓
   可以跳到完全不同的区域

3. 少样本学习

神经网络: 需要数千样本
GEPA: 只需 3-10 个样本就能反思

何时使用哪种方法？

互补使用

最佳实践: 结合两者

1. 使用 GEPA 快速找到好的 prompt
   ↓
2. 基于 GEPA 的结果训练模型
   ↓
3. 使用 RL 进一步微调

完整类比表

核心洞察

GEPA 本质上是用 LLM 替代了神经网络中的两个核心组件：

1. 前向传播中的模型：从神经网络变成 LLM
2. 反向传播中的梯度：从数学梯度变成 LLM 的文本反思

这使得 GEPA 能够优化任何可以用文本表示的系统，而不仅仅是神经网络。

下一步

• 算法概述 - GEPA 算法总体介绍
• 评估流程 - 详细了解评估过程
• 反思流程 - 详细了解反思机制