Gemma — Google DeepMind 開放權重大型語言模型家族完整教學

Gemma 是 Google DeepMind 基於 Gemini 研究與技術推出的 open-weight LLM (開放權重大型語言模型) 家族。本教學涵蓋 Gemma 1 至 Gemma 4 的完整生態系統，包含純文字、多模態 (multimodal)、Mixture-of-Experts (MoE; 混合專家) 及 Diffusion LLM (擴散語言模型) 等變體。

1. 專案概述

1.1 Gemma 是什麼

Gemma 是 Google DeepMind 以 Apache 2.0 授權釋出的開放權重大型語言模型家族。它衍生自 Gemini 模型的研究成果，但以完全開放的方式提供模型權重 (model weights)，讓研究者與開發者能夠在本地端部署、微調 (fine-tune) 及自訂模型行為。

官方 PyPI 套件 gemma 提供了一套以 JAX (高效能數值計算框架) 為基底的 Python 函式庫，支援從推論 (inference)、取樣 (sampling) 到微調的完整工作流程。

1.2 專案基本資訊

1.3 模型家族演進

Gemma 家族歷經四個世代，能力持續擴展：

timeline
    title Gemma 模型家族演進時間線
    2024-02 : Gemma 1
             : 2B / 7B 參數
             : 純文字 (Text-only)
    2024-06 : Gemma 2
             : 2B / 9B / 27B 參數
             : Sliding Window Attention
    2025-03 : Gemma 3
             : 1B / 4B / 12B / 27B 參數
             : 多模態 (Vision)
    2025-11 : Gemma 3n
             : 行動端優化
             : Per-layer Input Dim
    2026-05 : Gemma 4
             : E2B / E4B / 31B / 26B-A4B (MoE)
             : 多模態 + 音訊 + MoE + KV Cache 共享
    2026-06 : Diffusion Gemma
             : 擴散式語言模型
             : v4.1.0

1.4 模型規格總覽

1.5 儲存庫結構

 1google-deepmind/gemma/
 2├── gemma/                    # 主要 Python 套件
 3│   ├── gm/                   # 核心 API 命名空間
 4│   │   ├── nn/               # 模型定義 (Transformer / Gemma3n / Gemma4)
 5│   │   ├── ckpts/            # Checkpoint 載入與路徑管理
 6│   │   ├── data/             # 資料處理與 transform
 7│   │   ├── text/             # Tokenizer / Sampler / Chat
 8│   │   ├── tools/            # Tool Use / MCP 支援
 9│   │   ├── losses/           # DPO / NPO 損失函數
10│   │   ├── math/             # Positional Embedding / RoPE
11│   │   ├── sharding/         # 多裝置分片
12│   │   └── evals/            # 評估工具
13│   ├── diffusion/            # Diffusion LLM 模組
14│   └── peft/                 # 參數高效微調 (LoRA)
15├── examples/                 # 範例腳本 (分類/DPO/LoRA/多模態/NPO/seq2seq/sharding)
16├── colabs/                   # Colab 筆記本 (10+ 份)
17├── docs/                     # ReadTheDocs 文件源碼
18└── CHANGELOG.md

2. 核心架構與技術原理

2.1 整體架構

Gemma 的核心是一個基於 decoder-only Transformer (僅解碼器的 Transformer 架構) 的語言模型。從 Gemma 2 開始引入 Sliding Window Attention (滑動視窗注意力) 機制，在全域注意力 (Global Attention) 與局部注意力 (Local Sliding Attention) 之間交替使用，以在效能與記憶體消耗之間取得平衡。

