FunctionGemma : Comment exécuter & affiner

Apprenez à exécuter et affiner FunctionGemma localement sur votre appareil et votre téléphone.

FunctionGemma est un nouveau modèle de 270M paramètres par Google conçu pour l'appel de fonctions et l'affinage. Basé sur Gemma 3 270M et entraîné spécifiquement pour l'appel d'outils en texte uniquement, sa petite taille le rend idéal pour le déployer sur votre propre téléphone.

Vous pouvez exécuter le modèle en précision complète sur 550 Mo de RAM (CPU) et vous pouvez maintenant affiner le faire fonctionner localement avec Unsloth. Merci à Google DeepMind pour avoir collaboré avec Unsloth pour le support day-zero !

Tutoriel d'exécutionAffinage de FunctionGemma

• FunctionGemma GGUF à exécuter : unsloth/functiongemma-270m-it-GGUF

Notebooks gratuits :

• Affiner pour raisonner/réfléchir avant les appels d'outils en utilisant notre notebook FunctionGemma

• Faire appels d'outils multi-tours dans un notebook Appels d'outils Multi-tours

• Affiner pour activer les actions mobiles (calendrier, définir une minuterie) dans notre Notebook Actions mobiles

⚙️ Guide d'utilisation

Google recommande ces paramètres pour l'inférence :

• top_k = 64

• top_p = 0.95

• temperature = 1.0

• longueur maximale du contexte = 32,768

Le format de modèle de chat se trouve lorsque nous utilisons ce qui suit :

def get_today_date():
    """ Obtient la date d'aujourd'hui """
    return {"today_date": "18 décembre 2025"}
    
tokenizer.apply_chat_template(
    [
        {"role" : "user", "content" : "quelle est la date d'aujourd'hui ?"},
    ],
    tools = [get_today_date], add_generation_prompt = True, tokenize = False,
)

Format de modèle de chat FunctionGemma :

FunctionGemma nécessite le message système ou message du développeur comme Vous êtes un modèle capable d'effectuer des appels de fonctions avec les fonctions suivantes Les versions Unsloth ont cela pré-construit si vous oubliez d'en fournir un, donc veuillez utiliser unsloth/functiongemma-270m-it

<bos><start_of_turn>developer\nVous êtes un modèle capable d'effectuer des appels de fonctions avec les fonctions suivantes<start_function_declaration>declaration:get_today_date{description:<escape>Obtient la date d'aujourd'hui<escape>,parameters:{type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nquelle est la date d'aujourd'hui ?<end_of_turn>\n<start_of_turn>model\n

🖥️ Exécuter FunctionGemma

Voir ci-dessous pour un guide de bureau local ou vous pouvez consulter notre Guide de déploiement sur téléphone.

Tutoriel Llama.cpp (GGUF) :

Instructions pour exécuter dans llama.cpp (notez que nous utiliserons du 4 bits pour tenir sur la plupart des appareils) :

1

Obtenez le dernier llama.cpp sur GitHub ici. Vous pouvez suivre les instructions de compilation ci-dessous également. Changez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n'avez pas de GPU ou si vous voulez simplement une inférence CPU.

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

Vous pouvez récupérer directement depuis Hugging Face. Comme le modèle est si petit, nous utiliserons la variante BF16 en pleine précision non quantifiée.

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

Téléchargez le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Vous pouvez choisir BF16 ou d'autres versions quantifiées (bien que cela ne soit pas recommandé de descendre en dessous de 4 bits) en raison de la petite taille du modèle.

# !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

Ensuite, exécutez le modèle en mode conversation :

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

📱 Déploiement sur téléphone

Vous pouvez également exécuter et déployer FunctionGemma sur votre téléphone en raison de sa petite taille. Nous avons collaboré avec PyTorch pour créer un flux de travail simplifié utilisant l'entraînement conscient de la quantification (QAT) pour récupérer 70 % de précision puis les déployer directement sur des appareils en périphérie.

