もし Gemma-4 E2B と E4B の損失が 13〜15 であれば、それは完全に正常です — これはマルチモーダルモデルによくある癖です。Gemma-3N、Llama Vision、Mistral vision モデルなどでも同様でした。

Gemma 26B と 31B は、1〜3 かそれ以下でより低い損失になります。Vision では 2 倍高くなるので 3〜5 です

🍇勾配蓄積によって損失が大きく見える場合があります

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 では生成が意味不明でした

問題を参照: 「[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 gradient_checkpointing=True によって強制されます） Gemma4TextModel.forward はキャッシュの構築をスキップするため、KV 共有レイヤーは現在の隠れ状態から K と V をローカルに再計算する処理に落ちます。logits はめちゃくちゃになり、学習損失は発散します。

修正前（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 推論なしの chat template には gemma-4-thinking 推論ありのバリアントに使用します。大きい 26B と 31B には推論ありを、小さいものには推論なしを使用してください。
```
from unsloth.chat_templates import get_chat_template
tokenizer = get_chat_template(
    tokenizer,
    chat_template = "gemma-4-thinking", # または "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 を検索し、希望するモデルとデータセットを選択します。次に、ハイパーパラメータとコンテキスト長を必要に応じて調整します。

学習の進捗を監視する

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

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

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

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

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

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

Gemma 4 用の無料ノートブックを用意しました:

そして、強化学習（RL）向けには: E2B （RL GRPO）

より大きい Gemma 4 モデル向けのノートブックも用意しましたが、A100 が必要です:

Gemma-4-26B-A4B — A100 GPU

Gemma-4-31B — A100 GPU

もし GRPO、高速 vLLM 推論を無効にして Unsloth 推論を使えば、Unsloth で動作します。私たちの Vision 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", # gated モデル用の 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` 形式を使います。[Maxime Labonne の FineTome-100k](https://huggingface.co/datasets/mlabonne/FineTome-100k) データセットを ShareGPT 形式で使用します。Gemma-4 は以下のようなマルチターン会話を描画します:

```
<bos><|turn>user
こんにちは<turn|>
<|turn>model
やあ！<turn|>
```
正しい chat template を取得するために `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` の chat template を適用し、それを `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)

"""chat template がどうなったか見てみましょう！ processor tokenizer が追加するので、`<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` メソッドも使い、アシスタントの出力だけを学習してユーザー入力の損失は無視します。これによりファインチューニングの精度向上に役立ちます！"""

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",
)

"""instruction 部分のマスキングができたか確認しましょう！ 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ビット 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ビット / bf16 LoRA メモリが許すなら
まずは短いコンテキストと小さな rank から始める
パイプラインが安定してから拡張する

最高品質を目指していて、より多くのメモリがあるなら、代わりに 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, # 言語層をファインチューニングしない場合は 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` もサポートしています!!

新しい `UnslothVisionDataCollator` を使います。これは vision ファインチューニングの設定に役立ちます。
"""

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\": \"サンプル店舗\", \"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 中に thinking スタイルの振る舞いを保持したい場合:

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

多くの本番用アシスタントでは、最も簡単な設定は次のものだけをファインチューニングすることです: 最終的に表示される回答のみ.

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

マルチターン会話では、次のものだけを残します: 最終的に表示される回答 会話履歴の中に。 はいけません 以前の思考ブロックを後のターンに戻して入力してはいけません。

前へGemma 4 QAT

次へGLM-5.3

最終更新 2 か月前

役に立ちましたか？