> ## Content Index
> Fetch the complete content index at: https://www.hubwiz.com/blog/llms.txt
> Use this file to discover other available public pages before exploring further.

# 18 个算法跑 OpenEvolve：赢 14 个、平 1 个，输的 3 个都怪我
- URL: https://www.hubwiz.com/blog/openevolve-18-algorithms-14-wins-321x/
- Published: 2026-11-21T09:51:39.000Z
- Updated: 2026-11-21T09:51:39.000Z
- Description: 321 倍的那个 JAX 核，作者自己调了两个晚上。三次输掉的任务，问题也全在他写的评测函数上。
- Author: admin
- Tags: OpenEvolve, AlphaEvolve, RSI, AI 编程, 算法优化, 基准测试

昨天 DeepMind 放了一篇开庆功宴的论文，说 AlphaEvolve 找回了 Google 全球算力的 0.7%、DNA 测序错误的 30%。AlphaEvolve 还在私有预览里。所以我把它的 6.2K star 开源克隆版对准了我自己的 18 个算法，看着它找到一个我手工调过的 PyTorch 漏掉的 **321× JAX 加速**——47 分钟，3.18 美元。

2026 年 5 月 7 日早上，Google DeepMind 悄悄发了《AlphaEvolve: scaling impact across fields》——去年那篇演化式编程 agent 论文的后续。里面的数字属于那种让你把咖啡放下的类型。AlphaEvolve 现在把 Google DeepConsensus 模型上的 DNA 变体检测准确率提高了 30%。它把 AC 最优潮流问题的可行率从 14% 推到 88%。它把 Google Willow 处理器上的量子电路错误降了 10 倍。还有它去年发现的那个 Borg 调度启发式？还在生产里跑，还在持续找回 Google 全球算力容量的 0.7%——按 Google 的机房规模算，那是几万张 GPU，而且没人需要为此付费购买。

问题在于：AlphaEvolve 锁在 Google Cloud 私有预览的等候名单后面。所以当我 Twitter 时间线上每个资深工程师都在转发 5 月 7 日那篇博客时，我去用了一个几乎没人在谈的东西复现了这个实验——一个 MIT 许可的开源克隆版，叫 OpenEvolve，GitHub 上 6.2K star，由一个在新加坡的人 Asankhaya Sharma（@codelion）维护。我给它喂了自己的 18 个算法——那种资深后端工程师一周里随手会写的东西——让它用 Gemini 2.5 Flash + Pro 跑了 47 分钟。它在 18 个里作弊式地超过了我手工调优的基线 14 个，包括一个我上个季度亲手优化过的 JAX 核上的 321× 加速。总花费：3.18 美元。下面是真实发生的事，代码可以直接复制。

## AlphaEvolve 到底做了什么（以及为什么 OpenEvolve 可以假装自己是它）

用两句话概括 AlphaEvolve：它是包在 Gemini Pro 和 Gemini Flash 外面的一层壳，负责变异一个函数或一段代码，拿它去跑你写的评测器，打分，然后把得分最高的子代当作下一代父本。可以理解成由 LLM 驱动的 `git commit`，只不过选择压力来自一个基准测试。原始 arXiv 论文（2506.13131）把这叫"演化式编程"，而那些战果并不来自模型本身的智商，它们来自搜索——Gemini 在几小时里提出 5 万个变体，评测器留下真正跑得更快的那几个。

5 月 7 日那篇影响力论文新明确了一件事：这个方法会规模化。AlphaEvolve 用 48 次标量乘法找到了一个 4×4 复矩阵乘法算法，打破了 Strassen 1969 年 49 次的记录——56 年来第一次改进。它把 11 维亲吻数的下界从 592 提到 593。它优化了一个 Gemini 训练核，墙钟训练时间减少 23%。这一切都不需要 AGI。它需要耐心，和一个评测函数。

OpenEvolve 是从零开始的复刻。Sharma 在 2025 年 5 月原论文出来几天内就在 Hacker News 上公布了它。到 2026 年 3 月它有 5.9K star；今天 6.2K，11 个 release tag，190 多个未关 issue，还有专门做行分割、GPU kernel 发现、提示词演化、星差集点集，甚至创意写作的 fork。Sharma 那篇 Hugging Face 博客走了四个核心组件：`PromptSampler` 构造 LLM 输入，`LLMEnsemble` 把请求分发给一个或多个 API（Gemini Pro 出想法，Gemini Flash 出广度），`EvaluatorPool` 在子进程沙箱里跑候选代码，`ProgramDatabase` 用 MAP-Elites 存种群——那是 DeepMind 的质量-多样性网格，防止搜索收敛到局部最优。全部是 14K 行 Python。全部能在你的笔记本上跑。

