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 が必要。そんなもの、1枚のグラボで持ってる人はいません。でも、適切な量子化とツールを使えば、24GB の RTX 4090 で動かせるし、16GB のグラボでも部分的に CPU にオフロードすればいけます。GPU インスタンスが必要だけど長期契約は避けたいなら、LightNode を VPS プロバイダーとしておすすめします。

このガイドでは4つの方法を紹介します。Unsloth がほとんどの人にとってのイチオシです。

目次

1. Gemma 4 モデルファミリー概要
2. ハードウェア要件
3. 方法1：Unsloth Studio（推奨）
4. 方法2：Ollama
5. 方法3：llama.cpp
6. 方法4：HuggingFace Transformers
7. GGUF 量子化フォーマットを理解する
8. パフォーマンスのヒント
9. トラブルシューティング
10. どの方法を選ぶべき？

Gemma 4 モデルファミリー概要

Gemma 4 は4つのサイズがあります。適切なものを選ぶことが大事で、ハードウェア要件の差が結構大きいからです。

バリアント	総パラメータ	アクティブパラメータ	コンテキスト	モダリティ	用途
E2B	5.1B	2.3B（実効）	128K	テキスト、画像、音声	スマホ、ラズベリーパイ
E4B	8B	4.5B（実効）	128K	テキスト、画像、音声	ノートPC、CPUのみ
26B A4B (MoE)	25.2B	3.8B（アクティブ）	256K	テキスト、画像	高速推論、省VRAM
31B（Dense）	30.7B	30.7B	256K	テキスト、画像	最高品質

26B A4B は一番賢いやつです。総パラメータ 25.2B だけど、推論時にアクティブになるのは 3.8B だけ。Mixture-of-Experts アーキテクチャのおかげです（128人の専門家から8人がアクティブ、プラス1人の共有専門家）。4B モデルとほぼ同じ速度で動きながら、品質はフル 31B に迫ります。GPU の VRAM が 12-16GB なら、26B A4B の Q4 量子化がベストチョイスでしょう。

31B Dense がこのガイドのメインです。すべてのパラメータが毎回の forward pass でフルに動く、完全仕様のモデル。最高品質、最高のハードウェア要件。

4つのバリアントすべてが、設定可能な思考モード（Chain-of-Thought 推論）、ネイティブシステムプロンプト、関数呼び出し、140以上の言語に対応しています。

ハードウェア要件

方法を選ぶ前に、まず自分のハードウェアを確認しましょう。

Gemma 4 31B-it

量子化	必要な VRAM	品質低下	代表的なハードウェア
FP16（フル精度）	~62 GB	なし	A100、マルチGPU
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 にレイヤーをオフロードするならもっと必要。

方法1：Unsloth Studio（推奨）

Unsloth は Gemma 4 を動かす一番簡単な方法です。Web UI で、モデルのダウンロードも量子化の選択も推論も全部まとまってる。Windows、Linux、macOS、WSL に対応してます。

なぜ Unsloth がいいか

• ワンクリックで HuggingFace からモデルを検索＆ダウンロード
• ハードウェアに合った GGUF 量子化を自動で選択
• 画像、PDF、ドキュメントに対応した内蔵チャットインターフェース
• ツール呼び出しと Web 検索が組み込み済み
• コード実行サンドボックス
• コマンドラインの格闘不要

インストール

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 GPU なら 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」オプションをオンにします。これで Chain-of-Thought 推論が有効になり、モデルが最終回答を出す前にステップバイステップで問題に取り組みます。

Unsloth でファインチューニング

推論だけじゃなくてトレーニングもやりたいなら、Unsloth はそこもカバーしてます：

• LoRA ファインチューニング：アダプターのトレーニングで VRAM 使用量を最大 70% 削減
• GRPO 強化学習：現在最も効率的な RL ライブラリ
• データレシピ：PDF、CSV、DOCX ファイルからトレーニングデータセットを自動作成
• マルチ GPU サポート：利用可能、改良も継続中

Gemma 4 31B のファインチューニングには、QLoRA（4-bit 量子化トレーニング）を使って最低でも 24GB の GPU が1枚必要です。

Unsloth のアップデート

同じインストールコマンドを再度実行するだけ：

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

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

方法2：Ollama

コマンドライン派なら、Ollama が最速のスタート方法です。モデルのダウンロード、GPU 検出、サービングを全部自動でやってくれます。

インストール

# macOS
brew install ollama

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

# Windows
# https://ollama.com/download からダウンロード

Gemma 4 を動かす

# 31B モデルを pull して実行
ollama run gemma4:31b-it

