〈Stanford CS329A Self-Improving AI Agents〉-EP-Part 9 | Future Research Areas

https://www.youtube.com/watch?v=AyO6wyu4DEg

自我改進的迴路要一直轉下去,卡住它的通常不是模型不夠大,而是三件事:推理鏈不夠多元、驗證不夠可靠,還有要練什麼題目仍然得靠人挑。

這是 Stanford CS329A 最後一堂課的收法。前面八講把「自我改進的 Agent」拆成一堆零件,最後一講先把整季收回來,再把上面那三件事各自對到一篇論文,最後換一個尺度問同一個問題:這些 intelligence 要用多少瓦去換。講者在開頭就半開玩笑說,這個領域動得太快,也許下次開課,這三篇論文就各自變成一份講義了。

一季的課,收在一個迴圈上

課是從 LLM 開始的。過去這一年,test-time scaling 跟 train-time scaling 靠的是自我改進:迴圈由 verifier 跟 feedback 驅動,跑 verifier 拿到 reward,再用 RL、甚至 search algorithm,讓模型在數學跟程式這類題目上往山上爬。這是課程前半段的重心。

再往下走是 evolutionary strategies,有一整堂課在講 open-endedness。這裡的迴圈不只用 reward 拉;如果探索空間定義得出來,也可以讓模型自己去探索,課上談的是 Alpha Evolve 這類做法。

然後是 paradigm 的轉換:用 tool use 組出 end-to-end 的 workflow。模型跟環境、工具互動,整段流程就能自己跑;任務要跨好幾步,就得去看知識庫,於是需要 retrieval 跟 memory。越靠近真實世界的工作,planning 跟 multi-step reasoning 就越吃重。客座講者補上 post-training、multimodal agents、robotics、reasoning 這幾塊;另一位講者講了 symbolic techniques,它歸在 tool use 這把傘底下,也可以餵進 synthetic data,而這是另一個正在發生的趨勢。

把這些拼起來,就是這門課名裡的 Agent。它有自己的 goal,會去跟環境互動、收 feedback,再用 feedback 修正自己的步驟;它是指揮自己流程、會用工具、把目標完成的系統。課名取作 self-improving agents,重點不只在 LLM,也在 Agent 這一面。現在這個階段,LLM 本身常常還不夠力一個人走到終點,所以人會把系統手寫成 workflow,去編排 LLM 跟工具;coding agent 這一類已經看得到 agentic workflow 自己在跑。workflow 裡編排的東西包括 LLM、verifier(通常需要一個 reward 的來源,verifier 常常就是 LLM 當 judge)、tool call、search algorithm,也可以是平行的 LLM 呼叫一起去搜。因為整條 workflow 在追一個目標,它需要 planning、需要跨多步的 reasoning、走錯方向時要修正,而且整體能力要一直往上。self-improvement 就是在這裡進來的。

同一顆模型生出來的推理鏈太像

第一篇論文處理的是多元性,方法叫 multi-agent fine-tuning。

先看它想解的難題。pre-training 的算力花在壓縮網路規模的資料上;instruction tuning 往往要真人資料,需要人的偏好來判斷哪個回應好、哪個回應爛。替代方案是用 LLM 生成的資料,也就是 synthetic data,做成 iterative fine-tuning:讓模型生出可能的解答,把錯的濾掉,這叫 rejection sampling,然後只拿對的那批去微調。變化型不少,STaR 就是課上講過的,也可以把 reasoning chain 一起塞進這個過程。

問題出在:生成資料的如果是同一顆 LLM,它生出來的解答會非常像,效能往往幾輪、或幾十輪之後就停住。根因是缺乏多元性。pre-training 規模的資料之所以雜,是因為那是人在很長時間裡累積出來的;同一顆 LLM 對同一批 prompt 生成的輸出,溫度開高也多元不起來。

所以這篇的答案是找多個有專精的 Agent。generation agent 負責生出多樣的初始解,critic agent 負責評估跟修正,兩種都是訓練出來的。流程是這樣:N 個 generation agent 先各出一個答案,接著對這批答案做一次摘要(可以另一顆模型來摘要,也可以直接接起來),critic 對更新後的答案下評論,評論再塞回輸入。第二輪所有 generation agent 生出更新版答案,取多數決,再摘要,可以一路當成辯論打下去。

一般做法是針對單一 Agent 的回應下評論,這裡評的是多個 Agent 的回應先專精、摘要之後的版本。好處是在 critique 之前,差異就已經在裡面了;多數決等於是免費拿到的,前提是這些 Agent 訓練得不太一樣。generation model 都是從同一個 base model 微調出來的,目標是給定問題時產出好答案;每一輪把輸出跟多數決比對,符合的留下,用這些 prompt-response 對做 SFT。最陽春的版本是直接換不同模型來生,實務上也有人這樣做,講者稱它是窮人版的多模型生成。critic model 也是微調過的,輸入是題目跟更新後的答案,工作是把最好的挑出來;它的訓練資料混了「答案一開始是對的,後來在辯論中被修正」這類軌跡,學的是對比對與錯的答案。

結果要看兩張圖。橫軸是微調迭代次數,縱軸一個是 negative log likelihood,當效能的代理,另一個是 embedding dissimilarity,數值越高代表越多元。兩個開源模型在多 Agent 微調下,效能可以繼續往上,Llama 3 對這個方法反應特別好。右邊那張圖更有意思:整個過程裡回應一直維持相當多元,資料集是數學。三個開源模型都看到同一件事,多 Agent 的做法撐過好幾輪微調還在進步,單一 Agent 微調的準確率則會崩掉或不再往上。因為要微調,能測的只有開源模型。這是有點舊的工作,數字不算高,但連 GSM8K 這種鄰近領域都拿到比較高的表現,代表它不只在自己那份 in-domain 資料上有用。

回到大圖:要自我改進,餵進去的 reasoning chain 本身要夠多元,靠多顆模型或多個 Agent 去生,是其中一種做法。

答案對,推理鏈不一定對

第二個瓶頸是驗證,這個題目課程前幾講就碰過。

通常的做法是只看結果。數學題或定理證明,你看的是最後答案,用 outcome reward model 判斷有沒有對上 ground truth,對上就算驗證過。課上討論過兩個問題:如果推理鏈是錯的,會不會把模型帶歪、最後造成效能落差?以及 process reward model 為什麼那麼難做?

DeepSeek-MathV2 是最近出來的論文,想證明至少在定理證明這個領域,自動化的 self-verification loop 做得起來。

它要打破的假設是這樣:現在 RL 的前提是最終答案要對上 ground truth,這就是 reward 的來源,也讓 AIME 之類的數學 benchmark 一個一個飽和。但有正確答案不代表推理是對的;要模型在定理證明上真的變強,需要嚴謹的逐步推導,最終輸出給不了這個。麻煩在於 LLM 大多是在定量推理的資料上訓練出來的,生出來的證明在數學上可能根本無效,你叫它自己驗,它會說錯的證明是對的,LLM-as-a-judge 在這裡不太管用。懂這個領域的專家一看就知道問題在哪:這一步接不上前一步,或是在引用的地方有推理斷層。

DeepSeek-MathV2 除了 reward model 之外,還訓練 verifier,再在上面加一層 meta-verifier。一開始先讓真人指出證明裡的問題,而且不給參考解;用這批資料訓練 LLM 去辨認證明裡的問題、並且改進,最後就得到一顆能自己批判證明的模型。

架構上,generator 加 verifier 是 train-time scaling 的標準配置,一顆模型生證明,另一顆指出問題。多出來的是 meta-verifier:它會去看 verifier 的分析合不合理、對這份證明的判斷有沒有問題;verifier 則被訓練成根據這些問題替證明打分,分數落在 0.5 到 1 之間。verifier 再去改進 generator,generator 生出更難的證明,回頭再改進 verifier,形成一個迴圈。另一個重點是標註可以自動化:一旦有了找錯證明的種子資料,meta-verifier 把這件事學會之後,就不必一直靠人來標。

meta-verification 這個概念本身也值得記著。verifier 有可能在推理鏈是錯的時候給出正確的分數,例如它自己編出根本不存在的錯誤。meta-verification 問的正是:verifier 指出來的問題真的存在嗎?分數有從那些問題推出來嗎?也就是在評估「verifier 做得好不好」。他們讓專家標註這個評估的品質,只加上這一個 block,品質就往上。原本是 reasoning chain 上面有一層 verifier,現在 verifier 上面再問一句「這個評估對不對」。

結果的部分:RL 迴圈一般蓋在 GRPO 上,這篇蓋在 DeepSeek V3 的 base model 上。驗證與生成的迴圈在 IMO 題跟 CNML 題上跑 benchmark,這組題先前有客座講者講過 Gemini 版本,這篇是最近開源的版本。八輪迭代下來,只算 pass@1,proof score 就一路往上;換成 best@32,也就是從 32 份生成的證明裡挑最好的,在 IMO 2024 shortlist 上幾乎到 42%。當成一種 hill climbing 技術看,這相當有潛力,意思是只要你能指出推理鏈的問題,把模型往修掉這些問題的方向推,就有東西可以爬。

洞見收在這裡:最好的證明會拿到比較高的驗證分數,generator 也學得會分辨高品質跟有瑕疵的證明,self-verification 於是有比較好的改進迴圈。驗證可以是瓶頸,這是打破它的一條路。要搬到別的領域,需要的條件講者列得很清楚:LLM-based verifier 要在沒有參考解的情況下指出問題;要有 meta-verification 這層額外的 block,降低 verifier 幻覺出問題的機率;還要給 generator 額外的誘因,讓它靠刻意的推理把品質最大化。當然,這套還是受限在驗證相對容易的領域。

題目也讓模型自己出

第三個問題是:該練哪些資料、哪些 prompt?這篇論文還沒看到太多人用,但講者覺得很有意思:讓模型自己提出一批剛好落在「學過的邊緣」的任務。

現在的訓練堆疊是這樣:supervised learning 階段用人整理好的 reasoning trace;到了 RL with verifiable rewards,要靠專家整理問答對。做數學要數學專家,做 IMO 題要 IMO 專家,寫程式要強的軟體工程師。當模型能力繼續超過人,要找到更多專家、更多這種題目,就會開始卡住。

這篇的提議是讓同一顆模型既出題、也解題,等於走到另一個極端:不需要外部資料來源,也不需要人寫的 prompt。這件事在某些領域可行,他們挑了程式。題目分成三種:abduction、deduction、induction。

proposer 出題的方式,基本上就是幾種程式題的 paradigm。deduction 是生出程式跟 input,環境執行之後得到 output。abduction 類似,一樣生程式跟 input,環境算 output。induction 不一樣,它抽一個現成的程式,替它生新的 input,再加一段自然語言描述這個函式在做什麼,環境執行完再判斷這是不是往對的方向走。proposer 會 conditioned on 過去生成的例子,這些例子會明確寫進 prompt,作用是增加多樣性。

題目怎麼選?用難度。每一道生出來的題目都會送給 solver,成功率是 0,proposer 拿 0 分;成功率不是 0,就拿 1 減掉平均成功率。他們想選的是不 trivial、也不 impossible 的題,也就是 solver 有時成功、有時失敗的中等難度,這樣才有東西可學。proposer 的目標是在當前權重下生出最佳難度的題目;模型變強,它就要學會出更難的題。

有效性也要顧。在程式的抽象下,可以跑程式完整性檢查,真的執行看有沒有錯;可以做安全檢查;也可以確認同一組 input 跑很多次會拿到完全一樣的 output,這件事在程式裡做得到。提議的題目進訓練管線之前都會先驗過,這樣 proposer 沒辦法靠 hack 生出垃圾題。另外有一個 buffer:每一組 seed triplet(identifier、input、output、program)都會進 task buffer,proposer 可以從裡面抽參考,同時記著模型在這題上成功或失敗過幾次。累積下來就是一個隨時間演化的 curriculum。

結果是在 coding benchmark 上拿到 SOTA,而且 prompt 那一側完全沒有人整理過的資料,表現還贏過用數萬筆專家範例訓練出來的模型。出現的行為包括:複雜度指標隨時間往上,這在 proposer 一直加難度的情況下可以預期;迴圈設定正確的話,程式跟答案的多樣性也變好;proposer 隨著訓練進行,出的題越來越難。proposer 跟 solver 有一點對抗的味道,像賽局,但整體是把對方推上去。

這裡的 takeaway:任務選擇不該卡在人的資料上,前提是有某種形式的驗證,而且要有做 curriculum learning 的能力。雖然只在模型自己出的程式題上 hill climb,coding 跟 math benchmark 上都有強表現,math 也變好是比較意外的事,用領域裡其他結果可以解釋一部分。還有一個規律:模型越大,相對小模型拿到的增益越大。

另一位講者補了 Swirl 的結果,說兩邊看到的東西很像。在 Swirl 裡,模型自己生成訓練資料,不只讓它在生成資料的那個任務上變好,還會有 transfer。Swirl 做的任務是帶 retrieval 的 multi-hop 問答,但隨著 synthetic data 越生越多、RL 越做越多,模型在別的工具呼叫上也變好,例如呼叫 Python 解數學題,反過來也一樣。這裡有一個重複出現的趨勢:模型自己生成資料,跟泛化是綁在一起的。另一件有趣的事是,比較大的模型更會吸收這種 data flywheel、也更容易從中泛化,至少在 Swirl 的 RL 最佳化這一側是這樣。

講者把三個瓶頸收在一起,順便給出下一個研究方向。要真正的泛化跟推理,reasoning chain 的多樣性是關鍵,而怎麼做到還是開放問題;驗證要更好,越能打破驗證迴圈、不被人力或只有專家驗得動的題目卡住越好;第三是資料選擇,人能整理的 prompt 有限,打破這道牆對下一代的自我改進模型很重要。另一位講者補的方向是:如果只在「可以驗證、可以生 synthetic data」的領域把自我改進推到極限,把這些能力帶回多樣的 verifiable 任務,效能能被推到多高?能不能讓模型在驗得動的領域越來越聰明,同時把不可驗證領域對標註資料的需求降到最低?他補了一句,這會是很吃算力的實驗。

驗不動的領域怎麼辦

課堂上有人問,哪些應用不落在 verifiable 問題裡。答案是驗證很慢的那些:科學發現;chip design 裡跑一次要好幾天的模擬,跑完才收到一個 reward 訊號;或是化學實驗,得進 wet lab 跑完才知道品質好不好。這些領域難,是因為 RL 微調或 test-time scaling 需要 verifier 幾乎是即時的。等一下可以,幾分鐘可以,一小時或許也行,但 RL 訓練要跑幾百幾千步,不能等好幾天,也不能讓人進迴圈替它收 reward。真正不可驗證的還包括創意,或任何帶主觀性的指標。creative writing 就是:設計一個精確的 reward function 很難;當然可以把它建模出來,但模型只要稍微偏掉,RL 或 Agent 就會去 reward hacking。

現在有人怎麼解?訓練一顆另外的 reward model 去預測模擬的結果。不要真的跑那些昂貴的模擬或實驗,先在線下收一大堆資料,訓練 reward model:給定 input,預測 output 的品質,然後拿它當 RL 最佳化裡的驗證對象。但 reward model 的泛化能力取決於資料量,也可能不準,不準就會出事。

講者另外補了自己領域的例子。不用講到 chip design,光 Stanford 跟 Yale 做過的 kernel bench,編譯器執行就能給訊號,看有沒有生對程式,也有些指標可以量。但有個課堂專案要讀 performance profile,事情一複雜就難了:簡單的東西或許能設計出最佳化過的 kernel,但把這些東西全部串起來、要做 performance profiling、還要改掉沒最佳化的部分,整體上就是更難的問題。常見的解法是把問題拆成子問題,讓模型一個一個看,再放一些參考解在知識庫裡讓它查。講者說他描述的其實就是那個課堂專案,重點是問題本身難、模型能力又還沒到,所以往往要靠拆解,拆成模型現在做得到的樣子。

每一瓦能換到多少 intelligence

前半段講的是怎麼讓模型更會自我改進,後半段換一個角度:這些 intelligence 要花多少電。

這是跟 Professor Ray、Professor John Hennessy 及一大群合作者一起做的工作。他們看模型端跟硬體加速器端的趨勢,想知道未來的 AI 推論工作負載會長什麼樣,模型多大,需要什麼樣的加速器來服務。

現在的處境,講者用一個詞形容:mainframe 時代。ChatGPT、Gemini 這些大模型都跑在雲端,不跑本地,因為模型大;有些是專有的,根本拿不到;就算是開源的大模型,也還是在雲上跑。同時算力需求在爆炸。Google Cloud 過去十二到二十個月,服務的算力成長大約 1200 倍;Nvidia 有過年增 10 倍的年份。這些數字明確是被 AI 拉出來的。要滿足這個需求,資料中心要的電力大約是 250 gigawatt 這個量級,而且還在往上,所以能源供應只會更吃緊。Google 那邊處理的 token 數,去年二月是 160 兆,今年十月是 1.3 quadrillion,也就是 1300 兆。這是歷史上最快的算力需求成長之一。

但看一下工作負載長什麼樣。從一份很大規模的 ChatGPT 使用者資料集看,大約 77% 的請求是實用指引、找資訊、寫東西這類任務。很多這類任務不需要最強的前沿模型,小一點的本地模型就能處理。使用者當然會隨著 chatbot 變強、問越來越難的問題,但絕大多數查詢還是落在複雜度比較簡單的那一側,小的模型就接得住,不必動到大顆的專有模型。

另一邊,本地推論加速器在進步。2012 年到現在,本地加速器的 GPU 記憶體大約成長 126 倍;現在筆電、MacBook 可以有 100GB 這個量級的記憶體,再加上 8-bit 量化,某些最大的模型也能塞進本地跑。所以問題變成:本地推論可以在重新分配推論需求這件事上扮演什麼角色?現在幾乎所有流量都進雲端,進 H100、TPU、GP200、GP300 這些加速器。

為了系統性地看,他們先定義一個指標,intelligence per watt,簡稱 IPW。能力這一側看的是模型能處理多少比例的查詢,針對單輪跟推理型的查詢;這份研究裡把本地模型定義成 active parameters 20B 以下。效率這一側看的是在本地硬體上跑這些模型,每一瓦能換到多少有用的算力。定義寫下來是平均任務準確率除以平均功耗。

他們看的範圍:二十多顆本地模型,包含 Qwen、GPT-OSS 這類;企業級跟本地加速器都看;工作負載是一百萬筆來自 ChatGPT 的查詢,加上 natural reasoning、MMLU Pro、Super GPQA 這類推理 benchmark;指標有準確率、能源、延遲、算力使用等。這批資料拿來理解趨勢,不同模型與硬體組合下的各種指標也開源出來。

三個發現。本地模型已經很不錯,進步的趨勢更值得注意:2023 年以來,它們在準確率、或說能解決的 chat 查詢比例上成長 3.1 倍,而這只花了兩年;現在能處理前面那批查詢裡大約 88.7%。本地加速器的效率還落後企業級晶片,Apple M4 Max 的 IPW 比 B200 低 1.5 倍;原因是 B200 極度針對語言模型工作負載最佳化,M4 還要顧其他種類的工作負載,而且當初設計這些晶片時並不預期 LLM 會跑在本地,所以晶片設計者的重心大多放在雲端規模。最後一個觀察是 IPW 這個指標在過去兩年大約改善 5.3 倍,其中 3.1 倍來自模型變好,另外 1.7 倍來自硬體變有效率。

兩條趨勢擺在一起看:本地模型越來越強,能解以前解不了的題,速度還很快;同時模型效率跟硬體效率都在變好。這指向一個未來:越來越多流量可以由跑在 edge device 上的模型處理,筆電或手機都算。

還沒解完的幾件事

講者把幾個沒解完的方向列出來。一個是 test-time scaling 的基礎原理。現在的做法是透過 RL、收資料、然後微調模型,但這裡顯然還有更多東西。比如:為什麼會有這種性質?一直對模型問同一個問題、靠 test-time scaling 讓正確答案冒出來,這件事對模型來說代表什麼?把成功的軌跡 distill 回模型的最佳做法又是什麼?這些都還是開放問題。從 synthetic data flywheel 這個現象,可以很清楚接到 continual learning。

continual learning 的落差是這樣:人解任務、學東西,腦子是一直在進步的;模型大多是離線流程,某個 Agent 收了經驗,過一段時間才微調一次。人的行為跟模型的行為之間有落差,continual learning 這個概念有可能處理它。講者想問的是,什麼新的做法可以把正向經驗、從負面經驗學到的東西、還有模型解題的過程,用更自然的方式放回模型裡,不要走現在這種非同步的「生資料、再微調」。

還有一塊是 infra:high throughput、low latency 的 test-time scaling。test-time scaling 的做法,不管是重複取樣、對前幾輪的結果來回更新、還是工具呼叫,都跟現在主流的 chatbot 用法差很多,後者大多是單輪來回。這代表系統與推論最佳化有很大空間。講者的實驗室做過 Hydrogen、Tokasaurus 這類工作,這些方法變成主流之後會更重要,需要特定的做法去最佳化系統跟底層算力。

課程那張總圖上,pre-training 那一塊也有很多有意思的工作,這門課碰得比較少,重心放在 post-training 跟 test-time scaling。而現在衝出來的是 synthetic data flywheel 跟 continual learning,它們長在 fine-tuning、online learning 跟 test-time scaling 的接縫上。回到 IPW,下一步也很清楚:如果推論真的從全部在雲端,變成很大一部分在本地,那會需要 hybrid 的 inference serving engine,能在本地與雲端的模型跟加速器之間順順地分流,看需求跟資源的複雜度決定。另一個方向是新的模型架構與 kernel,特別是為本地加速器做能源效率,這塊比雲端加速器少人做很多。能源會是接下來最珍貴的資源;IPW 這類指標,以及更好的方式去理解與量測能源、瓦數、功耗,並且據此最佳化,會很重要。現在它還不是主流的目標函數,但預期會越來越普遍。

學生問的問題

第一個問題是:continual learning 是記憶系統的事,還是 LLM 本身的事?講者說,long-term memory system 確實是人類的類比。但在那之前,光是在 multi-step reasoning 裡從成功與失敗學習,讓模型把這套技能留下來,把權重、或一部分權重用有用的方式更新,就已經是個重要能力,而我們基本上還沒有。能不能學會一個新技能?能不能學會怎麼學?他舉機器人當例子:能不能看影片就學會一件事怎麼做,而不是被餵一大堆任務示範。

另一位講者補了其他把知識帶進來的路。in-context learning 是一種。想像有一個無限長的 context,模型可以完美取用裡面每一塊、並且從中學習;我們沒有這個,但如果有的話,那也許就是 continual learning 的一種解:把所有正面與負面的東西都放進 context,模型同時記得、同時對它推理。現在做不到,就算到一百萬、幾百萬,模型對 in-context 資料的推理能力還是會衰減。另一條路是課上講過的 Cartridge:不動權重、不微調,把東西放進 activation,或說 KV cache,來實現長 context 與 in-context learning。所以 continual learning 不一定只等於微調,把有效 context 長度大幅拉長也是一種想法。

