跳到正文
Hugging Face Blog·· 2026-08-25精選AI 評分62

Granite 4.2 大語言模型如何構建

Granite 4.2 LLMs: How They're Built

AI 導讀

IBM Granite 團隊詳述 Granite 4.2 推理模型系列的構建流程,涵蓋架構、訓練方法及評測結果。該系列有 3B、8B、30B 三種稠密、僅解碼器模型,均由 Granite-4.1 base models 後訓練;後者以約 15T tokens 預訓練,並透過五階段策略將上下文窗口延至 512K tokens。

推薦理由

文中並列三種規模共用的訓練主線,以及 8B、30B 額外加入真實環境 Agentic RL 的分支,可據此理解各規模訓練階段和智能體能力培養的差異。

正文 · 繁體中文

Granite 4.2 推理模型系列的技術實作詳解。

作者:Granite Team、IBM


重點摘要:Granite 4.2 是我們首個僅含稠密、decoder-only 推理 LLM 的系列,推出 3B、8B 和 30B 三種規模。這些模型由 Granite-4.1 基礎模型後訓練而成。Granite-4.1 基礎模型從零開始,以五階段策略在約 15T tokens 上預訓練,將上下文窗口延伸至 512K tokens,再以思維鏈、推理和代理軌跡資料作監督式微調,最後透過多階段強化學習 pipeline進行後訓練。此 pipeline 包含代理式 RL,讓 8B 和 30B 模型學習在真實沙盒環境內使用工具。所有模型均設有思考/非思考切換、針對簡單問題只耗用短暫推理預算的低力度思考模式,以及原生工具呼叫功能。所有 Granite 4.2 模型均以 Apache 2.0 授權發布。

連結:


概覽

Granite 4.2 是 Granite 語言模型系列中著重推理的版本。早期 Granite 版本擅長遵循指令,作為助手錶現出色;Granite 4.2 則加入明確的推理能力。每個模型都能在回答前產生思維鏈,亦可按任務所需的思考程度選用思考或非思考模式。介乎兩者之間的低力度模式只會為簡單問題分配短暫推理預算。

三種規模(3B、8B 和 30B)採用相同架構設計及訓練 pipeline(基礎模型、SFT,再到多階段 RL),只是在不同規模訓練。三者皆擅長推理和遵循指令。能力差異最明顯之處在於後訓練:8B 和 30B模型還會經過代理式 RL階段,學習作為代理操作:呼叫工具、編輯和執行程式碼、操作終端機,以及在真實環境中搜尋網絡。所有模型都支援原生工具呼叫。透過 OpenAI 相容端點(例如 vLLM)提供服務時,模型會以 OpenAI 函數呼叫格式輸出工具呼叫,可直接接入代理式 harness,無需額外轉接。Granite 4.2 亦支援 SGLang;即用配方請參閲 SGLang cookbook。

本文其餘部分會介紹整個建置過程:架構、預訓練、監督式微調、多階段 RL pipeline,以及結果。


模型架構

Granite 4.2 模型建基於 decoder-only 稠密 Transformer 架構,核心元件如下:

  • 注意力:Grouped Query Attention(GQA),設有 40 個注意力頭及 8 個 KV 頭
  • 位置嵌入:旋轉位置嵌入(RoPE),θ = 10,000,000
  • 前饋網絡:使用 SwiGLU 啟動函數的 MLP
  • 正規化:RMSNorm(ε = 1e-5)
  • 嵌入:輸入和輸出嵌入分開設定(不綁定)
  • 精度:bfloat16
元件 3B 稠密模型 8B 稠密模型 30B 稠密模型
嵌入維度 2560 4096 4096
層數 40 40 64
注意力頭大小 64 128 128
注意力頭數 40 32 32
KV 頭數 8 8 8
MLP 隱藏層大小 8192 12800 32768
MLP 啟動函數 SwiGLU SwiGLU SwiGLU
序列長度 131072 131072 131072
位置嵌入 RoPE RoPE RoPE
# 參數 3B 8B 30B

預訓練

