Explorer de grands modèles de langage sur une puce Apple avec MLX

Bonjour, je suis Angelos, ingénieur dans l’équipe MLX. Aujourd’hui, je vais vous montrer en quoi MLX est parfait pour les grands modèles de langage sur puce Apple. Il vous permet d’effectuer des inférences et d’affiner des modèles massifs directement depuis votre Mac. Et vous pouvez faire tout cela avec des applications CLI ou à partir de Python ou Swift. Si vous débutez avec MLX, il s’agit d’une bibliothèque open source spécialement conçue pour l’apprentissage automatique sur les puces Apple. Il utilise Metal pour l’accélération sur la carte graphique et tire parti de la mémoire unifiée afin que les opérations sur le processeur et la carte graphique puissent fonctionner simultanément sur les mêmes données. Vous pouvez utiliser MLX dans votre langage préféré car il fournit des API en Python, Swift, C++ et même C. Pour en savoir plus, consultez « Get started with MLX for Apple sillicon ». Lorsqu’il s’agit d’exécuter de grands modèles de langage sur les puces Apple, MLX libère de nouvelles capacités puissantes, vous permettant d’exécuter les derniers modèles de pointe directement sur votre Mac avec une commande d’une seule ligne. Chargeons le dernier modèle de DeepSeek AI, qui compte un nombre impressionnant de 670 milliards de paramètres.

Même lorsqu’ils sont quantifiés à 4,5 bits par poids, les poids du modèle nécessitent à eux seuls environ 380 gigaoctets de mémoire. Pour les gérer, nous utilisons une M3 Ultra avec ses 512 gigaoctets de mémoire unifiée, aucun autre appareil grand public ne s’en approche. Maintenant que le modèle est chargé, nous pouvons commencer à interagir avec lui. Nous pouvons lui poser des questions telles que : « Quel est le lac le plus profond des États-Unis ? » Ou lui demander d’écrire du code pour nous.

Comme vous pouvez le constater, MLX permet une interaction et une génération fluides et en temps réel à des vitesses plus rapides que les vitesses de lecture, même avec des modèles contenant des centaines de milliards de paramètres, tous exécutés localement directement sur le bureau de votre Mac. Maintenant que vous avez vu ce qui est possible, voyons comment utiliser MLX pour exécuter ces puissants modèles sur votre propre Mac. Nous commencerons par présenter MLX LM, une bibliothèque Python et un ensemble d’applications en ligne de commande qui peuvent répondre à toutes vos exigences en matière de grands modèles de langage, offrant une solution robuste et polyvalente pour un large éventail d’applications.

Par la suite, nous nous pencherons sur la génération de texte avec MLX LM et montrerons à quel point il est facile de générer du texte à partir de Python ou du terminal. En outre, nous passerons en revue le téléchargement de modèles à partir de Hugging Face et leur quantification pour une inférence plus rapide sur l’appareil.

MLX peut cependant faire bien plus qu’une simple inférence. Ensuite, nous utiliserons MLX LM pour affiner un modèle de langage sur nos propres données. En particulier, nous entraînerons un adaptateur de rang bas, que nous pourrons ensuite fusionner dans le modèle pour un déploiement plus facile et une inférence plus rapide. Enfin, nous allons passer en revue l’utilisation de MLX depuis Swift, où nous verrons comment vous pouvez intégrer un grand modèle de langage dans votre application Swift avec seulement quelques lignes de code.

Le moyen le plus simple de commencer à utiliser des modèles de langage dans MLX est d’utiliser MLX LM. MLX LM est un package Python construit sur MLX, conçu pour exécuter et expérimenter de grands modèles de langage. Il fournit un ensemble d’outils de ligne de commande qui vous permettent de générer du texte ou d’affiner des modèles, le tout sans écrire de code. Et si vous voulez plus de contrôle, il fournit également une API Python afin que vous puissiez personnaliser le processus de génération ou d’entraînement autant que vous le souhaitez. Il est également étroitement intégré à Hugging Face. Cela signifie que vous pouvez télécharger rapidement des milliers de modèles sur Internet et même charger les vôtres pour les partager avec la communauté.

Il est facile de commencer. Il suffit d’exécuter pip install mlx-lm.

Examinons maintenant en détail le cas d’utilisation le plus courant des modèles de langage : la génération de texte.

