如何在本機執行 Gemma 4 31B：Unsloth、Ollama、llama.cpp 和 HuggingFace

Google DeepMind 在 2026 年初發布了 Gemma 4，其中 31B 指令微調版本剛好踩在一個甜點上：參數量夠大，能在推理基準測試中和專有模型一較高下；又夠小，在一張不錯的消費級 GPU 上就能跑。它在 MMLU Pro 拿了 85.2%，在 AIME 2026 拿了 89.2%（不使用工具），這個成績已經能和參數量翻倍的模型放在一起討論了。

問題一直都在——「我到底怎麼跑這東西？」一個 30.7B 參數的全精度模型大約需要 62GB 的 VRAM，沒有人會在單張顯卡上放這麼多。但選對量化方法、用對工具，你可以在 24GB 的 RTX 4090 上跑起來，甚至在 16GB 顯卡上部分卸載到 CPU 也能用。如果你需要 GPU 實例但不想長期投入，我們推薦使用 LightNode 作為你的 VPS 服務商。

這篇指南涵蓋四種方法，其中 Unsloth 是大多數人的首選推薦。

目錄

1. Gemma 4 模型家族概覽
2. 硬體需求
3. 方法一：Unsloth Studio（推薦）
4. 方法二：Ollama
5. 方法三：llama.cpp
6. 方法四：HuggingFace Transformers
7. 理解 GGUF 量化格式
8. 效能優化技巧
9. 常見問題排查
10. 你該選哪種方法？

Gemma 4 模型家族概覽

Gemma 4 有四個尺寸。選對很重要，因為它們之間的硬體需求跨度相當大。

變體	總參數	活躍參數	上下文長度	模態	最佳用途
E2B	5.1B	2.3B（等效）	128K	文字、圖像、音訊	手機、樹莓派
E4B	8B	4.5B（等效）	128K	文字、圖像、音訊	筆電、純 CPU
26B A4B (MoE)	25.2B	3.8B（活躍）	256K	文字、圖像	快速推理、省顯存
31B（Dense）	30.7B	30.7B	256K	文字、圖像	最高品質

26B A4B 是最聰明的那一個：總參數 25.2B，但推理時只有 3.8B 被啟動，這得益於混合專家架構（128 個專家中啟動 8 個，外加 1 個共享專家）。它的推理速度幾乎和 4B 模型一樣快，品質卻接近完整的 31B。如果你的 GPU 有 12-16GB VRAM，26B A4B 的 Q4 量化版本可能是你的最佳選擇。

31B Dense 就是本篇指南的重點。它是滿血模型，每次前向傳播所有參數全部參與。品質最高，硬體要求也最高。

四個變體都支援可配置的思考模式（鏈式推理）、原生系統提示、函數呼叫，以及 140 種以上的語言。

硬體需求

在選擇方法之前，先搞清楚你手上的硬體是什麼水準。

Gemma 4 31B-it

量化	所需 VRAM	品質損失	典型硬體
FP16（全精度）	~62 GB	無	A100、多卡
Q8_0（8-bit）	~32 GB	可忽略	RTX 4090（24GB）+ CPU 卸載
Q5_K_M（5-bit）	~22 GB	極小	RTX 4090、RTX 3090
Q4_K_M（4-bit）	~18 GB	較小	RTX 4080、RTX 3090
Q3_K_M（3-bit）	~14 GB	明顯	RTX 4070、部分卸載

Gemma 4 26B A4B (MoE)

量化	所需 VRAM	品質損失	典型硬體
Q5_K_M	~14 GB	極小	RTX 4070 Ti
Q4_K_M	~10 GB	較小	RTX 4070、RTX 3080
Q3_K_M	~8 GB	明顯	RTX 4060 Ti 8GB

如果你只有 CPU，E4B 或 E2B 變體可以輕鬆跑起來。31B 在 CPU 上技術上可行，但速度令人煎熬（現代 CPU 上大約 1-3 tokens/秒）。

記憶體需求：在 VRAM 之外，還需要額外 8-16GB 系統記憶體給執行時開銷。如果有層卸載到 CPU，需要更多。

方法一：Unsloth Studio（推薦）

Unsloth 是執行 Gemma 4 最簡單的方式。它是一個 Web UI，把模型下載、量化選擇和推理全部打包在一起。支援 Windows、Linux、macOS 和 WSL。

為什麼選 Unsloth

• 一鍵搜尋並從 HuggingFace 下載模型
• 自動為你挑選適合硬體的 GGUF 量化版本
• 內建聊天介面，支援圖片、PDF 和文件
• 內建工具呼叫和網頁搜尋
• 程式碼執行沙箱
• 不用折騰命令列

安裝

macOS、Linux、WSL：

curl -fsSL https://unsloth.ai/install.sh | sh

