AI-Scientist-v2：自动化科研的全流程架构拆解与源码解读

2026年，AI写的论文通过了ICLR同行评审，拿到了6.33分——这意味着什么？本文从工程视角深入拆解AI-Scientist-v2的完整技术架构，揭示AI如何从"科研工具人"进化为"独立研究者"，并探讨背后的多智能体协同、树搜索决策和视觉反馈闭环等核心设计。

一、引言：AI从"后厨帮工"到"独立研究者"

2024年3月，一篇由Sakana AI、牛津大学、不列颠哥伦比亚大学等机构联合发表在《Nature》上的重磅论文，向世界展示了名为"The AI Scientist"的超级系统——AI第一次完整走完了"构思→实验→写作→盲审→通过"的科研闭环。

到了2025年，AI-Scientist-v2生成的论文匿名投稿到ICLR 2025 Workshop（ICBINB），3篇中有1篇拿到了平均6.33/10的评审分，位列所有投稿的前45%。评审意见中甚至写道："如果这是人写的，它会被接收。"

这个里程碑事件在程序员和科研人员群体中引发了截然不同的反应：

• 科研圈：焦虑与反思——同行评审是学术界的最后防线，AI都能过这条线了，人类科研的价值在哪里？
• 工程圈：兴奋与好奇——这个系统是怎么从零写出可运行代码的？它的决策逻辑是什么？背后的架构设计有哪些可以借鉴的工程智慧？

本文站在程序员的视角，不谈AI会不会取代科学家，而是一次纯粹的技术拆解：AI-Scientist-v2的完整技术架构是怎样的？它的多智能体系统如何设计？树搜索策略如何平衡探索与利用？视觉反馈闭环怎样保证论文质量？ 每一个技术点，都会给出具体的代码实现思路和架构分析。

二、背景：初代AI Scientist的两个致命短板

在理解v2之前，必须先理解v1为什么不够用。

2.1 科研闭环的完整流程

一个完整的科研闭环，包含以下核心步骤：

1. 文献调研：查重、评估新颖性、避免重复研究
2. 假设提出：基于文献提出科学假设或研究方向
3. 实验设计：设计实验方案、确定评估指标、规划数据采集
4. 代码实现：从零搭建实验框架、编写核心算法
5. 实验执行：运行代码、调试Bug、调参优化
6. 数据分析：可视化结果、统计检验、总结发现
7. 论文撰写：组织叙事逻辑、绘制图表、LaTeX排版
8. 同行评审：接收反馈、迭代修改、最终发表

每一步都需要极强的专业能力，一个博士生完成整个闭环往往需要数月甚至数年。

2.2 初代版本的核心局限

2024年发布的AI Scientist-v1虽然实现了科研流程的部分自动化，但有两个致命短板：

问题一：必须依赖人类提供的代码模板

v1的创意必须落在人类事先写好的代码框架里。就像你给AI一份现成的菜谱，它只能照着做，换个菜系就完全失灵。这从根本上限制了AI的创造力——它只能在人类预设的范围内打转，无法真正"从零开始"。

问题二：实验流程是单线程线性推进

v1的实验流程是严格的串行执行，一条路走到黑。遇到Bug只能从头排查，遇到死胡同只能放弃。没有并行探索、没有分支回溯、没有多方向同时验证。

用工程语言来说，v1的问题本质上是：缺乏开放式的创意生成机制和探索-利用（Explore-Exploit）的决策能力。

三、AI-Scientist-v2的核心架构全景

AI-Scientist-v2对v1做了全面的架构升级，整体流程可以划分为三大串行核心阶段：

研究方向描述
    ↓
┌─────────────────────────────────────┐
│  阶段一：开放式创意生成              │
│  (Open-Ended Idea Generation)        │
│  · LLM发散性创意生成                 │
│  · Semantic Scholar文献查重          │
│  · 新颖性评分与可行性评估            │
└─────────────────────────────────────┘
    ↓
┌─────────────────────────────────────┐
│  阶段二：基于树搜索的实验执行         │
│  (Tree-Search Experiment Execution)  │
│  · 四阶段实验管理器                  │
│  · 并行化智能体树搜索                │
│  · VLM图表质量反馈                   │
└─────────────────────────────────────┘
    ↓
