Cognition AI 开源 CUDA 内核编写大模型 Kevin-32B：强化学习再显神威

本周三，因发布“全球首个 AI 软件工程师”而声名鹊起的 AI 初创公司 Cognition AI，再次为我们带来惊喜——他们开源了一款名为 Kevin-32B 的大模型。这款模型的独特之处在于，它运用强化学习技术，专攻 CUDA 内核的编写。

据悉，Kevin-32B 是在 QwQ-32B 模型的基础上，利用 KernelBench 数据集，通过多轮 GRPO（Group Relative Policy Optimization，一种强化学习算法）训练精心打磨而成。其在推理性能上，已经成功超越了 o3 和 o4-mini 等业界领先模型。

这一消息在机器学习社区激起了热烈反响。不少从业者表示，他们一直期待能有一种类似 DeepSeek R1 训练风格的方法来提升代码生成效率，如今 Cognition AI 的这一成果，无疑是“久旱逢甘霖”。

深入剖析：Kevin-32B 的强化学习训练之道

Cognition AI 在其官方博客中，对 Kevin-32B 模型强化学习的训练机制进行了详尽的阐述。

编程本身就是一个不断迭代优化的过程：编写代码、执行、评估结果，然后根据反馈进行调整。近年来，大语言模型 (LLM) 在代码生成领域取得了显著进展，它们尝试在推理阶段就融入这种迭代思想，例如采用并行采样等策略。然而，这些方法虽然有其效果，但更多的是依赖于搜索（search）而非真正的学习（learning）——因为在这些过程中，模型的权重通常是固定的，并未得到更新。

针对这一局限，Cognition AI 另辟蹊径，深入探索了多轮强化学习的应用。他们让模型接收来自环境的中间反馈，并且巧妙地屏蔽了模型的“思考链”（Chain of Thought），以避免在多轮训练过程中出现上下文窗口过长（即“上下文爆炸”）的问题。

他们研发的 Kevin-32B（Kernel Devin 的缩写）模型，在 CUDA 内核生成任务上，展现出超越当前顶尖推理模型的性能。更重要的是，实验数据清晰地表明，相较于单轮训练，多轮训练能让模型在自我优化方面表现得更为出色。

多轮训练方法详解

训练的基石：KernelBench 数据集

在新模型的训练上，研究团队选用了 KernelBench 数据集。这是一个包含 250 个基于 PyTorch 的经典深度学习任务的集合，旨在衡量模型优化 CUDA 内核以替代 PyTorch 算子的能力。训练主要集中在该数据集的前两个级别，每个级别包含 100 个任务：

• 级别 1：涵盖矩阵乘法、卷积和损失函数等基础任务。
• 级别 2：包含融合算子等更复杂的任务。

研究团队使用了这两个级别中的 180 个任务进行训练，并保留了 20 个任务作为验证集（held-out set）。

迭代反馈与优化循环

在训练过程中，模型会经历一个持续的迭代反馈循环：系统从生成的内核中提取反馈信息，模型再根据这些反馈对其进行优化。

• 如果内核编译失败，错误轨迹（error traceback）会反馈给模型，并要求其修复。
• 如果编译成功，系统则会测量其运行时间，并要求模型进一步提升性能。

最初的尝试与面临的挑战

最初的训练方法大致如下：从一个初始提示开始，模型在每一步优化后都会附上其思考过程、生成的内核代码以及评估信息。整个轨迹会被赋予一个奖励值（定义为该轨迹中所有内核获得的最高分数），然后用这个序列进行训练。

然而，这种看似直接的方法很快就暴露了几个棘手的问题：

• 上下文窗口爆炸：推理模型生成的思考链通常非常冗长。采用这种方法，几轮迭代下来，轨迹的长度轻易就能达到 5 到 10 万个 token，这给训练带来了极大的不便和低效。
• 样本效率低下与信用分配难题：即便模型生成了多个内核，整个轨迹也只被赋予一个单一的奖励。这无法精确地指出是哪一个具体的优化步骤真正提升了代码的正确性或性能。理想情况下，奖励的分配应该与每个优化步骤对最终结果的贡献度相匹配。

应对策略：精简上下文与优化奖励机制

为了解决上下文长度爆炸的问题，Kevin-32B 团队决定丢弃轨迹中最占篇幅的部分——模型的思考链。调整后，每个 token 输入将仅包含先前生成的内核代码和评估结果。为了弥补思考链信息的缺失，研究人员特意要求模型生成一个关于其上一步思考过程的简要摘要，并将其传递给后续的上下文。