Windows（PowerShell）：

irm https://unsloth.ai/install.ps1 | iex

Docker：

docker run -d -e JUPYTER_PASSWORD="mypassword" \
  -p 8888:8888 -p 8000:8000 -p 2222:22 \
  -v $(pwd)/work:/workspace/work \
  --gpus all \
  unsloth/unsloth

啟動

unsloth studio -H 0.0.0.0 -p 8888

在瀏覽器打開 http://localhost:8888，就能看到 Unsloth Studio 的介面了。

執行 Gemma 4 31B

1. 搜尋模型：在模型搜尋欄輸入 gemma-4-31B
2. 選擇量化：Unsloth 託管了預量化的 GGUF 檔案。24GB 顯卡選 Q4_K_M 或 Q5_K_M；16GB 顯卡選 Q3_K_M
3. 下載：點擊下載。Q4_K_M 版本大約 18GB
4. 開始聊天：下載完成後，模型會自動載入到聊天介面

Unsloth 為 Gemma 4 31B-it 提供以下 GGUF 變體：

檔案	大小	量化
gemma-4-31B-it-Q3_K_M.gguf	~14 GB	3-bit（均衡）
gemma-4-31B-it-Q4_K_M.gguf	~18 GB	4-bit（推薦）
gemma-4-31B-it-Q5_K_M.gguf	~22 GB	5-bit（高品質）
gemma-4-31B-it-Q6_K.gguf	~26 GB	6-bit（近乎無損）
gemma-4-31B-it-Q8_0.gguf	~32 GB	8-bit（幾乎無損）

HuggingFace 儲存庫位址：unsloth/gemma-4-31B-it-GGUF。

使用聊天介面

Unsloth Studio 的聊天支援以下功能：

• 文字對話，帶思考模式開關
• 圖片上傳：拖放圖片進行視覺問答
• PDF/DOCX 上傳：提取並討論文件內容
• 程式碼執行：模型可以在沙箱中編寫和測試程式碼
• 自訂系統提示：設定行為和人設

要開啟 Gemma 4 的思考模式，在聊天設定裡打開「Thinking」選項。這會啟動鏈式推理，模型在給出最終答案之前會先逐步分析問題。

用 Unsloth 微調

如果你不只是想推理，還想做訓練，Unsloth 也能搞定：

• LoRA 微調：訓練適配器，VRAM 佔用減少最高 70%
• GRPO 強化學習：目前最高效的 RL 函式庫
• 資料配方（Data Recipes）：從 PDF、CSV、DOCX 檔案自動建立訓練資料集
• 多 GPU 支援：已上線，持續改進中

要對 Gemma 4 31B 做微調，你至少需要一張 24GB 的 GPU，使用 QLoRA（4-bit 量化訓練）。

更新 Unsloth

再次執行同樣的安裝命令即可：

# macOS/Linux/WSL
curl -fsSL https://unsloth.ai/install.sh | sh

# Windows
irm https://unsloth.ai/install.ps1 | iex

方法二：Ollama

如果你更喜歡命令列，Ollama 是最快的上手方式。它自動處理模型下載、GPU 偵測和模型服務。

安裝

# macOS
brew install ollama

# Linux
curl -fsSL https://ollama.com/install.sh | sh

# Windows
# 從 https://ollama.com/download 下載

執行 Gemma 4

# 拉取並執行 31B 模型
ollama run gemma4:31b-it

# 或者用更小的 MoE 變體，更省顯存
ollama run gemma4:26b-a4b-it

# 或者更小的 Dense 模型
ollama run gemma4:e4b-it
ollama run gemma4:e2b-it

Ollama 預設自動使用 Q4_K_M 量化。如果你想用別的量化級別：

# 指定量化的執行
ollama run gemma4:31b-it-q5_K_M

使用 API

Ollama 在 11434 連接埠暴露本機 API：

import requests

response = requests.post('http://localhost:11434/api/chat', json={
    "model": "gemma4:31b-it",
    "messages": [
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function to merge two sorted lists."}
    ],
    "stream": False
})

print(response.json()['message']['content'])

Ollama 的優缺點

優點：零設定，自動 GPU 偵測，簡潔的命令列，自帶 API 服務，模型管理簡單。

缺點：量化選項比 llama.cpp 少，不是所有模型都支援內建圖片功能（請檢查目前相容性），對推理參數的控制較少。

方法三：llama.cpp

想要對量化、記憶體使用和推理參數有最大控制權，llama.cpp 是不二之選。Ollama 和 Unsloth 底層就是用它做 GGUF 推理的。

從原始碼編譯

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# 支援 CUDA（NVIDIA）
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

# 支援 Metal（macOS Apple Silicon）
cmake -B build -DGGML_METAL=ON
cmake --build build --config Release -j$(nproc)

