# FunctionGemma: 実行とファインチューニング方法

FunctionGemmaは、関数呼び出しとファインチューニング向けに設計された、Googleによる新しい2.7億パラメータのモデルです。ベースは [Gemma 3](/docs/jp/moderu/tutorials/gemma-3-how-to-run-and-fine-tune.md) 270Mで、テキストのみのツール呼び出し向けに特化して学習されており、その小さなサイズのおかげで自分のスマートフォンにデプロイするのに最適です。

フル精度モデルを **550MBのRAM** （CPU）で実行でき、今では **ファインチューニング** をUnslothでローカル実行できます。初日サポートのためにUnslothと提携してくださったGoogle DeepMindに感謝します！

<a href="/pages/c590d523e85962de32ad10f332254fb7ec5aa904#run-functiongemma" class="button secondary">実行チュートリアル</a><a href="/pages/c590d523e85962de32ad10f332254fb7ec5aa904#fine-tuning-functiongemma" class="button primary">FunctionGemmaのファインチューニング</a>

* 実行用のFunctionGemma GGUF： [unsloth/functiongemma-270m-it-GGUF](https://huggingface.co/unsloth/functiongemma-270m-it-GGUF)

**無料ノートブック：**

* 以下を学習させるファインチューニング **ツール呼び出しの前に推論/思考する** 次を使って [FunctionGemmaノートブック](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\).ipynb)
* 実施する **マルチターンのツール呼び出し** 無料の [マルチターン・ツール呼び出しノートブックで](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Multi-Turn-Tool-Calling.ipynb)
* 以下を学習させるファインチューニング **モバイル操作を有効化** （カレンダー、タイマー設定）を次のノートブックで [モバイル操作ノートブック](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Mobile-Actions.ipynb)

### ⚙️ 使用ガイド

Googleは推論時に次の設定を推奨しています：

* `top_k = 64`
* `top_p = 0.95`
* `temperature = 1.0`
* 最大コンテキスト長 = `32,768`&#x20;

以下を使うとチャットテンプレート形式が分かります：

{% code overflow="wrap" %}

```python
def get_today_date():
    """ 今日の日付を取得します """
    return {"today_date": "2025年12月18日"}
    
tokenizer.apply_chat_template(
    [
        {"role" : "user", "content" : "今日の日付は何ですか？"},
    ],
    tools = [get_today_date], add_generation_prompt = True, tokenize = False,
)
```

{% endcode %}

#### FunctionGemmaのチャットテンプレート形式：