追問是實作面的:一直更新權重,還是更新一個記憶庫,哪個比較容易?講者說看應用。如果那是知識庫,更新記憶庫容易,最簡單的版本就是留一個資料庫讓 LLM 學著去查,要更新就更新資料庫。但你真正想教 LLM 的是對新領域推理的能力,外掛一個記憶系統做不到這件事,這時候更新權重就做得比較好。他舉機器人為例:不管加多少記憶系統,如果沒有更新 LLM 的權重,cross-embodiment generalization 不會發生,那比較是技能轉移的問題。

另一個問題來自課堂,問到 Absolute Zero 那篇:環境好像就是 post-training 用的資料,那有沒有論文是讓 Agent 自己生出環境的?講者回,在只有窄域智能的世界裡,遊戲可以做出模擬,拿來當玩具任務的環境。這一代環境之所以重要,是因為它們是真實世界任務的代理。所以重點不在「有沒有讓 Agent 自己生環境的論文」,問題其實是:你想代表的是哪一組任務,如果它容易模擬,用 Agent 生或用軟體生差不多。真正要問的是,它是不是模型跟真實世界互動、拿 feedback 的合理代理。遊戲的探索空間有限,比較容易用程式表示,也比較容易做模擬。

課結束的地方

講者在最後謝謝這班學生,說教這門課、準備這些內容是很享受的事。這個領域在動,現在教的東西,等下次開課就開始變成歷史,但學到的基礎技術長期都有價值,因為新東西大多還是長在這些基礎上;他也期待看到大家的專案與 poster。

另一位講者補的是自己的角度:他們在做投影片、備課的過程也學到很多,因為很多題目就是這麼新。謝謝學生一起走這段,希望大家學到新技能、被新的方向啟發,也希望這只是開始。

〈Stanford CS329A Self-Improving AI Agents〉-EP-Part 8 | Agentic Evaluations and Long Horizon Tasks

https://www.youtube.com/watch?v=8JAqLnTaZu4

Stanford CS329A「自我改進的 AI Agent」第八講的主題是 agentic evaluations 跟 long-horizon tasks。課一開始先問了一圈,班上同學做過的 agentic eval 有 multi-hop 的問答、有拿私人 wiki 當知識庫的 QA、有幫論文核對參考文獻的正確性,也有重構整個 repo 這種事。這些場景有個共通點:它們都不是答案已經放在 context 裡、答一次就結束的題目。

講者也提醒尺度的變化。四、五年前,模型能生出任何解釋都算大事;現在要量的是它可能怎麼影響經濟、怎麼影響安全,而傳統 benchmark 那種聊天、問答、單次作答的題目正快速飽和。模型卻已經在做要好幾個小時的工作,我們手上沒有一把公認的尺。整堂課用三份研究回答兩個問題:模型能完成多長、多複雜的任務,以及這些任務在真實世界裡值多少錢。

這兩個問題各有一把尺。METR 用人類專業者的工時當錨,量模型能完成的任務時間軸,順便量在那個長度上它有多可靠。OpenAI 的 GDPVal 把真實工作直接交給模型,跟業界專家的產出比 win rate。講者說兩者都有效,看到的 insight 也接近,但量出來的趨勢差很多,而這個差異本身就是重點。

METR:用人類專業者的工時當尺

METR 的題庫由三種長度的任務組成。最短的一組是 1 到 30 秒的原子動作,例如在軟體工程裡把一個檔案打開,約 66 題。中間那組是一分鐘到三十小時的軟體與研究工程任務,數量最多,約 97 題。最長的一組是完整 ML 研究風格的工作,可以做到八小時,只有 7 題。合起來大約 170 題,最短一秒,最長八小時。

流程是這樣:先蒐題、審題,確認每題夠明確;再讓該領域大約五年經驗的專業者實際做一遍,記錄成功完成的時間,以及在他們眼中這題有多難;agent 那邊則反覆跑,量成功率。資料夠了之後,把成功率對人類工時擬合成一條曲線,從曲線上讀出模型在這個任務長度上的表現,也就得到「時間軸」這個數字。

人類那一端有它自己的問題。有經驗的人被訓練成知道「怎樣算做完」,所以常常低估題目的難度;人覺得難不難,跟模型覺得難不難也不一定同步。他們的做法是找幾位專家解同一題,看人之間的一致性,數字差太多就再補資料點,大致一致就往下走。

那個 50% 也要講清楚。它不是「每一題都必須過一半」,而是每個任務各自算多次嘗試的成功率,再把各題的成功率平均起來。所以 50% 的意思比較接近:這件事交給它,大概一半的時候會拿到好答案。

七個月翻一倍,但那是 50% 的成功率

把成功率跟人類工時放在同一張圖上,趨勢是這樣:一秒到三十秒的短題成功率普遍偏高;一分鐘到好幾小時的多元題型散得很開,最高到 0.8,最低到 0;完整研究題有成功案例,整體偏低。任務越長,模型越難一路待在軌道上。

沿著時間軸看模型世代,2019 年的 GPT-2 大約只能處理兩秒的任務;2023 年的 GPT-4 到幾分鐘,換算下來約 8 分鐘;2025 年的 Claude 3.7 Sonnet 是 59 分鐘。這是 50% 成功率的水準,大約每七個月翻一倍。講者用一個日常比喻壓住這個數字:等於把事情交給一個實習生,他只有一半的機率做完,可能交回答案,也可能沒有。

換到 80% 成功率的門檻,同一顆模型只剩十幾分鐘的任務長度,課堂上先講 8 到 10 分鐘,後面換算成 15 分鐘左右。80% 那條線大致也照著同樣的節奏在長,只是位準低了一截。59 分鐘跟十幾分鐘之間的落差,就是真的要部署時會碰到的可靠度問題。

這些改善是哪些能力帶來的?講者列了 reasoning、code generation、tool use 這幾條主線,再加上幾件不那麼顯眼的事:不要一直重複同樣的行為、出錯之後能恢復、對「最終目標是什麼、自己走到哪裡」有記憶跟掌握。課堂補充的方向也類似:把 context 整理好、context 滿了就壓縮、遇到複雜問題先規劃再依新資料重新規劃、拿到使用者回饋就把工作重做一遍,以及對 codebase 這種環境有 memory。

失敗模式是另一個重點。研究者把 GPT-4 這種非推理模型跟 o1 這種推理模型並排比,看到幾種反覆出現的壞法:規劃能力差,不知道怎麼把任務拆成步驟;工具選錯;心算或推理本身算錯;明明還在動,卻提早放棄,因為它不知道這個任務「成功」長什麼樣子;以及卡進重複迴圈,失敗之後還是繼續選機率最高的同一個動作。重複迴圈在 o1 上比 GPT-4 少。講者說,失敗模式分析很有用,因為那直接指出模型還有哪裡可以變好。

這把尺也有它的限制。碰到沒有單一正確答案、比較亂的任務,模型表現會掉。SWE-bench 的趨勢跟 METR 的圖類似,但標註者傾向低估工時,而且模型大多看過那些 GitHub repo,所以在 SWE-bench 上量到的 doubling time 會比完全沒看過的 repo 短。更明顯的是內部 PR 的實驗:同一個題目,外部承包人員會比 repo 維護者慢 5 到 18 倍,而模型的表現比較接近承包人員的時間。講者的解讀是,模型現在的定位還比較像一個沒有 context、被叫來解題的外包,還不是那個懂這個領域的專家。

GDPVal:把真實工作交給模型,跟專家比 win rate

GDPVal 把問法換掉。METR 問的是「這個我想交給 AI 的任務,它能不能做完」;GDPVal 問的是「同一個任務交給模型、不交給人,產出夠不夠好」,而夠不夠好由 win rate 決定,比的對象是業界專家。

題庫直接從真實工作來,設計者是各領域十年以上經驗的專業人士,涵蓋不動產、政府、製造、專業科學與技術服務、醫療、金融、零售、批發,以及資訊業(包含影片剪輯)。課程上舉的例子包括:製造工程師要設計組裝線用的電纜捲軸立架 3D 模型;投資分析師要做競爭地景;註冊護理師要看影像寫諮詢報告;影片剪輯師要依腳本剪出開場影片;客服要草擬回覆不滿客戶的 email;飯店禮賓人員要排一家四口的行程;稽核要從幾張採購單裡找出定價不一致;房仲要做新案的銷售手冊;活動人員要排園遊會的攤位動線。因為這些題目帶主觀成分,成功指標才用 win rate 取代對錯。

規模上,這份資料集鎖定 GDP 前 5% 的經濟價值、九個產業、約 44 個職業;O*NET 裡跟電腦相關的數位任務,大約 60% 進了這個評測集,其中一部分是公開的 gold set。題目平均要七小時才能完成,有些要好幾週;文字跟多模態都有,CAD、影片、音訊、試算表、簡報都算;gold subset 平均一題大約 400 美元;大約 70% 的題目要求模型去跟參考檔案互動;89% 經過專家確認規格夠明確,不是因為寫得含糊才把模型考倒。

趨勢跟 METR 長得完全不同。GPT-4o 在 2024 年的平均 win rate 是 12.4%,之後慢慢爬到 25%,再到 30 幾%,Claude Opus 4.1 上來後是 47.6%。這條線接近線性,跟 METR 每七個月翻一倍的指數線是兩種形狀。

講者花了不少力氣解釋這個差異。指數趨勢很容易讓人往下推:現在能做一小時的任務,下一季就能做幾小時,再下一季就是幾天。GDPVal 說的是,好幾小時、幾天、甚至幾週的任務,模型只有某個程度的可靠度;而且它是按職業拆開來看的,比單看「幾小時」這種數字更接近現實。

模型之間也有性格差異。一邊在美感、文件排版、理解 PDF/試算表/簡報上比較好;另一邊在指令遵循、計算正確、純文字任務上比較好。失敗模式最常見的也是指令遵循:模型答應要去讀參考資料,實際上沒讀,然後用自己的幻覺蓋過去;另外還有排版錯誤。某一邊在跟參考資料相關的指令遵循錯誤明顯較少。

可接受度的分布長這樣:大約一半的任務是「可以接受但略差」,只有約 20% 是模型真的更好,29% 是差或災難;人類評分者之間對同一份產出也有分歧。

課程還把 GDPVal 接回這門課的主題。既然講的是自我改進的 agent,平行採樣或序列採樣(同一題試很多次,每次拿上一輪的結果再改)能改善多少,就是個好問題。允許試 N 次的話,成本大約改善 1.6 倍、速度大約 1.4 倍,相對於沒有輔助的專家;而且在它成功的那個子集裡,成本還不到人類專家薪資的 10%。

哪些職業已經接近打平?政府、零售與批發的表現接近人類專家;短題、幾小時以內的比較好,題目一長就下滑;多模態跟文字任務各有強弱。已經摸到人類專家水準的包括租借櫃檯人員、房仲、進出貨與庫存管理、採購、電腦與 IT 系統主管、軟體開發;另一張圖上表現突出的是政府行政服務主管、法遵人員、醫療與健康服務主管、個人理財顧問、客服、零售銷售第一線主管,以及銷售、編輯、調查與新聞分析這幾類工作。

但把 prompt 裡的 context 拿掉,win rate 會掉幾分,更根本的問題是模型不知道該去做什麼。真實工作是 context 很重的:人負責決定要解哪一個問題、要把哪些背景放進來,模型負責解。這跟前面承包人員與維護者的落差是同一件事的兩面。講者的近期結論也因此保守:AI 輔助已經在專業 workflow 裡發生,配上人類監督確實划算,不同職業受影響的程度差很多,而且不同模型強在不同任務類型。

DeepScholar-Bench:寫一篇 related work,看它漏掉什麼

第三份研究把焦點放在研究合成上面。任務是幫學術論文寫 related work 那一節。這個題目算是課堂上有人許願的,希望 AI 幫忙寫論文的 literature review。選它有兩個理由:寫論文的人都需要它,而且它必須不斷更新,用新論文重跑,沒有過期這回事。這個領域也不是沒人做,OpenAI、Gemini、Perplexity 都有 deep research 產品,STORM 跟 OpenScholar 從史丹佛出來,這門課的作業也讓人自己搭過一個 deep research agent。

資料集用近期 arXiv 論文,PhD 難度,橫跨 22 個領域,每月用新論文重跑一次,所以它是 live benchmark,也避開資料污染;挑的論文只在主要模型訓練完成之後才發表。

評分拆成三個軸。第一個是 knowledge synthesis:產出有沒有把知識組織好、讀起來連貫,以及有沒有抓到關鍵事實。第二個是 retrieval quality:檢索回來的參考文獻跟你要研究的主題相不相關,引用次數好不好看,以及涵蓋度,也就是有沒有找到真正重要的論文。第三個是 verifiability:citation 有沒有支撐它旁邊那句話,這裡同時看 precision(引的都對)跟 coverage(該引的有沒有引)。三個軸的指標都經過人類驗證,人類之間的一致性大約 70% 到 80%。

現有系統沒有一個超過 19%。講者特別點出,大部分 benchmark 到後來都會飽和,這一個還有一大段空間。

拆開看更有意思。某一套 deep research 系統的英文寫得好、組織也漂亮,但幾乎所有模型都持續漏掉關鍵事實,漂亮歸漂亮,不保證涵蓋。檢索整體只是「還可以」,大家都找不到完整又重要的來源,文件重要性全部低於 12.5%。verifiability 方面,有一套系統的 precision 到 90%,而 OpenAI Deep Research 的英文很順,verifiability 反而較低。講者把話說得很白:寫得連貫跟驗得過,目前沒有一套系統同時做到。

失敗模式集中在幾個地方。找不到完整的來源;即使找到相關文件,也不一定找到奠基性的論文,因為專家是靠經驗知道哪些非引不可,那種 context 是累積出來的;模型不太會判斷文件重不重要,只能判斷相不相關;檢索對了,也不一定有效率地抽出關鍵資訊,把正確來源直接給它,關鍵事實的覆蓋率也只有大約 50%,不給更低。

這也回答了「為什麼要挑一個看起來很窄的題目」。講者的論點是,真實任務要能用,就得有辦法好好查知識庫,研究合成只是一個代表案例。任務長度跟經濟價值之外,還有一整類能力是關於去哪裡找資料、找到之後怎麼用、用完能不能驗。

三張尺量到的不是同一件事

三份研究並排之後,會發現它們各自簡化了不同的東西,缺口也不一樣。

METR 是自動評分,沒有多 agent 互動,題目設計成單一 agent 就能跑,不特別懲罰犯錯,也沒有資源限制。真實工作可能有主觀的評分標準,可以拆給多個 agent,也有成本跟犯錯的代價。

GDPVal 的題目規格寫到極致,人腦裡該有的 context 全部寫進 prompt,而且一次做完,沒有來回修正的機會;它同時要求模型自己已經具備那些說不出口的知識。

DeepScholar-Bench 要模型檢索、抽事實、驗證,還要把 precision 跟 recall 的取捨做到那個職業可以接受的程度。

同一個任務放在不同的尺上,讀數會很不一樣。研究合成任務在 METR 的尺上是 30 分鐘到 8 小時,現在的能力大約到 50 分鐘,但在那個長度上品質可能還是差的,成功率可能只有一半。所以 METR 的圖上好看,不代表經濟價值高。

到這裡,能確定跟不能確定的就分得出來了。能確定的是:隔離、規格明確的任務一直在進步;軟體工程跟 ML 研究是進步最明顯的兩個領域,一部分原因是我們自己比較懂這兩個領域,等於在自動化自己的工作;小時級的任務做得不錯;比較強的模型能生出組織很好的產出,即使不是每一部分都對。

信心較低的是:需要大量 context 的任務表現不好,prompt 一模糊就不知道要做什麼;對抗性的環境下表現也不特別好;要 95% 的可靠度還不到;軟體跟知識工作之外的泛化還沒真的看到;碰到知識庫,檢索、抽關鍵事實、再把抽出來的東西驗到高準確率跟高涵蓋率,都還是缺口。

剩下的長尾

課程最後把三條線收在一起。METR 說 50% 可靠度下的時間軸每七個月翻一倍,外推到 2028 到 2031 年,幾乎是一個月長的任務可以交給模型;GDPVal 的 win rate 是線性爬升,即使某些任務已經到 48%,還是有很多類別拿不到高 win rate,而且很多題目需要 context 或參考資料;DeepScholar-Bench 顯示的是檢索跟驗證的硬缺口。

講者自己的判斷偏保守:可靠度跟錯誤恢復會繼續改善,但表現會隨任務類型變動;horizon 變長不等於輸出可靠或高品質;所以尺不能只有一把,duration-based、economic-value-based、synthesis-quality-based 的指標都需要,而且都還要找人來驗。

長尾為什麼難,課堂最後也給了方向。SWE-bench Verified 在 coding 上很強,但還有一大類任務不是 PR 型的,這些會繼續難;有人形容前 80% 容易做,最後 20% 花了十年,分散式系統就是模型很難搞對的領域之一。至於卡在哪裡,講者的診斷是資料問題跟模型能力的混合:要做出有代表性的任務不容易,補上每個任務需要的模型能力也不容易。法律研究、財務研究這種大類採用得快,但很特定的領域就卡在資料量跟模型能力上;機器人跟 embodied AI 那邊,則有一批新創直接把資料收集當成主要假設在打。

至於兩年後會變成什麼樣子,講者說他手上的其中一項任務,最後會變成 AI scientist 在做的事:提出 hypothesis、跑實驗、把整個迴圈跑完。那是他們對 AGI 的定義,現在還不到。現階段模型比較像一個很強的 brainstorming 夥伴,一個 AI co-scientist。他也覺得可靠度的長尾會是最難啃的一段。

講者最後也把問題拉回學生身上:CS 這個專業不會消失,能想清楚 fundamentals 才是關鍵,因為 AI 再強都還是需要有人把 context 給它。

〈Stanford CS329A Self-Improving AI Agents〉-EP-Part 7 | Self-Improvement and Deep Research Agents

https://www.youtube.com/watch?v=Uni9dqyuuDM

模型的輸出裡本來就躺著解答,難的是把它挑出來。

Stanford CS329A 第七講把整堂課押在「搜尋」這兩個字上。講者開場先把前提講白:我們大致知道解答存在於模型輸出的搜尋空間裡,這堂課要處理的是怎麼從那個空間裡把答案挑出來。她示範了兩種很不一樣的搜尋。一種是把 sampling 開到極限,再靠 filtering 和 clustering 把候選收斂到交得出去的數量,這是 AlphaCode 與 AlphaCode 2 的路線。另一種是在推理過程中一邊發現知識缺口、一邊發查詢,把檢索到的文件讀懂之後抄成筆記放回思路,這是 Search-O1。課程安排上,作業二用的是 HumanEval 這類單函數題目,作業三才會真正走到 agentic search 這一套。

一百萬個解答,只交十個出去

AlphaCode 要解的不是補完一行程式,而是完整的競賽題。題目給你一段描述、一組輸入輸出,等於一份契約:餵進這組輸入,就該吐出那組輸出。寫 code completion 的 agent 是幫你把當下那行接完;這裡要的是從題目讀出意圖、想出演算法、生出整個區塊的程式,而且連「先看懂 docstring 才知道該用哪種解法」都算在內。講者說,模型一次吐一行建議,開發者接得很順,成功率也高;換成端到端解掉一道題,就是另一個量級的問題。

這篇論文發表在 2022 年,講者說這是將近四年前的工作。當時他們讓模型直接在真實比賽裡跑,賽中生成、賽中篩選、賽中提交,總共打了十場,每場大約五千名參賽者。平均成績是排進前 54.3%,前提是每題只交十個候選。講者補了一句,這個水準大致和過去半年在 Codeforces 上出賽的參賽者裡約 28% 的那群人相當。這也是第一次有人示範 AI 可以跨出狹窄任務、把一道題從頭解到尾。成績表上列著每場比賽的最好、估計與最差排名,而排名是把提交出去的解放到其他參賽者的解旁邊,比正確性,也比效率。

這條 pipeline 的前半段是自己養一顆模型。他們用 encoder-decoder 架構,先在 GitHub 上大約 700GB 的程式碼做預訓練,目標是 next token prediction,loss 走 masked language model 那一套。到了微調階段,他們加了幾個技巧,其中一個叫 GOLD:對高機率的 token 給比較高的權重,對低機率的 token 給比較低的權重,等於在 next token prediction 的 loss 上再疊一層跟 token 可能性有關的加權,目的是把精確度拉起來,讓機率集中在比較有意義的模式上。他們另外做了 value conditioning 與 prediction。

接著才是這條 pipeline 真正的主角:大規模 sampling。每一道題生成一百萬個程式,一半 Python、一半 C++;prompt 裡的題目標籤與 rating 會被打亂,sampling 溫度拉高,讓解法盡量分散。

一百萬個答案不可能全部交上去,所以中間多了一道手續:先篩選,再 clustering。篩選的條件很樸素,只留下能通過題目範例測資的程式。clustering 處理的是「寫法不同、語意等價」這件事,他們另外訓練了一個測試輸入生成模型,讓它看著題目描述去預測新的測試輸入,用這種方式把語意等價的解法歸在一起。做完這兩步,才有辦法從一百萬個樣本裡挑出一小批候選,送進 Codeforces 平台。講者說,如果一題只能交十個,你不會想交十個長得差不多的解法。

評估有兩條軌道。一條是 Codeforces 的正式比賽,交出去就跟人類參賽者一起排名;另一條是 CodeContests 這個訓練資料集裡留出來的測試集,離線就能量到訊號,不必每次都在真實賽事上跑。

課堂上有人指著成績表問,為什麼同一套系統在某些比賽排得很前面,換一場就掉好幾個百分點。講者沒有直接回答,先把問題丟回去,再自己收:一種可能是那些題目離訓練分布比較遠,模型本來就沒見過;另一種可能是選答案這一步在某些比賽特別不靈光。搜尋空間裡有正確解,不代表你有能力把它挑出來,選得不好,一樣拿不到分。

pass@k 量覆蓋率,10@k 量你有沒有本事挑

要讀懂 AlphaCode 的成績,得先把兩個指標分開。pass@k 問的是:讓模型生成 k 個樣本、全部送去隱藏測資評測,有幾成題目真的被解掉。它量的是搜尋空間的覆蓋率,也就是取樣這件事本身有多會撈。10@k 的那個十,是實際能交出去的提交數;你就算生了一百萬個樣本,也沒辦法把一百萬個都拿去對隱藏測資,中間一定要有篩選與評分的動作。所以 10@k 量的是 selection 這一端做得好不好,兩個指標擺在一起,瓶頸在哪裡就很清楚。

實驗把模型分成 9B、41B,以及 41B 加上 clustering 三組,在驗證集與測試集上從 10@1k 一路做到 10@10k、10@100k、10@1M。結果有三件事很穩定:模型越大分數越好,樣本越多分數越好,同樣的模型再加上 clustering,分數再往上墊一層。clustering 之所以有效,理由不是它讓模型更聰明,而是它讓你能在十個名額裡塞進十種不一樣的思路。競賽題如果交十份本質相同的解,等於只交了一份。

