像 AlphaGo 一樣進化——Self-Play 讓 AI Agent 跟自己對弈、越打越強的完整指南

去年我花了整整三週訓練一個客服 AI Agent，餵了幾千條人工標註資料，自信滿滿地上線——結果第一個禮拜就被使用者用三句話繞暈了。Agent 開始鬼打牆、重複回答、甚至編造不存在的退貨政策。我盯著 log 想：「這東西怎麼比上線前還笨？」

後來一位做強化學習的朋友看了我的訓練流程，問了一句讓我愣住的話：「你為什麼不讓它跟自己打？」他說的就是 Self-Play——讓 AI 跟自己的舊版本對弈，透過不斷挑戰自己來發現盲點。這套方法在 AlphaGo 身上讓圍棋 AI 從業餘水準打到超越所有人類棋手，而現在，同樣的思路正在改變 LLM 的訓練方式。

這篇文章會帶你從頭理解 Self-Play 的原理，看它怎麼從棋盤遊戲跨到大型語言模型，然後拆解你能在自己的 AI 專案裡實際操作的方法。不需要 DeepMind 等級的算力，也不需要博士學位。

Self-Play 到底是什麼？從圍棋到 LLM 的核心邏輯

Self-Play 的概念其實比 AI 還老。想像兩個西洋棋選手坐在同一張桌子前——但他們其實是同一個人。左手下一步，右手反擊，每一局都在逼自己想出更刁鑽的走法。當這個過程重複幾百萬次，「這個人」的棋力會遠超過只跟固定對手練習的選手。

在 AI 領域，Self-Play 指的是讓模型跟自己的歷史版本或副本對弈，從對抗過程中發現弱點並自我進化。這跟傳統的監督式學習（Supervised Learning）完全不同——監督式學習需要人類提供「正確答案」，而 Self-Play 不需要。它靠的是勝負、獎懲，以及持續的博弈壓力。

DeepMind 在 2017 年發表的AlphaGo Zero 論文用數據證明了這件事的威力：完全不使用任何人類棋譜，AlphaGo Zero 從隨機落子開始，經過 490 萬局自我對弈，三天內就擊敗了使用人類數據訓練的前代 AlphaGo——比數是 100:0。

Self-Play 與傳統訓練的根本差異

AlphaGo 到 AlphaZero——Self-Play 如何重新定義棋盤 AI

要理解 Self-Play 為什麼這麼厲害，最好的教材就是 DeepMind 的 AlphaGo 系列。它的進化歷程本身就是一部 Self-Play 的教科書。

從 AlphaGo Fan 到 AlphaGo Zero 的三代跳躍

2015 年的 AlphaGo Fan 是第一個擊敗職業圍棋選手的 AI，但它的訓練仍然重度依賴 16 萬局人類棋譜。到了 2016 年擊敗李世石的 AlphaGo Lee，增加了自我對弈強化學習階段，但起點依然是人類數據。真正的突破發生在 2017 年的 AlphaGo Zero——它完全拋棄人類棋譜，從一張白紙開始，純靠 Self-Play。

這些數字背後隱藏了一個反直覺的事實：人類知識反而是瓶頸。AlphaGo Zero 不用人類棋譜，反而下得更好。因為人類棋譜包含了偏見——某些「標準定石」其實不是最優解，但幾百年來大家都這樣下，AI 也跟著學壞了。Self-Play 沒有這個包袱。

AlphaZero 更進一步，把同一套演算法同時用在圍棋、西洋棋和將棋三種遊戲上。DeepMind 的論文顯示 AlphaZero 只用了 4 小時的西洋棋 Self-Play 訓練，就超越了 Stockfish 8（當時最強的傳統引擎），在 1,000 局對弈中贏了 155 局、輸 6 局、和 839 局。

當 Self-Play 遇上大型語言模型——SPIN 與 SPPO 的突破