{% hint style="info" %}
FunctionGemmaではシステムまたは **開発者メッセージ** として `次の関数を使って関数呼び出しができるモデルです` Unsloth版にはこれが組み込み済みで、渡し忘れても補完されます。そのため、次を使ってください [unsloth/functiongemma-270m-it](https://huggingface.co/unsloth/functiongemma-270m-it)
{% endhint %}

{% code overflow="wrap" lineNumbers="true" %}

```
<bos><start_of_turn>developer\n次の関数を使って関数呼び出しができるモデルです<start_function_declaration>declaration:get_today_date{description:<escape>今日の日付を取得します<escape>,parameters:{type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\n今日の日付は何ですか？<end_of_turn>\n<start_of_turn>model\n
```

{% endcode %}

## 🖥️ FunctionGemmaを実行

ローカルデスクトップ向けガイドは以下をご覧ください。または、Phone Deployment Guideをご覧いただけます。

#### Llama.cppチュートリアル（GGUF）：

llama.cppで実行するための手順です（多くのデバイスに収めるため、4-bitを使用します）：

{% stepper %}
{% step %}
最新の `llama.cpp` を [GitHubはこちら](https://github.com/ggml-org/llama.cpp)から入手してください。以下のビルド手順に従うこともできます。変更してください `-DGGML_CUDA=ON` を `-DGGML_CUDA=OFF` GPUがない場合、またはCPU推論だけを使いたい場合。 **Apple Mac / Metalデバイスの場合**、次を設定し `-DGGML_CUDA=OFF` 、あとは通常どおり進めてください。Metalサポートはデフォルトで有効です。

{% code overflow="wrap" %}

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \\
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```

{% endcode %}
{% endstep %}

{% step %}
Hugging Faceから直接取得できます。モデルが非常に小さいため、量子化していないフル精度のBF16版を使用します。

```bash
./llama.cpp/llama-cli \\
    -hf unsloth/functiongemma-270m-it-GGUF:BF16 \\
    --jinja -ngl 99 --ctx-size 32768 \\
    --top-k 64 --top-p 0.95 --temp 1.0
```

{% endstep %}

{% step %}
（次をインストール後に）モデルをダウンロード： `pip install huggingface_hub hf_transfer` ）。選択できるのは `BF16` または他の量子化版です（ただし、モデルサイズが小さいため4-bitより下にするのは推奨されません）。

```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/functiongemma-270m-it-GGUF",
    local_dir = "unsloth/functiongemma-270m-it-GGUF",
    allow_patterns = ["*BF16*"],
)
```

{% endstep %}

{% step %}
次に会話モードでモデルを実行します：

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \\
    --model unsloth/functiongemma-270m-it-GGUF/functiongemma-270m-it-BF16.gguf \\
    --ctx-size 32768 \\
    --n-gpu-layers 99 \\
    --seed 3407 \\
    --prio 2 \\
    --top-k 64 \\
    --top-p 0.95 \\
    --temp 1.0 \\
    --jinja
```

{% endcode %}
{% endstep %}
{% endstepper %}

## 📱 スマホへのデプロイ

サイズが小さいため、FunctionGemmaはスマートフォン上でも実行・デプロイできます。PyTorchと協力して、量子化認識学習（[QAT](/docs/jp/burogu/quantization-aware-training-qat.md)）を使って70%の精度を回復し、その後エッジデバイスへ直接デプロイする簡略化されたワークフローを作成しました。

* FunctionGemmaをローカルでデプロイして **Pixel 8** と **iPhone 15 Pro** に **約50トークン/秒の推論速度**
* を実現しましょう
* プライバシー重視、即時応答、オフライン機能を利用できます [無料のColabノートブック](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(0_6B\)-Phone_Deployment.ipynb) を使ってQwen3 0.6Bをファインチューニングし、スマホデプロイ用にエクスポートできます。Gemma3に変更して、 [Gemma 3 Executorch docs](https://github.com/pytorch/executorch/tree/main/examples/models/gemma3).

{% content-ref url="/pages/6b439ad8eedcbf85fcbca5c3aa910e0d71794507" %}
[Run LLMs on your Phone](/docs/jp/ji-ben/inference-and-deployment/deploy-llms-phone.md)
{% endcontent-ref %}

を参照してください

<a href="/pages/6b439ad8eedcbf85fcbca5c3aa910e0d71794507#ios-deployment" class="button secondary" data-icon="apple">iOSチュートリアル</a><a href="/pages/6b439ad8eedcbf85fcbca5c3aa910e0d71794507#android-deployment" class="button secondary" data-icon="android">Androidチュートリアル</a>

## 🦥 FunctionGemmaのファインチューニング

Googleは次のように述べています **FunctionGemmaはファインチューニングを前提としている** ため、あなた固有の関数呼び出しタスク、マルチターンのユースケースを含めて調整できます。Unslothは現在FunctionGemmaのファインチューニングをサポートしています。私たちは2つのファインチューニング用ノートブックを作成し、Colabノートブックを使って **フルファインチューニングまたはLoRAで無料学習する方法**

{% columns %}
{% column %}
[**ツール呼び出し前に推論するファインチューニングノートブック**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\).ipynb)

{% embed url="<https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_(270M).ipynb>" %}
{% endcolumn %}

{% column %}
[**モバイル操作ファインチューニングノートブック**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Mobile-Actions.ipynb)

{% embed url="<https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_(270M)-Mobile-Actions.ipynb>" %}
{% endcolumn %}
{% endcolumns %}

では [**ツール呼び出し前に推論するファインチューニングノートブック**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\).ipynb)、 **関数呼び出しの前に「考える/推論する」ようにファインチューニングします**。連鎖的思考推論は、ツール利用能力を向上させるうえでますます重要になっています。

FunctionGemmaは、関数呼び出しに特化した小型モデルです。独自のチャットテンプレートを使用します。ツール定義とユーザープロンプトを与えると、構造化された出力を生成します。次にこの出力を解析してツールを実行し、その結果を取得して最終回答の生成に利用できます。

| ターン種別         | 内容                                                                                                                                                                                                                                                                                   |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **開発者プロンプト**  | <p><code>\<start\_of\_turn>developer</code></p><p><code>次の関数を使って関数呼び出しができます：</code></p>                                                                                                                                                                                              |
| **関数宣言**      | <p><code>\<start\_function\_declaration>declaration:get\_weather{</code></p><p><code>description: "都市の天気を取得する",</code></p><p><code>parameters: { city: STRING }</code></p><p><code>}</code></p><p><code>\<end\_function\_declaration></code></p><p><code>\<end\_of\_turn></code></p> |
| **ユーザートーン**   | <p><code>\<start\_of\_turn>user</code></p><p><code>パリの天気はどうですか？</code></p><p><code>\<end\_of\_turn></code></p>                                                                                                                                                                       |
| **関数呼び出し**    | <p><code>\<start\_of\_turn>model</code></p><p><code>\<start\_function\_call>call:get\_weather{</code></p><p><code>city: "paris"</code></p><p><code>}</code></p><p><code>\<end\_function\_call></code></p>                                                                            |
| **関数応答**      | <p><code>\<start\_function\_response>response:get\_weather{temperature:26}</code></p><p><code>\<end\_function\_response></code></p>                                                                                                                                                  |
| **アシスタントの締め** | <p><code>パリの天気は摂氏26度です。</code></p><p><code>\<end\_of\_turn></code></p>                                                                                                                                                                                                               |