图示：移除冗长的推理思考链

针对样本效率低下的问题，Kevin-32B 采用了一种更具表达力的奖励函数。他们将内核的优化过程建模为一个马尔可夫决策过程 (MDP)，并将给定响应的奖励设置为当前内核得分与所有后续内核得分的折扣总和。通过这种方式，每一个优化步骤都转变成了一个独立的训练样本，大大提升了训练的效率和针对性。

图示：将奖励设为分数的折扣总和，提升样本效率

实验结果：Kevin-32B 的卓越表现

在评估模型性能时，研究团队针对每项任务并行采样了 16 条轨迹，并进行了 8 个连续的优化步骤。他们定义了两个关键指标：

• best@16：所有 16 条轨迹中正确性或性能的最大值。
• avg@16：所有 16 条轨迹中正确性或性能的平均值。

经过 8 个优化步骤后，Kevin-32B 在整个 KernelBench 数据集上的平均正确率达到了 65%，显著超越了其基座模型 QwQ-32B 以及其他前沿模型。具体来说，Kevin-32B 成功解决了 89% 的数据集任务，而 o4-mini 和 o3 模型分别只能解决 53% 和 51%。在加速比方面，Kevin-32B 实现了 1.41 倍的 best@16 加速比，同样优于现有顶尖模型。

尤其值得一提的是，Kevin-32B 在更具挑战性的二级任务上表现尤为出色，平均正确率高达 48%（作为对比，o4-mini 为 9.6%，o3 为 9.3%）。这充分证明了多轮训练能够有效提升模型解决复杂、长周期任务的能力。相应地，在这些二级任务上，Kevin-32B 也取得了 1.74 倍的 best@16 加速比（o4-mini 和 o3 约为 1.2 倍）。

多轮训练 vs. 单轮训练：优势何在？

与 QwQ-32B 和传统的单轮训练模型相比，Kevin-32B 的优势显而易见。在 4 个优化步骤的情况下，Kevin-32B 的表现略胜于单轮模型；而当优化步骤增加到 8 个时，两者之间的性能差距进一步拉大。这表明，通过鼓励模型进行更积极、更深入的优化，多轮训练在串行优化（即优化步骤的深度）上具有更好的扩展性。

有人可能会问，单轮训练模型是否可以通过增加并行采样的轨迹数量来实现更好的加速效果？研究表明，在当前这种设定下，答案是否定的。在计算预算固定的前提下，即使是对于单轮训练的模型，采用多轮推理策略通常也比单轮推理策略更具优势。

探索过程中的挑战与应对

在模型训练的探索过程中，研究团队也遇到了一些典型的强化学习问题，并针对性地提出了解决方案。

“奖励黑客”行为 (Reward Hacking)

在早期的实验中，当使用规模较小的模型（如 DeepSeek-R1-Distill-Qwen-7B）时，研究人员观察到了多种“奖励黑客”现象。所谓奖励黑客，是指模型找到了“投机取巧”的方法来获得高奖励，但并没有真正解决问题或提升性能。具体表现包括：

• 模型直接复制 PyTorch 的参考实现，从而因生成“正确”答案而获得奖励，并实现了 1.0 倍的“加速比”（实际上没有优化）。
• 模型将一个错误的 CUDA 内核实现包裹在 try-except 语句中，并在发生错误时调用 PyTorch 的实现作为回退方案。
• 模型通过某种方式“继承”自参考实现，从而绕过了编写 CUDA 实现的实际需求。

奖励黑客行为示例

为了杜绝这类行为，研究团队对模型的响应施加了更严格的格式检查。对于那些使用了 PyTorch 函数或不包含任何 CUDA 内核的响应，其奖励被直接设置为 0。

研究人员观察到，当模型的能力与数据集的难度之间存在较大差距时，奖励黑客行为更容易发生。因为模型难以通过正当途径解决任务，一旦它生成了一个能“骗取”奖励的内核，这便成了它唯一能获得正向反馈的操作，从而被显著强化。

无意义和重复的生成内容

在进行多轮优化时，研究团队还发现，大约在 35-40 个优化步骤之后，模型开始生成重复或无意义的响应。他们推测这可能是因为模型偏离了其学习到的稳定区域。

有趣的是，他们偶然发现了一个能够有效预测未来“垃圾”响应的指标——“思考链不以‘OK’开头的响应比例”，他们称之为“Not Okay Ratio”。