棋盤遊戲有明確的勝負判定，Self-Play 的獎懲信號很清楚。但語言模型呢？一段回答寫得好不好，沒有「贏了」或「輸了」這麼乾脆。這是 Self-Play 從遊戲跨到 NLP 的最大挑戰——也是 2024 年以來一系列論文正在突破的關鍵。

SPIN：讓 LLM 跟自己的舊版本辯論

UCLA 的研究團隊在 2024 年初發表了SPIN（Self-Play Fine-Tuning），核心想法極其簡潔：讓 LLM 的新版本學會分辨「自己舊版本生成的回答」和「人類寫的回答」。聽起來像是在做真假判別？沒錯，就是把 GAN（生成對抗網路）的概念搬到了語言模型上。

訓練流程是這樣的：第 t 輪的模型生成一批回答，第 t+1 輪的模型要學會把這些「假回答」跟人類標註的「真回答」區分開。當模型越來越會分辨，代表它對「好回答長什麼樣」的理解越來越深。SPIN 論文證明了，當且僅當模型的輸出分佈與人類數據分佈完全一致時，訓練才會收斂——這就是 Self-Play 的 Nash 均衡在語言領域的體現。

結果非常亮眼。SPIN 在 HuggingFace Open LLM Leaderboard 和 MT-Bench 上都打敗了用 GPT-4 偏好數據做 DPO（Direct Preference Optimization）的模型。不需要額外的人類標註，不需要更強的教師模型，光靠跟自己打就能進步。

SPPO：用賽局理論優化偏好對齊

如果 SPIN 是「真假辯論」，那SPPO（Self-Play Preference Optimization）就是「擂台賽」。SPPO 把 LLM 的對齊過程建模為雙人零和博弈——同一個模型的兩個副本互相生成回答，然後讓模型自己判斷哪個回答比較好。透過迭代更新，模型的策略會逼近 Nash 均衡。

SPPO 用 Mistral-7B 和 Llama-3-8B 做實驗，在 AlpacaEval 2.0 和 Arena-Hard 上的表現不需要任何 GPT-4 的監督就能達到有競爭力的水準。這代表一件事：Self-Play 正在打破「弱模型必須靠強模型指導」的傳統範式。

Self-Play 在紅隊測試與對抗訓練的實戰應用

如果你的工作涉及 AI 安全，Self-Play 可能是你最強大的武器。AI 紅隊測試的本質就是讓一個 AI 試圖攻破另一個 AI 的防線。傳統做法是雇人類測試員來寫攻擊提示（adversarial prompts），但人類的想像力有限，而且很貴。Self-Play 的思路是：讓 AI 自己生成攻擊，自己學防禦。

攻擊者 vs 防禦者的軍備競賽

對抗式 Self-Play 的架構是這樣的：一個「紅隊 Agent」負責生成越來越刁鑽的攻擊提示，試圖讓「藍隊 Agent」（被測試的模型）產出不安全的回答。藍隊每次被攻破之後，就拿這些失敗案例做額外訓練，補上漏洞。然後紅隊再針對「補過的藍隊」發起新一輪攻擊。

Anthropic 在Constitutional AI 的研究中展示了類似的思路——讓模型根據一組原則進行自我批評和修正。而把 Self-Play 的框架疊上去之後，效果更強。攻擊者不再是靜態的提示集合，而是一個會「進化」的對手。

這種做法的優勢在於可擴展性。人類紅隊測試員一天能寫幾百條攻擊？Self-Play 可以在幾小時內生成幾十萬條，而且每一輪的攻擊品質都在提升。Meta 的 Llama Guard 系列就採用了對抗式訓練來強化安全過濾器。

如果你對怎麼實作紅隊測試有興趣，我們之前寫過一篇AI 紅隊測試完整指南，裡面有從團隊建置到工具選擇的完整流程。加上 Self-Play 框架之後，你的測試覆蓋率會大幅提升。

用 Python 實作簡易 Self-Play 訓練迴圈

理論講夠了，來寫程式。以下是一個精簡的 Self-Play 框架，展示如何讓兩個模型副本互相對弈並更新參數。這不是生產級程式碼，但它把核心概念實現得很清楚。

