MLX

MLX est un framework open source de calcul numérique et de machine learning développé par Apple, conçu pour tirer le maximum des puces Apple Silicon grâce à leur architecture mémoire unifiée.

Là où PyTorch et TensorFlow ont été conçus pour des machines avec un CPU et un GPU discret (avec des mémoires séparées), MLX est pensé nativement pour Apple Silicon. Sur un Mac M1, M2, M3, M4 ou M5, le CPU et le GPU partagent la même mémoire physique. MLX exploite cette architecture : pas de copie de données entre CPU et GPU, pas de transfert coûteux, pas de .to('cuda'). Le résultat est une exécution fluide des workloads ML sur Mac, que ce soit pour de l’inférence de LLM, du fine-tuning avec LoRA, de la génération d’images, ou de la reconnaissance vocale.

Éditeur: Apple Machine Learning Research
Version actuelle: 0.31.1 (12 mars 2026)
Date de sortie: 13 décembre 2023
Licence: Open Source MIT
APIs: Python (NumPy-like), C++, C, Swift
Plateformes: macOS 14+ (Apple Silicon), Linux (CPU + CUDA) Nouveau
Accélération: Metal (GPU Apple), CUDA (NVIDIA, sur Linux), CPU
Packages: MLX LM (LLM), MLX Whisper (audio), MLX Data (données)
GitHub: ml-explore/mlx
Site: mlx-framework.org

Pourquoi MLX existe

Avant MLX, faire du machine learning sérieux sur Mac était frustrant. PyTorch supportait Metal via le backend MPS (Metal Performance Shaders), mais le support était incomplet, avec de nombreuses opérations non implémentées ou bugguées. TensorFlow avait abandonné l’optimisation Mac. Les chercheurs et développeurs ML qui voulaient travailler localement sur leur MacBook étaient renvoyés vers Linux ou le cloud.

Apple a résolu ce problème en créant MLX de zéro, avec les spécificités d’Apple Silicon comme contraintes de design de base, pas comme un portage après coup. Le résultat est un framework qui se sent natif sur Mac et qui offre des performances que les frameworks généralistes ne peuvent pas atteindre sur ce matériel.

La mémoire unifiée : l’avantage décisif

C’est le concept central de MLX. Sur un système classique avec GPU discret (une RTX 4090 par exemple), le CPU a sa RAM (DDR5) et le GPU a sa VRAM (GDDR6X). Transférer des données de l’un à l’autre prend du temps et de la bande passante. C’est pour ça que PyTorch a ce fameux tensor.to('cuda') : il faut explicitement déplacer les tenseurs en VRAM avant de les traiter sur GPU.

Sur Apple Silicon, il n’y a qu’une seule mémoire (LPDDR5/LPDDR5X) partagée entre le CPU, le GPU et le Neural Engine. MLX exploite cette architecture : un tableau créé sur le CPU est immédiatement accessible par le GPU sans aucune copie. Vous passez d’un device à l’autre de manière transparente.

import mlx.core as mx

# Pas de .to('cuda') nécessaire
# Le tableau vit en mémoire partagée
a = mx.array([1.0, 2.0, 3.0])

# Opération sur GPU (Metal) : aucun transfert
b = mx.exp(a)

# Le résultat est immédiatement disponible pour le CPU
print(b)  # array([2.71828, 7.38906, 20.0855], dtype=float32)

En pratique, ça signifie qu’un Mac avec 64 Go de mémoire unifiée peut charger un LLM de 60 Go et l’exécuter sur GPU sans aucune limitation de VRAM. Sur un système classique, il vous faudrait un GPU avec 60+ Go de VRAM (une A100 80 Go ou un cluster de RTX 4090) pour faire la même chose.

Concepts clés du framework

Évaluation paresseuse (lazy computation)

MLX utilise une évaluation paresseuse : les opérations ne sont pas exécutées immédiatement. Au lieu de ça, MLX construit un graphe de calcul, puis l’évalue uniquement quand le résultat est effectivement nécessaire (quand vous affichez une valeur, la sauvegardez, ou appelez mx.eval()). Cela permet au framework d’optimiser le graphe de calcul avant exécution (fusion d’opérations, réorganisation, élimination de calculs inutiles).