Granite 4.2 模型由 Granite-4.1 基礎模型後訓練而成。Granite-4.1 基礎模型以五階段訓練策略,從零開始在約 15 trillion tokens 上訓練。Phase 1–2 進行基礎預訓練;Phase 3–4 使用質素逐步提高的資料退火進行中期訓練;Phase 5 則進行長上下文訓練,把上下文窗口延伸至 512K tokens。每個階段使用不同資料配比及學習率排程,逐步由廣泛的網絡規模資料轉向更精選、高質素來源。

預訓練配方大致沿用上一代;資料混合、階段排程和長上下文延伸的詳細説明,請參閲 Granite 4.1 網誌。


SFT:資料準備及品質控制

監督式微調(SFT)會把基礎模型轉化為可靠的指令遵循、推理及工具使用助手。SFT 資料混合包含代理式(31.6%)及非代理式(68.4%)資料,合共約 7.2 million 個樣本,約 100B tokens,其中約 65B 可用於訓練。

代理式語料涵蓋多個領域,包括軟件工程(SWE,69%)、工具呼叫(12.1%)、終端機使用(8.0%)、數學(3.5%)、搜尋(0.8%)及行動(0.2%)。這些樣本和軌跡由多種代理腳手架及 harness 生成,包括 OpenHands、OpenCode、Terminus-2、SWE-agent、OpenResearcher、MiniSWE、OpenSeeker、EnvScaler、Gemini CLI、Hermes、Codex 和 Goose。代理式資料結合開源資料集及我們自行合成的 RL 環境樣本,涵蓋多種代理與 harness 組合。

非代理式語料包括幾個主要類別:遵循指令(18.8%)、編碼(18.8%)、數學(14.6%)、多語言(7.0%)、科學(5.4%)、推理(3.0%)及安全性(0.8%)。

資料品質控制

樣本加入最終 SFT 資料混合前,我們會進行多階段品質控制。首先將不同來源的資料正規化,並重新格式化為一致的 OpenAI Chat 格式,統一不同資料集和腳手架的對話結構及工具互動方式。

然後使用 GPT-OSS-120B 和 Gemma 4 作為 LLM 評審,評估樣本質素。低分樣本,以及含有幻覺或虛構資料、無效工具互動、或呼叫工具清單中未定義函數的樣本,均會移除。適用時亦會採用多項針對特定資料集的啟發式規則,進一步提升質素並移除已知雜訊來源。

最後進行本地和全域去重。去重時會根據 tools 和 messages 欄位組合計算 SHA-256 雜湊,移除個別資料來源內及整體 SFT 資料混合中的重複樣本。

SFT 訓練詳情

首先對完整語料進行全域隨機洗牌,以減少排序造成的影響,並確保訓練期間不同領域的樣本充分混合。之後將洗牌後的語料分割成大小相同的 .parquet 分片,使用模型的 tokenizer 和 chat template 進行 token 化,並準備作大規模分散式訓練。

啟動最終大規模訓練前,我們會在具代表性的設定上調校超參數,測試學習率排程、初始學習率及預熱比例,以找出各模型規模均能穩定訓練的設定。最終訓練設定如下:

參數 值
運算資源 32–128 個節點(視模型規模而定),每個節點配備 4× Grace/GB200
序列長度(packed) 131,072(128K)
全域批次大小 128
學習率 1.0e-5,預熱後維持常數;Phase 2 為 3.0e-6
LR 預熱 train_iters 的 2.5%
訓練時長 約 2 個 epochs
平行處理 TP=2、PP=1、CP=4 或 CP=2

30B 模型的 Phase 2 SFT

30B 模型會額外進行第二階段 SFT,專門加強代理式編碼。此階段會提高代理式、SWE 和編碼資料的抽樣比例,增加它們對訓練分佈的實際影響;同時保留原始 SFT 語料約 16% 作重播資料。

之後以較低的 3.0e-6 學習率,對 30B 模型再微調約一個 epoch。這個針對性階段會增加模型接觸代理式編碼軌跡的機會,同時保留首階段 SFT 所建立的能力。