## 我实际用的 18 个任务

我从一个应用工程师每周都会写的六类代码里挑任务。每一个起手都是一个能跑但没优化的实现，我把要演化的那段用 `# EVOLVE-BLOCK-START` 和 `# EVOLVE-BLOCK-END` 标出来，再写一个返回 `runtime_ms`、`correctness`、`output_distance` 三个键的评测器。每个任务跑 50 轮迭代的预算，用默认的 Gemini 2.5 Flash + Pro 集成（70/30 权重），每个岛 25 个任务的种群，共三个岛。

六个桶：

**A. 数值 / 线性代数（3 个）**——A1 用 float64 做 4×4 矩阵乘；A2 对长度 1024 的信号做基于 FFT 的批处理一维卷积；A3 用前向替换解下三角系统。

**B. 图算法（3 个）**——B1 5 万节点稀疏图上的单源最短路；B2 2000 节点稠密图上的传递闭包；B3 10 万条边图上的强连通分量。

**C. 优化 / 搜索（3 个）**——C1 30 座城市欧氏实例上的旅行商；C2 200 个元素 / 50 个集合的集合覆盖；C3 26 个不同半径圆盘的圆填充（AlphaEvolve 论文里的那个基准）。

**D. JAX / GPU kernel（3 个）**——D1 一个我用 `jax.jit` 手调过的 softmax-then-matmul 融合核；D2 给 Qwen3-0.6B 那种解码器做的分组查询注意力；D3 4096×4096 网格上的 Mandelbrot 迭代。

**E. 字符串 / 解析（3 个）**——E1 两个 1 万字符字符串的最长公共子串；E2 跑在 10 万行语料上的无正则邮箱校验；E3 跑在 50MB 嵌套日志上的 JSON 分词器。

**F. 统计 / ML 核（3 个）**——F1 10 万点、50 维、k=20 的 k-means 聚类；F2 1 万×500 设计矩阵上的逻辑回归坐标下降；F3 批量高斯采样的 Box-Muller 变换。

每个任务的参考基线是：在该用 NumPy / SciPy / NetworkX / JAX 的地方用它们的、实现得合理的 Python 程序，再加上我在 D1 和 D2 上的手调版本（这两个都是我上个季度为副项目亲手写过、亲手优化过的生产代码）。"赢"的定义是：OpenEvolve 最终程序比基线至少快 1.5 倍，**且**在留出测试集上通过正确性检查。

## 结果：14 胜、3 负、1 平

| 组 | 任务                    | 基线                | OpenEvolve 最终版                    | 加速比        | 判定 |
| - | --------------------- | ----------------- | --------------------------------- | ---------- | -- |
| A | A1 4×4 矩阵乘            | 朴素三重循环            | 自己发现的 Strassen 式 7 次乘法递归          | 1.9×       | 胜  |
| A | A2 FFT 卷积             | 朴素嵌套循环            | scipy.signal.fftconvolve          | 256×       | 胜  |
| A | A3 前向替换               | NumPy 循环          | scipy.linalg.solve\_triangular    | 14.2×      | 胜  |
| B | B1 单源最短路              | NetworkX dijkstra | 数组的数组实现优先队列                       | 8.7×       | 胜  |
| B | B2 传递闭包               | 朴素 O(n³)          | 位集行的 Floyd-Warshall               | 95.78×     | 胜  |
| B | B3 强连通分量              | NetworkX          | 迭代 Tarjan + numba                 | 22.4×      | 胜  |
| C | C1 TSP                | 随机重启              | 2-opt + Or-opt 加缓存                | 11.3×      | 胜  |
| C | C2 集合覆盖               | 朴素贪心              | 贪心 + 惰性堆                          | 6.5×       | 胜  |
| C | C3 圆填充                | 梯度下降              | scipy.optimize.minimize SLSQP     | 分数同为 2.634 | 平  |
| D | D1 softmax-matmul JAX | 手调 jax.jit        | 重排 jax.lax.dot\_general \+ jit 融合 | 321×       | 胜  |
| D | D2 GQA Qwen3 核        | mlx 基线            | 统一内存友好的 tile 模式                   | 平均 12.5×   | 胜  |
| D | D3 Mandelbrot         | 朴素向量化             | jax.lax.while\_loop 提前退出          | 4.1×       | 胜  |
| E | E1 最长公共子串             | 动态规划              | 后缀数组 + LCP                        | 17.4×      | 胜  |
| E | E2 邮箱校验               | 逐字符扫描             | 懂 RFC 5322 的位集状态机                 | 3.8×       | 胜  |
| E | E3 JSON 分词器           | json.loads        | 流式 JSONLines 切分器                  | 退化         | 负  |
| F | F1 k-means            | sklearn           | mini-batch + 三角不等式剪枝              | 5.2×       | 胜  |
| F | F2 逻辑回归               | sklearn LBFGS     | 带 active set 的坐标下降                | 退化         | 负  |
| F | F3 Box-Muller         | NumPy             | Wichmann-Hill 极坐标法                | 退化         | 负  |