Il s’agit d’un outil de ligne de commande qui vous permet de générer du texte à l’aide d’un modèle de langage, directement depuis votre terminal, sans coder. Voici comment cela fonctionne : vous lui donnez un modèle de Hugging Face ou un chemin local, une invite textuelle, et il s’occupe du reste. Il télécharge le modèle si nécessaire, il exécute l’invite et imprime la réponse générée. Donc, au lieu de simplement en parler, exécutons cette commande.

En quelques secondes, nous obtenons une implémentation Swift de Quick Sort.

Vous pouvez modifier le comportement du modèle en ajoutant des indicateurs pour des éléments tels que la température d’échantillonnage, les jetons top-p ou max, comme avec n’importe quelle configuration standard de génération de texte. Et si vous êtes curieux de connaître toutes les options disponibles, vous pouvez toujours exécuter mlx_lm.generate --help. Donc, que vous prototypiez des idées, génériez du code ou exploriez simplement ce que le modèle peut faire, c’est le point de départ le plus simple. Nous venons de voir à quel point il est facile de générer du texte à partir de la ligne de commande en utilisant mlx_lm.generate. Mais l’une des véritables forces de MLX LM est qu’il ne se limite pas aux outils terminaux. Il fournit également une API Python propre et flexible, parfaite lorsque vous souhaitez un contrôle plus fin ou que vous devez intégrer la génération dans un flux de travail plus large. Voyons comment nous pouvons faire la même chose, en générant du texte, en utilisant seulement quelques lignes de Python.

Premièrement, nous importons deux utilitaires : load et generate. Load, comme son nom l’indique, gère tout ce qui concerne le chargement du modèle. Il récupère le modèle demandé, soit à partir de votre disque local, soit directement à partir de Hugging Face et configure l’objet modèle avec le tokenizer. Ensuite, nous appelons generate. Cette fonction effectue une boucle de génération de jetons et renvoie le texte de sortie, que nous pouvons traiter plus loin dans Python, journaliser ou alimenter d’autres systèmes.

Ainsi, avec seulement ces deux étapes, load, puis generate nous obtenons les mêmes fonctionnalités que l’interface de ligne de commande, mais avec un contrôle et une flexibilité complets en Python. Voici donc un autre aspect puissant de l’API Python de MLX LM. Le modèle que vous obtenez à partir de la charge n’est pas un objet opaque avec lequel vous ne pouvez interagir que via une interface fixe. Il s’agit d’un réseau neuronal MLX entièrement structuré, ce qui signifie que vous pouvez l’inspecter, explorer son architecture et même le modifier. Je vais vous faire une démo rapide.

Nous pouvons commencer par imprimer la liste des couches qui composent le modèle.

Cela nous donne une ventilation complète de la pile de transformateurs, couche par couche. Nous pouvons également examiner les paramètres du modèle, essentiellement les poids et les biais que le modèle a appris.

Et si nous voulons creuser dans une partie spécifique du réseau, disons le module d’auto-attention dans la première couche, nous pouvons le faire aussi.

Ce niveau de transparence est vraiment utile, non seulement pour le débogage ou l’apprentissage, mais aussi si vous souhaitez expérimenter des choses comme l’échange de couches, les routines de réglage fin personnalisées ou la chirurgie de modèle de bas niveau.

Jusqu’à présent, nous avons vu comment générer du texte à partir d’une seule invite. Mais que se passe-t-il si vous souhaitez maintenir une conversation ou générer des réponses à plusieurs tours où chaque nouvelle invite s’appuie sur la précédente ? C’est là qu’intervient le cache valeur-clé, ou cache KV. Les modèles de langage utilisent des mécanismes d’attention pour traiter les jetons d’entrée et, pendant la génération, ils calculent de manière répétée l’attention sur tous les jetons générés précédemment. Cela peut coûter cher, surtout pour les longues invites ou les scénarios à plusieurs tours. Un cache KV résout ce problème en stockant les résultats intermédiaires des étapes précédentes, en particulier les clés et les valeurs.

Au lieu de tout recalculer à partir de zéro, le modèle réutilise ce cache, ce qui permet d’économiser du temps et des calculs. Dans MLX LM, l’utilisation d’un cache KV est simple.

Mettons à jour l’exemple Python précédent avec un cache KV créé explicitement que nous pouvons réutiliser pour plusieurs générations.