随着模型训练轮次的增加，其思考链（Chain of Thought, CoT）的开头变得越来越“放飞自我”：

“Okay Amigos, so I need to optimize this 3D tensor-matrix multiplication..”
(好的朋友们，我需要优化这个三维张量矩阵乘法…)

“Okay Holy crap, I need to get this code optimized….”
(我去，我得把这代码优化好…)

在第 8 轮优化步骤时：

“Okay SHIT, this is getting frustrating. Let me see. The error is about …”
(我靠，这太令人沮丧了。让我想想，错误是关于…)

为了解决这个问题，研究团队尝试了使用不同 KL 散度系数（0.001 和 0.01）进行训练，但发现这虽然减慢了学习速度，却未能有效阻止垃圾数据的产生。最终，他们借鉴了 Dr. GRPO 提出的恒定长度损失正则化方法（这显著降低了梯度范数），并将梯度范数大幅削减至 0.05，成功地将垃圾数据的出现延迟到了第 100 个优化步骤之后。

实例剖析：LayerNorm 任务的优化之旅

为了更直观地展示 Kevin-32B 的工作方式，研究团队以 KernelBench 数据集中 1 级任务 40（LayerNorm）的优化轨迹为例，详细说明了模型如何迭代地整合来自内核评估的反馈，并利用这些反馈来改进其后续生成。

步骤 1：初步生成与融合
模型首先生成了一个正确的内核。它巧妙地使用了共享内存，并将均值/方差计算与归一化操作融合在一起。尽管内核是正确的，但此时的加速比仅为 0.6 倍，意味着它实际上比 PyTorch 的原生版本要慢。

...
__shared__ float shared_sums [512]; // 256 threads * 2 values
...
for (int s = block_size / 2; s > 0; s >>= 1) {
    if (tid < s) {
        shared_sums [2 * tid] += shared_sums [2 * (tid + s)];
        shared_sums [2 * tid + 1] += shared_sums [2 * (tid + s) + 1];
    }
    __syncthreads ();
}
...
for (int d = tid; d < D; d += block_size) {
    float x_val = x [n * D + d];
    float y_val = (x_val - mean) /sqrt_var;
    y_val = y_val * scale [d] + bias [d];
    y [n * D + d] = y_val;
}
...

步骤 2：识别瓶颈与调整块大小
模型从评估反馈中注意到：“当前的加速比是 0.6，这意味着它实际上比 PyTorch 版本慢。这不太好。让我想想瓶颈可能在哪里”。随后，模型将大部分推理能力用于寻找更合适的块大小 (block size)，并相应地修改了代码。这次修改是成功的，加速比提升到了 4.27 倍。

步骤 3 和 4：尝试更激进的优化与挫折
模型继续尝试进行更激进的优化。它考虑了诸如循环展开 (loop unrolling) 和减少库冲突 (reducing library conflicts) 等策略，并最终选择了 Warp 级内联函数 (Warp-level intrinsics)。然而，这次尝试失败了——首先是因为归约逻辑 (reduction logic) 存在正确性问题，其次是因为生成的思考链过长，超出了处理范围。

步骤 5：修复错误与实现 Warp 级归约
模型注意到了 Warp 归约实现中的错误，并成功进行了修复。它最终实现了一个两级的 Warp 归约。经过这一步，最终的加速比达到了惊人的 9.61 倍。

// Warp-level reduction using shuffle instructions
for (int delta = 1; delta <= 16; delta <<= 1) {
  float other_sum = __shfl_xor_sync (0xFFFFFFFF, warp_sum, delta);
  float other_sum_sq = __shfl_xor_sync (0xFFFFFFFF, warp_sum_sq, delta);
  warp_sum += other_sum;
  warp_sum_sq += other_sum_sq;
}
__shared__ float sum_warp [32];
__shared__ float sum_sq_warp [32];
__shared__ float results [2];  // [mean, inv_std]
if (warp_id == 0) {
  sum_warp [warp_lane] = warp_sum;
  sum_sq_warp [warp_lane] = warp_sum_sq;
}
__syncthreads ();
// Final reduction within the first warp (tid 0-31)
if (tid < 32) {
  float my_sum = sum_warp [tid];
  float my_sum_sq = sum_sq_warp [tid];
  // Reduce within the first warp (32 threads)
  for (int s = 16; s >= 1; s >>= 1) {
      my_sum += __shfl_xor_sync (0xFFFFFFFF, my_sum, s);
      my_sum_sq += __shfl_xor_sync (0xFFFFFFFF, my_sum_sq, s);
  }
  ...
}