import mlx.core as mx

a = mx.ones((1000, 1000))
b = mx.ones((1000, 1000))

# Rien n'est calculé à ce stade
c = a + b
d = c * 2

# Le calcul se déclenche ici, optimisé
mx.eval(d)
print(d.shape)  # (1000, 1000)

Transformations composables

MLX supporte des transformations de fonctions composables, un paradigme inspiré de JAX. Les trois principales sont :

Différentiation automatique (mx.grad) : calcule automatiquement les gradients d’une fonction, essentiel pour l’entraînement de réseaux de neurones. Vectorisation automatique (mx.vmap) : transforme une fonction qui opère sur un seul exemple en une version qui opère sur un batch entier, sans boucle Python. Compilation de graphe (mx.compile) : compile un graphe de calcul en un kernel optimisé pour une exécution plus rapide.

import mlx.core as mx

def f(x):
    return mx.sum(mx.square(x))

# Gradient automatique
grad_f = mx.grad(f)
x = mx.array([1.0, 2.0, 3.0])
print(grad_f(x))  # array([2, 4, 6], dtype=float32)

# Compilation pour accélération
fast_f = mx.compile(f)
result = fast_f(x)  # Exécution optimisée

Graphe dynamique

Contrairement aux frameworks à graphe statique, MLX construit le graphe de calcul dynamiquement. Changer la taille d’un tenseur en entrée ne déclenche pas de recompilation lente. Le debug est simple : vous utilisez un debugger Python standard (pdb, breakpoints) et vous inspectez les valeurs à n’importe quel point du graphe. C’est le même paradigme que PyTorch (eager mode), mais avec les optimisations de l’évaluation paresseuse en prime.

MLX LM : exécuter des LLM sur Mac

MLX LM est le package phare de l’écosystème MLX. C’est un outil complet pour générer du texte et fine-tuner des LLM sur Apple Silicon. Il supporte des milliers de modèles disponibles sur Hugging Face.

Installation et premier chat

# Installation
pip install mlx-lm

# Lancer un chat avec un modèle (téléchargé automatiquement)
mlx_lm.chat --model mlx-community/Llama-3.2-3B-Instruct-4bit

# Générer du texte avec un modèle Mistral
mlx_lm.generate 
  --model mistralai/Mistral-7B-Instruct-v0.3 
  --prompt "Expliquez le concept de mémoire unifiée"

MLX LM télécharge et convertit automatiquement les modèles depuis Hugging Face. La communauté MLX sur Hugging Face (mlx-community) propose des centaines de modèles pré-convertis et quantifiés au format MLX.

Modèles supportés

MLX LM supporte la plupart des architectures de LLM populaires. Parmi les modèles couramment utilisés avec MLX :

Famille	Tailles	Notes MLX
Llama 3.x (Meta)	1B à 70B+	Support natif complet, très populaire en mlx-community
Mistral / Mixtral	7B à 8×7B	MoE supporté, excellent rapport qualité/vitesse
Qwen 2.5 / 3 (Alibaba)	0.5B à 72B	Incluant les variantes MoE (Qwen 30B)
Phi 3/4 (Microsoft)	3.8B à 14B	Très rapide sur Mac, idéal pour les petites configs
Gemma (Google)	2B à 27B	Support natif
DeepSeek (R1 Distill)	1.5B à 70B	Raisonnement avancé, chain-of-thought
Command-R (Cohere)	35B, 104B	Fonctionne sur Mac Pro/Studio avec 192 Go
Falcon 3 (TII)	7B à 180B	Versions quantifiées disponibles

Quantification native

MLX LM intègre la quantification en 2, 3, 4, 6, et 8 bits. Vous pouvez convertir et quantifier un modèle Hugging Face en une seule commande :

# Quantifier un modèle en 4-bit et l'uploader sur HF
mlx_lm.convert 
  --model mistralai/Mistral-7B-Instruct-v0.3 
  -q 
  --q-bits 4 
  --upload-repo mlx-community/Mon-Mistral-7B-4bit

L’espace Hugging Face mlx-my-repo permet aussi de faire cette conversion directement dans le navigateur, sans installation locale.

Fine-tuning avec LoRA et QLoRA