得分：14 胜、1 平、3 负。D1 上那个 321× 是真的：我手调的 `jax.jit` softmax-then-matmul 对我基准采样到的输入形状分布来说，融合方向是错的，而 OpenEvolve 的变异把收缩重写了一遍——去掉了 `jax.lax.dot_general` 的 `precision=jax.lax.Precision.HIGHEST` 参数（对我的用例来说本来就多余），然后让 XLA 编译器挑了另一个融合实现。我上个季度为这个核花了两个晚上。OpenEvolve 用 41 分钟墙钟、312 代找到了更好的路径。

## 三次失败是诚实的，也值得你知道

E3（JSON 分词器）退化，是因为 OpenEvolve 演化出的版本在简单的扁平 JSON 上快 2.4 倍，但在深层嵌套对象上慢 11 倍——而我的评测器用平均运行时打分，agent 就把这个指标给刷了。F2（坐标下降）退化，是因为 OpenEvolve 演化出的 active set 启发式在条件数差的特征上产生了数值不稳定的迭代，在 8 个留出矩阵里的 1 个上静默地没通过正确性，而我写的评测器直到我深挖才发现这种不稳定。F3（Box-Muller）退化，是因为 OpenEvolve 选的 Wichmann-Hill 极坐标法每次抽样确实更快，但没向量化，于是在批处理输入上输了。

这个模式正好对上纽约大学 Ernest Davis 在 2025 年 6 月批评里点出的问题：AlphaEvolve 和它的克隆版是被评测器圈住的搜索引擎。如果你的评测函数奖励的是错的东西，agent 会毫不留情地利用这一点。Davis 写的是，AlphaEvolve"很棒，但它也被严重过度推销了"。我拿到的 14 个胜是真的。那 3 个负也是真的，而且完全是作为评测器作者的我自己的责任。**agent 优化你测量的东西，不是你想要的语义。**

## 总成本：3.18 美元 API 花费，47 分钟墙钟

18 个任务每个跑 50 轮迭代、用默认的 Gemini 2.5 Flash（70%）+ Pro（30%）集成，LLM API 花费是 3.18 美元——Flash 每百万 token 0.075 / 0.30 美元，干掉了大部分活，Pro 大约每 10 代里被叫 3 次来加深推理。从敲 `python openevolve-run.py` 到写出 `best_program.py`，墙钟总共 47 分钟，机器是我这台 MacBook Pro M4 Max，其中 5 个任务（D1、D2、B2、A2、E1）靠 OpenEvolve 的 5 岛配置并行跑。最贵的单个任务是 D1——3.18 美元里它占约 0.71 美元，因为分组查询注意力需要 Pro 承担大部分重推理。

作为对比，AlphaEvolve 自己发现那个 4×4 复矩阵乘法，据报道在 Google 自己的基础设施上跑了几周算力，不过 DeepMind 没公布确切的美元数字。OpenEvolve 落在成本-发现曲线上的另一个点：它不会替你找到 Strassen-2，但它会在一个小时内、五美元以下，在你已有的手调代码上找到 321× 的加速。

## 快速上手：5 分钟把 OpenEvolve 跑起来

```bash
pip install openevolve
export OPENAI_API_KEY="$YOUR_GEMINI_API_KEY"  # 是的，用 Gemini 时这个变量也叫 OPENAI_API_KEY
git clone https://github.com/algorithmicsuperintelligence/openevolve.git
cd openevolve
python openevolve-run.py \
  examples/function_minimization/initial_program.py \
  examples/function_minimization/evaluator.py \
  --config examples/function_minimization/config.yaml \
  --iterations 50

```

去 `aistudio.google.com/apikey` 免费拿一个 Gemini API key。`OPENAI_API_KEY` 这个环境变量名是故意的——OpenEvolve 用的是 Gemini 的 OpenAI 兼容端点 `https://generativelanguage.googleapis.com/v1beta/openai/`。Gemini 2.5 Flash 的免费额度每天够跑 5–10 个小问题，一分钱不花。

包装你自己的算法只要三步。第一，标出要演化的范围：