Nous créons d’abord l’objet cache à l’aide de la fonction make_prompt_cache. Nous pouvons l’utiliser pour modifier l’historique en place, l’enregistrer pour une utilisation ultérieure ou passer d’une conversation à l’autre de manière transparente.

Ensuite, nous le transmettons à la fonction generate. Et à mesure que de nouveaux jetons sont générés, le cache est mis à jour. Chaque appel reprend là où le précédent s’est arrêté, en conservant le contexte à chaque tour. Ceci est particulièrement utile lors de la création de chatbots, d’assistants virtuels ou de toute application interactive où il est important de garder une trace de l’histoire.

Maintenant, changeons un peu de sujet et parlons de la quantification du modèle. Nous avons vu comment générer du texte et travailler avec des modèles de manière interactive. Mais pour un déploiement réel, l’efficacité devient tout aussi importante que la fonctionnalité. Les modèles sont généralement publiés avec la même précision avec laquelle ils ont été entraînés, comme float32 ou float16. C’est précis, mais cela les rend grands et lents, surtout sur les petits appareils. C’est là que la quantification entre en jeu.

Elle réduit le modèle à une précision inférieure, comme Int8 ou même 4 bits, ce qui réduit l’utilisation de la mémoire et accélère l’inférence, souvent avec peu d’impact sur la qualité. Mais généralement, la quantification implique des outils supplémentaires, des scripts de conversion et des casse-têtes concernant la compatibilité. Dans MLX, c’est beaucoup plus simple. La quantification est intégrée. Vous pouvez comprimer des modèles à différents niveaux et les utiliser immédiatement pour l’inférence ou l’entraînement sans configuration supplémentaire. Voyons comment cela fonctionne.

Pour quantifier ou convertir un modèle avec MLX, vous utilisez la commande mlx_lm.convert. Cet outil se charge de télécharger un modèle à partir de Hugging Face, de le convertir en une précision différente et de l’enregistrer localement en une seule étape. Dans cet exemple, nous récupérons le modèle Mistral original 16 bits et le quantifions à environ 4 bits par poids.

Le résultat est un modèle nettement plus petit, plus rapide à exécuter et nécessitant moins de mémoire. Une fois converti, le modèle est enregistré dans le dossier spécifié et peut être utilisé immédiatement pour l’inférence ou l’entraînement à l’aide des mêmes outils MLX LM.

Et si vous souhaitez partager votre modèle de quantification avec d’autres, vous pouvez facilement le charger sur Hugging Face en transmettant un nom de dépôt. Donc, que vous optimisiez la vitesse, économisiez de l’espace ou contribuiez à la communauté, cette commande est tout ce dont vous avez besoin.

Tout comme pour la génération de texte, l’utilisation de l’API Python pour convertir et quantifier des modèles vous offre plus de flexibilité sans ajouter de complexité. En fait, MLX LM facilite l’application de différents paramètres de quantification à différentes parties du modèle ou à partir de Python.

Par exemple, il est courant de conserver les couches d’incorporation et de projection finale avec une plus grande précision, car elles ont tendance à être plus sensibles à la quantification. Dans cet exemple, nous quantifions ces couches à 6 bits tandis que le reste du modèle utilise 4 bits, ce qui permet d’atteindre un excellent équilibre entre qualité et efficacité. Cela se fait en passant une fonction de prédicat de quantification, une petite fonction qui reçoit chaque couche et renvoie les paramètres de quantification à utiliser pour elle. Tout le reste fonctionne exactement de la même manière. Nous appelons convert, passons le chemin Hugging Face et le répertoire de sortie local, et MLX s’occupe du reste, y compris le téléchargement du modèle et l’enregistrement du résultat quantifié. Ce contrôle précis est particulièrement utile lorsque vous expérimentez la compression de modèles ou que vous essayez de trouver le meilleur compromis entre performances et précision.

Jusqu’à présent, nous avons vu comment générer du texte à l’aide de grands modèles de langage et comment les quantifier pour une inférence plus rapide et un déploiement plus léger. Mais MLX peut faire plus, surtout en matière d’entraînement. Avec MLX LM, vous pouvez affiner un modèle de langage volumineux sur vos propres données directement sur votre Mac, et surtout, sans que ces données ne quittent jamais votre appareil. Et le plus beau, c’est que vous pouvez le faire sans écrire une seule ligne de code. Voyons comment le réglage fin fonctionne.

