FunctionGemma: Ausführen & Finetunen

Lerne, wie man FunctionGemma lokal auf deinem Gerät und Handy ausführt und finetunt.

FunctionGemma ist ein neues 270M-Parameter-Modell von Google, das für Funktionsaufrufe und Feinabstimmung entwickelt wurde. Basierend auf Gemma 3 270M und speziell für textbasierte Tool-Aufrufe trainiert, macht seine geringe Größe es ideal, es auf Ihrem eigenen Telefon bereitzustellen.

Sie können das Modell in voller Genauigkeit ausführen auf 550MB RAM (CPU) und Sie können es jetzt feinabstimmen lokal mit Unsloth ausführen. Danke an Google DeepMind für die Zusammenarbeit mit Unsloth für Day-Zero-Support!

Ausführungs-TutorialFeinabstimmung von FunctionGemma

• FunctionGemma GGUF zum Ausführen: unsloth/functiongemma-270m-it-GGUF

Kostenlose Notebooks:

• Feinabstimmen auf überlegen/denken vor Tool-Aufrufen mit unserem FunctionGemma-Notebook

• Machen Sie mehrstufige Tool-Aufrufe in einem kostenlosen Multi-Turn-Tool-Calling-Notebook

• Feinabstimmen auf mobile Aktionen aktivieren (Kalender, Timer setzen) in unserem Mobile Actions-Notebook

⚙️ Gebrauchsanleitung

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 das Folgende verwenden:

def get_today_date():
    """ Liefert das heutige Datum """
    return {"today_date": "18. Dezember 2025"}
    
tokenizer.apply_chat_template(
    [
        {"role" : "user", "content" : "was ist das heutige Datum?"},
    ],
    tools = [get_today_date], add_generation_prompt = True, tokenize = False,
)

FunctionGemma Chat-Template-Format:

FunctionGemma erfordert die System- oder Entwicklernachricht als Sie sind ein Modell, das Funktionsaufrufe mit den folgenden Funktionen durchführen kann Unsloth-Versionen haben dies vorinstalliert, falls Sie vergessen, eine zu übergeben. Bitte verwenden Sie unsloth/functiongemma-270m-it

<bos><start_of_turn>developer\nYou are a model that can do function calling with the following functions<start_function_declaration>declaration:get_today_date{description:<escape>Gets today's date<escape>,parameters:{type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nwhat is today's date?<end_of_turn>\n<start_of_turn>model\n

🖥️ FunctionGemma ausführen

Siehe unten für eine lokale Desktop-Anleitung oder Sie können unseren Phone Deployment Guide ansehen.

Llama.cpp Tutorial (GGUF):

Anleitung zum Ausführen in llama.cpp (Hinweis: Wir verwenden 4-Bit, um die meisten Geräte passend zu machen):

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 nur CPU-Inferenz wünschen.

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 ziehen. Da das Modell so klein ist, verwenden wir die unquantisierte Vollpräzisions-BF16-Variante.

./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 Installation von pip install huggingface_hub hf_transfer ). Sie können wählen BF16 oder andere quantisierte Versionen (obwohl es nicht empfohlen wird, unter 4-Bit zu gehen) aufgrund der geringen 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

Führen Sie dann 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

📱 Bereitstellung auf dem Telefon

Sie können FunctionGemma aufgrund seiner geringen Größe auch auf Ihrem Telefon ausführen und bereitstellen. Wir haben mit PyTorch zusammengearbeitet, um einen schlanken Workflow mit quantization-aware Training (QAT) zu erstellen, um 70 % Genauigkeit wiederherzustellen und sie dann direkt auf Edge-Geräte zu deployen.

• FunctionGemma lokal bereitstellen auf Pixel 8 und iPhone 15 Pro um Inference-Geschwindigkeiten von ~50 Tokens/s zu erreichen

• Erhalten Sie Datenschutz zuerst, sofortige Antworten und Offline-Fähigkeiten

• Verwenden Sie unser kostenloses Colab-Notebook um Qwen3 0.6B feinzuabstimmen und für die Telefonbereitstellung zu exportieren - ändern Sie es einfach zu 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 Telefon an:

iOS-TutorialAndroid-Tutorial

🦥 Feinabstimmung von FunctionGemma

Google stellte fest, dass FunctionGemma dazu gedacht ist, feinabgestimmt zu werden für Ihre spezifische Funktion-Abrufaufgabe, einschließlich Mehrfach-Turn-Anwendungsfälle. Unsloth unterstützt jetzt die Feinabstimmung von FunctionGemma. Wir haben 2 Feinabstimmun g s-Notebooks erstellt, die zeigen, wie Sie das Modell über vollständige Feinabstimmung oder LoRA kostenlos über ein Colab-Notebook trainieren können:

Reason before Tool Calling Feinabstimmungs-Notebook

Google Colabcolab.research.google.com

Mobile Actions Feinabstimmungs-Notebook

