Le projet que je te propose

🎯 Objectif

Fine-tuner :

google/functiongemma-270m-it

pour lui apprendre un mini-système de domotique :

turn_on_light(room)
turn_off_light(room)
set_light_brightness(room, brightness)
set_temperature(room, temperature)

Puis comparer :

FunctionGemma base
        VS
FunctionGemma fine-tuné

sur des prompts qu’il n’a jamais vus.

L’intérêt pédagogique est énorme : on peut montrer concrètement que le fine-tuning ne sert pas seulement à “rendre le modèle plus intelligent”, mais à ancrer un comportement spécialisé.

Google explique justement que le fine-tuning de FunctionGemma peut servir à résoudre les ambiguïtés de sélection d’outils, gérer des schémas non standards et transférer des workflows spécifiques vers un petit modèle. Google AI for Developers

🧪 Notre expérience

Je partirais sur ce dataset :

100-500 exemples

avec des variations comme :

"Allume la lumière du salon"
→ turn_on_light(room="living_room")

"Éteins la chambre"
→ turn_off_light(room="bedroom")

"Mets la lumière du bureau à 40%"
→ set_light_brightness(
      room="office",
      brightness=40
  )

"Monte le chauffage du salon à 21 degrés"
→ set_temperature(
      room="living_room",
      temperature=21
  )

Mais surtout, on ajouterait des cas négatifs :

"Quelle est la température actuelle ?"
→ NO TOOL

et des cas ambigus :

"Fais plus chaud dans le salon"

pour voir si le modèle apprend à produire :

set_temperature(
    room="living_room",
    temperature=???
)

ou à ne pas halluciner un paramètre absent.

🧠 Et on ferait un vrai benchmark AVANT / APRÈS

Par exemple :

                         BASE       FINE-TUNED

Tool selection           72%           96%
Arguments                61%           93%
No-tool                  78%           91%
Ambiguous prompts        42%           81%
JSON validity            89%           99%

Ces chiffres seraient les nôtres, mesurés expérimentalement — pas des chiffres inventés.

C’est ça qui rendrait le notebook intéressant.

📓 Structure du Colab

Je ferais environ 10 cellules principales.

1. Installation

!pip install -U transformers datasets accelerate trl

Google utilise justement transformers, datasets, accelerate et trl dans son guide officiel de fine-tuning. Google AI for Developers

from huggingface_hub import login

login()

Il faut avoir accepté les conditions d’utilisation de Gemma sur Hugging Face pour télécharger google/functiongemma-270m-it. Google AI for Developers

3. Charger FunctionGemma

MODEL_ID = "google/functiongemma-270m-it"

from transformers import AutoProcessor, AutoModelForCausalLM

processor = AutoProcessor.from_pretrained(MODEL_ID)

model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    device_map="auto",
    dtype="auto"
)

Le workflow officiel utilise également AutoProcessor et AutoModelForCausalLM. Google AI for Developers

4. Construire notre dataset

C’est ici que je voudrais aller plus loin que le notebook Google.

Par exemple :

examples = [
    {
        "user": "Allume la lumière du salon",
        "tool": "turn_on_light",
        "arguments": {
            "room": "living_room"
        }
    },
    {
        "user": "Éteins la lumière de la chambre",
        "tool": "turn_off_light",
        "arguments": {
            "room": "bedroom"
        }
    },
    {
        "user": "Mets la lumière du bureau à 40%",
        "tool": "set_light_brightness",
        "arguments": {
            "room": "office",
            "brightness": 40
        }
    }
]

Puis transformation vers le format conversationnel attendu par FunctionGemma.

5. Faire passer le modèle AVANT fine-tuning

Très important.

Avant de l’entraîner, on lui donne :

"Éteins la lumière du salon"

et on sauvegarde exactement ce qu’il produit.

Puis :

BASELINE
--------
Prompt
Input tokens
Output
Expected
PASS/FAIL

On garde tout.

6. Fine-tuning avec `SFTTrainer`

Google recommande justement TRL SFTTrainer pour l’entraînement supervisé de FunctionGemma. Google AI for Developers

Quelque chose dans ce style :

from trl import SFTTrainer

trainer = SFTTrainer(
    model=model,
    train_dataset=train_dataset,
    processing_class=processor,
    ...
)