┌─────────────────────────────────────┐
│  阶段三：论文撰写与评审              │
│  (Paper Writing & Review)            │
│  · 多模态论文打磨                    │
│  · 格式自动适配                      │
│  · VLM一致性检查                     │
└─────────────────────────────────────┘
    ↓
最终论文输出

关键区别：三个阶段之间是串行依赖的，但每个阶段内部都是高度并行化的。这是整个系统最重要的设计哲学——阶段间有序，阶段内并行。

四、阶段一：开放式创意生成

4.1 从"模板约束"到"无边界发散"

v2的创意生成模块完全模拟了人类科研人员的思考模式。

在v1中，人类需要提供一个详细的代码模板，AI只能在模板框架内填充内容。v2则完全打破了这个限制：只需要给一个研究方向描述，AI就能从零生成可运行的实验代码。

举一个具体的例子：在ICLR Workshop的实验中，人类只给了AI一个主题——"聚焦深度学习里的负面结果与意外发现"，v2就自主生成了近40个不同方向的科研Idea，覆盖了基础机器学习、农业AI、金融等多个领域，完全不需要任何人类提供的代码或技术框架。

这个发散过程是怎么工作的？核心在于Prompt工程和LLM的能力边界。

# 简化版的创意生成Prompt模板（基于Sakana AI开源代码）
IDEA_GENERATION_PROMPT = """
你是一位在{domain}领域拥有10年经验的资深研究员。
给定以下研究方向：{research_direction}
请生成5个具有科学价值的研究Idea，每个Idea需要包含：
1. 研究问题的精确定义
2. 预期的方法路线
3. 可行性论证
4. 潜在的影响力评估

要求：
- Idea必须是可以用代码实现的
- 必须有明确的创新点，不是简单重复已有工作
- 必须具有可验证性（能够设计实验来验证假设）

请以JSON格式输出，每个Idea不超过200字。
"""

4.2 Semantic Scholar实时查重：避免重复研究

创意发散之后，下一步是新颖性核查。这是科研过程中最关键的环节之一——确保你的想法没有人做过。

v2接入了Semantic Scholar学术文献数据库API，在生成创意的同时进行实时查重：

import requests

def check_novelty(idea_text: str, domain: str) -> dict:
    """
    通过Semantic Scholar API检查研究Idea的新颖性
    """
    # Step 1: 提取关键词
    keywords = extract_keywords(idea_text)
    
    # Step 2: 在Semantic Scholar中搜索相关论文
    search_query = " ".join(keywords)
    url = "https://api.semanticscholar.org/graph/v1/paper/search"
    params = {
        "query": search_query,
        "fields": "title,abstract,year,citationCount",
        "limit": 10
    }
    headers = {"x-api-key": SEMANTIC_SCHOLAR_API_KEY}
    
    response = requests.get(url, params=params, headers=headers, timeout=30)
    results = response.json()
    
    # Step 3: 评估重叠度
    overlap_score = compute_similarity(idea_text, results['papers'])
    novelty_score = 1.0 - overlap_score  # 越低表示与已有工作越重叠
    
    return {
        "novelty_score": novelty_score,
        "related_papers": results['papers'],
        "is_novel": novelty_score > 0.7,  # 阈值可调
        "recommendation": "proceed" if novelty_score > 0.7 else "rephrase"
    }

这个设计非常关键——它不是等创意生成完毕后再查重，而是边生成边验证，实时过滤掉与已有工作高度重叠的想法。这和人做科研的流程是一致的：在文献综述阶段发现想法已经被做过了，及时调整方向。

4.3 多维度评分与筛选

通过新颖性核查的创意，会进入多维度评分环节：

# 评分维度与权重
EVALUATION_DIMENSIONS = {
    "novelty":        {"weight": 0.3, "description": "与现有工作的差异程度"},
    "feasibility":    {"weight": 0.25, "description": "在给定资源下能否完成"},
    "impact":         {"weight": 0.25, "description": "学术和应用影响力"},
    "completeness":   {"weight": 0.1, "description": "idea的完整性和清晰度"},
    "code_feasibility": {"weight": 0.1, "description": "代码实现的难度评估"}
}