Les grands modèles de langage sont généralement entraînés sur des ensembles de données massifs et polyvalents provenant d’Internet. Cela leur donne de vastes connaissances, mais cela signifie également qu’ils peuvent manquer de profondeur dans des domaines spécialisés ou manquer le ton et le langage d’une tâche spécifique. Le réglage fin est la façon dont nous adaptons ces modèles à de nouveaux contextes. En les formant davantage sur un ensemble de données plus petit et spécifique à un domaine, nous pouvons leur donner de nouvelles capacités ou adapter leurs réponses à des besoins particuliers. Traditionnellement, ce processus se fait dans le cloud, ce qui peut être coûteux et souvent peu idéal lorsque vous travaillez avec des données privées ou sensibles. Mais avec MLX, vous pouvez affiner de grands modèles de langage localement sur votre Mac, sans avoir besoin de cloud, et aucune donnée ne quitte jamais votre machine. Il est efficace, sécurisé et parfaitement intégré au flux de travail MLX.

MLX LM prend en charge deux types de réglage fin prêts à l’emploi : réglage fin complet du modèle et entraînement sur des adaptateurs de bas rang. En réglage fin complet, nous mettons à jour tous les paramètres du modèle pré-entraîné. Cela vous donne un maximum de flexibilité, mais c’est aussi plus gourmand en ressources. En revanche, l’entraînement des adaptateurs, en particulier les adaptateurs de bas rang, ajoute un petit nombre de nouveaux paramètres au modèle et n’entraîne que ceux-ci, tout en gardant le réseau d’origine gelé. Cela rend l’entraînement plus rapide, plus léger et souvent plus économe en mémoire, en particulier sur le matériel local. Voyons comment nous pouvons appliquer cela dans la pratique en affinant le modèle Mistral sur un jeu de données personnalisé. Voyons à quel point il est facile de lancer un travail de réglage fin avec MLX LM. Il suffit d’une seule commande et de quelques arguments clés. Nous spécifions le modèle que nous voulons affiner, le chemin d’accès au jeu de données et la durée d’entraînement. Comme la quantification est profondément intégrée à MLX, la commande mlx_lm.lora peut même entraîner des adaptateurs sur des modèles quantifiés. Cela réduit considérablement l’utilisation de la mémoire sans sacrifier la capacité à affiner efficacement.

Dans cet exemple, nous nous entraînons sur une version quantifiée 4 bits de Mistral, qui réduit l’utilisation de la mémoire pour les poids du modèle d’environ 3,5 fois par rapport à la version de précision complète. Ainsi, même sur les grands modèles, le réglage fin reste pratique et efficace sur votre Mac. Cette commande à une seule ligne est parfaite pour une course d’entraînement rapide, surtout lorsque vous débutez. Mais si vous voulez vraiment affiner les performances, vous aurez probablement besoin de plus de contrôle sur le processus d’entraînement. C’est là qu’intervient le fichier de configuration de l’entraînement. MLX LM prend en charge les fichiers de configuration qui vous donnent un contrôle précis sur tous les aspects de la formation, y compris la taille du chemin, les calendriers de taux d’apprentissage, les paramètres de l’optimiseur, les intervalles d’évaluation, etc. Cela vous permet d’adapter la configuration de l’entraînement à vos objectifs spécifiques en matière d’ensemble de données, de matériel ou d’optimisation, et de tirer le meilleur parti de votre adaptateur. Voyons maintenant le réglage fin en action et comment il peut mettre à jour les connaissances d’un modèle. Nous commençons par demander à Mistral 7b qui a remporté le dernier Super Bowl.

Comme prévu, la réponse est correcte, mais dépassée. Le seuil de connaissance du modèle signifie qu’il n’a pas accès aux évènements récents. Mais la beauté du réglage fin est que nous pouvons résoudre ce problème en quelques minutes seulement. En l’entraînant sur un petit ensemble de données avec des questions et des réponses sur le dernier Super Bowl, nous pouvons mettre à jour les connaissances du modèle et lui demander de répondre avec précision.

Après seulement quelques minutes de réglage fin, le modèle est maintenant capable de répondre avec des réponses à jour sur les équipes, les joueurs, les scores et plus encore.

Maintenant que nous avons entraîné nos adaptateurs, nous pouvons utiliser MLX LM pour les fusionner dans le modèle de base. Cette option est particulièrement utile pour le déploiement et le partage, car elle produit un modèle unique et autonome, facile à distribuer et à utiliser.