ここでは、交互に推論するのではなく、単一の思考ブロックを使った簡略版を `<think></think>`で実装します。その結果、モデルとのやり取りは次のようになります：

| **思考** + **関数呼び出し** | <p><code>\<start\_of\_turn>model</code></p><p><mark style="color:blue;"><strong><code>\<think></code></strong></mark></p><p><mark style="color:blue;"><strong><code>ユーザーはパリの天気を求めている。get\_weatherツールがあるので、city引数を付けて呼び出すべきだ。</code></strong></mark></p><p><mark style="color:blue;"><strong><code>\</think></code></strong></mark></p><p><code>\<start\_function\_call>call:get\_weather{</code></p><p><code>city: "paris"</code></p><p><code>}</code></p><p><code>\<end\_function\_call></code></p> |
| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

## :accordion:モバイル操作向けFunctionGemmaのファインチューニング

FunctionGemmaにモバイル操作を行わせる方法を示すノートブックも作成しました。 [**モバイル操作ファインチューニングノートブック**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Mobile-Actions.ipynb)では評価も有効にしており、オンデバイス操作向けにファインチューニングすると、評価損失が下がることからもうまく機能する様子を示しています：

<figure><img src="/files/44170e880d68c5aab0d4316d3d30901f6d9324f2" alt="" width="375"><figcaption></figcaption></figure>

たとえば、次のプロンプトが与えられた場合 `2025年6月6日（金）午後2時に「Team Sync Meeting」のリマインダーを設定してください。`

{% code overflow="wrap" %}

```python
[{'role': 'developer',
  'content': 'YYYY-MM-DDTHH:MM:SS形式で与えられた現在日時: 2025-06-04T15:29:23\n曜日は水曜日\n次の関数を使って関数呼び出しができるモデルです\n',
  'tool_calls': None},
 {'role': 'user',
  'content': '2025年6月6日（金）午後2時に「Team Sync Meeting」のリマインダーを設定してください。',
  'tool_calls': None}]
```

{% endcode %}

モデルが次を出力できるようにファインチューニングしました：

{% code overflow="wrap" %}

```
<start_of_turn>user
2025年6月6日（金）午後2時に「Team Sync Meeting」のリマインダーを設定してください。<end_of_turn>
<start_of_turn>model
<start_function_call>call:create_calendar_event{body:None,datetime:2025-06-06 14:00:00,email:None,first_name:None,last_name:None,phone_number:None,query:None,subject:None,title:<escape>Team Sync Meeting<escape>,to:None}<end_function_call><start_function_response>
```

{% endcode %}

## :man\_running:FunctionGemmaによるマルチターン・ツール呼び出し

FunctionGemmaでマルチターンのツール呼び出しを行う方法を示すノートブックも作成しました。 [**マルチターン・ツール呼び出しノートブックで**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Multi-Turn-Tool-Calling.ipynb)では、FunctionGemmaが長いメッセージの変更の中でツールを呼び出せることを示します。たとえば、以下を参照してください：

<figure><img src="/files/c1562bcb3e27b04e488b661c766e079cfdd84e9b" alt=""><figcaption></figcaption></figure>

まず、以下のようにツールを定義する必要があります：

{% code expandable="true" %}

```python
def get_today_date():
    """
    今日の日付を取得します

    戻り値：
        today_date: 2025年12月18日形式の日付
    """
    from datetime import datetime
    today_date = datetime.today().strftime("%d %B %Y")
    return {"today_date": today_date}

def get_current_weather(location: str, unit: str = "celsius"):
    """
    指定した場所の現在の天気を取得します。

    引数：
        location: 都市と州、たとえば "San Francisco, CA, USA" または "Sydney, Australia"
        unit: 温度を返す単位。（選択肢: ["celsius", "fahrenheit"]）

    戻り値：
        temperature: 指定した場所の現在の気温
        weather: 指定した場所の現在の天気
    """
    if "San Francisco" in location.title():
        return {"temperature": 15, "weather": "sunny"}
    elif "Sydney" in location.title():
        return {"temperature": 25, "weather": "cloudy"}
    else:
        return {"temperature": 30, "weather": "rainy"}

def add_numbers(x: float | str, y: float | str):
    """
    2つの数を足し合わせます

    引数：
        x: 1つ目の数
        y: 2つ目の数

    戻り値：
        result: x + y
    """
    return {"result" : float(x) + float(y)}

def multiply_numbers(x: float | str, y: float | str):
    """
    2つの数を掛け合わせます

    引数：
        x: 1つ目の数
        y: 2つ目の数

    戻り値：
        result: x * y
    """
    return {"result" : float(x) * float(y)}
```

