Apple Silicon et MLX : révolution dans l'affinage local

Une nouvelle ère pour l'affinage des modèles linguistiques sur Mac

L'affinage des modèles linguistiques a longtemps été synonyme de coûts élevés liés à la location de GPU dans le cloud. Cependant, les utilisateurs de Mac équipés de puces Apple Silicon peuvent désormais personnaliser des modèles ouverts avec leurs propres données, directement sur leur appareil, sans frais supplémentaires. Cette avancée est rendue possible grâce à un cadre spécialement conçu pour tirer parti du matériel unique de ces ordinateurs portables.

En 2014, j'ai fait la transition de Windows et des machines Dell vers un Mac, et je n'ai jamais regretté ce choix. Ce qui a commencé comme une simple curiosité pour un système d'exploitation plus épuré s'est transformé en une véritable appréciation pour l'intégration harmonieuse du matériel et du logiciel par Apple. Aujourd'hui, cette synergie se manifeste de manière inattendue, notamment avec la possibilité d'affiner des modèles linguistiques directement sur l'appareil, sans recourir au cloud et sans que les données ne quittent jamais la machine.

Cette capacité est rendue possible par MLX, une bibliothèque de tableaux open source développée par l'équipe de recherche en apprentissage automatique d'Apple, accompagnée de son package MLX LM. Ce dernier offre des fonctionnalités de génération de texte et d'affinage pour des milliers de modèles ouverts, le tout à travers un ensemble de commandes simplifiées. Ce tutoriel vous guide à travers le processus complet : de l'installation des outils à la préparation d'un ensemble de données, en passant par l'entraînement d'un adaptateur LoRA, la réduction de l'utilisation de la mémoire par quantification, jusqu'au test et au déploiement du modèle affiné. À la fin, vous disposerez d'un modèle affiné fonctionnant sur votre propre machine et d'un flux de travail reproductible pour n'importe quel ensemble de données.

Pourquoi MLX est idéal pour Apple Silicon

La plupart des outils d'inférence locaux ont été initialement développés pour le matériel NVIDIA avant d'être adaptés pour Mac. MLX, en revanche, a été conçu dès le départ pour l'architecture de mémoire unifiée d'Apple Silicon, où le CPU et le GPU partagent un seul pool de mémoire.

Ce design unique élimine la nécessité de copier les données entre la mémoire système et la mémoire GPU dédiée. Sur un Mac doté de 16 Go de RAM, les poids du modèle, l'état de l'optimiseur et le lot d'entraînement coexistent dans le même espace, rendant l'affinage sur l'appareil non seulement possible, mais pratique. L'API de MLX s'inspire fortement de NumPy, ajoute une différenciation automatique pour l'entraînement et utilise Metal pour accélérer le traitement GPU tout en maintenant cette vue partagée de la mémoire.

Pour commencer, vous aurez besoin d'un Mac Apple Silicon (M1 ou plus récent), de macOS Ventura 13.5 ou d'une version ultérieure, et de Python 3.10 ou supérieur. Les Macs Intel ne sont pas pris en charge, et toute tentative d'installation sur ces machines renvoie une erreur "aucune distribution correspondante".

Sur un GPU discret, les données d'entraînement sont généralement transférées entre la mémoire système et la mémoire GPU dédiée. Apple Silicon conserve un pool partagé, permettant à un Mac de 16 Go d'affiner des modèles localement.

Configuration de votre environnement

Avec cette architecture en tête, la première étape consiste à installer les outils nécessaires. Commencez par le package et ses extensions d'entraînement, qui intègrent tout ce dont vous avez besoin pour l'affinage.

pip install "mlx-lm[train]"

Vérifiez que l'installation est correcte en effectuant un test rapide de génération sur un petit modèle.

mlx_lm.generate \
--model mlx-community/[Mistral](/dossier/mistral)-7B-Instruct-v0.3-4bit \
--[prompt](/glossaire/prompt) "Explain LoRA in two sentences." \
--max-tokens 120

Lors de la première exécution, un modèle Mistral quantifié en 4 bits est téléchargé depuis l'organisation MLX Community sur Hugging Face, mis en cache localement, puis utilisé pour générer une réponse. L'organisation mlx-community héberge des milliers de modèles pré-convertis, vous n'avez donc généralement pas besoin de convertir les poids vous-même.

