もし Gemma-4 E2B と E4B の loss が 13〜15 であっても、これはまったく正常です — これはマルチモーダルモデルによくある挙動です。Gemma-3N、Llama Vision、Mistral の vision モデルなどでも起こりました。

Gemma 26B と 31B は loss が 1〜3 かそれ以下で低めになります。ビジョンでは 2 倍高くなるので 3〜5 になります

🍇勾配蓄積によって loss が水増しされることがあります

loss が 13〜15 より高い（100 や 300 など）場合、たいていは勾配蓄積が正しく考慮されていません — 私たちは これを Unsloth と Unsloth Studio の一部として修正しました。

勾配蓄積について詳しくは、勾配蓄積のバグ修正ブログをご覧ください： https://unsloth.ai/blog/gradient

⁉️Gemma-4 31B と 26B-A4B の推論での IndexError

31B と 26B で推論を行うと、このエラーが表示されることがあります：

File "/.../cache_utils.py", line 937, in update
    keys, values = self.layers[layer_idx].update(...)
IndexError: list index out of range

原因は以下です：

if hasattr(decoder_config, "num_kv_shared_layers"):
    layer_types = layer_types[: -decoder_config.num_kv_shared_layers]

Gemma-4 31B と 26B-A4B には num_kv_shared_layers = 0。Python では、 -0 == 0なので layer_types[:-0] は layer_types[:0] == []。キャッシュは 0 個のレイヤースロットで構築され、最初の attention の forward が以下でクラッシュします Cache.update.

⛔ `use_cache = True` E2B、E4B の生成は意味不明でした

次の issue を参照： "[Gemma 4] use_cache=False が attention 計算を壊し、ゴミの logits を生成する #45242"

Gemma-4 E2B と E4B はレイヤー間で KV 状態を共有します（num_kv_shared_layers = 20 および 18）。キャッシュは、初期レイヤーが KV を保存し、後続レイヤーが再利用する唯一の場所です。 use_cache=False （すべての QLoRA チュートリアルが設定するように、また gradient_checkpointing=True が強制するように）、 Gemma4TextModel.forward キャッシュ構築がスキップされ、そのため KV 共有レイヤーは現在の隠れ状態からローカルに K と V を再計算する処理に落ちます。logits は壊れ、学習 loss は発散します。

修正前（unsloth/gemma-4-E2B-it、プロンプト「1+1 は？」）：

use_cache=True  -> '1 + 1 = **2**'
use_cache=False -> 'BROAD\肯. Specificallyboard K supposed\_n통  \\'
max_abs_logit_diff: 48.937500

修正後：

use_cache=True  -> '1 + 1 = **2**'
use_cache=False -> '1 + 1 = **2**'
max_abs_logit_diff: 0.000000     （ビット完全一致、9トークンすべてが同一）

📻音声の float16 オーバーフロー

Gemma4AudioAttention で使用します config.attention_invalid_logits_value = -1e9 の masked_fill 呼び出しで。fp16（Tesla T4）では、-1e9 が fp16 の最大値 65504 をオーバーフローし、次を引き起こします：

RuntimeError: value cannot be converted to type c10::Half without overflow

原因は self.config.attention_invalid_logits_value :

attn_weights = attn_weights.masked_fill(
    attention_mask.logical_not(), self.config.attention_invalid_logits_value
)

💡Gemma-4 のヒント