把取樣預算放到橫軸、解題率放到縱軸,會看到一條對數線性的關係:樣本每多一個數量級,解題率往上加一段;底模越強,斜率越漂亮。41B 那條曲線比底下那顆三億參數的模型陡,同樣的趨勢在 pass@k 上也看得到。講者特別點出一件事:如果只准交十份,曲線會提早壓平。pass@k 是不限提交次數的假想情境,可以爬到 40% 以上;換成 10@k,只剩 30% 左右。中間蒸發掉的那一段,就是選答案的能力還不夠,你被自己的 filtering 與 clustering 卡住。

這條對數線性是可以推導的,Azalia 在前面的課講過那篇推導;講者要強調的是,就算中間插進 selection 這一步,這條線還是維持對數線性。課堂上有人問,如果趨勢繼續,樣本數再往上加一個數量級,分數會不會直接翻倍,甚至值得當成專案題目。講者的回答很直接:把模型本身變強,比一直堆樣本容易。AlphaCode 2 就是從這條路走出來的,同樣一百萬個樣本,它可以拿到更好的成績,或者用一百個樣本就打平舊版本。她也補了一個容易被跳過的假設:往上加樣本的前提,是每一個新樣本都帶來新的多樣性;如果多生十倍,解法卻都長得一樣,分數不會動。還有一個更根本的限制,底模的能力本身有天花板,模型不夠強的時候,樣本再多也救不回來。課堂上也提到 saturation:模型越小時,要追到同樣的 pass@k,樣本數得開得越大,而加樣本的效益遲早會平掉。

loss 降下去,不代表解題率會上來

AlphaCode 這條路線的收穫,講者收在覆蓋率上:大規模 sampling 加上 filtering、clustering,確實可以把「正確解在不在樣本裡」這件事推到很高的水準。他們還回頭查了一件事,確認模型不是在抄訓練資料裡的解法。搜過之後,生成出來的程式帶有某種新意,所以這算是一種分布外的泛化,模型是真的在推理。

但訓練時盯著的 loss,對解題率來說是很差的代理指標,這顆模型在動態規劃與構造類演算法上就明顯偏弱。第二個代價是規模:每題一百萬個樣本,放在哪裡都不便宜。如果場景有時間限制,你需要的其實是一邊生成、一邊把可接受的解排出來,而不是等全部生完再挑。還有一件事跟難度有關:越難的題目需要越多樣本,而且這套一次到底的做法在難題上並不強;真正該走的方向是多步解法,讓難題拆成好幾步走得完的過程。

AlphaCode 2 換掉底模,也多了一顆會打分的模型

AlphaCode 2 的起手式是一個假設:為什麼要自己預訓練一顆模型,直接拿一顆現成的 LLM 來微調不行嗎。這篇在 Google 的工作挑了 Gemini Pro,做法是微調,而不只是在 prompt 裡把它帶進競賽題的世界。

取樣那邊的改動是把多樣性做到極致。他們養的不是一顆 AlphaCode 2,而是一家族模型:把 CodeContest V2 切成不同片段,配上不同的超參數、難度與題目標籤,各自微調出一個版本,再讓這些版本一起貢獻樣本。語言也收斂到只剩 C++,不像上一代是一半 Python、一半 C++;生成時把溫度與 metadata 都打亂,繼續逼多樣性。資料也換了,CodeContest V2 是開源的版本,問題與解的品質都更高。

真正的差別在選擇階段。第一代靠 clustering 這類啟發式規則,判斷哪些解法語意等價、哪些該留;第二代訓練了一顆 scoring model,講者直接把它叫作 reward model,讓它替每個候選估一個 0 到 1 之間的正確機率。這顆模型吃的不是拿來生成的那份資料,而是另一個品質更高、由人工標註與評分的資料集,學的其實是排序:同一道題,兩個解法擺在一起,哪一個該排在前面。

流程攤開就是:一百萬個樣本先全部拿去跑測試輸入,編譯不過或答案錯的直接丟掉,這一步砍掉大約 95%,剩下來的大約五萬個;接著聚成 cluster,只留下最大的十群;再用 scoring model 重新排序,每一群挑出分數最好的那一個代表。這十個代表,就是送出去的答案。

兩代擺在一起比:舊版要一百萬個樣本才有 25% 的解題率,新版在同樣一百萬個樣本上是 43%,接近兩倍;而且新版只要一百個樣本,就追平舊版一百萬個樣本的分數。對人類參賽者來說,整體落在第 85 百分位,大約是 Expert 到 Master 這個區間;如果只看它最好的兩個候選,可以勝過 99.5% 的參賽者。講者說,隔一年再推一次,只是換了一套系統,成績就走到這裡。

這裡真正留下來的一課是「用更少的樣本換到更好的成績」:底模更強、樣本更多樣、選擇更準,三個一起改才會有這個結果。代價也還在,實驗本身很貴,方法高度綁定程式這個領域,而且大部分算力花在生成那些根本編譯不過的樣本上。

九成五的樣本,死在編譯與基本測試那一關

95% 這個數字讓課堂上有人忍不住問,這樣不是貴到不合理嗎,有沒有更好的取樣方式,例如把 prompt 寫得更可靠,或改用別的做法。講者把問題丟回去,學生接了:作業一裡做過的 self-refinement 也許可以搬過來,先拿到一點回饋,再據此修正樣本,不必盲目生一百萬個。講者把兩條路分清楚:AlphaCode 這種做法比較像平行搜尋,生一大堆、靠 clustering 收斂;refinement 是在已經生出來的解上接回饋、把同一個解改好。問題是,在這個場景裡,回饋要從哪裡來。另一個可以砍成本的方向在訓練端:如果 RL 迴圈能讓模型本身更會解題,test-time 需要燒掉的算力就會少一些。

同一個問題也把討論帶到「這套系統到底要怎麼蓋」。講者把視角拉高一層:日常在用的 thinking model,背後其實也只有幾十個樣本;真正該問的是,你要怎麼蓋出那個能生出這幾十個樣本、還能把它們排隊評分的系統。用這個角度看,AlphaCode 2 已經很接近一個多模型系統:一邊是負責生成的家族,另一邊是負責評分的模型,中間靠 filtering、clustering 與評分把候選收斂到十個。如果把這樣一整套系統裡學到的東西蒸餾回單一模型,那顆模型就會變成大家熟悉的大型推理模型。講者把這個典範收成一句話:在 test-time compute 的世界裡,正確解應該存在於模型輸出的空間裡,所以你得有本事把它搜出來。自己重蓋一套系統的好處是,你手上的招比「當代模型剛好會什麼」多很多。

討論裡也順便解釋了為什麼 scoring model 不吃跟生成模型同一份資料。原因是汙染:評分模型不該看過完全一樣的題目,但它又必須看過同一個分布裡的東西,否則學不到怎麼排序。用不同階段、不同品質的資料集分頭微調,還得留意另一件事,後一個階段如果沒有把前一階段的資料混進來,模型會把前面學到的東西忘掉。

簡單題不必開到一百萬次取樣

講者丟了兩個問題給課堂:取樣策略該怎麼隨題目難度調整,以及推理要怎麼直接嵌進模型裡。

第一個問題的共識很清楚,難題才需要大規模取樣。有學生提議讓一個模型先把題目分成簡單、中等、困難,資料也帶著這些標籤,簡單題就從比較容易的池子裡多抓一點。講者把結論收在 sampling 這一側:如果題目簡單,模型本來就比較容易在搜尋空間裡撈到解,樣本數可以少一個量級,甚至靠幾輪迭代修正就能收斂,不必每次都開到一百萬。她也提醒,平行生大量樣本的目的,是逼出不同的解法路線,很少是在修同一個答案。

第二個問題把大家帶回訓練資料。有學生說,可以在資料裡加上提示,告訴模型這題用的是哪一類演算法;講者把它一般化成大家已經看過的東西。如果能把「寫程式之前先想一遍」的那段思考也放進訓練資料,那就是 chain of thought;如果反過來,先給模型答案,再要它把推理補出來,那是 STaR 那一類做法。遇到更複雜的題目,可以把它拆成子問題,為每個子問題加上提示,而不是要求模型一次解完。

有人追問,拆解之後如果第一步就錯了,後面不就跟著爛掉。講者的回答是,這正是為什麼最後一定要把迴圈關起來、而且要多步,最好還能像樹狀搜尋那樣,第一步先想幾個候選、確認大致正確,再往第二步走,走錯了還能回頭。這個方向還在早期。她也補了一個前提:任務拆解之所以行得通,是因為多數題目背後有共同的抽象模式;如果題目本身是分布外的,可能就得讓人留在迴圈裡,也就是前幾堂課談過的 AI scientist 那一類做法。

RAG 只在開頭檢索一次,複雜題目撐不住

課程後半段換到 deep research agent。Search-O1 的底層是大顆的推理模型,而推理模型有它天生的缺口:知識有 cutoff,昨天發生的事不在權重裡。講者說,還有一個更細微的症狀。推理模型遇到知識缺口的時候,不一定會停下來,而是會在推理鏈裡留下不確定性的字眼,例如 perhaps、alternatively,或是 wait。拿 GPQA 的推理鏈出來看,這種字出現的頻率很高。缺口不會自己消失,它會沿著整條推理鏈往下傳,把不確定性帶進最後的答案。

最直覺的補法是 RAG:把問題變成查詢,丟給搜尋工具,拿回一份文件塞進 prompt,再讓模型照著回答。講者用一個對比說明它為什麼不夠。如果問題只是問天氣,查一次就夠了;如果問題有好幾個部分,推理走到某一步才會發現需要新資訊,而你在一開始就把該查的查完,中間沒有再查的機會。RAG 相對直接推理當然有進步,但一進到 multi-step 的題目就會明顯吃虧。

讀懂文件再抄成筆記,才是 Search-O1 的重點

中間還有一種做法叫 agentic RAG。模型在推理過程裡遇到自己在意的實體,就插入特殊 token 觸發搜尋,檢索工具回來的文件直接插進推理鏈。這已經比開頭查一次好,但文件可以很長、又充滿雜訊,模型對長 context 的理解與推理就決定了上限;十份、二十份文件塞進去,它未必處理得來。

Search-O1 多做的是兩件事。第一個是讓模型一邊推理、一邊產生查詢,偵測到知識缺口就觸發一次搜尋,同一段推理裡可以來回好幾輪。第二個更要緊:拿到文件之後,它先讀過、判斷哪些段落跟當下的問題有關,抽出精華,再把這些筆記接回推理鏈。

講者用一題化學題走過三種做法。題目要算 product 3 的碳原子數,而 product 3 是一連串化學反應的產物。用一般推理模型,它看到不確定的名詞,就在腦內猜一個結構,然後照著猜出來的東西把答案算完,猜錯的話後面全部跟著錯。改成單純的 tool call 補文件,模型查完把文件塞進 prompt,一次塞進十份文件,資訊量超過它能好好推理的範圍,答案還是錯的,十個碳答成十四個。Search-O1 的做法是查完之後在文件裡推理,把真正相關的片段抓出來,再把整理過的資訊接回下一輪推理,答案就對了。

講者把這件事比成人類讀參考資料。你不需要把所有參考文獻都攤在桌上,你會做筆記,用自己的話把重點記下來,之後是這份筆記在幫你理解與綜合。Search-O1 裡負責讀文件的那個模組做的就是這件事:逐一檢查每份文件跟當前查詢、以及前面推理的關聯,抽出片段後附加到 prompt 上。它其實是在檢索工具內部又跑了另一個多步流程。

有人接著問,模型怎麼知道該搜什麼。講者把難點直接點出來:這才是整件事最難的地方。實務上你得先拆出問題裡的關鍵實體,針對那些實體去查,而不是把整段問題原封不動丟給搜尋工具;凡是你不打算信任權重裡那份知識的地方,就該交給 tool call。

課堂上有人問,如果前一段推理需要修正,這套機制怎麼處理。講者說這裡有個沒有寫得很明白的前提:系統裡得有一份狀態或記憶緩衝,記著目前要回答的查詢是什麼、前面推理走到哪裡。也有人問,能不能不改架構,直接在 prompt 裡叫模型把查到的東西做個總結再繼續推理。講者說這是好問題,建議在作業三直接試;她的保留意見是,這種做法等於假設模型對長 context 的理解與推理都很好,而這正是目前真正的限制,有一篇新工作叫 agentic context engineering 就在處理這件事。理想上當然希望模型能把長 context 吃得很乾淨,但那還不是現在。

文件越多,RAG 越差,Search-O1 反而越好

Search-O1 的成績攤開來看,橫軸是檢索回來的文件數量,縱軸是 pass@1,分成物理、化學、生物與整體四個面板。直接推理與 RAG 兩條線,文件變多,分數不會變好;Search-O1 的線會往上走,因為它會從每一份文件裡提煉相關資訊,文件越多,能抓到的線索越多。講者把這形容成另一條軸線:你可以靠迭代把同一個答案改好,也可以平行地多撈一些資料,再把資料削成塞得進 context 的大小。

在 GPQA 上,這條線畫出的是跟人類專家的距離。物理、化學、生物三欄都有專家的分數可以比;Search-O1 在物理與生物上已經很有競爭力,某些情況下甚至比人類專家高,化學明顯落後。講者提醒要看對角線,物理學家的分數要跟模型解物理題比,不能拿生物專家的分數去對。她也不忘踩剎車:這是「在這個等級的題目上有競爭力」,不是「已經超越人類專家」,化學還有很多空間。

有人提出一個假設:化學特別弱,會不會是因為摘要時很難保住化學意義,分子結構只要改一個地方,性質就整個變了。講者沒有下定論,只建議直接去 GPQA 上驗,並且補了另一個可能,每個科目的表現差異,也可能來自訓練資料本身不夠強,或題目落在分布外。

Multi-hop 問答是另一個戰場。這類題目要跨好幾份文件才能拼出答案,標準 RAG 做到某個水準就飽和,加上 agentic 的做法也會撞到天花板;在 HotpotQA 這類題庫上,表上被標成粗體的最好成績大多來自 Search-O1。講者也把進步歸給兩件事:不確定性下降,以及文件的品質與被提煉過的程度上升。多輪下來,模型能認出自己哪裡還不知道,再針對那裡補查,推理品質就上來了。她還給了一個可觀察的指標:推理鏈裡那些表達不確定的字,perhaps、wait、likely,數量在 Search-O1 的做法下大幅下降。

課堂上有人問檢索本身的 precision 與 recall。講者把責任歸屬講清楚:有可能真的沒檢索到對的文件,但這篇論文的主張是另一件事。即使找回來的只是好幾份「大致相關」的文件,一次全部塞進 context,等於要求模型同時對這麼多文件做推理,這才是它撐不住的地方。

最後一個沒解完的:模型不知道自己不知道

課程結束前,講者提到一篇沒時間講的 Search-R1,把它跟 Search-O1 放在一起對照:Search-O1 是用 prompting 的方式把迴圈關起來,Search-R1 則是用 RL 迴圈直接教模型怎麼去搜尋。差別在方法,不在目標。她請大家自己去找那篇論文看。

最後一個提問回到語言模型最根本的地方:模型輸出答案的時候,理論上帶著機率,這些機率跟答案對不對有沒有關係。講者先處理這個問題。把輸出 token 的 log probability 拿出來聚合,不能只是加總,起碼要做平均或幾何平均之類的處理;做出來會看到模型普遍過度自信。校正過去看,如果它只有五成把握是對的,它還是會表現得像有八成把握。這也解釋了為什麼你試著糾正模型,它有時候會很強硬地說是自己對,不太肯改。

沿著這條線,研究上有人在試的是讓模型用第二次 pass 估自己的信心,或直接用 RL、RLHF 把校正調好,讓它在沒把握的時候不要硬吐答案。不同模型的行為不一樣,外界看不到實驗室裡怎麼調,最後只剩下「這個模型在幻覺」這種籠統的說法。至於機率與正確性的相關性,講者的觀察是,答案是對的時候,模型大致會答對;答案不對的時候,它反而可能很篤定自己知道。幻覺與「模型知不知道自己在說什麼」,在她口中是一個還很活躍的研究領域,也是一個很適合拿來當專題的題目。

這堂課停在這裡:搜尋空間裡有解,選解的系統可以蓋得比模型本身更聰明,但模型對自己的無知,仍然沒有可靠的感覺。

〈Stanford CS329A Self-Improving AI Agents〉-EP-Part 6 | Train Time Scaling/Scaling RL

https://www.youtube.com/watch?v=yVnmHSAy3ck

訓練階段的算力,可以換到參數量換不到的東西。CS329A 第六講要講的就是這句話:把生成、驗證、過濾、微調接成一圈,讓模型從自己的輸出學,一顆 7B 模型在 AIME 這種競賽數學上,就能把 GPT-3.5 的五%推進到五十%以上。但這條迴圈有兩個硬條件,題目要落在模型搆得到的地方,領域要驗得動;而真正讓多數人卡住的不是想法,是 RL 的實作細節,熵、回應長度、reward 的分布,每一格沒調好,模型不是不學,是整條訓練崩掉。前幾堂課談的是推論端的算力、工具與程式回饋、強健的驗證,這一講要把迴圈關起來,用三篇論文把路走一遍:STaR、DeepSeekMath,跟把 GRPO 細節補齊的 DAPO。

AIME 那張表:小模型把大模型的位置佔走

課一開始,講者先換掉尺。前幾堂課用的 MATH 對現在的多數模型來說已經飽和,多數模型也都在上面訓練過,於是改用 AIME 2024 跟 AIME 2025;作業一用的也是這種近期的數學推理題。

同一張 AIME 上,175B 的 GPT-3.5 一般相信大約拿 5%。DeepSeekMath 用 train-time scaling,7B 拿到 51.7%,再加上一些額外的技巧可以到 60%。講者開場時把第三篇的方法講成 DPO,說套在 Qwen-32B 上可以拿到 50%。第一講談 scaling 時,故事是參數變多、能力變強;這裡要講的是另一根槓桿,而且它讓小模型跑到大模型的位置上。

三種訓練範式先分清楚。pretraining 是在網路資料上訓練,課程第一講處理過;fine-tuning 跟 RLHF 是用人類的偏好資料,把 base model 變成助理;test-time scaling 是前幾堂課的重點,多數投票、推論階段多取樣幾次、把多個輸出合起來,或評估模型輸出裡的錯誤再拿來改進。train-time scaling 就是再往前一步:把 test-time 生出來的東西濾過之後,拿回去做進一步的微調。講者說,這堂課如果只帶走一件事,就記這個圈。

為什麼這個圈值得記?因為過去的模型只從網路上的資料學,現在讓它從自己的輸出學,濾得聰明一點,就能再往上推。花在「訓練自己的輸出」上的算力,可以替代模型參數;這跟早期用小模型加大量資料換分數的路子平行。還有一個前提要先講白:直接用 RL 做推理通常行不通,多數時候不是方法錯,是實作細節很難做對,而演算法放大之後,那些小修正會變得極度關鍵。

把 test-time 的輸出接回訓練,前提是這個領域驗得動

課堂上一開始就有人問,train-time 跟 test-time 的算力該怎麼分,有沒有報酬率開始變平的那一點。講者把問題留到第三篇再答。

先看 o1 的兩張圖。縱軸是 AIME 的 pass@1,左圖橫軸是 train-time compute,右圖橫軸是 test-time compute。推論端的算力加上去,pass@1 跟著上去,這是對數線性的關係,前幾堂課已經看過;o1 這張圖多說的是,訓練端的算力加上去,pass@1 也會上去。兩條軸一起加,分數再往上,於是就有了一個可以繞的圈:模型先生出輸出,輸出回饋回去,模型在這張榜上再往上走。

這個圈為什麼在數學上轉得動?因為數學有 verifiability。前面有一整堂課在談強健的驗證,重點就是你有能力分辨哪些輸出是對的、哪些不是,才有辦法把對的那些挑出來餵進 train-time scaling。換到驗不動的領域,這條路就先斷一半。

講者把兩邊的性質對照著講。test-time compute 對使用者的門檻很低,模型訓練好了,多做幾次推論,只要其中有一個答案是對的,而你手上有一個好的 verifier,搜尋幾乎可以無限放大;下一週要講的 AlphaCode 就是這個方向的極端版本,只要搜尋能一直做下去,理論上一定找得到正確解,因為重複取樣本來就會把正確解採出來。train-time scaling 的挑戰不一樣,是你要把它 scale 對,而且這個封閉迴圈裡要有足夠的成功案例,它才轉得動。

台上也有人對那張圖有意見,覺得 test-time 看起來比較划算、有點可疑。講者的回應很直接:那張圖只是某一個時間點的其中一種切法,不同研究不一定有直覺上的優劣,而且「他們的圖不一定都對」。回到基本面,test-time 好用,前提是那個領域的驗證夠強;驗證不夠強的時候,你還是得讓模型自己變強,兩個方向各有各的用處。她給了一個很具體的說法,test-time 像是把義大利麵往牆上丟,而你剛好知道它該黏在哪裡;train-time 是直接教模型,把 pass@1 拉高,讓它更常自己吐出正確答案,但這一圈還是需要驗證。

思考模型在想什麼:分析、拆解、回頭、換路

推理為什麼有幫助,講者用現在這批 thinking model 走了一遍。o 系列、Gemini Flash Thinking,以及其他前沿實驗室的對應版本,解法都是讓模型在給答案之前,先花一段 token 把推理寫出來。這些 token 通常用在四種動作上。

problem analysis,先弄清楚題目在描述什麼。task decomposition,把任務拆成子任務。self-evaluation,回頭看自己剛剛的答案,覺得不對。backtracking,認出錯誤之後退到前面的步驟重做,甚至同時試幾條不同的路,像是一種平行的搜尋。講者強調最後這件事要有意義,模型本身得對「這是不是正確解」有一點感覺。

她拿了幾個 o1 早期版本的例子。一個是請模型寫 Bash 腳本,把某一種格式的字串做轉置再印回來。模型的輸出裡,第一步不是開始解題,而是先確認使用者要的輸入跟輸出格式是什麼,這是 problem analysis。同一個題目換一個片段,模型把解法拆成解析輸入字串、建矩陣、轉置、再照原格式輸出,這是 task decomposition;講者自己說,對這題來講有點殺雞用牛刀,但題目一複雜,這種拆法就值得。第三個例子是化學題,要算某個溶液的 pH,模型算到一半突然發現正確的公式不是它正在用的那一個,於是回頭改公式;就算知識本來就在模型裡,這個自我修正的動作還是真的發生了。

這些能力換到分數上是什麼樣子?在程式、資料分析、數學計算這類有驗證機制的領域,thinking model 對上不是 thinking model 的 GPT-4o,勝率超過 50%。換到個人寫作、編輯文字,勝率的進步就小得多。講者把這個對比收在同一句話上:能驗證、能把圈關起來的領域,進步快得多。

講者也順手回答了一個大家會擔心的問題:為了難題去微調,會不會把簡單題弄壞?通常不會,除非推理鏈整條壞掉、開始重複繞圈,那就是 overthinking。這個答案在後面的 RL 段落裡會再回來一次,因為它其實是 reward 分布跟 KL 的問題。

STaR:生成、驗證、過濾、微調

要教模型推理,第一件事是缺資料。網路規模的語料裡,多數內容沒有推理步驟,有大量推理步驟的來源很少;要人工標,成本高到不現實;想用已知的解題模式自動生成推理,只在一小撮特定領域可行;只給幾個範例做 few-shot prompting,也打不贏直接拿大量資料微調的模型。講者的結論很直白:少量的推理範例不夠用,而沒有推理鏈的大資料集反而還行。