import torch
import copy
from transformers import AutoModelForCausalLM, AutoTokenizer

class SelfPlayTrainer:
    """簡易 Self-Play 訓練器：讓模型跟自己的舊版本對弈"""

    def __init__(self, model_name: str, learning_rate: float = 1e-5):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.current_model = AutoModelForCausalLM.from_pretrained(model_name)
        self.opponent_model = copy.deepcopy(self.current_model)  # 舊版本副本
        self.optimizer = torch.optim.AdamW(
            self.current_model.parameters(), lr=learning_rate
        )

    def generate_response(self, model, prompt: str, max_length: int = 256):
        """讓模型生成回答"""
        inputs = self.tokenizer(prompt, return_tensors="pt")
        with torch.no_grad():
            outputs = model.generate(**inputs, max_new_tokens=max_length)
        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)

    def compute_preference_loss(self, prompt, human_response, model_response):
        """計算偏好損失：模型要學會分辨人類回答 vs 舊版本回答"""
        # 編碼人類回答（正樣本）
        pos_inputs = self.tokenizer(
            f"{prompt}\n{human_response}", return_tensors="pt"
        )
        pos_logits = self.current_model(**pos_inputs).logits

        # 編碼模型舊版本回答（負樣本）
        neg_inputs = self.tokenizer(
            f"{prompt}\n{model_response}", return_tensors="pt"
        )
        neg_logits = self.current_model(**neg_inputs).logits

        # 偏好損失：讓模型更傾向人類回答
        pos_score = pos_logits.mean()
        neg_score = neg_logits.mean()
        loss = -torch.log(torch.sigmoid(pos_score - neg_score))
        return loss

    def train_iteration(self, prompts, human_responses, num_epochs: int = 3):
        """一輪 Self-Play 訓練迭代"""
        for epoch in range(num_epochs):
            total_loss = 0
            for prompt, human_resp in zip(prompts, human_responses):
                # 1. 舊版本生成回答
                opponent_resp = self.generate_response(
                    self.opponent_model, prompt
                )
                # 2. 計算偏好損失
                loss = self.compute_preference_loss(
                    prompt, human_resp, opponent_resp
                )
                # 3. 反向傳播更新
                self.optimizer.zero_grad()
                loss.backward()
                self.optimizer.step()
                total_loss += loss.item()

            avg_loss = total_loss / len(prompts)
            print(f"Epoch {epoch+1}/{num_epochs}, Avg Loss: {avg_loss:.4f}")

        # 4. 更新對手為當前模型的快照
        self.opponent_model = copy.deepcopy(self.current_model)
        print("對手模型已更新為最新版本，開始下一輪 Self-Play")

# 使用範例
trainer = SelfPlayTrainer("microsoft/DialoGPT-medium")
prompts = ["如何提升程式碼品質？", "什麼是持續整合？"]
human_answers = [
    "程式碼品質的核心在於可讀性、測試覆蓋率和一致的編碼風格...",
    "持續整合是一種開發實踐，團隊成員頻繁地將程式碼整合到共享分支..."
]
trainer.train_iteration(prompts, human_answers, num_epochs=3)

這段程式碼的關鍵在第 compute_preference_loss 方法：模型要學會給「人類回答」打高分、給「舊版本自己的回答」打低分。隨著訓練進行，模型生成的回答會越來越像人類品質——因為如果舊版本的回答已經夠好，新版本就必須做得更好才能得到正向獎勵。

Self-Play 在程式碼生成與自動化測試的進化潛力

程式碼生成是 Self-Play 特別有潛力的應用場景，原因很簡單：程式碼有客觀的評判標準——它能不能跑、測試過不過、效能好不好。這比評估「回答寫得好不好」容易量化得多，跟棋盤遊戲的勝負判定有異曲同工之妙。

程式碼 Self-Play 的三種模式

在程式碼生成的場景裡，Self-Play 可以用三種不同的模式運作：