trainer.train()

Les paramètres seront volontairement modestes pour qu’on puisse faire tourner l’expérience dans Colab.

7. Le test le plus important

On ne teste surtout pas les exemples d’entraînement.

On crée un test_dataset avec des formulations inédites :

TRAIN:

"Allume la lumière du salon"

TEST:

"Tu peux éclairer le séjour ?"

Puis :

TRAIN:

"Mets le bureau à 40%"

TEST:

"Réduis l'intensité du bureau à 40"

Et encore mieux :

TRAIN:
"Allume la lumière du salon"

TEST:
"Active l'éclairage du séjour"

On teste donc une forme de généralisation linguistique.

8. Puis le “stress test”

C’est la partie que j’ajouterais spécialement pour notre article.

Ambiguïté

"Fais plus chaud."

Négation

"N'allume pas la lumière."

Hors domaine

"Explique-moi la relativité générale."

Plusieurs actions

"Allume le salon et mets la lumière à 30%."

Paramètre invalide

"Mets la lumière à 300%."

Outil concurrent

"Il fait froid dans le salon."

On observe alors comment 270M raisonne avec un espace d’actions extrêmement réduit.

9. Et surtout : visualiser les résultats

On pourra produire automatiquement :

┌────────────────────────────────────────────┐
│ FunctionGemma 270M Benchmark               │
├────────────────────┬───────────┬───────────┤
│                    │ Base      │ Fine-tuned│
├────────────────────┼───────────┼───────────┤
│ Tool selection     │ 72%       │ 94%       │
│ Arguments          │ 63%       │ 91%       │
│ JSON validity      │ 87%       │ 98%       │
│ No-tool            │ 76%       │ 89%       │
│ Multi-tool         │ 31%       │ 67%       │
└────────────────────┴───────────┴───────────┘

Et même quelques graphiques matplotlib.

🔥 Une deuxième expérience serait encore plus intéressante

Après notre petit dataset artificiel, on pourrait refaire exactement le même pipeline avec :

google/mobile-actions

Google fournit précisément ce dataset et un notebook officiel pour fine-tuner FunctionGemma dessus. Google AI for Developers

Le dataset permet de passer d’un jouet pédagogique à un cas beaucoup plus réaliste : calendrier, contacts, lampe torche, recherche, etc.

Google indique également que son fine-tuning Mobile Actions améliore fortement les performances du modèle sur ce workflow spécialisé. Google DeepMind

🚀 Et j’ai trouvé un raccourci très intéressant

Google propose aussi un FunctionGemma Tuning Lab directement sur Hugging Face.

Il permet de définir ses fonctions, préparer les données et lancer le fine-tuning via une interface. Hugging Face+1

FunctionGemma Tuning Lab sur Hugging Face

Mais pour notre article, je préfère le Colab codé à la main : le lecteur comprendra réellement ce qui se passe.

💡 Et on peut aller encore plus loin

Il existe maintenant également un tutoriel Google utilisant Tunix + LoRA sur un Colab TPU v5e-1, avec FunctionGemma et google/mobile-actions. Google présente cette approche comme une manière de faire du fine-tuning rapidement et à faible coût sur le TPU gratuit de Colab. Google Developers Blog

Donc je verrais carrément 3 notebooks dans la série :

01_functiongemma_baseline.ipynb
        ↓
02_functiongemma_finetuning.ipynb
        ↓
03_functiongemma_evaluation.ipynb

Et dans le 3e :

         Hugging Face Dataset
                  ↓
          Test Generator
                  ↓
        ┌─────────┴─────────┐
        ↓                   ↓
 FunctionGemma        Fine-tuned
   270M                 270M
        ↓                   ↓
        └─────────┬─────────┘
                  ↓
             Evaluator
                  ↓
        Accuracy / Errors /
        Tool selection /
        Arguments / No-tool

Ça ferait un excellent prolongement technique à ton article LinkedIn : on ne dit plus seulement “les SLM sont intéressants”, on prend un 270M, on le mesure, on le fine-tune, on casse le modèle avec des tests, puis on regarde précisément ce qu’il a appris.

Et surtout, on peut produire un vrai Colab reproductible avec le code complet, plutôt qu’un pseudo-tutoriel. GitHub