もし 推論能力を維持したい 場合は、推論スタイルの例と直接回答を混ぜることができます（推論を最低 75% に保ってください）。そうでなければ、完全にそのまま出力しても構いません。使用するのは gemma-4 です。思考なしのチャットテンプレートには gemma-4-thinking 思考版を使ってください。大きい 26B と 31B には思考版、小さいものには思考なし版を使います。
```
from unsloth.chat_templates import get_chat_template
tokenizer = get_chat_template(
    tokenizer,
    chat_template = "gemma-4-thinking", # Or "gemma-4"
)
```
思考モードを有効にするには enable_thinking = True / False で tokenizer.apply_chat_template
思考有効：
```
processor.tokenizer.apply_chat_template([
    {"role" : "user", "content" : "2+2 は何ですか？"},
], tokenize = False, enable_thinking = True, add_generation_prompt = True)
```
次を出力します <bos><|turn>system\n<|think|><turn|>\n<|turn>user\n2+2 は何ですか？<turn|>\n<|turn>model\n
思考無効：
```
processor.tokenizer.apply_chat_template([
    {"role" : "user", "content" : "2+2 は何ですか？"},
], tokenize = False, enable_thinking = False, add_generation_prompt = True)
```
次を出力します <bos><|turn>user\n2+2 は何ですか？<turn|>\n<|turn>model\n<|channel>thought\n<channel|>
Gemma 4 は140言語をサポートしており、多言語ファインチューニングに強力です。
学習することを推奨します E4B QLoRA ではなく E2B LoRA E4B のほうが大きく、量子化精度の差はごくわずかだからです。Gemma 4 E4B LoRA はさらに優れています。
ファインチューニング後は、次へエクスポートできます GGUF （llama.cpp/Unsloth/Ollama など用）

⚡クイックスタート

🦥 Unsloth Studio ガイド

Gemma 4 は次で実行・ファインチューニングできます Unsloth Studio、ローカル AI 向けの新しいオープンソース Web UI です。

Unsloth Studio なら、モデルをローカルで次の環境で実行できます MacOS、Windows、Linux 上で NVIDIA GPU を使って学習できます。Intel、MLX、AMD の学習サポートも今月中に登場予定です。

Unsloth をインストール

ターミナルで実行：

MacOS、Linux、WSL：

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

Windows PowerShell：

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

インストールはすぐに完了し、約1〜2分かかります。

Unsloth を起動

MacOS、Linux、WSL および Windows：

unsloth studio -H 0.0.0.0 -p 8888

その後、次を開いてください http://localhost:8888 をブラウザで。

Gemma 4 を学習

初回起動時には、アカウントを保護するためのパスワードを作成し、後で再度サインインする必要があります。その後、モデル、データセット、基本設定を選ぶ簡単なオンボーディングウィザードが表示されます。いつでもスキップできます。

検索バーで Gemma 4 を検索し、希望のモデルとデータセットを選択します。次に、ハイパーパラメータやコンテキスト長を必要に応じて調整します。

学習の進捗を監視

学習開始をクリックすると、モデルの学習進捗を監視・確認できます。学習 loss は着実に減少しているはずです。完了すると、モデルは自動的に保存されます。

ファインチューニングしたモデルをエクスポート

完了すると、Unsloth Studio ではモデルを GGUF、safetensor などの形式にエクスポートできます。

ファインチューニング済みモデルと元のモデルを比較

をクリック 比較モード して、LoRA アダプターと元のモデルを比較します。

🦥 Unsloth Core（コードベース）ガイド

Gemma 4 用の無料ノートブックを作成しました：

E4B （推論 + テキスト）

E4B （ビジョン + テキスト）

E4B （音声）

31B （Kaggle）

E2B （ビジョン + テキスト）

E2B （音声）

また、強化学習（RL）用にも作成しました： E2B （RL GRPO）

より大きな Gemma 4 モデル用のノートブックもありますが、A100 が必要です：

Gemma-4-26B-A4B - A100 GPU

Gemma-4-31B - A100 GPU

次を行いたい場合は GRPO、高速 vLLM 推論を無効にして Unsloth 推論を使えば Unsloth で動作します。以下の ビジョン RL ノートブック例に従ってください。

以下は独立した Gemma-4-26B-A4B-it のテキスト SFT レシピです。これはテキストのみです — 詳しくはビジョンのファインチューニングセクションも参照してください。

from unsloth import FastModel
import torch