• Déployer FunctionGemma localement sur Pixel 8 et iPhone 15 Pro pour obtenir vitesses d'inférence d'environ ~50 tokens/s

• Obtenez confidentialité d'abord, réponses instantanées et capacités hors ligne

• Utilisez notre notebook Colab gratuit pour affiner Qwen3 0.6B et l'exporter pour le déploiement sur téléphone - changez-le simplement en Gemma3, et suivez les docs Gemma 3 Executorch.

📱Run LLMs on your Phone

Consultez nos tutoriels iOS et Android pour le déploiement sur votre téléphone :

Tutoriel iOSTutoriel Android

🦥 Affinage de FunctionGemma

Google a noté que FunctionGemma est destiné à être affiné pour votre tâche d'appel de fonctions spécifique, y compris les cas d'utilisation multi-tours. Unsloth prend désormais en charge l'affinage de FunctionGemma. Nous avons créé 2 notebooks d'affinage, qui montrent comment vous pouvez entraîner le modèle via affinage complet ou LoRA gratuitement via un notebook Colab :

Notebook d'affinage "Raisonner avant l'appel d'outil"

Google Colabcolab.research.google.com

Notebook d'affinage Actions Mobiles

Google Colabcolab.research.google.com

Dans le Notebook d'affinage "Raisonner avant l'appel d'outil", nous allons l'affiner pour "penser/raisonner" avant l'appel de fonction. Le raisonnement en chaîne (chain-of-thought) devient de plus en plus important pour améliorer les capacités d'utilisation des outils.

FunctionGemma est un petit modèle spécialisé pour l'appel de fonctions. Il utilise son propre modèle de chat distinct. Lorsqu'on lui fournit des définitions d'outils et une invite utilisateur, il génère une sortie structurée. Nous pouvons ensuite analyser cette sortie pour exécuter l'outil, récupérer les résultats et les utiliser pour générer la réponse finale.

Type de tour	Contenu
Invite du développeur	<start_of_turn>developer Vous pouvez effectuer des appels de fonctions avec les fonctions suivantes :
Déclaration de fonction	<start_function_declaration>declaration:get_weather{ description : "Obtenir la météo pour la ville", parameters : { city : STRING } } <end_function_declaration> <end_of_turn>
Tour de l'utilisateur	<start_of_turn>user Quel temps fait-il à Paris ? <end_of_turn>
Appel de fonction	<start_of_turn>model <start_function_call>call:get_weather{ city : "paris" } <end_function_call>
Réponse de la fonction	<start_function_response>response:get_weather{temperature:26} <end_function_response>
Clôture de l'assistant	Le temps à Paris est de 26 degrés Celsius. <end_of_turn>

Ici, nous implémentons une version simplifiée en utilisant un seul bloc de réflexion (plutôt que du raisonnement entrelacé) via <think></think>. Par conséquent, notre interaction avec le modèle ressemble à ceci :

Réflexion + Appel de fonction	<start_of_turn>model <think> L'utilisateur souhaite la météo pour Paris. J'ai l'outil get_weather. Je devrais l'appeler avec l'argument city. </think> <start_function_call>call:get_weather{ city : "paris" } <end_function_call>

🪗Affinage de FunctionGemma pour les actions mobiles

Nous avons également créé un notebook pour montrer comment faire effectuer des actions mobiles par FunctionGemma. Dans le Notebook d'affinage Actions Mobiles, nous avons activé l'évaluation également, et montrons comment l'affinage pour des actions sur l'appareil fonctionne bien, comme on le voit par la baisse de la perte d'évaluation :

Par exemple, étant donné une invite Veuillez définir un rappel pour une "Réunion d'équipe" ce vendredi 6 juin 2025 à 14h.

