FunctionGemma: So ausführen & feinabstimmen

Erfahren Sie, wie Sie FunctionGemma lokal auf Ihrem Gerät und Telefon ausführen und feinabstimmen.

FunctionGemma ist ein neues Modell mit 270 Mio. Parametern von Google, das für Funktionsaufrufe und Fine-Tuning entwickelt wurde. Basierend auf Gemma 3 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

Kostenlose Notebooks:

• Fine-Tuning, um vor Tool-Aufrufen zu schlussfolgern/denken mit unserem FunctionGemma-Notebook

• Machen Sie Multi-Turn-Tool-Calling in einem kostenlosen Notebook für Multi-Turn-Tool-Calling

• Fine-Tuning, um mobile Aktionen aktivieren (Kalender, Timer setzen) in unserem Notebook für mobile Aktionen

⚙️ 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:

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

Format des FunctionGemma-Chat-Templates:

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

<bos><start_of_turn>developer\nSie sind ein Modell, das Funktionsaufrufe mit den folgenden Funktionen durchführen kann<start_function_declaration>declaration:get_today_date{description:<escape>Gibt das heutige Datum zurück<escape>,parameters:{type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nWie lautet das heutige Datum?<end_of_turn>\n<start_of_turn>model\n

🖥️ 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):

1

Holen Sie sich die neueste llama.cpp auf GitHub hier. 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.

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

2

Sie können direkt von Hugging Face herunterladen. Da das Modell so klein ist, verwenden wir die unquantisierte BF16-Variante in voller Genauigkeit.

./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

3

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.

# !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*"],
)

4

Dann führen Sie das Modell im Konversationsmodus aus:

./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

📱 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) 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 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.

📱Run LLMs on your Phone

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:

Fine-Tuning-Notebook „vor dem Tool-Calling schlussfolgern“

Google Colabcolab.research.google.com

Fine-Tuning-Notebook für mobile Aktionen

Google Colabcolab.research.google.com

Im Fine-Tuning-Notebook „vor dem Tool-Calling schlussfolgern“, 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	<start_of_turn>developer Sie können Funktionsaufrufe mit den folgenden Funktionen durchführen:
Funktionsdeklaration	<start_function_declaration>declaration:get_weather{ description: "Wetter für Stadt abrufen", parameters: { city: STRING } } <end_function_declaration> <end_of_turn>
Benutzerdurchlauf	<start_of_turn>user Wie ist das Wetter in Paris? <end_of_turn>
Funktionsaufruf	<start_of_turn>model <start_function_call>call:get_weather{ city: "paris" } <end_function_call>
Funktionsantwort	<start_function_response>response:get_weather{temperature:26} <end_function_response>
Abschluss des Assistenten	Das Wetter in Paris beträgt 26 Grad Celsius. <end_of_turn>

Hier implementieren wir eine vereinfachte Version mit einem einzigen Denkblock (statt verschachteltem Reasoning) über <think></think>. Folglich sieht unsere Modellinteraktion so aus:

Denken + Funktionsaufruf	<start_of_turn>model <think> Der Benutzer möchte das Wetter für Paris. Ich habe das Tool get_weather. Ich sollte es mit dem Stadt-Argument aufrufen. </think> <start_function_call>call:get_weather{ city: "paris" } <end_function_call>

🪗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, 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".

[{'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}]

Wir haben das Modell so feinabgestimmt, dass es Folgendes ausgeben kann:

<start_of_turn>user
Bitte setze für diesen Freitag, den 6. Juni 2025, um 14:00 Uhr eine Erinnerung für ein "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>

🏃‍♂️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, 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:

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)}

Dann erstellen wir ein Mapping für alle Tools:

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:

#@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+):(?:<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

Und jetzt können wir das Modell aufrufen!

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:

Fine-Tuning-Notebook „vor dem Tool-Calling schlussfolgern“

Google Colabcolab.research.google.com

Fine-Tuning-Notebook für mobile Aktionen

Google Colabcolab.research.google.com

Notebook für Multi-Turn-Tool-Calling

Google Colabcolab.research.google.com