model, tokenizer = FastModel.from_pretrained(
    model_name = "unsloth/gemma-4-26B-A4B-it", # この値を unsloth/gemma-4-E2B-it などに変更
    dtype = None, # 自動検出の場合は None
    max_seq_length = 8192, # 長いコンテキスト用に任意の値を選択！
    load_in_4bit = True,  # メモリ削減のための 4bit 量子化
    full_finetuning = False, # [NEW!] いまはフルファインチューニングが使えます！
    # token = "YOUR_HF_TOKEN", # ゲート付きモデル用の HF トークン
)

"""# Gemma 4 はテキスト、ビジョン、音声を処理できます！

まずは、Gemma 4 がマルチモーダル入力をどのように扱えるか見てみましょう。Gemma 4 の推奨設定である `temperature = 1.0, top_p = 0.95, top_k = 64` を使います
"""

from transformers import TextStreamer
# 推論用のヘルパー関数
def do_gemma_4_inference(messages, max_new_tokens = 128):
    _ = model.generate(
        **tokenizer.apply_chat_template(
            messages,
            add_generation_prompt = True, # 生成のために必須
            tokenize = True,
            return_dict = True,
            return_tensors = "pt",
        ).to("cuda"),
        max_new_tokens = max_new_tokens,
        use_cache=True,
        temperature = 1.0, top_p = 0.95, top_k = 64,
        streamer = TextStreamer(tokenizer, skip_prompt = True),
    )

"""# Gemma 4 は画像を見られます！

<img src="https://files.worldwildlife.org/wwfcmsprod/images/Sloth_Sitting_iStock_3_12_2014/story_full_width/8l7pbjmj29_iStock_000011145477Large_mini__1_.jpg" alt="代替テキスト" height="256">
"""

sloth_link = "https://files.worldwildlife.org/wwfcmsprod/images/Sloth_Sitting_iStock_3_12_2014/story_full_width/8l7pbjmj29_iStock_000011145477Large_mini__1_.jpg"

messages = [{
    "role" : "user",
    "content": [
        { "type": "image", "image" : sloth_link },
        { "type": "text",  "text" : "この動物が出演している映画はどれですか？" }
    ]
}]
# Unsloth の自動コンパイラには 1 分待つ必要があるかもしれません
do_gemma_4_inference(messages, max_new_tokens = 256)

"""ナマケモノについて詩を作ろう！"""

messages = [{
    "role": "user",
    "content": [{ "type" : "text",
                  "text" : "ナマケモノについて詩を書いてください。" }]
}]
do_gemma_4_inference(messages)

"""# Gemma 4 をファインチューニングしましょう！

いまは選択によってビジョンとテキスト部分をファインチューニングできます。音声部分もファインチューニング可能で、そちらも選択できるように取り組んでいます！

ここで LoRA アダプターを追加し、更新する必要があるパラメータ数を少なくします！
"""

model = FastModel.get_peft_model(
    model,
    finetune_vision_layers     = False, # テキストのみならオフ！
    finetune_language_layers   = True,  # オンのままにしてください！
    finetune_attention_modules = True,  # Attention は GRPO に有効
    finetune_mlp_modules       = True,  # 常にオンのままにしてください！

    r = 8,           # 大きいほど精度は高いが、過学習する可能性あり
    lora_alpha = 8,  # 推奨 alpha は少なくとも r と同じ
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
)

"""<a name="Data"></a>
### データ準備
ここでは会話スタイルのファインチューニングに `Gemma-4` フォーマットを使います。ShareGPT 形式の [Maxime Labonne の FineTome-100k](https://huggingface.co/datasets/mlabonne/FineTome-100k) データセットを使います。Gemma-4 は以下のような複数ターンの会話をレンダリングします：

```
<bos><|turn>user
こんにちは<turn|>
<|turn>model
やあ！<turn|>
```
正しいチャットテンプレートを取得するために、私たちの `get_chat_template` 関数を使います。`zephyr, chatml, mistral, llama, alpaca, vicuna, vicuna_old, phi3, llama3, phi4, qwen2.5, gemma3, gemma-4` などをサポートしています。
"""