• 生成-測試對抗：一個模型負責寫程式碼，另一個負責寫測試案例來打破它。生成器的目標是寫出通過所有測試的程式碼，測試器的目標是找到能讓程式碼失敗的邊界案例。兩邊互相強化。
• 解題-出題對抗：一個模型負責解程式題，另一個負責出更難的題目。出題者必須出「剛好難到讓解題者失敗」的題目——太簡單沒有訓練效果，太難則對弈者學不到東西。這就是「近端發展區」的 AI 版本。
• 重構對弈：兩個模型副本交替重構同一段程式碼。每次重構後用靜態分析工具評分，得分高的一方「贏」，並成為下一輪的基準。經過多輪對弈，程式碼品質會持續提升。

import subprocess
import tempfile
import os

class CodeSelfPlay:
    """程式碼生成的 Self-Play：生成器 vs 測試器"""

    def __init__(self, generator_model, tester_model):
        self.generator = generator_model  # 負責寫程式碼
        self.tester = tester_model        # 負責寫測試
        self.history = []

    def run_code_with_tests(self, code: str, tests: str) -> dict:
        """在沙盒中執行程式碼和測試，回傳結果"""
        with tempfile.TemporaryDirectory() as tmpdir:
            # 寫入程式碼
            code_path = os.path.join(tmpdir, "solution.py")
            test_path = os.path.join(tmpdir, "test_solution.py")
            with open(code_path, "w") as f:
                f.write(code)
            with open(test_path, "w") as f:
                f.write(f"from solution import *\n{tests}")

            # 執行測試
            result = subprocess.run(
                ["python", "-m", "pytest", test_path, "-v"],
                capture_output=True, text=True, timeout=30,
                cwd=tmpdir
            )
            return {
                "passed": result.returncode == 0,
                "output": result.stdout,
                "errors": result.stderr
            }

    def play_round(self, task_description: str) -> dict:
        """一輪 Self-Play 對弈"""
        # Step 1: 生成器寫程式碼
        code = self.generator.generate(
            f"請根據以下需求寫出 Python 函數：\n{task_description}"
        )

        # Step 2: 測試器針對這段程式碼寫邊界測試
        tests = self.tester.generate(
            f"以下是一段 Python 程式碼，請寫出能找到 bug 的測試案例：\n{code}"
        )

        # Step 3: 執行測試
        result = self.run_code_with_tests(code, tests)

        # Step 4: 記錄勝負
        round_result = {
            "task": task_description,
            "code": code,
            "tests": tests,
            "generator_wins": result["passed"],
            "tester_wins": not result["passed"],
            "details": result["output"]
        }
        self.history.append(round_result)

        # Step 5: 用結果做訓練（勝者策略被強化）
        if result["passed"]:
            print("生成器獲勝：程式碼通過所有測試")
            # 強化生成器的策略
        else:
            print("測試器獲勝：成功找到程式碼 bug")
            # 強化測試器的策略，同時用失敗案例訓練生成器

        return round_result

# 多輪 Self-Play
game = CodeSelfPlay(generator_model, tester_model)
tasks = [
    "實作一個 LRU Cache，支援 get 和 put 操作",
    "寫一個函數解析 cron 表達式並回傳下次執行時間",
    "實作一個支援事務的 key-value store"
]
for task in tasks:
    result = game.play_round(task)

這套「生成器 vs 測試器」的 Self-Play 模式，跟反思型 Agent 的自我修正機制有很深的關聯。差別在於反思型 Agent 是單一模型的內部反省，而 Self-Play 是兩個角色的外部對抗——壓力更大，進步通常也更快。

Self-Play 的變體——Self-Rewarding 與多 Agent 辯論

Self-Play 不只有「兩個模型互打」這一種形式。2024-2025 年間，研究社群發展出了好幾種變體，各自解決不同的問題。

Self-Rewarding Language Models

