LSE（学习自进化）强化学习框架深度研究

✨步子哥 (steper) • 2026年04月14日 03:15

                        ## 1. 单步强化学习目标的实现机制

### 1.1 目标定义与核心思想

#### 1.1.1 从多步到单步的简化策略

大语言模型部署后面临的"静态出厂"瓶颈，根源在于传统训练范式将能力固化于参数空间，无法根据实际交互经验动态调整。现有自改进方法如Reflexion、TextGrad等完全依赖模型固有的推理能力，从未针对"如何根据失败案例修改指令"这一特定技能进行显式训练。这种隐式推理模式要求模型同时完成信用分配、梯度估计和探索-利用平衡三项RL优化器核心功能，仅凭自然语言推理难以可靠实现。

LSE框架的核心创新在于将复杂的多步自我进化过程 **从根本上简化为单步强化学习目标**。原始多步进化问题的累积奖励最大化目标可形式化为 $\max_{f_\psi} \sum_{t=0}^{T} \gamma^t \bar{R}(c_t)$，其中 $c_{t+1} = f_\psi(c_t, S_t)$，这一表述面临严重的长期信用分配困难——动作影响在时间步上延迟传播，导致梯度估计方差过大。LSE通过将时间范围压缩至 **T=1**，采用 **上下文赌博机（contextual bandit）框架**，使每个编辑决策获得即时、明确的反馈信号，大幅降低学习难度。

这一简化并非忽视问题复杂性，而是策略性的能力分离：训练阶段专注于学习"如何生成可能带来改进的上下文"这一核心技能，测试时的树状搜索则负责在多个候选修改中进行系统性探索。这种"训练时单步、测试时多步"的分离既保证了训练可行性，又为测试时的自适应进化提供了灵活空间。

#### 1.1.2 单步目标的数学表述

LSE的单步强化学习目标具有精确的数学结构。自进化策略 $f_\psi$ 接收当前上下文 $c_0$ 和性能摘要 $S_0$ 作为输入，输出新上下文 $c_1 \sim f_\psi(\cdot | c_0, S_0)$，并立即获得奖励反馈。性能摘要 $S_0$ 通常包含验证集上的准确率、错误模式分析、代表性失败案例等结构化信息，为策略决策提供全面依据。

**核心优化对象的关键转变** ——从"生成高性能上下文"到"生成能带来性能提升的上下文"——体现在奖励函数的精确定义：

$$r_{\text{LSE}} = \bar{R}(c_1) - \bar{R}(c_0)$$

其中 $\bar{R}(c)$ 表示上下文 $c$ 在 **固定验证集 $D$** 上的平均下游任务性能。这一 **改进量奖励（improvement-based reward）** 设计具有深刻的激励相容性：即使当前上下文性能很高，只要存在改进空间，正向奖励仍然可能；反之，任何导致性能下降的编辑都会收到负反馈。这种结构天然激励持续探索，避免了绝对性能目标下的早熟收敛陷阱。

### 1.2 进化技能的训练过程

#### 1.2.1 策略网络架构

LSE的自进化策略 $f_\psi$ 采用大语言模型架构，具体实现使用 **Qwen3-4B-Instruct** 作为主干模型。输入端包含两类信息的融合：当前上下文 $c_t$（自然语言形式的系统提示或指令）和性能摘要 $S_t$（结构化反馈信息）。性能摘要通常格式化包含验证集准确率、按错误类型分解的统计、代表性失败示例及其分析等，与上下文拼接后输入模型。

新上下文生成采用标准自回归解码，但通过 **温度采样** 等技术调节探索程度——训练初期较高温度鼓励多样化候选，后期逐渐降低以聚焦高置信度改进。生成的上下文 $c_{t+1}$ 需满足语法合法性（如保持JSON结构）和语义连贯性约束，通过后过滤或训练数据清洗保障质量。

关键设计在于 **动作模型（action model）$\pi_\theta$ 的冻结策略**：下游任务执行模型的参数在训练全程保持不变，自进化策略仅优化提示层面的上下文。这种解耦使得进化技能与特定任务模型分离，为跨模型迁移奠定基础。

#### 1.2.2 训练数据构建

训练数据通过与环境交互动态生成，形成上下文-奖励对序列。具体流程为：从多样化初始上下文分布采样 $c_0$，在验证集 $D$ 上评估获得 $\bar{R}(c_0)$ 和 $S_0$；策略 $f_\psi$ 生成候选改进 $c_1$，评估获得 $\bar{R}(c_1)$；计算奖励 $r = \bar{R}(c_1) - \bar{R}(c_0)$，形成训练样本 $(c_0, S_0, c_1, r)$。

**固定验证集 $D$ 的一致性保障**是数据质量关键。$D$ 规模通常设为 **5-10个样本**，每个样本评估 **8次生成取平均**，平衡可靠性与效率。$D$ 的固定性确保跨时间、跨样本的奖励可比性，消除评估数据变化引入的噪声。多样化初始上下文的采样策略包括：人工种子提示的随机扰动、预训练模型合成变体、以及训练过程中引入策略自身生成的历史上下文，形成"课程学习"效果。

#### 1.2.3 参数优化方法

LSE采用策略梯度方法，针对改进量奖励特性进行专门设计。**基线简化技巧**是核心优化：由于 $r = \bar{R}(c_1) - \bar{R}(c_0)$，且 $\bar{R}(c_0)$ 在给定 $c_0$ 时为常数，可将目标重写为最大化 $\mathbb{E}[\bar{R}(c_1)]$，基线选择历史平均性能即可。

改进量奖励的 **梯度方差控制优势** 体现在其中心化分布特性——奖励集中在零附近，正负反映改进方向，幅度反映改进大小。这种结构降低了梯度估计方差，使学习更加稳定。具体训练配置包括：学习率 $1 \times 10^{-5}$，每批次采样32个节点，每个节点生成4个rollout，共训练4个epoch，基于开发集选择最优检查点。

与标准RL算法的兼容性良好，可采用PPO、GRPO等先进方法，仅需替换奖励函数为改进量形式。实验表明，相同预算下改进量奖励变体 consistently 优于绝对奖励变体。

## 2. 树状引导搜索的操作机制

### 2.1 进化树的结构与维护

#### 2.1.1 节点信息存储

LSE在测试阶段维护 **进化树 $G$**，每个节点存储四元组 $(c_n, S_n, \bar{R}_n, v_n)$，共同支持高效搜索决策：

| 字段 | 符号 | 功能说明 |
|:---|:---|:---|
| 上下文内容 | $c_n$ | 该节点对应的完整提示文本 |
| 性能摘要 | $S_n$ | 验证集评估结果与错误分析 |
| 平均奖励估计 | $\bar{R}_n$ | 固定验证集 $D$ 上的平均性能 |
| 访问计数 | $v_n$ | 被选择用于扩展的次数 |

这一结构使进化树不仅是搜索辅助，更是**知识积累载体**——通过回溯高绩效祖先节点，系统能从失败探索中恢复，避免线性链的不可逆缺陷。

#### 2.1.2 树的动态扩展

扩展遵循 **选择-扩展-评估** 循环：UCB算法选中节点 $n^*$ 后，策略 $f_\psi$ 以其 $(c_{n^*}, S_{n^*})$ 为输入生成新上下文 $c_{\text{new}}$，创建为 $n^*$ 的子节点。深度优先与广度探索的平衡通过UCB公式自动实现——高价值节点获重复精细化改进，低访问节点获强制探索机会。

内存效率通过 **基于价值的剪枝** 保障：定期删除低 $\bar{R}_n$ 叶节点，或限制深度和分支因子。适度剪枝（如保留top-k节点）在内存受限时仍保持较好搜索效果。

### 2.2 候选方案的选择策略

#### 2.2.1 UCB算法的应用

LSE采用 **上置信界（UCB）算法** 作为节点选择策略：

$$n^* = \arg\max_{n \in G} \left( \bar{R}_n + C \sqrt{\frac{\ln N}{v_n}} \right)$$

其中 $N = \sum_n v_n$ 为总访问次数，$C$ 为探索-利用权衡参数。该公式由 **利用项** $\bar{R}_n$（倾向历史表现好的节点）和 **探索项** $C\sqrt{\ln N / v_n}$（激励未充分探索节点）组成。对数项确保探索bonus随总迭代缓慢增长，分母 $v_n$ 使未探索节点获更大权重。

**参数 $C$ 的调节** 直接影响行为：$C=0$ 退化为纯贪婪选择，$C \to \infty$ 接近均匀随机探索。实践中适中值（如 $C=2$）表现最佳。UCB的 **对数遗憾界** 理论保证——在随机奖励假设下，累积遗憾增长率为 $O(\sqrt{KT \ln T})$——为LSE可靠性提供基础。

#### 2.2.2 与线性链策略的对比

| 特性 | 线性链策略 | UCB树搜索 |
|:---|:---|:---|
| 结构 | 单一路径 $c_0 \to c_1 \to c_2 \to \cdots$ | 分支树形，多路径并行 |
| 错误恢复 | **无，错误累积导致性能崩盘** | **有，通过回溯快速恢复** |
| 探索方式 | 顺序局部搜索 | 全局自适应平衡 |
| 最优性保证 | 无 | 渐进最优（UCB理论） |

**BIRD Card Games数据集上的性能恢复曲线** 是典型验证：线性链因一次错误编辑准确率从~60%断崖跌至~20%，后续迭代在劣质基础上持续恶化，永远无法恢复；UCB树搜索遭遇类似挫折后，通过选择机制回溯到历史高值节点，数轮内重回~60%并继续提升，最终收敛至更优解。这一"自愈"能力是树结构的核心优势，揭示了自我进化问题的关键结构特性——上下文空间存在多个局部最优，且编辑效果具有不可预测性，显式状态维护的冗余设计是鲁棒自进化的必要条件。

### 2.3 测试时的完整流程

#### 2.3.1 初始化与根节点设定

测试时进化始于根节点创建：上下文 $c_{\text{root}}$ 为任务提供的种子提示，性能摘要 $S_{\text{root}}$ 通过在验证集 $D$ 上评估获得，平均奖励 $\bar{R}_{\text{root}}$ 同步计算，访问计数 $v_{\text{root}}$ 初始化为1。

#### 2.3.2 迭代选择-扩展-评估循环

每轮迭代包含三个核心步骤：

| 步骤 | 操作 | 输出 |
|:---|:---|:---|
| **选择** | 应用UCB公式从 $G$ 中选节点 $n^*$ | 待扩展节点 |
| **扩展** | $f_\psi(c_{n^*}, S_{n^*})$ 生成 $c_{\text{new}}$，创建子节点 | 新叶节点 |
| **评估** | 在固定 $D$ 上评估 $c_{\text{new}}$，得 $\bar{R}_{\text{new}}$ 和 $S_{\text{new}}$ | 更新节点信息 |

迭代持续至预设轮次限制或计算预算耗尽。评估是主要计算开销来源，需运行下游任务模型并计算准确率。

#### 2.3.3 最优上下文的最终输出