STaR 的切入點很簡單。先準備一小批有推理步驟的範例,用它們去生成解法,例如在一萬題上跑一輪,一萬只是一個代表性數字;接著只留下答案是對的那些,這些題目帶著推理鏈,可以拿去做微調;然後把整個流程再跑一次。跟 test-time scaling 的差別就在那個「只留對的」。

為什麼不能只留對的就好?因為模型卡住的那些題目,如果直接丟掉,模型就學不到怎麼解新題,訊號等於零。STaR 對這些失敗題多了一個動作:把正確答案當提示給模型,要它把推理倒著補出來。講者用的例子是答案 42,人類把答案講出來,模型開始生推理;生出來的推理,加上題目跟答案,一起進訓練資料。關鍵在最後一步:微調的時候不要把提示一起給模型,要讓它看起來像是模型自己直接解出來的。這樣訓練集就能往更難的題目擴,推理能力可以一圈一圈往上墊,而不是卡在模型原本就解得動的那些題。

把 STaR 攤成演算法,就是生成推理、從成功的路徑學習、失敗的用提示去 rationalize、把生成的推理當訓練資料。講者把它形容成很 bare bones 的做法,甚至說它幾乎可以算是一種 off-policy 的 RL。

這套做法站在三個假設上。最終答案正確與否,可以當成推理品質的代理,他們在數學上發現大致成立,所以濾掉錯答案就等於濾掉低品質的推理鏈;代價是模型也一併失去了從錯誤推理鏈學習的機會。第二個假設是,模型被給答案當提示之後,生得出有效的推理路徑。第三個是,一開始的語言模型要強到能從少數範例 bootstrap 起來;如果題目類型離它太遠,這一圈推不動,這也是為什麼要反覆迭代。

6B 的 GPT-J:樣本效率亮燈,GSM8K 上熄火

STaR 的實驗用一顆 6B 的開源模型 GPT-J。訓練上有幾個安排:先做一小段 warm-up,學習率之後固定在常數,外圈跑固定的迭代次數,內圈的步數一輪一輪加上去;他們刻意讓訓練前期慢一點,再慢慢把每一輪內部的工作量拉高。

資料用四種。GSM8K 是大家熟悉的國小數學題,大約九千筆;Common Sense QA 是日常常識的選擇題,有推理可寫;還有多位數加法的算術題;最後一種是他們自己生成的合成資料。

幾組結果值得記。對比直接用數學資料做 supervised fine-tuning,STaR 這條路可以把成績往上推,而且只用了 70 到 87% 的資料,等於有一批沒有正確解的樣本被整批丟掉。另一個限制是它並不是真的 RL,跑多輪之後會開始平掉;講者說 RL 本身有它的難處,但這裡同樣會飽和,迭代次數要抓,還要一些調校。

Common Sense QA 上有一個比較人性的檢查。他們把 STaR 生出來的推理拿給真人看,跟 prompt 資料集裡原本的 few-shot 推理擺在一起,問人比較偏好哪一種,結果是 STaR 的推理大致說得通。同一條線上還有樣本效率:用 rationalization,資料只用了 86%,就達到 72.5% 的準確率,對比之下要達到同樣水準,一般微調得吃下更多資料。講者說這是一顆很小的模型,但這是推理這條路第一次看到有生命跡象。

到了 GSM8K 的數學推理,rationalization 反而沒什麼用。GPT-J 對 baseline 有進步,但幅度不大;直接拿好資料做微調,也能拿到類似的提升。講者給的理由是題目太簡單:模型被要求用 chain of thought 時,實際用掉的計算步數,跟給它 rationalization 提示時差不多,多這一步沒有多換到什麼。GSM8K 對當時的 GPT-4o 已經在能力範圍內,對 GPT-J 也是。即使如此,直接微調跟 STaR 加 rationalization 相比,後者還是有一點收穫。

終點對不等於每一步都對:STaR 的破口與兩個後繼

課堂上有人追問,給提示生出來的那條推理鏈,品質要不要檢查?講者說這篇沒有在 rationalization 那一步做過濾,後續的論文才開始補,例如在上面加一個 process reward model,逐步判斷哪一步說得通。她也把這個缺口直接變成專題題目:如果你不想只靠最後答案當正確性的代理,該怎麼評估推理鏈的品質?

下一個問題更根本:資料裡的答案是誰保證的?這篇的起點本來就是一個有正確答案的 benchmark,訓練集跟測試集都從那裡切出來,正確與否不是模型自己說了算。

還有人問,錯的推理鏈能不能直接當負面教材來學。講者的回答是,這件事到現在都還沒做好。目前能轉動迴圈的前提,是有非零的 reward;現在的做法大多是「對的就留下、錯的就濾掉」,從失敗中學習只有少數論文在試,不是這堂課要處理的範圍。

提示怎麼寫,也不是中性的。few-shot 的範例長什麼樣,模型就照著長,最後訓練資料也長成那樣;這一塊需要 prompt engineering,而它會把模型往某個方向偏。講者把 rationalization 的邏輯收成一句:它是條件在「你已經有答案」這件事上,有了答案,模型才比較有機會把好的推理生出來;沒有答案的時候,它可能很有自信地生出一條錯的。至於推理鏈的品質本身,多數任務根本沒有現成的評估方式,要嘛找人看,要嘛訓練一個 process reward model;而只靠最終答案過濾,中間可能藏著無效的步驟,真的陰性跟偽陽性都會出現。

課堂上最後把問題推到更根本的地方:STaR 的天花板在哪?討論收在幾件事上。它不會做出訓練資料裡沒有的邏輯跳躍,不會自己長進新領域;如果模型連提示都給了還是想不出來,rationalization 也生不出東西,錯誤樣本累積下去只會更糟。講者說這些答案都對,但真正的重點是 base model 本身能做什麼,這一整條線的魔法大多是在那個基礎上長出來的。

也有人問,這種方法對前沿模型有用嗎,為什麼不直接用更強的模型生資料來蒸餾小的就好。講者沒有正面反駁,只把課程的立場講清楚:這幾篇是在示範從零開始能怎麼做,讓大家理解這條路要付出什麼;實務上你當然可以拿前沿模型的輸出來用,那是蒸餾,另外一條路。後面兩篇延伸也順帶提了。V-STaR 是在迴圈裡多加一個 verifier,generator 跟 verifier 一起訓練;Quiet-STaR 把推理步驟從語言空間搬到 latent space,用 MLP 來做。講者的說法是,既然要讓模型在內部想,何必一定要用英文想。

DeepSeekMath:先養能力,再開 RL

第二篇換到數學推理,用的是它自己提出、後來變得很有名的 RL 方法。

它看的 benchmark 是比 AIME 簡單、也更早的 MATH。隨著模型變大,這張榜的分數本來就在往上;DeepSeekMath 出來的時候,一顆 7B 的模型突然跑到很前面。講者說,主要的躍進是他們把 train-time scaling 迴圈裡 RL 那一段做對了。

做對的第一件事,發生在 RL 之前。更早的 Minerva 是在 PaLM 上堆大量的科學與數學資料,來源多半是 arXiv 論文。DeepSeek 的判斷是,訓練在 arXiv 論文上不是關鍵;他們改用 Common Crawl 的網頁,而且起點是一顆已經在程式上練過的 DeepSeek-Coder。理由很直接:從一個程式推理已經被強化過的模型出發,數學也會跟著好。他們把 Common Crawl 裡的數學內容認真篩過,做成 OpenWebMath 這類語料,覆蓋的數學領域更廣,能挖出的 token 也多得多。講者把這一步叫做 RL 之前的 priming:如果模型在某個領域本來就弱,你得先把它的能力養起來。這也是第一次有人把「從程式起家」對數學與工具使用的幫助講清楚;他們也發現,只練 arXiv 並沒有同樣的效果。

能力養起來之後,才是先把數學資料做 supervised fine-tuning,再把 RL 放大。

GRPO:拿掉 critic,用同一題的一組答案當基準

RLHF 時代最常見的演算法是 PPO,即使已經有 verifier 也一樣。PPO 的記憶體問題出在它要同時養好幾份模型:舊的 policy、正在學的新 policy、提供回饋的 critic,還有指派 reward 的 reward model,四份一起放在那裡。7B 還撐得住,想放大就很吃力。

DeepSeekMath 提出的 GRPO 把 critic 拿掉,改成用「同一題的一組答案」當基準,模型份數從四份降到三份。做法是每一題取樣多個答案,用 reward model 打分,再把分數正規化:reward 減掉這組的平均,再除以標準差,得到的值就當作 advantage。講者說,這其實跟 DPO 那一類方法在做的事一樣,都是拿 reward 互相比較;而 reward model 本來就是用比較的方式訓練出來的,所以這種正規化放在 GRPO 的脈絡裡很合理,記憶體也省下來,RL 才有辦法往大規模走。

她沒有把完整的公式寫上黑板,只要大家記住那個直覺:reward 減平均、除以離散程度,就是 advantage 的估計。效果是 7B 在數學上從 46.8 走到 51.7,也是第一個不靠 critic、在 7B 規模跨過五十%的開源模型。

後面這一層是講者認為最值得帶走的觀念。不同的 RL 變體,差別通常只在兩件事上:資料從哪裡來,以及梯度怎麼算。梯度取決於一個梯度係數,還有一個「給定題目時輸出這個答案的機率」;係數怎麼算,各種演算法就不一樣。GRPO 的係數來自這個 group baseline,它對「單一題、只求一個答案」的任務很合適。把幾個方法擺在一起看更清楚:STaR 是生成一次,答對就是 reward 1,答錯就是 0;online rejection fine-tuning 也是邊生成邊篩,錯的就丟掉;GRPO 則是每一題生一組、每一組都打分,advantage 來自組內的平均與離散程度。

reward 沒有分布,模型就沒有東西可以爬

課堂上有人把擔心講出來:為了難題去更新全部權重,會不會把其他題目跟其他 benchmark 弄壞?講者用 reward 的分布回答。如果題目簡單到模型每次都對,reward 永遠是 1,不會有 0;分數沒有分布,正規化就沒有意義,模型也就沒有東西可以學。反過來,如果整批題目都太難,reward 到處都是 0,模型同樣找不到施力點。她要的是一批有訊號的題目,reward 在裡面有分布,模型才有東西可以爬。

KL divergence 是另一個方向的安全帶。有人指出,這件事在原始論文裡的解法就是加上 KL 項:如果模型已經會解的題目被過度最佳化,能力會回退,KL 可以把 policy 拉住,不要偏離它原本就會的東西太遠。講者接受這個補充,並把它跟自己的說法並置:一邊是選題要有好的分布,讓模型有爬坡的訊號,一邊是 KL 讓它不要跑遠。她還補了第三條路:不一定要更新全部權重,後來有一些工作跟 blog 用 LoRA 這類局部更新,也能在加入新能力的同時,把原本的表現留在原地。

reward 從哪裡來也順便被問了一次。如果 reward 只有 0 跟 1,能不能用?可以,但那只是代理,你可以對多個樣本取平均,讓它變平滑;要真的連續分數,就是訓練一個 reward model 來打分。同一段討論裡,講者也講了 DeepSeekMath 這邊一個容易被忽略的結果:這個線上 RL 迴圈主要拉起來的是 majority@k,不是 pass@k;同一題取樣 32 次,變好的是多數答案變一致,而不是模型突然能解開以前解不開的題。講者的評語是,模型變得更一致,不是真的變聰明。

DAPO:在 Qwen-32B 上把 30 調到 50

第三篇處理的是更難的題目、更長的推理鏈。把 GRPO 直接放大到很好取得的 Qwen-32B 上跑 AIME,只有 30%,而且會出現幾個典型症狀:模型的熵崩掉、變得太有自信、訓練不穩,回應長度還會失控地長。同一個榜上,DeepSeek-R1 那篇拿到 47%。DAPO 的工作就是把 GRPO 沒講清楚的細節攤開,一個一個補。第一個動作很單純:overlong filtering,把過長的回應濾掉,光這一步就把 30% 推到 36%。

再來是不對稱的 PPO 裁切。標準的 PPO clipping 把「往上加」跟「往下減」用同一把尺;低機率的 token 想被拉上來只能拉一點點,高機率的 token 一樣會被裁,探索空間就塌掉了。DAPO 讓裁切變成不對稱,允許比較大的上修。圖上的差別很明顯:做了不對稱裁切,準確率比較高,右邊的熵也維持住,沒有崩;沒做的話,熵直接崩掉。講者提醒,熵在這裡是「模型還剩多少探索空間」的代理指標。

第二個是 dynamic sampling。GRPO 是取樣 64 個答案,算出分布,用組平均當基準;DAPO 改成超額取樣,然後把「全對」跟「全錯」的組濾掉,只留下中間有訊號的那些。理由是不想浪費梯度:reward 全對或全錯,advantage 就是零,那些組本來就沒東西可傳;濾掉之後,真正有貢獻的組維持住有效的 batch size。課堂上有人問 64 這個數字是不是太小,講者的回答是這只是一個示範值,實際要取多少,取決於 benchmark 的難度跟 base model 的能力。

第三個是 loss 要下在 token 還是樣本上。如果 loss 是 sample-level,一題一個分數,那一大段又長又爛的回答,跟一句又短又好的回答會拿到一樣的權重;DAPO 改成 token-level,並加上跟長度有關的形狀調整。他們同時盯著熵跟平均回應長度:不做這件事的時候,熵會往上長,回應長度也會失控,做下去才把兩個都壓住。

第四個是 soft overlong punishment。模型碰到難題會一直想,最後被截斷,這種被截斷的推理鏈會帶進很多雜訊;DAPO 在 token 上放一個漸進的懲罰,讓訓練穩定下來,而不是把噪音吃進去。講者補充,其他論文對同一件事有別的做法,例如直接在 RL 迴圈裡把 context length 拉長,DAPO 選的是懲罰函數。

把這些加起來,Qwen-32B 在 AIME 上的分數是這樣走的:GRPO 30%、加 overlong filtering 36%、加不對稱裁切 38%、加 soft overlong punishment 41%、加 token-level loss 42%、最後加 dynamic sampling 到 50%。50% 這個數字已經超過把 DeepSeek-R1 蒸餾到 Qwen-32B 的結果;也就是說,他們是直接在 Qwen-32B 上爬坡,爬出一顆很強的模型。

loss 之外的儀表板:熵、回應長度、飽和

DAPO 這篇留下來的原則,講者覺得比技巧本身更重要:在 RL 裡,loss 本身不足以當進步的代理。要一起看三件事。回應長度有沒有失控;熵是不是落在中間,不要太低也不要太高;以及整批樣本裡「全對」的比例有多高,那個比例決定你還需要取樣多少。

症狀對應的處理也很具體。回應長度爆掉,就要去控制 loss;熵要盯住;跑了一段步數還看不到進步,reward model 很可能已經飽和。講者的結論是,RL 的外圈最佳化本身比 supervised learning 難,這也是為什麼 SFT 跟 RL 的選擇不是純粹的資料量問題:SFT 在手上有一堆高品質資料時更快、更直接,但它不會把推理鏈這種能力帶起來;RL 在 reward 訊號夠強的領域可以用少得多的範例爬坡,代價是真的很難調穩。

三套方法什麼時候用哪一套

課的最後,講者把三篇併成一張選擇表。

手上只有幾百個帶推理的範例、也還沒有 RL 基礎設施,STaR 是合理的起點;在 GSM8K 這類簡單推理題上能看到進步,幅度不算驚人,但至少還留在模型能力範圍內。如果你有一顆夠好的 base model,也願意先用好的 instruction 資料把它養過一遍,GRPO 是一個就算記憶體不夠、GPU 數量有限也能跑的演算法,在標準數學推理題上已經被證明有效。推理鏈會拉得很長、題目難到需要 state-of-the-art,才需要 DAPO 這一層:把 RL 演算法跟基礎設施裡的每一個變數都控制住,這對 AMC、IMO 這種競賽級題目很有用。

三套都會改善的東西也要講清楚:算力加上去,majority@k 會變好;答案的格式通常會變整齊;模型在多步之間會更連貫。但三套都還沒有動到最底層的那件事,沒有教會模型解全新的問題,也沒有讓它大幅跨出原本的領域。講者說,pass@k 要動,等於要模型的基本能力跳一階,而歷史上這種跳階通常來自某種突破,或某個維度上的規模化,不是迴圈多跑幾輪就會發生。

回到課堂一開始那個「算力該分給哪一邊」的問題,講者整場給的答案不是一個比例,而是兩個前提:驗證夠不夠強,以及迴圈裡有沒有足夠的成功案例。還有一個跨三篇的前提要一直記著,推理品質、整條 RL 迴圈,全都取決於模型本身有多會想,以及有沒有一個 verifier 或 reward model 在旁邊。reward model 太弱,模型爬不動;模型太強,reward 會被 hack 掉。這也是為什麼上一堂課談的程式應用特別好做,因為那裡有真的可驗證的 reward:數學跟程式有最終的正確答案,再加上執行回饋跟 unit test。問題是,這種地方有多少?以及,一個 verifier 不夠的時候,能不能用一整組 verifier 互相補位?講者提到課上已經看過的 Weaver,就是這個方向。

還沒解完的:pass@k 不動、失敗學不會、reward 會飽和

講者收在一串還沒解的問題上,也承認 train-time scaling 現在還是很活躍的研究區。

第一個是那個怪現象:為什麼線上 RL 會把 majority@k 拉起來,pass@k 卻不動?第二個是那些看起來很聰明的行為,backtracking、自我評估、自我修正,到底是模型真的長出了新行為,還是這些模式本來就在,只是變得更常見?第三個是失敗的資料。現在多半的做法是直接把錯的濾掉,只有少數論文試著從失敗裡學到東西;怎麼用失敗的推理鏈又不讓訓練崩掉,還沒有好答案。

她點的三個可能方向也很清楚:資料面,怎麼生成更好的訓練資料;演算法面,怎麼讓 RL 對 reward model 的雜訊更有韌性、該用什麼樣的 reward;以及把 STaR 的 rationalization 跟 DPO 那一類方法接起來。

最後有人問到前沿實驗室現在的配方。RL 佔整個訓練的比例,去年大概在 99 比 1 那種量級,最近長到可能 5% 左右;Grok 4 對外說自己用了 50% 的 RL,但講者說那個比例並沒有換到預期的大跳躍,因為瓶頸在別的地方:reward 不夠強,或 reward 裡有雜訊。課堂上另一個人問到 AMC、USAMO 這種題庫很小、又要小心資料洩漏的競賽資料,沒有足夠資料怎麼確保驗證訊號。講者的回答把問題換了一個問法:不是「資料夠不夠多」,而是「手上的資料夠不夠讓模型爬坡」,會不會在 dynamic sampling 的時候把有訊號的組整批濾掉。RL 本身資料效率高,要的資料量沒有那麼大;驗證訊號則是另一件事,verifier 可以用一整組來補,而不是只能靠一個。

〈Stanford CS329A Self-Improving AI Agents〉-EP-Part 5 | Planning and Multi-Step Reasoning

https://www.youtube.com/watch?v=Ml_fp9XkB8Y

規劃不是把計畫一次寫完就算了。多步任務真正的難點有三個:走過的步驟能不能拿回來搜尋、彼此不相干的步驟能不能並起來跑、工具的使用能不能在沒碰過工具的情況下學會,而這就是 CS329A 第五講排出來的三篇論文。去年 ICML 的 LATS,把 MCTS 搬進語言模型的推理路徑,用 test-time compute 換準確率;NeurIPS 2025 的 Sprint,把可以並行的計畫從序列生成裡切出來,要的是省延遲;下週要在 COLM 報告的 SWIRL,把工具呼叫留在離線標註階段,用每一步的 reward 訓練多步行為。講者收尾時把三套併起來看:它們不互斥,是一組可以拼裝的工具箱,而且每一套都留了接口給後面的人接。

規劃不是把計畫寫出來就結束

講者用一個度假規劃的 prompt 說明多步任務的形狀。推理的那一步,模型要想清楚這件事要做什麼:預算是多少、行程怎麼排。動作的那一步,是它真的去蒐集資訊:開瀏覽器、生一個搜尋 query、去讀 Reddit 或旅遊部落格。再下一步是搜尋與修正:拿到線上蒐集來的回饋之後,回頭改目前為止的計畫,也許換一個目的地,也許查當地還有什麼新東西可做。想、做、搜尋三個動作輪流出現,才把「幫我排一趟旅行」這種題目解完。

LATS 要處理的正是這個縫隙。講者的說法是,當時的目標是把「LLM 生一份計畫然後照著執行」推進到「鼓勵模型探索多種不同的計畫與路徑」。模型到今天為止都還是這樣:生出多樣解、照著行動、為了解一個問題規劃好幾層最佳化,這些都是弱項。這篇的做法是把 RL 跟多步規劃裡已經存在的技術搬進來,包括多步的 Monte Carlo tree search;再加上一個當時比較新的條件,模型有能力把回饋吃進來,所以它可以一邊跟環境互動,一邊把環境給的東西帶回搜尋過程,用來修正跟最佳化之後的計畫。

LATS 跟 ReAct 差在拿什麼當分數

論文標題講得很白:Language Agent Tree Search 把推理、行動、規劃收在語言模型裡。講者用「規劃一趟夏威夷旅行」走了一遍。同一個 prompt 取樣幾次,模型可能決定去問去過 Hawaii 的朋友,或是去讀相關的 subreddit;框架會替每一個動作算出一個分數,再用分數去更新這棵樹接下來要往哪裡長。動作一分數比較高,就從它展開,於是模型去問朋友 A 跟朋友 B 的意見,兩個回應的品質各給一個分數,再從那裡繼續長。這是多動作取樣的流程,不同分支的動作可以真的並行執行。

樹上同時要考慮探索跟利用。一直往當下分數最好的狀態走,可能會錯過現在看起來普通、但走下去更好的節點,這就是 MCTS 進場的地方。

跟 ReAct 的差別,講者特別點出來,在「分數是對什麼打的」。ReAct 先用一個 verifier 在 test time 引導搜尋,被評分的是推理軌跡,展開的方向由那個分數決定。LATS 不評推理痕跡,它評模型採取行動之後的結果,再把模型對這條軌跡的 reflection、以及環境給的觀察一起算進去。整個直覺可以拆成三塊:chain of thought 把推理拆成一步一步;tree expansion 透過動作生成讓步驟分岔;規劃與搜尋就在這棵樹上跑。從 ReAct 借來的是第四塊,動作得到的回饋會回流到之後的搜尋裡。

迷宮那一題,六個階段走一遍

LATS 的流程有六個階段:selection、expansion、evaluation、simulation、backpropagation、reflection。講者用一道「走出迷宮」的題目把它走完。初始觀察是你在一間燈光昏暗的房間裡,左邊一扇門、右邊一扇門,目標是找到出口。

selection 要先挑一個節點來展開,挑選的依據是 UCT。選好節點之後是 expansion,從這個節點取樣可以採取的動作。這個例子取了三個:打開左邊的門、打開右邊的門、檢查房間有沒有線索。三個動作都在環境裡執行過,觀察結果接回 context。打開左門得到的觀察是一條掛著畫的昏暗走廊,開右門是另一個觀察,第三個動作也有自己的結果。

