# FunctionGemma: Wie man ausführt und feinabstimmt
FunctionGemma ist ein neues Modell mit 270 Mio. Parametern von Google, das für Funktionsaufrufe und Fine-Tuning entwickelt wurde. Basierend auf [Gemma 3](/docs/de/modelle/tutorials/gemma-3-how-to-run-and-fine-tune.md) 270M und speziell für textbasiertes Tool-Calling trainiert. Seine geringe Größe macht es ideal für den Einsatz auf Ihrem eigenen Smartphone.
Sie können das Modell in voller Genauigkeit ausführen auf **550 MB RAM** (CPU) und Sie können es jetzt **fine-tunen** lokal mit Unsloth. Vielen Dank an Google DeepMind für die Partnerschaft mit Unsloth für Support ab Tag 0!
Anleitung zum AusführenFine-Tuning von FunctionGemma
* FunctionGemma GGUF zum Ausführen: [unsloth/functiongemma-270m-it-GGUF](https://huggingface.co/unsloth/functiongemma-270m-it-GGUF)
**Kostenlose Notebooks:**
* Fine-Tuning, um **vor Tool-Aufrufen zu schlussfolgern/denken** mit unserem [FunctionGemma-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\).ipynb)
* Machen Sie **Multi-Turn-Tool-Calling** in einem kostenlosen [Notebook für Multi-Turn-Tool-Calling](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Multi-Turn-Tool-Calling.ipynb)
* Fine-Tuning, um **mobile Aktionen aktivieren** (Kalender, Timer setzen) in unserem [Notebook für mobile Aktionen](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Mobile-Actions.ipynb)
### ⚙️ Verwendungsleitfaden
Google empfiehlt diese Einstellungen für die Inferenz:
* `top_k = 64`
* `top_p = 0,95`
* `temperature = 1,0`
* maximale Kontextlänge = `32,768`
Das Chat-Template-Format findet sich, wenn wir Folgendes verwenden:
{% code overflow="wrap" %}
```python
def get_today_date():
""" Gibt das heutige Datum zurück """
return {"today_date": "18. Dezember 2025"}
tokenizer.apply_chat_template(
[
{"role" : "user", "content" : "Wie lautet das heutige Datum?"},
],
tools = [get_today_date], add_generation_prompt = True, tokenize = False,
)
```
{% endcode %}
#### Format des FunctionGemma-Chat-Templates:
{% hint style="info" %}
FunctionGemma erfordert die System- oder **Developer-Nachricht** als `Sie sind ein Modell, das Funktionsaufrufe mit den folgenden Funktionen durchführen kann` Unsloth-Versionen haben dies bereits integriert, falls Sie vergessen, eine anzugeben. Bitte verwenden Sie daher [unsloth/functiongemma-270m-it](https://huggingface.co/unsloth/functiongemma-270m-it)
{% endhint %}
{% code overflow="wrap" lineNumbers="true" %}
```
developer\nSie sind ein Modell, das Funktionsaufrufe mit den folgenden Funktionen durchführen kanndeclaration:get_today_date{description:Gibt das heutige Datum zurück,parameters:{type:OBJECT}}\nuser\nWie lautet das heutige Datum?\nmodel\n
```
{% endcode %}
## 🖥️ FunctionGemma ausführen
Unten sehen Sie eine Anleitung für den lokalen Desktop oder Sie können unseren Leitfaden zur Smartphone-Bereitstellung ansehen.
#### Llama.cpp-Tutorial (GGUF):
Anweisungen zum Ausführen in llama.cpp (beachten Sie, dass wir 4-Bit verwenden werden, um auf die meisten Geräte zu passen):
{% stepper %}
{% step %}
Holen Sie sich die neueste `llama.cpp` auf [GitHub hier](https://github.com/ggml-org/llama.cpp). Sie können auch den unten stehenden Build-Anweisungen folgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder einfach nur CPU-Inferenz möchten. **Für Apple Mac / Metal-Geräte**, setzen Sie `-DGGML_CUDA=OFF` und fahren Sie dann wie gewohnt fort - Metal-Unterstützung ist standardmäßig aktiviert.
{% 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 %}
Sie können direkt von Hugging Face herunterladen. Da das Modell so klein ist, verwenden wir die unquantisierte BF16-Variante in voller Genauigkeit.
```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 %}
Laden Sie das Modell herunter über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Sie können `BF16` oder andere quantisierte Versionen wählen (obwohl es nicht empfohlen wird, unter 4-Bit zu gehen) aufgrund der kleinen Modellgröße.
```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 %}
Dann führen Sie das Modell im Konversationsmodus aus:
{% 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 %}
## 📱 Smartphone-Bereitstellung
Sie können FunctionGemma aufgrund seiner geringen Größe auch auf Ihrem Smartphone ausführen und bereitstellen. Wir haben mit PyTorch zusammengearbeitet, um einen optimierten Workflow mithilfe von quantisierungsbewusstem Training ([QAT](/docs/de/blog/quantization-aware-training-qat.md)) zu erstellen, um 70 % Genauigkeit wiederherzustellen und es dann direkt auf Edge-Geräten bereitzustellen.
* FunctionGemma lokal bereitstellen auf **Pixel 8** und **iPhone 15 Pro** um **Inferenzgeschwindigkeiten von \~50 Token/s zu erreichen**
* Erhalten Sie Privatsphäre zuerst, sofortige Antworten und Offline-Funktionen
* Verwenden Sie unser [kostenloses Colab-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(0_6B\)-Phone_Deployment.ipynb) um Qwen3 0,6B feinabzustimmen und für die Smartphone-Bereitstellung zu exportieren - ändern Sie es einfach in Gemma3 und folgen Sie den [Gemma 3 Executorch-Dokumenten](https://github.com/pytorch/executorch/tree/main/examples/models/gemma3).
{% content-ref url="/pages/86b6f77ee96e4edb00c776189ff1bf5032a3aaeb" %}
[Run LLMs on your Phone](/docs/de/grundlagen/inference-and-deployment/deploy-llms-phone.md)
{% endcontent-ref %}
Sehen Sie sich unsere iOS- und Android-Tutorials zur Bereitstellung auf Ihrem Smartphone an:
iOS-TutorialAndroid-Tutorial
## 🦥 Fine-Tuning von FunctionGemma
Google bemerkte, dass **FunctionGemma für das Fine-Tuning vorgesehen ist** für Ihre spezifische Funktionsaufruf-Aufgabe, einschließlich Multi-Turn-Anwendungsfällen. Unsloth unterstützt jetzt das Fine-Tuning von FunctionGemma. Wir haben 2 Fine-Tuning-Notebooks erstellt, die zeigen, wie Sie das Modell über **vollständiges Fine-Tuning oder LoRA kostenlos über ein Colab-Notebook trainieren können:**
{% columns %}
{% column %}
[**Fine-Tuning-Notebook „vor dem Tool-Calling schlussfolgern“**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\).ipynb)
{% embed url="" %}
{% endcolumn %}
{% column %}
[**Fine-Tuning-Notebook für mobile Aktionen**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Mobile-Actions.ipynb)
{% embed url="" %}
{% endcolumn %}
{% endcolumns %}
Im [**Fine-Tuning-Notebook „vor dem Tool-Calling schlussfolgern“**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\).ipynb), werden wir **es für "denken/schlussfolgern" vor dem Funktionsaufruf feinabstimmen**. Chain-of-Thought-Reasoning wird immer wichtiger, um die Fähigkeiten zur Werkzeugnutzung zu verbessern.
FunctionGemma ist ein kleines Modell, das auf Funktionsaufrufe spezialisiert ist. Es verwendet sein eigenes, eigenständiges Chat-Template. Wenn Tool-Definitionen und ein Benutzer-Prompt bereitgestellt werden, erzeugt es eine strukturierte Ausgabe. Diese Ausgabe können wir dann parsen, um das Tool auszuführen, die Ergebnisse abzurufen und sie zur Generierung der endgültigen Antwort zu verwenden.
| Turn-Typ | Inhalt |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Developer-Prompt** |
\developer
Sie können Funktionsaufrufe mit den folgenden Funktionen durchführen:
|
| **Funktionsdeklaration** |
\declaration:get\_weather{
description: "Wetter für Stadt abrufen",
parameters: { city: STRING }
}
\
\
|
| **Benutzerdurchlauf** |
\user
Wie ist das Wetter in Paris?
\
|
| **Funktionsaufruf** |
\model
\call:get\_weather{
city: "paris"
}
\
|
| **Funktionsantwort** |
\response:get\_weather{temperature:26}
\
|
| **Abschluss des Assistenten** |
Das Wetter in Paris beträgt 26 Grad Celsius.
\
|
Hier implementieren wir eine vereinfachte Version mit einem einzigen Denkblock (statt verschachteltem Reasoning) über ``. Folglich sieht unsere Modellinteraktion so aus:
| **Denken** + **Funktionsaufruf** |
\model
\
Der Benutzer möchte das Wetter für Paris. Ich habe das Tool get\_weather. Ich sollte es mit dem Stadt-Argument aufrufen.
\
\call:get\_weather{
city: "paris"
}
\
|
| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
## :accordion:Fine-Tuning von FunctionGemma für mobile Aktionen
Wir haben auch ein Notebook erstellt, das zeigt, wie Sie FunctionGemma mobile Aktionen ausführen lassen können. Im [**Fine-Tuning-Notebook für mobile Aktionen**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Mobile-Actions.ipynb), haben wir auch die Auswertung aktiviert und zeigen, wie das Fine-Tuning für Aktionen auf dem Gerät gut funktioniert, wie am sinkenden Evaluierungsverlust zu sehen ist:
Zum Beispiel, gegeben einen Prompt `Bitte setze für diesen Freitag, den 6. Juni 2025, um 14:00 Uhr eine Erinnerung für ein "Team Sync Meeting".`
{% code overflow="wrap" %}
```python
[{'role': 'developer',
'content': 'Aktuelles Datum und Uhrzeit im Format YYYY-MM-DDTHH:MM:SS angegeben: 2025-06-04T15:29:23\nWochentag ist Mittwoch\nSie sind ein Modell, das Funktionsaufrufe mit den folgenden Funktionen durchführen kann\n',
'tool_calls': None},
{'role': 'user',
'content': 'Bitte setze für diesen Freitag, den 6. Juni 2025, um 14:00 Uhr eine Erinnerung für ein "Team Sync Meeting".',
'tool_calls': None}]
```
{% endcode %}
Wir haben das Modell so feinabgestimmt, dass es Folgendes ausgeben kann:
{% code overflow="wrap" %}
```
user
Bitte setze für diesen Freitag, den 6. Juni 2025, um 14:00 Uhr eine Erinnerung für ein "Team Sync Meeting".model
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:Team Sync Meeting,to:None}
```
{% endcode %}
## :man\_running:Multi-Turn-Tool-Calling mit FunctionGemma
Wir haben auch ein Notebook erstellt, das zeigt, wie Sie FunctionGemma für Multi-Turn-Tool-Calls verwenden können. Im [**Notebook für Multi-Turn-Tool-Calling**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Multi-Turn-Tool-Calling.ipynb), zeigen wir, wie FunctionGemma in der Lage ist, Tools in einer langen Nachrichtenänderung aufzurufen, zum Beispiel siehe unten:
Sie müssen zunächst Ihre Tools wie unten angeben:
{% code expandable="true" %}
```python
def get_today_date():
"""
Gibt das heutige Datum zurück
Gibt zurück:
today_date: Heutiges Datum im Format 18. Dezember 2025
"""
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"):
"""
Gibt das aktuelle Wetter an einem angegebenen Ort zurück.
Args:
location: Die Stadt und der Bundesstaat, z. B. "San Francisco, CA, USA" oder "Sydney, Australia"
unit: Die Einheit, in der die Temperatur zurückgegeben wird. (Auswahl: ["celsius", "fahrenheit"] )
Gibt zurück:
temperature: Die aktuelle Temperatur am angegebenen Ort
weather: Das aktuelle Wetter am angegebenen Ort
"""
if "San Francisco" in location.title():
return {"temperature": 15, "weather": "sonnig"}
elif "Sydney" in location.title():
return {"temperature": 25, "weather": "bewölkt"}
else:
return {"temperature": 30, "weather": "regnerisch"}
def add_numbers(x: float | str, y: float | str):
"""
Addiert 2 Zahlen
Args:
x: Erste Zahl
y: Zweite Zahl
Gibt zurück:
result: x + y
"""
return {"result" : float(x) + float(y)}
def multiply_numbers(x: float | str, y: float | str):
"""
Multipliziert 2 Zahlen miteinander
Args:
x: Erste Zahl
y: Zweite Zahl
Gibt zurück:
result: x * y
"""
return {"result" : float(x) * float(y)}
```
{% endcode %}
Dann erstellen wir ein Mapping für alle Tools:
```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())
```
Wir benötigen außerdem etwas Code für den Tool-Aufruf und das Parsen:
{% code expandable="true" %}
```python
#@title FunctionGemma-Parsierungscode (erweiterbar)
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+):(?:(.*?)|([^,}]*))", args)
}
} for name, args in re.findall(r"call:(\w+)\{(.*?)\}", 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 %}
Und jetzt können wir das Modell aufrufen!
```python
from unsloth import FastLanguageModel
import torch
max_seq_length = 4096 # Kann jede Sequenzlänge wählen!
model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "unsloth/functiongemma-270m-it",
max_seq_length = max_seq_length, # Wählen Sie beliebige Werte für langen Kontext!
load_in_4bit = False, # 4-Bit-Quantisierung zur Reduzierung des Speicherverbrauchs
load_in_8bit = False, # [NEU!] Etwas genauer, verwendet 2x Speicher
load_in_16bit = True, # [NEU!] Aktiviert 16-Bit-LoRA
full_finetuning = False, # [NEU!] Wir haben jetzt vollständiges Fine-Tuning!
# token = "hf_...", # verwenden Sie einen, wenn Sie geschützte Modelle verwenden
)
messages = []
messages.append({"role": "user", "content": "Wie lautet das heutige Datum?"})
messages = do_inference(model, messages, max_new_tokens = 128)
```
Probieren Sie die 3 Notebooks aus, die wir für FunctionGemma erstellt haben:
{% columns %}
{% column %}
[Fine-Tuning-Notebook „vor dem Tool-Calling schlussfolgern“](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\).ipynb)
{% embed url="" %}
{% endcolumn %}
{% column %}
[Fine-Tuning-Notebook für mobile Aktionen](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Mobile-Actions.ipynb)
{% embed url="" %}
{% endcolumn %}
{% column %}
[Notebook für Multi-Turn-Tool-Calling](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/FunctionGemma_\(270M\)-Multi-Turn-Tool-Calling.ipynb)
{% embed url="" %}
{% 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/de/modelle/tutorials/functiongemma.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.