The AI Scientist 深度实战：从 Nature 论文到自进化智能体——端到端科研自动化的架构革命
当 AI 能够独立完成"提出假设 → 编写代码 → 运行实验 → 撰写论文 → 同行评审"的全流程，人类科学家的角色将如何重新定义？本文深入剖析 Sakana AI 的 The AI Scientist 系统，从技术架构到代码实现，全面解读这场科研范式的静默革命。
一、引言：科学史上的里程碑时刻
2026年3月26日，科学界迎来了一个标志性的历史时刻——权威期刊《Nature》正式发表了由 Sakana AI、牛津大学和英属哥伦比亚大学联合研发的"The AI Scientist"系统研究论文。这是人类历史上首次，一个完全由人工智能系统自主完成的科学研究成果登上顶级科学期刊。
更令人震撼的是，该系统生成的一篇论文通过了计算机顶级会议 ICLR 2025 Workshop 的同行盲审，三位审稿人给出的评分分别为 6、7、6（总分10分），平均分 6.33，超过了该 Workshop 的平均录用线。研讨会组织者坦言，如果不是因为预先制定的"AI生成论文自动撤回"协议，这篇论文极大概率会被正式接收。
这不是简单的"AI辅助写作"，而是一个完整的端到端自动化科研系统。它标志着长达几个世纪的人类独占科学发现的时代正在走向终结，也预示着一个全新的"AI驱动科研"时代的开启。
本文将从技术架构、核心算法、代码实现、部署实践等多个维度，深入剖析 The AI Scientist 系统，帮助开发者理解这场科研范式革命的技术本质。
二、背景：为什么需要"AI科学家"？
2.1 传统科研模式的瓶颈
科学研究本质上是一个迭代优化的过程：提出假设、设计实验、收集数据、分析结果、修正理论。这个循环看似简单，但在实际操作中面临诸多效率瓶颈：
文献调研耗时巨大：研究者需要阅读大量文献才能找到研究空白点，这个过程往往占据项目前期30-50%的时间。
实验试错成本高昂：很多实验需要反复调整参数、修复Bug，一个简单的消融实验可能耗费数周。
论文撰写繁琐：从方法描述到图表制作，从文献引用到格式排版，论文撰写是一项"低创造性、高重复性"的工作。
同行评审周期漫长：一篇论文从投稿到接收，平均周期为3-12个月，严重拖慢了科研节奏。
2.2 AI辅助科研的演进路线
AI在科研中的应用经历了三个阶段：
阶段一：工具辅助（2015-2020）
- 语法检查（Grammarly）
- 文献检索（Semantic Scholar）
- 数据可视化（Tableau）
阶段二：能力增强（2020-2024）
- 代码辅助（GitHub Copilot）
- 论文润色（ChatGPT）
- 实验设计建议
阶段三：流程自动化（2024-2026）
- The AI Scientist：端到端自动化
- Darwin Gödel Machine：自进化智能体
- AlphaEvolve：数学问题自动求解
The AI Scientist 代表了第三阶段的最高成就——它不再是"工具"，而是"协作伙伴"，甚至可以说是一个"不知疲倦的超级博士生"。
三、The AI Scientist 系统架构全景
3.1 四大核心阶段
The AI Scientist 系统将科研流程抽象为四个核心阶段，形成完整的闭环：
┌─────────────────────────────────────────────────────────────────┐
│ The AI Scientist Pipeline │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Ideation │───▶│Experiment│───▶│ Write-up │───▶│ Review │ │
│ │ 构思 │ │ 实验 │ │ 撰写 │ │ 评审 │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ 文献查重 代码生成 LaTeX排版 NeurIPS标准 │
│ 假设生成 自动调试 图表绘制 优缺点分析 │
│ 方向筛选 树状搜索 文献引用 接收/拒稿 │
│ │
└─────────────────────────────────────────────────────────────────┘
3.2 架构分层设计
从技术实现角度，系统采用分层架构：
┌─────────────────────────────────────────────────────────────────┐
│ Application Layer │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Idea │ │ Experiment │ │ Paper │ │
│ │ Generator │ │ Manager │ │ Writer │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ Agentic Layer │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Tree │ │ Debug │ │ Review │ │
│ │ Search │ │ Agent │ │ Agent │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ Foundation Layer │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ GPT-4o │ │ Claude │ │ Gemini │ │
│ │ Sonnet │ │ Opus │ │ Pro │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ Tool Layer │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Semantic │ │ Python │ │ LaTeX │ │
│ │ Scholar │ │ Executor │ │ Compiler │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────────────┘
3.3 核心模块解析
3.3.1 灵感构思模块（Ideation）
这是系统的"大脑"，负责提出研究假设。核心逻辑：
# 简化的灵感生成流程
def generate_research_ideas(topic_description, num_ideas=10):
"""
基于研究主题生成创新假设
Args:
topic_description: 研究方向的文字描述
num_ideas: 要生成的假设数量
Returns:
List[ResearchIdea]: 筛选后的研究假设列表
"""
ideas = []
for i in range(num_ideas):
# Step 1: 使用LLM生成初始假设
raw_idea = llm.generate_hypothesis(topic_description)
# Step 2: 文献查重，确保新颖性
novelty_score = semantic_scholar.check_novelty(raw_idea)
if novelty_score < THRESHOLD:
continue # 跳过重复的idea
# Step 3: 可行性评估
feasibility = evaluate_feasibility(raw_idea)
# Step 4: 多轮反思优化
refined_idea = refine_with_reflections(raw_idea, num_reflections=5)
ideas.append(refined_idea)
return rank_and_select(ideas, top_k=3)
关键技术点：
- 新颖性检测：调用 Semantic Scholar API，计算与现有文献的相似度
- 反思机制：让 LLM 对自己提出的假设进行批判性审视
- 多样性保证：通过 temperature 调节和 beam search 确保假设的多样性
3.3.2 实验执行模块（Experimentation）
这是系统的"手脚"，负责代码编写和实验运行。核心架构：
class ExperimentManager:
"""实验管理器：协调代码生成、执行、调试"""
def __init__(self, config):
self.tree_search = AgenticTreeSearch(config)
self.debug_agent = DebugAgent()
self.code_generator = CodeGenerator()
def run_experiment(self, idea: ResearchIdea) -> ExperimentResult:
"""
执行完整的实验流程
"""
# Step 1: 生成初始代码框架
initial_code = self.code_generator.generate(idea)
# Step 2: 树状搜索探索最优方案
search_tree = self.tree_search.build_tree(
root_code=initial_code,
max_depth=5,
num_workers=3
)
# Step 3: 执行并收集结果
results = []
for node in search_tree.get_all_nodes():
try:
result = self.execute_with_sandbox(node.code)
results.append(result)
except ExecutionError as e:
# 自动调试
fixed_code = self.debug_agent.fix(node.code, e)
result = self.execute_with_sandbox(fixed_code)
results.append(result)
# Step 4: 选择最佳结果
return self.select_best_result(results)
**Agentic Tree Search（智能体树状搜索）**是 v2 版本的核心创新：
Root Node (Baseline)
│
┌─────────────┼─────────────┐
│ │ │
Hyperparam Architecture Ablation
Tuning Change Study
│ │ │
┌───┴───┐ ┌───┴───┐ ┌───┴───┐
│ │ │ │ │ │
LR Batch ResNet Trans Drop Reg
0.001 64 Block Form 0.1 0.01
图例：
🟢 Green: 最佳性能节点
🔴 Red: 执行失败节点（需调试）
⚪ White: 待探索节点
搜索策略采用 Best-First Tree Search (BFTS)：
def best_first_tree_search(root, max_nodes=21, num_workers=3):
"""
最佳优先树状搜索
策略：优先扩展评估分数最高的节点
"""
open_list = PriorityQueue()
open_list.put((0, root))
visited = set()
while not open_list.empty() and len(visited) < max_nodes:
# 并行扩展多个节点
batch = []
for _ in range(min(num_workers, open_list.qsize())):
score, node = open_list.get()
if node.id not in visited:
batch.append(node)
# 并行执行扩展
with ThreadPoolExecutor(max_workers=num_workers) as executor:
children_list = list(executor.map(expand_node, batch))
# 更新队列
for node, children in zip(batch, children_list):
visited.add(node.id)
for child in children:
if child.score > THRESHOLD:
open_list.put((-child.score, child)) # 负号实现最大堆
return get_best_leaf(visited)
3.3.3 论文撰写模块（Write-up）
这是系统的"笔杆子"，负责论文生成。核心流程：
class PaperWriter:
"""论文自动撰写器"""
def __init__(self, template="iclr"):
self.template = load_latex_template(template)
self.sections = {
"abstract": self.write_abstract,
"introduction": self.write_introduction,
"method": self.write_method,
"experiments": self.write_experiments,
"related_work": self.write_related_work,
"conclusion": self.write_conclusion
}
def generate_paper(self, experiment_result: ExperimentResult) -> str:
"""
生成完整的LaTeX论文
"""
paper = self.template.copy()
# 逐节生成
for section_name, writer_func in self.sections.items():
content = writer_func(experiment_result)
paper = paper.replace(f"{{{section_name}}}", content)
# 自动生成图表
figures = self.generate_figures(experiment_result)
paper = self.insert_figures(paper, figures)
# 文献引用
paper = self.add_citations(paper, experiment_result.idea)
# 编译验证
self.compile_latex(paper)
return paper
def write_method(self, result: ExperimentResult) -> str:
"""
方法部分撰写：包含数学公式推导
"""
# 提取关键方法
method_description = result.idea.method_description
# 让LLM生成数学形式化
latex_code = llm.generate_latex_equation(method_description)
# 示例：生成的正则化项
# \mathcal{L}_{comp} = \frac{1}{T-1} \sum_{t=1}^{T-1} \| h_{t+1} - h_t \|^2
return latex_code
ICLR 盲审通过的论文片段示例：
\section{Method}
\subsection{Compositional Regularization}
To prevent hidden states from undergoing drastic changes between
consecutive time steps, we introduce a compositional regularization
term defined as:
\begin{equation}
\mathcal{L}_{comp} = \frac{1}{T-1} \sum_{t=1}^{T-1} \| h_{t+1} - h_t \|^2
\end{equation}
where $h_t$ represents the hidden state at time step $t$, and $T$
denotes the sequence length. This regularization encourages smooth
transitions in the representation space, thereby improving
generalization.
3.3.4 自动评审模块（Review）
这是系统的"质检员"，基于 NeurIPS 评审标准：
class AutomatedReviewer:
"""自动化论文评审系统"""
def __init__(self, model="gpt-4o"):
self.model = model
self.criteria = {
"originality": "Is the idea novel?",
"quality": "Is the method technically sound?",
"clarity": "Is the paper well-written?",
"significance": "Is the contribution important?",
"reproducibility": "Can others reproduce the results?"
}
def review_paper(self, paper_path: str) -> ReviewResult:
"""
对论文进行全面评审
"""
paper_content = read_paper(paper_path)
scores = {}
comments = {}
for criterion, question in self.criteria.items():
# 逐项评分
response = llm.evaluate(
paper_content,
question,
model=self.model
)
scores[criterion] = parse_score(response)
comments[criterion] = extract_comments(response)
# 计算总分
overall_score = calculate_weighted_score(scores)
# 生成决策
decision = "Accept" if overall_score >= 6.0 else "Reject"
return ReviewResult(
scores=scores,
comments=comments,
overall_score=overall_score,
decision=decision
)
评审报告示例：
=============================================================
REVIEW REPORT
=============================================================
Paper Title: Compositional Regularization for Neural Network Generalization
Overall Score: 6.33 / 10.0
Decision: Accept (Borderline)
-------------------------------------------------------------
Detailed Scores:
-------------------------------------------------------------
Originality: 6/10 (Novel approach with incremental innovation)
Quality: 7/10 (Solid experimental validation)
Clarity: 6/10 (Well-structured but minor ambiguities)
Significance: 7/10 (Practical value for the community)
Reproducibility: 6/10 (Code provided, but hyperparameters unclear)
-------------------------------------------------------------
Strengths:
-------------------------------------------------------------
1. The proposed compositional regularization is theoretically motivated
2. Experiments cover multiple benchmarks with consistent improvements
3. Ablation studies provide insights into the method's behavior
-------------------------------------------------------------
Weaknesses:
-------------------------------------------------------------
1. Comparison with existing regularization methods is limited
2. The theoretical analysis could be more rigorous
3. Some figures are difficult to read in grayscale
-------------------------------------------------------------
Questions for Authors:
-------------------------------------------------------------
1. How does the method scale to larger models (e.g., 1B+ parameters)?
2. Can you provide more details on the computational overhead?
=============================================================
四、核心算法：Agentic Tree Search 详解
4.1 为什么需要树状搜索？
传统的"单线程"实验流程存在严重缺陷：
传统流程：
Idea → Code → Run → Error → Fix → Run → Success → Done
问题：
1. 只探索一条路径，可能错过更优解
2. 遇到错误后只能回退一步
3. 无法并行探索多个方向
树状搜索将实验过程建模为一个探索问题：
树状搜索：
Root Idea
│
┌─────────────┼─────────────┐
│ │ │
Approach A Approach B Approach C
│ │ │
┌───┴───┐ ┌───┴───┐ ┌───┴───┐
│ │ │ │ │ │
A1 A2 B1 B2 C1 C2
优势：
1. 多路径并行探索
2. 失败节点可回退到任意祖先
3. 自动选择最优分支
4.2 BFTS 算法伪代码
class AgenticTreeSearch:
"""
Agentic Tree Search with Best-First Strategy
"""
def __init__(self, config):
self.max_depth = config.get("max_depth", 5)
self.max_nodes = config.get("max_nodes", 21)
self.num_workers = config.get("num_workers", 3)
self.max_debug_depth = config.get("max_debug_depth", 3)
self.debug_prob = config.get("debug_prob", 0.7)
def search(self, root_idea: ResearchIdea) -> Node:
"""
执行树状搜索，返回最优节点
"""
root = Node(
code=generate_initial_code(root_idea),
idea=root_idea,
depth=0
)
open_list = PriorityQueue()
open_list.put((float('inf'), root))
best_node = root
visited_count = 0
while not open_list.empty() and visited_count < self.max_nodes:
# 并行获取多个候选节点
batch = self._get_batch(open_list, self.num_workers)
# 并行扩展
with ThreadPoolExecutor() as executor:
results = list(executor.map(self._expand_and_execute, batch))
# 处理结果
for node, result in results:
visited_count += 1
if result.success:
# 更新最优节点
if result.score > best_node.score:
best_node = node
# 生成子节点
children = self._generate_children(node, result)
for child in children:
priority = self._calculate_priority(child)
open_list.put((priority, child))
else:
# 尝试调试
if random.random() < self.debug_prob:
fixed_node = self._debug_node(node, result.error)
if fixed_node:
open_list.put((float('inf'), fixed_node))
return best_node
def _expand_and_execute(self, node: Node) -> Tuple[Node, ExecutionResult]:
"""
执行节点代码并返回结果
"""
try:
result = execute_in_sandbox(node.code, timeout=300)
return node, ExecutionResult(success=True, score=result.score)
except Exception as e:
return node, ExecutionResult(success=False, error=str(e))
def _generate_children(self, node: Node, result: ExecutionResult) -> List[Node]:
"""
基于当前结果生成子节点
"""
children = []
# 策略1：超参数调优
for hp in HYPERPARAMS_TO_TUNE:
new_code = modify_hyperparameter(node.code, hp)
children.append(Node(
code=new_code,
idea=node.idea,
parent=node,
depth=node.depth + 1,
strategy="hyperparam_tuning"
))
# 策略2：架构修改
for arch_change in ARCHITECTURE_CHANGES:
new_code = apply_architecture_change(node.code, arch_change)
children.append(Node(
code=new_code,
idea=node.idea,
parent=node,
depth=node.depth + 1,
strategy="architecture_change"
))
# 策略3：消融实验
for component in IDENTIFIED_COMPONENTS:
new_code = ablate_component(node.code, component)
children.append(Node(
code=new_code,
idea=node.idea,
parent=node,
depth=node.depth + 1,
strategy="ablation"
))
return children
def _debug_node(self, node: Node, error: str) -> Optional[Node]:
"""
自动调试失败节点
"""
debug_agent = DebugAgent()
fixed_code = debug_agent.fix(node.code, error)
if fixed_code:
return Node(
code=fixed_code,
idea=node.idea,
parent=node.parent,
depth=node.depth,
strategy="debug"
)
return None
4.3 节点评分策略
def calculate_priority(node: Node) -> float:
"""
计算节点的探索优先级
考虑因素：
1. 当前性能分数
2. 探索深度
3. 多样性奖励
4. 历史改进趋势
"""
# 基础分数
base_score = node.score if node.score else 0
# 深度惩罚（避免过深探索）
depth_penalty = 0.1 * node.depth
# 多样性奖励
diversity_bonus = calculate_diversity(node, visited_nodes)
# 改进趋势
improvement_trend = calculate_improvement_trend(node)
priority = (
base_score * 0.5 +
improvement_trend * 0.3 +
diversity_bonus * 0.2 -
depth_penalty
)
return priority
五、部署实践：从零搭建 AI Scientist
5.1 环境准备
# 创建conda环境
conda create -n ai_scientist python=3.11
conda activate ai_scientist
# 安装PyTorch（根据你的CUDA版本调整）
conda install pytorch torchvision torchaudio pytorch-cuda=12.4 -c pytorch -c nvidia
# 安装PDF和LaTeX工具
conda install anaconda::poppler
conda install conda-forge::chktex
# 克隆仓库
git clone https://github.com/SakanaAI/AI-Scientist-v2.git
cd AI-Scientist-v2
# 安装依赖
pip install -r requirements.txt
5.2 配置API Keys
# 必需：OpenAI API
export OPENAI_API_KEY="your-openai-key"
# 可选：Semantic Scholar API（提高文献检索速度）
export S2_API_KEY="your-s2-key"
# 可选：AWS Bedrock（使用Claude模型）
export AWS_ACCESS_KEY_ID="your-aws-access-key"
export AWS_SECRET_ACCESS_KEY="your-aws-secret-key"
export AWS_REGION_NAME="us-west-2"
5.3 运行完整流程
Step 1: 生成研究假设
创建研究主题描述文件 my_research_topic.md：
# Research Topic: Efficient Attention Mechanisms
## Title
Efficient Attention Mechanisms for Long-Sequence Modeling
## Keywords
Transformer, Attention, Long-Context, Memory Efficiency
## TL;DR
Explore novel attention mechanisms that reduce the quadratic complexity
of standard attention while maintaining model quality.
## Abstract
Standard attention mechanisms in Transformers scale quadratically with
sequence length, limiting their applicability to long sequences. This
project explores efficient attention variants including sparse attention,
linear attention, and memory-efficient implementations.
## Research Questions
1. Can we design an attention mechanism with linear complexity?
2. How does sparse attention compare to full attention on long documents?
3. What are the trade-offs between efficiency and model quality?
运行假设生成：
python ai_scientist/perform_ideation_temp_free.py \
--workshop-file "ai_scientist/ideas/my_research_topic.md" \
--model gpt-4o-2024-05-13 \
--max-num-generations 20 \
--num-reflections 5
输出文件 my_research_topic.json 包含多个候选假设：
{
"ideas": [
{
"id": "idea_001",
"title": "Sliding Window Attention with Adaptive Window Sizes",
"hypothesis": "Adaptive window sizes can improve efficiency while maintaining quality",
"proposed_experiments": [
"Compare fixed vs adaptive windows on LongBench",
"Ablation study on window size selection strategies"
],
"related_work": ["Sparse Transformer", "Longformer", "BigBird"],
"novelty_score": 0.82
},
...
]
}
Step 2: 运行实验并生成论文
python launch_scientist_bfts.py \
--load_ideas "ai_scientist/ideas/my_research_topic.json" \
--model_writeup o1-preview-2024-09-12 \
--model_citation gpt-4o-2024-11-20 \
--model_review gpt-4o-2024-11-20 \
--model_agg_plots o3-mini-2025-01-31 \
--num_cite_rounds 20
配置文件 bfts_config.yaml：
agent_config:
num_workers: 3
steps: 21
num_seeds: 3
search_config:
max_debug_depth: 3
debug_prob: 0.7
num_drafts: 5
model_config:
experiment_model: claude-3-5-sonnet-20241022
writeup_model: o1-preview-2024-09-12
review_model: gpt-4o-2024-11-20
5.4 查看结果
实验完成后，在 experiments/ 目录下会生成：
experiments/
└── 20260523_143022_sliding_window_attention/
├── logs/
│ └── 0-run/
│ └── unified_tree_viz.html # 树状搜索可视化
├── code/
│ ├── baseline.py
│ ├── experiment_1.py
│ └── ...
├── results/
│ ├── metrics.json
│ └── plots/
├── paper.pdf # 生成的论文
└── review.json # 自动评审结果
5.5 安全注意事项
⚠️ 重要警告：AI Scientist 会执行 LLM 生成的代码，存在安全风险。务必在沙箱环境中运行：
# 使用Docker沙箱
docker run --rm -it \
-v $(pwd):/workspace \
-e OPENAI_API_KEY=$OPENAI_API_KEY \
--network none \ # 禁用网络访问
python:3.11-slim \
/bin/bash
# 在容器内运行实验
cd /workspace
python launch_scientist_bfts.py ...
六、进阶：v1 vs v2 深度对比
6.1 架构差异
| 特性 | AI Scientist v1 | AI Scientist v2 |
|---|---|---|
| 模板依赖 | 需要人类编写的代码模板 | 完全无模板，从零开始 |
| 探索策略 | 线性单路径 | Agentic Tree Search |
| 适用领域 | 特定ML任务 | 跨ML领域泛化 |
| 成功率 | 高（有模板指导） | 较低（自由探索） |
| 创新上限 | 受限于模板设计 | 理论上无上限 |
6.2 代码对比
v1 模板模式：
# v1: 人类定义模板，AI填充细节
class TemplateBasedExperiment:
def __init__(self, template_path):
self.template = load_template(template_path)
# 模板包含：数据加载、模型定义、训练循环
def run(self, hyperparams):
# 只需要填入超参数
model = self.template.create_model(**hyperparams)
trainer = self.template.create_trainer(model)
return trainer.train()
v2 无模板模式：
# v2: AI完全自主设计
class TemplateFreeExperiment:
def __init__(self, research_idea):
self.idea = research_idea
self.code_generator = AutonomousCodeGenerator()
def design_from_scratch(self):
# 第一步：设计数据流
data_pipeline = self.code_generator.design_data_pipeline(
self.idea.data_requirements
)
# 第二步：设计模型架构
architecture = self.code_generator.design_architecture(
self.idea.method_description
)
# 第三步：设计训练流程
training_loop = self.code_generator.design_training_loop(
data_pipeline, architecture
)
return integrate(data_pipeline, architecture, training_loop)
6.3 选择建议
使用 v1 的场景：
- 有成熟的代码模板可以复用
- 任务目标明确，创新空间有限
- 需要高成功率、快速产出
使用 v2 的场景：
- 探索全新领域，没有现成模板
- 追求突破性创新
- 有充足的算力和时间预算
七、延伸：Darwin Gödel Machine 与自进化
7.1 从科研自动化到自我进化
The AI Scientist 解决了"科研流程自动化"的问题，但仍有一个核心限制：系统本身的架构是固定的。
2026年5月，Sakana AI 推出的 Darwin Gödel Machine (DGM) 实现了质的飞跃：AI 可以修改自己的代码。
7.2 DGM 核心原理
class DarwinGodelMachine:
"""
Darwin Gödel Machine: 能够自我进化的智能体
核心思想：
1. 智能体可以读取自己的源代码
2. 生成修改提案
3. 在基准测试上验证改进
4. 保留有益修改，形成"进化档案"
"""
def __init__(self, initial_agent):
self.current_agent = initial_agent
self.archive = AgentArchive()
self.archive.add(initial_agent)
def evolve(self, num_generations=100):
"""
执行进化循环
"""
for gen in range(num_generations):
# Step 1: 选择父代（性能越高，被选中概率越大）
parent = self.archive.select_parent()
# Step 2: 变异生成子代
child = self.mutate(parent)
# Step 3: 在基准测试上评估
score = self.evaluate(child)
# Step 4: 如果有改进，加入档案
if score > parent.score:
self.archive.add(child)
print(f"Generation {gen}: Improved! Score: {score:.4f}")
# Step 5: 更新当前最优
if score > self.current_agent.score:
self.current_agent = child
return self.current_agent
def mutate(self, agent):
"""
智能体修改自己的代码
"""
# 读取自身源代码
source_code = agent.get_source_code()
# 让LLM生成修改提案
modification = llm.propose_modification(
source_code,
agent.performance_history
)
# 应用修改
new_code = apply_modification(source_code, modification)
# 创建新智能体
return Agent(code=new_code, parent=agent)
def evaluate(self, agent):
"""
在基准测试上评估智能体
"""
# 使用SWE-bench和Polyglot等标准基准
scores = []
for benchmark in BENCHMARKS:
result = run_benchmark(agent, benchmark)
scores.append(result.score)
return np.mean(scores)
7.3 进化档案机制
DGM 的关键创新是维护一个"进化档案"（Agent Archive），避免陷入局部最优：
class AgentArchive:
"""
智能体档案库：维护多样化的进化路径
"""
def __init__(self, max_size=100):
self.agents = []
self.max_size = max_size
def add(self, agent):
"""添加新智能体，维护多样性"""
if len(self.agents) >= self.max_size:
self._prune()
self.agents.append(agent)
self._update_diversity()
def select_parent(self):
"""
选择父代进行变异
策略：性能越高，子代越多，被选中概率越大
但也要保证多样性，避免所有后代来自同一个体
"""
# 计算选择概率
scores = np.array([a.score for a in self.agents])
diversity_bonus = np.array([self._diversity(a) for a in self.agents])
probabilities = (
softmax(scores / temperature) * 0.7 +
diversity_bonus / diversity_bonus.sum() * 0.3
)
return np.random.choice(self.agents, p=probabilities)
def _diversity(self, agent):
"""计算智能体与档案中其他个体的差异度"""
distances = []
for other in self.agents:
if other != agent:
dist = code_distance(agent.code, other.code)
distances.append(dist)
return np.mean(distances) if distances else 1.0
7.4 实验结果
DGM 在 SWE-bench 和 Polyglot 上的进化曲线：
Generation 1: Score = 23.4% (Baseline)
Generation 5: Score = 28.1% (+4.7%)
Generation 10: Score = 35.6% (+12.2%)
Generation 20: Score = 41.3% (+17.9%)
Generation 50: Score = 48.7% (+25.3%)
Generation 100: Score = 52.1% (+28.7%)
关键进化事件：
- Gen 7: 自主添加了代码预检查机制
- Gen 23: 发现了更高效的错误处理策略
- Gen 45: 实现了自适应的上下文压缩
八、伦理与未来展望
8.1 伦理挑战
1. 学术诚信问题
如果 AI 生成的论文大量涌入学术圈，如何定义"原创性"？如何界定作者身份？
# 假设场景：AI批量生产论文
for i in range(100):
idea = generate_idea()
paper = ai_scientist.run(idea)
submit_to_conference(paper)
# 结果：学术圈被AI论文淹没，人类难以筛选
建议措施：
- 论文必须声明AI参与程度
- 建立"AI生成内容"检测机制
- 调整学术评价体系，从"数量"转向"质量"
2. 知识产权争议
AI 生成的论文，版权归谁？是AI开发者、使用者，还是"无人拥有"？
3. 科研人员转型
传统"科研民工"的工作（调参、画图、写文献综述）可能被自动化，科研人员需要向"研究方向设计者"和"AI系统监督者"转型。
8.2 技术演进方向
短期（1-2年）：
- 多模态论文生成（包含视频、交互式图表）
- 跨学科知识迁移
- 实时协作版本
中期（3-5年）：
- 自进化科研系统（结合DGM）
- 全自动化实验室集成
- 科研知识图谱构建
长期（5-10年）：
- 通用人工智能科学家
- 突破人类认知极限的发现
- 科研范式根本性变革
8.3 人机协作的新范式
未来的科研模式可能是：
┌─────────────────────────────────────────────────────────────────┐
│ Human-AI Collaborative Research │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Human Scientist AI Scientist │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ Define │─────────────▶│ Generate │ │
│ │ Direction │ │ Hypotheses │ │
│ └─────────────┘ └─────────────┘ │
│ │ │ │
│ │ ▼ │
│ │ ┌─────────────┐ │
│ │ │ Run │ │
│ │ │ Experiments │ │
│ │ └─────────────┘ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ Validate │◀─────────────│ Generate │ │
│ │ Insights │ │ Papers │ │
│ └─────────────┘ └─────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ Refine │──────────────────────────────────────┐ │
│ │ Direction │ │ │
│ └─────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────┘ │
│ (Iterative Loop) │
│ │
└─────────────────────────────────────────────────────────────────┘
人类的核心价值：
- 方向把控：决定"什么是值得研究的问题"
- 价值判断：评估研究成果的社会意义
- 伦理监督：确保研究符合道德规范
- 创新整合：将AI的发现融入人类知识体系
AI的核心价值：
- 效率提升：加速实验迭代、论文撰写
- 规模探索：并行测试大量假设
- 知识整合：快速整合跨领域文献
- 质量保证：自动化评审和错误检测
九、总结
The AI Scientist 的出现，标志着科学研究从"手工作坊"时代迈向"工业化"时代。它不是要取代人类科学家，而是要解放科学家从繁琐的重复劳动中，让他们能够专注于真正有价值的事情——提出深刻的问题、设计创新的方向、解读复杂的意义。
核心要点回顾：
- 端到端自动化：从假设到论文，全流程无需人类干预
- 树状搜索策略：Agentic Tree Search 实现多路径并行探索
- 自动评审系统：基于 NeurIPS 标准的客观评价
- 安全部署：必须在沙箱环境中运行，防止代码执行风险
- 自进化前景：结合 Darwin Gödel Machine，AI 将具备自我改进能力
给开发者的建议：
- 如果你从事AI研究：尝试用 AI Scientist 加速你的实验迭代
- 如果你从事科研工具开发：借鉴其架构设计思路
- 如果你关注AI伦理：思考如何规范AI在科研中的使用
未来已来，只是分布不均。The AI Scientist 让我们看到了科学研究的另一种可能——一个由AI驱动的、更高效、更开放、更民主化的科研新时代。
参考资料
- Sakana AI. "The AI Scientist-v2: Workshop-Level Automated Scientific Discovery via Agentic Tree Search." Nature, 2026.
- GitHub: https://github.com/SakanaAI/AI-Scientist-v2
- Sakana AI. "Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents." 2026.
- ICLR 2025 Workshop Paper: "Compositional Regularization for Neural Network Generalization"
本文由程序员茄子原创，转载请注明出处。