from unsloth.chat_templates import get_chat_template
tokenizer = get_chat_template(
    tokenizer,
    chat_template = "gemma-4-thinking",
)

"""データセットの最初の3000行を取得します"""

from datasets import load_dataset
dataset = load_dataset("mlabonne/FineTome-100k", split = "train[:3000]")

"""ここで `standardize_data_formats` を使い、ファインチューニング用にデータセットを正しい形式へ変換してみます！"""

from unsloth.chat_templates import standardize_data_formats
dataset = standardize_data_formats(dataset)

"""100 行目がどのように見えるか見てみましょう！"""

dataset[100]

"""ここで会話に `Gemma-3` のチャットテンプレートを適用し、`text` に保存する必要があります。ファインチューニング中なので、`removeprefix(`'<bos>'`)` を使って `<bos>` トークンを削除します。Processor は学習前にこのトークンを追加し、モデルは 1 つだけを想定しています。"""

def formatting_prompts_func(examples):
   convos = examples["conversations"]
   texts = [tokenizer.apply_chat_template(convo, tokenize = False, add_generation_prompt = False).removeprefix('<bos>') for convo in convos]
   return { "text" : texts, }

dataset = dataset.map(formatting_prompts_func, batched = True)

"""チャットテンプレートがどう適用されたか見てみましょう！ processor tokenizer が `<bos>` トークンを追加するので、`<bos>` トークンがないことに注目してください。"""

dataset[100]["text"]

"""<a name="Train"></a>
### モデルを学習
ではモデルを学習しましょう。処理を速くするために 60 ステップだけ行いますが、完全に実行するには `num_train_epochs=1` を設定し、`max_steps=None` をオフにできます。
"""

from trl import SFTTrainer, SFTConfig
trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset,
    eval_dataset = None, # 評価を設定できます！
    args = SFTConfig(
        dataset_text_field = "text",
        per_device_train_batch_size = 1,
        gradient_accumulation_steps = 4, # GA を使ってバッチサイズを模倣します！
        warmup_steps = 5,
        # num_train_epochs = 1, # 1 回の完全学習実行に設定します。
        max_steps = 60,
        learning_rate = 2e-4, # 長い学習では 2e-5 に下げてください
        logging_steps = 1,
        optim = "adamw_8bit",
        weight_decay = 0.001,
        lr_scheduler_type = "linear",
        seed = 3407,
        report_to = "none", # TrackIO/WandB などを使用
    ),
)

"""また、Unsloth の `train_on_completions` メソッドを使って、アシスタントの出力のみに学習し、ユーザー入力の loss は無視します。これによりファインチューニングの精度向上に役立ちます！"""

from unsloth.chat_templates import train_on_responses_only
trainer = train_on_responses_only(
    trainer,
    instruction_part = "<|turn>user\n",
    response_part = "<|turn>model\n",
)

"""では、指示部分のマスキングが正しくできているか確認しましょう！もう一度100行目を表示します。サンプルには期待どおり `<bos>` が1つだけ含まれているのが分かります！"""

tokenizer.decode(trainer.train_dataset[100]["input_ids"])

"""では、マスクされた例を表示してみましょう。答えだけが含まれているはずです："""

tokenizer.decode([tokenizer.pad_token_id if x == -100 else x for x in trainer.train_dataset[100]["labels"]]).replace(tokenizer.pad_token, " ")

"""# モデルを学習させましょう！

学習を再開するには、`trainer.train(resume_from_checkpoint = True)` を設定します
"""

trainer_stats = trainer.train()

OOM が発生したら：