# 純 CPU
cmake -B build
cmake --build build --config Release -j$(nproc)

下載 GGUF 模型

從 Unsloth 的 HuggingFace 儲存庫下載量化模型：

# 安裝 huggingface-cli
pip install huggingface-hub

# 下載 Q4_K_M（推薦 24GB 顯卡使用）
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models

# 或者 Q5_K_M，品質更好
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q5_K_M.gguf \
  --local-dir ./models

執行模型

# 基礎聊天
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -c 8192 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64 \
  -p "You are a helpful assistant.\nUser: Explain quantum computing in simple terms.\nAssistant:"

關鍵參數說明：

• -ngl 99：把所有層卸載到 GPU。如果 VRAM 不夠就減小這個數字（例如 -ngl 40 大約卸載三分之二的層）
• -c 8192：上下文長度（token 數）。處理長文件可以增加到 256K，但上下文越長越吃顯存
• --temp 1.0：Google 建議 Gemma 4 使用 temperature=1.0
• --top-p 0.95 和 --top-k 64：建議的取樣參數

啟動伺服器

./build/bin/llama-server \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -c 8192 \
  --host 0.0.0.0 \
  --port 8080 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

然後在瀏覽器存取 http://localhost:8080，或者呼叫相容 OpenAI 的 API：

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="unused")

response = client.chat.completions.create(
    model="gemma-4-31b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Write a Rust function to reverse a linked list."}
    ]
)

print(response.choices[0].message.content)

GPU 卸載策略

如果你的 GPU 顯存不夠載入完整模型，可以把層在 GPU 和 CPU 之間分配：

# 16GB 顯卡跑 Q4 模型（總大小約 18GB）
# 大約卸載 40 層到 GPU，其餘用 CPU
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 40 \
  -c 4096

速度比全 GPU 卸載慢，但能裝進小顯存顯卡。根據你的 CPU 和卸載層數，大約 5-15 tokens/秒。

方法四：HuggingFace Transformers

如果你在開發應用，需要程式設計等級的控制，HuggingFace Transformers 讓你直接存取模型，支援全精度或自訂量化。

安裝

pip install -U transformers torch accelerate

如果需要圖片支援：

pip install -U transformers torch torchvision accelerate

全精度執行（需要 62GB+ VRAM）

from transformers import AutoProcessor, AutoModelForCausalLM

MODEL_ID = "google/gemma-4-31B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain the difference between TCP and UDP."},
]

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=False
)

inputs = processor(text=text, return_tensors="pt").to(model.device)
input_len = inputs["input_ids"].shape[-1]

outputs = model.generate(**inputs, max_new_tokens=1024)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
result = processor.parse_response(response)
print(result)

4-bit 量化執行（18GB VRAM）

from transformers import AutoProcessor, AutoModelForCausalLM, BitsAndBytesConfig

MODEL_ID = "google/gemma-4-31B-it"

# 4-bit 量化設定
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16
)

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    quantization_config=quantization_config,
    device_map="auto"
)

處理圖片

31B 模型支援文字和圖片輸入：

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "google/gemma-4-31B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://example.com/photo.jpg"},
            {"type": "text", "text": "Describe what you see in this image."}
        ]
    }
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=512)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
result = processor.parse_response(response)
print(result)

開啟思考模式

Gemma 4 支援鏈式推理。設定 enable_thinking=True 即可啟用：

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=True  # 啟動推理模式
)

開啟思考模式後，模型會先輸出內部推理過程，再給出最終答案。用 processor.parse_response(response) 可以把思考過程和最終答案分開。

理解 GGUF 量化格式

下載 GGUF 檔案時你會看到很多後綴，這裡說說它們實際代表什麼。

格式	位元數	大小（31B）	適用場景
Q8_0	8-bit	~32 GB	最佳品質，需要 32GB+ VRAM
Q6_K	6-bit	~26 GB	近乎無損，24GB+ VRAM
Q5_K_M	5-bit	~22 GB	品質/容量的甜點
Q4_K_M	4-bit	~18 GB	最佳平衡，適配 24GB 顯卡
Q3_K_M	3-bit	~14 GB	小顯存顯卡，有一定品質損失
Q2_K	2-bit	~10 GB	萬不得已的選擇，品質下降明顯

我的建議：24GB 顯卡選 Q4_K_M，能多出 4GB 空間就選 Q5_K_M。Q4_K_M 和 Q5_K_M 在基準測試上有差距，但日常使用基本感覺不出來。低於 Q3_K_M 就不太值得了，除非真的沒有其他選擇。

_K_M 後綴意思是「K-量化，中等」。還有 _K_S（小，壓縮更多）和 _K_L（大，壓縮更少）變體。_K_M 是預設推薦。

效能優化技巧