Meta 在 2024 年提出的Self-Rewarding Language Models走了一條更激進的路：讓模型不只自己訓練自己，還自己給自己打分。傳統 RLHF 需要一個獨立的獎勵模型（Reward Model），而 Self-Rewarding 把獎勵模型和語言模型合一。模型在 LLM-as-a-Judge 的框架下，同時扮演「選手」和「裁判」。

用 Llama 2 70B 做三輪迭代後，模型在 AlpacaEval 2.0 的表現超越了 Claude 2、Gemini Pro 和 GPT-4 0613。這個結果的震撼之處在於——Llama 2 70B 的基礎能力遠不如 GPT-4，但透過 Self-Play 式的迭代自我提升，它在特定評測上追了上來。

多 Agent 辯論：群體 Self-Play

另一個有趣的變體是多 Agent 辯論。標準的 Self-Play 是 1v1，但多 Agent 辯論把規模擴展到多個模型同時對話，透過「辯論 → 投票 → 修正」的循環來提升回答品質。MIT 和 Google 的研究顯示，三個模型經過辯論後的回答準確率，比單一模型高出 15-25%。

這些變體的共同點是：不依賴外部的、更強的模型來指導。這在實務上非常重要——當你手上只有一個模型，沒辦法存取 GPT-4 或 Claude 的 API 來做教師指導時，Self-Play 系列方法就是你的出路。關於怎麼設計 Agent 之間的協作架構，可以參考我們的AI Agent 入門教學。

Self-Play 的五大陷阱與避坑策略

Self-Play 不是「設定好就讓它跑」的魔法按鈕。在實際操作中，有幾個坑我自己踩過，也看到社群裡很多人踩。

策略崩潰（Strategy Collapse）

最常見也最危險的問題。兩個對弈的模型可能會共同發現一個「取巧策略」——在棋盤遊戲裡可能是某種無限循環的走法，在語言模型裡可能是生成一堆看似流暢但毫無內容的廢話。因為兩邊都在用同一個策略，所以勝率各半，訓練信號消失，進步停滯。

遺忘效應（Catastrophic Forgetting）

當模型在 Self-Play 中學到新策略時，可能會忘記之前學過的好策略。這在 LLM 上特別嚴重——你的模型可能在對話能力上進步了，但寫程式的能力退化了。解法是用 EWC（彈性權重鞏固）或定期在原始數據上做回放訓練。

評估陷阱（Evaluation Trap）

在 Self-Play 中，你怎麼知道模型真的變強了？如果評估標準就是「贏過對手」，而對手也在一起變爛，你可能看到勝率維持 50% 就以為一切正常——其實兩邊都在退步。必須保留一個獨立的外部評估基準。

計算資源爆炸

每一輪 Self-Play 都需要跑兩份模型推論 + 一次訓練更新。AlphaZero 用了 5,000 個第一代 TPU 來生成自我對弈數據，加上 64 個第二代 TPU 來訓練——這不是一般團隊玩得起的規模。好消息是，LoRA 和量化技術已經把門檻降低了很多。用 QLoRA 搭配梯度檢查點，一張 A100 就能跑 7B 模型的 Self-Play。

獎勵駭客（Reward Hacking）

模型可能會找到「騙過獎勵函數」的方法，而不是真正提升能力。在 Self-Rewarding 模式下特別容易發生——如果模型同時是選手和裁判，它可能學會「寫出讓自己打高分的回答」而不是「寫出真正好的回答」。解法是在 Self-Play 過程中定期引入人類評估做校準。

從零開始設計你的 Self-Play 管線——實戰清單

假設你現在手上有一個微調過的 LLM，想導入 Self-Play 來進一步提升品質。以下是實際的操作步驟。

Step A：定義對弈規則

你需要先回答這個問題：「怎麼判斷誰贏了？」對話品質可以用 LLM-as-Judge 打分、程式碼可以用測試通過率、翻譯可以用 BLEU/COMET 分數。獎勵信號越清晰，Self-Play 的效果越好。

Step B：建立對手池