graph TD
    subgraph "Gemma Transformer 架構"
        A["Input Tokens"] --> B["Embedding Layer
(vocab_size = 262144)"]
        B --> C["Transformer Block x N"]
        C --> D["RMS Norm"]
        D --> E["Linear Projection"]
        E --> F["Logit Softcap (30.0)"]
        F --> G["Output Probabilities"]
    end

    subgraph "Transformer Block 細節"
        C1["RMS Pre-Norm"] --> C2{"Attention Type?"}
        C2 -->|"Global"| C3["Multi-Head Attention
(full context)"]
        C2 -->|"Local Sliding"| C4["Sliding Window Attention
(window_size)"]
        C3 --> C5["Post-Attn Norm"]
        C4 --> C5
        C5 --> C6["Residual Connection"]
        C6 --> C7["RMS Pre-Norm"]
        C7 --> C8["Gated FFN
(GeGLU / SwiGLU)"]
        C8 --> C9["Post-FFW Norm"]
        C9 --> C10["Residual Connection"]
    end

    style A fill:#e8f5e9
    style G fill:#fff3e0

2.2 關鍵技術特色

2.2.1 混合注意力模式 (Hybrid Attention Pattern)

Gemma 使用交替式的全域/局部注意力配置。以 Gemma 4 E4B 為例，每 6 層使用一個模式週期：5 層 Local Sliding + 1 層 Global。

graph LR
    subgraph "Gemma 4 Attention Pattern (每 6 層為一週期)"
        L1["Layer 1
Local Sliding"] --> L2["Layer 2
Local Sliding"]
        L2 --> L3["Layer 3
Local Sliding"]
        L3 --> L4["Layer 4
Local Sliding"]
        L4 --> L5["Layer 5
Local Sliding"]
        L5 --> L6["Layer 6
Global"]
        L6 -.->|"循環"| L1
    end

    style L6 fill:#bbdefb
    style L1 fill:#fff9c4
    style L2 fill:#fff9c4
    style L3 fill:#fff9c4
    style L4 fill:#fff9c4
    style L5 fill:#fff9c4

2.2.2 Grouped Query Attention (GQA; 分組查詢注意力)

從 Gemma 2 開始，模型使用 GQA 以降低 KV Cache (鍵值快取) 的記憶體需求。例如 Gemma 4 E4B 使用 8 個 attention heads 但僅 2 個 KV heads。

2.2.3 KV Cache 共享 (Gemma 4 獨有)

Gemma 4 引入了跨層的 KV Cache 共享機制 (KVCacheSharingConfig)。上層的注意力可以重用下層已計算的 KV 對，大幅減少推論時的記憶體消耗。E4B 模型中有 42.8% 的層 (18/42) 共享 KV Cache。

graph TB
    subgraph "KV Cache 共享示意 (Gemma 4 E4B)"
        direction TB
        UL["Upper Layers (18層)
共享 KV Cache"] -.->|"reuse KV"| BL["Bottom Layers (24層)
獨立 KV Cache"]
    end

    subgraph "記憶體效益"
        M1["傳統：42 組獨立 KV"] --> M2["共享後：24 組 KV
節省 ~43% KV 記憶體"]
    end

    style UL fill:#e1bee7
    style BL fill:#c8e6c9

2.2.4 Mixture-of-Experts (MoE; 混合專家模型)

Gemma 4 的 26B-A4B 變體使用 MoE 架構：

• 總參數量 26B，但每個 token 僅活化約 4B 參數
• 每層包含 128 個 expert (專家)，每次啟用 top-8
• 每個 expert 的維度為 704
• 額外搭配一個 dense shared MLP (密集共享多層感知器)，hidden_dim = 2112

2.2.5 多模態支援

Gemma 3 起支援 Vision (視覺)，Gemma 4 進一步加入 Audio (音訊) 編碼器：

graph LR
    subgraph "Gemma 4 多模態輸入處理"
        IMG["Image
影像"] --> VE["Vision Encoder
(SigLiP)"]
        AUD["Audio
音訊"] --> AE["Audio Encoder
(Conformer)"]
        TXT["Text
文字"] --> TOK["Tokenizer
(v4, 262144 vocab)"]

        VE --> MERGE["Token Merge
多模態 token 合併"]
        AE --> MERGE
        TOK --> MERGE

        MERGE --> TRANS["Transformer
Decoder"]
        TRANS --> OUT["Output
文字生成"]
    end

    style IMG fill:#e3f2fd
    style AUD fill:#fce4ec
    style TXT fill:#e8f5e9

2.2.6 Rotary Position Embedding (RoPE; 旋轉位置編碼)

Gemma 使用 RoPE 進行位置編碼，Gemma 4 對 Global 與 Local Attention 使用不同的 RoPE 配置：

• Local: base_frequency = 10,000, rope_proportion = 1.0
• Global: base_frequency = 1,000,000, rope_proportion = 0.25

高 base frequency 使 Global Attention 能處理更長的上下文 (context length)。

2.2.7 Diffusion LLM (v4.1.0 新增)

v4.1.0 引入 Diffusion Gemma — 一種將擴散模型 (diffusion model) 概念應用於語言生成的實驗性方法。與傳統自回歸 (autoregressive) 生成不同，Diffusion LLM 透過迭代去噪 (iterative denoising) 過程並行生成所有 token。

2.3 軟體架構

graph TD
    subgraph "gemma PyPI 套件架構"
        GM["gm (核心命名空間)"]

        GM --> NN["nn
模型定義"]
        GM --> CKPTS["ckpts
Checkpoint 管理"]
        GM --> TEXT["text
Tokenizer + Sampler"]
        GM --> DATA["data
資料處理"]
        GM --> LOSSES["losses
DPO / NPO"]
        GM --> TOOLS["tools
Tool Use / MCP"]
        GM --> MATH["math
位置編碼"]
        GM --> SHARD["sharding
多裝置分片"]

        NN --> NN_BASE["_gemma.py
Gemma 1-3 定義"]
        NN --> NN_3N["gemma3n/
行動端優化"]
        NN --> NN_4["gemma4/
Gemma 4 (MoE/Audio)"]
        NN --> NN_VIS["vision/
Vision Encoder"]

        TEXT --> CHAT["ChatSampler
多輪對話"]
        TEXT --> TOOL_S["ToolSampler
工具呼叫"]
        TEXT --> TEMPL["_template.py
對話模板"]

        DIFF["diffusion/
Diffusion LLM"] --> DIFF_S["_sampler.py"]
        DIFF --> DIFF_M["_models.py"]
        DIFF --> HDA["hackable_diffusion_adapter/
微調範例 (PubMedQA / Sudoku)"]
    end

    style GM fill:#bbdefb
    style DIFF fill:#f8bbd0

3. 安裝與環境設定

3.1 系統需求

3.2 安裝步驟

3.2.1 安裝 JAX

Gemma 基於 JAX 框架。必須先安裝對應硬體的 JAX 版本：

1# CPU only
2pip install jax
3
4# NVIDIA GPU (CUDA 12)
5pip install jax[cuda12]
6
7# Google Cloud TPU
8pip install jax[tpu] -f https://storage.googleapis.com/jax-releases/libtpu_releases.html

3.2.2 安裝 Gemma

1pip install gemma

3.2.3 使用 uv 建立隔離環境 (推薦)

1# 建立虛擬環境
2uv venv gemma-env
3source gemma-env/bin/activate
4
5# 安裝 JAX + Gemma
6uv pip install jax[cuda12] gemma

3.3 下載模型權重

Gemma 模型權重託管於 Kaggle Hub。需先建立 Kaggle 帳號並同意使用條款。

3.3.1 透過 kagglehub 程式化下載

1import kagglehub
2
3# 登入 (首次使用需設定 API Token)
4kagglehub.login()
5
6# 下載 Gemma 4 E4B IT (Instruction-Tuned) 版本
7weights_dir = kagglehub.model_download('google/gemma-4/flax/gemma4-e4b-it')
8print(f"模型下載至: {weights_dir}")

3.3.2 Kaggle API Token 設定

1# 從 kaggle.com/settings 取得 API Token
2# 放置於 ~/.kaggle/kaggle.json
3mkdir -p ~/.kaggle
4echo '{"username":"YOUR_USERNAME","key":"YOUR_KEY"}' > ~/.kaggle/kaggle.json
5chmod 600 ~/.kaggle/kaggle.json

3.3.3 可用 Checkpoint 一覽

3.4 驗證安裝

 1from gemma import gm
 2import jax
 3
 4# 檢查 JAX 後端
 5print(f"JAX backend: {jax.default_backend()}")  # cpu / gpu / tpu
 6print(f"可用裝置: {jax.devices()}")
 7
 8# 確認 gemma 模組載入
 9print(dir(gm))
10# 應包含: ckpts, data, losses, math, nn, text, tools, sharding, ...

4. 使用教學與範例

4.1 基礎文字生成

最簡單的使用方式是透過 ChatSampler 進行多輪對話：

 1from gemma import gm
 2
 3# 1. 建立模型與載入參數
 4model = gm.nn.Gemma4_E4B()
 5params = gm.ckpts.load_params(gm.ckpts.CheckpointPath.GEMMA4_E4B_IT)
 6
 7# 2. 建立 ChatSampler (支援多輪對話)
 8sampler = gm.text.ChatSampler(
 9    model=model,
10    params=params,
11    multi_turn=True,  # 保留對話歷史
12)
13
14# 3. 開始對話
15response = sampler.chat("請用繁體中文解釋什麼是 Transformer 架構")
16print(response)
17
18# 4. 接續上一輪對話
19follow_up = sampler.chat("能用更簡單的比喻說明嗎？")
20print(follow_up)

4.2 多模態對話 (文字 + 影像)

Gemma 3 以上版本支援影像輸入：

 1from gemma import gm
 2from PIL import Image
 3
 4# 載入模型 (需包含 Vision Encoder)
 5model = gm.nn.Gemma4_E4B(text_only=False)  # text_only=False 啟用視覺
 6params = gm.ckpts.load_params(gm.ckpts.CheckpointPath.GEMMA4_E4B_IT)
 7
 8# 載入影像
 9image1 = Image.open("photo_a.jpg")
10image2 = Image.open("photo_b.jpg")
11
12# 建立 sampler
13sampler = gm.text.ChatSampler(
14    model=model,
15    params=params,
16    multi_turn=True,
17)
18
19# 使用 <|image|> 標記插入影像位置
20prompt = """請比較這兩張影像的差異：
21
22影像 1: <|image|>
23影像 2: <|image|>
24
25請用條列式說明主要差異。"""
26
27response = sampler.chat(prompt, images=[image1, image2])
28print(response)

4.3 Tool Use (工具呼叫)

Gemma 4 支援結構化的工具呼叫 (function calling)：

 1from gemma import gm
 2
 3model = gm.nn.Gemma4_E4B()
 4params = gm.ckpts.load_params(gm.ckpts.CheckpointPath.GEMMA4_E4B_IT)
 5
 6# 定義可用工具
 7tools = [
 8    {
 9        "name": "get_weather",
10        "description": "取得指定城市的天氣資訊",
11        "parameters": {
12            "city": {"type": "string", "description": "城市名稱"},
13            "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
14        }
15    }
16]
17
18# 使用 ToolSampler
19tool_sampler = gm.text.ToolSampler(
20    model=model,
21    params=params,
22    tools=tools,
23)
24
25response = tool_sampler.chat("台北現在天氣如何？")
26# 模型會輸出結構化的 tool call 請求

4.4 批次推論 (Batch Inference)

 1from gemma import gm
 2
 3model = gm.nn.Gemma4_E4B()
 4params = gm.ckpts.load_params(gm.ckpts.CheckpointPath.GEMMA4_E4B_IT)
 5
 6sampler = gm.text.Sampler(model=model, params=params)
 7
 8# 批次處理多個 prompt
 9prompts = [
10    "什麼是機器學習？",
11    "Python 和 JavaScript 的主要差異是什麼？",
12    "解釋 DNA 的結構。",
13]
14
15for prompt in prompts:
16    result = sampler.sample(prompt, max_tokens=256)
17    print(f"Q: {prompt}")
18    print(f"A: {result}\n")

4.5 量化推論 (Quantized Inference)

使用 INT4 量化版本以降低記憶體需求：

 1from gemma import gm
 2
 3# 載入量化版 checkpoint
 4model = gm.nn.Gemma3_4B()
 5params = gm.ckpts.load_params(
 6    gm.ckpts.CheckpointPath.GEMMA3_4B_IT,
 7    quantized=True,  # 載入 INT4 量化版
 8)
 9
10sampler = gm.text.ChatSampler(model=model, params=params)
11response = sampler.chat("用 Python 寫一個快速排序演算法")
12print(response)

4.6 多裝置分片 (Sharding)

大型模型需要跨多個 GPU/TPU 分片運行：

 1from gemma import gm
 2import jax
 3
 4# 檢視可用裝置
 5print(f"可用 GPU 數量: {len(jax.devices('gpu'))}")
 6
 7# 載入模型時自動分片
 8model = gm.nn.Gemma4_31B()
 9params = gm.ckpts.load_params(
10    gm.ckpts.CheckpointPath.GEMMA4_31B_IT,
11    # 分片策略會根據可用裝置自動調整
12)
13
14sampler = gm.text.ChatSampler(model=model, params=params)
15response = sampler.chat("解釋量子計算的基本原理")

4.7 使用流程總覽

flowchart TD
    START["開始"] --> CHOOSE{"選擇使用場景"}

    CHOOSE -->|"純文字對話"| TEXT["ChatSampler
multi_turn=True"]
    CHOOSE -->|"影像+文字"| MULTI["text_only=False
ChatSampler + images"]
    CHOOSE -->|"工具呼叫"| TOOL["ToolSampler
定義 tools schema"]
    CHOOSE -->|"批次處理"| BATCH["Sampler.sample()
迴圈處理"]

    TEXT --> LOAD["載入模型 + Checkpoint"]
    MULTI --> LOAD
    TOOL --> LOAD
    BATCH --> LOAD

    LOAD --> INFER["執行推論"]
    INFER --> OUTPUT["取得輸出"]

    OUTPUT --> CONTINUE{"繼續對話？"}
    CONTINUE -->|"是"| INFER
    CONTINUE -->|"否"| END["結束"]

    style START fill:#c8e6c9
    style END fill:#ffcdd2

5. 微調與客製化

5.1 微調策略總覽

Gemma 支援多種微調方法，適用於不同場景：

graph TD
    subgraph "Gemma 微調策略選擇"
        FT["微調需求"] --> Q1{"資料量與
計算資源？"}

        Q1 -->|"少量資料
有限 GPU"| LORA["LoRA
(Low-Rank Adaptation)"]
        Q1 -->|"充足資料
多 GPU"| FULL["Full Fine-tuning
全參數微調"]

        LORA --> L1["rank=4~64"]
        LORA --> L2["記憶體需求低"]
        LORA --> L3["適合領域適應"]

        FULL --> F1["更新所有參數"]
        FULL --> F2["需要大量 VRAM"]
        FULL --> F3["適合任務專化"]

        FT --> Q2{"對齊方法？"}
        Q2 -->|"偏好學習"| DPO["DPO
(Direct Preference Optimization)"]
        Q2 -->|"負面偏好"| NPO["NPO
(Negative Preference Optimization)"]
        Q2 -->|"監督式"| SFT["SFT
(Supervised Fine-Tuning)"]
    end

    style LORA fill:#e8f5e9
    style DPO fill:#e3f2fd
    style NPO fill:#fce4ec

5.2 LoRA 微調範例

LoRA (Low-Rank Adaptation; 低秩適應) 是最實用的微調方式，只訓練少量額外參數：

 1from gemma import gm
 2
 3# 1. 載入基礎模型
 4model = gm.nn.Gemma4_E4B()
 5params = gm.ckpts.load_params(gm.ckpts.CheckpointPath.GEMMA4_E4B_IT)
 6
 7# 2. 建立 LoRA 配置
 8lora_config = gm.peft.LoRAConfig(
 9    rank=16,          # LoRA rank (低 → 更少參數 / 高 → 更多表達力)
10    alpha=32,         # 縮放係數
11    target_modules=[  # 套用 LoRA 的模組
12        "q_proj",
13        "v_proj",
14    ],
15)
16
17# 3. 套用 LoRA 到模型
18lora_params = gm.peft.apply_lora(params, lora_config)
19
20# 4. 準備訓練資料
21train_data = gm.data.load_parquet("path/to/training_data.parquet")
22
23# 5. 執行微調
24# (實際訓練迴圈詳見 examples/lora.py)

5.3 SFT (Supervised Fine-Tuning; 監督式微調)

使用 examples/seq2seq.py 進行監督式微調：

 1# examples/seq2seq.py 的核心流程
 2
 3from gemma import gm
 4
 5# 準備 seq2seq 資料
 6# 格式: [{"input": "問題", "output": "答案"}, ...]
 7
 8# 使用 gm.data 模組處理資料
 9dataset = gm.data.create_dataset(
10    data_path="path/to/data.jsonl",
11    tokenizer=gm.text.Tokenizer(version=4),
12    max_length=2048,
13)
14
15# 訓練配置
16# 詳見 colabs/finetuning.ipynb

5.4 DPO (Direct Preference Optimization; 直接偏好最佳化)

DPO 用於根據人類偏好對齊模型行為：

 1from gemma.gm import losses
 2
 3# DPO 損失函數
 4# 需要成對的 (chosen, rejected) 回應
 5dpo_loss = losses.dpo_loss(
 6    policy_chosen_logps=chosen_logps,
 7    policy_rejected_logps=rejected_logps,
 8    reference_chosen_logps=ref_chosen_logps,
 9    reference_rejected_logps=ref_rejected_logps,
10    beta=0.1,  # KL 散度的溫度係數
11)

5.5 Diffusion Fine-tuning (擴散式微調)

v4.1.0 新增的 Diffusion Gemma 提供了另一種微調路徑，特別適合需要非自回歸生成的場景。儲存庫內含兩個完整範例：

• PubMedQA: 醫學問答任務微調 (hackable_diffusion_adapter/data/pubmedqa/)
• Sudoku: 數獨解題任務微調 (hackable_diffusion_adapter/data/sudoku/)

1# Diffusion fine-tuning 的核心概念
2# 模型學習從「噪聲 token 序列」去噪成「乾淨的回答」
3
4# 詳見 gemma/diffusion/hackable_diffusion_adapter/ 目錄
5# 包含完整的：
6# - 資料處理 (data/)
7# - 訓練配置 (configs/)
8# - 評估指標 (eval/)
9# - LoRA 支援 (hd/lora.py)

5.6 微調硬體需求對照

6. 與 AIKT 工具鏈的整合潛力

6.1 整合情境分析

AI-Knowledge Template (AIKT) 的多層工具鏈可從多個面向與 Gemma 結合：

graph TD
    subgraph "AIKT 工具鏈與 Gemma 整合點"
        GEMMA["Gemma
(Local LLM)"]

        GEMMA --> INT1["paper-qa-lite (Layer 10)
本地 RAG 問答後端"]
        GEMMA --> INT2["paper-tutorial (Layer 15)
論文摘要生成"]
        GEMMA --> INT3["ai-save (Layer 1)
URL 內容摘要"]
        GEMMA --> INT4["meeting-intel (Layer 14)
會前情資分析"]
        GEMMA --> INT5["research-pipeline-v2 (Layer 18)
多管線研究工作流"]
    end

    subgraph "整合價值"
        V1["離線運作
無需外部 API"]
        V2["機密資料
不出本地"]
        V3["成本控制
無 token 費用"]
        V4["客製微調
領域專化"]
    end

    INT1 --> V1
    INT4 --> V2
    INT1 --> V3
    GEMMA --> V4

    style GEMMA fill:#bbdefb
    style V2 fill:#ffcdd2

6.2 paper-qa-lite 整合

Gemma 可作為 paper-qa-lite (Layer 10) 的本地推論後端 (local inference backend)，取代雲端 API 呼叫：

 1# 概念性整合：用 Gemma 回答基於論文的問題
 2from gemma import gm
 3
 4model = gm.nn.Gemma4_E4B()
 5params = gm.ckpts.load_params(gm.ckpts.CheckpointPath.GEMMA4_E4B_IT)
 6
 7sampler = gm.text.ChatSampler(model=model, params=params)
 8
 9# 將論文段落作為 context 餵入
10paper_context = """
11[Paper excerpt from local RAG retrieval]
12Methods: We performed single-cell RNA sequencing on 10,000 cells...
13"""
14
15question = "這篇論文使用了什麼實驗方法？"
16prompt = f"根據以下論文內容回答問題：\n\n{paper_context}\n\n問題：{question}"
17
18response = sampler.chat(prompt)

6.3 機密資料處理場景

• 所有資料留在本地，不經任何外部 API
• 符合 AIKT 的機密邊界規範
• 可在 air-gapped (隔離網路) 環境中運作

6.4 多模態應用於知識管理

Gemma 4 的視覺 (Vision) 能力可強化 AIKT 的文件處理流程：

• docling (Layer 8): 用 Gemma Vision 理解 PDF 中的複雜圖表
• video-to-tutorial (Layer 17): 用 Gemma 多模態理解影片截圖
• graphify (Layer 4): 用 Gemma 生成知識圖的節點描述

6.5 微調用於領域專化

針對生物醫學 (biomedical) 領域，可將 Gemma 微調為專用的論文理解模型：

flowchart LR
    subgraph "領域微調工作流"
        D1["paper-search
(Layer 9)"] -->|"收集論文"| D2["docling
(Layer 8)"]
        D2 -->|"轉為 Markdown"| D3["準備訓練資料
(SFT pairs)"]
        D3 -->|"LoRA 微調"| D4["Gemma-Bio
(領域模型)"]
        D4 -->|"部署"| D5["paper-qa-lite
(Layer 10)"]
    end

    style D4 fill:#c8e6c9

7. 常見問題與限制

7.1 常見問題 (FAQ)

Q1: Gemma 與 Gemini 的差異是什麼？

Gemini 是 Google 的閉源 (closed-source) 商用模型，透過 API 存取。Gemma 是基於 Gemini 研究技術的開放權重模型，可下載並在本地運行。Gemma 的參數規模較小（最大 31B vs Gemini 數千億），但授權自由度高。

Q2: 為什麼使用 JAX 而不是 PyTorch？

Google DeepMind 的研究基礎建立在 JAX 之上。JAX 提供：

• 原生 XLA (Accelerated Linear Algebra) 編譯
• TPU 一等支援
• 函數式程式設計風格，易於分片與平行化
• jit 編譯可大幅加速推論

若需要 PyTorch 版本，可使用 HuggingFace Transformers 的 Gemma 實作。

Q3: INT4 量化對品質的影響大嗎？

官方提供的 INT4 量化 checkpoint 經過 Quantization-Aware Training (QAT; 量化感知訓練)，品質損失相對較小。對大多數應用場景影響可控，但在需要精確推理的任務上可能有退化。

Q4: 如何選擇模型大小？

Q5: Diffusion Gemma 何時應該使用？

Diffusion LLM 仍處於實驗性階段。它的優勢在於：

• 可並行生成所有 token（非自回歸）
• 可在生成過程中進行全局修正
• 適合結構化輸出任務（如表格填充、數獨解題）

目前不建議用於一般對話場景。

7.2 已知限制

7.2.1 框架限制

• 僅支援 JAX: 官方實作僅提供 JAX 版本。PyTorch / TensorFlow 使用者需透過 HuggingFace 或其他社群實作
• Checkpoint 格式: 使用 Flax 格式，無法直接與 GGUF / SafeTensors 互通
• JAX 安裝: JAX 的 GPU 版本安裝有時不夠直觀，尤其是 CUDA 版本匹配

7.2.2 模型限制

• Context Length (上下文長度): 受 Sliding Window 大小限制，Local Attention 的有效視窗在 512–4096 token 之間
• 語言偏向: 主要以英文為主訓練，中文能力與專用中文模型仍有差距
• 幻覺 (Hallucination): 開放權重模型普遍存在的問題，需搭配 RAG 等技術緩解
• 即時知識: 訓練資料有截止日期，無法回答最新事件

7.2.3 部署限制

• 記憶體需求: 大模型需要多 GPU 分片，增加部署複雜度
• MoE 模型: 26B-A4B 雖然活化參數少，但仍需載入全部 26B 參數到記憶體
• 音訊支援: Gemma 4 的 Audio Encoder (Conformer) 目前僅限特定模型變體

7.3 替代方案比較

7.4 除錯技巧

 1# 1. 檢查 JAX 是否偵測到 GPU
 2import jax
 3print(jax.devices())  # 應顯示 GpuDevice
 4
 5# 2. 記憶體不足時的處理
 6import os
 7os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"] = "0.9"  # 限制 GPU 記憶體使用比例
 8
 9# 3. 啟用 JAX 的 debug 模式
10jax.config.update("jax_debug_nans", True)  # 偵測 NaN 值
11
12# 4. 檢查模型載入是否成功
13model = gm.nn.Gemma4_E4B()
14print(f"模型層數: {model.config.num_layers}")
15print(f"Embed dim: {model.config.embed_dim}")
16print(f"Attention types: {model.config.attention_types[:6]}")

附錄：參考資源

技術報告

官方 Colab 筆記本

相關連結

• Gemma 生態系統 — 其他框架的 Gemma 實作
• Gemma PyPI — Python 套件頁面
• ReadTheDocs 文件 — 完整 API 文件
• JAX 安裝指南 — JAX 環境設定

本教學基於 google-deepmind/gemma v4.1.0 (2026-06-11) 撰寫。 最後更新：2026-06-20