#### :interrobang:Gemma-4 31B および 26B-A4B 推論時の IndexError
31B と 26B で推論を行うと、このエラーが表示されることがあります:
```python
ファイル "/.../cache_utils.py"、937 行目、update 内
keys, values = self.layers[layer_idx].update(...)
IndexError: list index out of range
```
原因は以下です:
```python
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`.
#### :no\_entry: `use_cache = True` E2B、E4B では生成結果が意味不明になっていました
[issue を参照してください](https://github.com/huggingface/transformers/issues/45242) "\[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 共有レイヤーは現在の hidden states から K と V をローカルで再計算することになります。logits は壊れ、学習 loss は発散します。
**修正前（`unsloth/gemma-4-E2B-it`、プロンプト "What is 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 トークンすべて同一）
```
#### :radio:音声 float16 オーバーフロー
`Gemma4AudioAttention` は `config.attention_invalid_logits_value = -1e9` を `masked_fill` 呼び出しで使用します。fp16（Tesla T4）では、-1e9 は fp16 の最大値 65504 を超えてオーバーフローし、次を引き起こします:
```python
RuntimeError: value cannot be converted to type c10::Half without overflow
```
これは `self.config.attention_invalid_logits_value` :
```python
attn_weights = attn_weights.masked_fill(
attention_mask.logical_not(), self.config.attention_invalid_logits_value
)
```
#### 💡Gemma-4 のヒント
1. もし **推論能力** を維持したいなら、推論スタイルの例と直接回答を混ぜることができます（最低でも 75% は推論を維持）。それ以外の場合は完全に出力させることもできます。\
\
使用するのは `gemma-4` 非 thinking の chat-template 用にはこれを、そして `gemma-4-thinking` thinking バリアント用にはこれを使います。\
26B と 31B の大きいモデルには thinking 版を、小さいモデルには非 thinking 版を使ってください。
```python
from unsloth.chat_templates import get_chat_template
tokenizer = get_chat_template(
tokenizer,
chat_template = "gemma-4-thinking", # または "gemma-4"
)
```
2. thinking モードを有効にするには、 `enable_thinking = True / False` を `tokenizer.apply_chat_template`
thinking 有効:
processor.tokenizer.apply_chat_template([
{"role" : "user", "content" : "2+2 はいくつですか？"},
], tokenize = False, enable_thinking = True, add_generation_prompt = True)
次が出力されます `<|turn>system\n<|think|>\n<|turn>user\n2+2 はいくつですか？\n<|turn>model\n`
thinking 無効:
```python
processor.tokenizer.apply_chat_template([
{"role" : "user", "content" : "2+2 はいくつですか？"},
], tokenize = False, enable_thinking = False, add_generation_prompt = True)
```
次が出力されます `<|turn>user\n2+2 はいくつですか？\n<|turn>model\n<|channel>thought\n`
3. Gemma 4 は 140 言語をサポートしているため、多言語ファインチューニングに強力です。
4. 学習には **E4B QLoRA** を **E2B LoRA** より推奨します。E4B のほうが大きく、量子化による精度差はごくわずかだからです。Gemma 4 E4B LoRA はさらに優れています。
5. ファインチューニング後、 [GGUF](#saving-export-your-fine-tuned-model) （llama.cpp/Unsloth/Ollama/etc. 用）へエクスポートできます
### ⚡クイックスタート
#### 🦥 Unsloth Studio ガイド
{% columns %}
{% column %}
Gemma 4 は [Unsloth Studio](/docs/jp/xin-zhe/studio.md)で実行およびファインチューニングできます。これはローカル AI 向けの私たちの新しいオープンソース Web UI です。
Unsloth Studio では、モデルをローカルで **MacOS、Windows**、Linux 上で実行し、NVIDIA GPU で学習できます。Intel、MLX、AMD の学習サポートは今月中に提供予定です。
{% endcolumn %}
{% column %}
"""
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, # GRPO には Attention が有効
finetune_mlp_modules = True, # 常にオン推奨！
r = 8, # 大きいほど高精度ですが、過学習の可能性あり
lora_alpha = 8, # 少なくとも alpha == r を推奨
lora_dropout = 0,
bias = "none",
random_state = 3407,
)
"""
### データ準備
会話スタイルのファインチューニングには、現在 `Gemma-4` 形式を使用します。ShareGPT スタイルの [Maxime Labonne の FineTome-100k](https://huggingface.co/datasets/mlabonne/FineTome-100k) データセットを使用します。Gemma-4 は複数ターンの会話を以下のように表現します:
```
<|turn>user
こんにちは
<|turn>model
こんにちは！
```
正しいチャットテンプレートを取得するために `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(`''`) を使って `` トークンを削除します。Processor は学習前にこのトークンを追加し、モデルは 1 つだけを期待するためです。"""
def formatting_prompts_func(examples):
convos = examples["conversations"]
texts = [tokenizer.apply_chat_template(convo, tokenize = False, add_generation_prompt = False).removeprefix('') for convo in convos]
return { "text" : texts, }
dataset = dataset.map(formatting_prompts_func, batched = True)
"""チャットテンプレートがどう適用されたか見てみましょう！ processor tokenizer が 1 つ追加するので、`` トークンがないことに注目してください。"""
dataset[100]["text"]
"""
### モデルを学習
ではモデルを学習しましょう。ここでは高速化のために 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 などを使用可能
),
)
"""また、アシスタント出力のみを学習し、ユーザー入力の loss を無視するために 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 行目を表示します。サンプルに期待どおり `` が 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()
````
{% endcode %}
{% hint style="info" %}
もし OOM になったら:
* 下げる `per_device_train_batch_size` を **1** および/または減らす `max_seq_length`.
* 維持する `use_`[`gradient_checkpointing`](/docs/jp/burogu/500k-context-length-fine-tuning.md#unsloth-gradient-checkpointing-enhancements)`="unsloth"` をオンに（VRAM 使用量を減らし、コンテキスト長を拡張するよう設計されています）。
{% endhint %}
**MoE 用ローダー例（bf16 LoRA）:**
```python
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 などで学習できるようになりました。 [無料ノートブック](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_5_\(4B\)_Vision_GRPO.ipynb).
{% columns %}
{% column %}
Gemma 4 E2B RL は 9GB で動作します。
{% embed url="" %}
このノートブックの目的は、Gemma 4 に数独パズルの解き方を学ばせることです。 [GRPO](/docs/jp/meru/reinforcement-learning-rl-guide.md#from-rlhf-ppo-to-grpo-and-rlvr).
モデルは空のマスを埋める戦略を考案し、正しい配置と有効なパズル完成に対して報酬を与えます。
Gemma 4 RL は vLLM ではサポートされていなくても、Unsloth では次を設定することで実行できます `fast_inference=False` モデル読み込み時に:
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
```python
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` 最初は
* 言語、attention、MLP レイヤーのみをファインチューニングする
* タスクに必要なら後でビジョンまたは音声レイヤーを有効化する
#### Gemma 4 マルチモーダル LoRA の例:
{% code expandable="true" %}
````python
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% だけを効率的に学習できるようにします。
**[新機能]** ビジョン部分のみ、言語部分のみ、またはその両方のファインチューニングにも対応しました。さらに、attention モジュール、MLP レイヤー、またはその両方をファインチューニングすることも選べます！
"""
model = FastVisionModel.get_peft_model(
model,
finetune_vision_layers = True, # ビジョンレイヤーをファインチューニングしないなら 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", # いまは任意！必要ならリスト指定も可能
)
"""
### データ準備
手書き数式のサンプルデータセットを使用します。目的は、これらの画像をコンピュータ可読形式、具体的には 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))
"""データセットを整形するには、すべてのビジョンファインチューニングタスクで次の形式に従う必要があります:
```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の指示付きチャットテンプレートを取り上げ、ベースモデルに適用しましょう"""
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)
"""見てのとおり、まったくひどいです！指示にまったく従っていません
### モデルを学習
さあ、モデルを学習しましょう。速度を上げるために60ステップだけ実行しますが、完全な実行には`num_train_epochs=1`を設定し、`max_steps=None`をオフにできます。強化学習用に`DPOTrainer`と`GRPOTrainer`もサポートしています!!
新しい`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 など用
# ビジョンのファインチューニングでは、以下の項目を必ず設定してください:
remove_unused_columns = False,
dataset_text_field = "",
dataset_kwargs = {"skip_prepare_dataset": True},
max_length = 2048,
)
)
trainer_stats = trainer.train()
````
{% endcode %}
#### 画像の例の形式
覚えておいてください: Gemma 4のマルチモーダルプロンプトでは、画像を **前に** テキスト指示の
{% code expandable="true" %}
```json
{
"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\"}"}
]
}
]
}
```
{% endcode %}
#### 音声の例の形式
音声は **E2B / E4B** のみです。クリップは短く、タスクに特化させてください。
{% code expandable="true" %}
```json
{
"messages": [
{
"role": "user",
"content": [
{"type": "audio", "audio": "/path/to/audio OR object"},
{"type": "text", "text": "以下の英語の音声区間を書き起こして、英語のテキストにしてください。出力は書き起こしのみとしてください。"}
]
},
{
"role": "assistant",
"content": [
{"type": "text", "text": "こんにちは、皆さん。お帰りなさい。"}
]
}
]
}
```
{% endcode %}
### ファインチューニング済みモデルの保存 / エクスポート
次のための、個別の推論 / デプロイメントガイドを確認できます [Unsloth Studio](/docs/jp/xin-zhe/studio/export.md), [llama.cpp](/docs/jp/ji-ben/inference-and-deployment/saving-to-gguf.md), [vLLM](/docs/jp/ji-ben/inference-and-deployment/vllm-guide.md), [llama-server](/docs/jp/ji-ben/inference-and-deployment/llama-server-and-openai-endpoint.md), [Ollama](/docs/jp/ji-ben/inference-and-deployment/saving-to-ollama.md) または [SGLang](/docs/jp/ji-ben/inference-and-deployment/sglang-guide.md).
#### GGUFに保存
UnslothはGGUFへ直接保存する機能をサポートしています:
```python
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にプッシュします:
```python
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トークンの誤り** （学習時と同じチャットテンプレートを使用しなければなりません）。
詳細は推論ガイドをお読みください:
{% columns %}
{% column width="50%" %}
{% content-ref url="/pages/d5ae43f1915ceda3d304ad7c413cb4efbe3d1a3f" %}
[推論とデプロイ](/docs/jp/ji-ben/inference-and-deployment.md)
{% endcontent-ref %}
{% content-ref url="/pages/9bfa988baa17c249340a58c332b8584f20d2537c" %}
[GGUF & llama.cpp](/docs/jp/ji-ben/inference-and-deployment/saving-to-gguf.md)
{% endcontent-ref %}
{% endcolumn %}
{% column width="50%" %}
{% content-ref url="/pages/a58a8ab897451539e1493312c6a640b4d5ee40b7" %}
[Model Export](/docs/jp/xin-zhe/studio/export.md)
{% endcontent-ref %}
{% content-ref url="/pages/0fde417d83989a8108b1d466ec2b53c46e9f4279" %}
[vLLM](/docs/jp/ji-ben/inference-and-deployment/vllm-guide.md)
{% endcontent-ref %}
{% endcolumn %}
{% endcolumns %}
### Gemma 4のデータにおけるベストプラクティス
Gemma 4には、注意すべきフォーマット上の詳細がいくつかあります。
#### 1. 標準のチャット役割を使う
Gemma 4は標準の以下を使います:
* `system`
* `user`
* `assistant`
つまり、SFTデータセットは、古いGemma固有の役割形式ではなく、通常のチャット形式で記述する必要があります。
#### 2. Thinkingモードは明示的です
SFT中に思考スタイルの挙動を保持したい場合は:
* 形式を一貫させる
* 次のどちらで学習するかを決めてください **表示される思考ブロック** または **最終回答のみ**
* 行う **複数の互換性のない思考形式を同じデータセットで** 混在させないでください
多くの本番用アシスタントでは、最も簡単な設定は **最終的に表示される回答のみ**.
#### 3. マルチターンのルール
マルチターンの会話では、会話履歴には **最終的に表示される回答** のみを残してください。以前の思考ブロックを後続のターンに **複数の互換性のない思考形式を同じデータセットで** 戻し込まないでください。
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://unsloth.ai/docs/jp/moderu/gemma-4/train.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.