进化终止后，选择平均奖励最高节点：$c_{\text{best}} = \arg\max_{n \in G} \bar{R}_n$。更复杂策略可考虑节点鲁棒性（多验证子集上的稳定表现）或多高价值节点集成。最优节点未必是最后创建节点——UCB探索可能发现早期被忽视的高价值区域，"后发先至"现象在复杂搜索空间中常见。

## 3. 基于增量（Delta）的奖励机制

### 3.1 奖励设计的理论基础

#### 3.1.1 绝对分值奖励的优化陷阱

传统RL方法在自我进化场景中采用 **绝对分值奖励** $r_{\text{abs}} = \bar{R}(c_1)$，存在多重深层缺陷：

**高初始性能上下文的学习抑制** 是最直接问题。若策略偶然发现 $\bar{R}(c_{\text{high}}) = 90\%$ 的上下文，此后任何修改都可能导致奖励下降——即使方向本质改进，短期内可能因评估方差或局部次优无法超越90%。策略陷入"舒适区"，缺乏继续探索动力，形成**早熟收敛**。

**任务难度差异导致的奖励偏差** 进一步复杂化学习。BIRD基准各数据库的Seed Prompt基线性能从52.3%（Formula 1）到65.3%（Codebase）不等。绝对奖励使策略倾向"挑选容易任务"——简单任务上获高分比困难任务上的中等改进更受奖励，导致学习偏离真正提升进化能力的方向。

**策略收敛到保守解的风险** 是上述问题的综合体现。绝对奖励激励寻找"安全"上下文——性能尚可、方差低、难以进一步改进。这种保守策略训练初期可能表现良好，但长期限制自我进化潜力。实验对比显示，绝对奖励变体训练后期性能plateau，而改进量奖励变体持续进步。

#### 3.1.2 改进量奖励的优势分析

LSE的**改进量奖励** $r_{\text{LSE}} = \bar{R}(c_1) - \bar{R}(c_0)$ 从根本上规避上述陷阱，具有三重关键优势：

| 优势维度 | 具体机制 | 效果 |
|:---|:---|:---|
| **难度无关的公平比较** | 减去初始性能 $\bar{R}(c_0)$ 自动归一化任务难度 | 困难任务+5%与简单任务+5%获同等奖励 |
| **持续探索的激励相容性** | 不惩罚"从高处跌落"的尝试，只要新上下文比当前基础更好 | 策略敢于尝试结构性修改，非固守局部最优 |
| **与单步目标的天然契合** | 将多步信用分配转化为简单两状态比较 | 局部可验证性降低学习难度，4B模型即可掌握 |

这种激励结构与自我进化的根本目标高度一致：不断发现更好的上下文配置，推动性能边界。

### 3.2 增量奖励的计算标准

#### 3.2.1 核心公式与符号定义

**平均奖励函数** $\bar{R}(c)$ 的精确定义：给定上下文 $c$，在固定验证集 $D = \{(x_i, y_i)\}_{i=1}^{|D|}$ 上，下游任务模型 $\pi_\theta$ 生成预测 $\hat{y}_i = \pi_\theta(x_i; c)$，平均奖励为正确率：

$$\bar{R}(c) = \frac{1}{|D|} \sum_{i=1}^{|D|} \mathbb{1}[\hat{y}_i = y_i]$$

对于Text-to-SQL等生成任务，正确性判断采用 **执行准确率**（比较查询执行结果）而非字符串匹配，对语义等价但语法不同的SQL更具包容性。

**验证集 $D$ 的固定性与代表性** 是奖励可比性基石。$D$ 规模通常 **5-10个样本**，每样本评估 **8次生成取平均**。固定性确保跨时间、跨样本的奖励可比；代表性保证估计性能与真实任务分布一致。尽管样本量有限，自我进化技能的较好样本效率以及"识别改进方向"的元能力学习，使这一设计在实践中有效。

**优势函数 $A_{\text{LSE}}$ 的精确表达** 整合上述组件。与标准RL中时间差分（TD）优势的区别在于：LSE的优势是 **"编辑优势"** 而非"状态优势"——比较同一策略在不同上下文下的表现，而非不同策略在同一状态下的表现。这一概念创新是LSE理论框架的核心贡献。

#### 3.2.2 "真实性能进步"的评估维度

"真实性能进步"的评估超越简单准确率比较，涉及多维度量化分析：

**下游任务准确率的量化度量** 是基础层，采用执行准确率等指标。**多轮评估的方差控制** 通过重复评估实现：同一上下文在 $D$ 的多个子集或扰动版本上评估取平均，提升关键决策点可靠性。**统计显著性检验的引入** 为改进判断提供严谨性：计算准确率差异的置信区间，仅统计显著时给予正奖励，避免对噪声信号的过度反应。

### 3.3 奖励机制的训练效果

#### 3.3.1 与替代奖励方案的消融对比

Figure 2a的系统对比验证改进量奖励核心作用：

| 奖励变体 | 公式 | 训练动态 | 最终性能 |
|:---|:---|:---|:---|
| $A_{\text{GRPO}}$ | $\bar{R}(c_1)$ with GRPO group baseline | 初期快速上升，很快plateau于~62% | 基线 |
| $A_{\text{LSE}}$ | $\bar{R}(c_1) - \bar{R}(c_0)$ | 持续上升，不断发现新改进方向 | **~67%，显著领先** |

$A_{\text{GRPO}}$ 策略倾向于复制早期高奖励提示的小幅变体；$A_{\text{LSE}}$ 策略保持探索动力，敢于尝试结构性修改。**归一化变体尝试**（相对改进率、符号改进等）未显示一致优势，简单绝对改进量在实践中最稳健。

#### 3.3.2 跨模型迁移能力的来源

LSE最引人注目的发现是 **跨模型迁移能力**：经LSE训练的4B模型生成的进化指令，可直接应用于7B模型 **Arctic-7B**，使其性能提升 **6.7%**（57.7% → 64.4%），无需任何额外训练。

| 迁移场景 | 源模型 | 目标模型 | 性能提升 | 关键机制 |
|:---|:---|:---|:---|:---|
| 同架构不同规模 | Qwen3-4B | Qwen3-7B | 验证中 | 架构共享的提示响应规律 |
| 不同架构 | Qwen3-4B | Arctic-7B | **+6.7%** | 进化技能与任务内容解耦 |
| 到闭源模型 | Qwen3-4B | GPT-5/Claude | 提示优化服务 | 元技能的通用性 |

**进化技能与任务内容的解耦** 是核心机制。LSE训练的是"如何根据反馈改进提示"的元技能，表现为识别提示缺陷、提出针对性修改、验证修改效果等通用能力，与下游具体任务内容（SQL语法、数据库模式）相对独立。这种解耦使得小规模模型在专门化元任务上能够超越大规模通用模型——GPT-5和Claude 3.5 Sonnet虽拥有更强基础能力，但缺乏针对性进化技能训练，在自我改进任务上反而落后。

**对闭源模型提示优化的启示** 拓展应用前景：LSE训练的开源小模型可作为"提示优化器"，为GPT-5等闭源模型生成高质量提示，使其自进化性能达到65.2%，接近LSE自身67.3%的水平。这一"小模型服务大模型"范式为闭源模型性能提升提供新途径。

## 4. 实验验证与性能突破

### 4.1 SQL生成任务的核心结果

#### 4.1.1 BIRD基准上的准确率对比

LSE在**BIRD（BIg Bench for Reasoning over Databases）** Text-to-SQL基准取得突破性成果，最引人注目的是 **小规模模型的越级表现**：

| 方法 | 模型规模 | 平均执行准确率 | 相对Seed提升 |
|:---|:---|:---|:---|
| Seed Prompt（原始） | — | **57.2%** | — |
| Claude 3.5 Sonnet | ~175B | 64.5% | +12.8% |
| GPT-5（自进化） | ~1.8T | 65.2% | +14.0% |
| **LSE (Qwen3-4B)** | **4B** | **67.3%** | **+17.7%** |

这一结果的多重意义：**参数效率** ——4B模型超越175B和1.8T级别顶级模型，挑战"规模即一切"共识；**技能特异性** ——LSE将自我进化显式训练为可学习技能，非依赖通用推理；**动态适应** ——测试时进化使模型针对特定数据库自适应调整，静态大模型缺乏此灵活性。

分数据库详细结果：

| 数据库领域 | Seed | +LSE进化 | 提升幅度 | 特性分析 |
|:---|:---|:---|:---|:---|
| Financial | 56.8% | 68.3% | **+11.5%** | 数值计算、聚合函数复杂 |
| Toxicology | 54.5% | 62.3% | +7.8% | 专业术语、隐式约束多 |
| Codebase | 65.3% | 71.5% | +6.2% | 初始提示已较优化 |
| Formula 1 | 52.3% | 57.0% | +4.7% | 验证集难度区分度有限 |
| Card Games | 59.5% | 63.0% | +3.5% | 业务逻辑最复杂 |

Financial领域最大提升暗示初始提示改进空间大；Formula 1和Card Games的较小提升可能反映验证集难度不足以区分改进效果，或已接近优化极限。

#### 4.1.2 跨数据库的泛化表现

LSE的 **领域自适应** 能力体现在动态进化轨迹中：面对新数据库，策略从通用种子提示出发，通过多轮迭代逐步积累领域特定知识——识别常见模式（日期处理、聚合函数使用）、添加针对性示例、调整错误处理策略等。

与静态微调的 **效率对比**：

| 方法 | 适应方式 | 计算成本 | 数据需求 | 灵活性 |
|:---|:---|:---|:---|:---|
| 静态微调 | 参数更新 | 高（全量梯度计算） | 大量领域标注数据 | 低，需重新训练 |
| LSE进化 | 提示优化 | **低（仅验证集评估）** | **无需额外标注** | **高，测试时即时适应** |

LSE单次数据库适应开销为 $O(|D| \times T \times \text{cost}_{\text{eval}})$，$T$ 为进化轮次（通常10-20轮），实践中小于完整微调成本。

### 4.2 关键消融实验

#### 4.2.1 奖励设计的影响（Figure 2a）

Figure 2a系统对比验证改进量奖励核心作用：

- **$A_{\text{GRPO}}$（绝对奖励）**：训练初期快速上升，很快plateau于~62%，策略倾向复制早期高奖励提示
- **$A_{\text{LSE}}$（改进量奖励）**：训练曲线持续上升，最终达~67%，策略保持探索动力

差距在训练后期尤为明显：绝对奖励的保守策略 vs. 改进量奖励的持续创新。

#### 4.2.2 搜索策略的影响（Figure 2b）

| 场景 | 线性链 | UCB树搜索 |
|:---|:---|:---|
| 正常进化 | 逐步提升 | 提升+波动探索 |
| 遭遇错误编辑 | **性能崩盘，无法恢复**（BIRD Card Games: 60%→20%） | **短暂下降，快速回溯恢复** |
| 长期稳定性 | 差，方差大 | 好，收敛到稳定高值 |

性能恢复曲线是典型验证：线性链断崖下跌后持续恶化；UCB树搜索数轮内重回峰值并继续提升。

#### 4.2.3 进化轮次的边际效益分析