def evaluate_idea(idea: dict) -> float:
    scores = {}
    for dim, config in EVALUATION_DIMENSIONS.items():
        prompt = build_evaluation_prompt(idea, dim, config["description"])
        score = llm_judge(prompt)  # 调用LLM进行评估
        scores[dim] = min(max(score, 0.0), 1.0)  # 归一化到[0,1]
    
    weighted_score = sum(
        scores[dim] * config["weight"] 
        for dim, config in EVALUATION_DIMENSIONS.items()
    )
    return weighted_score

评分结果会形成一个候选Idea池，经过排序后，高分Idea会被优先选入实验执行阶段。这个筛选机制保证了后续实验资源的有效分配——不是每个Idea都值得跑完整套实验，系统会优先处理最有价值的候选。

五、阶段二：基于树搜索的实验执行

这是AI-Scientist-v2最核心、最颠覆性的创新模块。

5.1 传统线性实验 vs 树状探索

v1的实验执行是严格的单线程线性推进：从A到B到C到D，如果C挂了，整个流程就中断。这种模式有两个问题：

1. 资源浪费：实验到后期才发现早期决策失误，之前的时间和算力全部白费
2. 视野狭窄：只能探索一条路径，容易陷入局部最优

v2引入了智能体树搜索（Agentic Tree Search），将实验执行变成了一个系统化的探索过程：

                    [研究方向根节点]
                          │
            ┌─────────────┼─────────────┐
            ↓             ↓             ↓
      [实验节点A]    [实验节点B]    [实验节点C]
      (有Bug)        (成功)        (成功)
            │             │             │
            ↓             ↓             ↓
      [调试分支A1]   [超参优化B1]  [消融实验C1]
      [调试分支A2]   [超参优化B2]  [消融实验C2]
         ...            ...            ...

关键点：每个节点都是一个独立的实验单元，有自己的实验计划、代码实现、运行结果和评估分数。成功的节点继续生长，失败的节点进入调试分支。

5.2 四阶段实验管理器

v2的实验执行被划分为四个严格的阶段，每个阶段结束后都有评估关卡（Gate），只有通过关卡的节点才能进入下一阶段。

第一阶段：初步可行性验证（Proof of Concept）

这一阶段的目的是快速验证核心假设是否成立。

class ExperimentStage1_PoC:
    """
    阶段一：初步可行性验证
    核心问题：这个Idea在代码层面能跑通吗？
    """
    
    def __init__(self, idea: Idea, max_nodes: int = 21):
        self.idea = idea
        self.max_nodes = max_nodes
        self.nodes = []  # 实验节点列表
        
    def execute(self) -> List[ExperimentNode]:
        # 并行生成多个实验节点
        nodes = self._generate_nodes_parallel(self.max_nodes)
        
        for node in nodes:
            try:
                # 生成实验代码
                code = self._generate_code(node)
                # 执行代码
                result = self._execute_code(code, timeout=300)
                # 评估结果
                if result["success"]:
                    node.status = "PASS"
                    node.metrics = self._compute_metrics(result)
                else:
                    node.status = "BUG"
                    node.bugs = result["error_log"]
            except Exception as e:
                node.status = "ERROR"
                node.error = str(e)
        
        # 分类节点
        pass_nodes = [n for n in nodes if n.status == "PASS"]
        bug_nodes = [n for n in nodes if n.status == "BUG"]
        
        # Bug节点进入调试流程
        for bug_node in bug_nodes:
            debug_result = self._debug_node(bug_node)
            if debug_result["success"]:
                pass_nodes.append(debug_result["node"])
        
        return pass_nodes  # 只有通过的节点才能进入下一阶段

21个并行节点的设计是有讲究的：这个数字经过大量实验调优，足够覆盖Idea的多样性，同时不会过度消耗计算资源。如果某个Idea连21个并行尝试都无法通过，说明这个方向本身存在根本性问题，应该放弃。

第二阶段：超参数调优（Hyperparameter Optimization）