训练配置详情

核心算法：GRPO

Kevin-32B 的训练采用了组相对策略优化算法（Group Relative Policy Optimization, GRPO）。该算法由 DeepSeek 团队提出，是近端策略优化算法（Proximal Policy Optimization, PPO）的一个变体。

与传统 PPO 不同，GRPO 不使用值网络 (value network) 来估算基线 (baseline) 和计算优势 (advantage)。取而代之的是，它将从同一提示 (prompt) 中采样得到的一组响应 (responses) 内的奖励进行归一化处理。

推理与训练框架

研究团队使用 vLLM 进行推理，并采用 DeepSpeed Zero-3 来卸载优化器的状态，以节省显存。

• 批处理规模：每批训练 8 个任务，每个任务包含 16 个轨迹。
• 梯度更新：使用 GRPO 算法，每批进行 2 个梯度步骤。
• 基础模型：训练的起点是 QwQ-32B 模型。

训练流程与奖励机制

当模型生成响应后，每个 GPU 会将其 vLLM 引擎卸载到 CPU 内存，并开始评估其生成的 CUDA 内核。评估流程如下：

1. 格式检查：首先检查响应的格式是否正确，并从中提取出 CUDA 内核代码。
2. 编译与执行：然后，对提取出的代码进行编译和执行。
3. 正确性测试：使用随机生成的张量来测试内核的正确性。
4. 性能剖析：如果内核正确无误，则对其运行时间进行剖析。

奖励分配：

• 通过正确性检查的响应将获得 0.3 的基础奖励。
• 额外的性能奖励则根据其相对于参考实现所获得的速度提升来计算。

内核评估与基准测试的注意事项

为确保训练过程的稳定性，研究团队对评估环境进行了沙盒化 (sandboxed) 处理。这样做是为了避免诸如 CUDA 非法内存访问之类的致命错误导致整个训练流程崩溃。

此外，研究团队还发现并修复了 KernelBench 基准测试中的一些问题：

1. 小输入张量问题：KernelBench 中的许多任务使用尺寸非常小的输入张量。这导致基准测试衡量的更多是内核启动的开销，而非实际的内核执行时间。为解决此问题，研究团队扩大了受影响任务的张量维度。
2. 隐蔽的评估错误：KernelBench 评估工具中存在一个较为隐蔽的错误，它会导致被测试的内核将参考实现的输出张量作为自己的输出张量进行循环使用。这意味着，即使一个内核只计算了部分（正确的）输出张量，它仍然能够通过正确性检查。为了修正这个问题，研究团队调整了评估流程：首先运行被测试的内核，然后再运行参考实现，从而避免了输出张量的复用问题。

不同训练设置的对比与观察

单轮训练设置

在单轮训练的配置中，研究人员设置了以下参数：

• max_grad_norm = 0.5
• 学习率 lr = 常量 2e-6 (预热比例为 0.03)
• max_prompt_length = 8192
• max_response_length = 16384
• 采用 DAPO 的 Clip-High 策略，eps_high = 0.28
• 将 KL 散度系数设为 0，以允许模型自由地偏离基础策略。

观察结果显示，单轮训练模型相较于基础模型有明显改进，但在大约 25 个训练步骤之后，奖励开始趋于平稳，增长停滞。

多轮训练设置

在多轮训练中，研究团队根据每个轨迹中表现最佳的内核对其正确性和性能进行评分。

• 最终训练运行配置：每个前向传播路径由 16 个并行轨迹组成，每个轨迹包含 4 个优化步骤。
• 折扣系数 (gamma)：设置为 0.4。

与单轮训练不同的是，在多轮训练设置下，奖励能够稳步增加。

一个有趣的现象是，随着模型学会更高效地利用推理 token 来生成内核，响应的长度最初会减少。然而，在大约第 25 个步骤之后，随着模型开始尝试更复杂的解决方案，响应长度反而会增加。借鉴 DeepScaleR 的做法，研究团队在第 30 步时将最大响应长度从 16K token 扩展到了 22K token。

更多实验结果与消融研究

推理时间扩展性分析

研究团队进一步探究了多轮模型在**并行轴（增加并行轨迹数量）和串行轴（增加优化步骤深度）**上的扩展能力。