| 进化轮次 | 累计准确率提升 | 单轮边际提升 | 阶段特征 |
|:---|:---|:---|:---|
| 0→5 | +8% | +1.6%/轮 | 快速捕获明显改进空间 |
| 5→10 | +3% | +0.6%/轮 | 进入精细优化阶段 |
| 10→15 | +1% | +0.2%/轮 | 边际效益递减 |
| 15→20 | +0.5% | +0.1%/轮 | 接近收敛，波动增大 |

**25轮** 为标准配置，在计算成本与性能收益间取得 practical 平衡。资源受限场景5-10轮已捕获大部分改进；高质量要求场景15-20轮精细优化仍有价值。自适应终止策略（连续多轮无改进则停止）是未来优化方向。                    

讨论回复

2 条回复

✨步子哥 (steper) #1

04-14 04:00

                                        <!DOCTYPE html><html lang="zh-CN"><head>
    <meta charset="UTF-8"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
    <title>LSE（学习自进化）强化学习框架深度研究</title>
    <script src="https://cdn.tailwindcss.com"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/js/all.min.js"></script>
    <link href="https://fonts.googleapis.com/css2?family=Playfair+Display:ital,wght@0,400;0,700;1,400&amp;family=Inter:wght@300;400;500;600;700&amp;display=swap" rel="stylesheet"/>
    <script src="https://cdn.jsdelivr.net/npm/mermaid@10.6.1/dist/mermaid.min.js"></script>
    <style>
        :root {
            --earth-primary: #8B7355;
            --earth-secondary: #D4C5B9;
            --earth-accent: #A0927B;
            --ocean-primary: #4A7C7E;
            --ocean-light: #7BA7A8;
            --text-primary: #2C2C2C;
            --text-secondary: #6B6B6B;
            --bg-primary: #FEFCFA;
            --bg-secondary: #F5F2ED;
        }
        
        body {
            font-family: 'Inter', sans-serif;
            background-color: var(--bg-primary);
            color: var(--text-primary);
        }
        
        .serif-display {
            font-family: 'Playfair Display', serif;
        }
        
        .toc-sidebar {
            position: fixed;
            left: 0;
            top: 0;
            width: 280px;
            height: 100vh;
            background: linear-gradient(135deg, var(--earth-primary) 0%, var(--earth-accent) 100%);
            color: white;
            overflow-y: auto;
            z-index: 1000;
            padding: 2rem 1.5rem;
        }
        
        .main-content {
            margin-left: 280px;
            min-height: 100vh;
        }
        
        .hero-section {
            background: linear-gradient(135deg, var(--earth-secondary) 0%, var(--earth-primary) 50%, var(--ocean-primary) 100%);
            color: white;
            position: relative;
            overflow: hidden;
        }
        
        .hero-overlay {
            background: rgba(0,0,0,0.2);
            backdrop-filter: blur(2px);
        }
        
        .bento-grid {
            display: grid;
            grid-template-columns: 2fr 1fr;
            grid-template-rows: auto auto;
            gap: 2rem;
            height: 60vh;
        }
        
        .hero-title {
            grid-column: 1 / 2;
            grid-row: 1 / 3;
            display: flex;
            flex-direction: column;
            justify-content: center;
        }
        
        .hero-visual {
            grid-column: 2 / 3;
            grid-row: 1 / 2;
            background: linear-gradient(45deg, rgba(255,255,255,0.1), rgba(255,255,255,0.05));
            border-radius: 1rem;
            backdrop-filter: blur(10px);
            border: 1px solid rgba(255,255,255,0.2);
        }
        
        .hero-stats {
            grid-column: 2 / 3;
            grid-row: 2 / 3;
            background: rgba(255,255,255,0.1);
            border-radius: 1rem;
            padding: 1.5rem;
        }
        
        .section-header {
            border-left: 4px solid var(--ocean-primary);
            padding-left: 1.5rem;
            margin: 3rem 0 2rem 0;
        }
        
        .citation-link {
            color: var(--ocean-primary);
            text-decoration: none;
            font-weight: 500;
            border-bottom: 1px dotted var(--ocean-primary);
        }
        
        .citation-link:hover {
            background-color: var(--ocean-light);
            color: white;
            border-radius: 0.25rem;
            padding: 0.125rem 0.25rem;
        }
        
        .highlight-box {
            background: linear-gradient(135deg, var(--ocean-light) 0%, var(--ocean-primary) 100%);
            color: white;
            border-radius: 1rem;
            padding: 2rem;
            margin: 2rem 0;
        }
        
        .formula-box {
            background: var(--bg-secondary);
            border: 2px solid var(--earth-accent);
            border-radius: 0.75rem;
            padding: 1.5rem;
            margin: 1.5rem 0;
            font-family: 'Courier New', monospace;
        }
        
        .toc-link {
            display: block;
            padding: 0.5rem 0;
            color: rgba(255,255,255,0.8);
            text-decoration: none;
            border-left: 3px solid transparent;
            padding-left: 1rem;
            transition: all 0.3s ease;
        }
        
        .toc-link:hover, .toc-link.active {
            color: white;
            border-left-color: var(--ocean-light);
            background: rgba(255,255,255,0.1);
            border-radius: 0.5rem;
        }
        
        .toc-section {
            font-weight: 600;
            margin-top: 1rem;
            margin-bottom: 0.5rem;
            color: white;
        }
        
        .pull-quote {
            font-size: 1.25rem;
            line-height: 1.6;
            font-style: italic;
            color: var(--earth-primary);
            border-left: 4px solid var(--ocean-primary);
            padding-left: 2rem;
            margin: 2rem 0;
            background: var(--bg-secondary);
            padding: 2rem;
            border-radius: 0.75rem;
        }
        
        /* Mermaid diagram styles */
        .mermaid-container {
            display: flex;
            justify-content: center;
            min-height: 300px;
            max-height: 800px;
            background: #ffffff;
            border: 2px solid #e5e7eb;
            border-radius: 12px;
            padding: 30px;
            margin: 30px 0;
            box-shadow: 0 8px 25px rgba(0, 0, 0, 0.08);
            position: relative;
            overflow: hidden;
        }

        .mermaid-container .mermaid {
            width: 100%;
            max-width: 100%;
            height: 100%;
            cursor: grab;
            transition: transform 0.3s ease;
            transform-origin: center center;
            display: flex;
            justify-content: center;
            align-items: center;
            touch-action: none; /* 防止触摸设备上的默认行为 */
            -webkit-user-select: none; /* 防止文本选择 */
            -moz-user-select: none;
            -ms-user-select: none;
            user-select: none;
        }

        .mermaid-container .mermaid svg {
            max-width: 100%;
            height: 100%;
            display: block;
            margin: 0 auto;
        }

        .mermaid-container .mermaid:active {
            cursor: grabbing;
        }

        .mermaid-container.zoomed .mermaid {
            height: 100%;
            width: 100%;
            cursor: grab;
        }

        .mermaid-controls {
            position: absolute;
            top: 15px;
            right: 15px;
            display: flex;
            gap: 10px;
            z-index: 20;
            background: rgba(255, 255, 255, 0.95);
            padding: 8px;
            border-radius: 8px;
            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
        }

        .mermaid-control-btn {
            background: #ffffff;
            border: 1px solid #d1d5db;
            border-radius: 6px;
            padding: 10px;
            cursor: pointer;
            transition: all 0.2s ease;
            color: #374151;
            font-size: 14px;
            min-width: 36px;
            height: 36px;
            text-align: center;
            display: flex;
            align-items: center;
            justify-content: center;
        }

        .mermaid-control-btn:hover {
            background: #f8fafc;
            border-color: #3b82f6;
            color: #3b82f6;
            transform: translateY(-1px);
        }

        .mermaid-control-btn:active {
            transform: scale(0.95);
        }
        
        <span class="mention-invalid">@media</span> (max-width: 1024px) {
            .toc-sidebar {
                transform: translateX(-100%);
                transition: transform 0.3s ease;
            }
            
            .toc-sidebar.open {
                transform: translateX(0);
            }
            
            .main-content {
                margin-left: 0;
            }
            
            .bento-grid {
                grid-template-columns: 1fr;
                grid-template-rows: auto auto auto;
                height: auto;
            }
            
            .hero-title {
                grid-column: 1;
                grid-row: 1;
            }
            
            .hero-visual {
                grid-column: 1;
                grid-row: 2;
            }
            
            .hero-stats {
                grid-column: 1;
                grid-row: 3;
            }

            .mermaid-control-btn:not(.reset-zoom) {
                display: none;
            }
            .mermaid-controls {
                top: auto;
                bottom: 15px;
                right: 15px;
            }
        }

        /* Responsive adjustments for small screens */
        <span class="mention-invalid">@media</span> (max-width: 768px) {
            .hero-section .bento-grid {
                padding-left: 1rem;
                padding-right: 1rem;
            }
            .hero-title h1 {
                font-size: 2.25rem;
            }
            .hero-title p {
                font-size: 1.125rem;
            }
            .hero-stats .grid {
                grid-template-columns: 1fr;
            }
        }

        <span class="mention-invalid">@media</span> (max-width: 480px) {
            .hero-title h1 {
                font-size: 1.75rem;
            }
            .hero-title p {
                font-size: 1rem;
            }
        }
    </style>
  <base target="_blank">