強化學習:多階段、多環境 pipeline

SFT 之後,我們會執行多階段、多環境強化學習 pipeline。我們不只執行單次 RL,而是讓模型執行一連串聚焦階段,涵蓋數學、程式碼、科學、遵循指令、工具使用和結構化輸出,之後再到軟件工程、終端機操作和網絡搜尋。每個階段都是獨立的 RL 執行,只針對一項能力,並以之前階段的檢查點作為 warm start。

Granite 4.2 staged RL curriculum

圖 1。分階段 RL 課程。所有規模均執行基礎 RL(可驗證獎勵 + 技能加強);只有 8B 和 30B 執行代理式 RL 階段(SWE → 終端機 → 搜尋)。所有模型最後均進行 RLHF。每個階段都是獨立的 GRPO 執行,並以上一個檢查點作 warm start。

訓練方法

每個階段都採用非同步 GRPO(Group Relative Policy Optimization),讓迴圈中的生成端和訓練端互不阻塞。一組生成工作者持續抽樣回應,並把完成的軌跡放進共用緩衝區;緩衝區累積足夠一個 step 的資料後,訓練端便取出該批資料、執行一次最佳化器步驟,再把更新後參數傳給生成工作者,期間不會暫停它們。更新可能在 rollout 中途生效,令單條軌跡由兩個相鄰版本的 policy 組成。我們容許這種情況,免得花資源避免它:工作者重用現有 KV cache,不會在每次更新後重建;唯一防護措施是限制它們最多隻比訓練端落後一次更新,以限制樣本偏離現行 policy 的程度。剩餘差異會在目標函數中透過截斷重要性抽樣處理,將訓練與生成 log-probability 比率限制在固定上限,避免少數過時 token 主導一次更新。

優勢值採用羣組相對方式,並設有leave-one-out 基準線:每個回應都與同一提示下抽取的其他樣本平均獎勵比較,因此無需另設 value network。以RLVR(第一個且執行時間最長的階段)為例:每個 step 配對256 個提示,每個提示抽取16 個回應,組成4,096 個樣本的批次;訓練端一次最佳化器步驟便會處理整批資料,然後才開始下一輪 rollout。後續階段沿用同一機制,只調整每個階段的具體設定,詳見下表。

RL 訓練設定

所有階段共用一組主要超參數,讓整個課程更容易執行和比較。以下參數在所有階段固定:

參數 值(各階段共用)
演算法 GRPO(不設 value network;採羣組相對優勢值)
訓練技術堆疊 NeMo-RL(Megatron-Core + vLLM)及 NeMo-Gym 環境
比率裁剪(最小/最大) 0.2 / 0.28
微批次大小 1
平行處理 Tensor 平行度 2–4;不使用 pipeline 或 context parallelism

各階段改變的是每次執行的設定形狀:每個 step 有多少提示和生成內容、上下文長度、是否執行代理迴圈,以及限制偏離參考 policy 的力度。以下列出30B模型各階段的準確設定:

階段 提示/step 生成數/提示 最大序列長度 rollout 回合數 KL LR
RLVR(×3) 256 16 64K 1 0 5e-7
IF 加強 256 16 64K 1 0 5e-7
程式碼加強 64 16 64K 1 0.05 5e-7
SWE 1 64 16 128K 1 0.01 5e-7
SWE 2 32 16 128K 128 0 5e-7
終端機 8 32 64K 64 0.01 1e-6
搜尋 32 16 128K 64 0.01 5e-7
RLHF 128 16 48K 1 0.05 5e-7

以上為 30B 模型參數。全域批次大小 = 每個 step 的提示數 × 每個提示的生成數(例如 RLVR 為 256 × 16 = 4096)。3B 和 8B 模型使用相同配方和超參數,但階段較少(見三種規模有何差異);改變的是階段清單,而非參數。