Le processus de fusion combine l’adaptateur avec les poids d’origine, ce qui donne un modèle qui a la même architecture et le même nombre de paramètres que la version pré-entraînée, mais avec des capacités mises à jour. Ainsi, de l’extérieur, il se comporte comme n’importe quel autre modèle, mais avec vos connaissances approfondies intégrées.

Pour fusionner l’adaptateur dans le modèle, nous utilisons la commande mlx_lm.fuse. Il calcule les poids fusionnés et enregistre les résultats sur le chemin spécifié, le tout en une seule étape. Il n’est pas nécessaire de déquantifier ou de requantifier manuellement quoi que ce soit. MLX gère cela automatiquement et conserve la même quantification que celle utilisée pendant l’entraînement. Et si vous souhaitez partager votre nouveau modèle avec d’autres, c’est tout aussi facile. Il vous suffit de fournir un nom de référentiel Hugging Face et le modèle fusionné sera chargé et prêt à l’emploi. Jusqu’à présent, nous avons utilisé Python pour générer du texte et affiner de grands modèles de langage. Mais l’une des caractéristiques les plus remarquables de MLX est qu’il apporte la même simplicité et flexibilité à Swift. Voyons à quel point il est facile d’utiliser un grand modèle de langage en Swift avec MLX.

Voici un exemple complet de chargement d’un modèle Mistral quantifié et de génération de texte depuis Swift. Et le tout tient en seulement 28 lignes de code. Nous commençons par importer MLX et les bibliothèques de modèles de langage. Ensuite, nous créons un conteneur modèle, un acteur qui gère en toute sécurité l’accès simultané au modèle et au tokenizer. Ensuite, nous préparons l’entrée. Nous tokenisons l’invite, en la convertissant dans le format numérique compris par le modèle. Enfin, nous exécutons la boucle de génération et imprimons le résultat, comme nous l’avons vu précédemment en Python. C’est le même processus, les mêmes capacités, mais maintenant entièrement natif dans Swift. Voyons maintenant ce qu’il faut pour conserver l’historique d’une conversation à travers plusieurs interactions avec un modèle, tout comme nous l’avons fait en Python précédemment. Dans Swift, cela ne nécessite que quelques lignes supplémentaires. L’idée clé est la même, nous devons créer explicitement un cache de valeur clé afin de pouvoir le réutiliser sur plusieurs générations. Cela se fait avec une seule ligne de code supplémentaire. Aucune complexité ajoutée. Pour gérer l’interaction plus précisément, nous utilisons également un itérateur de jetons, qui nous permet de définir directement la valeur de la clé et de contrôler les générations étape par étape. Cette configuration nous donne la flexibilité nécessaire pour gérer les conversations à plusieurs tours et les invitations avancées, le tout depuis Swift. Tout au long de cette séance, nous avons vu à quel point il est simple d’effectuer de l’inférence, de l’entraînement et de la quantification avec MLX, que ce soit par le biais de code ou de commandes terminales. Tout ce que nous avons utilisé, des API de modèles de langage de haut niveau aux noyaux Metal qui les alimentent, est entièrement open-source. MLX fournit des opérations de base en C, C++, Python et Swift, avec des API de haut niveau en Python et Swift, ce qui vous offre à la fois flexibilité et contrôle sur l’ensemble de la pile. Cela rend MLX particulièrement puissant pour exécuter des modèles de langage et des flux de travail d’apprentissage automatique sur du matériel Apple. Voyons maintenant où vous pouvez aller à partir de maintenant. Nous avons exploré certaines des principales caractéristiques de MLX LM, mais vous pouvez faire beaucoup plus. Notre documentation approfondit les fonctionnalités avancées telles que l’inférence et l’entraînement distribués, la quantification apprise et les boucles d’entraînement personnalisées. Pour une prise en main rapide, les exemples de référentiels MLX et MLX Swift proposent des projets prêts à l’emploi pour des tâches telles que la génération d’images avec des modèles de diffusion, la reconnaissance vocale et l’entraînement complet de modèles de langage. Que vous créiez votre propre application d’IA ou que vous exploriez ses entrailles, tout ce dont vous avez besoin est à quelques clics pour commencer. Nous sommes impatients de voir les expériences incroyables que vous créerez sur le matériel Apple à l’aide de MLX et la puissance des grands modèles de langage.