不要只保留「上一個版本」當對手。建立一個對手池（opponent pool），保留最近 5-10 個歷史版本，每次隨機抽選對手。這能有效防止策略崩潰——即使新版本學到了一個針對上個版本的取巧策略，它還是可能輸給更早的版本。

Step C：設定更新門檻

不是每一輪訓練都要更新「官方版本」。AlphaZero 的做法是：新版本必須在跟舊版本的對弈中達到 55% 以上的勝率，才能取代舊版本。這個門檻可以根據你的任務調整，但一定要有。沒有門檻，模型可能因為一次糟糕的訓練就退化。

Step D：多樣性監控

在每輪 Self-Play 之後，檢查模型輸出的多樣性指標（distinct-n、entropy）。如果多樣性持續下降，代表模型正在收斂到單一策略。這時候需要介入——增加溫度參數、引入隨機採樣、或在訓練中加入多樣性獎勵。技能庫的設計原理也可以幫助你理解怎麼讓 Agent 保持行為多樣性。

Step E：外部校準循環

每 5-10 輪 Self-Play，插入一次人類評估或外部基準測試。這是防止「兩邊一起變爛」的最後防線。如果發現外部指標退步，就回滾到表現最好的版本重新開始。Constitutional AI 的原則式對齊也能作為 Self-Play 過程中的外部校準機制。

Self-Play 的未來——從訓練技巧到 Agent 生態核心

Self-Play 正在從一種「訓練技巧」演化為 AI Agent 生態系統的核心機制。當我們看到 Self-Rewarding、SPPO、對抗式紅隊測試這些應用一起浮出水面，一個趨勢已經很清楚：未來的 AI 系統不只會從人類數據中學習，更會從跟自己的對話和對抗中持續進化。

OpenAI 在 2019 年的多智能體捉迷藏實驗就預示了這個方向——在純 Self-Play 環境中，Agent 自動發展出了使用工具、建造障礙物、甚至利用物理引擎漏洞的行為。沒有人教它們這些，全部是對抗壓力逼出來的湧現行為。

2026 年以後，我預期會看到三個發展方向：

• 持續學習的 Self-Play Agent：部署在生產環境中的 Agent，會在背景持續跟自己的歷史版本對弈，自動發現能力退化並修復。這比定期重新訓練更即時、更經濟。
• 跨模態 Self-Play：不只在文字上對弈，而是在視覺、聽覺、操作等多模態任務上做 Self-Play。想像一個機器人在虛擬環境中跟自己的舊版本比賽組裝零件——誰組得更快更精確。
• Self-Play 即服務：雲端平台提供 Self-Play 訓練基礎設施，開發者只需要上傳模型和定義獎勵函數，平台自動安排對弈、訓練和評估。降低門檻讓中小團隊也能用上這項技術。

如果你正在思考怎麼讓自己的 AI Agent 持續進化，Self-Play 會是工具箱裡最值得投資的一項能力。不管是用在模型訓練、安全測試、還是品質保證，「讓 AI 跟自己打」這個看似簡單的概念，蘊含著推動整個領域前進的動能。

Self-Play 常見問題

下一步：讓你的 AI 開始跟自己對打

Self-Play 的核心精神很簡單——不要等更強的老師出現，讓模型成為自己的老師。從 AlphaGo Zero 的 490 萬局自我對弈，到 SPIN 讓 LLM 無需額外標註就能超越 DPO 訓練的模型，這個方向的潛力才剛開始釋放。

如果你正在開發 AI Agent、優化 LLM 品質、或建立紅隊測試流程，Self-Play 值得你認真研究。不需要 Google DeepMind 等級的資源——一台有 GPU 的工作站、一個清晰的獎勵函數設計、加上本文提供的框架和程式碼，你就能開始實驗。

想跟我們討論怎麼把 Self-Play 或其他 AI 進化策略導入你的專案？預約一次免費的 AI 技術諮詢，我們可以一起看看你的模型有哪些地方能透過「跟自己打」來突破瓶頸。