KL 排程依獎勵類型而定:獎勵客觀且可驗證時(RLVR 和 SWE 2 的 KL 為 0)可自由探索;目標涉及偏好、安全性或加入特定技能時(RLHF 和程式碼加強的 KL 為 0.05),則要貼近參考 policy。rollout 回合欄計算的是GRPO 本身在每次 rollout 中看到的環境互動次數。所有情況下,模型都以完整的真實環境軌跡訓練。

分階段課程

每個階段都是獨立的 RL 執行,只設一個目標及專屬獎勵訊號。完成後,policy 會匯出為 Hugging Face 格式,並作為下一階段的基礎模型,因此整條 pipeline 由一連串 warm start 組成:

SFT ─▶ RLVR ─▶ Skill boosters ─▶ SWE agent ─▶ Terminal ─▶ Search ─▶ RLHF
      └──────── foundational RL ────────┘   └──────── agentic RL (8B / 30B) ────────┘

8B 和 30B模型會完成整個階梯;3B模型則走較短路徑:執行基礎 RL 和對齊,不包括代理式階段。

獎勵訊號

一個階段主要按獎勵方式界定。整條 pipeline 使用三類獎勵,而單一階段可同時使用多類:

獎勵類型 衡量內容 用途
可驗證 精確匹配、單元測試、格式檢查器,以及依據真值的規則式檢查器 RLVR · 加強階段 · SWE
獎勵模型/LLM 評審 開放式質素、偏好、安全性、答案正確性 RLVR · 搜尋 · RLHF
代理式成果 模型是否真的在真實環境中解決任務? SWE · 終端機 · 搜尋

可驗證獎勵客觀且難以鑽空子,因此 pipeline 會先安排這類獎勵。評審和偏好獎勵則處理無法由檢查器表達的開放式質素。代理式成果獎勵最稀疏:通常只在漫長的工具使用軌跡結尾提供一個二元訊號。

基礎 RL:建立技能

RLVR:可驗證獎勵 RL

RLVR 是 pipeline 的基礎階段,資料混合也最廣:以單一混合資料集涵蓋多個可驗證領域。

  • 數學:附方框答案檢查的思維鏈,以及以 Lean 進行形式化證明
  • 競技編程:在沙盒中以隱藏測試檢查解答
  • STEM/研究生程度科學選擇題及一般知識
  • 遵循指令:結構化輸出及反向指令任務
  • 工具/函數呼叫:單步工具使用
  • 推理謎題及拒答(懂得何時拒絕)

每種任務都有專屬驗證器,獎勵會根據個別樣本判定。RLVR 在 3B 和 8B 上執行兩輪,在 30B 上執行三輪。每輪都是重新 warm start 的獨立訓練,使用重新加權的公開和內部整理 RL 資料混合。

技能加強:針對性提升

RLVR 之後,會執行幾個短暫的加強階段,集中訓練能受惠於特定領域強化的能力:

  • 遵循指令(IF):多輪對話、inverse-IFEval、結構化輸出
  • 程式碼:只涵蓋競技編程

技能加強階段是小型、聚焦的訓練。輕量 KL 懲罰讓模型貼近現有行為,同時微調一項技能。

代理式 RL:學會行動(8B/30B)

在代理式階段,模型會學習行動:在真實環境中呼叫工具、觀察結果並反覆調整,獎勵則取決於是否真的完成任務。各階段設定相同:多輪工具使用、真實(而非模擬)環境、稀疏成果獎勵,以及從程式碼加強檢查點 warm start 的 GRPO。依序執行:SWE → 終端機 → 搜尋。

Agentic RL environments