接著是 evaluation。每一個「動作加觀察」形成的新狀態都要給一個分數,他們把兩個分數合起來。一個是 LM-as-judge:把動作跟觀察丟給語言模型,問它這個狀態多有希望,直接要一個 0 到 1 的分數。另一個是 self-consistency:假設這裡不是取樣三個動作,而是取樣五十次,把動作歸類,某一類出現得越頻繁,分數越高。講者舉的例子裡,狀態 A 的 self-consistency 分數比較高,因為動作 A 有 75% 的取樣都出現。兩個分數合起來,每個狀態就有了一個值。

simulation 用的是貪婪法。狀態 SA 分數最高,SB、SC 低很多,所以就從 SA 一路展開下去:再取樣、再展開,直到成功、失敗,或是把展開的預算用完。這場走訪裡,SA 底下的候選動作選了往樓梯走,運氣很好,觀察裡就看到出口標示得清清楚楚。到此 simulation 結束,這條軌跡不是成功就是失敗。

真正重要的是這條軌跡怎麼回寫。backpropagation 拿整條軌跡的回報去更新沿途每個狀態的價值,算法是一個移動平均:新價值等於舊價值乘上造訪次數減一,加上這條軌跡的回報,再除以造訪次數。講者也把 UCT 的算式拆開,它就是一個利用項加上一個超參數乘上探索項;NP 是父節點被造訪的次數,NS 是當前這個節點被造訪的次數。相對於父節點,一個節點被造訪得越少,探索項越大,就越會被鼓勵去走;被造訪很多次,除下來的數字變小,UCT 就相對那些還沒被探索的兄弟節點低。課程裡有人追問 UCT 的理論保證,講者的回答是這裡有數學也有直覺,但沒有證明這樣是最佳解,只是把探索跟利用兩邊平衡起來,被認為是比較好的做法。

最後一個階段是 reflection。backprop 做完之後,模型會對整條軌跡補上一段自己的想法:這次成功或失敗,是什麼造成的。講者說這個動作對整體品質的幫助相當明顯。

UCT 可以換掉,重複的動作會被累加

課堂上兩個技術問題都繞著這棵樹的邊界條件。有人指出 UCT 是從 bandit learning 來的 upper confidence bound,bandit 裡還有很多挑手臂的演算法,這篇有沒有比較過別的?講者的回答是沒有比較。探索的方式在 multi-armed bandit 的文獻裡有一整套,全部都可以搬到這個框架裡試;這篇的主要貢獻是搭出一個平台,讓別人把不同的最佳化方法接上去。

另一個人問的是重複動作。如果軌跡裡出現 A、B、A、B 這種重複,或是同一個動作在不同的節點出現,這棵樹有沒有辦法處理,還是會把它們當成各自獨立的軌跡?講者說,同一個動作在軌跡裡重複出現時,從某個父節點看過去,這個動作的次數會被累加,而次數本來就會進到 UCT 的算式裡,所以在建樹的過程裡就會被算進去。她也補了背後的前提:這裡假設面對的是一棵樹,不是一張全連接的圖。

HotpotQA 跟 WebShop:多取樣跟 reflection 都換得到分數

LATS 挑了兩個資料集驗證。HotpotQA 是設計成多步的問答集:每一題要答對,至少得從兩篇不同的 Wikipedia 頁面檢索資料,多步是題目本身規定的。講者說結果很好,取樣的軌跡數越多,表現就明顯往上走;reflection 跟把推理痕跡帶回來,又另外給了一段提升。這篇提供的是機制:test time 多花算力,可以真的換到多步推理題上更好的解。

WebShop 走的是應用面。講者唸了一個實際的查詢:想找一張小型的可攜折疊桌,要已經組裝好的,顏色跟表面處理有指定,價格也有條件。這種題目同樣是多步的。LATS 在這上面沒有做任何 fine-tuning,只在 test time 跑,成績就很高,已經接近人類專家的水準。

把 LATS 收成幾句話:它把推理、行動、規劃放在一起,把 MCTS 這類已知的方法帶進語言模型,在多個領域都拿到很強的結果;因為是 test-time 加模組化的做法,移植跟實作都相對容易。

代價也講清楚了。樹的展開、backprop,每一項都在加成本,而論文並沒有真的分析成本效益。另一個沒有處理的前提是:有些動作不可逆。模型如果是在跑一筆交易,動作真的執行下去,後果會很實際,例如真的付了一筆服務費。遇到這種場景,搜尋要怎麼調整,這篇沒有回答。

Sprint:不是不用想,是不用排隊想

第二篇是 Sprint,NeurIPS 2025,講者上課的時候論文還沒在會議上報告。它處理的是規劃與平行執行,以及怎麼用模型自己讓它想得更平行。

動機來自一個大家已經很熟的現象:O1、Gemini 2.5 Pro 這類前沿模型碰到難題會想得更久,而想得越久跟準確率越高是連動的。講者放了 DeepSeek R1 的訓練曲線:訓練往下走,它在 AIME 這類數學題上越來越強,同時每一則回應的平均長度也一直往上。越長的連鎖思考換到越高的分數,趨勢就是這樣。

但把長長的思考軌跡攤開來看,很多步驟其實彼此獨立。模型在試不同路線,把任務拆成子任務,其中一些子任務可以同時跑,還有一些步驟是在驗證前面做過的事。既然計算圖上有彼此不相依的部分,就沒有道理等它們一個接一個被生出來。

Sprint 就做這件事,而且是在 post-training 階段進來。它讓模型用 planner 生出多份計畫,再讓多個 executor 平行把計畫執行掉;一輪做完,再來一輪計畫跟平行執行。規劃與執行交錯,就是加速的來源。

讓模型自己標出哪些步驟可以並行

資料是模型自己標出來的。他們先有一批 DeepSeek R1 產生的推理軌跡,再用一個模型,講者舉的是 GPT-4o,把軌跡切成一段一段的步驟,並且替每一步標上這是規劃還是執行;有些步驟裡,一份計畫底下掛著好幾個執行片段。標完之後可以畫成一張 DAG:例如第四步跟第二步彼此不相依,但都接在第一步後面。這張圖讓模型看出哪些步驟可以並起來,於是資料就能打包成第一步先做、第二步跟第三步同時做。

這批資料拿去做 supervised fine-tuning。講者特別強調「LRM」在這裡只是 large reasoning model 的意思,現在每一顆 LLM 基本上都算推理模型了。微調的內容是把同一套思考過程重寫成帶標籤的版本;模型學到的行為是,在推論的時候自己把標籤生出來:計畫一、它的執行、計畫二、它的執行。

推論的結構值得說清楚,因為課堂上有人以為這變成三條平行線同時生成。它還是下一個 token 一個一個生。改變的是模型現在會在一個時間點上,把可以並行的計畫一起吐出來:先出來計畫一跟計畫二,計畫一輸出完,它的執行就開始跑,計畫二輸出完,它的執行也開始跑;執行結果回到 context,模型再生下一輪的計畫。實務上就長成這樣:第一步之後同時生出第二步跟第四步,讀完兩邊的結果再繼續。

課堂上另一個問題是重規劃。如果模型在執行第四步之後發現前面的方向錯了,想退回去用計畫三而不是計畫二,它記得住哪份計畫對應哪份執行嗎?講者的回答是它還是可以,因為所有 context 都還在。訓練教的只是不要等:計畫二既然跟計畫一無關,就沒有理由壓著不先做。也因為計畫跟執行是用特殊標籤生出來的,外面的系統可以照著標籤去真的把工作並起來跑。

平行之後,準確率跟著上去

訓練配方是這樣的:在數學資料集上生六千條思考軌跡,留下並行程度比較高的那些,把格式重排之後,對 DeepSeek R1 蒸餾出來的 Qwen-7B 做 supervised fine-tuning。

有個出乎意料的結果。專案一開始的目標是把並行度拉高、把序列生成的 token 數壓下來,這件事做到了;但同一個過程也把準確率一起推上去。模型似乎喜歡這種比較有結構的思考方式。圖上可以看到,序列 token 數相對 R1 蒸餾 7B 這個基準大幅下降,準確率還高出 3.5 個百分點,而且序列 token 數比 32B 模型少很多。

還有 out-of-domain 的表現。平行思考只在數學資料上訓練過,但模型在 Countdown 跟 GPQA diamond 上也變好,這兩個資料集完全沒有進訓練。講者的解讀是,平行思考本身似乎就在幫模型,序列 token 的節省是順便拿到的。

軌跡的形狀也有兩種變化。難題需要更多輪的規劃與執行。前期,模型觀察到更多平行、更多探索;後期則收斂下來,往單一計畫裡鑽深。另一個課堂提問處理了矛盾的歸屬:如果每一個平行分支單看都對,合起來卻錯,該聽誰的?講者說不論序列還是平行,最後所有東西都會被壓回 context 裡,模型在思考之後要生出最終答案,有矛盾就要在這裡解掉。她也說兩種做法都可能出現思考上的矛盾,而這篇看到的比較像是「同一道題的不同步驟」,不是「同一道題的不同解法」。

瓶頸也在課堂上被問到。平行跑的獨立任務,怎麼保證每個花差不多時間,不會有人拖隊?講者說保證不了。他們做了一些安排,但還是可能出現 straggler:第四步比第二步久很多,你就只能等第四步。不過至少等的時間是第四步,不是第四步加第二步。他們的一個做法是,如果某個執行太簡單,就把它併回計畫裡,讓並行的區塊變大一點。這條線還能再最佳化,她也不確定論文有沒有分析到這一層。

平行度有多少,取決於任務。數學的序列 token 比例比 GPQA 低,這個比例本身就是平行度的指標。在數學上,跟準確率相當、甚至更低的其他方法比,Sprint 把序列 token 砍掉大約四成。但題目本身想得少的時候,能並行的空間也少,這個「先規劃再執行」的重排甚至可能比基準差;優勢出現在需要更多思考、token 更多的難題上。

講者順手提了一份最近的 Sonnet 4.5 系統卡:裡面的 prompt 鼓勵模型盡量用工具,至少用一百次。她的觀察是,我們正在進入一個問題規模更大的階段,一題要處理的 token 早就超過 8K 到 10K。

Sprint 這篇只做了 supervised fine-tuning。講者認為 RL、GRPO 這類方法有機會從同一批資料裡挖出更多東西,泛化也會更好;工具的重疊使用,以及在實作上真的做出 wall-clock 的加速,都還是可以做的題目。

SWIRL:要教多步工具使用,但不要在訓練時真的呼叫工具

第三篇是 SWIRL,下週要在 Montreal 的 COLM 報告。它同樣是訓練端的方法,要讓模型把多步推理做得更好。

動機很日常。很多真實任務要靠多步推理加上工具:用搜尋引擎回答多跳問題、解數學題、做軟體工程專案、規劃旅行、分析資料。人在處理重要任務時,工具通常要來回好幾輪,推理跟呼叫交錯出現。一個步驟就已經夠複雜,步驟一多,錯誤跟麻煩會沿路累積。

這篇的設計目標列得很具體:模型要知道什麼時候該呼叫工具,要生得出對的 query 去觸發工具,要在多個推理步驟之間維持準確率,要學會從錯誤裡回復,還要知道什麼時候該停下來、不再呼叫新工具,直接給最終答案。最後要能適應新的工具跟新的推理任務。

還有一個目標是操作面的,也決定了整個做法:訓練過程不要真的去用工具。工具會失敗、會慢、會有 bug,而訓練本身已經夠貴了。

講者也點名了既有做法的問題。RLHF、RLAIF、執行回饋這些微調流程,很多是在單一步驟上做最佳化:模型把想做的做完,生出一個最終答案,reward 就看這個答案對不對,然後把這個訊號往回傳到動作上。SWIRL 想要的是對「生出這些步驟的過程」有更多掌握。

工具呼叫留在標註階段,訓練時只看動作好不好

做法從資料開始。給一個 prompt,讓模型一次只走一步。每一步都告訴它:你可以推理、可以生一段 chain of thought、可以呼叫工具,如果你已經準備好生最終答案,就直接生。第一個動作可能是推理加上一次工具呼叫,環境的回應接著被放進來;下一輪再把原始 prompt、前一個動作、環境的結果一起送進去,問它下一個動作。這樣反覆迭代出來的就是多步資料,不同題目的步數從一到三步、五步都有。

每一步都要有標籤。他們用 LLM-as-judge:把前面的 context 跟當前這個動作交給評審模型,請它估這一步有多好。這整件事在離線做完,很多題目可以平行跑。

接下來的分離是這篇的關鍵。所有真正的工具呼叫都發生在離線標註階段,產生的軌跡被存下來。到了 RL 微調,模型被放到第 k 步的位置上,prompt、前面的步驟、環境的回應都已經在 context 裡,它要做的是生出下一個動作;這個動作拿到一個分數,分數拿去做最佳化。沒有人真的去執行那個動作。講者的理由是,語言模型判斷「這個動作提得好不好」已經夠準,不需要真的跑一遍再評估。

課堂上有人立刻追問:評審看不到工具真正的輸出,怎麼有辦法打分?講者說,評審評的是 query 的品質,不是工具的輸出。它看到模型在問某個人的年齡,在搜尋結果還沒回來之前,就能判斷這是不是一個合理的搜尋問題;不知道那個人的年齡,並不妨礙它判斷這個問題問得好不好。她也回答另一個追問:這裡沒有訓練任何 judge 模型,就是直接 prompting。

被最佳化的目標寫成這樣:假設有 s1 到 sk 這些步驟,每一步後面接一個動作,動作裡包含一段推理跟一次工具呼叫;他們最大化的是「在目前為止的 context 之下,單一動作的期望 reward」,而這個 context 就是前面累積下來的狀態與動作,一路從動作一做到動作 k。課堂示範裡的軌跡長這樣:第一個動作是去查第一個人的年齡,拿到環境回應之後,第二個動作是查第二個人的年齡,最後一步模型判斷資訊夠了,生出 answer 標籤跟最終答案。

推論時的迴圈長得跟資料生成很像。prompt 會說請用幾個字回答下列問題,並指定可用的工具,例如計算機:如果你覺得用計算機有幫助,把數學 query 放在標籤裡;也告訴模型,一旦資訊夠了,就生出 answer 標籤跟最終答案。模型第一步呼叫計算機,把想算的東西放進 query;工具被執行,輸出回到模型;模型再被問一次,這次帶著前面的思考與工具結果。就這樣一輪一輪往下走。

process-filtered 的資料,比只留答對的更有用

實驗設定是這樣的:多步合成資料由 Gemma 2 27B 產生,題目來自 HotpotQA 跟 GSM8K,大約五萬條軌跡。資料可以只用 process filter,也就是評審對每一步都投贊成;可以只用 outcome filter,只留最終答案正確的;可以兩者都過;也可以隨機抽。

結果有點反直覺。只用 process filter、完全不管最終答案對不對的那批資料,訓練效果比只留答對的軌跡、或過程跟結果都要對的資料更好。講者的解釋是,如果模型本來就答得對,你留著這些軌跡,對它解不開的題目幫助有限;反倒是過程站得住、結果沒收好的軌跡,在教模型用不同的方式想同一道題,讓它有機會解開以前解不開的題目。

泛化是這篇最漂亮的地方。在 GSM8K 上訓練,教模型用 SymPy 或計算機解數學題,然後拿去測 HotpotQA,準確率從 65 拉到 71。如果直接拿 HotpotQA 訓練,工具是搜尋而不是計算機,同一份評測從 65 到 73。反過來也成立:在 HotpotQA 上用搜尋工具訓練過的模型,換到 GSM8K 用 Python 也表現得更好。講者的解讀是,模型學到的是怎麼一步一步想、怎麼把工具叫起來,換工具也帶得走,不只是學會用某一支工具。

資料量的效果同樣明顯。在 HotpotQA 上用搜尋工具訓練,測試的卻是數學題:訓練樣本從一百筆增加到一萬筆,模型在完全不同的任務上也跟著變好。講者說這是這篇最重要的一張圖。在比較容易生出資料的環境裡合成資料,教模型怎麼用工具、怎麼多步思考,這個行為可以搬到全新的工具與領域上,規模再放大一點,可能是一套很有力的方法。

他們也試著解釋為什麼會變好。方法是看每次回答時每一步的平均 process reward,比較 RL 前後:過程的正確性在 in-distribution 的 HotpotQA 上提升,在 out-of-distribution 的 GSM8K 上也提升。模型每一步想得更對,兩邊都一樣。他們另外看了 precision、recall 等指標,也跟前沿模型比過。

最後是 RL 跟 SFT 的對照。同一套流程用 supervised fine-tuning 也跑得起來,但多步 RL 明顯贏過 SFT。SFT 對資料的要求還剛好相反:它最需要過程跟結果都對的資料,只給 process-filtered 的資料反而差。講者的解釋是,SFT 本質上是模仿學習,你給它軌跡,要它照著重現,結尾錯了就會拖累表現;RL 則是在既有的前綴上讓模型再挑一次動作,並且對這個新動作給 reward,它才有機會跳出資料裡原本的樣子。

SWIRL 的總結是:跨資料集與工具都能泛化,能轉移到不相干的任務,從 process-filtered 的資料學得更好,合成資料越多、in-domain 跟 out-of-domain 都跟著漲,而這些改善在每一步的 process 正確性上看得到。

三套工具放在一起,是一組可以拼裝的工具箱

課要收尾的時候,講者把三篇併起來看。LATS 花的是 test-time compute,在難題上用搜尋加 reflection 換準確率;Sprint 動的是規劃的結構,把獨立的計畫並起來跑,省延遲,通常也順便漲分;SWIRL 把工具呼叫搬到離線,用 process reward 訓練多步行為。三者在時間軸上分工,不是互相取代。

她也強調這條線的模組化程度。UCT 可以換成別的分數策略,搜尋可以考慮成本,不可逆的動作可以加上安全限制,reflection 可以寫得更有內容,最後還需要有人把標籤化的平行計畫真的變成看得到的執行加速。這些接口都還開著,講者最後一句話是:多步推理跟規劃是一個非常活躍、還在往前走的領域。

〈Stanford CS329A Self-Improving AI Agents〉-EP-Part 4 | Learning from Feedback with Tools/Code

https://www.youtube.com/watch?v=Lxh9RF5S-K0

模型能不能自己變好,取決於它有沒有地方把訊號拿回來。CS329A 第四講把自我改進拆成三個個案:ReAct、RLIF、Constitutional AI。三套技術都在講同一件事,差別不在演算法多花俏,而在回饋從哪裡來。ReAct 的回饋來自環境與工具,模型搜尋、觀察、再決定下一步;RLIF 的回饋來自程式真的跑起來的結果,測試過不過就是訊號;Constitutional AI 的回饋來自模型對自己的批評,而批評的標準是人類事先寫好的憲法。講者開場就把這條線畫出來:同一個迴圈,餵進去的東西不一樣,能修的錯也不一樣。前兩講談的 test-time compute 與 robust verification 是同一條線上的事,這一講把鏡頭轉到「回饋」本身。

人類先想再做,ReAct 把這個迴圈搬進語言空間

人要做一件事之前通常會先想一下。講者用一個很生活的例子開場:決定要不要來修這門課,你會先想這對自己有什麼用,想通了才有動機行動;真的進了教室,你得到一個新的觀察,喜不喜歡這門課,這個觀察又回頭改變你的下一個念頭,也許是去寫作業,也許是別的決定。想與做之間來回,人靠這個迴圈運作。

語言模型過去把想與做分成兩件事。模型很會解自然語言處理的問題,在多數人熟悉的聊天情境裡也夠用,但要在真實世界的任務裡發揮作用,它得能跟環境、工具、程式碼互動,並且從互動裡學東西。困難的地方在於模型會幻覺,而且對自己環境裡正在發生的事一無所知。你問它今天氣溫幾度、今天哪裡發生了什麼事,除非它真的發一個搜尋請求、把資料抓回來,否則它手上沒有這筆資訊。少了這層 grounding,它就沒有辦法採取有意義的行動,更沒辦法把行動結果接回推理。

當時的兩條路線各缺一半。chain of thought 讓模型把中間步驟寫出來,數學題可以一步步推到答案,但這些步驟是模型內部狀態的產物,沒有來自外部世界的回饋。另一條路線像 WebGPT,學的是怎麼跟瀏覽器互動,可以在人類偏好的互動軌跡上做微調,但它不特別具備推理過程。ReAct 要解的就是把這兩種範式接起來。

做法出乎意料地簡單,主要靠 prompting。先要模型針對任務生出 verbal reasoning trace,把這段推理接回 prompt,再問它基於這段推理該採取什麼行動;行動做完得到觀察,觀察再進下一輪。講者把它畫成兩條迴圈,左邊是推理,右邊是行動,中間靠語言空間串起來。thought、action、observation 一個接一個,每一個都在通知下一個,跟人走到廚房發現沒水、於是決定去超市那種順序感很像。她也提醒,想加平行取樣之類的花招可以,但那要另外設計流程。

實作上,這篇用的是當年較舊的模型,frozen 的 PaLM,靠 few-shot 示範。範例裡有 thought、有 action、有 observation,然後要模型產出下一步。決策型任務的示範則讓模型自己選:這一步要先推理,還是直接動作。行動的正確性另外用一個技巧處理,把問題框成分類,先把合法的行動集合列出來,讓模型在「世界狀態、目前推理、合法行動清單」之間做選擇。講者提到她在 Google 跟機器人團隊合作的另一篇也用同一招,因為機器人這種場景沒有合法行動清單根本動不了。她也回應了課堂上的一個技術問題:thought 不算在 action space 裡,兩者是分開的迴路;之所以要有 reasoning token,是因為語言模型在語言這個抽象層次上生成推理,比較容易輸出正確的行動。

Apple Remote 那一題,CoT 與純行動都答不出來

講者用一題 HotpotQA 把差別走完:除了 Apple Remote 之外,還有哪個裝置可以控制它當初設計要操作的程式。標準 prompting 直接問,答案不對。chain of thought 把中間步驟寫出來,答案還是不完全正確。

純行動版本會搜尋,但推理不在裡面。它搜 Apple Remote,拿到觀察;再從觀察裡挑出 Front Row 去搜;一路跟下去,最後發現這是一個已經停產的東西,於是給不出好答案。

ReAct 的走法不一樣,先想再查。第一步先想:我得先查 Apple Remote,找出它原本是設計來操作哪個程式。搜下去得到一個觀察:這是一支很早推出、2005 年、差不多二十年前的遙控器,原本設計來控制 Front Row Media Center。接著它想,下一步該查 Front Row,於是去搜,搜不到;它換了個詞叫 front row software,再搜,這才知道那是一個已經停止的媒體軟體中心。到這裡它再想一次,答案就接得起來了。

講者下的結論是,推理這個抽象讓它給出比純行動更好的答案,而把 thought、action、observation 交錯起來,是模型表現變好的原因。她也順帶說了今天的情況:Qwen 這類模型打開 thinking mode 就會自動出現這整套行為,因為開源模型在 distill 的時候早就把這類軌跡吃進去了。工具呼叫對現在的模型來說已經算是內建,甚至不需要 ReAct 這個外框,模型直接在 chain of thought 裡就把想與做串完。