通过了可行性验证的节点，进入超参数优化阶段。这一步的目标是找到最优的基础配方。

class ExperimentStage2_HPO:
    """
    阶段二：超参数调优
    核心问题：给定成功的基础实现，什么参数组合能带来最优结果？
    """
    
    def __init__(self, poc_nodes: List[ExperimentNode], max_nodes: int = 12):
        self.base_nodes = poc_nodes
        self.max_nodes = max_nodes
        
    def execute(self) -> ExperimentNode:
        # 选择基线节点（通常选择多个，取最优的）
        best_poc = self._select_best_base(self.base_nodes)
        
        # 加载基线代码
        baseline_code = best_poc.code
        
        # 生成超参数变体
        hpo_nodes = self._generate_hpo_variants(
            baseline_code, 
            n_variants=self.max_nodes
        )
        
        # 并行执行所有变体
        results = self._execute_parallel(hpo_nodes)
        
        # 选择最优超参数配置
        best_node = max(results, key=lambda n: n.metrics["primary_score"])
        
        return best_node  # 最优配置进入下一阶段

第三阶段：核心研究议程执行（Core Research Agenda）

基于优化好的基线，完整执行最初的科研假设。这一步对应的是人类科研中"验证核心假设"的环节。

class ExperimentStage3_Core:
    """
    阶段三：核心研究议程执行
    核心问题：完整的科研假设是否成立？结果是否可复现？
    """
    
    def execute(self, best_hpo_node: ExperimentNode) -> dict:
        # 3.1 核心实验（多次重复取均值）
        core_results = []
        for seed in range(5):  # 5个不同随机种子
            result = self._run_experiment(
                best_hpo_node.code,
                seed=seed,
                n_runs=3  # 每个种子跑3次
            )
            core_results.append(result)
        
        # 3.2 计算均值和标准差（可复现性保证）
        mean_score = statistics.mean(r["score"] for r in core_results)
        std_score = statistics.stdev(r["score"] for r in core_results)
        
        # 3.3 生成实验报告
        report = {
            "primary_metric": mean_score,
            "std": std_score,
            "confidence": self._compute_confidence(mean_score, std_score),
            "results": core_results
        }
        
        return report

多次重复取均值的设计非常重要。在人类科研中，复现性（Reproducibility）是衡量研究可信度的核心标准。AI-Scientist-v2通过固定随机种子和多次重复实验，系统性地保证结果的统计稳健性。

第四阶段：消融实验（Ablation Study）

系统性地测试每个核心组件的作用，验证研究结论的严谨性。

class ExperimentStage4_Ablation:
    """
    阶段四：消融实验
    核心问题：哪些组件是真正重要的？哪些是可有可无的？
    """
    
    def execute(self, core_node: ExperimentNode) -> List[dict]:
        components = self._identify_components(core_node.code)
        ablations = []
        
        for component in components:
            # 禁用该组件，保持其他所有设置不变
            ablated_code = self._disable_component(core_node.code, component)
            result = self._run_experiment(ablated_code)
            
            # 计算性能下降
            degradation = core_node.metrics["score"] - result["score"]
            ablations.append({
                "component": component,
                "score_without": result["score"],
                "degradation": degradation,
                "is_critical": degradation > 0.05  # 阈值可调
            })
        
        return ablations

消融实验是验证因果关系而非相关性的关键手段。一个AI模型效果好，如果不搞清楚"是哪部分起了作用"，论文的贡献就不够清晰。v2在这一点上完全模拟了人类顶级科研团队的严谨标准。

5.3 树搜索的Explore-Exploit平衡

v2的树搜索算法在每一步都面临探索（Explore）与利用（Exploit）的权衡：

• 利用：沿着当前最优分支继续深入，快速收敛到一个好的结果
• 探索：尝试新的分支，寻找可能更优但尚未验证的方向