圖 2。三種代理式 RL 環境。每個環境均配對真實 harness 和真實環境,並採用稀疏、以成果為依據的獎勵。3B 模型不會執行這些階段。

  • SWE 代理(軟件工程)。每項任務都是獨立沙盒中的真實程式碼儲存庫。模型由 OpenHands harness 驅動,在多輪內部互動中讀取程式碼、編輯檔案並執行測試套件。獎勵可驗證:隱藏測試是否通過?任務取自開源 SWE 資料集,每個樣本都配有該儲存庫專用的容器映像。
  • 終端機代理(終端機/OS 操作)。透過 Harbor/Terminus-2 代理 harness,在即時 shell 中執行多步任務。模型會規劃一連串指令、觀察輸出並從錯誤中恢復;成功完成任務便會獲得獎勵。這是唯一會在 GRPO 層級執行多輪代理迴圈的階段,每次 rollout 最多涵蓋 64 個環境回合。
  • 搜尋代理(深度研究)。模型會在瀏覽代理迴圈中即時呼叫網絡搜尋工具,回答困難、多跳的問題:逐步蒐集證據、分析資料並給出答案。由於正確性屬開放式評估,最終答案會由 LLM 評審評分。

對齊:RLHF

所有模型的最後階段都是針對人類偏好和安全性的 RLHF。此階段使用生成式獎勵模型(GenRM)最佳化偏好,並加入涵蓋越獄抵抗力和適當拒答的安全性獎勵。這是整條 pipeline 中 KL 懲罰最高的階段,可調整語氣和安全性,同時不削弱早期階段建立的能力。除了人類偏好和安全性對齊,這個階段亦會懲罰推理過長,避免模型保留早期階段習得的過度冗長推理習慣。

三種規模的差異

方法和基礎架構相同,差別在於各模型會走完整個階梯的哪一段。

階段 3B 8B 30B
RLVR(可驗證) ×2 ×2 ×3
技能加強 程式碼 IF · GPQA · 程式碼 IF · 程式碼
SWE 代理 — ✓ ✓
終端機代理 — ✓ ✓
搜尋代理 — ✓ ✓
RLHF(偏好 + 安全性) ✓ ✓ ✓

3B 是強大的基礎 RL 模型;8B 和 30B 則在此之上加入代理式 RL 階段,學習在真實環境中使用工具行動。


可擴展 RL 的代理式 AI 基礎架構

此規模的強化學習需要基礎架構同時驅動訓練迴圈及一整批即時環境。代理式階段尤其需要此能力,因為每個訓練樣本都是多輪 rollout,會編輯程式碼、執行命令或瀏覽網頁。Granite 4.2 的 RL 建基於兩個開放元件:訓練端的 NeMo-RL 和 rollout 端的 NeMo-Gym。

NeMo-RL + NeMo-Gym system architecture

圖 3。RL 系統。NeMo-RL 驅動 GRPO 迴圈(以 Megatron-Core 作訓練後端、vLLM 生成,以及 Megatron-Bridge 轉換 HF⇄Megatron 權重)。NeMo-Gym 協調 rollout,並以可插拔的資源形式提供工具、沙盒及獎勵/驗證器呼叫。

職責分工如下:

  • NeMo-RL(訓練端)。Megatron-Core 是訓練後端;vLLM 生成 rollout;Megatron-Bridge 則在 Megatron 和 Hugging Face 格式之間轉換權重,讓每個階段都能匯出乾淨的 HF 檢查點,供下一階段使用。
  • NeMo-Gym(rollout 端)。它會透過統一介面,把每個環境公開為一組資源(驗證器、工具、沙盒及獎勵模型)。這是代理式階段的接入點:SWE 儲存庫沙盒、終端機 harness 和網絡搜尋工具都在此接入,對訓練迴圈而言,它們看起來與簡單的數學驗證器完全相同。

這種統一性令前述分階段課程切實可行:加強階段的規則式檢查器和完整 SWE 沙盒,對 GRPO 都呈現相同介面。

這種分工亦令前述非同步訓練迴圈在實際上得以運作:生成和 policy 更新分別在不同 GPU 池執行,因此昂貴的生成 GPU 羣(包括即時代理式環境)可持續工作,不會在最佳化器步驟期間閒置。


結果

我們評估 Granite 4.2 在代理式編碼、一般代理和工具使用、推理、聊天及遵循指令,以及長上下文方面的表現。下方是完整基準測試表,之後的圖表按模型規模列出主要結果。

