FunctionGemma: Wie man ausführt & feinabstimmt

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

FunctionGemma ist ein neues Modell von Google mit 270M Parametern, 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 Präzision 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 Partnerschaft mit Unsloth für Day-Zero-Unterstützung!

AusführungsanleitungFeinabstimmung von FunctionGemma

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

Kostenlose Notebooks:

• Feinabstimmen auf Erwägen/denken vor Tool-Aufrufen mittels unseres FunctionGemma-Notebooks

• Führen Sie Multi-Turn-Tool-Aufrufe durch 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 Folgendes 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 benötigt die System- oder Developer-Nachricht als Sie sind ein Modell, das Funktionsaufrufe mit den folgenden Funktionen durchführen kann Unsloth-Versionen haben dies eingebaut, falls Sie vergessen, eine zu übergeben, verwenden Sie daher bitte 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 unsere Telefon-Bereitstellungsanleitung ansehen.

Llama.cpp Tutorial (GGUF):

Anweisungen zum Ausführen in llama.cpp (beachte, dass wir 4-Bit verwenden werden, um auf die meisten Geräte zu passen):

1

Hole dir die neueste llama.cpp auf GitHub hier. Du kannst auch den Build-Anweisungen unten folgen. Ändere -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn du keine GPU hast oder nur CPU-Inferenz möchtest. Für Apple Mac / Metal-Geräte, setze -DGGML_CUDA=OFF 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 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 (nach der Installation 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

Dann führe 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

📱 Telefon-Bereitstellung

Sie können FunctionGemma aufgrund seiner geringen Größe auch auf Ihrem Telefon ausführen und bereitstellen. Wir haben mit PyTorch zusammengearbeitet, um einen optimierten Workflow unter Verwendung quantisierungsbewusster Ausbildung zu erstellen (QAT), um 70 % Genauigkeit wiederherzustellen und sie dann direkt auf Edge-Geräten bereitzustellen.

• Bereitstellen von FunctionGemma lokal auf Pixel 8 und iPhone 15 Pro um Inferenzgeschwindigkeiten von ~50 Tokens/s zu erreichen

• Erhalten Sie Datenschutz zuerst, sofortige Antworten und Offline-Funktionen

• Verwenden Sie unser kostenloses Colab-Notebook um Qwen3 0.6B feinzuabstimmen und für die Telefonbereitstellung zu exportieren - ändern Sie es einfach auf Gemma3 und folgen Sie den Gemma 3 Executorch-Dokumenten.

📱Run LLMs on your Phone

Sehen Sie sich unsere iOS- und Android-Tutorials für die Bereitstellung auf Ihrem Telefon an:

iOS-TutorialAndroid-Tutorial

🦥 Feinabstimmung von FunctionGemma

Google bemerkte, dass FunctionGemma dazu gedacht ist, feinabgestimmt zu werden für Ihre spezifische Funktion-Aufruf-Aufgabe, einschließlich Multi-Turn-Anwendungsfälle. Unsloth unterstützt jetzt die Feinabstimmung von FunctionGemma. Wir haben 2 Feinabstimmungs-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-Notebookwerden wir es feinabstimmen, "denken/überlegen" vor Funktionsaufrufen. Chain-of-Thought-Reasoning wird zunehmend wichtig, um die Fähigkeiten zur Tool-Nutzung zu verbessern.

FunctionGemma ist ein kleines Modell, das auf Funktionsaufrufe spezialisiert ist. Es verwendet sein eigenes spezielles Chat-Template. Wenn es mit Tool-Definitionen und einer Benutzeraufforderung versehen wird, 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.

Zug-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: "Hole das Wetter für die Stadt", parameters: { city: STRING } } <end_function_declaration> <end_of_turn>
Benutzerzug	<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>
Assistent-Abschluss	Das Wetter in Paris beträgt 26 Grad Celsius. <end_of_turn>

Hier implementieren wir eine vereinfachte Version unter Verwendung eines einzelnen Denkblocks (anstelle von verflochtenem Reasoning) mittels <think></think>. Folglich sieht unsere Modellinteraktion so aus:

Thinking + 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 Argument city 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-Notebookhaben wir ebenfalls eine Bewertung aktiviert und zeigen, wie sich die Feinabstimmung für On-Device-Aktionen bewährt, wie man an dem sinkenden Evaluationsverlust sehen kann:

Zum Beispiel gegeben eine Aufforderung Bitte legen Sie eine Erinnerung für ein "Team Sync Meeting" an diesem Freitag, dem 6. Juni 2025, um 14:00 Uhr fest.

[{'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 legen Sie eine Erinnerung für ein "Team Sync Meeting" an diesem Freitag, dem 6. Juni 2025, um 14:00 Uhr fest.',
  'tool_calls': None}]

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

<start_of_turn>user
Please set a reminder for a "Team Sync Meeting" this Friday, June 6th, 2025, at 2 PM.<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 Multi-Turn-Tool-Aufrufe durchführen lassen können. Im Multi-Turn-Tool-Calling-Notebookzeigen wir, wie FunctionGemma in der Lage ist, Tools in einer langen Nachrichtenfolge aufzurufen, zum Beispiel siehe unten:

Sie müssen zuerst 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 bestimmten 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 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": "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 eine Zuordnung 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 auch etwas Code zur Tool-Aufruf- und Parsing-Verarbeitung:

#@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 })
    has_tool_calls = False

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)
    has_tool_calls = False

Und jetzt können wir das Modell aufrufen!

from unsloth import FastLanguageModel
import torch
max_seq_length = 4096 # Sie können 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 beliebig für langen Kontext!
    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
    full_finetuning = False, # [NEU!] Wir haben jetzt vollständige Feinabstimmung!
    # token = "hf_...", # verwenden Sie einen, wenn Sie gegatterte Modelle verwenden
)

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