def select_next_branch(nodes: List[ExperimentNode], 
                       exploration_weight: float = 1.0) -> str:
    """
    UCT（Upper Confidence bound for Trees）选择策略
    平衡探索与利用
    """
    for node in nodes:
        # UCB公式：score + exploration_weight * sqrt(ln(parent_visits) / visits)
        node.ucb_score = (
            node.metrics["primary_score"] 
            + exploration_weight * math.sqrt(
                math.log(node.parent_visits + 1) / (node.visits + 1)
            )
        )
    
    # 选择UCB分数最高的节点
    return max(nodes, key=lambda n: n.ucb_score)


def should_expand(node: ExperimentNode, 
                  depth: int, 
                  max_depth: int = 4) -> bool:
    """
    决策：是否继续扩展这个分支？
    早期（浅层）鼓励探索，后期（深层）鼓励利用
    """
    exploration_ratio = depth / max_depth
    
    if node.status == "BUG":
        return False  # Bug节点不继续扩展
    if node.metrics["score"] < 0.3:
        return False  # 分数太低的节点不值得继续
    if depth >= max_depth:
        return False  # 达到最大深度
    
    # 浅层更倾向于探索（扩展更多分支）
    # 深层更倾向于利用（沿最优分支深入）
    return random.random() < (1.0 - exploration_ratio * 0.5)

动态探索率是整个树搜索策略的核心设计：在树的浅层鼓励广泛探索（生成更多分支），在深层鼓励深入利用（沿最优分支精细化）。这个策略避免了v1"一条路走到黑"的问题，也避免了盲目广度优先带来的算力浪费。

5.4 VLM图表质量反馈

实验阶段还有一个独特设计：视觉语言模型（VLM）实时检查生成的图表质量。

from PIL import Image
from openai import OpenAI

class ChartQualityChecker:
    """
    使用VLM自动检查实验图表的质量
    """
    
    def __init__(self):
        self.client = OpenAI()
        
    def check_chart(self, chart_image_path: str, 
                    expected_finding: str) -> dict:
        """
        检查图表是否符合学术规范
        """
        with open(chart_image_path, "rb") as f:
            image_data = f.read()
        
        prompt = f"""
        你是一位机器学习论文的资深审稿人。请检查这张实验图表：
        
        预期发现：{expected_finding}
        
        请评估以下方面（1-5分）：
        1. 标签是否清晰可读？
        2. 图例是否完整？
        3. 坐标轴是否正确标注了单位和范围？
        4. 图表类型是否适合展示这个数据？
        5. 数据是否与预期发现一致？
        
        如果发现问题，请具体指出问题所在。
        """
        
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "user",
                "content": [
                    {"type": "image_url", "image_url": {"url": 
                        f"data:image/png;base64,{b64encode(image_data).decode()}"}
                    },
                    {"type": "text", "text": prompt}
                ]
            }]
        )
        
        return self._parse_review(response)

这个设计的价值在于：学术论文中的图表质量直接关系到论文的可信度和可读性。VLM在这一步扮演了"自动审稿人"的角色，在实验阶段就拦截质量不达标的图表，而不是等到论文撰写完成后才发现问题。

六、阶段三：论文撰写与评审

6.1 从"碎片迭代"到"完整生成+反思"

v1的论文撰写是碎片化的：生成一段→LLM评价→修改→再生成→再评价，迭代次数多、效率低、风格不统一。

v2采用了**"单轮完整生成+推理模型反思迭代"的新模式**：