任務 3B 稠密模型 8B 稠密模型 30B 稠密模型
代理式(編碼)
SWE Bench 多語言版 不適用 30.7841.89
SWE Bench Pro 不適用 19.1133.29
SWE Bench Verified 不適用 47.6757.00
Terminal-Bench 2.1 不適用 20.5629.24
代理式(一般)
τ³-bench 45.78 58.0662.00
BFCL (v4) 52.41 50.2961.39
ProfBench 32.10 41.2042.90
BirdBench 不適用 41.0741.85
GDPval 不適用 1189.001225.00
推理
AIME25 78.33 86.6789.17
HMMT Feb25 66.67 78.3389.17
GPQA 54.80 64.1466.41
LiveCodeBench v6 69.71 73.2475.77
SciCode 24.11 36.0938.76
聊天及遵循指令
MMLU-Pro 67.84 74.0477.60
MMLU-ProX lite (IBM) 27.78 61.0666.64
Arena-Hard-V2 34.96 65.1967.93
IFBench (prompt) 74.33 79.3377.17
長上下文
RULER 64K 67.52 80.9989.96
RULER 128K 55.30 71.4181.38

支援語言:英文、德文、西班牙文、法文、日文、葡萄牙文、阿拉伯文、捷克文、意大利文、韓文、荷蘭文及中文。

下方圖表按能力範疇列出這些結果。

Reasoning benchmarks

圖 4。推理(pass@1)。數學(AIME25、HMMT)、科學(GPQA)和程式碼推理(LiveCodeBench、SciCode)分數均隨模型規模增加而穩定上升。

Agentic coding benchmarks

圖 5。代理式編碼解決率。只有 8B 和 30B 訓練了代理式 RL 階段;30B 模型在各種 SWE-Bench 變體及 Terminal-Bench 均領先。

General agentic and tool-use benchmarks

圖 6。三種模型規模的一般代理式及工具使用基準測試結果。


量化

我們亦發布 Granite 4.2 模型的四種量化版本,可透過 vLLM 進行推論。模型使用 LLM Compressor 轉換為 FP8、NVFP4 和 MXFP4,亦透過 llama.cpp 框架轉換為 GGUF 格式,以便在記憶體較少的環境部署。

FP8

FP8 版本採用動態逐 channel 權重量化及逐 token 啟動值量化,不使用校準。

FP4

NVFP4 和 MXFP4 版本使用 GPTQ 量化,並以從 SFT 資料集抽取的 2K 個樣本校準。校準期間的最大上下文長度為 2K。

GGUF

Granite 4.2 模型轉換至 GGUF 時,會使用標準 llama.cpp 工具,詳情見此處。

提供多種 GGUF 格式:

  • Q8_0
  • Q6_K
  • Q5_K_S
  • Q5_K_M
  • Q5_1
  • Q5_0
  • Q4_K_S
  • Q4_K_M
  • Q4_1
  • Q4_0
  • Q3_K_S
  • Q3_K_M
  • Q3_K_L
  • Q2_K

基礎設施

硬件

我們在 CoreWeave 託管的 NVIDIA GB200 NVL72 叢集上訓練 Granite 4.2 語言模型,該叢集具備:

  • 一個包含 72 部 GPU 的 NVLink 網域,支援機櫃內高速通訊
  • 非阻塞式 Fat-Tree NDR 400 Gb/s InfiniBand 網絡,提供完整頻寬的機櫃間連線
  • 數以千計的 GPU 以叢集規模運作

這套基礎設施提供高頻寬、低延遲通訊,滿足高效大規模分散式訓練的需要。

軟件堆疊

訓練軟件堆疊封裝於 .sqsh 容器映像,每個映像均提供可重現、可移植的執行環境,並固定相容 SBSA 的 CUDA 目標、Linux aarch64 Python wheels 及 GPU 專用二進位檔。大規模 SFT 訓練使用 NGC PyTorch 基礎映像(Ubuntu 22.04、CUDA 12.8、Python 3.12);RL 堆疊則使用獨立的 NeMo-RL 容器。


入門(Transformers)

安裝

pip install torch
pip install accelerate transformers