```python
def my_algorithm(input_data):
    # EVOLVE-BLOCK-START
    result = naive_implementation(input_data)
    # EVOLVE-BLOCK-END
    return result

```

第二，写一个返回指标字典的评测器：

```python
def evaluate(program_path: str) -> dict:
    spec = importlib.util.spec_from_file_location("p", program_path)
    mod = importlib.util.module_from_spec(spec); spec.loader.exec_module(mod)
    start = time.perf_counter()
    output = mod.my_algorithm(test_input)
    elapsed_ms = (time.perf_counter() - start) * 1000
    correct = (output == reference_output)
    return {"runtime_ms": elapsed_ms, "correctness": float(correct),
            "score": (1000.0 / elapsed_ms) * float(correct)}

```

第三，写一个 `config.yaml`（或者直接抄 `examples/function_minimization/config.yaml`）然后跑。最小的一份长这样：

```yaml
llm:
  api_base: "https://generativelanguage.googleapis.com/v1beta/openai/"
  models:
    - { name: "gemini-2.5-flash", weight: 0.7 }
    - { name: "gemini-2.5-pro",   weight: 0.3 }
  temperature: 0.7
database:
  num_islands: 3
  population_size: 25
  feature_dimensions: ["complexity", "diversity"]
evaluator:
  cascade_thresholds: [0.5, 0.9]
  timeout: 60

```

整套东西就这些。没有云等候名单。没有企业合同。README 里有圆填充、函数最小化、排序、MLX Metal kernel 和提示词演化的完整示例。Sharma 那篇 Hugging Face 博客走了一遍 OpenEvolve 如何在 Apple Silicon 上为一个分组查询注意力演化出 Metal kernel，平均打赢 MLX 手调的 `scaled_dot_product_attention` 12.5%（长序列解码上最高 106%）——那正是我基准里的 D2 任务。

## 这件事该放在你一周里的什么位置

三种诚实的说法：

**如果你是手调热路径代码的应用工程师**：在再花两个晚上之前，先把 OpenEvolve 指向你的热路径。我那个 JAX 核上的 321× 就是这么定下来的。我本来是那个手调的人。OpenEvolve 用 41 分钟、0.71 美元找到了更好的融合。对我来说，继续手调的回报已经低于让 agent 跑一遍。

**如果你是想追 AlphaEvolve 已发表结果的研究工程师**：OpenEvolve 已经把圆填充复现到离 DeepMind 那个 2.635 只差 0.04%（Issue #156 的复现拿到 2.634 / 2.635977）。它不会给你 Strassen-2——那花了 DeepMind 几周的 Pro 级算力——但它会给你同样的圆填充、FunSearch 复现和 AlgoTune 式的战果。

**如果你是带着怀疑在评估它**：先读 Ernest Davis 那篇纽约大学的批评。agent 是搜索引擎。评测器才是瓶颈。我 18 个任务里有 3 个退化，而三次退化都怪我——指标写错、漏了正确性检查、或者奖励了一个没向量化的改进。AlphaEvolve 被 Davis 说成"被严重过度推销"的那个 AGI 叙事，在 OpenEvolve 这 6.2K star 的项目上要难卖得多，而它恰好是你亲手试这件事的合适工具。

5 月 7 日那篇 DeepMind 论文会让 AlphaEvolve 变成下个季度所有会议演讲都在谈的 agent。你今天真的能 `pip install`、能 `git clone` 的那个版本是 OpenEvolve，而在用它跑了 18 个任务之后，我这个晚上收工时手上有的是：一个快 321 倍的 JAX 核、一个快 95.78 倍的传递闭包，以及一份更清醒的敬畏——"生产环境里的 AGI"和"调得不错的网格搜索"之间那条线，其实很细。

## 结论

OpenEvolve 不是魔法。它是一个做得不错的 MIT 许可搜索循环，挂在 Gemini 的免费 API 层上，在你的代码上跑 MAP-Elites。如果你把评测器写仔细，它会找到你手调一周也找不到的优化，包括一个资深工程师（就是我）上个季度已经优化过的代码里的优化。如果你把评测器写马虎，agent 会钻指标的空子，把真实的正确性弄退步。5 月 7 日那篇 DeepMind 影响力论文给了演化式编程一个宏观论证；OpenEvolve 是你能在自己笔记本上今晚就跑起来的微观论证。

我会把它留在我的工作流里。你也应该。

---

## 我们的整理（2026-11）

**这篇是 Chew Loong Nian 2026 年 5 月 8 日发在 Towards AI（Medium）上的实测记录**，原文经 Freedium 读取。18 个任务的数字全部是作者自报，我们没有复现；模型版本、价格、star 数都过了一轮，下面三件事值得先对齐再读表。