Il est important de noter que l'affinage avec MLX nécessite des modèles au format safetensors de Hugging Face. Les fichiers GGUF, courants dans d'autres outils locaux, sont compatibles pour l'inférence mais pas pour l'entraînement ici. Les architectures prises en charge incluent Llama, Mistral, Qwen2, Phi, Gemma, et Mixtral, parmi d'autres, ce qui signifie que la plupart des modèles ouverts populaires sont disponibles dès le départ.

Préparation de votre ensemble de données

Une fois l'environnement configuré, l'étape suivante est de formater vos données pour qu'elles soient utilisables par le formateur. MLX LM lit les données d'entraînement à partir d'un dossier contenant trois fichiers : train.jsonl, valid.jsonl, et un test.jsonl optionnel. Chaque ligne de ces fichiers contient un exemple JSON. Le fichier d'entraînement est requis, le fichier de validation permet au formateur de rapporter la perte de validation pendant l'exécution, et le fichier de test évalue le modèle après la fin de l'entraînement.

Trois formats de données sont pris en charge : chat, completions, et text. Le format chat est le plus robuste par défaut. Il stocke des messages étiquetés par rôle par ligne et permet à MLX LM d'appliquer le modèle selon son propre modèle de chat, de sorte que vos données correspondent à la manière dont le modèle a été formé pour gérer les conversations.

{"messages": [{"role": "user", "content": "What is LoRA?"}, {"role": "assistant", "content": "An efficient way to fine-tune a model."}]}

Pour des paires d'entrées et de sorties simples, le format completions est plus simple et fonctionne bien pour les tâches de type instruction.

{"prompt": "Summarize: The market rose sharply today.", "completion": "Markets gained."}
{"prompt": "Translate to French: good morning", "completion": "bonjour"}

Par défaut, le formateur calcule la perte sur l'exemple entier, ce qui signifie que le modèle consacre des efforts à reproduire à la fois l'invite et la réponse. Passer --mask-prompt lui indique de calculer la perte uniquement sur la complétion, de sorte que l'entraînement se concentre sur la réponse qui vous intéresse réellement. Cela produit généralement un modèle qui suit les instructions de manière plus fiable, et cela fonctionne avec les formats chat et completions. Pour les données de chat, le dernier message de la liste est considéré comme la complétion.