下げる per_device_train_batch_size を 1 にし、必要に応じて max_seq_length.
を維持する use_gradient_checkpointing="unsloth" をオンにします（VRAM使用量を減らし、コンテキスト長を伸ばすために設計されています）。

MoE（bf16 LoRA）用の読み込み例：

import os
import torch
from unsloth import FastModel

model, tokenizer = FastModel.from_pretrained(
    model_name = "unsloth/Gemma-4-26B-A4B-it",
    max_seq_length = 2048,
    load_in_4bit = False,     # MoE QLoRA は推奨されません。dense 31B なら問題ありません
    load_in_16bit = True,     # bf16/16-bit LoRA
    full_finetuning = False,
)

読み込んだら、LoRAアダプタを追加し、上のSFT例と同様に学習します。

強化学習（RL）

これで Gemma 4 を RL、GSPO、GRPO などで学習できるようになりました。無料ノートブック.

Gemma 4 E2B RL は 9GB で動作します。

Google Colabcolab.research.google.com

このノートブックの目的は、Gemma 4 に Sudoku パズルの解き方を学習させることです。 GRPO.

モデルは空白マスを埋める戦略を考案し、正しい配置や有効なパズルの完成に対して報酬を与えます。

vLLM ではサポートされていませんが、次の設定にすることで Unsloth で Gemma 4 RL を実行できます。 fast_inference=False モデルを読み込むときに：

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/gemma-4-E2B-it",
    fast_inference=False,
)

MoEファインチューニング（26B-A4B）

この 26B-A4B モデルは、Gemma 4 ラインナップの中で速度と品質の中間にあたります。これは MoE モデルで、トークンごとに有効になるパラメータが一部だけなので、保守的なファインチューニング方法は次のとおりです：

使う LoRA を、フルファインチューニングではなく
優先する 16-bit / bf16 LoRA もしメモリに余裕があるなら
まずは短いコンテキストと小さいランクから始める
パイプラインが安定してからのみ拡張する

最高品質を目指し、さらにメモリに余裕があるなら、代わりに 31B を使ってください。

マルチモーダルファインチューニング（E2B / E4B）

なぜなら E2B および E4B サポート画像および音声に対応しているため、これらがマルチモーダルファインチューニング向けの主な Gemma 4 バリアントです。

マルチモーダルモデルを FastVisionModel
で読み込み、 finetune_vision_layers = False をまず
言語、アテンション、MLP レイヤーだけをファインチューニングする
必要に応じて後から vision か audio レイヤーを有効にする

Gemma 4 マルチモーダル LoRA の例：

from unsloth import FastVisionModel # LLM 用は FastLanguageModel
import torch

model, processor = FastVisionModel.from_pretrained(
    "unsloth/gemma-4-26B-A4B-it",
    load_in_4bit = True, # メモリ使用量を減らすために 4bit を使用。16bit LoRA の場合は False。
    use_gradient_checkpointing = "unsloth", # 長いコンテキストでは True か "unsloth"
)

"""ここで、パラメータ効率の高いファインチューニングのために LoRA アダプタを追加します。これにより、全モデルパラメータのわずか 1% だけを効率的に学習できます。

**[NEW]** さらに、vision コンポーネントのみ、language コンポーネントのみ、または両方をファインチューニングすることもサポートしています。加えて、attention モジュール、MLP レイヤー、またはその両方をファインチューニングするか選べます！
"""

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = True, # vision レイヤーをファインチューニングしない場合は False
    finetune_language_layers   = True, # language レイヤーをファインチューニングしない場合は False
    finetune_attention_modules = True, # attention レイヤーをファインチューニングしない場合は False
    finetune_mlp_modules       = True, # MLP レイヤーをファインチューニングしない場合は False

    r = 32,                           # 大きいほど精度は高くなりますが、過学習する可能性があります
    lora_alpha = 32,                  # 推奨される alpha は少なくとも r と同じ
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
    use_rslora = False,               # rank stabilized LoRA をサポートしています
    loftq_config = None,               # そして LoftQ も
    target_modules = "all-linear",    # これは任意になりました！必要ならリストを指定できます
)