[{'role': 'developer',
  'content': 'Date et heure actuelles données au format YYYY-MM-DDTHH:MM:SS : 2025-06-04T15:29:23\nLe jour de la semaine est mercredi\nVous êtes un modèle capable d'effectuer des appels de fonctions avec les fonctions suivantes\n',
  'tool_calls': None},
 {'role': 'user',
  'content': 'Veuillez définir un rappel pour une "Réunion d'équipe" ce vendredi 6 juin 2025 à 14h.',
  'tool_calls': None}]

Nous avons affiné le modèle pour qu'il puisse produire :

<start_of_turn>user
Veuillez définir un rappel pour une "Réunion d'équipe" ce vendredi 6 juin 2025 à 14h.<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>

🏃‍♂️Appels d'outils Multi-tours avec FunctionGemma

Nous avons également créé un notebook pour montrer comment faire effectuer à FunctionGemma des appels d'outils multi-tours. Dans le notebook Appels d'outils Multi-tours, nous montrons comment FunctionGemma est capable d'appeler des outils dans un long changement de message, par exemple voir ci-dessous :

Vous devez d'abord spécifier vos outils comme ci-dessous :

def get_today_date():
    """
    Obtient la date d'aujourd'hui

    Retourne :
        today_date : Date d'aujourd'hui au format 18 décembre 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"):
    """
    Obtient la météo actuelle dans un emplacement donné.

    Args :
        location : La ville et l'état, par ex. "San Francisco, CA, USA" ou "Sydney, Australia"
        unit : L'unité pour retourner la température. (choix : ["celsius", "fahrenheit"])

    Retourne :
        temperature : La température actuelle à l'emplacement donné
        weather : La météo actuelle à l'emplacement donné
    """
    if "San Francisco" in location.title():
        return {"temperature": 15, "weather": "ensoleillé"}
    elif "Sydney" in location.title():
        return {"temperature": 25, "weather": "nuageux"}
    else:
        return {"temperature": 30, "weather": "pluvieux"}

def add_numbers(x: float | str, y: float | str):
    """
    Additionne 2 nombres

    Args :
        x : Premier nombre
        y : Deuxième nombre

    Retourne :
        resultat : x + y
    """
    return {"result" : float(x) + float(y)}

def multiply_numbers(x: float | str, y: float | str):
    """
    Multiplie 2 nombres

    Args :
        x : Premier nombre
        y : Deuxième nombre

    Retourne :
        resultat : x * y
    """
    return {"result" : float(x) * float(y)}

Nous créons ensuite un mappage pour tous les outils :

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

Nous avons aussi besoin de code d'invocation d'outil et d'analyse :

#@title Code d'analyse FunctionGemma (extensible)
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

Et maintenant nous pouvons appeler le modèle !

from unsloth import FastLanguageModel
import torch
max_seq_length = 4096 # Vous pouvez choisir n'importe quelle longueur de séquence !
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/functiongemma-270m-it",
    max_seq_length = max_seq_length, # Choisissez n'importe quelle valeur pour un contexte long !
    load_in_4bit = False,  # quantification 4 bits pour réduire la mémoire
    load_in_8bit = False, # [NOUVEAU !] Un peu plus précis, utilise 2x la mémoire
    load_in_16bit = True, # [NOUVEAU !] Active LoRA 16 bits
    full_finetuning = False, # [NOUVEAU!] Nous avons maintenant le fine-tuning complet !
    # token = "hf_...", # utilisez-en un si vous utilisez des modèles à accès restreint
)

messages = []
messages.append({"role": "user", "content": "Quelle est la date d'aujourd'hui ?"})
messages = do_inference(model, messages, max_new_tokens = 128)

Essayez les 3 notebooks que nous avons créés pour FunctionGemma :

Notebook d'affinage "Raisonner avant l'appel d'outil"

Google Colabcolab.research.google.com

Notebook d'affinage Actions Mobiles

Google Colabcolab.research.google.com

notebook Appels d'outils Multi-tours

Google Colabcolab.research.google.com