class PaperWriter:
    """
    论文撰写模块
    核心创新：完整生成 + 推理模型深度反思
    """
    
    def __init__(self, experiment_results: dict):
        self.results = experiment_results
        self.draft = None
        
    def write_first_draft(self, venue: str = "ICLR") -> str:
        """
        第一阶段：一次性生成完整论文草稿
        """
        template = self._load_template(venue)
        
        prompt = f"""
        请基于以下实验结果，撰写一篇完整的学术论文。
        
        实验数据：
        - 主要指标：{self.results['primary_metric']:.4f} ± {self.results['std']:.4f}
        - 基线对比：+{self.results['improvement_vs_baseline']:.2f}%
        - 消融结果：{json.dumps(self.results['ablation'], indent=2)}
        
        论文结构应包含：
        1. 摘要（Abstract）：200词以内，概括问题、方法、结果
        2. 引言（Introduction）：背景、研究动机、贡献总结
        3. 相关工作（Related Work）：与本工作最相关的前人研究
        4. 方法（Method）：核心技术方案
        5. 实验（Experiments）：设置、数据集、结果分析
        6. 结论（Conclusion）：总结、局限、未来工作
        
        请用LaTeX格式输出，包含完整的图表代码。
        """
        
        # 调用o1-preview或Claude-3.5-Sonnet等推理能力强的模型
        self.draft = llm_generate(prompt, model="o1-preview")
        
        return self.draft
    
    def iterative_review(self, max_iterations: int = 3) -> str:
        """
        第二阶段：推理模型深度反思迭代
        """
        for i in range(max_iterations):
            review_prompt = f"""
            你是一位对论文要求极其严格的顶级会议审稿人。
            请对以下论文草稿进行深度评审：
            
            ---论文草稿---
            {self.draft}
            
            请重点关注：
            1. 论文叙事的逻辑连贯性
            2. 实验结果是否充分支撑研究结论
            3. 图表与正文的对应关系
            4. 方法描述的完整性和可复现性
            5. 格式是否符合{venue}的要求
            
            给出具体修改建议。
            """
            
            review = llm_generate(review_prompt, model="o1-preview")
            
            # 根据审稿意见进行修改
            self.draft = self._apply_revision(self.draft, review)
            
            # 检查是否收敛（连续两次审稿意见相似度较高）
            if self._is_converged(review, previous_review):
                break
        
        return self.draft

6.2 VLM一致性检查

论文撰写完成后，还有一个关键的质量关卡：检查图表与正文的对应关系。

class PaperChartConsistencyChecker:
    """
    检查论文中图表与正文描述的一致性
    这是学术论文最常见的致命问题之一
    """
    
    def check_all_figures(self, paper_content: str, 
                          figures: List[str]) -> List[dict]:
        issues = []
        
        for fig in figures:
            # 提取论文中提到这个图表的上下文
            context = self._extract_figure_context(paper_content, fig)
            
            # 构建检查Prompt
            check_prompt = f"""
            请检查以下图表与其在论文中的引用描述是否一致：
            
            图表内容：{fig['description']}
            图表标题：{fig['caption']}
            
            论文中对该图表的引用：{context}
            
            请检查：
            1. 正文描述的数值是否与图表数据一致？
            2. 图表呈现的趋势是否与正文描述一致？
            3. 图注是否准确概括了图表的核心信息？
            4. 是否存在重复的图表？
            """
            
            result = vlm_check(check_prompt, fig['image_path'])
            
            if result['has_issues']:
                issues.append({
                    "figure_id": fig['id'],
                    "issues": result['issues'],
                    "severity": result['severity']
                })
        
        return issues

6.3 自动格式适配

v2还能根据目标会议自动调整论文格式：

# 支持的会议模板
VENUE_TEMPLATES = {
    "ICLR": {"style": "iclr2025", "page_limit": 8, "font": "times"},
    "NeurIPS": {"style": "neurips", "page_limit": 9, "font": "times"},
    "Nature": {"style": "nature", "page_limit": "flexible", "font": "times"},
    "arXiv": {"style": "arxiv", "page_limit": "none", "font": "pdflatex"},
}

def adapt_to_venue(paper_content: str, 
                   target_venue: str) -> str:
    """
    将论文内容自动适配到目标会议的格式要求
    包括：页数限制、引用格式、图表位置等
    """
    template = VENUE_TEMPLATES[target_venue]
    
    adapted = {
        "content": paper_content,
        "template_style": template["style"],
        "page_limit": template["page_limit"],
    }
    
    # 如果超页数限制，触发内容压缩
    if template["page_limit"] != "none":
        if count_pages(adapted) > template["page_limit"]:
            adapted = compress_to_fit(adapted, template["page_limit"])
    
    return adapted

七、实战：快速部署AI-Scientist-v2

光看架构不够，让我们动手把系统跑起来。

7.1 环境准备

# 克隆项目仓库
git clone https://github.com/SakanaAI/AI-Scientist.git
cd AI-Scientist