"""<a name="Data"></a>
### データ準備
手書き数式のサンプルデータセットを使用します。目的は、これらの画像をコンピュータで読める形式、具体的には LaTeX に変換し、レンダリングできるようにすることです。これは複雑な式で特に役立ちます。

データセットには[こちら](https://huggingface.co/datasets/unsloth/LaTeX_OCR)からアクセスできます。完全なデータセットは[こちら](https://huggingface.co/datasets/linxy/LaTeX_OCR)です。
"""

from datasets import load_dataset
dataset = load_dataset("unsloth/LaTeX_OCR", split = "train")

"""データセットの概要を見てみましょう。2枚目の画像とそれに対応するキャプションを確認します。"""

dataset

dataset[2]["image"]

dataset[2]["text"]

"""LaTeX はブラウザ上で直接レンダリングすることもできます！"""

from IPython.display import display, Math, Latex

latex = dataset[3]["text"]
display(Math(latex))

"""データセットを整形するには、すべての vision ファインチューニングタスクは次の形式に従う必要があります：

```python
[
    {
        "role": "user",
        "content": [
            {"type": "text", "text": instruction},
            {"type": "image", "image": sample["image"]},
        ],
    },
    {
        "role": "user",
        "content": [
            {"type": "text", "text": instruction},
            {"type": "image", "image": sample["image"]},
        ],
    },
]
```
"""

instruction = "この画像の LaTeX 表現を書いてください。"

def convert_to_conversation(sample):
    conversation = [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": instruction},
                {"type": "image", "image": sample["image"]},
            ],
        },
        {"role": "assistant", "content": [{"type": "text", "text": sample["text"]}]},
    ]
    return {"messages": conversation}
pass

"""データセットをファインチューニング用の「正しい」形式に変換しましょう："""

converted_dataset = [convert_to_conversation(sample) for sample in dataset]

"""最初の例は次のように構造化されます："""

converted_dataset[0]

"""Gemma 4 の instruction チャットテンプレートを取り入れ、ベースモデルで使ってみましょう"""

from unsloth import get_chat_template

processor = get_chat_template(
    processor,
    "gemma-4-thinking"
)

"""ファインチューニング前に、ベースモデルの性能を評価してみましょう。このチャットテンプレートをまだ見ていないため、強い結果は期待しません。"""

image = dataset[2]["image"]
instruction = "この画像の LaTeX 表現を書いてください。"

messages = [
    {
        "role": "user",
        "content": [{"type": "image"}, {"type": "text", "text": instruction}],
    }
]
input_text = processor.apply_chat_template(messages, add_generation_prompt = True)
inputs = processor(
    image,
    input_text,
    add_special_tokens = False,
    return_tensors = "pt",
).to("cuda")

from transformers import TextStreamer

text_streamer = TextStreamer(processor, skip_prompt = True)
result = model.generate(**inputs, streamer = text_streamer, max_new_tokens = 128,
                        use_cache = True, temperature = 1.0, top_p = 0.95, top_k = 64)

"""これは完全にひどいことが分かります！まったく指示に従っていません

<a name="Train"></a>
### モデルを学習
さあ、モデルを学習させましょう。高速化のために 60 ステップだけ実行しますが、完全な実行では `num_train_epochs=1` を設定し、`max_steps=None` を無効にできます。強化学習用に `DPOTrainer` と `GRPOTrainer` もサポートしています！！

vision ファインチューニング設定を助ける新しい `UnslothVisionDataCollator` を使います。
"""

from unsloth.trainer import UnslothVisionDataCollator
from trl import SFTTrainer, SFTConfig

