Gerganov et la révolution des LLM avec Llama.cpp

Les performances des LLM post-projet llama.cpp

Rappelez-vous, c’était il n’y a pas si longtemps (mais une éternité pour le monde de l’IA). Avant 2023, exécuter de Grands Modèles Linguistiques (LLM) était soumis à de très fortes contraintes techniques.

Des modèles comme GPT-3, le premier ChatGPT, ou BLOOM de BigScience comptent des dizaines, voire des centaines de milliards de paramètres. Cela rendait leur utilisation sur CPU classique extrêmement difficile sans GPU.

Évidemment, les chiffres empiriques sont rares, car personne n’avait vraiment intérêt à tenter l’expérience, mais on estime qu’un ChatGPT de l’époque tournant sans GPU aurait été 100x plus lent.

Concernant les RAM ? Ce n’était pas mieux. GPT-3 (≈175 milliards de paramètres) occupait environ 350 Go de RAM en demi-précision (FP16)​ et jusqu’à ~700 Go en précision simple (FP32). Même si certains modèles plus petits étaient moins gourmands, on estime en pratique qu’il fallait à l’époque environ 256 Go de RAM pour espérer faire tourner la plupart des gros LLM en local.

Des techniques avaient bien évidemment été explorées à l’époque, comme le Offloading ou la quantification des modèles. Techniques plus ou moins efficaces qui avaient de gros effets secondaires sur les performances des modèles.

Alors, qu’est-ce qui a changé avec Georgi Gerganov ?

LLama.cpp : la Genèse

Avec l’engouement généré par ChatGPT pour les modèles LLM, tout le monde cherchait des méthodes pour faire tourner des modèles du niveau de GPT-3.5. C’est avec la sortie du modèle LLaMA de Meta en février 2023 qu’un développeur bulgare du nom de Georgi Gerganov a une idée.

Déjà auteur de Whisper.cpp (un portage CPU du modèle de transcription vocale d’OpenAI). Il se lance un défi audacieux en mars 2023 : faire tourner LLaMA sur un simple laptop « Pour le fun », comme le dit lui-même l’intéressé.

Il y arrive en un temps record avec une implémentation minimaliste en C/C++ pur du modèle LLaMA​. Aucune dépendance lourde n’est nécessaire et la qualité est bien au rendez-vous.

Son secret ? Une librairie de tenseurs optimisée maison (GGML). En clair, compresser le réseau de neurones pour qu’il tienne en mémoire restreinte.

C’est une approche qui tranche radicalement avec les solutions existantes de l’époque, qui sont généralement basées sur PyTorch/TensorFlow.

Mais alors, quelles sont les avancées majeures du projet Llama.cpp ?

Quantization

La Quantization consiste à réduire la précision numérique des poids du modèle tout en conservant au maximum les performances. C’est la technique la plus largement utilisée par Llama.cpp pour diminuer la mémoire nécessaire à ses calculs.

Avec cette technique, convertir un modèle LLaMA 7B de FP16 à 4 bits réduit sa taille d’environ 13 Go à plus ou moins 4 Go. Cela permet de charger de très grands modèles dans la RAM de n’importe quel ordinateur standard.

En fait, Llama.cpp est tellement efficace que des hackers ont réussi à le lancer sur un smartphone Android ou même un Raspberry Pi 4 au rythme faramineux d’un token par seconde. Un rythme certes lent, complètement impensable avant.

Pour ceux qui s’interrogent sur la dégradation de la qualité d’un LLM aussi compressé, Gerganov a découvert que le gain de perplexité (donc l’imprécision du modèle) n’augmentait que de 4 % à 4-bit et restait quasiment inchangée à 8 (Q8_0).

La Quantization est donc un apport majeur de Gerganov pour l’exécution de gros LLM sur de petites machines.

Optimisations SIMD et AVX sur CPU

L’autre grande caractéristique de LLama.cpp est l’utilisation intensive des instructions vectorielles SIMD. Gerganov a conçu le cœur de calcul pour traiter en parallèle plusieurs opérations matricielles.

En utilisant la bibliothèque sous-jacente avec des kernel optimisés écrits spécifiquement pour exploiter AVX2/AVX-512​, on transforme notre CPU en véritable mini-GPU.

Ces gains apportent concrètement jusqu’à 50 % de performances en plus sur certains types de poids. L’appui sur le multithreading est un facteur clé : Llama.cpp peut générer du texte à un rythme de l’ordre de 15–30 tokens par seconde sur un PC grand public. Avant, sur des implémentations en FP32, ce n’était que de quelques tokens par seconde dont on parlait.

Chargement en mémoire et exécution

Llama.cpp, c’est aussi des méthodes de gestion de la mémoire très astucieuse.

L’avancée la plus majeure est probablement l’utilisation de mappage mémoire (mmap) pour le chargement des modèles. Au lieu de lire entièrement le modèle et d’en faire une copie en RAM (pas pratique et chronophage), le programme mappe le fichier de poids directement dans l’espace mémoire du processus.

Deux avantages à cette méthode :

• Réduis l’empreinte RAM effective : pas de duplication inutile de données puisque la mémoire utilisée peut être partagée avec le cache disque du système
• Accélère drastiquement le load du modèle