MLX LM supporte le fine-tuning par LoRA (Low-Rank Adaptation) et QLoRA directement sur Mac. C’est l’une des fonctionnalités les plus remarquables : fine-tuner un modèle de 7B paramètres sur un MacBook Pro avec 32 Go de mémoire unifiée prend quelques heures au lieu de nécessiter un GPU cloud.

# Fine-tuning LoRA d'un modèle Llama 3
mlx_lm.lora 
  --model mlx-community/Llama-3.2-3B-Instruct-4bit 
  --train 
  --data ./training_data 
  --iters 1000 
  --batch-size 4 
  --lora-rank 8

MLX LM supporte aussi le fine-tuning distribué via mx.distributed, permettant de répartir la charge sur plusieurs Mac connectés en Thunderbolt.

Inférence distribuée

Pour les modèles qui ne tiennent pas dans la mémoire d’un seul Mac, MLX permet de distribuer l’inférence sur plusieurs machines connectées via Thunderbolt ou Ethernet. Le LLM est découpé en tranches (tensor parallelism), chaque Mac gérant une partie du modèle. Avec Thunderbolt 4 (40 Gb/s) ou Thunderbolt 5 (80 Gb/s sur les Mac M5), la bande passante inter-nœuds est suffisante pour une inférence fluide.

Cluster Mac pour gros modèles Deux Mac Studio M2 Ultra (192 Go chacun) connectés en Thunderbolt peuvent exécuter un modèle de ~350 Go en inférence distribuée. Avec des Mac M5 Max/Ultra et Thunderbolt 5, les débits inter-nœuds doublent, rendant cette approche encore plus viable pour les modèles de plus de 100 milliards de paramètres.

L’API Python en détail

API NumPy-like

L’API Python de MLX suit de très près NumPy. Si vous connaissez NumPy, vous connaissez MLX. Les noms de fonctions, les signatures, les conventions de broadcasting sont quasi identiques :

import mlx.core as mx

# Création de tableaux (identique à NumPy)
a = mx.zeros((3, 4))
b = mx.random.normal((3, 4))
c = mx.arange(0, 10, 0.5)

# Opérations (identiques à NumPy)
d = mx.matmul(a, b.T)
e = mx.sum(b, axis=1)
f = mx.where(b > 0, b, mx.zeros_like(b))  # ReLU

# Slicing et indexation
g = b[:, 1:3]
h = b[b > 0]

Package mlx.nn pour les réseaux de neurones

Le package mlx.nn suit les conventions de PyTorch pour la construction de réseaux de neurones :

import mlx.core as mx
import mlx.nn as nn
import mlx.optimizers as optim

class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear1 = nn.Linear(784, 256)
        self.linear2 = nn.Linear(256, 10)

    def __call__(self, x):
        x = nn.relu(self.linear1(x))
        return self.linear2(x)

model = SimpleModel()
optimizer = optim.Adam(learning_rate=1e-3)

# Entraînement
def loss_fn(model, x, y):
    return mx.mean(nn.losses.cross_entropy(model(x), y))

loss_and_grad = nn.value_and_grad(model, loss_fn)
loss, grads = loss_and_grad(model, x_batch, y_batch)
optimizer.update(model, grads)
mx.eval(model.parameters(), optimizer.state)

MLX Swift

MLX dispose aussi d’une API Swift complète, ce qui le rend directement utilisable dans les applications iOS/macOS natives. C’est un avantage unique par rapport aux autres frameworks ML : vous pouvez intégrer de l’inférence LLM directement dans une app Swift sans passer par un bridge Python.

Les exemples officiels MLX Swift incluent la génération de texte avec des LLM et VLM, le fine-tuning LoRA, et la génération d’images avec SDXL, le tout dans du code Swift natif.

Performance sur M5 et Neural Accelerators

La puce Apple M5, introduite en 2025, apporte des Neural Accelerators dédiés au sein de chaque cœur GPU. Avec macOS 26.2 (Tahoe) et MLX, ces accélérateurs offrent des gains massifs sur les multiplications matricielles, l’opération fondamentale de l’inférence LLM.

Les benchmarks publiés par Apple ML Research montrent des résultats impressionnants sur un MacBook Pro M5 avec 24 Go de mémoire unifiée comparé au M4 :