Google Colabcolab.research.google.com

Im Reason before Tool Calling Feinabstimmungs-Notebook, werden wir es feinabstimmen, "denken/überlegen" vor Funktionsaufrufen. Ketten-der-Gedanken-Reasoning wird zunehmend wichtig, um die Tool-Nutzungsfähigkeiten zu verbessern.

FunctionGemma ist ein kleines Modell, das auf Funktionsaufrufe spezialisiert ist. Es verwendet seine eigene spezielle Chat-Vorlage. Wenn Werkzeugdefinitionen und eine Benutzeraufforderung bereitgestellt werden, erzeugt es eine strukturierte Ausgabe. Diese Ausgabe können wir dann parsen, um das Werkzeug auszuführen, die Ergebnisse abzurufen und sie zur Erstellung der endgültigen Antwort zu verwenden.

Turn-Typ	Inhalt
Entwickler-Prompt	<start_of_turn>developer Sie können Funktionsaufrufe mit den folgenden Funktionen durchführen:
Funktionsdeklaration	<start_function_declaration>declaration:get_weather{ description: "Hole Wetter für Stadt", parameters: { city: STRING } } <end_function_declaration> <end_of_turn>
Benutzer-Turn	<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>
Assistenten-Abschluss	Das Wetter in Paris ist 26 Grad Celsius. <end_of_turn>

Hier implementieren wir eine vereinfachte Version unter Verwendung eines einzelnen Denkblocks (anstatt verflochtenes Reasoning) via <think></think>. Folglich sieht unsere Modellinteraktion so aus:

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

🪗Feinabstimmung von FunctionGemma für Mobile Actions

Wir haben auch ein Notebook erstellt, das zeigt, wie Sie FunctionGemma mobile Aktionen ausführen lassen können. Im Mobile Actions Feinabstimmungs-Notebook, haben wir ebenfalls Evaluation aktiviert und zeigen, wie das Feinabstimmen für On-Device-Aktionen gut funktioniert, wie im abnehmenden Evaluationsverlust zu sehen ist:

Zum Beispiel gegeben eine Aufforderung Bitte setzen Sie eine Erinnerung für ein "Team Sync Meeting" diesen Freitag, den 6. Juni 2025, um 14:00 Uhr.

[{'role': 'developer',
  'content': 'Aktuelles Datum und Uhrzeit im Format YYYY-MM-DDTHH:MM:SS: 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 setzen Sie eine Erinnerung für ein "Team Sync Meeting" diesen Freitag, den 6. Juni 2025, um 14:00 Uhr.',
  'tool_calls': None}]

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

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

🏃‍♂️Mehrstufige Tool-Aufrufe mit FunctionGemma

Wir haben auch ein Notebook erstellt, das zeigt, wie Sie FunctionGemma mehrstufige Tool-Aufrufe durchführen lassen können. Im Multi-Turn-Tool-Calling-Notebook, zeigen wir, wie FunctionGemma in der Lage ist, Werkzeuge in einer langen Nachrichtenfolge aufzurufen, zum Beispiel siehe unten:

Sie müssen zuerst Ihre Werkzeuge 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 gegebenen Ort zurück.

    Argumente:
        location: Die Stadt und das Bundesland, z. B. "San Francisco, CA, USA" oder "Sydney, Australia"
        unit: Die Einheit, in der die Temperatur zurückgegeben werden soll. (Optionen: ["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": "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):
    """
    Addiert 2 Zahlen

    Argumente:
        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

    Argumente:
        x: Erste Zahl
        y: Zweite Zahl

    Gibt zurück:
        result: x * y
    """
    return {"result" : float(x) * float(y)}

Wir erstellen dann ein Mapping für alle Werkzeuge:

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 auch etwas Code zur Werkzeugaufruf- und Parsing-Logik:

#@title FunctionGemma Parsing-Code (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):
    {"role": "user", "content": "Solve x^5 + 3x^4 - 10 = 3."},
        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 # Es kann jede Sequenzlänge gewählt werden!
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/functiongemma-270m-it",
    dtype = dtype, # None für automatische Erkennung
    load_in_4bit = False,  # 4-Bit-Quantisierung zur Reduzierung des Speichers
    load_in_8bit = False, # [NEU!] Etwas genauer, verwendet 2x Speicher
    load_in_16bit = True, # [NEU!] Aktiviert 16bit LoRA
    load_in_4bit = True,  # 4-Bit-Quantisierung zur Reduzierung des Speichers
    full_finetuning = False, # [NEU!] Wir haben jetzt Full-Finetuning!
)

messages = []
messages.append({"role": "user", "content": "Was ist 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:

Reason before Tool Calling Feinabstimmungs-Notebook

Google Colabcolab.research.google.com

Mobile Actions Feinabstimmungs-Notebook

Google Colabcolab.research.google.com

Multi-Turn-Tool-Calling-Notebook

Google Colabcolab.research.google.com