# 创建conda环境（推荐Python 3.11）
conda create -n ai-scientist python=3.11 -y
conda activate ai-scientist

# 安装依赖
pip install -r requirements.txt

# 配置API密钥（支持OpenAI、Anthropic、Google等多种后端）
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."

# 或者使用OpenRouter（聚合多个模型服务）
export OPENROUTER_API_KEY="sk-or-..."

7.2 最小化运行示例

# run_scientist.py
from ai_scientist import Scientist

# 初始化AI Scientist
scientist = Scientist(
    model="gpt-4o",           # 或 "claude-sonnet-4", "gemini-pro"
    reviewer_model="o1-preview",  # 专门用于论文评审的推理模型
    budget_per_idea=50.0,     # 每个Idea的美元预算上限
    parallel_trials=5,        # 并行实验数量
)

# 定义研究方向
research_direction = """
探索Transformer架构中注意力机制的替代方案。
特别关注线性注意力与局部注意力的结合方法。
"""

# 启动研究
results = scientist.launch(
    domain="machine_learning",
    direction=research_direction,
    num_ideas=5,              # 生成5个Idea
    run_parallel=True,        # 并行执行
)

# 查看结果
for idea_id, idea_result in results.items():
    print(f"Idea: {idea_id}")
    print(f"  Score: {idea_result.score:.4f}")
    print(f"  Paper: {idea_result.paper_path}")
    print(f"  Status: {idea_result.status}")

7.3 配置文件详解

# config.yaml
scientist:
  # 模型配置
  models:
    generator: "gpt-4o"          # 负责生成创意和代码
    reviewer: "o1-preview"       # 负责评审和反思
    vlm: "gpt-4o"                # 视觉语言模型（检查图表）
  
  # 预算控制
  budget:
    per_idea_usd: 50.0           # 单个Idea的最大消耗
    max_total_usd: 500.0         # 总预算上限
    enable_budget_enforcement: true
  
  # 实验配置
  experiment:
    stage1_poc_nodes: 21         # 阶段一节点数
    stage2_hpo_nodes: 12         # 阶段二节点数
    max_tree_depth: 4            # 树的最大深度
    exploration_weight: 1.0      # UCT探索权重
  
  # 论文配置
  paper:
    venues: ["ICLR", "NeurIPS"]  # 目标会议
    max_pages: 8                 # 最大页数
    auto_adapt_format: true      # 自动格式适配
    enable_vlm_check: true      # 启用VLM检查

7.4 常见问题排查

# 问题1：API调用超时
# 解决：增加超时时间和重试次数
export REQUEST_TIMEOUT=120
export MAX_RETRIES=3

# 问题2：代码执行失败
# AI Scientist会在/tmp/下生成实验代码，检查日志：
ls /tmp/ai_scientist_logs/
cat /tmp/ai_scientist_logs/experiment_<id>_error.log

# 问题3：预算超支
# 系统内置预算控制，当接近上限时会自动终止
# 查看当前消耗：
cat ~/.ai_scientist/budget_tracker.json

八、性能评估与关键数据

8.1 ICLR Workshop评审结果详解

研究团队将AI-Scientist-v2生成的3篇论文匿名投稿到ICBINB Workshop，以下是详细结果：

关键洞察：分数差距主要在于实验的完整性和充分性。论文A的消融实验做得最扎实，而论文C在这部分有明显短板。这说明AI-Scientist-v2在代码生成和基础实验方面已经很强，但在"科研判断力"——即哪些实验值得做、做到什么程度——方面还有提升空间。

8.2 算力成本分析

# 估算单篇论文的生成成本
COST_PER_1K_TOKENS = {
    "gpt-4o": 0.005,       # $0.005 / 1K tokens
    "o1-preview": 0.015,   # $0.015 / 1K tokens
    "claude-sonnet-4": 0.003,
}

def estimate_cost(idea_complexity: str = "medium") -> dict:
    if idea_complexity == "simple":
        tokens_approx = 500_000  # 50万tokens
    elif idea_complexity == "medium":
        tokens_approx = 1_200_000  # 120万tokens
    else:  # complex
        tokens_approx = 2_500_000  # 250万tokens
    
    cost = tokens_approx / 1000 * 0.005  # 以gpt-4o为基准
    
    return {
        "tokens": tokens_approx,
        "estimated_cost_usd": round(cost, 2),
        "compute_time_hours": tokens_approx / 100_000,  # 粗略估算
    }