上下文長度管理

Gemma 4 31B 支援最長 256K token 的上下文，但上下文中的每個 token 都要吃顯存。幾個實用建議：

• 4K token：只要能裝下模型的顯卡都沒問題
• 8K token：大多數對話的標準配置，依然很輕鬆
• 32K token：根據量化級別額外需要 4-6GB 顯存
• 128K+ token：需要大量顯存或積極卸載

從 -c 8192 開始，需要時再增加。

取樣參數

Google 為 Gemma 4 建議的設定：

temperature = 1.0
top_p = 0.95
top_k = 64

這和大多數模型不一樣。別給 Gemma 4 用 temperature=0.7，它就是用 temperature=1.0 訓練的，在這個設定下效果最好。

Flash Attention

如果你用 HuggingFace Transformers，開啟 Flash Attention 可以加快推理、降低記憶體佔用：

model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    attn_implementation="flash_attention_2",
    device_map="auto"
)

需要 pip install flash-attn，以及相容的 GPU（大多數 NVIDIA RTX 系列都行）。

多 GPU 設定

如果你有多張顯卡，Transformers 中的 device_map="auto" 會自動處理分配。llama.cpp 這樣做：

./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -ts 1,1 \  # 在 2 張 GPU 之間平均分配
  -c 8192

常見問題排查

顯存不足（CUDA OOM）

最常見的問題。按絕望程度依次列出解決方案：

1. 用更低的量化：從 Q5 換到 Q4，或從 Q4 換到 Q3
2. 減少上下文長度：把 -c 從 8192 降到 4096 或 2048
3. 卸載到 CPU：減小 -ngl 來卸載部分層
4. 用 26B A4B MoE 變體：同等品質水準，顯存只需一小部分
5. 用 E4B 變體：什麼機器都能跑

CPU 推理太慢

如果你在用 CPU 跑，31B 模型大約 1-3 tokens/秒。可選方案：

• 換用 E4B 或 E2B 模型（CPU 上 10-20 tok/s）
• 用 GPU 雲端實例（LightNode 提供 GPU VPS 選項）
• 編譯 llama.cpp 時啟用你 CPU 的指令集（AVX2、AVX-512）

模型下載失敗

Q4_K_M 檔案大約 18GB。如果下載一直失敗：

# 用 huggingface-cli 的斷點續傳功能
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models \
  --local-dir-use-symlinks False

或者用支援斷點續傳的下載工具。HuggingFace CDN 對大檔案有時候不太穩定。

"Model not supported" 錯誤

確保你用的是最新版本的工具。Gemma 4 很新，舊版的 llama.cpp、Ollama 和 Transformers 都不支援：

# 更新 llama.cpp
cd llama.cpp && git pull && cmake --build build --config Release -j$(nproc)

# 更新 Ollama
ollama pull gemma4:31b-it  # 如果需要會自動更新

# 更新 Transformers
pip install -U transformers

你該選哪種方法？

場景	最佳方法
想要圖形介面，不想碰終端機	Unsloth Studio
想要最快上手，命令列沒問題	Ollama
需要對推理有最大控制	llama.cpp
在開發應用程式	HuggingFace Transformers
顯存有限（8-16GB）	Unsloth 或 Ollama，用 Q3/Q4
有 24GB+ VRAM	任何方法都行，用 Q4_K_M 或 Q5_K_M
需要圖片理解能力	Unsloth Studio 或 HuggingFace Transformers
想做微調	Unsloth（內建 LoRA/GRPO 訓練）

對於大多數剛入門的朋友，Unsloth Studio 是最省心的路。裝好它，搜尋 Gemma 4，選一個適合你顯卡的量化版本，然後開始聊天。從安裝到第一次對話，整個過程大約 15 分鐘。

如果你終端機用得熟、只是想跑模型，Ollama 兩個命令就搞定了。而如果你需要程式設計介面或者在模型之上建構應用，HuggingFace Transformers 配合 4-bit 量化給你完整的 Python API。

總結

在本機跑 Gemma 4 31B 已經變得相當實用了。一年前，同等品質水準的 30B 模型還是個研究專案。現在使用 Unsloth 或 Ollama，15 分鐘就能搞定，而且能跑在你現在就能買到的消費級硬體上。

這個模型本身在推理、程式設計和多模態任務上足以抗衡專有方案。256K 上下文、內建思考模式、圖片理解和函數呼叫，讓它在真正的實際工作中派上用場，而不只是拿來玩玩。

如果要在遠端 GPU 上部署模型，LightNode 提供 GPU VPS 實例，按小時計費，需要的時候開一台，用完關掉就行。

Gemma 4 模型卡（HuggingFace） 裡有完整的技術細節，Unsloth GGUF 儲存庫 裡有所有量化版本可供下載。