# または、より VRAM が少ない 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 自動検出、シンプルな CLI、API サーバー内蔵、モデル管理が簡単。

デメリット：llama.cpp より量子化オプションが少ない、全モデルで内蔵画像機能がサポートされていない場合がある（現在の互換性を確認してください）、推論パラメータの制御が少ない。

方法3：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 GPU に推奨）
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 で約3分の2のレイヤーをオフロード）
• -c 8192：コンテキスト長（トークン数）。長いドキュメントには最大 256K まで増やせるが、コンテキストが長いほど VRAM を消費
• --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 の VRAM がフルモデルの読み込みに足りない場合、レイヤーを GPU と CPU の間で分割できます：

# 16GB GPU で 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/秒くらい。

方法4：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 は Chain-of-Thought 推論をサポート。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 GPU にフィット
Q3_K_M	3-bit	~14 GB	小さい GPU、品質低下あり
Q2_K	2-bit	~10 GB	最後の手段、品質低下が顕著

おすすめ：24GB GPU なら Q4_K_M、あと 4GB 余裕があるなら Q5_K_M。Q4_K_M と Q5_K_M の差はベンチマークでは計測できるけど、日常的な使用ではほとんど気になりません。Q3_K_M を下回るのは、他に選択肢がない場合だけ。

_K_M サフィックスは「K-quantization、中」を意味します。_K_S（小、圧縮多め）と _K_L（大、圧縮少なめ）のバリアントもあります。_K_M がデフォルトのおすすめです。

パフォーマンスのヒント

コンテキスト長の管理

Gemma 4 31B は最大 256K トークンのコンテキストに対応していますが、コンテキスト内の各トークンが VRAM を消費します。実用的な目安：

• 4K トークン：モデルが載る GPU ならどれでも余裕
• 8K トークン：ほとんどの会話の標準、まだ余裕
• 32K トークン：量子化によって 4-6GB の追加 VRAM が必要
• 128K+ トークン：大量の VRAM または積極的なオフロードが必要

-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 セットアップ

複数の 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 バリアントを使う：同じ品質レベルで、VRAM はほんの一部
5. E4B バリアントを使う：どんなマシンでも動く

CPU 推論が遅い

CPU で動かしている場合、31B モデルは約 1-3 tokens/秒。選択肢：

• E4B または E2B モデルに切り替える（CPU で 10-20 tok/s）
• GPU クラウドインスタンスを使う（LightNode が GPU VPS オプションを提供）
• CPU の命令セット（AVX2、AVX-512）を有効にして llama.cpp をビルド

モデルのダウンロード失敗

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

どの方法を選ぶべき？

シナリオ	ベストな方法
GUI がいい、ターミナルは触りたくない	Unsloth Studio
最速で始めたい、CLI は OK	Ollama
推論を最大限に制御したい	llama.cpp
アプリケーションを開発している	HuggingFace Transformers
VRAM が限られている（8-16GB）	Unsloth または Ollama、Q3/Q4 で
24GB+ VRAM がある	どの方法でも OK、Q4_K_M か Q5_K_M で
画像理解が必要	Unsloth Studio または HuggingFace Transformers
ファインチューニングしたい	Unsloth（LoRA/GRPO トレーニング内蔵）

これから始めるほとんどの人には、Unsloth Studio が一番の近道です。インストールして、Gemma 4 を検索して、GPU に合った量子化を選んで、チャットを始めるだけ。インストールから最初の会話まで、だいたい 15 分で終わります。

ターミナルに慣れていてただモデルを動かしたいなら、Ollama なら2つのコマンドでいけます。プログラム的なアクセスが必要な場合や、モデルの上に何かを構築するなら、HuggingFace Transformers の 4-bit 量子化で完全な Python API が使えます。

まとめ

Gemma 4 31B をローカルで動かすことが、驚くほど実用的になりました。1年前なら、この品質レベルの 30B モデルは研究プロジェクトでした。今では Unsloth や Ollama で 15 分のセットアップで済み、今買えるコンシューマーハードウェアで動きます。

モデル自体も、推論、コーディング、マルチモーダルタスクにおいてプロプライエタリな代替に十分対抗できます。256K コンテキスト、内蔵思考モード、画像理解、関数呼び出しが揃っていて、実験としてだけでなく、実際の仕事に本当に使えるものになっています。

リモート GPU でモデルをホストするなら、LightNode が時間課金の GPU VPS インスタンスを提供しています。必要な時に立ち上げて、終わったらシャットダウンすれば OK です。

Gemma 4 モデルカード（HuggingFace） に完全な技術詳細があり、Unsloth GGUF リポジトリ にはすべての量子化バリアントがダウンロード可能です。