</head>

  <body>
    <!-- Table of Contents Sidebar -->
    <nav class="toc-sidebar">
      <div class="mb-8">
        <h2 class="text-xl font-bold serif-display mb-2">目录导航</h2>
      </div>

      <div class="toc-section">框架概述</div>
      <a href="#hero" class="toc-link">研究背景</a>
      <a href="#executive-summary" class="toc-link">执行摘要</a>

      <div class="toc-section">核心技术</div>
      <a href="#single-step-rl" class="toc-link">单步强化学习目标</a>
      <a href="#tree-search" class="toc-link">树状引导搜索</a>
      <a href="#delta-reward" class="toc-link">增量奖励机制</a>

      <div class="toc-section">实验验证</div>
      <a href="#experiments" class="toc-link">性能突破</a>
      <a href="#ablation" class="toc-link">关键消融实验</a>

      <div class="toc-section">结论展望</div>
      <a href="#conclusion" class="toc-link">研究意义</a>

      <div class="mt-8 pt-8 border-t border-white/20">
        <p class="text-xs text-white/60">基于最新学术研究成果</p>
        <p class="text-xs text-white/60 mt-1">2024年度技术报告</p>
      </div>
    </nav>

    <!-- Main Content -->
    <main class="main-content">
      
      <!-- Executive Summary -->
      <section id="executive-summary" class="py-16 px-8 max-w-7xl mx-auto">
        <div class="section-header">
          <h2 class="text-3xl font-bold serif-display">执行摘要</h2>
        </div>

        <div class="grid lg:grid-cols-3 gap-8 mb-12">
          <div class="lg:col-span-2">
            <div class="pull-quote">
              &#34;LSE框架通过单步改进量奖励显式训练模型掌握自我进化技能，核心是将奖励定义为编辑前后的性能差值，配合树状UCB搜索实现测试时的灵活探索。&#34;
            </div>

            <p class="text-lg leading-relaxed mb-6">
              当前大语言模型普遍面临知识冻结和经验丢失的&#34;静态出厂&#34;瓶颈。本研究介绍的LSE（学习自进化）强化学习框架，将复杂的自我改进过程简化为单步强化学习目标，显式训练模型掌握进化技能。
            </p>

            <p class="text-lg leading-relaxed mb-6">
              技术核心在于采用树状引导搜索平衡探索与利用，并引入基于增量（Delta）的奖励机制，仅对真实的性能进步给予正向反馈，有效避免了传统绝对分值奖励导致的优化陷阱。
            </p>
          </div>

          <div class="bg-gray-50 p-6 rounded-lg">
            <h3 class="text-xl font-semibold mb-4 text-gray-800">关键创新点</h3>
            <ul class="space-y-3 text-gray-700">
              <li class="flex items-start">
                <i class="fas fa-lightbulb text-yellow-500 mt-1 mr-3"></i>
                <span>单步强化学习目标简化</span>
              </li>
              <li class="flex items-start">
                <i class="fas fa-tree text-green-500 mt-1 mr-3"></i>
                <span>树状UCB搜索算法</span>
              </li>
              <li class="flex items-start">
                <i class="fas fa-chart-line text-blue-500 mt-1 mr-3"></i>
                <span>增量式奖励机制</span>
              </li>
              <li class="flex items-start">
                <i class="fas fa-exchange-alt text-purple-500 mt-1 mr-3"></i>
                <span>跨模型迁移能力</span>
              </li>
            </ul>
          </div>
        </div>

        <div class="highlight-box">
          <h3 class="text-2xl font-bold mb-4">突破性成果</h3>
          <div class="grid md:grid-cols-2 gap-8">
            <div>
              <h4 class="text-xl font-semibold mb-3">性能超越</h4>
              <p class="mb-4">经LSE训练的4B参数模型在SQL生成等任务上性能超越了GPT-5等顶级闭源模型，且具备跨模型迁移能力。</p>
              <p>这为构建能够动态适应环境、具备自我迭代能力的智能系统提供了实证支持与技术路径。</p>
            </div>
            <div>
              <h4 class="text-xl font-semibold mb-3">技术贡献</h4>
              <p class="mb-4">实验表明，相同预算下改进量奖励变体 consistently 优于绝对奖励变体，验证了增量奖励设计的有效性。</p>
              <p>LSE最引人注目的发现是跨模型迁移能力：经LSE训练的4B模型生成的进化指令，可直接应用于7B模型，使其性能提升6.7%。</p>
            </div>
          </div>
        </div>
      </section>

      <!-- Single-Step RL Objective -->
      <section id="single-step-rl" class="py-16 px-8 max-w-7xl mx-auto bg-gray-50">
        <div class="section-header">
          <h2 class="text-3xl font-bold serif-display">单步强化学习目标的实现机制</h2>
        </div>

        <div class="grid lg:grid-cols-2 gap-12 mb-12">
          <div>
            <h3 class="text-2xl font-semibold mb-6">从多步到单步的简化策略</h3>
            <p class="text-lg leading-relaxed mb-6">
              大语言模型部署后面临的&#34;静态出厂&#34;瓶颈，根源在于传统训练范式将能力固化于参数空间，无法根据实际交互经验动态调整。现有自改进方法如Reflexion、TextGrad等完全依赖模型固有的推理能力，从未针对&#34;如何根据失败案例修改指令&#34;这一特定技能进行显式训练<a href="https://arxiv.org/pdf/2603.18620" class="citation-link">[58]</a>
              <a href="https://chatpaper.com/zh-CN/paper/254630" class="citation-link">[67]</a>。
            </p>

            <div class="formula-box">
              <h4 class="font-semibold mb-3">原始多步进化目标：</h4>
              <div class="text-center text-lg">
                max<sub>f<sub>ψ</sub></sub> Σ<sub>t=0</sub><sup>T</sup> γ<sup>t</sup> R̄(c<sub>t</sub>)
              </div>
              <p class="text-sm mt-3 text-gray-600">面临严重的长期信用分配困难</p>
            </div>
          </div>

          <div>
            <img src="https://kimi-web-img.moonshot.cn/img/img-blog.csdnimg.cn/79b2149e207f54f3f06a08c4a3e6bb5ecba3283c.jpeg" alt="强化学习智能体与环境交互示意图" class="w-full rounded-lg shadow-lg" size="medium" aspect="wide" query="强化学习智能体环境交互" referrerpolicy="no-referrer" data-modified="1" data-score="0.00"/>

            <div class="mt-6 p-6 bg-white rounded-lg shadow-md">
              <h4 class="font-semibold mb-3 text-ocean-primary">LSE简化策略</h4>
              <p class="text-gray-700">将时间范围压缩至 T=1，采用上下文赌博机框架，使每个编辑决策获得即时、明确的反馈信号。</p>
            </div>
          </div>
        </div>

        <div class="bg-white p-8 rounded-lg shadow-md mb-8">
          <h3 class="text-2xl font-semibold mb-6">单步目标的数学表述</h3>
          <div class="grid md:grid-cols-2 gap-8">
            <div>
              <p class="text-lg leading-relaxed mb-4">
                LSE的单步强化学习目标具有精确的数学结构。自进化策略 f<sub>ψ</sub> 接收当前上下文 c<sub>0</sub> 和性能摘要 S<sub>0</sub> 作为输入，输出新上下文 c<sub>1</sub> ~ f<sub>ψ</sub>(·|c<sub>0</sub>, S<sub>0</sub>)，并立即获得奖励反馈。
              </p>
              <p class="text-gray-600">
                性能摘要 S<sub>0</sub> 通常包含验证集上的准确率、错误模式分析、代表性失败案例等结构化信息。
              </p>
            </div>
            <div class="formula-box">
              <h4 class="font-semibold mb-3">核心奖励函数：</h4>
              <div class="text-center text-xl font-bold text-ocean-primary mb-4">
                r<sub>LSE</sub> = R̄(c<sub>1</sub>) - R̄(c<sub>0</sub>)
              </div>
              <p class="text-sm text-gray-600">
                改进量奖励设计具有深刻的激励相容性：即使当前上下文性能很高，只要存在改进空间，正向奖励仍然可能。
              </p>
            </div>
          </div>
        </div>

        <div class="grid lg:grid-cols-3 gap-6">
          <div class="bg-white p-6 rounded-lg shadow-md">
            <h4 class="text-lg font-semibold mb-3 text-earth-primary">
              <i class="fas fa-cogs mr-2"></i>策略网络架构
            </h4>
            <p class="text-gray-700">
              采用Qwen3-4B-Instruct作为主干模型，输入端融合当前上下文和性能摘要，通过温度采样调节探索程度。
            </p>
          </div>
          <div class="bg-white p-6 rounded-lg shadow-md">
            <h4 class="text-lg font-semibold mb-3 text-earth-primary">
              <i class="fas fa-database mr-2"></i>训练数据构建
            </h4>
            <p class="text-gray-700">
              通过与环境交互动态生成上下文-奖励对序列，固定验证集D的规模通常为5-10个样本，每个样本评估8次生成取平均。
            </p>
          </div>
          <div class="bg-white p-6 rounded-lg shadow-md">
            <h4 class="text-lg font-semibold mb-3 text-earth-primary">
              <i class="fas fa-chart-line mr-2"></i>参数优化方法
            </h4>
            <p class="text-gray-700">
              采用策略梯度方法，学习率1×10<sup>-5</sup>，每批次采样32个节点，基于开发集选择最优检查点。
            </p>
          </div>
        </div>
      </section>

      <!-- Tree-Guided Search -->
      <section id="tree-search" class="py-16 px-8 max-w-7xl mx-auto">
        <div class="section-header">
          <h2 class="text-3xl font-bold serif-display">树状引导搜索的操作机制</h2>
        </div>

        <div class="mb-12">
          <div class="mermaid-container">
            <div class="mermaid-controls">
              <button class="mermaid-control-btn zoom-in" title="放大">
                <i class="fas fa-search-plus"></i>
              </button>
              <button class="mermaid-control-btn zoom-out" title="缩小">
                <i class="fas fa-search-minus"></i>
              </button>
              <button class="mermaid-control-btn reset-zoom" title="重置">
                <i class="fas fa-expand-arrows-alt"></i>
              </button>
              <button class="mermaid-control-btn fullscreen" title="全屏查看">
                <i class="fas fa-expand"></i>
              </button>
            </div>
            <div class="mermaid" id="tree-diagram">
              graph TD
              A[&#34;根节点 c₀&#34;] --&gt; B[&#34;节点1 c₁&#34;]
              A --&gt; C[&#34;节点2 c₂&#34;]
              A --&gt; D[&#34;节点3 c₃&#34;]
              B --&gt; E[&#34;节点4 c₄&#34;]
              B --&gt; F[&#34;节点5 c₅&#34;]
              C --&gt; G[&#34;节点6 c₆&#34;]
              D --&gt; H[&#34;节点7 c₇&#34;]
              D --&gt; I[&#34;节点8 c₈&#34;]

              style A fill:#4A7C7E,stroke:#2C2C2C,stroke-width:3px,color:#fff
              style B fill:#7BA7A8,stroke:#2C2C2C,stroke-width:2px,color:#fff
              style C fill:#7BA7A8,stroke:#2C2C2C,stroke-width:2px,color:#fff
              style D fill:#7BA7A8,stroke:#2C2C2C,stroke-width:2px,color:#fff
              style E fill:#A0927B,stroke:#2C2C2C,stroke-width:1px,color:#fff
              style F fill:#A0927B,stroke:#2C2C2C,stroke-width:1px,color:#fff
              style G fill:#A0927B,stroke:#2C2C2C,stroke-width:1px,color:#fff
              style H fill:#A0927B,stroke:#2C2C2C,stroke-width:1px,color:#fff
              style I fill:#A0927B,stroke:#2C2C2C,stroke-width:1px,color:#fff
            </div>
          </div>
        </div>

        <div class="grid lg:grid-cols-2 gap-12 mb-12">
          <div>
            <h3 class="text-2xl font-semibold mb-6">进化树的结构与维护</h3>
            <p class="text-lg leading-relaxed mb-6">
              LSE在测试阶段维护进化树 G，每个节点存储四元组 (c<sub>n</sub>, S<sub>n</sub>, R̄<sub>n</sub>, v<sub>n</sub>)，共同支持高效搜索决策<a href="https://arxiv.org/pdf/2603.18620" class="citation-link">[58]</a>
              <a href="https://arxiv.org/pdf/2603.18620" class="citation-link">[102]</a>。
            </p>

            <div class="bg-gray-50 p-6 rounded-lg">
              <h4 class="font-semibold mb-4">节点信息存储</h4>
              <div class="space-y-3">
                <div class="flex justify-between">
                  <span class="font-medium">上下文内容 c<sub>n</sub></span>
                  <span class="text-gray-600">完整提示文本</span>
                </div>
                <div class="flex justify-between">
                  <span class="font-medium">性能摘要 S<sub>n</sub></span>
                  <span class="text-gray-600">验证集评估结果</span>
                </div>
                <div class="flex justify-between">
                  <span class="font-medium">平均奖励估计 R̄<sub>n</sub></span>
                  <span class="text-gray-600">固定验证集性能</span>
                </div>
                <div class="flex justify-between">
                  <span class="font-medium">访问计数 v<sub>n</sub></span>
                  <span class="text-gray-600">被选择扩展次数</span>
                </div>
              </div>
            </div>
          </div>

          <div>
            <img src="https://kimi-web-img.moonshot.cn/img/developer.qcloudimg.com/3e75903161179559e4859ead10e0df251aabbbb4.jpg" alt="树搜索算法示意图" class="w-full rounded-lg shadow-lg mb-6" size="medium" aspect="wide" query="树搜索算法" referrerpolicy="no-referrer" data-modified="1" data-score="0.00"/>

            <div class="highlight-box">
              <h4 class="text-xl font-semibold mb-3">树结构的核心优势</h4>
              <p class="text-lg">
                通过回溯高绩效祖先节点，系统能从失败探索中恢复，避免线性链的不可逆缺陷，实现&#34;自愈&#34;能力。
              </p>
            </div>
          </div>
        </div>

        <div class="bg-white p-8 rounded-lg shadow-md mb-8">
          <h3 class="text-2xl font-semibold mb-6">UCB算法的应用</h3>
          <div class="grid md:grid-cols-2 gap-8">
            <div class="formula-box">
              <h4 class="font-semibold mb-3">UCB选择公式：</h4>
              <div class="text-center text-lg mb-4">
                n* = argmax<sub>n∈G</sub> (R̄<sub>n</sub> + C√(ln N/v<sub>n</sub>))
              </div>
              <div class="text-sm text-gray-600 space-y-1">
                <div>• 利用项 R̄<sub>n</sub>：倾向历史表现好的节点</div>
                <div>• 探索项 C√(ln N/v<sub>n</sub>)：激励未充分探索节点</div>
              </div>
            </div>
            <div>
              <p class="text-lg leading-relaxed mb-4">
                UCB算法由利用项和探索项组成，对数项确保探索bonus随总迭代缓慢增长，分母 v<sub>n</sub> 使未探索节点获更大权重<a href="https://arxiv.org/pdf/2603.18620" class="citation-link">[58]</a>
                <a href="https://arxiv.org/pdf/2603.18620" class="citation-link">[102]</a>。
              </p>
              <div class="bg-gray-50 p-4 rounded-lg">
                <h5 class="font-semibold mb-2">参数C的调节</h5>
                <p class="text-sm text-gray-700">
                  C=0退化为纯贪婪选择，C→∞接近均匀随机探索。实践中适中值（如C=2）表现最佳。
                </p>
              </div>
            </div>
          </div>
        </div>

        <div class="grid md:grid-cols-2 gap-8">
          <div class="bg-white p-6 rounded-lg shadow-md">
            <h4 class="text-lg font-semibold mb-4 text-red-600">
              <i class="fas fa-times-circle mr-2"></i>线性链策略缺陷
            </h4>
            <ul class="space-y-2 text-gray-700">
              <li>• 单一路径，无错误恢复能力</li>
              <li>• 错误累积导致性能崩盘</li>
              <li>• 仅限于顺序局部搜索</li>
              <li>• 无最优性保证</li>
            </ul>
          </div>
          <div class="bg-white p-6 rounded-lg shadow-md">
            <h4 class="text-lg font-semibold mb-4 text-green-600">
              <i class="fas fa-check-circle mr-2"></i>UCB树搜索优势
            </h4>
            <ul class="space-y-2 text-gray-700">
              <li>• 分支树形，多路径并行</li>
              <li>• 通过回溯快速恢复</li>
              <li>• 全局自适应平衡探索</li>
              <li>• 渐进最优（UCB理论）</li>
            </ul>
          </div>
        </div>

        <div class="pull-quote mt-8">
          &#34;BIRD Card Games数据集上的性能恢复曲线验证了树结构的核心优势：线性链因一次错误编辑准确率从~60%断崖跌至~20%，后续迭代在劣质基础上持续恶化；UCB树搜索遭遇类似挫折后，通过选择机制回溯到历史高值节点，数轮内重回~60%并继续提升。&#34;
        </div>
      </section>

      <!-- Delta Reward Mechanism -->
      <section id="delta-reward" class="py-16 px-8 max-w-7xl mx-auto bg-gray-50">
        <div class="section-header">
          <h2 class="text-3xl font-bold serif-display">基于增量（Delta）的奖励机制</h2>
        </div>

        <div class="grid lg:grid-cols-2 gap-12 mb-12">
          <div>
            <h3 class="text-2xl font-semibold mb-6">绝对分值奖励的优化陷阱</h3>
            <p class="text-lg leading-relaxed mb-6">
              传统RL方法在自我进化场景中采用绝对分值奖励 r<sub>abs</sub> = R̄(c<sub>1</sub>)，存在多重深层缺陷<a href="https://arxiv.org/pdf/2603.18620" class="citation-link">[58]</a>
              <a href="https://www.wispaper.ai/en/blog/learning-to-self-evolve-20260321/zho" class="citation-link">[99]</a>。
            </p>

            <div class="space-y-4">
              <div class="bg-red-50 border-l-4 border-red-400 p-4">
                <h4 class="font-semibold text-red-800">高初始性能上下文的学习抑制</h4>
                <p class="text-red-700 text-sm mt-1">
                  若策略发现R̄(c<sub>high</sub>) = 90%的上下文，此后任何修改都可能导致奖励下降，策略陷入&#34;舒适区&#34;。
                </p>
              </div>
              <div class="bg-orange-50 border-l-4 border-orange-400 p-4">
                <h4 class="font-semibold text-orange-800">任务难度差异导致的奖励偏差</h4>
                <p class="text-orange-700 text-sm mt-1">
                  BIRD基准各数据库的Seed Prompt基线性能从52.3%到65.3%不等，绝对奖励使策略倾向&#34;挑选容易任务&#34;。
                </p>
              </div>
            </div>
          </div>

          <div>
            <h3 class="text-2xl font-semibold mb-6">改进量奖励的优势分析</h3>
            <p class="text-lg leading-relaxed mb-6">
              LSE的改进量奖励 r<sub>LSE</sub> = R̄(c<sub>1</sub>) - R̄(c<sub>0</sub>) 从根本上规避上述陷阱，具有三重关键优势<a href="https://arxiv.org/pdf/2603.18620" class="citation-link">[58]</a>
              <a href="https://www.wispaper.ai/en/blog/learning-to-self-evolve-20260321/zho" class="citation-link">[99]</a>。
            </p>

            <div class="space-y-4">
              <div class="bg-green-50 border-l-4 border-green-400 p-4">
                <h4 class="font-semibold text-green-800">难度无关的公平比较</h4>
                <p class="text-green-700 text-sm mt-1">
                  减去初始性能自动归一化任务难度，困难任务+5%与简单任务+5%获同等奖励。
                </p>
              </div>
              <div class="bg-blue-50 border-l-4 border-blue-400 p-4">
                <h4 class="font-semibold text-blue-800">持续探索的激励相容性</h4>
                <p class="text-blue-700 text-sm mt-1">
                  不惩罚&#34;从高处跌落&#34;的尝试，只要新上下文比当前基础更好。
                </p>
              </div>
            </div>
          </div>
        </div>

        <div class="bg-white p-8 rounded-lg shadow-md mb-8">
          <h3 class="text-2xl font-semibold mb-6">增量奖励的计算标准</h3>
          <div class="grid md:grid-cols-2 gap-8">
            <div>
              <div class="formula-box">
                <h4 class="font-semibold mb-3">平均奖励函数：</h4>
                <div class="text-center text-lg mb-4">
                  R̄(c) = (1/|D|) Σ<sub>i=1</sub><sup>|D|</sup> 1[ŷ<sub>i</sub> = y<sub>i</sub>]
                </div>
                <p class="text-sm text-gray-600">
                  对于Text-to-SQL等生成任务，采用执行准确率而非字符串匹配，对语义等价但语法不同的SQL更具包容性。
                </p>
              </div>
            </div>
            <div>
              <p class="text-lg leading-relaxed mb-4">
                验证集D的固定性与代表性是奖励可比性基石。D规模通常5-10个样本，每样本评估8次生成取平均<a href="https://arxiv.org/html/2603.18620v1" class="citation-link">[71]</a>。
              </p>
              <div class="bg-gray-50 p-4 rounded-lg">
                <h5 class="font-semibold mb-2">&#34;真实性能进步&#34;的评估维度</h5>
                <ul class="text-sm text-gray-700 space-y-1">
                  <li>• 下游任务准确率的量化度量</li>
                  <li>• 多轮评估的方差控制</li>
                  <li>• 统计显著性检验的引入</li>
                </ul>
              </div>
            </div>
          </div>
        </div>

        <div class="highlight-box">
          <h3 class="text-2xl font-bold mb-4">奖励机制的训练效果</h3>
          <div class="grid md:grid-cols-2 gap-8">
            <div>
              <h4 class="text-xl font-semibold mb-3">消融对比结果</h4>
              <div class="space-y-3">
                <div class="flex justify-between items-center p-3 bg-red-100 rounded">
                  <span class="font-medium">A<sub>GRPO</sub> (绝对奖励)</span>
                  <span class="text-red-600 font-bold">~62%</span>
                </div>
                <div class="flex justify-between items-center p-3 bg-green-100 rounded">
                  <span class="font-medium">A<sub>LSE</sub> (改进量奖励)</span>
                  <span class="text-green-600 font-bold">~67%</span>
                </div>
              </div>
              <p class="text-sm mt-3">
                相同预算下改进量奖励变体 consistently 优于绝对奖励变体<a href="https://www.wispaper.ai/zh/blog/learning-to-self-evolve-20260321/zho" class="citation-link">[105]</a>。
              </p>
            </div>
            <div>
              <h4 class="text-xl font-semibold mb-3">跨模型迁移能力</h4>
              <div class="bg-white p-4 rounded-lg">
                <div class="text-center mb-3">
                  <div class="text-3xl font-bold text-ocean-primary">+6.7%</div>
                  <div class="text-sm text-gray-600">性能提升 (57.7% → 64.4%)</div>
                </div>
                <p class="text-sm text-gray-700">
                  经LSE训练的4B模型生成的进化指令，可直接应用于7B模型Arctic-7B，无需任何额外训练<a href="https://arxiv.org/html/2603.18620v1" class="citation-link">[71]</a>
                  <a href="https://www.wispaper.ai/zh/blog/learning-to-self-evolve-20260321/zho" class="citation-link">[88]</a>。
                </p>
              </div>
            </div>
          </div>
        </div>
      </section>

      <!-- Experiments -->
      <section id="experiments" class="py-16 px-8 max-w-7xl mx-auto">
        <div class="section-header">
          <h2 class="text-3xl font-bold serif-display">实验验证与性能突破</h2>
        </div>

        <div class="bg-white p-8 rounded-lg shadow-md mb-12">
          <h3 class="text-2xl font-semibold mb-6">BIRD基准上的准确率对比</h3>
          <div class="grid md:grid-cols-2 gap-8 mb-8">
            <div>
              <h4 class="text-xl font-semibold mb-4">核心结果</h4>
              <div class="space-y-4">
                <div class="flex items-center justify-between p-4 bg-gray-50 rounded-lg">
                  <div>
                    <div class="font-semibold">Seed Prompt（原始）</div>
                    <div class="text-sm text-gray-600">基线方法</div>
                  </div>
                  <div class="text-right">
                    <div class="text-2xl font-bold">57.2%</div>
                    <div class="text-sm text-gray-500">—</div>
                  </div>
                </div>
                <div class="flex items-center justify-between p-4 bg-blue-50 rounded-lg">
                  <div>
                    <div class="font-semibold">Claude 3.5 Sonnet</div>
                    <div class="text-sm text-gray-600">~175B参数</div>
                  </div>
                  <div class="text-right">
                    <div class="text-2xl font-bold text-blue-600">64.5%</div>
                    <div class="text-sm text-gray-500">+12.8%</div>
                  </div>
                </div>
                <div class="flex items-center justify-between p-4 bg-green-50 rounded-lg">
                  <div>
                    <div class="font-semibold">GPT-5（自进化）</div>
                    <div class="text-sm text-gray-600">~1.8T参数</div>
                  </div>
                  <div class="text-right">
                    <div class="text-2xl font-bold text-green-600">65.2%</div>
                    <div class="text-sm text-gray-500">+14.0%</div>
                  </div>
                </div>
                <div class="flex items-center justify-between p-4 bg-gradient-to-r from-purple-50 to-pink-50 rounded-lg border-2 border-purple-300">
                  <div>
                    <div class="font-semibold text-purple-800">LSE (Qwen3-4B)</div>
                    <div class="text-sm text-purple-600">4B参数</div>
                  </div>
                  <div class="text-right">
                    <div class="text-2xl font-bold text-purple-600">67.3%</div>
                    <div class="text-sm text-purple-500 font-semibold">+17.7%</div>
                  </div>
                </div>
              </div>
            </div>
            <div>
              <h4 class="text-xl font-semibold mb-4">分数据库详细结果</h4>
              <div class="space-y-3">
                <div class="flex justify-between items-center p-3 bg-gray-50 rounded">
                  <span class="font-medium">Financial</span>
                  <div class="text-right">
                    <span class="text-sm text-gray-600">56.8% → </span>
                    <span class="font-bold text-green-600">68.3%</span>
                    <span class="text-sm text-green-600 ml-2">+11.5%</span>
                  </div>
                </div>
                <div class="flex justify-between items-center p-3 bg-gray-50 rounded">
                  <span class="font-medium">Toxicology</span>
                  <div class="text-right">
                    <span class="text-sm text-gray-600">54.5% → </span>
                    <span class="font-bold">62.3%</span>
                    <span class="text-sm text-blue-600 ml-2">+7.8%</span>
                  </div>
                </div>
                <div class="flex justify-between items-center p-3 bg-gray-50 rounded">
                  <span class="font-medium">Codebase</span>
                  <div class="text-right">
                    <span class="text-sm text-gray-600">65.3% → </span>
                    <span class="font-bold">71.5%</span>
                    <span class="text-sm text-blue-600 ml-2">+6.2%</span>
                  </div>
                </div>
                <div class="flex justify-between items-center p-3 bg-gray-50 rounded">
                  <span class="font-medium">Formula 1</span>
                  <div class="text-right">
                    <span class="text-sm text-gray-600">52.3% → </span>
                    <span class="font-bold">57.0%</span>
                    <span class="text-sm text-blue-600 ml-2">+4.7%</span>
                  </div>
                </div>
                <div class="flex justify-between items-center p-3 bg-gray-50 rounded">
                  <span class="font-medium">Card Games</span>
                  <div class="text-right">
                    <span class="text-sm text-gray-600">59.5% → </span>
                    <span class="font-bold">63.0%</span>
                    <span class="text-sm text-blue-600 ml-2">+3.5%</span>
                  </div>
                </div>
              </div>
            </div>
          </div>
          <div class="mt-8 p-6 bg-blue-50 rounded-lg">
            <h4 class="text-lg font-semibold mb-3 text-blue-800">结果分析</h4>
            <p class="text-blue-700">
              这一结果的多重意义：参数效率——4B模型超越175B和1.8T级别顶级模型，挑战&#34;规模即一切&#34;共识；技能特异性——LSE将自我进化显式训练为可学习技能，非依赖通用推理；动态适应——测试时进化使模型针对特定数据库自适应调整<a href="https://www.wispaper.ai/en/blog/learning-to-self-evolve-20260321/zho" class="citation-link">[99]</a>
              <a href="https://www.wispaper.ai/zh/blog/learning-to-self-evolve-20260321/zho" class="citation-link">[105]</a>。
            </p>
          </div>
        </div>

        <div class="grid lg:grid-cols-2 gap-8 mb-12">
          <div class="bg-white p-6 rounded-lg shadow-md">
            <h4 class="text-xl font-semibold mb-4">跨数据库泛化表现</h4>
            <img src="https://kimi-web-img.moonshot.cn/img/mysql.taobao.org/d805cb6c16576e662788d4a401a71e455983933e.png" alt="数据库查询优化示意图" class="w-full rounded-lg mb-4" size="medium" aspect="wide" query="数据库查询优化" referrerpolicy="no-referrer" data-modified="1" data-score="0.00"/>
            <p class="text-gray-700 mb-4">
              LSE的领域自适应能力体现在动态进化轨迹中：面对新数据库，策略从通用种子提示出发，通过多轮迭代逐步积累领域特定知识。
            </p>
            <div class="bg-gray-50 p-4 rounded-lg">
              <h5 class="font-semibold mb-2">效率对比</h5>
              <div class="space-y-2 text-sm">
                <div class="flex justify-between">
                  <span>静态微调</span>
                  <span class="text-red-600">高成本，需重训练</span>
                </div>
                <div class="flex justify-between">
                  <span>LSE进化</span>
                  <span class="text-green-600 font-semibold">低成本，即时适应</span>
                </div>
              </div>
            </div>
          </div>

          <div class="bg-white p-6 rounded-lg shadow-md">
            <h4 class="text-xl font-semibold mb-4">领域自适应关键能力</h4>
            <div class="space-y-4">
              <div class="flex items-start">
                <i class="fas fa-search text-blue-500 mt-1 mr-3"></i>
                <div>
                  <div class="font-medium">识别常见模式</div>
                  <div class="text-sm text-gray-600">日期处理、聚合函数使用</div>
                </div>
              </div>
              <div class="flex items-start">
                <i class="fas fa-plus-circle text-green-500 mt-1 mr-3"></i>
                <div>
                  <div class="font-medium">添加针对性示例</div>
                  <div class="text-sm text-gray-600">根据错误模式补充例证</div>
                </div>
              </div>
              <div class="flex items-start">
                <i class="fas fa-cog text-purple-500 mt-1 mr-3"></i>
                <div>
                  <div class="font-medium">调整错误处理</div>
                  <div class="text-sm text-gray-600">优化异常情况的应对策略</div>
                </div>
              </div>
            </div>
            <div class="mt-4 p-4 bg-green-50 rounded-lg">
              <div class="text-center">
                <div class="text-2xl font-bold text-green-600">O(|D|×T)</div>
                <div class="text-sm text-green-700">单次适应开销</div>
              </div>
            </div>
          </div>
        </div>
      </section>

      <!-- Ablation Studies -->
      <section id="ablation" class="py-16 px-8 max-w-7xl mx-auto bg-gray-50">
        <div class="section-header">
          <h2 class="text-3xl font-bold serif-display">关键消融实验</h2>
        </div>

        <div class="grid lg:grid-cols-2 gap-8 mb-12">
          <div class="bg-white p-6 rounded-lg shadow-md">
            <h3 class="text-xl font-semibold mb-4">进化轮次的边际效益分析</h3>
            <div class="space-y-4">
              <div class="border-l-4 border-green-400 pl-4">
                <div class="font-semibold text-green-800">0→5轮</div>
                <div class="text-sm text-green-700">+8%提升，+1.6%/轮</div>
                <div class="text-xs text-green-600">快速捕获明显改进空间</div>
              </div>
              <div class="border-l-4 border-blue-400 pl-4">
                <div class="font-semibold text-blue-800">5→10轮</div>
                <div class="text-sm text-blue-700">+3%提升，+0.6%/轮</div>
                <div class="text-xs text-blue-600">进入精细优化阶段</div>
              </div>
              <div class="border-l-4 border-yellow-400 pl-4">
                <div class="font-semibold text-yellow-800">10→15轮</div>
                <div class="text-sm text-yellow-700">+1%提升，+0.2%/轮</div>
                <div class="text-xs text-yellow-600">边际效益递减</div>
              </div>
              <div class="border-l-4 border-red-400 pl-4">
                <div class="font-semibold text-red-800">15→20轮</div>
                <div class="text-sm text-red-700">+0.5%提升，+0.1%/轮</div>
                <div class="text-xs text-red-600">接近收敛，波动增大</div>
              </div>
            </div>
            <div class="mt-4 p-4 bg-purple-50 rounded-lg">
              <div class="text-center">
                <div class="text-2xl font-bold text-purple-600">25轮</div>
                <div class="text-sm text-purple-700">标准配置，平衡成本与收益</div>
              </div>
            </div>
          </div>

          <div class="bg-white p-6 rounded-lg shadow-md">
            <h3 class="text-xl font-semibold mb-4">实验配置对比</h3>
            <div class="space-y-4">
              <div class="bg-gray-50 p-4 rounded-lg">
                <h5 class="font-semibold mb-2">奖励设计对比</h5>
                <div class="space-y-2 text-sm">
                  <div class="flex justify-between">
                    <span>绝对奖励 (GRPO)</span>
                    <span class="text-red-600">~62%，早熟收敛</span>
                  </div>
                  <div class="flex justify-between">
                    <span>改进量奖励 (LSE)</span>
                    <span class="text-green-600 font-semibold">~67%，持续探索</span>
                  </div>
                </div>
              </div>

              <div class="bg-gray-50 p-4 rounded-lg">
                <h5 class="font-semibold mb-2">搜索策略对比</h5>
                <div class="space-y-2 text-sm">
                  <div class="flex justify-between">
                    <span>线性链</span>
                    <span class="text-red-600">错误累积，无法恢复</span>
                  </div>
                  <div class="flex justify-between">
                    <span>UCB树搜索</span>
                    <span class="text-green-600 font-semibold">自愈能力，稳定收敛</span>
                  </div>
                </div>
              </div>

              <div class="bg-gray-50 p-4 rounded-lg">
                <h5 class="font-semibold mb-2">迁移能力验证</h5>
                <div class="space-y-2 text-sm">
                  <div class="flex justify-between">
                    <span>同架构不同规模</span>
                    <span class="text-blue-600">验证中</span>
                  </div>
                  <div class="flex justify-between">
                    <span>不同架构 (4B→7B)</span>
                    <span class="text-green-600 font-semibold">+6.7%</span>
                  </div>
                </div>
              </div>
            </div>
          </div>
        </div>

        <div class="bg-white p-8 rounded-lg shadow-md">
          <h3 class="text-2xl font-semibold mb-6">实验结果深度分析</h3>
          <div class="grid md:grid-cols-3 gap-6">
            <div class="text-center">
              <div class="w-16 h-16 bg-green-100 rounded-full flex items-center justify-center mx-auto mb-4">
                <i class="fas fa-trophy text-2xl text-green-600"></i>
              </div>
              <h4 class="font-semibold mb-2">参数效率突破</h4>
              <p class="text-sm text-gray-600">
                4B模型超越175B和1.8T级别模型，挑战&#34;规模即一切&#34;共识
              </p>
            </div>
            <div class="text-center">
              <div class="w-16 h-16 bg-blue-100 rounded-full flex items-center justify-center mx-auto mb-4">
                <i class="fas fa-cogs text-2xl text-blue-600"></i>
              </div>
              <h4 class="font-semibold mb-2">技能特异性</h4>
              <p class="text-sm text-gray-600">
                将自我进化显式训练为可学习技能，非依赖通用推理
              </p>
            </div>
            <div class="text-center">
              <div class="w-16 h-16 bg-purple-100 rounded-full flex items-center justify-center mx-auto mb-4">
                <i class="fas fa-sync-alt text-2xl text-purple-600"></i>
              </div>
              <h4 class="font-semibold mb-2">动态适应能力</h4>
              <p class="text-sm text-gray-600">
                测试时进化使模型针对特定数据库自适应调整
              </p>
            </div>
          </div>
        </div>
      </section>

      <!-- Conclusion -->
      <section id="conclusion" class="py-16 px-8 max-w-7xl mx-auto">
        <div class="section-header">
          <h2 class="text-3xl font-bold serif-display">研究意义与未来展望</h2>
        </div>

        <div class="grid lg:grid-cols-2 gap-12 mb-12">
          <div>
            <h3 class="text-2xl font-semibold mb-6">技术贡献总结</h3>
            <div class="space-y-6">
              <div class="flex items-start">
                <div class="w-8 h-8 bg-ocean-primary rounded-full flex items-center justify-center mr-4 mt-1">
                  <span class="text-white font-bold text-sm">1</span>
                </div>
                <div>
                  <h4 class="font-semibold mb-2">单步强化学习目标</h4>
                  <p class="text-gray-700">
                    将复杂的多步自我进化过程简化为单步强化学习目标，大幅降低学习难度，同时保证训练可行性。
                  </p>
                </div>
              </div>

              <div class="flex items-start">
                <div class="w-8 h-8 bg-ocean-primary rounded-full flex items-center justify-center mr-4 mt-1">
                  <span class="text-white font-bold text-sm">2</span>
                </div>
                <div>
                  <h4 class="font-semibold mb-2">树状UCB搜索算法</h4>
                  <p class="text-gray-700">
                    通过上置信界算法平衡探索与利用，实现测试时的灵活探索，具备错误恢复和自愈能力。
                  </p>
                </div>
              </div>

              <div class="flex items-start">
                <div class="w-8 h-8 bg-ocean-primary rounded-full flex items-center justify-center mr-4 mt-1">
                  <span class="text-white font-bold text-sm">3</span>
                </div>
                <div>
                  <h4 class="font-semibold mb-2">增量式奖励机制</h4>
                  <p class="text-gray-700">
                    基于性能差值的奖励设计避免优化陷阱，激励持续探索，与自我进化的根本目标高度一致。
                  </p>
                </div>
              </div>
            </div>
          </div>

          <div>
            <img src="https://kimi-web-img.moonshot.cn/img/msimg.bioon.com/4de98904a3ebb86f19650bac2d893477f72c546c.jpg" alt="人工智能自我进化技术示意图" class="w-full rounded-lg shadow-lg mb-6" size="medium" aspect="wide" query="人工智能自我进化" referrerpolicy="no-referrer" data-modified="1" data-score="0.00"/>

            <div class="bg-gradient-to-r from-ocean-light to-ocean-primary p-6 rounded-lg text-white">
              <h4 class="text-xl font-semibold mb-3">突破性发现</h4>
              <p class="text-lg">
                经LSE训练的4B参数模型在SQL生成任务上性能超越了GPT-5等顶级闭源模型，且具备跨模型迁移能力，为构建能够动态适应环境、具备自我迭代能力的智能系统提供了实证支持。
              </p>
            </div>
          </div>
        </div>

        <div class="bg-white p-8 rounded-lg shadow-md mb-12">
          <h3 class="text-2xl font-semibold mb-6">应用前景</h3>
          <div class="grid md:grid-cols-2 gap-8">
            <div>
              <h4 class="text-lg font-semibold mb-4 text-ocean-primary">即时应用领域</h4>
              <div class="space-y-4">
                <div class="flex items-start">
                  <i class="fas fa-database text-blue-500 mt-1 mr-3"></i>
                  <div>
                    <div class="font-medium">数据库查询优化</div>
                    <div class="text-sm text-gray-600">Text-to-SQL任务的持续改进</div>
                  </div>
                </div>
                <div class="flex items-start">
                  <i class="fas fa-code text-green-500 mt-1 mr-3"></i>
                  <div>
                    <div class="font-medium">代码生成与优化</div>
                    <div class="text-sm text-gray-600">编程辅助工具的自我进化</div>
                  </div>
                </div>
                <div class="flex items-start">
                  <i class="fas fa-comments text-purple-500 mt-1 mr-3"></i>
                  <div>
                    <div class="font-medium">对话系统优化</div>
                    <div class="text-sm text-gray-600">聊天机器人的自适应改进</div>
                  </div>
                </div>
              </div>
            </div>
            <div>
              <h4 class="text-lg font-semibold mb-4 text-ocean-primary">长期发展方向</h4>
              <div class="space-y-4">
                <div class="flex items-start">
                  <i class="fas fa-robot text-red-500 mt-1 mr-3"></i>
                  <div>
                    <div class="font-medium">自主AI系统</div>
                    <div class="text-sm text-gray-600">具备自我迭代能力的智能体</div>
                  </div>
                </div>
                <div class="flex items-start">
                  <i class="fas fa-sync-alt text-orange-500 mt-1 mr-3"></i>
                  <div>
                    <div class="font-medium">持续学习系统</div>
                    <div class="text-sm text-gray-600">动态适应环境变化的AI</div>
                  </div>
                </div>
                <div class="flex items-start">
                  <i class="fas fa-network-wired text-teal-500 mt-1 mr-3"></i>
                  <div>
                    <div class="font-medium">分布式进化</div>
                    <div class="text-sm text-gray-600">多模型协同进化框架</div>
                  </div>
                </div>
              </div>
            </div>
          </div>
        </div>

        <div class="highlight-box">
          <h3 class="text-2xl font-bold mb-4">研究展望</h3>
          <div class="grid md:grid-cols-2 gap-8">
            <div>
              <h4 class="text-xl font-semibold mb-3">技术深化方向</h4>
              <ul class="space-y-2 text-white">
                <li>• 探索更复杂的树搜索算法变体</li>
                <li>• 研究多目标优化的奖励机制</li>
                <li>• 开发自适应的进化终止策略</li>
                <li>• 扩展到多模态任务场景</li>
              </ul>
            </div>
            <div>
              <h4 class="text-xl font-semibold mb-3">应用拓展方向</h4>
              <ul class="space-y-2 text-white">
                <li>• 构建开源的提示优化服务平台</li>
                <li>• 为企业提供定制化的进化解决方案</li>
                <li>• 建立跨模型的进化技能共享机制</li>
                <li>• 推动AI自我进化技术的标准化</li>
              </ul>
            </div>
          </div>
        </div>

        <div class="pull-quote mt-8">
          &#34;LSE框架的成功实现了&#39;小模型服务大模型&#39;的新范式，为闭源模型性能提升提供了新途径，也为构建能够动态适应环境、具备自我迭代能力的下一代智能系统奠定了坚实基础。&#34;
        </div>
      </section>

      <!-- Footer -->
      <footer class="bg-gray-900 text-white py-12 px-8">
        <div class="max-w-7xl mx-auto">
          <div class="grid md:grid-cols-3 gap-8">
            <div>
              <h3 class="text-xl font-bold mb-4">主要参考文献</h3>
              <div class="space-y-2 text-sm">
                <a href="https://arxiv.org/pdf/2603.18620" class="block text-gray-300 hover:text-white">
                  [58] LSE: Learning to Self-Evolve (arXiv:2603.18620)
                </a>
                <a href="https://arxiv.org/html/2603.18620v1" class="block text-gray-300 hover:text-white">
                  [71] LSE Framework Technical Report
                </a>
                <a href="https://www.wispaper.ai/en/blog/learning-to-self-evolve-20260321/zho" class="block text-gray-300 hover:text-white">
                  [99] Learning to Self-Evolve Analysis
                </a>
              </div>
            </div>
            <div>
              <h3 class="text-xl font-bold mb-4">相关资源</h3>
              <div class="space-y-2 text-sm">
                <a href="https://chatpaper.com/zh-CN/paper/254630" class="block text-gray-300 hover:text-white">
                  [67] ChatPaper Analysis
                </a>
                <a href="http://lonepatient.top/2026/03/20/arxiv_papers_2026-03-20" class="block text-gray-300 hover:text-white">
                  [117] arXiv Papers Collection
                </a>
                <a href="https://www.wispaper.ai/zh/blog/learning-to-self-evolve-20260321/zho" class="block text-gray-300 hover:text-white">
                  [105] 中文技术分析
                </a>
              </div>
            </div>
            <div>
              <h3 class="text-xl font-bold mb-4">技术标签</h3>
              <div class="flex flex-wrap gap-2">
                <span class="px-3 py-1 bg-ocean-primary rounded-full text-xs">Self-Evolution</span>
                <span class="px-3 py-1 bg-earth-primary rounded-full text-xs">Reinforcement Learning</span>
                <span class="px-3 py-1 bg-ocean-light rounded-full text-xs">Tree Search</span>
                <span class="px-3 py-1 bg-earth-accent rounded-full text-xs">Delta Reward</span>
                <span class="px-3 py-1 bg-gray-700 rounded-full text-xs">Text-to-SQL</span>
              </div>
            </div>
          </div>
          <div class="border-t border-gray-700 mt-8 pt-8 text-center text-gray-400">
            <p>© 2024 LSE Framework Research. All rights reserved.</p>
          </div>
        </div>
      </footer>
    </main>

    <script>
        // Initialize Mermaid with custom theme and contrast improvements
        mermaid.initialize({
            startOnLoad: true,
            theme: 'base',
            themeVariables: {
                primaryColor: '#4A7C7E',
                primaryTextColor: '#ffffff',
                primaryBorderColor: '#2C2C2C',
                lineColor: '#6B6B6B',
                secondaryColor: '#A0927B',
                tertiaryColor: '#D4C5B9',
                background: '#FEFCFA',
                mainBkg: '#4A7C7E',
                secondBkg: '#A0927B',
                tertiaryBkg: '#D4C5B9',
                nodeBkg: '#4A7C7E',
                nodeTextColor: '#ffffff',
                edgeLabelBackground: '#FEFCFA',
                clusterBkg: '#F5F2ED',
                clusterBorder: '#A0927B',
                defaultLinkColor: '#6B6B6B',
                titleColor: '#2C2C2C',
                edgeLabelColor: '#2C2C2C',
                fontFamily: 'Inter, sans-serif',
                fontSize: '14px'
            },
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true,
                curve: 'basis',
                padding: 20
            },
            securityLevel: 'loose'
        });

        // Initialize Mermaid Controls for zoom and pan
        function initializeMermaidControls() {
            const containers = document.querySelectorAll('.mermaid-container');

            containers.forEach(container => {
            const mermaidElement = container.querySelector('.mermaid');
            let scale = 1;
            let isDragging = false;
            let startX, startY, translateX = 0, translateY = 0;

            // 触摸相关状态
            let isTouch = false;
            let touchStartTime = 0;
            let initialDistance = 0;
            let initialScale = 1;
            let isPinching = false;

            // Zoom controls
            const zoomInBtn = container.querySelector('.zoom-in');
            const zoomOutBtn = container.querySelector('.zoom-out');
            const resetBtn = container.querySelector('.reset-zoom');
            const fullscreenBtn = container.querySelector('.fullscreen');

            function updateTransform() {
                mermaidElement.style.transform = `translate(${translateX}px, ${translateY}px) scale(${scale})`;

                if (scale > 1) {
                container.classList.add('zoomed');
                } else {
                container.classList.remove('zoomed');
                }

                mermaidElement.style.cursor = isDragging ? 'grabbing' : 'grab';
            }

            if (zoomInBtn) {
                zoomInBtn.addEventListener('click', () => {
                scale = Math.min(scale * 1.25, 4);
                updateTransform();
                });
            }

            if (zoomOutBtn) {
                zoomOutBtn.addEventListener('click', () => {
                scale = Math.max(scale / 1.25, 0.3);
                if (scale <= 1) {
                    translateX = 0;
                    translateY = 0;
                }
                updateTransform();
                });
            }

            if (resetBtn) {
                resetBtn.addEventListener('click', () => {
                scale = 1;
                translateX = 0;
                translateY = 0;
                updateTransform();
                });
            }

            if (fullscreenBtn) {
                fullscreenBtn.addEventListener('click', () => {
                if (container.requestFullscreen) {
                    container.requestFullscreen();
                } else if (container.webkitRequestFullscreen) {
                    container.webkitRequestFullscreen();
                } else if (container.msRequestFullscreen) {
                    container.msRequestFullscreen();
                }
                });
            }

            // Mouse Events
            mermaidElement.addEventListener('mousedown', (e) => {
                if (isTouch) return; // 如果是触摸设备，忽略鼠标事件

                isDragging = true;
                startX = e.clientX - translateX;
                startY = e.clientY - translateY;
                mermaidElement.style.cursor = 'grabbing';
                updateTransform();
                e.preventDefault();
            });

            document.addEventListener('mousemove', (e) => {
                if (isDragging && !isTouch) {
                translateX = e.clientX - startX;
                translateY = e.clientY - startY;
                updateTransform();
                }
            });

            document.addEventListener('mouseup', () => {
                if (isDragging && !isTouch) {
                isDragging = false;
                mermaidElement.style.cursor = 'grab';
                updateTransform();
                }
            });

            document.addEventListener('mouseleave', () => {
                if (isDragging && !isTouch) {
                isDragging = false;
                mermaidElement.style.cursor = 'grab';
                updateTransform();
                }
            });

            // 获取两点之间的距离
            function getTouchDistance(touch1, touch2) {
                return Math.hypot(
                touch2.clientX - touch1.clientX,
                touch2.clientY - touch1.clientY
                );
            }

            // Touch Events - 触摸事件处理
            mermaidElement.addEventListener('touchstart', (e) => {
                isTouch = true;
                touchStartTime = Date.now();

                if (e.touches.length === 1) {
                // 单指拖动
                isPinching = false;
                isDragging = true;

                const touch = e.touches[0];
                startX = touch.clientX - translateX;
                startY = touch.clientY - translateY;

                } else if (e.touches.length === 2) {
                // 双指缩放
                isPinching = true;
                isDragging = false;

                const touch1 = e.touches[0];
                const touch2 = e.touches[1];
                initialDistance = getTouchDistance(touch1, touch2);
                initialScale = scale;
                }

                e.preventDefault();
            }, { passive: false });

            mermaidElement.addEventListener('touchmove', (e) => {
                if (e.touches.length === 1 && isDragging && !isPinching) {
                // 单指拖动
                const touch = e.touches[0];
                translateX = touch.clientX - startX;
                translateY = touch.clientY - startY;
                updateTransform();

                } else if (e.touches.length === 2 && isPinching) {
                // 双指缩放
                const touch1 = e.touches[0];
                const touch2 = e.touches[1];
                const currentDistance = getTouchDistance(touch1, touch2);

                if (initialDistance > 0) {
                    const newScale = Math.min(Math.max(
                    initialScale * (currentDistance / initialDistance),
                    0.3
                    ), 4);
                    scale = newScale;
                    updateTransform();
                }
                }

                e.preventDefault();
            }, { passive: false });

            mermaidElement.addEventListener('touchend', (e) => {
                // 重置状态
                if (e.touches.length === 0) {
                isDragging = false;
                isPinching = false;
                initialDistance = 0;

                // 延迟重置isTouch，避免鼠标事件立即触发
                setTimeout(() => {
                    isTouch = false;
                }, 100);
                } else if (e.touches.length === 1 && isPinching) {
                // 从双指变为单指，切换为拖动模式
                isPinching = false;
                isDragging = true;

                const touch = e.touches[0];
                startX = touch.clientX - translateX;
                startY = touch.clientY - translateY;
                }

                updateTransform();
            });

            mermaidElement.addEventListener('touchcancel', (e) => {
                isDragging = false;
                isPinching = false;
                initialDistance = 0;

                setTimeout(() => {
                isTouch = false;
                }, 100);

                updateTransform();
            });

            // Enhanced wheel zoom with better center point handling
            container.addEventListener('wheel', (e) => {
                e.preventDefault();
                const rect = container.getBoundingClientRect();
                const centerX = rect.width / 2;
                const centerY = rect.height / 2;

                const delta = e.deltaY > 0 ? 0.9 : 1.1;
                const newScale = Math.min(Math.max(scale * delta, 0.3), 4);

                // Adjust translation to zoom towards center
                if (newScale !== scale) {
                const scaleDiff = newScale / scale;
                translateX = translateX * scaleDiff;
                translateY = translateY * scaleDiff;
                scale = newScale;

                if (scale <= 1) {
                    translateX = 0;
                    translateY = 0;
                }

                updateTransform();
                }
            });

            // Initialize display
            updateTransform();
            });
        }

        // Initialize mermaid controls
        initializeMermaidControls();

        // Smooth scrolling for TOC links
        document.querySelectorAll('.toc-link').forEach(link => {
            link.addEventListener('click', function(e) {
                e.preventDefault();
                const targetId = this.getAttribute('href').substring(1);
                const targetElement = document.getElementById(targetId);
                if (targetElement) {
                    targetElement.scrollIntoView({
                        behavior: 'smooth',
                        block: 'start'
                    });
                }
            });
        });

        // Active TOC link highlighting
        window.addEventListener('scroll', function() {
            const sections = document.querySelectorAll('section[id]');
            const tocLinks = document.querySelectorAll('.toc-link');
            
            let currentSection = '';
            sections.forEach(section => {
                const rect = section.getBoundingClientRect();
                if (rect.top <= 100 && rect.bottom >= 100) {
                    currentSection = section.id;
                }
            });
            
            tocLinks.forEach(link => {
                link.classList.remove('active');
                if (link.getAttribute('href') === '#' + currentSection) {
                    link.classList.add('active');
                }
            });
        });

        // Mobile menu toggle (if needed)
        function toggleTOC() {
            const sidebar = document.querySelector('.toc-sidebar');
            sidebar.classList.toggle('open');
        }

        // Add responsive behavior for small screens
        if (window.innerWidth <= 1024) {
            // Create hamburger menu button
            const menuButton = document.createElement('button');
            menuButton.innerHTML = '<i class="fas fa-bars"></i>';
            menuButton.className = 'fixed top-4 left-4 z-50 bg-gray-800 text-white p-3 rounded-lg shadow-lg';
            menuButton.onclick = toggleTOC;
            document.body.appendChild(menuButton);
            
            // Close sidebar when clicking outside
            document.addEventListener('click', function(e) {
                const sidebar = document.querySelector('.toc-sidebar');
                const menuButton = document.querySelector('button[onclick="toggleTOC()"]');
                
                if (sidebar.classList.contains('open') && 
                    !sidebar.contains(e.target) && 
                    e.target !== menuButton && 
                    !menuButton.contains(e.target)) {
                    sidebar.classList.remove('open');
                }
            });
        }
    </script>
  

</body></html>                                    

✨步子哥 (steper) #2

04-14 04:01

                                        <html><body>
<!-- Hero Section -->
      <section id="hero" class="hero-section relative">
        <div class="hero-overlay">
          <div class="bento-grid max-w-7xl mx-auto p-8">
            <div class="hero-title">
              <h1 class="text-5xl font-bold serif-display italic mb-6 leading-tight">
                LSE（学习自进化）
                <br/>
                <span class="text-4xl">强化学习框架深度研究</span>
              </h1>
              <p class="text-xl opacity-90 leading-relaxed max-w-2xl">
                突破传统AI模型&#34;静态出厂&#34;瓶颈，通过单步强化学习目标与树状搜索算法，实现模型的持续自我进化能力
              </p>
            </div>

            <div class="hero-visual flex items-center justify-center">
              <img src="https://kimi-web-img.moonshot.cn/img/www.chinaminingmagazine.com/b39ab781501f75a5d28a42ab14f8fdf387512775.jpg" alt="神经网络结构图" class="w-full h-full object-cover rounded-lg opacity-80" size="medium" aspect="wide" query="神经网络结构" referrerpolicy="no-referrer" data-modified="1" data-score="0.00"/>
            </div>

            <div class="hero-stats">
              <h3 class="text-lg font-semibold mb-4">核心性能指标</h3>
              <div class="grid grid-cols-2 gap-4 text-sm">
                <div>
                  <div class="text-2xl font-bold">67.3%</div>
                  <div class="opacity-80">BIRD基准准确率</div>
                </div>
                <div>
                  <div class="text-2xl font-bold">4B</div>
                  <div class="opacity-80">参数规模</div>
                </div>
                <div>
                  <div class="text-2xl font-bold">+17.7%</div>
                  <div class="opacity-80">相对提升</div>
                </div>
                <div>
                  <div class="text-2xl font-bold">25</div>
                  <div class="opacity-80">进化轮次</div>
                </div>
              </div>
            </div>
          </div>
        </div>
      </section>                                    

需要登录才能发表回复

登录注册

LSE（学习自进化）强化学习框架深度研究

讨论回复

推荐