基本推論(思考模式)

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_path = "ibm-granite/granite-4.2-30b"
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path, device_map="cuda", torch_dtype=torch.bfloat16)
model.eval()

messages = [
    {"role": "user", "content": "How many r's are in the word 'strawberry'?"},
]

text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True, enable_thinking=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

with torch.no_grad():
    output = model.generate(**inputs, max_new_tokens=8192, temperature=1.0, top_p=0.95, do_sample=True)

print(tokenizer.decode(output[0][inputs.input_ids.shape[-1]:], skip_special_tokens=False))

輸出範例

<think>
Okay, let's see. The problem is to find how many 'r's are in the word 'strawberry'.

First, I need to write out the word: s t r a w b e r r y.

Now, I need to count the number of 'r' letters. Let's list each letter and check for 'r'.

1. s – not r
2. t – not r
3. r – yes, that's one
4. a – no
5. w – no
6. b – no
7. e – no
8. r – yes, that's two
9. r – yes, that's three
10. y – no

Total r's = 3.
</think>
There are **3** r's in the word "strawberry".<|im_end|>

非思考模式

messages = [
    {"role": "user", "content": "What is the capital of France?"},
]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True, enable_thinking=False)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=2048, temperature=1.0, top_p=0.95, do_sample=True)
print(tokenizer.decode(output[0][inputs.input_ids.shape[-1]:], skip_special_tokens=False))

輸出範例

<think></think>The capital of France is Paris.<|im_end|>

低力度思考

messages = [
    {"role": "user", "content": "What is 2 + 2?"},
]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True,
                                     enable_thinking=True, low_effort=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=4096, temperature=1.0, top_p=0.95, do_sample=True)
print(tokenizer.decode(output[0][inputs.input_ids.shape[-1]:], skip_special_tokens=False))

輸出範例

<think>
Simple answer.
</think>
2 + 2 = 4.<|im_end|>

工具呼叫

Granite 模型支援結合推理的工具呼叫:呼叫工具前,模型會先推理該呼叫甚麼工具及原因。工具使用 OpenAI 函數定義 schema 定義。

基本工具呼叫

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Get the current weather for a specified city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Name of the city"}
                },
                "required": ["city"]
            }
        }
    }
]

messages = [
    {"role": "user", "content": "What's the weather like in Boston right now?"},
]
text = tokenizer.apply_chat_template(messages, tokenize=False, tools=tools,
                                     add_generation_prompt=True, enable_thinking=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=4096, temperature=1.0, top_p=0.95, do_sample=True)
print(tokenizer.decode(output[0][inputs.input_ids.shape[-1]:], skip_special_tokens=False))

輸出範例

<think>
Okay, the user is asking for the weather in Boston right now. Let me check the tools
available. There's a function called get_current_weather that takes a city parameter.
I need to call that with the city set to Boston.
</think>
<tool_call>
<function=get_current_weather>
<parameter=city>
Boston
</parameter>
</function>
</tool_call>
<|im_end|>

包含工具回應的多輪對話

messages = [
    {"role": "user", "content": "What's the weather like in Boston right now?"},
    {"role": "assistant", "content": "<think>\nThe user wants to know the current weather in Boston. I should call get_current_weather.\n</think>",
     "tool_calls": [{"function": {"name": "get_current_weather", "arguments": {"city": "Boston"}}}]},
    {"role": "tool", "content": '{"temperature": "72°F", "condition": "Partly cloudy", "humidity": "65%"}'},
]
text = tokenizer.apply_chat_template(messages, tokenize=False, tools=tools,
                                     add_generation_prompt=True, enable_thinking=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=4096, temperature=1.0, top_p=0.95, do_sample=True)
print(tokenizer.decode(output[0][inputs.input_ids.shape[-1]:], skip_special_tokens=False))

輸出範例

<think>
The tool returned the weather data for Boston: temperature 72°F, partly cloudy, humidity 65%.
I need to present this information clearly to the user.
</think>
The current weather in Boston is 72°F, partly cloudy, with 65% humidity.<|im_end|>