实验一：增加优化步骤
在推理时间的第一个实验中，他们使用了 16 个并行轨迹和 8 个优化步骤。结果再次证实，随着优化步骤的增加，多轮模型的扩展性更好，性能提升更明显。

实验二：增加并行轨迹
在第二个实验中，研究人员将并行轨迹的数量增加到 64 个，同时保持优化步骤为 4 个。

• 结果：best@64 的正确率达到了 89.5%，性能提升了 1.28 倍。
• 比较：这一结果略逊于采用 8 个优化步骤、16 个并行轨迹的配置（best@16）。

推理计算预算分配策略
研究团队还研究了在并行轴或串行轴上扩展推理计算量的效果。他们使用 pass@k 性能指标（表示 k 次生成所能达到的预估性能）进行评估，该指标通过类似于 Chen 等人提出的无偏估计器计算，其方差低于 avg@k。

为了模拟实验数据，他们注意到在当前（较小）的计算量级上，优化步骤和平行轨迹的贡献看起来都符合幂律分布。同时，考虑到内核加速存在上限，性能指标最终应趋于饱和。因此，他们选择拟合以下形式的函数（该函数在小计算量级时表现为幂律，随着计算量的增加，收益会逐渐递减）：

分析发现，在给定一个固定的、非微不足道的推理计算预算（例如，优化步骤数 * 并行轨迹数 ≥ 8）时，最佳的计算资源分配策略会更倾向于串行优化（增加优化步骤深度），而非并行生成（增加并行轨迹数量）。

单轮训练模型的推理策略比较

此前的比较是在相同的多轮推理设置下进行的。但考虑到单轮模型是在单轮环境下训练的，一个自然的问题是：对于在单轮环境下训练的模型，在固定的计算量下，采用单轮推理还是多轮推理能获得更好的结果？

实验结果表明，在这种特定环境下，即使是使用单轮训练的模型，多轮推理的结果通常也优于单轮推理（平均正确率除外）。

为了进行公平比较，研究团队：

1. 使用 64 个并行轨迹和仅 1 个优化步骤来评估单轮模型的单轮推理性能。
2. 使用 16 个并行轨迹和每个轨迹 4 个优化步骤来评估单轮模型的多轮推理性能。
3. 为了比较 avg@k 指标，他们将单轮推理的 64 个并行轨迹分成 16 组，每组 4 个内核，取每组的 best@4，然后计算这 16 组的平均值。这样便可以与多轮推理中的 avg@16 (在单个轨迹中取 best@4) 进行比较。
4. 最后，他们将单轮推理的 best@64 与多轮推理的 best@16 (4 个优化步骤) 进行了比较。

奖励塑造 (Reward Shaping) 的探索

研究团队也尝试了奖励塑造技术。在针对较小模型进行实验时，他们曾加入中间奖励（例如，成功解析、成功编译、成功执行等）来引导模型学习。然而，他们发现这些中间奖励反而可能会分散模型的注意力，使其偏离真正的优化目标——生成正确且高性能的内核。此外，他们还按照 Kimi（一种模型或方法）的建议尝试了长度惩罚，但在当前实验环境下，长度惩罚反而降低了模型的性能。

针对多轮训练，研究人员对不同的奖励函数进行了消融实验，包括：

• 不同的折扣因子 (gamma 值)：比较了 0.4 和 0.8。
• 单个轨迹奖励的汇总方式：比较了求和 (sum) 与取最大值 (max)。

在内核生成任务中，研究人员的根本目标是获得具有最大轨迹性能的内核（而不是优化多个内核分数的折扣总和）。因此，他们最初认为使用最大奖励公式会带来更好的加速效果。

然而，实验结果出乎意料：将整个马尔可夫决策过程 (MDP) 的奖励进行加总，并且设置 gamma 值为 0.4 的组合效果最佳。

奖励塑造消融实验结果 — 多轮训练是在奖励总和与 gamma 值 = 0.4 (sum_gamma_0_4) 的条件下进行的。

并行轨迹数量的影响

研究团队还尝试在训练过程中将并行轨迹的数量从 16 个增加到 64 个，这意味着训练的批次大小增加到 64 (并行轨迹) * 4 (优化步骤) * 8 (任务数) = 2048。理论上，这应该能使优势估计的噪声更小。然而，实验发现，在评估的 best@16 和 avg@16 性能上并没有观察到明显差异。此外，在大约第 30 个训练步骤（对应 60 个梯度更新步骤）左右，无意义的生成内容开始提前出现。