模型不知道自己知道什麼,應用端要自己補護欄

課堂上有人問,模型怎麼知道自己知道什麼、什麼時候該去搜。講者的回答分兩層。第一層是它其實不知道,它是從互動裡拿到回饋才知道的。第二層更麻煩:請模型替自己的輸出打分、問它有沒有信心,它通常過度自信、校準很差,這是一個還沒解完的研究問題。所以她給應用開發者的建議是,把注意力放在讓模型用對的工具、拿到有外部依據的資訊,而不是指望它自己判斷「我會不會」。她也補了一句對比:有搜尋結果可以對照時,幻覺比純粹依賴模型內部狀態好控制得多。

同一個問題的另一面是答案互相矛盾的時候怎麼辦。講者說這要由應用端決定,如果幾份結果沒有共識,可以用 majority voting 之類的做法;前幾講談過的驗證手段也可以搬過來。對終端應用來說,重點是交出去的答案站得住,所以要多幾層 guardrail:答案送出前先驗一次,或讓多個來源互相對照,而不是相信單一輸出。

還有一個學生問到 KV cache:thought 與 observation 在模型內部的表徵有沒有不同的交錯模式,observation 是環境給的、不是模型自己生的。講者說這可以當這門課的研究專案,開源模型都拿得到。

ReAct 贏過純行動,但沒有穩定贏過 CoT

HotpotQA 是在 Wikipedia 上做多跳問答,FEVER 偏事實查核。這兩個任務的 action space 都很窄,基本上就是搜 Wikipedia 頁面、查某個字串、或是宣告任務完成,等於在模擬人使用 Wikipedia 的動作。

比較的基準線排開來看:標準 prompting,沒有 thought、沒有 action、沒有 observation;chain of thought,要模型一步一步想;CoT-SC,用 self-consistency,也就是多數投票;Act,中間沒有思考,只有行動;另外還有兩種互為退路的變體,一種是 ReAct 失敗幾步之後退回 CoT-SC,另一種是多數答案出現不到一半時退回 ReAct。

結果裡有兩件事值得記。ReAct 一般來說比純行動好;但它並沒有穩定贏過 chain of thought,FEVER 上贏,HotpotQA 上不一定。真正贏過標準做法的是把 CoT-SC 與 ReAct 接起來的版本。講者從這裡下的判斷是,把模型內部知識與外部知識好好合併是有價值的,推理則是模型走到正確答案的中介,讓它知道該去檢索什麼。

失敗模式也一併看了。CoT 的主要問題是幻覺;ReAct 因為有外部知識庫可以檢索,錯誤比較少,也比較能信任。同一個方法在不同訓練方式下的排序也清楚:能 fine-tune 時表現更好,能跑 RL 迴圈時又更好,後者留到下一週講。

WebShop 上 66.6 對 82.1,還差人類專家一截

知識密集任務之外還有決策型任務,例如網頁瀏覽、機器人、遊戲環境。講者用 WebShop 當例子:使用者給一句指令,例如找一個有抽屜的床頭櫃,agent 要在模擬環境裡完成購買。基準線是模仿學習,也就是單純 fine-tune,以及模仿學習加 RL,也就是 SFT 加 RL。

ReAct 在這張表上分數與成功率都贏過兩條基準線。分數看的是中間步驟,成功率看的是任務最後有沒有完成。但講者沒有把話說滿:ReAct 的分數是 66.6,人類專家 82.1,中間還有一大段;成功率更低,因為這是多步流程,任何一步做錯,錯誤會一路串下去。

限制也講得很直接。action space 一大,需要的示範就多到塞不進 context;需要多步推理,推論成本就比單步高;還有一個很常見的副作用,模型會在一些根本不需要想的簡單任務上想太久。她說現在很多模型都有這個毛病,thinking trace 拉得很長,怎麼讓模型不要想太多,本身就是一串有趣的研究。

課堂後半花了幾分鐘討論環境本身出錯的情況。如果回饋是吵雜的、甚至誤導的,怎麼辦?有人提議在 agent 上加一層 reflection,讓它對環境給的東西先反思再推理;有人說要能 backtrack,因為被錯誤回饋帶偏之後,模型可能卡在迴圈裡;也有人提多數投票與信心指標。講者順著這些回答收了幾點:需要更好的方法估計自己對環境回饋的信心,需要任務分解,太複雜的任務先切成子任務,也可以考慮平行思考、把過去的經驗放進 memory。有人提到推理與行動的理想比例,講者說這確實值得研究,不同任務可能不一樣。還有人建議做 compound system,把子任務依照各家模型的強項分工出去。

RLIF:把測試的 pass/fail 當成 RL 的 observation

第二篇轉到 coding agent。講者先在課堂上問有多少人用過 Claude Code,舉手的人接近全班,她說那就不必多解釋為什麼這件事重要。程式與工程任務大量交給 agent 之後,真正決定 agent 強不強的,是它能不能理解使用者意圖,並且在生成程式碼之後拿到某種回饋,讓它有東西可以往上疊。

RLIF 的框架是 end-to-end 的 RL fine-tuning,也是最早證明執行回饋能把 coding LLM 明顯拉上來的工作之一。action 就是模型生出來的程式碼;前面講 ReAct 時稱作 observation 的東西,在這裡是 execution feedback,也就是把程式跑起來、跑測試、收集測試過或不過的結果,換成一個 binary reward。有了這個訊號,模型可以在 fine-tuning 的階段一輪一輪修,PPO 是他們用的演算法。講者說這篇有兩個機制值得記,一個是 two-tier test strategy,一個是 hybrid token turn-level policy,她也請大家把論文仔細讀過。

框架的核心是一個迭代的回饋迴圈,訓練時與推論時都用到執行回饋。最上面那一格,模型拿到一段自然語言的問題描述,例如請寫一個 hello world;它生出一個程式解,拿去跑一組 public tests。如果沒過,執行回饋就回到模型手上,讓它再試一次,這個循環一直走到通過,或是走到規定的回合數上限。通過的那些解再送去一組完全沒見過的 private tests,由那邊的結果決定 reward,reward 進 PPO 更新。講者把左邊稱作 RL 的 exploitation 階段,用推論時的回饋迴圈把現行策略的潛力榨出來;右邊是 update,用執行結果更新策略,模型就在這裡自我改進。

課堂上有人問 public tests 哪來的。講者說這是外層迴圈要設計的事,以 code contests 為例,題目本來就附測試,你可以切一部分當 public tests,在推論時提供回饋,另一部分留著訓練模型。也有人問「測試失敗」是什麼意思:測試就是實際跑一段 Python 函式,失敗代表模型生出來的那個解不正確,測試的輸出會餵回模型,連著題目與生成結果一起,變成下一輪的輸入。至於失敗與通過由誰判斷,答案是測試本身,不是模型自己說了算。

講者用一個例子把流程走完:題目是寫程式偵測回文子字串。第一回合模型生了一個基本解,public tests 沒過,而且是執行超時,這是很常見的錯法。收到這個回饋之後,第二回合它生了一個做過最佳化的版本,這次過了 public tests,於是送去 private tests,再決定怎麼更新模型。

兩層測試的分工是這樣:public tests 是為了快速迭代而存在的小 subset,提供即時回饋,引導模型把解寫好;private tests 在生成過程裡完全隱藏,只負責在最後給訊號。講者說這個切法是他們眼中自我改進迴圈裡有用的創新,因為模型沒辦法靠背下測試輸出來過關。它也回應了課堂上另一個追問:如果全部測試都當 public,就沒有那層乾淨的訓練訊號了。

token 逐個生,獎勵整輪給

RL 演算法的細節講者請大家自己看論文,她只強調一件事:語言模型是一次一個 token 生出來的,所以 policy model 在生成程式碼時有比較細的控制粒度;但 value function 是 turn level 在算,reward 打在整段回應上,所有 token 共用一個 advantage 值。她說這跟 GRPO 的做法比較接近,都是給整段序列獎勵,而不是逐 token 給。

錯誤在第二、第三輪變少,修改也變準

結果的圖有兩張,縱軸都是 solve rate,橫軸是取樣預算,而且是對數尺度,驗證集與測試集各一組。模型是 Llama 3.1 那一代,講者自己說結果有點舊,但趨勢夠清楚:在 code contests 這種競賽程式題上跑 RLHF 之後,solve rate 明顯上升。她解釋 solve rate @k 的意思:同一題生十份解,看裡面有幾份能過。

為什麼有效,講者把問題反過來問。base model 光看到錯的解與執行回饋,其實沒什麼用;真正有幫助的是訓練時每一輪都把執行回饋秀給它看,而且這樣學到的東西可以泛化到其他程式 benchmark。這個效果在錯誤分析裡最明顯:他們數第一輪、第二輪、第三輪各有幾個錯,順便記錄程式碼改動的次數與錯誤類型,小模型與大模型各一組。跑過 RLHF 的模型,回合往後推,錯的輸出變少,後面的回合開始真的把解修好;沒有這個迭代迴圈的版本,改出來的東西還是不對。

講者的總結是兩種好處同時發生:取樣提供多樣性,而模型知道自己錯在哪裡,改動就更有針對性。有一個例外她也被問到:超時的錯誤數不會那樣降下來,因為那代表解法始終沒對,測試跑到時間用完為止。她補了一句,這些行為跟領域很有關係。

binary reward 撐到哪裡為止

課堂上有人提出一個很合理的懷疑:binary feedback 在簡單題目上夠用,題目一難,可能就需要 error trace 或更多 metadata 才 debug 得動。講者說很有可能,這會是個好專案。順著這個問題,討論走到 process reward model 與 outcome reward model 哪個比較好,也就是要不要每一步都給回饋。她說這個爭論還沒有結論,上一講 Azalia 談過,換一個領域、換一個 benchmark,可能就要重新 hill climb 一次。

也有人問 SFT 能不能取代 RL。講者的回答是這個問題還在辯論中:在推理軌跡上做 SFT 也能拿到一部分好處,領域內的東西 SFT 一定有效,但 RL 有機會解比較新的問題,泛化好一些。她反過來提醒大家這篇論文真正要學到的事:自我改進迴圈是可行的,而且在夠簡單的問題上,binary reward 就撐得起來。

這套迴圈也直接搬進了作業。作業不是寫程式,而是數學題:模型生一份解法,自己去抓哪裡錯了,把錯誤當成回饋接在後面,再生成下一版,看每多一輪錯誤能不能變少。沒有執行環境可以跑,形狀還是同一個。

Constitutional AI:人類只寫憲法,批評與修改交給模型

第三篇要處理的是無害。要讓模型有用又無害,傳統做法是人類回饋:把模型的多個輸出排起來給人看,問哪個正確、哪個有用、哪個夠具體,累積出偏好之後訓練 reward model,再拿它去 hill climb。講者說這條路效果不錯,模型變大時 RLHF 的曲線明顯比單純 fine-tune 好;但它不好規模化,因為你得收集成千上萬筆人類標註,過程冗長又費工。

Constitutional AI 換掉了這一環。Anthropic 讓人類只寫一份憲法,一組 16 條原則,用來說明希望模型具備什麼行為;人類除了寫這份文件之外不必進迴圈。這個做法之所以行得通,是因為模型變得很會遵循指令:要它照某個格式回答,它做得到;要它判斷某段輸出有沒有某種行為,它也能給出答案。憲法正是要利用這個能力。

流程分兩階段。第一階段是自我批評與修改:拿一組紅隊 prompt 去刺激模型產生輸出,接著送出 critique request,問它這段輸出有沒有有害或不道德的內容,或是有沒有性別偏見,或是不適合年幼的孩子;再送 revision request,要它把這些痕跡拿掉、改寫成合宜的版本。這些批評與修改的軌跡,被拿去對模型做 supervised fine-tuning。

第二階段是 RL。他們先用 AI feedback 訓練一個偏好模型,學會偏好符合憲法的回應,再用這個偏好模型去 fine-tune 語言模型,讓它最大化得分。講者強調這一步取代的是原本靠人類偏好訓練出來的 reward model。她也回答了課堂上的疑問:偏好模型本身還是要驗,要有測試集或驗證集,把 AI 給的分數跟人類評分對齊,只是不必到一萬筆那種規模。

helpfulness 與 harmlessness 是同一條曲線的兩端

監督學習階段的圖先給出一個取捨:修訂次數增加,無害程度往上走,有用程度會往下掉。他們的說法是,如果你一直把模型往一組固定原則推,它會變得比較不好用,但兩者加起來整體是單調改善的。

真正關鍵的是最後那張 Pareto 圖,縱軸是 harmlessness Elo,橫軸是 helpfulness Elo。pretrained base model 是起點,分數不高;只做 helpful 的標準 RLHF 會把 frontier 往有用那一邊推;helpful 加 harmless 是另一條曲線;只做 constitutional supervised learning 的版本還輸給 RLHF;把 constitutional RL 接上 chain of thought,才走到那條最好的交換曲線。講者說這是這篇論文的核心主張之一:你可以同時把有用與無害推到自己想要的位置。

文字版結論是,讓模型照原則評估自己的回應,得到的模型差不多一樣有用、也許略差一點,但無害程度高出一大截。這也是 Claude 系列當年很強的地方,現在這套技巧已經被各家的模型普遍採用。講者也提到這套原則的適用範圍不只於此:只要你想讓模型遵循一組彼此可能衝突的指令,同樣的框架都能用。

課堂上有人問憲法修正的問題,如果原則改了,怎麼便宜地更新模型,又怎麼確定舊規則真的被忘掉。講者有兩個回答。第一,RLHF 通常是最後一階段,post-training 佔整體算力大約 5%,模型本來就經常更新,憲法要改可以搭這個頻率。第二,這背後是 continual learning 這個未解問題:怎麼讓模型忘掉一組知識、或改遵守另一組規則,目前沒有保證。有人試過用 interpretability 的方法去「取消」某些知識,但沒有證明一定能忘掉。她也點了一串後續工作,包括 self-refine 那種用自我回饋反覆修的做法、用 RL 教模型自我修正,以及把 RLHF 與 AI 回饋版本互相比較的研究。她補了一句很實際的觀察:模型自己批評自己有時比較難,找其他模型一起批評有時效果更好,原因還是模型會過度自信。

三種回饋來源,同一個條件

講者在收尾時把三篇兜在一起。ReAct 從環境與工具拿觀察,把推理與行動交錯起來,讓模型在有外部依據的需求上答得更好、查核得更準,放進遊戲或瀏覽器這種環境當決策者也行;它的決策軌跡很好讀,工具呼叫到今天已經內建在許多模型裡,是這條線的基本積木。RLIF 把測試當成程式領域最好的執行回饋,一輪一輪把回饋吃進去,讓模型在競賽程式題上少花一點預算就達到前段水準。Constitutional AI 則用人類寫的原則生出回饋,讓自我改進迴圈轉起來。三條路的共同條件是同一件事:回饋裡要有足夠的訊號,模型才可能走到訓練資料之外的地方。

她也回答了 agent 與語言模型的關係。課堂上有人定義 agent 是好幾顆模型互相連接、有記憶、有 session、能做 function call;講者說,這已經開始接近她心目中的 agent,只是還沒有 session、還沒有記憶。而 agent 最根本的積木之一,就是怎麼讓語言模型用某種方式回應,所以這三篇值得先弄懂。至於實務上的 workflow,她舉了 SWE-bench 這類要改整個 codebase 的任務:先搜尋相關檔案、把元件摘要起來、建一張壓縮過的圖或 RAG index、提出 patch、用測試驗證,不對再迭代,跟這一講的迴圈同一個形狀。她也提到 Azalia 實驗室的 CodeMonkeys 在做很接近的事。

有人問,現在有了 RL 的 post-training,這些手工設計的框架會不會被取代。講者的答案是一半一半。如果某個任務的搜尋空間可以被定義清楚,那就有機會自動化;但要替所有任務定義搜尋空間,這件事本身就不明確。她拿職業別來舉例:會計師、財務 agent、法律 agent 各自照什麼步驟做事,這些都是領域專屬的,定義不出來。ReAct 的價值在於它定義了一個順序,先想、再做、再看,這本身就是一種 workflow;把它一般化成 agent,就是替某個任務定義 workflow,而 workflow 依舊是領域專屬的。

課就收在「搜尋空間定義得出來嗎」

最後一個問題問的是更大的事:人類的認知方式這麼多元,有沒有系統性的研究把認知科學跟語言模型接起來。講者說現在很硬,大家確實都在借用人的解題方式,但終極目標是讓模型自己找到往上爬的路,而不是用文字替它把 reasoning space 講死。她觀察封閉模型在這件事上做得比「用文字指定推理空間」更好。

那能不能自動化?她說要看搜尋空間有沒有被定義出來。遊戲是定義得清楚的那一類,action space 有限、狀態有限,可以讓模型自己去探索。但真實任務多半不是這樣,你要去搜工具、去經歷環境、收集觀察再拿回來用,所以現在才會在語言空間裡做這件事。課堂上還有人問,能不能用數學結構去限制對話的生成;講者說某種程度上做得到,但這些模型是在網際網路的資料上訓練的,再怎麼限制也很難把它們學過的東西全部擋掉,這是一場跟資料的拔河,過濾資料確實在做,能做到多少是另一回事。

課就在這裡收掉。

〈Stanford CS329A Self-Improving AI Agents〉-EP-Part 3 | Robust Verification

https://www.youtube.com/watch?v=p7TdPUcPoik

語言模型答對的次數,比它認出自己答對的次數多。上一講把這件事量了出來:同一個題目取樣幾十次、幾百次,正確答案常常就在裡面,卡住的是系統沒有能力自動把它挑出來。這個落差叫 generation-verification gap。CS329A 第三講整堂課都在處理這一端,也就是 verifier。講者把過去四年四篇論文排成一條線:2021 年跟著 GPT-3 一起訓練的那顆 verifier;把分數打在每一個推理步驟上的 PRM;讓模型自己 rollout 出標籤的 Math Shepherd;還有 NeurIPS 2025 那篇 Weave,把一整群不完美的 verifier 加權起來,再 distill 成 4 億參數的小模型。講者最後給的判斷是,驗證這一端做好,8B 的系統可以站到 70B 等級的位置上。

2021 年的 verifier:GSM8K,跟每題一百個候選

第一篇是 OpenAI 2021 年的 Training Verifiers to Solve Math Problems。動機很直白:LLM 會幻覺,會很有自信地把錯的解法端到使用者面前。講者補了一句,四年之後這句話還是成立,模型當然強了很多,但問題沒有消失。

這篇的另一個貢獻是做出 GSM8K。8,500 題小學數學,設計時要的是題目的品質與多樣性,而且刻意壓在多步推理上:題目本身不難,可是要解出來得走好幾步;解答用自然語言寫,不是純數學符號,因為這樣才收得到推理過程。講者到今天還是推薦用 GSM8K 測小型模型,也建議學生把它放進自己專案的評測裡。

Verifier 的訓練方式是一條清楚的迴圈。generator 先在同一批資料上 fine-tune 兩個 epoch,接著對每一題取樣 100 份解答,拿人類寫好的標準答案比對,一份一份標成對或錯,再用這些「題目、解答、標籤」訓練 verifier 一個 epoch。這批題目跟答案是靠大量人工監督做出來的,所以標準答案是可靠的,標籤可以直接從它長出來。

Verifier 自己也是一顆語言模型,頭上多了一個 scalar head,對每個 token 輸出一個二元預測。損失有兩條疊在一起:一條是預測對錯的二元分類,一條是原本的 next-token prediction。題目的 token 被遮掉,不列入最佳化,模型只需要管解答那一段。標籤的顆粒度可以選:切在句子層級,看每個句號之前那句話對不對;或切在 token 層級,後者很吵,等於要求每一個 token 都走在通往正確答案的軌道上。測試時整份解答只留一個判斷,取最後一個 token 的分數當結論。講者示範了兩份解答,一份中段分數掉下去,但後段一路轉綠,最後對上;另一份前面很好,後段出錯,最後一個 token 是紅的,跟實際標籤一致。

測試時的做法就是 best-of-N:同一個問題生成很多解答,用 verifier 給分,選分數最高的那一份當系統輸出。講者也講了一個實務上的保留:先做 supervised fine-tune 這一步,現在未必必要,模型已經很會聽指令、很懂數學,很多新的 verifier 直接訓練驗證目標,不先做那一輪 SFT。

Verifier 得贏過 fine-tune,而且大小要配對

跟「直接 fine-tune 同一批資料」比,verification 是贏的。GPT-3 的 6B 與 175B 兩個尺寸都是這樣,而且 verifier 的訓練資料越多,差距越明顯。資料量少於一千筆左右時,175B 那顆的 verification 幫不上什麼忙;資料堆上去之後,兩條線就分開了。

兩條線會不會交叉,這個問題也被追問過:資料真的夠多時,fine-tune 跟 verification 大概會收斂到差不多的結果。但 verifier 的價值在別的地方,你不會動到 base model,generator 保持通用,由 verifier 在旁邊帶它。這跟把模型整顆改成某個資料集的形狀是兩件事。

另一組 ablation 問的是大小怎麼配:大 generator 配小 verifier,還是小 generator 配大 verifier?答案是前者比較好。講者說這在某種程度上符合直覺,如果生成平均來說比驗證難,把多的參數放在生成那一邊就說得通。這條線還沒走完,generator 與 verifier 的 Pareto 最佳大小怎麼配,是一個值得做的題目;現在 base model 強很多,Hugging Face 上也有一堆現成的 verifier 與 reward model,甚至有 leaderboard 可以對著測。

候選數推到 400 之後,verifier 也開始追不上

test-time scaling 的結果也畫在同一篇論文裡。候選數往上加,verifier 帶來的準確率就一直往上,到大約 400 份都還有明顯增益,再往上就平掉了。取樣到 800 份時,verifier 已經追不上解答真正的分布,挑不出最好的那一份。對照上一講的 majority voting:那時候的結論是十幾個樣本、從來沒撐到 50 個就失效;verifier 把這條線推到了 400。

為什麼 400 之後會掉,講者解釋得很清楚。圖上量的不是 coverage,是整條系統最終的輸出。候選一多,verifier 的 precision 就下降:800 份裡如果有兩份解答非常接近、一份對一份錯,它分不出來;400 份的時候還分得出來。實務上他們停在 100 個樣本,因為大部分增益在那裡就拿到了,而且表現穩定。標籤的產生方式也順帶講明白:人類對每一題只寫一次標準答案,離線做一次就結束,之後模型生 100 份,逐份跟這份答案比對,對錯就出來了。

verifier 自己能不能再 scaling,講者把答案留到後面幾篇論文。

ORM 與 PRM:一個打總分,一個每一步打分

第二篇是 Let's Verify Step by Step,一樣出自 OpenAI,隔不到兩年。問題換了個角度:模型逐步解題,前面某一步錯了,整份答案就被帶歪。

這篇把 reward model 分成兩種。outcome-based reward model,簡稱 ORM,給整份解答一個分數,看的是最後答案對不對,就是前一篇 verifier 的概念。process-based reward model,簡稱 PRM,對過程中的每一步各給一個分數。