Modèle	Précision	Gain TTFT (M5 vs M4)	Gain génération
Qwen 1.7B	BF16	Significatif	Accéléré
Qwen 8B	BF16	Jusqu’à ~4× plus rapide	Accéléré
Qwen 8B	4-bit	Accéléré	Accéléré
Qwen 14B	4-bit	Accéléré	Accéléré
Qwen 30B (MoE)	4-bit	Accéléré	Accéléré
GPT-OSS 20B	MXFP4 natif	Accéléré	Accéléré
FLUX-dev 12B (image)	4-bit	~3.8× plus rapide	N/A

Prérequis M5 Neural Accelerators Pour bénéficier des Neural Accelerators du M5, vous devez utiliser macOS 26.2 (Tahoe) ou supérieur. MLX utilise les TensorOps et le framework Metal Performance Primitives introduits avec Metal 4 pour accéder à ces accélérateurs. Les puces M1 à M4 continuent de fonctionner normalement avec MLX, mais sans les gains spécifiques aux Neural Accelerators.

MLX vs. les alternatives

Critère	MLX	PyTorch (MPS)	llama.cpp (Metal)
Optimisé pour Apple Silicon	Oui (natif)	Partiel (backend MPS)	Oui (backend Metal)
Mémoire unifiée	Exploitée nativement	Partiellement	Exploitée
Entraînement / fine-tuning	Oui (LoRA, full)	Oui (complet)	Non
Inférence LLM	Oui (MLX LM)	Oui (via HF)	Oui (rapide)
Formats modèle	Safetensors (HF)	PyTorch / Safetensors	GGUF
API Swift	Oui (native)	Non	Oui (via C API)
Multi-plateforme	macOS + Linux (CUDA/CPU)	Oui (Windows, Linux, macOS)	Oui (toutes)
Quantification	2-8 bits (natif)	Via bibliothèques tierces	GGUF (2-8 bits, K-quants, I-quants)
Inférence distribuée	Oui (Thunderbolt)	Oui (NCCL, etc.)	Oui (RPC, expérimental)

Verdict : Sur Mac, MLX est le meilleur choix pour le fine-tuning et l’entraînement de modèles ML. Pour la pure inférence de LLM en chat, llama.cpp via Ollama reste souvent plus rapide grâce à ses optimisations Metal spécialisées et au format GGUF ultra-optimisé. L’idéal sur Mac est de combiner les deux : MLX LM pour le fine-tuning et l’expérimentation, Ollama/llama.cpp pour le déploiement en inférence.

L’écosystème MLX

MLX s’étend bien au-delà de l’inférence de LLM. L’écosystème comprend :

MLX LM : génération de texte et fine-tuning de LLM. MLX Whisper : transcription audio basée sur le modèle Whisper d’OpenAI, optimisée pour Apple Silicon. MLX Data : bibliothèque de chargement de données agnostique au framework (compatible PyTorch, JAX, MLX). MLX Examples : exemples officiels couvrant l’entraînement de Transformers, la génération d’images (Stable Diffusion, FLUX), la génération de musique (MusicGen), les embeddings (CLIP), les autoencoders variationnels, et plus encore. MLX Swift Examples : exemples en Swift pour la génération de texte, le fine-tuning, et la génération d’images SDXL.

La communauté MLX sur Hugging Face est très active, avec des centaines de modèles pré-convertis au format MLX prêts à l’emploi.

Installation

Sur macOS (Apple Silicon)

# Installation de base
pip install mlx

# Pour les LLM
pip install mlx-lm

# Pour la transcription audio
pip install mlx-whisper

MLX nécessite macOS 14.0 (Sonoma) minimum. Pour les Neural Accelerators du M5, macOS 26.2 (Tahoe) est requis. Python 3.10 ou supérieur est nécessaire.

Sur Linux

# Version CPU uniquement
pip install mlx[cpu]

# Avec support CUDA 12
pip install mlx[cuda12]

# Avec support CUDA 13
pip install mlx[cuda13]