多輪對話

截短歷史思考內容

messages = [
    {"role": "user", "content": "What is 15 * 37?"},
    {"role": "assistant", "content": "<think>\nLet me calculate 15 * 37.\n15 * 37 = 15 * 30 + 15 * 7 = 450 + 105 = 555\n</think>\n15 * 37 = 555"},
    {"role": "user", "content": "Now divide that by 5"},
]

# Default: previous thinking is stripped to save context
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True,
                                     enable_thinking=True, truncate_history_thinking=True)

# To preserve full history:
text_full = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True,
                                          enable_thinking=True, truncate_history_thinking=False)

解析思考內容與最終答案

import re

def parse_model_output(text):
    """Separate thinking content from final answer."""
    think_match = re.search(r'<think>(.*?)</think>', text, re.DOTALL)
    if think_match:
        thinking = think_match.group(1).strip()
        answer_start = text.find('</think>') + len('</think>')
        answer_end = text.find('<|im_end|>', answer_start)
        answer = text[answer_start:answer_end].strip() if answer_end != -1 else text[answer_start:].strip()
    else:
        thinking, answer = "", text.strip()
    return thinking, answer

thinking, answer = parse_model_output(output_text)

與代理式編碼 harness 搭配使用

Granite 模型可作為代理式編碼工具的核心。由於它透過 OpenAI 相容 API 支援推理和工具呼叫,無需額外介面便可整合熱門代理式 harness。啟動 vLLM 伺服器後,按下方相應 harness 的指示操作。

OpenCode

OpenCode 是在終端機執行的 AI 編碼代理。

安裝:

curl -fsSL https://opencode.ai/install | bash

設定 ~/.config/opencode/opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "local/granite-4.2-30b",
  "provider": {
    "local": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "vLLM (local)",
      "options": {
        "baseURL": "http://localhost:8000/v1",
        "apiKey": "EMPTY"
      },
      "models": {
        "granite-4.2-30b": {
          "name": "Granite 4.2 30B",
          "limit": {
            "context": 131072,
            "output": 8192
          }
        }
      }
    }
  }
}

執行:

opencode
opencode run "your task description"

完整文件請參閲 opencode.ai/docs。

Pi

Pi 是在終端機執行的精簡 AI 編碼代理 harness,支援透過 models.json 設定檔自訂 provider。

安裝:

curl -fsSL https://pi.dev/install.sh | sh

設定 ~/.pi/agent/models.json:

{
  "providers": {
    "vllm": {
      "baseUrl": "http://localhost:8000/v1",
      "api": "openai-completions",
      "apiKey": "EMPTY",
      "compat": {
        "supportsDeveloperRole": false,
        "supportsReasoningEffort": false
      },
      "models": [
        {
          "id": "granite-4.2-30b",
          "name": "Granite 4.2 30B",
          "reasoning": true,
          "input": ["text"],
          "contextWindow": 131072,
          "maxTokens": 8192,
          "samplingParams": {
            "temperature": 1.0,
            "top_p": 0.95
          },
          "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 }
        }
      ]
    }
  }
}

執行:

pi

然後在互動工作階段中選取 granite-4.2-30b 模型,可使用 /model 或 Ctrl+L。

完整文件請參閲 pi.dev/docs。

OpenHands

OpenHands 是 AI 軟件工程師,可規劃工作、編寫程式碼和執行命令。

  1. 安裝並啟動 OpenHands,並依照官方安裝指南操作。

  2. 在 OpenHands 設定中設定 LLM,使用以下資料:

    • 模型: granite-4.2-30b
    • Base URL: http://localhost:8000/v1
    • API Key:你的 vLLM --api-key 值

注意:連接 vLLM 等 OpenAI 相容端點時,必須加入 openai/ 前綴。詳細設定、疑難排解和其他安裝方式,請參閲 OpenHands 本地 LLM 文件。


資源:


最後更新:September 11, 2026(補充説明基礎模型)。

來源:Hugging Face Blog · huggingface.co