標籤怎麼來,決定了兩者的成本。一題數學題、一份逐步解答,最後答案可以直接對標準答案,ORM 的標籤到此為止。PRM 得靠人類標註員一步一步看、一步一步給分。最後的 reward 是每一步分數的乘積。用的時候可以 prompt 模型把步驟寫清楚,PRM 逐步打分,乘起來得到一個品質區間,再決定這份答案要輸出還是重試。這個做法叫 process supervision,credit assignment 精準,可以指到出錯的那一步。

更關鍵的是它處理 false positive 的能力。模型有可能過程整個歪掉,卻碰巧走到正確答案;outcome supervision 看到的只是一個對的答案,process supervision 有機會把中間那些錯步驟挑出來。它也鼓勵人類看得懂、願意背書的推理方式,因為那些標籤就是人寫的。這篇論文同時釋出 PRM800K,一組 80 萬筆 step-level 標籤的開源資料集。

PRM800K:真正貴的不是數量,是「看起來對的錯答案」

蒐集這批標籤的過程本身就是一個方法。他們讓語言模型逐步生出大量樣本,然後優先挑「convincing wrong answers」給人標,也就是最後答案對、中間步驟錯的那一種。這個選擇讓他們比隨機挑樣本省下 2.6 倍的資料量。標籤有三種:正、負、中性。整個流程是迭代的,資料收一批、PRM 訓一輪、下一輪的資料品質再往上。

講者用一題示範:某個分數的分母比分子的三倍少七,這個分數等於五分之二,問分子是多少。前五步都對,最後一步把 x 算成 7,正確答案是 14,那一步就標成錯。

訓練細節上,base model 是 GPT-4,ORM 與 PRM 都先做過 supervised fine-tune。ORM 取 completion 最後一個 token 的分數,PRM 用每一步機率的乘積。

結果是 PRM 贏過 ORM,也贏過 majority voting。majority voting 大約一百個樣本之後就失效;PRM 還能挑出稀有的正確答案,有些題目在取樣分布裡正確率不到 5%。資料效率的差距也很嚇人:ORM 每題標 100 份解答,效果大約等於 PRM 每題標 1 份。泛化方面,majority voting 跨到新領域時反而比 ORM 好,但 PRM 整體最好,能承受更多 distribution shift。

PRM 的代價,與那個擋不住的跳步

PRM 不是沒有代價。第一,它需要 k 乘以步數的標籤,要跟 ORM 做完全公平的比較並不容易,論文自己也知道,只能在部分圖上盡量控制步數。第二,PRM 的分數門檻是一個新引入的 hyperparameter,得為自己的系統去調,這是額外的複雜度。講者也說,新的做法很多是把 PRM 跟 ORM 併用,兩邊的好處都要。

另一個問題是跳步。如果模型直接寫「設分子為 x,x 等於 14」,中間的推理全省略,PRM 會不會照樣給高分?講者的回答分兩層。PRM 看得到題目、前面的步驟與當前這一步,答案對,它沒有理由扣分;PRM 本身不負責逼模型逐步思考。但這個設定裡你並沒有動 generator,你還是可以 prompt 它把步驟寫出來,PRM 只負責打分。真正會出事的是拿 PRM 去 fine-tune generator:模型可能學會停止推理,直接生出 PRM 喜歡的答案,這時候就得特別小心,確保 chain of thought 站得住。

這裡的標籤是人寫的,跳步會被人標低。下一篇把標註自動化之後,這層保障就沒了,講者直接說那確實是個 caveat。

Math Shepherd:標籤不找人了,讓模型自己 rollout

第三篇是 Math Shepherd。動機來自一個很實際的瓶頸:PRM 比 ORM 有潛力,特別是搭上 test-time scaling,但它很吃資料,而人工標註又貴又慢。所以問題變成,能不能把 PRM 的標籤蒐集自動化?

做法是把一個推理步驟的品質,定義成「從這一步走到最終正確答案的潛力」。站在某一步上,從那裡往外取樣 n 條後續軌跡,看最後有幾條答對。hard estimate 是只要 n 條裡有任何一條最後答對,這一步就算成功;soft estimate 是算比例,n 條裡有幾條答對就是幾分之幾。n 等於 3 的時候,hard 給第一步 1 分,soft 給三分之二。人的標註就被這套 rollout 換掉了,前提是你手上有每一題的最終標籤。

弱點也很明顯。如果正確路徑很罕見,可能要取樣到一百條才看得到,用三條去看就會給 0 分;難題上多數樣本都錯,等於整題收不到訊號;中間有錯步驟、最後卻走對的軌跡,會被標成正確。取樣多一點可以減少這些誤判,但不是保證。

使用方式跟前面一樣:取樣候選解答、用 PRM 打分、取最高的那一份當輸出。他們也把 PRM 當 reward model,用 RL 訓練 generator,讓它生出分數越來越高的步驟。hard 與 soft 最後差別不大;n 變大時 soft 看起來好一點,但 n 等於 4 那組就是他們最好的結果,最後選 hard,因為比較好量。

沒有半個人標的標籤,還是贏過 majority voting

成績單會讓人多看兩眼:整份訓練資料沒有任何人類標註,全部由模型產生。跟幾個 baseline 比:self-consistency,也就是 majority voting 的另一個名字;ORM;以及 Math Shepherd 自己的 PRM。它贏過 majority voting 與 ORM,也贏過前一篇的 PRM800K,在 MATH 上差距更大,因為 MATH 比 GSM8K 難得多。這些結論跨了 Llama 7B、Llama 34B 與 DeepSeek 67B。

加上 RL 又更好。拿 Mistral 7B 對這顆 PRM 做 PPO,結果明顯高於只對 ORM 做 RL。這個差距比單純 test-time scaling 小一點,但意義不同:模型生標註,標註訓 PRM,PRM 同時在測試時與 RL 訓練裡改進 generator,好幾層都用同一顆模型替自己產生資料與 reward。效果在某個點上會開始鈍化。

課堂上補了兩個方向。一個是給模型一份 rubric 或一組規則,讓它拿每一步去對照,多一份訊號判斷這一步合不合理;另一個是讓它用工具,例如計算機或 sympy,把方程式直接算掉。多一點 supervision、多一點工具,加上 agentic 的做法,驗證品質還能再往上。還有一個問題牽涉算力怎麼分:generator 多取樣、verifier 多取樣,兩邊吃的是同一筆預算,固定 compute 下該怎麼配,講者說這是可以做的題目;同時提醒 ORM 與 PRM 最好用同一批資料訓練,否則比起來不公平。

Weave:不要訓練更強的 verifier,把一群不完美的加起來

第四篇是 Shrinking the Generation-Verification Gap with Weak Verifiers,Stanford 的工作,NeurIPS 2025,課堂前幾個月才發表。動機還是同一個 gap,做法換了:不訓練一顆新的 verifier,改用 inference compute,把一群 verifier 集成起來。

這裡的「weak」不是故意找爛的,是承認沒有一顆 verifier 是完美的。pool 裡放的是市面上最好的 verifier,它們跟真實標籤有相關,但都有缺陷。成員有三類:PRM、ORM,還有一大類是把 LLM 當 judge,直接把答案丟給模型問它對不對,或讓它用工具、用 rubric 生出一個分數。

先看集成有沒有用。拿不同 lab、不同資料集訓練出來的 verifier 排在一起,比 top-1、top-5、top-10,整體來說集成有幫助,但不是單調的,多塞不一定更好。真正穩定有用的是學權重,給每個成員一個權重再加起來。有標籤的話,naive Bayes 或 logistic regression 這種很簡單的方法就夠,一顆 verifier 一個權重。以 MATH 500 為例,用一批標籤把權重找出來,再套到新的測試資料上,進步就很明顯。

先篩掉爛的,再用 1% 的標籤學權重

Weave 的流程叫 score, weight, select。先把各家 verifier 的分數標準化到同一個尺度,再用一小批標籤把品質太差的 verifier 濾掉。講者特別強調這一步重要,verifier 要先過某個品質門檻,才有資格進 pool。

剩下的靠 weak-to-strong supervision 來估準確率,這條線受 Snorkel 與 Alex Ratner 等人的工作啟發。設定是這樣:n 個 query,每個 query 生 k 份解答,pool 裡有 m 顆 verifier,總共 n 乘 k 乘 m 個標籤;要估的是「第 i 題的第 j 份解答是對的」這個機率,條件是手上所有 verifier 給出的標籤。關鍵假設是每一顆 verifier 抓到的是正確性的不同側面。講者的說法是,如果 pool 裡每一顆對每一份樣本都給一樣的分數,集成起來什麼都沒學到;訊號在於它們彼此哪裡一致、哪裡不一致。在這個假設下可以寫出機率,再用兩組等式:第一組用到任兩顆 verifier 彼此獨立的假設,第二組只是機率的定義,沒有額外假設。從這兩組式子架一個最佳化,就解出每一顆 verifier 的權重。

跟 naive ensemble 比,這個做法有幫助,在 GPQA Diamond、MATH、MMLU Pro 這些難題上增益更大,因為 baseline 本來就低,加權集成把分數拉起來一大段。

算力分配那張圖上放了幾條線:深紅虛線是 Pass@K oracle,代表如果有一個完美的挑選器會拿到多少,但我們沒有,所以才要訓 verifier;紫色是 supervised,假設有一大批標籤可以學權重;藍色是 unsupervised,每個資料集只用 1% 的訓練標籤;橘色是 naive ensemble,直接平均,但還是先濾掉爛的。這幾條都明顯贏過 majority voting,也贏過 multi-agent verification。MAV 是 prompt 一堆 LLM,依照不同面向替一份回應打分,本質上是 rubric 式的做法,在兩個設定裡不比 majority voting 好,甚至更差。

8B 的系統站上 70B 的位置,然後把它蒸餾成 400M

難題上的準確率從四成多被拉到七成以上,對上的是 o3-mini 那個等級。8B 的 generator,Llama 3.1 8B instruct,配上 8B 以下的 verifier,在這些資料集上平均 70%,講者的說法是這顆 8B 模型靠 inference scaling 就被拉到接近 70B 等級模型做 majority voting 的水準;把同樣的生成加驗證套到 70B 等級的模型上,平均 86.2%,跟 o3-mini 這種不同量級的專有模型差不多。她提醒,這張圖量的是整個系統最終的準確率,不是 coverage,跟上一講那些 coverage 曲線不一樣。

集成很花錢。每一份解答都要跑一整排 verifier 才有分數可以平均,如果每題是一百份解答,乘上去很可觀。他們的做法是把 Weave 訓練一次,再用 distillation 壓進一顆很小的模型:4 億參數,原始的在 7B 這個量級。蒸餾版保住原本那一大團 verifier 97% 的準確率,測試時的算力少 99% 以上。兩個版本都開源,checkpoint 也都放出來了,拿去做 Agent 或 test-time scaling 的專案都可以。

效率圖上,淺藍是蒸餾版,深藍是原始 Weave,橫軸是花掉的總 inference compute,縱軸是成功率。蒸餾版明顯省;原始 Weave 因為準確率到得了比較高的位置,在那個水準上反而比 naive ensemble 與 majority voting 更省 FLOP。

課收在 pass@1,跟一個還沒回答的架構問題

四篇論文是一條四年的路。verification 同時改進訓練與推論的結果,process reward 比 outcome reward 更有用,但最好兩個併用。verifier 吃資料,資料越多越好,而且可以拿去 RL fine-tune generator。Weave 走的是另一條,用 weak supervision 在一群 verifier 上做最佳化,test-time scaling 的方式是加更多 verifier,不是把同一顆 verifier 多取樣幾次,最後還能蒸餾掉。

課堂最後把鏡頭拉遠。這些 benchmark 幾乎都是數學與推理,還有哪裡可以做?講者說 coding 很有趣,GPQA 那些 benchmark 裡本來就有些程式題,不全是數學。她提到接下來要講的 CodeMonkeys,做法是不直接訓練 verifier,而是讓模型在測試時自己生 unit test,那些 unit test 就變成 verifier。她也認為驗證對任何推理任務都有用。

reasoning model 會不會讓這套過時?不會。這一類模型的訓練本來就是生推理步驟、拿 reward、跑 RL 迴圈、把正面的軌跡留下來當下一輪的資料;test-time scaling 已經被吃進資料生成裡。多取樣還是能讓它們探索到解空間裡更多地方。

那未來會不會變成取樣只用來生訓練資料,測試時就問一次?講者說這正是想去的方向,模型要強到 pass@1 就對。張力在另一頭:把 log prob 壓得太尖、只往一個答案收斂,創造力與解答的多樣性可能一起被弄丟;她說現在反而喜歡那些思考方式有創意、有多樣性的模型,這是想保留的特質。

最後一個沒答完的問題是架構。generator 跟 verifier 該不該同一家族、同一量級?講者說這是個好題目。一般來說模型比較喜歡自己家族的生成結果,也比較懂自己那套解讀方式;有一篇論文講某些模型用不同類別的 verifier 反而更好,但同尺寸同家族與不同尺寸不同家族到底差在哪,她還沒看到有人專門研究。

〈Stanford CS329A Self-Improving AI Agents〉-EP-Part 1 | Course Overview

https://www.youtube.com/watch?v=6YnLB0XbTnI

CS329A 的第一堂課,講者花了大半時間講過去五年這條線怎麼走過來。2018 到 2024 年,大家靠更多算力、更多資料、更多參數,把 test loss 一路壓下去;2024 年前後這條路開始飽和,下一個把模型變強的來源搬到了推論端:同一個模型不動,讓它多生幾個答案,再用 verifier 把對的那個挑出來,挑出來的東西接回訓練,就變成自我改進的迴圈。agent 則是把單輪的 chat 拉長成多步驟的真實任務,要它自己規劃、動手、看回饋、決定什麼時候停。這門課要處理的,是這條鏈上每一段還卡在哪裡。

課是秋季班第一堂。台上兩位講者是 Akanksha 與 Azalia Mirhoseini。Akanksha 是史丹佛的兼任教授,同時在 Reflection AI 做研究;Azalia 是資工系助理教授。兩人是當年在 Google Brain 認識的,後來都在 Google DeepMind,Azalia 另外在 Anthropic 做過 Claude。這是這門課第二次開,教材與課程進行方式都改過。

2018 到 2024:三條曲線,一條往下掉的 loss

GPT-3 之後最讓人吃驚的事很單純:參數變多,模型就變好。BERT 和 T5 已經是不錯的模型,但參數加上去之後,表現是另一個檔次。這件事後來被寫成一組 scaling law,畫成三張圖,x 軸分別是 compute、資料集大小、參數量,y 軸都是 test loss,三條線一致往右下走。這是 GPT-3 之後 ChatGPT、PaLM、Gemini 那一整代模型的共同基礎。

模型尺寸的實際演進,講者也列了一輪:BART 3.4 億個參數,GPT-2 15 億,GPT-3 1750 億,PaLM 5400 億,GPT-4 外界估計已經到上兆。2018 到 2024 年,這條線幾乎是照指數在長,large 這個字說的就是它一直在變大。講者自己也說,這張圖有點過時了;而這條路在最近一年開始碰到某種飽和點。

變大之後,benchmark 成績持續變好,也冒出了以前沒見過的能力。few-shot learning 是一個,以前要為一個特定領域微調一個模型,現在只要給幾個例子,它就能照著同樣的格式推理,做原型變得非常快;emergent behavior 是另一個,某些能力只在夠大的模型上才冒出來。講者順手把 zero-shot 與 few-shot 分清楚:只給任務描述(例如 translate English to French)然後直接問答案,是 zero-shot;描述之外再附幾個範例,是 few-shot。這兩個能力是 GPT-3、PaLM 那一代解鎖的,後面的推理進展可以說是從這裡長出來的。

CoT 不是誰設計出來的,是模型變大之後冒出來的

scaling law 是可以預測的曲線,但有些行為是模型變大之後才出現,事前沒人預測得到。Azalia 說,這裡面最重要的是 chain of thought。

她用的例子是一個小學數學題:Roger 有五顆網球,又買了兩罐,每罐三顆,總共幾顆?一種 prompt 是只給答案 11;另一種是把過程寫出來,5 加上 2×3 等於 11。把推理過程示範過一次,模型就比較知道怎麼走到答案,也能把這個過程套到新題目上。這題現在任何 10 億參數的模型都會做,不需要範例、也不需要 CoT;但 CoT 這個性質一路留到現在,是這一年 reasoning model 與 thinking model 進展的關鍵。

它跟模型大小有關。LaMDA 8B、當時 GPT 系列大約 7B 的版本,套上 CoT 幾乎沒差;要 PaLM 這種規模的模型才開始吃到好處。其他 emergent 能力也是這樣,模組化算術、字母重排(unscramble)這類題目,要在某個尺寸之上才突然會做。講者說,frontier lab 之所以還願意繼續推 scaling law,就是為了這些現在還看不到、但遲早會冒出來的能力。

這些能力不是被設計出來的。Akanksha 的說法是,當初把難題丟給模型,是看到「把推理寫出來」之後表現變好才發現的。第一個給出跡象的是 GSM8K 那篇論文,到了 PaLM 這種規模才變成一件大事,其中一個讓人印象深刻的例子是它會解釋笑話。Azalia 補了一個區分:CoT 本身是 emergent,但今天的 reasoning model 是被訓練成要思考的,模型會慢慢收斂到「知道什麼時候該想很久、什麼時候不必」。

ChatGPT 那一跳:pre-training 之上的三步

ChatGPT 2022 年 11 月發表,五天達到一百萬個使用者,比先前那些知名服務都快。Azalia 說,除了把參數變大,還有兩塊創新是它跟 GPT-3 拉開差距的關鍵:instruction tuning 與 RLHF。她把整條管線從頭走了一遍。

pre-training 是最簡單的一步,就是拿各種文本與資料訓練模型預測下一個 token。這樣練出來的模型讀過整個網路與書本,但沒有是非概念,只有對世界的統計知識,也不特別會照指令走。接著是把模型對齊人類偏好:用大量人工整理的高品質資料(書、創意散文,企業願意花幾百萬甚至上億美元買的那種)繼續做 next-token prediction 的微調,把模型往人類的目標與價值推。講者強調,對齊到現在都還是沒有被解決的大問題。

再來是 instruction tuning。資料是 instruction 加上問答配對,來源是人工產的、模板產的,加上合成資料;除了單純的問答,也有 CoT 式的 fine-tuning,把解題過程與答案一起示範給模型。這個階段的資料品質與涵蓋廣度,直接決定模型最後的品質。走到這裡,模型已經很接近今天的樣子:能來回對話,知道怎麼理解一個問題、怎麼走一段流程給出答案。

最後一步是 RLHF,跟前面最大的差別是資料與目標函數的產生方式。不再是「題目配標準答案」的監督式資料,而是請人(有時是專家,有時是一般人)對模型的產出評分,做出一個 reward model,再用它引導 LLM 往「reward model 說好」的方向走。評分維度可以是正確性、helpfulness、specificity、無害性,看你在意什麼就給哪個維度多少權重。這幾步合起來,就是 ChatGPT 跟 GPT-3 之前那些模型的差別。

推論端也要 scaling:一萬個樣本,一顆 verifier

一年半以前,pre-training 加 fine-tuning 是主要戰場;現在 inference 也是能力的前沿。Azalia 說,這條線她實驗室去年夏天就開始做了,專案叫 Large Language Monkeys,靈感來自無限猴子定理:讓猴子一直打字,總有一天會打出莎士比亞。她們把 LLM 當那隻猴子:同一個題目問很多次(parallel sampling),再靠一個 verifier 或選擇機制挑出對的那個當輸出。verifier 可以是 unit test,程式題跑測試,看哪一份程式碼全過。

這件事可行的原因是模型的生成不是決定性的,同一個 prompt 每次答案都不一樣,而 temperature 可以控制變異的程度。實驗在 math 與 coding benchmark 上把每題的樣本數從 1 拉到 10,000,量的是 coverage,也就是至少有一個樣本解對的比例。結果是 Llama 3 8B 與 70B 在只給一個樣本時都比 GPT-4o 差,樣本數一多,兩者都反超 GPT-4o。講者的說法是,模型知道的其實比只問它一次拿到的多很多。有些題目一萬個樣本裡只有三、四個是對的,這也說明了把 inference 拉大有多重要。

有兩個邊界要講清楚。verifier 只在可驗證的領域好用;沒有 verifier 的地方,得靠 LLM-as-judge、把 LLM 當 reward function,或讓 LLM 拿工具去驗,這門課有一整堂在講 verifier。另外,temperature 不是越高越好,太高會變亂碼,一般超過 1.2 就不太行,想要更多樣性得用別的方法。至於延遲,平行採樣的好處是可以同時跑,latency 相對不是問題,真正的取捨在成本,而成本跟題目的類型與複雜度有關。這不是暴力搜尋:可能答案的空間比一萬大得多,而且答案得先被模型生出來才存在,10,000 個樣本其實算是取樣效率很高,尤其 IMO 等級的難題,一顆 7B 的 Llama 偶爾也能解出來。

推理模型:把推論端的算力接回訓練

DeepSeek、Gemini 的 thinking 系列,核心創新是把 fine-tuning 跟 test-time scaling 接在一起。有了 test-time scaling,模型本身就是一台合成資料的引擎:數學題有標準答案,就讓模型在推論時生出一堆通往那個答案的推理;程式題就生出大量可用的高品質資料。這些產出回頭變成訓練集,拿去微調模型。這就是「自我改進」最核心的一塊,Azalia 說這是她們最興奮的地方,因為 test-time scaling 看起來沒有明顯的天花板。

O1 則示範了另一件事:test-time compute 拉高,pass@1 在 AIME(一組很難的數學題)上以對數線性往上走。過去這種曲線只有訓練端看得到,現在不改變參數量,光在推論端加算力也成立。

推理模型在做的事,講者用人類來比擬:難題要想比較久、要試不同策略。它會先分析題目要什麼,再把大題拆成好處理的小題;中間會自己評估,跑個測試、按個計算機,或自己判斷答案再拿回饋調整;這條路走不通就回溯,換一條替代方案。其中一部分是人工整理的訓練資料教會模型的,但很大一部分是模型在 fine-tuning 與 RL 的過程裡,從合成資料自己學到的。

課堂上播了 O1 寫 bash 腳本把矩陣轉置的例子。模型先自言自語:使用者要的是 bash script,先弄清楚輸入輸出的格式;接著拆解:解析輸入、把矩陣建成 array of arrays;中間還出現「等等,這裡的形式不對」這種自我修正。Azalia 說,這跟 prompt 裡的 CoT 差別在於,這串思考是模型自己生的。她也比較了推理模型與 GPT-4o:數學計算、資料分析、程式設計這類推理任務上全面勝出,個人寫作、文字編輯這類就不一定。

至於推理模型的進步,是「把思考講出來」這個動作造成的,還是資料造成的,課堂上也討論過。Akanksha 的說法是,pre-training 完的 base model 其實已經會做一些推理,但它會生出很多條不同的推理鏈,而且不知道哪一條對;訓練端與推論端的 scaling,有一大部分在教它「哪一條是對的」,所以 pass@1 往上走,對照組是 repeated sampling 的 pass@K 或 coverage。