MLX sur Linux : un ajout récent Le support Linux (CPU et CUDA) est un ajout récent à MLX. Il fonctionne, mais l’écosystème d’optimisations est principalement orienté Apple Silicon. Sur Linux avec GPU NVIDIA, PyTorch reste le framework le plus mature et le plus performant. L’intérêt de MLX sur Linux est surtout de permettre le développement cross-plateforme : vous développez sur Mac, vous déployez sur Linux sans réécrire le code.

Limites

La principale limite de MLX est son écosystème encore réduit comparé à PyTorch. PyTorch bénéficie de milliers de bibliothèques tierces, d’un écosystème de formation mature, et d’une communauté de développeurs bien plus large. MLX est excellent pour l’inférence et le fine-tuning de modèles existants, mais pour de l’entraînement from scratch sur des architectures personnalisées, PyTorch offre plus de flexibilité et de ressources communautaires.

La seconde limite est la dépendance à Apple Silicon. Bien que le support Linux/CUDA soit apparu, MLX brille spécifiquement sur Mac. Si votre infrastructure de production est basée sur des GPU NVIDIA dans le cloud, PyTorch ou vLLM seront plus adaptés.

La troisième est la bande passante mémoire. La mémoire unifiée d’Apple Silicon est partagée entre CPU et GPU, ce qui signifie que la bande passante mémoire est le facteur limitant pour l’inférence de gros modèles. Une RTX 4090 avec sa GDDR6X à ~1 TB/s est nettement plus rapide en bande passante pure qu’un M4 Pro à ~270 GB/s. Pour l’inférence de petits modèles (7-14B), Apple Silicon est très compétitif. Pour les gros modèles, un GPU discret haut de gamme reste plus rapide, à condition que le modèle tienne en VRAM.

Questions fréquentes sur MLX

MLX fonctionne-t-il sur Mac Intel ?

Non. MLX est conçu exclusivement pour Apple Silicon (M1 et supérieur). Les Mac Intel ne possèdent pas l’architecture mémoire unifiée qui est au cœur du design de MLX. Si vous avez un Mac Intel, utilisez PyTorch avec le backend CPU, ou passez par llama.cpp qui supporte les Mac Intel via son backend CPU (AVX2).

Quelle est la différence entre MLX et llama.cpp sur Mac ?

llama.cpp est un moteur d’inférence spécialisé qui utilise le format GGUF et des techniques de quantification avancées (K-quants, I-quants). MLX est un framework ML généraliste qui peut aussi faire de l’inférence (via MLX LM) mais qui supporte en plus l’entraînement, le fine-tuning, et la génération d’images/audio. Pour la pure inférence de LLM en chat, llama.cpp est souvent légèrement plus rapide grâce à ses optimisations Metal très ciblées. Pour tout le reste (fine-tuning, entraînement, recherche), MLX est le bon choix.

Combien de RAM faut-il pour exécuter un LLM avec MLX ?

Un modèle 7B quantifié en 4-bit nécessite environ 4 Go de mémoire. Un Mac avec 8 Go peut l’exécuter, mais avec peu de marge pour le contexte et l’OS. 16 Go permettent de travailler confortablement avec des modèles 7B-14B. 32 Go ouvrent la porte aux modèles 30B+ quantifiés. 64 Go et plus permettent de faire tourner des modèles de 70B en 4-bit ou des modèles plus petits en haute précision pour le fine-tuning.

Peut-on fine-tuner un LLM avec MLX sur un MacBook Air ?

Oui, à condition d’avoir un modèle de taille raisonnable. Un MacBook Air M3 avec 16 Go peut fine-tuner un modèle 3B-7B en QLoRA (quantifié + LoRA). Le fine-tuning sera plus lent qu’avec un GPU cloud dédié, mais il est tout à fait fonctionnel. Comptez quelques heures pour 1000 itérations de LoRA sur un modèle 7B. Pour un MacBook Air M2 avec 8 Go, cantonnez-vous aux modèles 1-3B.

MLX supporte-t-il les modèles multimodaux (vision, audio) ?

Oui. MLX LM supporte les modèles vision-language (VLM) comme LLaVA, Qwen-VL, et MiniCPM-V. MLX Whisper gère la transcription audio. Les exemples officiels incluent la génération d’images avec Stable Diffusion et FLUX, la génération de musique avec MusicGen, et les embeddings multimodaux avec CLIP. L’écosystème multimodal de MLX est en croissance constante.