Assurez-vous que chaque exemple tient sur une seule ligne sans sauts de ligne internes, car le lecteur traite chaque ligne comme un enregistrement distinct. Divisez vos données de sorte qu'environ 80 % se retrouvent dans train.jsonl et 10 à 20 % dans valid.jsonl. Environ 200 à 500 exemples est un minimum raisonnable pour modifier le comportement d'un modèle (beaucoup moins tendent à surajuster et mémoriser plutôt qu'à généraliser).

Entraînement de votre premier adaptateur LoRA

Avec vos données prêtes, l'étape suivante est l'entraînement. Plutôt que de mettre à jour chaque poids dans le modèle, l'Adaptation de Rang Faible (LoRA) fige les poids d'origine et entraîne de petites matrices d'adaptateur à leurs côtés. Cela réduit les besoins en mémoire et en stockage à une fraction de l'affinage complet tout en conservant la plupart de la qualité. La méthode provient de l'article LoRA de Hu et ses collègues.

LoRA garde les grands poids pré-entraînés figés et n'entraîne que les petites matrices A et B. Comme seules ces deux adaptateurs reçoivent des mises à jour, la mémoire et le stockage restent faibles.

Lancez un entraînement avec une commande, en pointant vers un modèle et votre dossier de données.

--model mlx-community/Mistral-7B-Instruct-v0.3-4bit \

Au fur et à mesure de son exécution, MLX LM affiche la perte d'entraînement, la perte de validation, les jetons traités et les itérations par seconde. Les poids des adaptateurs sont enregistrés dans un dossier d'adaptateurs par défaut. Des indicateurs clés à connaître : --fine-tune-type accepte lora (par défaut), dora, ou full ; --num-layers définit combien de couches de transformateur reçoivent des adaptateurs (par défaut : 16) ; et --iters contrôle la durée de l'entraînement.

L'exemple définit --batch-size 1 intentionnellement pour garder l'utilisation de la mémoire aussi basse que possible. Cela évite les plantages sur des machines de 16 Go. Si vous avez 64 Go ou plus, l'augmenter à 2 ou 4 réduit le temps total d'entraînement. Lorsque la mémoire est limitée mais que vous souhaitez l'effet d'un lot plus important, --grad-accumulation-steps augmente la taille effective du lot sans augmenter l'utilisation de la mémoire.

Si vous préférez des graphiques en direct plutôt que des sorties terminales, ajoutez --report-to wandb pour enregistrer les métriques dans Weights & Biases. Si vous rencontrez des problèmes de mémoire, réduisez --num-layers à 8 ou 4, ou ajoutez --grad-checkpoint pour échanger des calculs contre une mémoire plus faible. Ces deux indicateurs suffisent généralement à faire tenir un travail qui autrement manquerait d'espace.

Choix d'un modèle de base et des paramètres d'adaptateur

En s'appuyant sur les mécanismes d'entraînement ci-dessus, deux décisions précoces façonnent le reste de votre exécution : quel modèle choisir comme point de départ et combien l'adapter. Pour un premier projet, un modèle de 8B paramètres en forme de 4 bits est le compromis idéal. Une fois que le flux de travail semble confortable, vous pouvez passer à des modèles de 13B ou 14B, qui nécessitent 14 à 18 Go de mémoire de travail et s'exécutent confortablement sur une machine de 32 Go.

Le nombre de couches entraînées et le rang de l'adaptateur contrôlent ensemble la capacité. Plus de couches et un rang plus élevé donnent à l'adaptateur plus de place pour apprendre, au prix de la mémoire et du temps. Un point de départ courant utilise 16 couches avec un rang modéré, puis ajuste en fonction de la perte de validation. Si la perte d'entraînement diminue tandis que la perte de validation augmente, l'adaptateur mémorise vos exemples.

Le taux d'apprentissage est également important. Des valeurs dans la plage de 1e-5 à 5e-5 fonctionnent pour la plupart des exécutions LoRA. Trop élevé et l'entraînement devient instable ; trop bas et le modèle bouge à peine. Changez un paramètre à la fois afin de pouvoir attribuer toute amélioration à un choix spécifique.

Réduction de l'utilisation de la mémoire par quantification

Remarquez que le modèle de base ci-dessus se termine déjà en 4 bits. Entraîner un adaptateur LoRA sur un modèle quantifié est ce que les gens appellent QLoRA, décrit dans l'article QLoRA. Comme la quantification est intégrée dans MLX, la même commande mlx_lm.lora entraîne des adaptateurs directement sur des poids quantifiés sans configuration supplémentaire.

Le bénéfice est concret. Un modèle 7B en 4 bits réduit la mémoire des poids d'environ 3,5 fois par rapport à la pleine précision, amenant un affinement de 7B confortablement dans 8 Go de mémoire de travail. Sur un MacBook de 16 Go, cela laisse amplement de marge pour le système d'exploitation et votre lot d'entraînement.

Si vous préférez quantifier un modèle de pleine précision vous-même avant l'entraînement, la commande convert s'en occupe.

mlx_lm.convert \
--hf-path mistralai/Mistral-7B-Instruct-v0.3 \
--mlx-path ./mistral-4bit \

Cela écrit une version en 4 bits dans un dossier local que vous passez ensuite à --model.

Tester et générer avec votre adaptateur

Avec l'entraînement terminé, il est temps de voir à quel point l'adaptateur a bien appris. Évaluez-le par rapport à votre ensemble de test réservé pour obtenir un chiffre que vous pouvez suivre à travers les expériences.

--model mlx-community/Mistral-7B-Instruct-v0.3-4bit \
--adapter-path ./adapters \

Pour voir le modèle répondre, passez le même chemin d'adaptateur à la commande de génération. MLX LM charge le modèle de base et applique votre adaptateur par-dessus.

mlx_lm.generate \
--model mlx-community/Mistral-7B-Instruct-v0.3-4bit \
--adapter-path ./adapters \
--prompt "Summarize: Our quarterly revenue grew twelve percent."

Exécutez la même invite sans l'adaptateur pour comparer. Si votre ensemble de données correspondait bien à la tâche cible, le modèle devrait montrer une amélioration notable dans la génération de réponses pertinentes.