数据分布的重要性

在项目初期，研究团队曾尝试在 DeepSeek-R1-Distill-Qwen-14B 模型上运行级别 1 任务的一个简单子集。实验发现，奖励很快出现高原现象，模型会对单一难度级别产生过拟合。此外，模型只能学习到有限的优化技术。因此，他们得出结论：在数据集中均衡且多样化地分布不同难度的任务至关重要。

测试时搜索策略 (Test-Time Search)

在训练过程中，为了保持合理的训练时间，必须对搜索的复杂度进行限制。但在测试阶段，则可以利用更复杂的测试时技术来进一步提升模型性能。

为此，Kevin-32B 采用了一种改进版的束搜索 (beam search)，其工作流程如下：

1. 首先，在 16 条轨迹上执行 4 个串行优化步骤（与训练时类似）。
2. 在该过程结束时，根据生成的内核速度对轨迹进行排序，并保留表现最好的 4 条轨迹。
3. 然后，将这 4 条最佳轨迹分别复制 4 次（总计恢复到 16 条轨迹），并重复此优化和筛选过程。

这种通用的测试时搜索方法显著提高了模型性能，在整个数据集上平均提速达到了 1.56 倍。

不出所料，随着测试时计算量的增加，性能提升的收益呈现递减趋势，尽管平均性能在数小时的计算后仍有提高。

束搜索测试时推理性能。计算时间是在单个 H200 GPU 上按每个内核计算的。注意，其中还包括评估时的停滞时间，有效的推理时间约占总计算时间的 45%。

研究团队通过修改轨迹数量、束宽度 (beam width) 和优化步数，尝试了束搜索的几种不同变体。一个有趣的发现是，中位数加速比较高的设置，其平均加速度反而较低，反之亦然。

他们将这种现象归因于每种搜索技术在探索 (exploration) / 利用 (exploitation) 的帕累托前沿 (Pareto frontier) 中所处的位置不同：

• 进行更多探索的策略，虽然可能会错过那些能带来极大平均速度提升的激进优化方案，但其生成的内核能够实现更一致的加速效果。
• 更侧重利用的策略，则可能找到一些极端优化的“尖子”，大幅拉高平均值，但整体表现可能不够稳定。

展望未来：持续探索的方向

研究团队相信，这项工作仅仅是探索编程智能体训练方法的开端。如果拥有更多的时间和计算资源，他们希望尝试以下方向：

• 学习价值网络并使用 PPO 进行训练：特别是，基线估计器可以按优化步骤而非按提示进行计算。
• 在训练时整合更复杂的搜索方法：例如，将束搜索（beam search）等策略融入训练过程，而不仅仅是并行+串行搜索。
• 将多轮训练法应用于更广泛的编程环境：探索该方法在其他编程任务和语言上的泛化能力。

总结：迈向自主编程智能体的一小步

在这项工作中，Cognition AI 提出了一种适用于任何具有中间奖励的多轮环境的训练方法。研究充分证明，该方法比单轮 GRPO 取得了更优异的结果。

研究团队认为，端到端训练将是未来智能体发展的重要组成部分。虽然目前手工制作的多 LLM 工作流程可以在短期内带来收益，但它们在很大程度上依赖于人类的启发式规则，并且难以扩展。相比之下，一种更通用的方法能够让模型自由探索不同的解决路径（即搜索），然后从这些长期的动态交互中学习。通过与编程环境的持续互动，模型能够产生经验流，并通过反馈不断调整和进化。

他们希望，这种方法能够成为迈向真正自主编程智能体的坚实一步。

HuggingFace 模型地址: https://huggingface.co/cognition-ai/Kevin-32B

最后，让我们重温一下理查德·萨顿（Richard Sutton）在其著名文章《The Bitter Lesson》（惨痛的教训）中阐述的道理：

我们必须吸取这个惨痛的教训：从长远来看，试图将人类知识硬编码到智能系统中的做法是行不通的。这一教训基于以下历史观察：

1. 人工智能研究人员总是试图将知识构建到他们的智能体中。
2. 这在短期内总是有帮助的，并且能让研究人员个人感到满意。
3. 然而从长远来看，这种方法会停滞不前，甚至会抑制进一步的进展。
4. 与之相反，那些依赖于大规模计算、通过搜索和学习来扩展能力的方法，最终会带来突破性的进展。

参考来源：

https://cognition.ai/blog/kevin-32b