拆成兩顆模型的話,推理鏈通常交給大的那一顆,再讓小的模型把答案整理出來;推理能力本來就是隨模型大小上升的。有意思的是,模型比較喜歡自己的推理痕跡,就算是更好的模型產的也一樣。至於推理模型是怎麼被教會推理的,Akanksha 直說沒有公開研究講清楚,大概是兩者都有:base model 本來就有思考的底子,instruction tuning 的資料裡又充滿 CoT 的示範,剩下的靠模型自己泛化;課程會講 outcome reward model 與 process reward model 怎麼給回饋。

從 chat 到 agent:目標、工具、驗證、停手

Akanksha 把線拉到 agent。她說,LLM 不管是當 chatbot 還是 reasoning model,基本還是單輪、還是 chat 格式:好玩,但沒有真的替你把一件事做完。這一年的變化是 Claude Code、Deep Research 這類 agent 開始跑真實世界的工作流。她舉的例子是,如果你要到史丹佛上一門課、想找個地方住一年,agent 會去看很多網站、做分析,最後給你幾個選項的優缺點。這種事以前做不到。Claude Code 或 OpenAI 的 Codex 也一樣:用英文下指令,它就改檔案、想測試案例,已經是工程師日常的生產力工具。

chatbot 跟 agent 的分界,她定義得很清楚:agent 拿到一個目標,會自己規劃步驟、跟環境互動、根據回饋修正,直到達成目標,或回來告訴你做不到。有目標、有動作、有回饋、知道自己什麼時候該停,這四件事湊齊才算。過程中它要用模型以外的工具、從工具拿輸入,還要有某種記憶來追蹤任務。

現實是,簡單的情境(例如 deep research)可以端到端做完,但多數場景還是很靜態的工作流。今天存在的東西比較接近 agentic workflow:一顆模型給出解法,另一顆當評審決定收不收;或是像 deep research 那樣,對多個輸入平行呼叫 LLM,再把結果聚合成一份摘要。她形容投影片上的方塊和箭頭簡化到有點卡通,但業界多半真的是這樣:與其做開放式的迴圈,不如先照人類的做法把手繪的流程圖搭起來,回饋交給 LLM evaluator。

她把工作流拆成幾種呼叫:問模型、用 verifier 或 judge 收件(也就是 LLM-as-judge),需要的時候再叫搜尋、查天氣這類 tool call,最後把它們編排起來。最簡單的編排是 prompt chaining,把任務拆成子任務串起來;難度分流(routing)決定要跑複雜還是簡單的流程;平行化適合 deep research 這類多個關鍵字同時查再聚合的工作;orchestrator 則是用一顆中央的 LLM 做規劃,Claude Code 就有一個先產出計畫、再照計畫發後續 LLM call 的結構。這些工作流對模型的要求是一組新的能力:更會規劃、更會多步推理,還要更會自我改進,也就是犯錯之後能自己修回來。

coding agent 的迴圈是課堂上最具體的例子:LM agent 透過終端機跟電腦互動,你叫它實作一個測試,它去翻 repo、搜檔案、看檔案、改行,然後在終端機跑一串指令;看輸出再決定要去改另一個檔案,還是去看別的檔案。Akanksha 說這個迴圈去年還不太可靠,這一陣子才開始穩定。架構其實沒大改,改變的是模型本身與 RL:可驗證獎勵的 RL 有效,training-time scaling 有效,而且自我改進的迴路會接手,因為模型現在生得出測試,測試又可以拿來驗模型自己生的程式碼。去年課程講過的 Code Monkeys 就是這個做法:讓模型為自己產出的程式碼生 unit test,再看這些測試有沒有讓東西變好。

卡點在驗證:generator-verifier gap

Azalia 把問題講白:如果有好的 verifier,模型就能生出對的程式碼;問題是要怎麼得到好的 verifier。Akanksha 接著講 generator-verifier gap:模型很容易生出一堆胡說八道,或是一堆看起來合理的推理痕跡、看起來有用的內容;但到底有沒有用,需要回饋迴路才知道。創意寫作能拿到多少回饋?到最後人類回饋會變成瓶頸。有客觀回饋的領域可以持續進步,但要拿到 robust 的驗證很難,而驗證一直是這個領域的瓶頸之一。Azalia 在課堂上會講她實驗室的一篇論文,談怎麼把不同的 verifier 組合起來。

至於 RL 有用還是 pre-training 的資料有用,課堂上沒有共識,能確定的是兩邊都有幫助。有個直覺是這樣:如果 pre-training 已經讓模型在大量樣本裡至少生得出一個正確答案,那 RL 給的回饋應該只是教它把那個答案挑出來,也就是提升 pass@1(只問一次就答對的機率),不該改變模型本身的能力才對。Akanksha 說這個迴圈還沒有被完全理解,一邊開始商業化、一邊還有很多研究空間,但也有一些跡象顯示,持續做 RL 確實能繼續把模型變好。

Agent 已經在這些地方工作

課堂後半把 agent 的用途講得很實在。重複性高的工作最適合:code migration、版本升級、重構 codebase,還有資料清理與資料倉儲搬遷這類工程。客服是另一個大宗,即時轉錄、knowledge assist(客服不必背下所有知識,讓 LLM 查出來並把相關文章推到面前)、通話摘要,每一段都能拆給 LLM,端到端的部分也開始出現。再往上一層是研究報告:以前要自己做文獻回顧、逐篇摘要、再合成,現在可以整包交出去;課堂舉的例子是 2022 冬季奧運開幕式,agent 會先找出該讀哪些參考資料、排出大綱、逐篇摘要,最後合成一篇長文,這學期有一份作業就是做這件事。最遠的一格是 AI scientist:從發想、實驗迭代到論文撰寫都插手。講者自己也說模型會幻覺,但讀過整個網路讓它常常提出框外的點子,當腦力激盪的夥伴意外好用。

O3 這類模型在訓練裡看過大量完整的任務軌跡,所以能自己規劃、推理、多步推理,再給出結論;而把一個目標交出去的時候,第一件事往往是把使用者的意圖問清楚,因為需求常常沒講清楚,連「怎麼算做完」都得先講好。

課的後半,與還沒解完的那一題

課程的後半回到課堂規矩:這學期三次作業加一個專案,各佔一半成績,專案二到四個人一組,海報發表排在 12 月 12 日下午;客座講師會找 frontier lab 的人來講 post-training 的演變、機器人上的多模態 agent 這類題目。

整堂課收在一個還沒解完的問題上:驗證。模型生得出東西已經不是瓶頸,能不能便宜、可靠地判定它生出來的東西對不對,才是現在的瓶頸。驗證這一塊沒有進展,generator-verifier gap 就會一直是這條鏈上最窄的一段。

〈Stanford CS329A Self-Improving AI Agents〉-EP-Part 2 | Test-Time Compute Scaling

https://www.youtube.com/watch?v=-Ggc37xLj_Y

模型參數不動、也不做任何微調,光是把 inference 階段的算力加上去,同一顆模型就能變強。但這條路能拿回多少,取決於你有沒有辦法在一堆生成出來的答案裡,認出哪一個是對的。Stanford CS329A 第二講講的就是這兩句話,前半段在證明模型其實早就知道答案,後半段在講為什麼你常常拿不回來。

訓練有三個階段,inference 是第三條可以加的軸

LLM 的開發可以拆成三段。pretraining 歷史上最貴:跑好幾個月、用掉一大堆 GPU、吃掉上兆個資料 token。fine-tuning 通常輕得多,用得上的資料量跟算力都少了幾個數量級。inference 是拿到訓練好的模型之後真正去用它,過去的用法很省,使用者丟一個 query,模型回一個答案,一次來回就結束,每次 inference 幾乎不花算力。

新的 paradigm 換了另一種花法。同一個 agent 可以離線工作,生出很多 token,一遍一遍修自己的輸出。講者把這形容成一個新的旋鈕:訓練結束之後,你還有一個地方可以把能力往上加。上一堂課講過 pretraining 的 scaling law,test loss 對資料量、算力、參數量有一條可以預測的曲線,換 setup 方程式會變,但方向是可預測的;這一堂要問的是 inference 這一端有沒有同樣的東西。

同一題問一千次,小模型可以反超大模型

先回頭講 large language monkeys。無限猴子定理的版本是這樣:同一顆 LLM、同一個問題,不要只問一次,問十次、一百次,然後讓一個 verifier 指出哪一份回應是對的,那一份就當系統的輸出。

理由是模型的生成不是決定性的。Llama 3 的 8B 或 7B 單次作答打不贏 GPT-4o,但同一題問很多次、再從候選裡挑出對的那一個,小模型可以顯著變好,在一些任務上反超這些更大、更封閉的模型。講者的說法是,這些小模型其實已經知道答案,只是第一次不告訴你;重複取樣是把已經存在的答案挖出來。

這個做法在硬數學、程式、問答,以及 SWE-bench 這類 agentic benchmark 上都成立。SWE-bench 模擬的是軟體工程師改程式、生出 patch 的工作。圖上量的是 coverage,也就是至少有一個樣本解對的題目比例,橫軸是樣本數,從一到一千。講者說圖上那顆 DeepSeek(她記得是 V3)在一千個樣本之後,解掉的程式與軟體工程題目比 Claude 3.5 或 o1 Preview 還多。這件事在程式題上特別有用:如果有 unit test 可以指出哪一個樣本是對的,就得到一條端到端的自動化路徑,把一顆開源模型變成更強的系統,完全不用重新訓練。

Coverage 有自己的 scaling law,背後是一條很長的難題尾巴

pretraining 的 scaling law 用來預測 test loss,test-time compute 也可以定義一條類似的關係:coverage 跟平行取樣的樣本數之間是一條 exponential power law,係數 a、b 從實際曲線擬合出來。實驗跨了 Llama 3 的 8B、7B,以及 Gemma、Pythia 這些模型,參數從 7,000 萬到 700 億,也跨了好幾個任務領域,預測曲線大致貼著實際量到的 coverage 走,連 7,000 萬參數的模型都看得到同樣的行為。實務上的意思很直接:你可以先算要多少樣本、配多少資源,才達到你要的 coverage。

為什麼一堆單題的指數曲線合起來會變成 power law,講者也解釋了。單一題目 pass@1 的機率是 p,那 k 個樣本全部答錯的機率是 1 減 p 連乘 k 次,至少一個答對的機率就是 1 減掉它,這是單題的算法。換到一整組題目,要出現他們觀察到的 power law,必要且充分條件是題目裡有一條很長的難題尾巴,也就是 pass@1 非常低的那些題。實際去看資料,形狀就是這樣:一大票簡單題在 pass@1 就被解掉,題目越難 pass@1 越低,最後拖出一條長尾。

對整個產業來說,這個發現把花錢的位置多開了一個。以前公司把幾億、幾十億美元壓在 pretraining,fine-tuning 少很多,每次 inference 幾乎像不用錢;現在 inference compute 本身可以是一筆大開銷,而且可以離線做:把 agent 放出去解一個問題,讓它一直生 token、一直把答案變好。講者說,test-time scaling 讓算力有第二個可以預測地花掉的地方。

驗證先行:有些領域天生驗得動

重複取樣要真的有用,前提是系統挑得出對的那一份,所以自動驗證是整件事的瓶頸。有些領域的驗證天生比別的領域簡單。

形式數學可以用 formal proof 的軟體跑,逐步檢查證明對不對。程式題可以寫 unit test,而寫一個 unit test 通常比寫整個程式簡單得多,這件事甚至交給人做就好。講者特別興奮的一個方向是 AI as a compiler:用 LLM 把 PyTorch 這種原始碼編譯成 CUDA 這類更貼近硬體、為 GPU 最佳化的低階語言,再比對兩邊在同樣輸入下的輸出是不是一樣。你不需要判斷 CUDA 寫得好不好,只要看行為等不等價。實驗室有一套叫 Kernel Bench 的 CUDA 生成 benchmark,樣本數往上加,coverage 就跟著往上,用的就是這個等價性當 perfect verifier。同樣的道理可以推到任何兩種語言之間的翻譯:Python、C++ 跟 Java 互轉,等價性比正確性容易量。

Generation-verification gap:生得出來,挑不出來

沒有 verifier 的領域就是另一回事。講者比較了幾種 best-of-N 的選法:majority voting,也就是選出現次數最多的那個答案;用模型排序;用 reward model 打分。圖上綠線是 majority voting,藍線是假設有一個 perfect verifier 的 coverage,兩條線之間差了一大截。majority voting 大概在 10 個或 50 個樣本之後就平掉了,coverage 卻還在往上走,而且這個差距在 MATH 這種比較難的資料集上比在 GSM8K 上更明顯。換成 reward model 打分數、取最高分那一份,也還是留下一大段沒用到。

這個落差就是講者口中的 generation-verification gap。生成端生得出很多好答案,驗證端決定你實際能拿回多少。原因出在難題上:在一千個、一萬個樣本裡,最難的那些題可能只對過一次、兩次、三次,majority voting 根本選不到這種罕見的正確答案。就算在比較簡單的 GSM8K 上,也有些難題的正確答案出現頻率低到讓驗證變得很難,你要怎麼找到它們?

verifier 的品質自己也是變數。課堂上有人問,量到的 coverage 到底可不可信。講者說數學題的答案他們人工檢查過一輪,準確率在九成多,她給的數字是 97、98% 上下;但 unit test 沒覆蓋到的地方就會漏,所以 verifier 有多好,直接決定這個 coverage 數字有多少是真的。那組每題一萬個樣本的資料集放在 Hugging Face 上,講者說想把 generation-verification gap 縮小的人,這可以當課程專案。

課堂討論裡學生提了幾個方向。有人提 hybrid 架構,用 knowledge graph 加上 advanced RAG 的文件,平常先靠知識庫回答,覺得不夠準才去查 RAG,因為 RAG 本身也吃延遲,目標是降低對 verifier 的依賴。有人提 self-study:先讓模型去探索一個領域、把學到的東西整理起來,再進入平行的解題取樣;講者說後面的課會講 self-study、search 跟 tool use 這些重複取樣以外的方法。也有人反過來想:如果確認一個答案是對的很貴,那剔除明顯錯的可能便宜得多,用模擬、外部工具或另一顆模型來過濾。至於「生一萬個 verifier 來多數決」的提議,講者說他們做過的版本是 weakly supervised 的 verifier 集成,十顆、二十顆,不是一萬顆,方向有趣但算力上很貴。

平行取樣之外還有序列修改,reward model 決定算力往哪走

接下來講者換到另一篇論文,標題直白:scaling LLM test time compute optimally can be more effective than scaling model parameters。她把 test-time scaling 拆成幾件事:平行取樣是一種,讓模型對同一個輸入獨立生好幾個答案;序列修改是另一種,模型先提出一個初步做法,從不同角度看它、一直改到可以回答為止。論文裡的序列修改是靠 prompting 誘導出來的,今天的 reasoning model 因為被訓練過,內部自己就會出現這種行為。

兩種可以混。最簡單的版本是生兩個平行的候選,各自做序列修改,最後用 PRM 或 ORM 挑比較好的那一個。講者說某種組合通常比只用一種好,但沒有通用的分配比例,這塊還是開放問題。

reward model 分成兩種。outcome reward model,簡稱 ORM,看最後的答案打分,best-of-N 就是挑分數最高的那一份。process reward model,簡稱 PRM,打的是解題過程裡每一步的分數。這裡的 step 不是 token,而是一個在智識上完整的段落,或一句話,看你怎麼定義。訓練資料可以找人在每一步標好或壞,用這些標註把 PRM 訓出來。PRM 在自己訓練領域附近的任務上表現最好,但因為它本質上是 language model,跨任務還是會有一點 generalization。實務上有現成的 PRM 可以拿來用在你的任務上,也可以用自己的資料自己訓一顆 PRM 跟 ORM。

PRM 可以拿來引導搜尋。課堂上示範的是 beam search:每一層給四個樣本的預算,PRM 挑分數最高的兩條分支,從這兩條繼續往下展,也可以用一個門檻決定要留哪些。這樣做會把沒希望的路徑剪掉,算力集中在有機會的分支上。

難度決定算力該怎麼分

講者引的論文用一個數學資料集,大約一萬兩千題訓練、500 題測試,難度用 pass@1 定義,再切成五個 bin。研究團隊自己訓了 PRM,也微調了一顆專門做修改的模型;不過講者補了一句,現在只要是 instruction-tuned 的模型,prompt 叫它修改,它就會改。

結果比的是 majority voting、ORM、PRM 引導,以及各種混合方式,目標是找出在每個準確度水準下,最少需要多少 generation 預算。容易的題目那一側,sequential 對 parallel 的比例越高(圖上顏色最深的那塊)表現越好。題目越難,最適比例就越難講,甚至從第四個 bin 到第五個 bin 就換了答案。課堂上有人把直覺講出來:容易的題目有很多條路都通,所以一條路慢慢改就好;難的題目可能只有少數幾條路走得通,那就得多開幾條平行路徑去撞。講者說這是個直覺上合理的講法。

還有一個好處是逐步驗證。有 PRM 之後,違反限制條件的分支可以在還沒把算力花下去之前就剪掉。

Test-time scaling 補位 pretraining,但補不到最難的那一格

這篇論文還有一個觀察,講者也說這到今天為止還是成立:對容易跟中等的題目來說,多加測試階段的算力,比多花 pretraining 的算力划算。圖上把 inference token 對 pretraining token 的比例畫出來,容易跟中等的題目這個比例是正的。但最難的題目換了答案:即使給一個相當大的 inference 預算,模型更大、pretraining 更多的那一邊還是贏。講者提醒,不要因此下結論說 pretraining 做完了、只要一直從手上的模型取樣就好。

課堂上有人問到帳要怎麼算,因為 pretraining 付一次,inference scaling 是每碰到一個新題目就再付一次。講者同意這個區分,但她補了另一面:不是每個組織都 pretrain 得起一顆大模型,那條路太貴;test-time scaling 對很多題目來說是可行、負擔得起的那一條,即使每次都要重付。開源模型跟小模型會隨著測試階段算力加得越多而越有用,這件事在她們實驗室很多研究裡都看到,可是最難的那些問題,還是 frontier model 做得比較好。

有人問,那能不能把一顆小模型變成難題的專家?講者把兩件事分開:針對一組特定題目微調,當然可以變好;但論文比的是通用的做法,資料是一般性的資料,訓練配方也是大家常用的那一套,比的是一般情況下的表現。

Archon:把 inference 的算力分配當成架構搜尋問題

課堂後半是重頭戲,Archon,一篇把 inference-time scaling 當成架構搜尋的論文,共同作者之一是 Yurii。命題是這樣:不同的 inference-time 技巧跟不同的模型可以混搭,那就把「正確性對成本」的那條前緣當成最佳化目標,去找出怎麼搭最好。

系統的輸入有四樣:要最佳化的目標 benchmark、inference call 的預算、手上有哪些 LLM、以及有哪些 inference-time 技巧可以用。中間的 optimizer 叫 ITAS,inference time architecture search,工作是在預算內把模型跟操作排成一個架構。輸出可能同時包含平行生成、序列處理、排序、批評、驗證,以及 fusion。

操作本身有幾種。generation 就是從模型取樣一個或好幾個回應。fusion 是把原始問題跟 k 個候選答案一起給 LLM,請它把所有候選裡的資訊合成一個最終答案。critic 描述一份回應的強項跟弱點。ranker 用 prompt 讓模型把候選排序。verifier 給一份回應打分或做選擇,順便講它為什麼這樣判斷。還有 unit test generation 跟 unit test evaluation:前者生出檢查用的 test;後者更妙,是把答案跟生成的 test 一起給模型,請模型判斷這份答案過不過,test 不一定要真的被執行。這些操作全是 prompting-based,底下的 LLM 沒有為了這些角色被特別訓練過。

舉例來說,一題「檢查括號有沒有配對」的程式題,模型可以生出「奇數個括號就輸出 No」這種 unit test,也可以生出「遇到右括號時,必須對上最近一個還沒配對的左括號」這種 test,甚至可以把實作這些 test 的程式碼也一起生出來。

Fusion 可以贏過 oracle selection

講者用一組實驗說明這些操作各自的份量。手上有 1 到 10 份候選回答時,比較幾種用法:隨機挑一份、請模型排序後挑第一名、用 oracle 挑出最好的那一份、把全部候選丟給模型 fusion 成一個新答案,以及先篩到前五名再 fusion。

排序贏過隨機,oracle 贏過模型排序,這兩個都不意外。有意思的是 fusion:它生出來的答案,比 oracle 從現有候選裡挑最好的那一個還要好。先篩選再 fusion 的分數又更高。講者的解釋是,fusion 不是從幾個答案裡選一個,它可以把散在好幾個不完美候選裡的資訊合起來。候選換成不同模型產出的(集成從最好那顆模型開始,一顆一顆加進來),同樣的趨勢還在,只是隨機選那條線變得更差,因為原本那顆模型是這一群裡比較好的。

加了層的 inference 架構,答案一層比一層準

Archon 搜的是有層次的架構:可能先讓幾個模型各自生成,接著上 critic,再排序,然後好幾個 fuser,中間再穿插一輪 critic 或 ranker,最後收在一個 final fusion。這種搜尋很貴,因為評估一個架構要跑很多次 inference call,所以他們先做了一輪預處理把搜尋空間縮小:第一層一定是 generation;一層只准放一種技巧;critic 一定排在 ranker 或 fuser 前面;unit test generator 後面一定要接 evaluator。離線實驗也看到 generation、critique、ranker、refusion 這串順序效果特別好,就把它保留在搜尋空間裡。

最佳化的目標是準確度對模型呼叫次數,另外可以加上手上有哪些模型、inference 時間、inference 成本預算這些條件。他們用 Bayesian optimization 搜,比 greedy 或隨機搜尋更省樣本,用更少的架構設定就走到最後的結果。

在程式題上,搜出來的一個架構是先生一大堆樣本、生 unit test,然後評估。架構的層數變多、排得仔細,準確度就往上。講者舉的例子是一個用不同模型的集成,三層 critic 跟 fuser,最後再一個 final fuser;它不只贏過「最好的模型只問一次」,也贏過「最好那顆模型問八次、接一層 fusion」。講者把這比成 deep learning 裡加層。她不主張任意加深都有用,但小心選過的 inference layer,確實讓答案在許多任務上一層比一層準。

14.1% 的 pass@1,跟一個還沒分配完的問題

Archon 最後只吐出一個回應,所以量的是 pass@1。它可以是針對單一任務最佳化的版本,也可以是跨多個任務訓練出來的通用版本;通用版本在最佳化時沒見過的任務上也轉移得過去。結果是只用開源模型,在多個任務上打平或超過當時的封閉源碼 frontier model,幅度不小。講者給的平均數字是:在 instruction following、推理、數學、程式這幾類題目上,Archon 的 pass@1 平均比 GPT-4o 或 Claude 3.5 Sonnet 高 14.1%。

課收在一個還沒解完的問題上。講者的說法是,inference token 該被當成一種可以分配的資源,真正難的是怎麼分:平行探索、序列修改、驗證、剪枝、批評、排序、fusion,每一種都在搶同一筆預算,而哪一種該分到多少,目前沒有通用答案。