trainer = SFTTrainer(
    model = model,
    train_dataset = converted_dataset,
    processing_class = processor.tokenizer,
    data_collator = UnslothVisionDataCollator(model, processor),
    args = SFTConfig(
        per_device_train_batch_size = 1,
        gradient_accumulation_steps = 4,
        max_grad_norm = 0.3,
        warmup_ratio = 0.03,
        max_steps = 60,
        # num_train_epochs = 2, # 完全な学習では、max_steps の代わりにこれを設定してください
        learning_rate = 2e-4,
        logging_steps = 1,
        save_strategy = "steps",
        optim = "adamw_8bit",
        weight_decay = 0.001,
        lr_scheduler_type = "cosine",
        seed = 3407,
        output_dir = "outputs",
        report_to = "none", # Weights and Biases など用

        # vision ファインチューニングでは、以下の項目を必ず設定してください：
        remove_unused_columns = False,
        dataset_text_field = "",
        dataset_kwargs = {"skip_prepare_dataset": True},
        max_length = 2048,
    )
)

trainer_stats = trainer.train()

画像の例の形式

覚えておいてください：Gemma 4 のマルチモーダルプロンプトでは、画像を先にその後にテキスト指示を置きます。

{
  "messages": [
    {
      "role": "user",
      "content": [
        {"type": "image", "image": "/path/to/image OR object"},
        {"type": "text", "text": "このレシートからすべてのテキストを抽出してください。明細、合計、店舗名、日付を JSON として返してください。"}
      ]
    },
    {
      "role": "assistant",
      "content": [
        {"type": "text", "text": "{\"merchant\": \"Example Store\", \"total\": \"19.99\"}"}
      ]
    }
  ]
}

音声の例の形式

音声は E2B / E4B のみです。クリップは短く、タスクに特化したものにしてください。

{
  "messages": [
    {
      "role": "user",
      "content": [
        {"type": "audio", "audio": "/path/to/audio OR object"},
        {"type": "text", "text": "次の英語の音声区間を英語テキストに書き起こしてください。転写のみを出力してください。"}
      ]
    },
    {
      "role": "assistant",
      "content": [
        {"type": "text", "text": "こんにちは、みなさん。おかえりなさい。"}
      ]
    }
  ]
}

ファインチューニング済みモデルの保存 / エクスポート

特定の推論 / デプロイガイドは以下で確認できます。 Unsloth Studio, llama.cpp, vLLM, llama-server, Ollama または SGLang.

GGUF に保存

Unsloth は直接 GGUF へ保存することをサポートしています：

model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q4_k_m")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q8_0")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "f16")

または、GGUF を Hugging Face にプッシュします：

model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q4_k_m")
model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q8_0")

エクスポートしたモデルが別のランタイムで悪化する場合、Unsloth は最も一般的な原因を次のように示します： 推論時のチャットテンプレート / EOS トークンの誤り （学習時と同じチャットテンプレートを使う必要があります）。

詳細は推論ガイドをご覧ください：

🖥️推論とデプロイ GGUF & llama.cpp

Model Export vLLM

Gemma 4 のデータに関するベストプラクティス

Gemma 4 には、覚えておくべきフォーマット上の注意点がいくつかあります。

1. 標準のチャットロールを使う

Gemma 4 は標準の

system
user
assistant

これは、SFT データセットを古い Gemma 固有のロール形式ではなく、通常のチャット形式で記述するべきことを意味します。

2. Thinking モードは明示的

SFT 中に思考スタイルの挙動を保持したい場合：

形式を一貫させる
次のどちらで学習するかを決める 表示される思考ブロック または 最終回答のみ
する しない 互換性のない複数の思考形式を同じデータセットで混ぜない

ほとんどの本番アシスタントでは、最も簡単な構成は 最終的に表示される回答のみ.

3. マルチターンのルール

マルチターン会話では、会話履歴には 最後に表示される回答 だけを残します。以前の しない 思考ブロックを後続のターンに再度入力しないでください。

前へGemma 4 QAT 次へQwen3.6

最終更新 1 か月前

役に立ちましたか？