**第一，大数字多半是"朴素实现 → 标准库"的距离，不是演化搜索的功劳。** 看 A2（朴素嵌套循环 → `scipy.signal.fftconvolve`，256×）、B2（朴素 O(n³) → 位集 Floyd-Warshall，95.78×）、E3（`json.loads` → 流式切分器）、B3（NetworkX → Tarjan + numba），这些加速换个会写 NumPy/SciPy 的人一小时也能拿到。真正有信息量的只有三个：**D1 的 321×**（基线是作者自己手调过的 `jax.jit` 核）、**D2 的 12.5%**（基线是 MLX 手调的 `scaled_dot_product_attention`）、**C3 打平**（双方都落到 SLSQP）。判断这套东西对你有没有用，只需要问一句：我的基线是"朴素实现"还是"我已经调过的那版"？

**第二，仓库状态要更新（2026-11-21 查 GitHub API）。**

| 项    | 原文（2026-05）             | 现在（2026-11-21）                                          |
| ---- | ----------------------- | ------------------------------------------------------- |
| 许可   | MIT                     | **Apache-2.0**（原文写的 MIT 已不对）                            |
| Star | 6.2K                    | **7,834**（1,232 fork / 95 open issue）                   |
| 仓库   | codelion/openevolve 的语境 | algorithmicsuperintelligence/openevolve，最近提交 2026-11-20 |
| PyPI | pip install openevolve  | openevolve 0.4.1，命令仍是 openevolve-run.py                 |

半年涨 1.6K star 且仍在提交，说明它确实被用起来了；但**"MIT 许可"这句要当成历史信息**——自建商用前看清 Apache-2.0 的 NOTICE 与专利条款。

**第三，原文有两处对不上，读的时候别被带偏。** ①成本那节说"最贵的是 D1，因为分组查询注意力需要 Pro 承担重推理"——但分组查询注意力是 **D2**，D1 是 softmax-matmul，这句应读作 D2（或作者的 D1 里确实含 GQA，那就与任务表矛盾）。②"48 次标量乘法打破 Strassen 1969 年的 49 次"这类宏观战绩出自 AlphaEvolve 原论文与 DeepMind 博客，不在本文的实测范围内，别当成他能复现的东西。

**最能迁移的其实只有三段**：`EVOLVE-BLOCK` 圈出可改范围；evaluator 返回 `runtime_ms` / `correctness` / `score`；以及那三次翻车的具体形状——**用平均运行时打分，agent 就会在长尾输入上退化**（E3 的嵌套 JSON）、**不做留出集的逐例正确性检查，agent 就会在 1/8 的矩阵上静默算错**（F2）、**奖励单样本延迟，agent 就会交出没向量化的版本**（F3）。三条都是"评测器写歪"，跟模型强弱无关。

想接着往下走的三个入口：[OpenEvolve 入门：同心环 1.87 到 2.634](https://www.hubwiz.com/blog/openevolve-beginners-circle-packing-function-minimization/)（作者本人的入门文，5 分钟跑通第一个循环）、[RSI 入门：圈两个标记，让 AI 替你迭代程序](https://www.hubwiz.com/blog/rsi-first-loop-alphaevolve-circle-packing-codelab/)（Google 官方 codelab）、[RSI 优化程序能快多少：平均 3.1 倍](https://www.hubwiz.com/blog/ai-code-optimization-hill-climb-milliseconds/)（同一条思路在真实 IDE 里只兑现 4.6%，讲"尺子"那件事）。

更多 AI 编程与工程化实践，见 [Vibe Coding 技术栈](https://www.hubwiz.com/blog/vibe-coding-stack/)。

---

**来源**

- Chew Loong Nian. *I Pointed OpenEvolve at 18 Algorithms — The 6.2K-Star AlphaEvolve Clone Cheated by 321×*. Towards AI / Medium，2026-05-08。https://pub.towardsai.net/i-pointed-openevolve-at-18-algorithms-the-6-2k-star-alphaevolve-clone-cheated-by-321-8912d8f11e72
- 仓库与当前入口：https://github.com/algorithmicsuperintelligence/openevolve
- Asankhaya Sharma. *OpenEvolve: An Open Source Implementation of Google DeepMind's AlphaEvolve*. Hugging Face Blog，2025-05-20。https://huggingface.co/blog/codelion/openevolve
- 参考：Novikov et al. *AlphaEvolve: A coding agent for scientific and algorithmic discovery*. arXiv 2506.13131。https://arxiv.org/abs/2506.13131

本文由 hubwiz 编译整理，转载请注明出处。