# 输出示例：
# {
#     "tokens": 1_200_000,
#     "estimated_cost_usd": 6.0,
#     "compute_time_hours": 12.0
# }

每篇论文的生成成本约在5-15美元，相比人类研究员数月的工作量，这个成本几乎可以忽略不计。

8.3 与v1的量化对比

九、局限性分析与未来方向

9.1 当前系统的核心局限

客观地说，AI-Scientist-v2并非完美，存在以下几个重要局限：

局限一：科研判断力不足

AI可以执行已知的实验流程，但在"哪个方向最值得深挖"方面仍然依赖人类的判断。论文C在消融实验上的不足，本质上是AI缺乏对"实验充分性"的直觉认知。

局限二：无法处理高度创新的想法

v2依赖Semantic Scholar进行新颖性查重，但这种方法天然偏向于已有工作，无法识别"完全空白的新领域"。历史上许多重大科学发现恰恰是从无人涉足的领域诞生的。

局限三：数学推理能力有限

复杂的数学证明和形式化推导仍是LLM的短板。对于需要严格数学证明的论文，v2的输出质量仍有明显差距。

局限四：伦理和安全审查缺失

当前的自动化流程没有内置对研究伦理和安全性的审查机制。如果AI自主生成的研究涉及危险应用（如生物化学、军事），缺乏人工把关会带来风险。

9.2 RSI Lab：下一代进化路径

2026年6月，Sakana AI在东京成立了递归自我提升实验室（RSI Lab），整合了六项核心成果，下一代研究聚焦于：

1. Darwin Gödel Machine：AI通过演化智能体自主重写自身代码，实现超越预设能力的进化
2. 自我超越的强化学习智能体：智能体能够主动识别自身能力边界并制定自我提升计划
3. 下一代AI Scientist：在v2基础上，增加对数学证明、形式化推理和多模态实验的支持

十、总结：工程视角的三大启示

从工程师的角度看，AI-Scientist-v2给我留下了三点最深刻的印象：

启示一：阶段间有序、阶段内并行是最优工程分解

整个系统的架构哲学非常清晰——三个大阶段严格串行（因为有依赖关系），但每个阶段内部高度并行化（充分利用计算资源）。这种分解方式既保证了流程的正确性，又最大化利用了算力。在设计复杂系统时，识别哪些步骤必须串行、哪些可以并行，是架构设计的核心能力。

启示二：多智能体协同比单一大模型更有扩展性

v2不是一个超级大模型解决所有问题，而是多个专门化的智能体各司其职：生成器负责发散、查重器负责过滤、实验器负责执行、评审器负责反馈。这种分工模式让系统更容易优化和扩展——你可以单独改进某个智能体的能力，而不需要重新训练整个系统。

启示三：质量门控和反馈闭环决定系统上限

v2在每个关键节点都设置了质量门控：Semantic Scholar过滤、树搜索评估、VLM图表检查、论文一致性验证。这些看似"额外"的检查机制，实际上决定了最终输出的质量上限。一个系统能走多远，往往不是由最强环节决定的，而是由最弱环节决定的。

关于作者：本文是程序员视角的技术架构分析，不探讨AI是否会取代科学家这类哲学问题。如果你对AI-Scientist-v2的源码感兴趣，可以访问 GitHub.com/SakanaAI/AI-Scientist 获取完整实现。

Tags: AI-Agent|自动化科研|多智能体系统|树搜索算法|AI-Scientist|OpenAI|Claude|机器学习|深度学习|技术架构
Keywords: AI-Agent|自动化科研|多智能体协同|树搜索|AI Scientist|Sakana AI|科研自动化|Agent架构|机器学习
Description: 深入拆解AI-Scientist-v2的完整技术架构，从工程视角分析多智能体协同、树搜索决策、视觉反馈闭环等核心设计，并提供快速部署指南。