Pourquoi je n'ai pas pu entraîner Gemma 3n localement (et pourquoi j'utilise Vertex AI à la place)
Je travaille sur une application de coaching de prononciation qui nécessite une IA multimodale capable de comprendre à la fois le texte et l'audio. L'application utilise actuellement les modèles audio natifs de Google Gemini, mais je souhaitais affiner un modèle dédié au coaching de prononciation. Le Gemma 3n de Google semblait parfait avec son support audio natif via l'encodeur Universal Speech Model. J'ai un MacBook Pro M4 Pro avec 48 Go de RAM. C'est sûrement suffisant pour entraîner un modèle de 5 milliards de paramètres localement, n'est-ce pas ?
Spoiler : non. Voici ce que j'ai appris de mes échecs.
Pourquoi j'ai essayé l'entraînement local
L'attrait était évident :
- Aucun coût : L'entraînement sur GPU cloud coûte 2 à 5 $ par tentative sur des services comme RunPod ou Vast.ai
- Confidentialité : Mes données d'entraînement restent locales
- Itération rapide : Pas de téléchargement de jeux de données ni de configuration d'environnements cloud
- Apprentissage pratique : Je voulais expérimenter les scripts d'entraînement PyTorch, comprendre les techniques d'optimisation de la mémoire et apprendre par essais et erreurs. Localement, je peux modifier le code et réessayer en quelques secondes, contre le déploiement dans le cloud et l'attente de l'exécution des scripts
J'avais 988 exemples d'entraînement couvrant les erreurs de prononciation, l'analyse de la prestation orale et les conversations de coaching. Cela semblait être un candidat parfait pour un entraînement local de nuit.
Que signifie réellement entraîner un modèle ?
Clarification rapide : lorsque les gens disent « entraîner », ils peuvent vouloir dire deux choses très différentes.
L'entraînement à partir de zéro est ce que font Google et OpenAI. Vous commencez avec des nombres aléatoires et vous apprenez à un réseau neuronal tout depuis le début. Cela nécessite des milliards d'échantillons de texte, des centaines de GPU et des mois de temps de calcul. C'est coûteux et lent.
Le fine-tuning (affinage) consiste à prendre un modèle déjà entraîné et à lui enseigner votre tâche spécifique. Le travail difficile est déjà fait. Le modèle comprend le langage et le raisonnement. Vous lui montrez simplement votre format et votre domaine spécifiques. C'est comme embaucher quelqu'un qui sait déjà coder et lui apprendre votre base de code, plutôt que d'apprendre à coder à quelqu'un à partir de zéro.
Pour mon cas d'utilisation, je souhaite faire du fine-tuning. Le modèle comprend déjà l'anglais et la prononciation. J'ai juste besoin qu'il donne un retour dans mon format.
Comment affiner avec Hugging Face
Hugging Face rend tout ce processus beaucoup plus facile qu'il ne le devrait. Ils hébergent des milliers de modèles pré-entraînés et vous fournissent des bibliothèques Python pour les affiner. Vous n'avez pas besoin d'un doctorat pour cela.
Voici le flux de travail de base :
from transformers import AutoProcessor, AutoModelForImageTextToText
# Télécharger le modèle et le processeur
processor = AutoProcessor.from_pretrained("google/gemma-3n-E2B-it")
model = AutoModelForImageTextToText.from_pretrained("google/gemma-3n-E2B-it")
Deux lignes de code. Cela télécharge un modèle d'IA de 5,4 milliards de paramètres sur votre ordinateur portable. Le processor convertit vos données dans le bon format, et model est le réseau neuronal lui-même.
Ensuite, vous utilisez la classe Trainer pour exécuter l'entraînement :
from transformers import Trainer, TrainingArguments
training_args = TrainingArguments(
output_dir="outputs/gemma3n",
num_train_epochs=3,
per_device_train_batch_size=1,
learning_rate=3e-5,
)
trainer = Trainer(
model=model,
args=training_args,
train_dataset=my_dataset,
)
trainer.train() # Démarrer l'entraînement !
C'est génial car vous évitez toutes les opérations de bas niveau comme l'écriture de boucles de descente de gradient et la gestion des points de contrôle. L'inconvénient ? Vous ne savez pas vraiment ce qui se passe sous le capot, surtout combien de mémoire tout utilise. Ce qui est exactement le problème que j'ai rencontré.
Le problème de mémoire
L'entraînement d'un grand modèle linguistique nécessite de faire tenir plusieurs éléments en mémoire simultanément :
- Poids du modèle : Pour Gemma 3n E2B (5,4B paramètres), cela représente environ 11 Go en float16
- Gradients : Encore environ 11 Go (même taille que les poids)
- États de l'optimiseur : Adam conserve 2 états par paramètre, soit environ 22 Go supplémentaires
- Activations : Résultats de calcul intermédiaires
- Données du lot : Les exemples d'entraînement en cours de traitement
Total : 50 à 60 Go pour le modèle E2B le plus petit, 70 à 80 Go pour E4B. Mes 48 Go de RAM n'allaient pas suffire.
Ce que j'ai essayé
Tentative 1 : Fine-tuning complet avec E4B
Mémoire insuffisante lors de l'initialisation de l'optimiseur. Le modèle s'est chargé (16 Go), mais l'optimiseur n'a pas pu allouer son état.
Tentative 2 : Tailles de lot plus petites
Réduire batch_size de 2 à 1 n'a fait que retarder l'erreur OOM jusqu'à la passe arrière.
Tentative 3 : LoRA avec E4B
LoRA (Low-Rank Adaptation) n'entraîne que de petites couches d'adaptation au lieu du modèle complet, réduisant les paramètres entraînables de 7,8 milliards à 40 millions (0,5 %). Mais le modèle de base figé doit toujours tenir en mémoire : 59 Go pour E4B seul.
Tentative 4 : LoRA avec E2B
Celle-ci a failli réussir. Le modèle E2B plus petit avec LoRA utilisait 40 à 45 Go, laissant 3 à 8 Go de marge. L'entraînement a commencé et s'est poursuivi pendant quelques heures avant de rencontrer des erreurs de mémoire lors de lots spécifiques avec des séquences plus longues.
Pourquoi cela a finalement échoué
Même avec des optimisations agressives (LoRA, batch_size=1, pas de point de contrôle de gradient), 48 Go n'étaient pas suffisants pour un entraînement cohérent. L'utilisation de la mémoire variait selon l'exemple :
- Exemples courts : 38-42 Go (OK)
- Exemples longs : 46-50 Go (plantages)
Je pourrais probablement y arriver en filtrant les exemples plus longs ou en réduisant max_length à 1024 jetons, mais à ce stade, je compromets les capacités du modèle pour m'adapter aux contraintes matérielles.
Passage à Vertex AI
Après trois jours de tentatives infructueuses, je passe à Vertex AI de Google Cloud pour l'entraînement :
- GPU A100 40 Go : Beaucoup de mémoire pour le modèle E4B avec LoRA
- Infrastructure gérée : Pas de débogage de mémoire, pas de plantages
- Coût : Environ 3 à 5 $ pour une exécution d'entraînement complète (3 époques)
- Temps : 2 à 3 heures contre mes 6 à 9 heures tentées localement
J'écrirai un article de blog séparé sur le processus d'entraînement Vertex AI, y compris :
- Configuration des tâches d'entraînement personnalisées avec Gemma 3n
- Téléchargement des jeux de données vers Cloud Storage
- Surveillance de l'entraînement avec TensorBoard
- Déploiement du modèle entraîné sur les points de terminaison Vertex AI
Quand pouvez-vous entraîner localement ?
L'entraînement local sur Apple Silicon est viable si :
- Votre modèle est plus petit : Les modèles de 1 à 3 milliards de paramètres avec LoRA tiennent confortablement dans 48 Go
- Vous avez plus de RAM : Le M4 Max avec 128 Go gérerait facilement Gemma 3n E2B
- Vous utilisez la quantification : La quantification 4 bits ou 8 bits réduit encore la mémoire mais ajoute de la complexité
Leçons clés
- La mémoire est le goulot d'étranglement : 48 Go de mémoire unifiée semblent beaucoup jusqu'à ce que vous essayiez d'entraîner des modèles de 5 milliards de paramètres et plus. Les états de l'optimiseur seuls peuvent doubler ou tripler vos besoins en mémoire
- LoRA aide mais n'est pas magique : Il réduit les paramètres entraînables de 99 %, mais les poids du modèle de base figés doivent toujours tenir en mémoire pendant les passes avant et arrière
- L'entraînement cloud est rentable : 3 à 5 $ pour une exécution d'entraînement sont raisonnables par rapport à des jours de débogage d'erreurs OOM et d'expériences ratées
- Connaissez les limites de votre matériel : La mémoire unifiée d'Apple Silicon est excellente pour l'inférence et l'entraînement de modèles plus petits (1 à 3 milliards de paramètres), mais l'entraînement fiable de modèles de 5 milliards et plus nécessite une VRAM GPU dédiée