Autre ajout intéressant : l’inférence en streaming. Llama.cpp est conçu pour générer ses tokens de réponse un par un au fur et à mesure dès qu’ils sont prêts.

Cela permet de proposer une expérience d’utilisation bien plus fluide et similaire à celle proposée par ChatGPT.

Enfin, la cerise sur le gâteau : l’exécution out-of-core pour les très gros modèles.

Par exemple : une exécution hybride CPU+GPU est possible, où une partie des couches du modèle restent en RAM (CPU) tandis que d’autres sont offload sur un GPU.

Cette technique permet de dépasser la seule VRAM du GPU en utilisant la RAM comme extension aux prix d’un petit coup sur les performances du modèle. La force de Llama.cpp est de gérer intelligemment ce basculement afin de prévenir tout dépassement de mémoire en préservant la vitesse du débit.

Gestion du cache : lean and mean

Lors de la génération de texte, les états internes du modèle sont conservés en cache. Cela veut dire que le modèle n’a pas besoin de recalculer le contexte à chaque nouveau token.

Dans les faits, cela veut dire que le coût par token diminue après le prompt initial. Une fonction indispensable pour le débit global. Combiné au fait que Llama.cpp minimise les allocations dynamiques et autres surcoûts d’exécution. Vous obtenez un code parfaitement efficace et léger pour toutes les opérations mathématiques les plus lourdes.

C++ mieux que Python

Ce qui caractérise Llama.cpp est son approche 100 % autonome.

L’ensemble du projet est écrit en C/C++ standard, sans frameworks lourds ni dépendances externes (pas de PyTorch, TensorFlow, MKL…). Ce choix offre plusieurs avantages :

• Portable et simple – N’importe qui peut cloner le repo et compiler llama.cpp en une minute. Que ce soit sur Linux, Windows, macOS ou même des choix plus exotiques (rappelez-vous les hackers et leur compilation sur Android). Pas besoin de pile Python.
• Sur mesure – Comme Gerganov a voulu contrôler chaque aspect du code bas niveau, Llama.cpp est optimisable aux petits oignons. Ce qui aurait été impossible avec des frameworks comme ONNX Runtime ou PyTorch.
• Flexible – Avec son API C++ toute légère, Llama.cpp peut être appelé depuis n’importe langage ou outil. Encore une fois, c’est bien son absence de dépendances qui rend ça possible et rend son intégration bien plus simple.

CPU VS GPU : le match

Comme vu plus haut, les avancées de Llama.cpp permettent des avancées considérables sur les performances des CPU, mais comment se débrouille-t-elle face à des déploiements sur GPU ?

Tout d’abord, il faut bien comprendre qu’un GPU moderne est un véritable cheval de course. Il apporte une accélération massive via ses milliers de cœurs parallèles et mémoire dédiée.

Un rapide test sur un modèle Mistral 7B quantifié nous apporte la réponse : un CPU desktop délivre ~14 tokens/s, alors que la même inférence sur un GPU RTX 4090 atteint ~100 tokens/s avec llama.cpp, et jusqu’à ~170 tokens/s avec TensorRT.

Le GPU est donc 7 fois plus rapide. Sa bande passante et ses unités de calcul massivement parallèles sont à mettre au crédit de ce grand fossé en termes de performances pures.

Évidemment, même si cette comparaison est intéressante pour l’exercice, il faut bien comprendre qu’elle n’est pas vraiment représentative de l’avancée énorme que représente Llama.cpp.

Avec son framework, Gerganov a ouvert la voie à toute une génération de développeurs et d’utilisateurs individuels qui pourront utiliser des LLM à la maison.

Domination chinoise et perspectives d’avenir

Cela ne vous a pas échappé, les modèles LLM chinois, DeepSeek et Qwen en particulier, ont fait énormément parler d’eux.

DeepSeek, déployé en début d’année, attendrait les performances des meilleurs modèles d’Open AI tout en étant bien moins couteux à développer. Alibaba a également fait des annonces en grande pompe pour son modèle Qwen 2.5 max, qui serait encore meilleur.

Si les promesses de performances des uns et des autres peuvent nous laisser sceptiques ou émerveillés, le cœur de ces changements dans le marché réside en réalité ailleurs.

En étant complètement open source et moins couteux, DeepSeek marche sur les traces de Llama.cpp : rendre les LLM plus accessibles.

Ces acteurs créent, en effet, un contexte où l’inférence locale devient de plus en plus praticable. Les contours d’un monde dans lequel le logiciel et le matériel convergeront sont maintenant de plus en plus palpables.

Conclusion

En combinant quantification agressive, calcul vectoriel optimisé, gestion mémoire ingénieuse et code natif sans dépendances, Georgi Gerganov et son bébé Llama.cpp ont apporté des contributions techniques décisives dans la course à l’IA.

Le projet a surtout eu effet de démocratiser grandement l’accès aux LLM et à orienter la compétition non plus sur les performances pures, mais sur l’optimisation des modèles.

Les GPU auront toujours l’avantage de la puissance brute liée à leur conception. Llama.cpp prouve néanmoins qu’avec un design intelligent, le CPU est une incroyable alternative qui dispense d’infrastructure lourde.

Les modèles récents nous laissent entrevoir un monde où optimisation et performances seront de moins en moins des questions de choix, mais bien des acquis.