{% endcode %}

次に、すべてのツールのマッピングを作成します：

```python
FUNCTION_MAPPING = {
    "get_today_date" : get_today_date,
    "get_current_weather" : get_current_weather,
    "add_numbers": add_numbers,
    "multiply_numbers": multiply_numbers,
}
TOOLS = list(FUNCTION_MAPPING.values())
```

さらに、ツール呼び出しとパースのコードも必要です：

{% code expandable="true" %}

```python
#@title FunctionGemma parsing code (expandible)
import re
def extract_tool_calls(text):
    def cast(v):
        try: return int(v)
        except:
            try: return float(v)
            except: return {'true': True, 'false': False}.get(v.lower(), v.strip("'\""))

    return [{
        "name": name,
        "arguments": {
            k: cast((v1 or v2).strip())
            for k, v1, v2 in re.findall(r"(\w+):(?:<escape>(.*?)<escape>|([^,}]*))", args)
        }
    } for name, args in re.findall(r"<start_function_call>call:(\w+)\{(.*?)\}<end_function_call>", text, re.DOTALL)]

def process_tool_calls(output, messages):
    calls = extract_tool_calls(output)
    if not calls: return messages
    messages.append({
        "role": "assistant",
        "tool_calls": [{"type": "function", "function": call} for call in calls]
    })
    results = [
        {"name": c['name'], "response": FUNCTION_MAPPING[c['name']](**c['arguments'])}
        for c in calls
    ]
    messages.append({ "role": "tool", "content": results })
    return messages

def _do_inference(model, messages, max_new_tokens = 128):
    inputs = tokenizer.apply_chat_template(
        messages, tools = TOOLS, add_generation_prompt = True, return_dict = True, return_tensors = "pt",
    )
    output = tokenizer.decode(inputs["input_ids"][0], skip_special_tokens = False)

    out = model.generate(**inputs.to(model.device), max_new_tokens = max_new_tokens,
                         top_p = 0.95, top_k = 64, temperature = 1.0,)
    generated_tokens = out[0][len(inputs["input_ids"][0]):]
    return tokenizer.decode(generated_tokens, skip_special_tokens = True)
    
def do_inference(model, messages, print_assistant = True, max_new_tokens = 128):
    output = _do_inference(model, messages, max_new_tokens = max_new_tokens)
    messages = process_tool_calls(output, messages)
    if messages[-1]["role"] == "tool":
        output = _do_inference(model, messages, max_new_tokens = max_new_tokens)
    messages.append({"role": "assistant", "content": output})
    if print_assistant: print(output)
    return messages
```

{% endcode %}

さあ、モデルを呼び出せます！

```python
from unsloth import FastLanguageModel
import torch
max_seq_length = 4096 # 任意のシーケンス長を選択できます！
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/functiongemma-270m-it",
    max_seq_length = max_seq_length, # 長いコンテキストには任意に選択可能！
    load_in_4bit = False,  # メモリ削減のための4bit量子化
    load_in_8bit = False, # [NEW!] 少し高精度、メモリは2倍使用
    load_in_16bit = True, # [NEW!] 16bit LoRAを有効化
    full_finetuning = False, # [NEW!] 現在はフルファインチューニングも可能です！
    # token = "hf_...", # ゲート付きモデルを使う場合はこれを使用
)

messages = []
messages.append({"role": "user", "content": "今日の日付は何ですか？"})
messages = do_inference(model, messages, max_new_tokens = 128)
```

私たちが作成したFunctionGemma用の3つのノートブックを試してみてください：

{% columns %}
{% column %}
[ツール呼び出し前に推論するファインチューニングノートブック](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\).ipynb)

{% embed url="<https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_(270M).ipynb>" %}
{% endcolumn %}

{% column %}
[モバイル操作ファインチューニングノートブック](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Mobile-Actions.ipynb)

{% embed url="<https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_(270M)-Mobile-Actions.ipynb>" %}
{% endcolumn %}

{% column %}
[マルチターン・ツール呼び出しノートブックで](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Multi-Turn-Tool-Calling.ipynb)

{% embed url="<https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_(270M)-Multi-Turn-Tool-Calling.ipynb>" %}
{% endcolumn %}
{% endcolumns %}


---

# 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/tutorials/functiongemma.md?ask=<question>
```

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.
