Agent 竞赛优化技巧
本文档整理自 Kaggle Agent 相关竞赛的高分方案、学术论文及实战经验，涵盖 Agent 架构设计、Prompt 工程、记忆管理、工具使用、搜索规划等核心优化技巧。
一、Agent 架构设计
1.1 多智能体协作框架
| 维度 |
说明 |
| 核心思想 |
将数据科学流程分解为多个阶段，每个阶段由专门的 Agent 负责 |
| 典型角色 |
Reader（理解赛题）、Planner（规划方案）、Developer（编写代码）、Reviewer（审查代码）、Summarizer（生成报告） |
| 协作方式 |
阶段间传递状态和上下文，每个 Agent 专注于特定任务 |
| 竞赛价值 |
比单 Agent 方案更稳定，各阶段质量可控，错误传播减少 |
| 代表方案 |
AutoKaggle（ICLR 2025）、Agent K v1.0（华为诺亚） |
1.2 分阶段工作流
赛题理解 → 初步EDA → 数据清洗 → 深度EDA → 特征工程 → 建模验证预测
↓ ↓ ↓ ↓ ↓ ↓
Reader Planner Developer Reviewer Developer Summarizer
| 阶段 |
关键动作 |
输出 |
| 赛题理解 |
读取赛题描述、数据字典、评估指标 |
任务类型、目标列、特征列表 |
| 初步EDA |
数据形状、缺失值、分布统计 |
数据概览报告 |
| 数据清洗 |
缺失值处理、异常值处理、类型修正 |
清洗后的数据集 |
| 深度EDA |
特征相关性、目标分布、泄漏检测 |
特征分析报告 |
| 特征工程 |
交叉特征、聚合特征、编码转换 |
特征矩阵 |
| 建模验证 |
K折训练、OOF预测、模型融合 |
最终提交文件 |
1.3 多模型 Agent 协同
| 维度 |
说明 |
| 实践案例 |
Chris Deotte 使用 GPT-5.4 Pro + Gemini 3.1 Pro + Claude Opus 4.6 三个 Agent 协同 |
| 分工策略 |
不同 Agent 负责不同实验方向（EDA、基线、特征工程、模型融合） |
| 成果 |
生成 60 万+ 行代码，运行 850 个实验，4 层 Stack 150 个模型获得第一名 |
| 关键 |
人类在环（Human-in-the-loop）控制方向，Agent 负责执行和迭代 |
二、Prompt 工程
2.1 系统 Prompt 优化
| 维度 |
说明 |
| 清晰简洁 |
使用简单直接的语言，既具体又灵活 |
| 结构化组织 |
用 XML 标签或 Markdown 标题划分部分（背景、指令、工具指南、输出格式） |
| 最少话术原则 |
先用最佳模型测试包含所有预期的最少话术，再根据失效模式添加指令 |
| 示例驱动 |
用 <good-example> 和 <bad-example> 明确区分可取和不可取的行为 |
| 强调式指令 |
使用 "IMPORTANT"、"NEVER"、"ALWAYS" 等强调词引导关键规则 |
2.2 典型 Prompt 模板
EDA 阶段：
"Please write and run EDA code to understand the CSV files train.csv and test.csv"
基线构建：
"Please write full code pipeline to read train.csv and test.csv and train a kfold XGBoost model. Save the OOF and Test PREDS to disk as Numpy files. Display the metric score each fold and overall."
特征工程：
"Can you please try creating new features from [specific columns]? Try interactions, aggregations, and encodings. Save OOF and Test predictions."
模型融合：
"Can you please try combining all our OOF and Test PREDs using various meta models? Please try Hill Climbing, Ridge/Logistic regression, NN, and GBDT stackers."
2.3 Prompt 反模式
| 反模式 |
问题 |
改进 |
| 塞满边缘情况 |
Prompt 过长，模型忽略关键指令 |
用多样化示例替代规则堆砌 |
| 过于笼统 |
模型行为不可预测 |
提供具体约束和输出格式 |
| 假设共享上下文 |
Agent 不知道之前步骤的结果 |
显式传递状态和中间结果 |
| 脆弱 if-else |
硬编码逻辑无法适应新情况 |
提供启发式规则和判断标准 |
三、记忆管理
3.1 多层记忆架构
| 记忆类型 |
作用 |
类比 |
| Session（短期） |
单次对话的上下文 |
应用状态（临时） |
| Working Memory（工作） |
当前任务的推理状态 |
工作内存 |
| Long-term Memory（长期） |
跨对话的经验和知识 |
数据库（持久） |
3.2 记忆管理策略
| 策略 |
说明 |
竞赛价值 |
| 自适应记忆 |
平衡近期详细上下文与历史摘要 |
避免上下文溢出，保留关键经验 |
| 经验提取 |
LLM 驱动的巩固，提取关键事实而非原始消息 |
存储"学习到的教训"而非原始日志 |
| 语义检索 |
基于含义的检索，而非关键词匹配 |
查询"验证分数下降"匹配"过拟合处理经验" |
| 跨任务迁移 |
共享长期记忆实现知识迁移 |
之前赛题的经验可应用于新赛题 |
3.3 Agent K 记忆机制
| 动作类型 |
说明 |
| 长期记忆动作 |
管理外部数据库，将经验转化为决策指导 |
| 内部动作 |
更新工作记忆，塑造推理过程 |
| 外部动作 |
与环境交互，执行任务并获取奖励 |
四、工具设计与使用
4.1 工具库构建
| 工具类别 |
具体工具 |
用途 |
| 代码执行 |
Python REPL、Notebook 执行 |
运行生成的代码 |
| 调试工具 |
错误追踪、单元测试 |
验证代码正确性 |
| 数据操作 |
pandas、cuDF（GPU 加速） |
数据处理和分析 |
| 建模工具 |
XGBoost、LightGBM、sklearn |
模型训练和预测 |
| 可视化 |
matplotlib、seaborn |
EDA 图表生成 |
| 超参优化 |
HEBO、Optuna |
自动调参 |
4.2 GPU 加速
| 维度 |
说明 |
| 核心优势 |
GPU 加速 pandas 操作（cuDF）可带来 10x~150x 速度提升 |
| 关键洞察 |
Agent 分析数据时，LLM 推理只需 1~2 秒，但数据处理可能很慢 |
| 加速库 |
cuDF（数据）、cuML（机器学习）、XGBoost GPU、PyTorch |
| 竞赛价值 |
初始探索从 30 分钟缩短到 3 分钟，相同时间内可迭代更多假设 |
| Kaggle 环境 |
免费 Kaggle GPU（T4/P100）即可运行完整 Agent 工作流 |
4.3 工具使用最佳实践
| 实践 |
说明 |
| 命名对象管理 |
允许 Agent 灵活命名、保存和检索中间结果 |
| 工具动态选择 |
根据当前阶段从配置文件确定需要的工具 |
| 工具遮蔽 |
在特定阶段隐藏不相关工具，减少 Agent 决策负担 |
| 工具组合 |
复杂任务需要多个工具协同（如 EDA → 特征工程 → 建模） |
五、搜索与规划策略
5.1 ReAct（Reasoning + Acting）
| 维度 |
说明 |
| 核心思想 |
交替生成推理轨迹和任务特定动作 |
| 循环模式 |
Thought → Action → Observation → Thought → ... |
| 优势 |
动态适应环境反馈，结合内部推理与外部工具 |
| 局限 |
在复杂 ML 流水线中难以生成有效的工具序列 |
| 适用 |
简单到中等复杂度的单步骤任务 |
5.2 树搜索方法
| 方法 |
说明 |
竞赛表现 |
| MCTS |
蒙特卡洛树搜索，探索代码优化路径 |
单独使用效果有限，状态评分不一致 |
| LATS |
语言 Agent 树搜索，结合 LLM 评估 |
比 MCTS 更稳定，但计算成本高 |
| MCTS-Shaped |
带形状奖励的 MCTS + 结构化文本反馈 |
在 ML-Tool-Bench 上表现最佳 |
| Hierarchical MCTS |
分层 MCTS，先规划阶段再规划动作 |
适合长流程任务 |
5.3 MCGS（Monte Carlo Graph Search）
| 维度 |
说明 |
| 核心改进 |
在 MCTS 基础上引入图结构，支持轨迹回溯、跨分支引用、多分支聚合 |
| 解决痛点 |
传统树搜索中节点孤立，高质量方案分散在不同分支 |
| 竞赛价值 |
AutoMLGen 在 MLE-Bench 上获得冠军（12 小时预算内） |
| 知识复用 |
允许历史轨迹复用和跨分支知识迁移 |
5.4 搜索策略选择指南
任务复杂度
|
+-- 简单单步: ReAct
|-- 中等多步: MCTS / LATS
|-- 复杂长流程: MCTS-Shaped / Hierarchical MCTS
+-- 需要知识复用: MCGS
六、调试与错误处理
6.1 Debug Chain 机制
| 维度 |
说明 |
| 核心思想 |
结构化、系统化的调试链，迭代修复错误代码 |
| 流程 |
执行 → 捕获错误 → LLM 分析原因 → 生成修复 → 重新执行 |
| 单元测试 |
每个阶段用单元测试验证正确性 |
| 自动恢复 |
无需人工干预的自我修正能力 |
| 竞赛价值 |
Agent K 在单元测试失败时自动生成修复方案 |
6.2 错误分类与处理
| 错误类型 |
处理方式 |
| 语法错误 |
LLM 直接修复代码 |
| 运行时错误 |
分析堆栈追踪，定位问题代码 |
| 逻辑错误 |
通过单元测试发现，LLM 重新设计逻辑 |
| 数据错误 |
检查数据形状、类型、缺失值 |
| 资源错误 |
内存不足时启用梯度检查点或减小 batch size |
七、实验管理与迭代
7.1 实验追踪
| 维度 |
说明 |
| 保存策略 |
每次实验（无论好坏）都保存 OOF 和 Test 预测到磁盘 |
| 记录内容 |
CV 分数、特征列表、模型参数、训练时间 |
| 命名规范 |
实验名包含关键信息（模型_特征_分数） |
| 版本控制 |
用 Git 或文件名版本管理代码迭代 |
7.2 迭代加速技巧
| 技巧 |
说明 |
| 快速基线 |
先用最简单模型跑通全流程，再逐步优化 |
| 并行实验 |
多个 Agent 同时探索不同方向 |
| 增量改进 |
每次只改变一个变量（特征/模型/参数） |
| 早停机制 |
CV 分数不提升时停止该方向探索 |
| 经验积累 |
将成功和失败的实验都记录到长期记忆 |
7.3 模型融合自动化
| 方法 |
说明 |
| Hill Climbing |
贪心选择最优模型组合 |
| Ridge/Logistic 堆叠 |
用线性模型融合多个模型预测 |
| NN 堆叠 |
用神经网络学习模型权重 |
| GBDT 堆叠 |
用树模型捕捉非线性关系 |
| 四层 Stack |
Chris Deotte 方案：150 个模型分 4 层融合 |
八、人类在环工作流
8.1 人机分工
| 角色 |
人类负责 |
Agent 负责 |
| 方向控制 |
决定探索方向、选择模型类型 |
执行具体代码、报告结果 |
| 质量审查 |
检查特征合理性、数据泄漏 |
生成代码、运行实验 |
| 创意输入 |
提出新特征想法、领域知识 |
实现想法、评估效果 |
| 最终决策 |
选择提交方案、调整策略 |
生成候选方案、提供数据 |
8.2 干预时机
| 时机 |
人类动作 |
| EDA 后 |
审查数据理解是否正确，补充领域知识 |
| 基线后 |
评估 CV 分数是否合理，决定下一步方向 |
| 特征工程后 |
检查特征是否有意义，排除泄漏特征 |
| 模型融合前 |
选择哪些模型参与融合，设定融合策略 |
| 提交前 |
最终审查，确认无数据泄漏和过拟合 |
九、典型 Agent Pipeline
9.1 表格数据竞赛 Pipeline
1. 赛题理解
└── Agent 读取描述、数据字典、评估指标
└── 输出：任务类型、目标列、特征列表
2. 初步 EDA
└── Agent 编写并运行 EDA 代码
└── 输出：数据形状、缺失值、分布统计
3. 基线构建
└── Agent 训练 XGBoost/LightGBM 基线
└── 输出：CV 分数、OOF 预测、Test 预测
4. 特征工程
└── Agent 尝试交叉特征、聚合特征、编码
└── 输出：改进的 CV 分数、新特征列表
5. 模型调参
└── Agent 使用 Optuna/HEBO 自动调参
└── 输出：最优参数、最终 CV 分数
6. 模型融合
└── Agent 尝试 Hill Climbing、Stacking
└── 输出：融合后的 Test 预测
7. 生成提交
└── Agent 格式化提交文件
└── 输出：submission.csv
9.2 多模态竞赛 Pipeline
| 阶段 |
工具/方法 |
| 数据理解 |
模态检测（文本/图像/音频） |
| 预处理 |
对应模态的专用处理库 |
| 特征提取 |
预训练模型（BERT/ViT/Perch） |
| 建模 |
深度学习框架（PyTorch） |
| 融合 |
多模态融合策略 |
十、竞赛评估指标
10.1 Agent 性能指标
| 指标 |
说明 |
优秀标准 |
| 有效提交率 |
成功提交且格式正确的比例 |
> 0.85 |
| 超过中位数比例 |
提交分数超过中位数的比例 |
> 0.40 |
| 平均百分位排名 |
所有提交的平均百分位 |
< 45（越低越好） |
| 奖牌获得率 |
获得奖牌（金/银/铜）的比例 |
> 0.25 |
10.2 代表方案表现
| 方案 |
模型 |
有效提交率 |
超过中位数 |
平均百分位 |
奖牌率 |
| PiML |
o3-mini |
- |
41.0% |
44.7 |
29.5% |
| AIDE |
GPT-4o |
- |
30.8% |
38.8 |
23.1% |
| AutoKaggle |
- |
0.85 |
- |
- |
综合 0.82 |
| Agent K |
- |
- |
- |
- |
6 金 3 银 7 铜 |
| AutoMLGen |
- |
- |
- |
- |
MLE-Bench 冠军 |
十二、强化学习算法与优化
12.1 算法选择矩阵
| 算法 |
适用场景 |
优势 |
劣势 |
代表项目 |
| PPO |
连续/离散动作，需要稳定训练 |
样本效率好，超参数鲁棒 |
需要大量环境交互 |
Halite IV (gmoss13) |
| DQN |
离散动作空间 |
实现简单，值函数学习 |
过估计问题 |
Halite IV (Lund) |
| IMPALA |
大规模分布式训练 |
高吞吐，离线策略 |
实现复杂 |
Lux AI S3 (Flat Neurons) |
| AlphaZero |
完美信息博弈 |
无需人类知识，自进化 |
计算资源需求大 |
Connect X (第 9 名) |
| SARSA |
在线策略学习 |
保守策略，安全 |
收敛慢 |
Connect X |
| Q-Learning |
离线策略学习 |
探索性好 |
不稳定 |
Connect X |
| A3C |
异步并行训练 |
训练速度快 |
梯度冲突 |
Maze Crawler (参考) |
12.2 网络架构设计
通用架构模式
输入层 (状态表示)
↓
特征提取层 (CNN/MLP)
↓
时序建模层 (LSTM/GRU/ConvLSTM)
↓
注意力层 (Transformer/Self-Attention)
↓
策略头 (动作概率分布)
价值头 (状态价值估计)
Lux AI S3 第一名 (Flat Neurons)
输入: 1000+ 特征/瓦片
↓
24 残差块 (空间特征提取)
↓
ConvLSTM (时序建模，处理部分可观测)
↓
4 层 Transformer (全局注意力，多智能体交互)
↓
策略头 + 价值头
训练: 20B+ 步
Halite IV (gmoss13)
双网络架构:
- 船只动作网络: 控制采集船
- 船坞动作网络: 控制船坞建造
算法: PPO
训练: 自对战
Connect X (AlphaZero)
输入: 棋盘状态 (6x7 或可变)
↓
残差网络 (类似 ResNet)
↓
策略头 (每列落子概率)
价值头 (胜率估计)
搜索: MCTS + 神经网络指导
12.3 训练策略优化
自对战训练 (Self-Play)
# 伪代码: 自对战训练循环
def self_play_training(agent, opponent_pool):
for iteration in range(num_iterations):
# 从对手池采样
opponent = sample_from_pool(opponent_pool)
# 对弈生成数据
game_data = play_game(agent, opponent)
# 更新 agent
agent.train(game_data)
# 更新对手池
if agent.improved():
opponent_pool.add(agent.copy())
关键设计:
- 维护历史版本对手池
- 避免过拟合单一策略
- 持续进化策略多样性
奖励函数设计
| 技术 |
原理 |
应用 |
效果 |
| 动态奖励缩放 |
根据训练进度自动调整奖励尺度 |
Lux AI S3 |
稳定训练，避免梯度爆炸 |
| 奖励塑形 |
添加中间奖励引导学习 |
Halite IV |
加速收敛，引导探索 |
| 稀疏奖励处理 |
到达目标 + 奖励，每步 - 小惩罚 |
Maze Crawler |
解决信用分配问题 |
| 课程学习 |
从简单到复杂环境 |
通用 |
逐步提升难度 |
探索与利用平衡
| 方法 |
公式/机制 |
适用场景 |
| 自适应熵正则化 |
动态调整熵系数 |
Lux AI S3 |
| Epsilon-greedy 衰减 |
ε = ε_0 * decay^step |
Halite IV |
| UCB 探索 |
Q(s,a) + c * sqrt(ln N(s) / N(s,a)) |
MCTS |
| 噪声注入 |
动作 + 高斯噪声 |
连续控制 |
12.4 特征工程
密集特征设计 (Lux AI S3 案例)
# 每瓦片 1000+ 特征
features_per_tile = {
# 连续特征 (100 个)
'resource_amount': float,
'distance_to_base': float,
'unit_health': float,
'enemy_density': float,
# 独热编码离散特征
'tile_type': one_hot(10), # 地形类型
'unit_type': one_hot(5), # 单位类型
'ownership': one_hot(3), # 归属
'visibility': one_hot(2), # 可见性
}
十三、博弈搜索类 Agent
13.1 搜索算法对比
| 算法 |
时间复杂度 |
空间复杂度 |
适用场景 |
Connect X 得分 |
| Greedy |
O(b) |
O(1) |
实时决策 |
268 |
| Minimax |
O(b^d) |
O(bd) |
完美信息 |
873 |
| Alpha-Beta 剪枝 |
O(b^(d/2)) |
O(bd) |
完美信息 |
873+ |
| MCTS |
O(N) |
O(N) |
大分支因子 |
1075 |
| MCTS-Minimax 混合 |
O(N * b^k) |
O(N + bk) |
混合场景 |
980 |
| AlphaZero |
O(N * 迭代) |
O(网络参数) |
自进化 |
1282 |
b = 分支因子, d = 搜索深度, N = 模拟次数
13.2 优化技术
Bitboard 位运算 (Connect X Championship Agent)
# 传统表示 vs Bitboard
# 传统: 6x7 二维数组
board = [[0]*7 for _ in range(6)]
# Bitboard: 两个 64 位整数
player1_board = 0b... # 玩家 1 棋子位置
player2_board = 0b... # 玩家 2 棋子位置
# 优势: 100 倍速度提升
# - 位运算并行检查
# - 缓存友好
# - 快速胜负判断
置换表 (Zobrist 哈希)
# 伪代码: 置换表缓存
zobrist_table = {} # 状态哈希 -> 评估值
def evaluate_with_transposition(state):
hash_key = zobrist_hash(state)
if hash_key in zobrist_table:
return zobrist_table[hash_key] # 缓存命中
value = deep_evaluate(state)
zobrist_table[hash_key] = value
return value
开局库设计
# 预计算开局序列
opening_book = {
'empty_board': [3, 3, 2, 4, ...], # 最优开局序列
'response_patterns': {...}, # 常见局面应对
}
# 优势:
# - 避免早期搜索
# - 保证开局质量
# - 节省计算时间
13.3 评估函数设计
模式识别评估 (Connect X)
def evaluate_board(board, player):
score = 0
# 检查所有可能的连线
for line in all_possible_lines(board):
player_count = count(line, player)
opponent_count = count(line, opponent)
if player_count == 4:
score += WIN_SCORE
elif player_count == 3 and opponent_count == 0:
score += THREE_IN_A_ROW
elif player_count == 2 and opponent_count == 0:
score += TWO_IN_A_ROW
return score
十四、混合方法设计
14.1 RL + 规则混合架构
Halite IV 第一名 (ttvand)
决策流程:
输入状态
↓
规则引擎 (处理确定性逻辑)
├── 简单情况: 直接返回动作
└── 复杂情况: 传递给 RL Agent
↓
深度学习 Agent (PPO/DQN)
↓
返回动作
Halite IV 第四名 (0Zeta - 纯规则)
规则系统 + Optuna 参数优化
↓
100% 启发式策略
↓
Optuna 自动调优 100+ 参数
↓
达到第 4 名 (无 ML)
14.2 混合策略优势分析
| 方法 |
优势 |
劣势 |
适用场景 |
| 纯 RL |
泛化能力强，自动学习 |
训练慢，不稳定 |
复杂模式学习 |
| 纯规则 |
确定性，可解释 |
泛化差，调参多 |
简单逻辑，边界情况 |
| RL + 规则 |
兼顾两者优势 |
设计复杂 |
大多数游戏 |
| RL + 动态规划 |
最优子结构利用 |
状态空间限制 |
可分解问题 |
14.3 具体混合案例
Hungry Geese (digitalspecialists)
# 伪代码: 混合决策
def decide_action(state):
# 1. 启发式检查
if immediate_danger(state):
return escape_action(state)
if food_nearby(state):
return greedy_food_action(state)
# 2. 动态规划 (短路径)
if reachable_food(state):
return dp_path_to_food(state)
# 3. 深度 RL (复杂决策)
return neural_network_action(state)
Lux AI S3 (3Comets)
# 伪代码: 混合策略
def decide_unit_action(unit, state):
if is_first_turn():
# 规则辅助探测
return explore_with_rules(unit, state)
# 多智能体 RL 决策
return rl_agent.decide(unit, state)
十五、多智能体系统设计
15.1 架构模式
Orchestrator-Worker 模式
Orchestrator (协调器)
├── Worker 1 (单位 1)
├── Worker 2 (单位 2)
├── ...
└── Worker N (单位 N)
协调方式:
- 集中训练，分散执行
- 共享经验池
- 通信机制 (A2A 协议)
Supervisor-QualityControl 模式
Supervisor (监督者)
├── Agent 1 (执行)
├── Agent 2 (执行)
└── Quality Control (质量验证)
验证循环:
- 检查动作合法性
- 评估动作质量
- 反馈修正
15.2 多智能体协作机制
Lux AI S3 设计
16 个单位协调:
- 资源采集组: 8 单位
- 战斗组: 6 单位
- 侦察组: 2 单位
协调策略:
- 角色分配 (基于位置/状态)
- 目标分解 (全局 -> 局部)
- 冲突解决 (资源竞争)
部分可观测处理
# 伪代码: 部分可观测推理
def infer_global_state(local_observation, history):
# 1. 维护信念状态
belief = update_belief(history)
# 2. 推断隐藏信息
inferred_state = {
'enemy_positions': predict_enemy(belief),
'resource_locations': predict_resources(belief),
}
# 3. 结合局部观测
return merge(local_observation, inferred_state)
15.3 训练策略
集中训练分散执行 (CTDE)
训练阶段:
- 全局状态可用
- 共享梯度
- 联合策略优化
执行阶段:
- 仅局部观测
- 独立决策
- 无通信限制
对手池训练
# 伪代码: 多智能体训练
def train_multi_agent(agents, num_episodes):
for episode in range(num_episodes):
# 采样对手组合
opponents = sample_opponent_pool(agents)
# 对弈生成数据
trajectories = play_game(agents, opponents)
# 更新所有 agent
for agent in agents:
agent.train(trajectories)
# 更新对手池
update_opponent_pool(agents)
十六、推理优化技术
16.1 性能优化清单
| 技术 |
效果 |
实现难度 |
适用场景 |
| Bitboard 位运算 |
100x 速度 |
中 |
棋盘游戏 |
| 置换表缓存 |
避免重复计算 |
低 |
搜索算法 |
| 开局库 |
节省早期搜索 |
低 |
固定开局 |
| 迭代加深 |
时间控制 |
中 |
限时搜索 |
| 并行搜索 |
多核加速 |
高 |
大搜索空间 |
| 剪枝优化 |
减少搜索 |
中 |
博弈树 |
16.2 超时安全机制
# 伪代码: 安全超时处理
def search_with_timeout(state, time_limit):
start_time = time.now()
best_move = None
for depth in range(1, max_depth):
if time.now() - start_time > time_limit * 0.8:
break # 预留 20% 时间
move, score = iterative_deepening(state, depth)
best_move = move
if is_terminal(state):
break
return best_move # 保证返回已找到的最优解
十七、参数优化方法
17.1 Optuna 自动化搜索
Halite IV (0Zeta) 案例
import optuna
def objective(trial):
# 定义搜索空间
params = {
'resource_threshold': trial.suggest_float('resource_threshold', 0.1, 0.9),
'attack_distance': trial.suggest_int('attack_distance', 1, 10),
'retreat_health': trial.suggest_float('retreat_health', 0.1, 0.5),
# ... 100+ 参数
}
# 评估参数组合
score = evaluate_bot(params)
return score
# 运行优化
study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=1000)
17.2 超参数调优策略
| 方法 |
适用场景 |
计算成本 |
效果 |
| 网格搜索 |
小参数空间 |
高 |
穷举 |
| 随机搜索 |
中等参数空间 |
中 |
高效 |
| Optuna (TPE) |
大参数空间 |
低 |
最优 |
| 贝叶斯优化 |
昂贵评估 |
中 |
样本高效 |
十八、知识蒸馏与课程学习
18.1 知识蒸馏 (Knowledge Distillation)
强化学习中的知识蒸馏
原理: 将大型教师网络 (或模型集成) 的策略迁移到小型学生网络，实现高效部署。
# 伪代码: RL 知识蒸馏
def distill_rl(teacher_policy, student_policy, states, temperature=2.0):
# 教师策略输出 (软目标)
teacher_logits = teacher_policy(states)
teacher_probs = softmax(teacher_logits / temperature)
# 学生策略输出
student_logits = student_policy(states)
student_probs = softmax(student_logits / temperature)
# 蒸馏损失 (KL 散度)
distillation_loss = kl_divergence(teacher_probs, student_probs) * temperature^2
# 结合真实奖励损失
total_loss = alpha * distillation_loss + (1 - alpha) * policy_loss
return total_loss
应用场景
| 场景 |
方法 |
效果 |
| 集成 -> 单模型 |
将多个专家策略蒸馏为单一模型 |
推理速度提升 5-10 倍 |
| 大模型 -> 小模型 |
教师网络指导学生网络 |
保持 95%+ 性能 |
| 离线策略 -> 在线策略 |
历史回放数据蒸馏 |
稳定初始策略 |
Halite IV 冠军方案应用
三阶段训练范式:
1. 规则引导的模仿预训练
- 人类专家策略 + 大量回放数据
- 蒸馏出稳健的初始策略
2. 对抗自博弈精调
- Self-Play + Policy Gradient 与 Q-learning 双轨更新
- 在对抗中不断演化策略多样性
3. 跨智能体课程迁移
- 不同难度地图、初始资源密度、对手强度梯度
- 从单点防御到全域压制的全谱系能力
蒸馏类型
| 类型 |
知识来源 |
适用场景 |
| Response-based |
教师网络输出 logits |
策略迁移 |
| Feature-based |
中间层特征表示 |
特征提取器压缩 |
| Relation-based |
样本间关系 |
多智能体协作 |
| Attention-based |
注意力权重 |
Transformer 压缩 |
18.2 课程学习 (Curriculum Learning)
核心思想
模仿人类学习过程，从简单到复杂逐步提升难度。
Halite IV 课程学习应用
| 阶段 |
地图规模 |
对手强度 |
资源密度 |
训练目标 |
| 阶段 1 |
16x16 |
随机 |
密集 |
基础采集 |
| 阶段 2 |
21x21 |
贪婪 |
中等 |
采集 + 运输 |
| 阶段 3 |
32x32 |
规则 Bot |
稀疏 |
建造 + 防御 |
| 阶段 4 |
32x32 |
RL Agent |
动态 |
攻击 + 扩张 |
| 阶段 5 |
64x64 |
集成模型 |
竞争 |
全谱系能力 |
十九、分层智能体架构与世界模型
19.1 三层认知架构 (Halite IV 冠军方案)
┌─────────────────────────────────────────────────────┐
│ 战略规划器 (Strategic Planner) │
│ - MCTS + 世界模型 (World Model) │
│ - 资源分布预测 │
│ - 对手意图识别 │
│ - 长期扩张路径规划 │
└──────────────────────┬──────────────────────────────┘
│
┌──────────────────────▼──────────────────────────────┐
│ 战术协调器 (Tactical Coordinator) │
│ - 图神经网络 (GNN) 舰船集群拓扑建模 │
│ - 编队生成 │
│ - 区域控制权评估 │
│ - 动态攻防优先级排序 │
└──────────────────────┬──────────────────────────────┘
│
┌──────────────────────▼──────────────────────────────┐
│ 微操控制器 (Micro-controller) │
│ - 硬编码规则 + 轻量级策略网络 │
│ - 舰船移动 │
│ - 碰撞规避 │
│ - 基础攻击 │
└─────────────────────────────────────────────────────┘
各层职责详解
微操控制器 (Micro-controller)
class MicroController:
def decide_ship_action(self, ship, local_state):
"""毫秒级决策 (<8ms)"""
# 规则优先级最高
if immediate_collision_risk(ship, local_state):
return emergency_avoid(ship)
if low_health(ship):
return retreat_to_base(ship)
# 轻量级策略网络
return policy_network(ship, local_state)
战术协调器 (Tactical Coordinator)
class TacticalCoordinator:
def __init__(self):
self.gnn = GraphNeuralNetwork()
def coordinate_fleet(self, fleet_state):
"""GNN 舰船集群拓扑建模"""
# 构建舰队图
graph = build_fleet_graph(fleet_state)
# GNN 推理
fleet_embeddings = self.gnn(graph)
# 编队生成
formations = generate_formations(fleet_embeddings)
# 区域控制权评估
control_map = evaluate_territorial_control(fleet_embeddings)
# 动态攻防优先级
priorities = compute_attack_defense_priorities(control_map)
return formations, priorities
战略规划器 (Strategic Planner)
class StrategicPlanner:
def __init__(self):
self.world_model = WorldModel()
self.mcts = MonteCarloTreeSearch()
def plan_strategy(self, global_state):
"""MCTS + 世界模型多步推演"""
# 世界模型预测
future_states = self.world_model.predict(global_state, horizon=50)
# MCTS 搜索
best_plan = self.mcts.search(
initial_state=global_state,
world_model=self.world_model,
simulations=1000
)
return best_plan
多时间尺度动作决策
| 层级 |
决策频率 |
时间尺度 |
动作类型 |
| 战略层 |
每 50 步 |
长期 (100+ 步) |
扩张方向、资源分配 |
| 战术层 |
每 10 步 |
中期 (10-50 步) |
编队移动、攻防切换 |
| 微操层 |
每步 |
短期 (1-10 步) |
移动、攻击、采集 |
19.2 世界模型 (World Model)
原理
学习环境动态模型，用于规划而不需要实际与环境交互。
class WorldModel:
def __init__(self):
self.dynamics_model = DynamicsNetwork() # 状态转移
self.reward_model = RewardNetwork() # 奖励预测
self.observation_model = ObsNetwork() # 观测重建
def predict(self, state, action, horizon=10):
"""预测未来状态序列"""
trajectory = [state]
current_state = state
for _ in range(horizon):
next_state = self.dynamics_model(current_state, action)
reward = self.reward_model(current_state, action)
current_state = next_state
trajectory.append((next_state, reward))
return trajectory
def plan_with_model(self, current_state, planner):
"""使用世界模型进行规划"""
# 在想象空间中搜索
return planner.search_in_imagination(
initial_state=current_state,
world_model=self,
simulations=500
)
应用场景
- MCTS 指导: 减少实际环境交互
- 对手意图预测: 推断对手下一步动作
- 资源分布预测: 预测资源再生模式
- 风险评估: 预测危险区域
19.3 图神经网络 (GNN) 多智能体协调
舰队拓扑建模
class FleetGNN(nn.Module):
def __init__(self, node_dim, hidden_dim, num_layers=3):
super().__init__()
self.gcn_layers = nn.ModuleList([
GraphConvLayer(node_dim if i == 0 else hidden_dim, hidden_dim)
for i in range(num_layers)
])
def forward(self, fleet_graph):
"""
输入: 舰队图
- 节点: 每艘船的状态 (位置、生命值、类型)
- 边: 船只间关系 (距离、通信范围)
"""
node_features = fleet_graph.node_features
adjacency = fleet_graph.adjacency
for gcn in self.gcn_layers:
node_features = gcn(node_features, adjacency)
node_features = F.relu(node_features)
return node_features # 每艘船的嵌入表示
GNN 应用
| 应用 |
输入 |
输出 |
效果 |
| 编队生成 |
船只位置图 |
编队分配 |
自动形成战斗队形 |
| 区域控制评估 |
敌我分布图 |
控制热力图 |
识别战略要地 |
| 攻防优先级排序 |
战场态势图 |
优先级列表 |
动态调整战术 |
| 信息传播 |
通信图 |
全局状态估计 |
部分可观测推理 |
二十、优先经验回放与奖励塑形
20.1 优先经验回放 (Prioritized Experience Replay)
标准 PER
class PrioritizedReplayBuffer:
def __init__(self, capacity, alpha=0.6):
self.buffer = []
self.priorities = []
self.alpha = alpha # 优先级指数
def add(self, transition, td_error):
"""添加经验，优先级由 TD 误差决定"""
priority = (abs(td_error) + 1e-6) ** self.alpha
self.buffer.append(transition)
self.priorities.append(priority)
def sample(self, batch_size, beta=0.4):
"""按优先级采样"""
probs = np.array(self.priorities) / sum(self.priorities)
indices = np.random.choice(len(self.buffer), batch_size, p=probs)
# 重要性采样权重
weights = (len(self.buffer) * probs[indices]) ** (-beta)
weights /= weights.max()
return [self.buffer[i] for i in indices], weights, indices
增强 PER (RCP 值)
引入三个额外特征:
- R (Reward): 奖励值
- C (Counter): 转换使用计数器
- P (Policy Probability): 策略概率
class EnhancedPER(PrioritizedReplayBuffer):
def compute_rcp_priority(self, transition):
"""计算 RCP 优先级"""
reward_norm = normalize(transition.reward)
counter_norm = 1 / (1 + transition.usage_count) # 使用越少优先级越高
policy_prob = transition.policy_probability
# 聚合策略 (可自定义)
priority = (
w_r * reward_norm +
w_c * counter_norm +
w_p * (1 - policy_prob) # 低概率动作优先级高
)
return priority ** self.alpha
多智能体经验回放优化 (AccMER)
class CacheAwareMER:
"""缓存局部性感知多智能体经验回放"""
def __init__(self, reuse_window=5):
self.reuse_window = reuse_window
self.cached_transitions = []
def sample_with_reuse(self, transitions, step):
"""
重复使用高优先级转换，减少缓存未命中
"""
if step % self.reuse_window != 0:
# 重用缓存的高优先级转换
return self.cached_transitions
# 采样新转换
high_priority = self.sample_high_priority(transitions)
self.cached_transitions = high_priority
return high_priority
效果: 32 智能体训练时间减少 25.4%
20.2 奖励塑形 (Reward Shaping)
Halite IV 17 类中间奖励
class RewardShaper:
def __init__(self):
self.dynamic_scheduler = DynamicWeightScheduler()
def compute_reward(self, state, action, next_state):
"""计算综合奖励"""
rewards = {
# 采集效率
'halite_collected': self.halite_reward(state, next_state),
# 生存率
'ship_survival': self.survival_reward(state, next_state),
# 控制面积增长
'territory_growth': self.territory_reward(state, next_state),
# 对手舰船摧毁
'enemy_destroyed': self.combat_reward(state, next_state),
# 盐矿保有量稳定性
'resource_stability': self.stability_reward(state, next_state),
# ... 共 17 类奖励信号
}
# 动态权重调度
weights = self.dynamic_scheduler.get_weights(state.step_count)
return sum(weights[k] * v for k, v in rewards.items())
动态权重调度器
| 比赛阶段 |
采集权重 |
生存权重 |
攻击权重 |
扩张权重 |
| 早期 (0-100 步) |
0.4 |
0.3 |
0.1 |
0.2 |
| 中期 (100-250 步) |
0.2 |
0.2 |
0.3 |
0.3 |
| 后期 (250-400 步) |
0.1 |
0.2 |
0.5 |
0.2 |
奖励塑形通用模式
# 稀疏奖励 -> 密集奖励
def shape_reward(original_reward, state, next_state):
"""潜在函数奖励塑形"""
# 潜在函数 (衡量状态价值)
phi = lambda s: potential_function(s)
# 塑形奖励
shaped = original_reward + gamma * phi(next_state) - phi(state)
return shaped
二十一、LLM 作为游戏 Agent 核心
21.1 DeepSeek-R1 + PPO 方案 (Lux AI S3)
# 技术栈
- 模型: DeepSeek-R1-Distill-Qwen-1.5B
- 量化: 4-bit (BitsAndBytes)
- RL 框架: Hugging Face TRL (PPO)
- 游戏环境: luxai_s3 (JAX-based)
21.2 训练策略
def train_llm_agent():
"""LLM 游戏 Agent 训练流程"""
# 1. 状态编码为文本提示
state_prompt = encode_game_state_as_prompt(game_state)
# 2. LLM 生成动作
action = llm.generate(state_prompt)
# 3. 奖励计算
reward = compute_reward(game_state, action)
# 4. PPO 更新
# - 自对战稳定训练
# - 小批量 + 频繁更新 (高结果方差)
# - 奖励塑形 (资源采集、敌人摧毁等中间奖励)
ppo.update(
states=state_prompt,
actions=action,
rewards=reward,
batch_size=small_batch, # 高方差场景用小批量
update_frequency=frequent # 频繁更新
)
21.3 关键挑战与解决方案
| 挑战 |
解决方案 |
| 训练不稳定 |
自对战 + 小批量频繁更新 |
| 稀疏奖励 |
奖励塑形 (中间奖励) |
| 推理延迟 |
4-bit 量化 + 缓存 |
| 动作空间映射 |
文本 -> 离散动作解析器 |
二十二、竞赛项目设计模式
22.1 ARC_Prize_2026
NVARC 团队方案 (第一名, 27.64%)
- 多阶段合成数据生成: 通过多个阶段生成训练数据，逐步提升数据质量
- Refinement Loop: 迭代优化机制，持续改进模型输出
- Qwen3 微调 + LoRA: 使用低秩适配技术高效微调大语言模型
- 程序合成 + 转导模型组合: 结合程序生成和序列转换方法
- Test-time Training (TTT): 在推理时进行模型调整
- 深度学习引导的程序合成: 用神经网络指导程序生成过程
22.2 Lux_AI_Season3
Flat Neurons 团队方案 (第一名)
- IMPALA 算法: 大规模分布式强化学习算法
- 动态奖励缩放: 根据训练进度自动调整奖励尺度
- 自适应熵正则化: 动态调整探索与利用平衡
- 24 残差块 + ConvLSTM + 4 层 Transformer: 深度混合网络架构
- 1000+ 特征/瓦片: 密集特征工程 (100 连续特征 + 独热编码离散特征)
- 超过 20B 步训练: 大规模训练策略
KASSII 团队方案 (第四名)
Elias Buerger 方案 (第五名)
- xLSTM 架构: 扩展 LSTM 的强化学习 agent
- 教师模型: 知识蒸馏训练策略
3Comets 团队方案 (第 14 名)
- 多智能体 RL + RNN 记忆单元: 序列建模能力
- 规则辅助第一局探测: 混合策略，用规则探索遗迹位置
22.3 Halite_IV
ttvand 方案 (第一名)
- 深度学习 Agent + 规则 Agent 混合: 结合两种方法的优势
- 双 Agent 架构: 规则 Agent 和深度学习 Agent 独立实现
0Zeta 团队方案 (第四名)
- 100% 基于规则的 Bot: 纯启发式策略
- Optuna 参数优化: 自动化超参数搜索
- 无 ML 技术: 完全依赖手工调优的启发式
gmoss13 方案
- PPO (Proximal Policy Optimization): 近端策略优化算法
- 双神经网络: 船只动作网络 + 船坞动作网络
- 自对战训练: 自我博弈提升策略
22.4 Connect_X
AlphaZero 方案 (第 9 名)
- AlphaZero 强化学习算法: 自对战 + MCTS + 神经网络
- 得分对比: Greedy (268), Minimax (873), MCTS (1075), MCTS-minimax hybrid (980), AlphaZero (1282)
Connect X Championship Agent
- Bitboard 引擎: 位运算优化，100 倍速度提升
- Negamax 搜索: 优化的博弈树搜索
- 模式识别评估: 启发式局面评估
- 开局库: 20+ 移动序列预计算
- 置换表 (Zobrist 哈希): 状态缓存避免重复计算
- 30+ 种 Agent 变体: 模块化架构
22.5 Hungry_Geese
digitalspecialists 团队方案 (第 9 名)
- 深度强化学习 + 启发式策略结合: 混合方法
- 动态规划: 最优子结构利用
- 训练管道搭建: 完整的训练流程
- 模型架构调优: 网络结构优化
- 启发式逻辑与模型融合: 规则与学习结合
22.6 AgentSociety_Challenge
Top 方案通用架构
- 多阶段 retrieve-plan-generate 管道: 检索 - 规划 - 生成三阶段
- 上下文提示工程: 结合用户画像、物品属性和历史评论
- 协同过滤风格的用户建模: 传统推荐与 LLM 结合
22.7 AI_Agents_Intensive
MLE-STAR 方案 (Google Cloud + KAIST)
- 搜索引擎检索有效模型: 自动化工具选择
- 针对性代码块优化: 局部代码改进
- MLE-bench 64% 奖牌率: 从 36.6% 提升到 63.6%
StockTrendAnalyzer Agent
- 多智能体系统: Orchestrator + Prediction Server + MCP Server
- Gemini 模型编排: 大模型协调
- 市场趋势检测 + 新闻情感分析 + 短期价格预测 + 邮件提醒
Customer Support AI Agent
- 4 个专用 Agent: Classifier + Researcher + Writer + Validator
- Google Gemini 2.5 Flash: 高效推理
- FastAPI REST API + Web 界面: 完整部署
Converge 多智能体销售自动化
- 13 个专用 Agent 协调: 大规模多智能体系统
- FAISS 检索增强: 向量检索
- 监督者质量控制: 质量保障机制
EduMentor 智能学习教练
- 3 Agent 协调: Planner + Teacher + Evaluator
- 个性化学习计划 + 每日任务调度 + 测验生成 + 进度追踪
22.8 Santa_2025
第三名方案 - Sparrow 算法
- 定制化 Sparrow 优化算法: 专用优化器
- 排名: 3/3395 (金牌)
Santa 2024 方案 (第 6 名金牌)
- LLM 优化 + 排列优化: 大模型辅助优化
- Claude Haiku/Sonnet 单调用 vs Agent 架构对比
- DSPY 框架提示词优化: 自动化提示词优化
- DeepSeek-R1-Distill-Llama-8B 微调: 模型微调
Santa 2022 方案 (第 9 名金牌)
- 纯数学优化 (改进的旅行商问题): 组合优化
- 手动启发式 + 加速技术: 无法依赖优化求解器
二十三、通用设计模式总结
23.1 强化学习类
- 算法选择: PPO, DQN, A3C, IMPALA, AlphaZero, SARSA, Q-Learning
- 训练策略: 自对战训练、课程学习、奖励塑形
- 网络架构: CNN, RNN, LSTM, Transformer, xLSTM, ConvLSTM
- 优化技术: 动态奖励缩放、自适应熵正则化、探索率调优
23.2 博弈搜索类
- 搜索算法: Minimax, Alpha-Beta 剪枝, MCTS, Negamax
- 优化技术: Bitboard 位运算、置换表 (Zobrist 哈希)、开局库
- 评估函数: 模式识别、启发式评估
23.3 多智能体系统类
- 架构模式: Orchestrator-Worker, Supervisor-QualityControl, A2A 通信
- 协调机制: 角色分配、职责划分、质量验证循环
- 工具集成: MCP 协议、FAISS 检索、自定义工具
23.4 LLM Agent 类
- 提示工程: 上下文提示、DSPY 优化、多阶段提示
- 微调技术: LoRA、QLoRA、4-bit 量化
- 管道设计: Retrieve-Plan-Generate、多阶段检索
23.5 优化算法类
- 启发式算法: 模拟退火、模因算法、遗传算法
- 数学优化: TSP 变种、装箱问题、排列优化
- 参数优化: Optuna 自动化搜索、网格搜索
二十四、常见陷阱与解决方案
| 陷阱 |
症状 |
解决方案 |
| 奖励稀疏 |
不收敛 |
奖励塑形、课程学习 |
| 过拟合对手 |
对新对手差 |
对手池多样化 |
| 训练不稳定 |
性能波动 |
降低学习率、PPO 裁剪 |
| 推理超时 |
提交失败 |
迭代加深、超时检查 |
| 特征不足 |
性能上限低 |
密集特征工程 |
| 探索不足 |
局部最优 |
增加熵、噪声注入 |
二十五、高级优化技术补充
25.1 持续时间感知梯度更新
问题: 不同动作执行时间不同，导致异步策略梯度更新偏向快速但次优的解决方案。
解决方案:
def duration_aware_gradient_update(transitions):
"""持续时间感知梯度更新"""
for transition in transitions:
# 根据动作持续时间调整梯度
duration = transition.action_duration
# 长时间高奖励动作应获得更大梯度
adjusted_reward = transition.reward * duration_weight(duration)
# 更新策略
policy_gradient(transition, adjusted_reward)
def duration_weight(duration):
"""持续时间权重"""
# 长时间动作需要更大权重补偿
return sqrt(duration / base_duration)
25.2 环境仪器化 (Environment Instrumentation)
部分信用机制
仅使用测试集性能作为奖励提供有限反馈。几乎正确的程序与完全失败的程序被同等对待。
def instrumented_reward(program, test_cases):
"""环境仪器化提供部分信用"""
results = []
for test in test_cases:
result = run_program(program, test)
# 不仅看通过/失败
# 评估"几乎正确"程度
partial_score = evaluate_partial_correctness(result, test.expected)
results.append(partial_score)
# 综合奖励
return sum(results) / len(results)
应用:
- 区分"几乎正确"和"完全错误"的程序
- 提供更细粒度的学习信号
- 加速收敛
25.3 多步 RL 与自我改进提示
自我改进提示机制
def multi_step_rl_with_self_improve(agent, max_iterations=5):
"""多步 RL + 自我改进"""
for iteration in range(max_iterations):
# 1. 执行任务
result = agent.execute_task()
# 2. 评估结果
score = evaluate(result)
# 3. 生成自我改进提示
if score < target:
improvement_prompt = generate_self_improve_prompt(
current_result=result,
score=score,
error_analysis=analyze_errors(result)
)
# 4. 更新策略
agent.update_with_prompt(improvement_prompt)
# 5. RL 奖励
reward = compute_reward(score)
agent.update_policy(reward)
25.4 状态抽象建模
分层状态抽象
class StateAbstraction:
def abstract_state(self, raw_state, level='high'):
"""
状态抽象层级:
- low: 原始像素/网格
- medium: 特征向量
- high: 语义状态
"""
if level == 'low':
return raw_state.grid
elif level == 'medium':
return self.extract_features(raw_state)
elif level == 'high':
return {
'territory_control': self.compute_territory(raw_state),
'resource_advantage': self.compute_resource_advantage(raw_state),
'military_strength': self.compute_military(raw_state),
'strategic_position': self.compute_position(raw_state),
}
应用:
- 战略规划: 使用高级抽象
- 战术决策: 使用中级抽象
- 微操控制: 使用低级抽象
25.5 高效经验回放策略
Agent-Centric 采样
class AgentCentricReplay:
"""以 Agent 为中心的经验采样"""
def sample(self, agent_id, buffer, batch_size):
"""
优先采样与当前 Agent 相关的经验
"""
# 按 Agent 相关性过滤
relevant = filter_by_agent(buffer, agent_id)
# 在相关经验中按优先级采样
return prioritized_sample(relevant, batch_size)
优势:
- 提高样本相关性
- 加速特定 Agent 学习
- 减少无关经验干扰
25.6 模型集成与堆叠
策略集成
class PolicyEnsemble:
def __init__(self, policies, weights=None):
self.policies = policies
self.weights = weights or [1/len(policies)] * len(policies)
def predict(self, state):
"""集成多个策略"""
predictions = []
for policy, weight in zip(self.policies, self.weights):
pred = policy(state)
predictions.append(pred * weight)
return sum(predictions)
快照集成 (Snapshot Ensembles)
def snapshot_ensemble_training(model, epochs, snapshots=5):
"""从单次训练中获得多个模型"""
snapshots_models = []
lr_schedule = cyclic_learning_rate(epochs, snapshots)
for epoch in range(epochs):
set_learning_rate(lr_schedule[epoch])
train_one_epoch(model)
# 在 LR 周期低点保存快照
if is_cycle_low_point(epoch):
snapshots_models.append(copy.deepcopy(model))
return snapshots_models
25.7 伪标签 (Pseudo-Labeling)
多阶段伪标签
def multi_stage_pseudo_labeling(model, unlabeled_data, stages=3):
"""多阶段伪标签训练"""
current_model = model
for stage in range(stages):
# 生成伪标签
pseudo_labels = current_model.predict(unlabeled_data)
# 软标签蒸馏
soft_labels = softmax(pseudo_labels / temperature)
# 训练新模型
current_model = train_with_pseudo_labels(
current_model,
unlabeled_data,
soft_labels
)
# 后处理
current_model = postprocess(current_model)
return current_model
25.8 测试时训练 (Test-Time Training)
原理
在推理时对模型进行微调，适应特定测试分布。
def test_time_training(model, test_input, num_steps=10):
"""测试时训练"""
# 使用测试输入进行少量更新
for _ in range(num_steps):
prediction = model(test_input)
loss = self_consistency_loss(prediction)
loss.backward()
optimizer.step()
# 返回微调后的预测
return model(test_input)
应用:
- ARC Prize: 测试时适应新规则
- 分布偏移: 适应测试环境变化
25.9 完整训练流程示例
Halite IV 冠军方案完整流程
def train_champion_agent():
"""Halite IV 冠军方案训练流程"""
# ===== 阶段 1: 规则引导的模仿预训练 =====
agent = initialize_agent()
expert_data = load_expert_replays()
# 行为克隆
agent.imitation_learning(expert_data)
# 知识蒸馏 (规则 -> 神经网络)
distill_rules_to_network(agent, rule_bot)
# ===== 阶段 2: 对抗自博弈精调 =====
opponent_pool = OpponentPool()
opponent_pool.add(agent.copy())
opponent_pool.add(rule_bot)
for iteration in range(num_iterations):
# 采样对手
opponent = opponent_pool.sample()
# 自对战
trajectory = play_game(agent, opponent)
# 双轨更新 (Policy Gradient + Q-learning)
agent.policy_gradient_update(trajectory)
agent.q_learning_update(trajectory)
# 更新对手池
if agent.improved():
opponent_pool.add(agent.copy())
# ===== 阶段 3: 跨智能体课程迁移 =====
curriculum = CurriculumScheduler()
for stage in range(num_stages):
config = curriculum.get_config(stage)
# 在当前难度训练
train_with_config(agent, config)
# 评估是否晋级
if evaluate(agent, config) > threshold:
curriculum.advance()
return agent
25.10 性能优化清单
推理优化
| 技术 |
效果 |
实现难度 |
| 4-bit 量化 |
内存减少 75% |
低 |
| 模型蒸馏 |
推理速度 5-10x |
中 |
| 快照集成 |
免费集成 |
低 |
| Bitboard |
100x 速度 |
中 |
| 缓存局部性优化 |
训练时间 -25% |
高 |
训练优化
| 技术 |
效果 |
适用场景 |
| 优先经验回放 |
样本效率提升 |
所有 RL |
| 课程学习 |
收敛加速 |
稀疏奖励 |
| 自对战 |
策略进化 |
博弈游戏 |
| 知识蒸馏 |
稳定初始策略 |
冷启动 |
| 奖励塑形 |
信用分配 |
稀疏奖励 |
| 持续时间感知梯度 |
公平更新 |
变长动作 |
25.11 完整设计 Checklist
算法选择
- [ ] 游戏类型分析 (完美信息/部分可观测/连续/离散)
- [ ] 算法匹配 (RL/搜索/混合)
- [ ] 基线实现 (Greedy/Random)
- [ ] 进阶算法 (PPO/MCTS/AlphaZero)
网络架构
- [ ] 输入特征设计 (密集 > 稀疏)
- [ ] 空间特征提取 (CNN/残差块)
- [ ] 时序建模 (LSTM/ConvLSTM)
- [ ] 全局注意力 (Transformer)
- [ ] 策略头 + 价值头
训练策略
- [ ] 自对战训练设置
- [ ] 奖励函数设计/塑形
- [ ] 探索策略 (熵/epsilon-greedy)
- [ ] 对手池维护
- [ ] 课程学习 (可选)
推理优化
- [ ] Bitboard 位运算 (如适用)
- [ ] 置换表缓存
- [ ] 开局库设计
- [ ] 超时安全机制
- [ ] 内存效率优化
参数调优
- [ ] Optuna 自动化搜索
- [ ] 关键参数敏感性分析
- [ ] 最终参数验证
混合方法
- [ ] 规则系统实现 (确定性逻辑)
- [ ] RL 与规则集成点
- [ ] 动态规划应用 (如适用)
- [ ] 启发式策略补充
二十六、更多竞赛项目设计模式
26.1 Orbit_Wars
官方环境配置
- kaggle-environments 库: 官方多智能体环境实现
- 轨道力学模拟: 物理引擎集成
环境 Bug 修复
- 舰队竞争条件处理: 并发控制
- 几何隧道效应修复: 碰撞检测优化
- 多攻击者战斗逻辑: 复杂交互处理
技术要点
参考方案
- TF-IDF 搜索: 传统信息检索
- LLM 提示工程: 大模型辅助检索
- 迭代检索工作流: 多轮检索优化
- Hugging Face 语言模型: 文档理解
多样性评分优化
diversity_score = (
weights['lexical'] * lexical_diversity +
weights['semantic'] * semantic_diversity +
weights['category'] * category_diversity +
weights['topic'] * topic_diversity
)
技术要点
- 自动化网页爬取与数据收集
- 词汇多样性优化
- 语义多样性优化
- 多指标加权评分
26.3 Maze_Crawler
MazeCrawler 游戏 + AI Agent
- A* 搜索: 启发式路径规划
- Dijkstra 算法: 最短路径计算
- 5 种随机迷宫生成算法: Eller's 等算法
- Python3 + Pygame 实现: 可视化环境
强化学习实现参考
- Q-Learning, DQN, PPO, A3C: 多种 RL 算法
- 状态表示: 迷宫网格 + Agent 位置 + 目标位置
- 奖励设计: 到达目标 + 奖励，每步 - 小惩罚
技术要点
26.4 Agents_Capstone
StockTrendAnalyzer Agent
- 多智能体系统 + Gemini 编排: 大模型协调
- 组件: Orchestrator Server + Streamlit UI + A2A Prediction Server + MCP Server
- 功能: 市场趋势检测、新闻情感分析、短期价格预测、邮件提醒
Customer Support AI Agent
- 4 Agent 管道: Classifier + Researcher + Writer + Validator
- Google Gemini 2.5 Flash + FastAPI + HTML5: 完整部署
- FAQ 搜索工具 + 质量验证循环 + REST API
Converge 多智能体销售与客服自动化
- 13 个专用 Agent 协调: 大规模系统
- FAISS 检索 + 监督者质量控制 + A2A 通信
EduMentor 智能自主学习教练
- 3 Agent 协调: Planner + Teacher + Evaluator
- 个性化学习计划 + 每日任务调度 + 测验生成与评估 + 进度追踪 + 动机提醒
技术要点
- Agent 角色设计与职责分配
- 工具集成与自定义
- 记忆管理与上下文工程
- 质量验证与自我修正循环
- 可观测性与评估
十一、关键经验总结
| 经验 |
说明 |
| 快速迭代是关键 |
竞赛成功取决于生成、测试、迭代想法的速度 |
| GPU 加速不可少 |
数据处理速度直接影响 Agent 迭代效率 |
| 保存所有实验 |
每次实验都保存 OOF 和 Test 预测，便于后续融合 |
| 多 Agent 协同 |
不同 Agent 负责不同方向，比单 Agent 更全面 |
| 人类在环 |
人类控制方向，Agent 负责执行，效果最佳 |
| 结构化 Prompt |
用 XML 标签组织 Prompt，比纯文本更可靠 |
| 记忆管理 |
跨对话的经验积累是 Agent 持续进步的关键 |
| 工具库完备 |
预验证的工具库比让 Agent 从头编写更可靠 |
| 调试自动化 |
自动调试和修复能力决定 Agent 的独立程度 |
| 搜索策略选择 |
根据任务复杂度选择合适的搜索方法 |