◆ IA Locale — Ton ChatGPT privé et gratuit, sur ta machine, en 1 h · 24 € · ou tous les kits 49 € →

#LFM2 de Liquid AI : pourquoi un modèle pensé pour le CPU

Liquid AI est une société issue du MIT (CSAIL), fondée en 2023 autour des « liquid neural networks » et des modèles à état continu. Après une première génération LFM1 fermée, l'entreprise a publié en juillet 2025 les poids de LFM2, sa deuxième génération, en trois tailles : 350M, 700M et 1,2B de paramètres. D'autres variantes ont suivi (2,6B, une version MoE 8B-A1B, des modèles vision et audio, puis la génération LFM2.5). Le fil conducteur ne change pas : ces modèles visent l'exécution sur l'appareil, c'est-à-dire un téléphone, un portable sans carte graphique, un mini-PC ou une carte embarquée.

La quasi-totalité des petits modèles ouverts que vous connaissez (Qwen3, Gemma 3, Llama 3.2, SmolLM) sont des transformers classiques : chaque couche fait de l'attention sur tout le contexte. Ça marche très bien sur GPU, mais sur CPU chaque token généré doit relire un cache clé-valeur (KV cache) qui grossit avec la conversation, et le prefill d'un long prompt coûte cher. LFM2 attaque précisément ces deux points en remplaçant la majorité des couches d'attention par des blocs de convolution courte, beaucoup moins gourmands en mémoire et en bande passante.

Cible: Inférence sur l'appareil : CPU x86 ou ARM, NPU, GPU intégré. Le GPU dédié n'est pas le terrain de jeu principal, même s'il fonctionne.
Promesse chiffrée: Liquid AI annonce un décodage et un prefill jusqu'à 2 fois plus rapides que Qwen3 à taille comparable sur CPU (mesures publiées sur un AMD Ryzen AI 9 HX 370 et un Samsung Galaxy S24 Ultra).
Qualité: À paramètres égaux, LFM2 se place au niveau ou un peu au-dessus des transformers concurrents sur les benchmarks de connaissances, d'instructions et de maths ; le 1,2B rivalise avec Qwen3-1,7B sur MMLU et IFEval.
Licence: LFM Open License v1.0 : usage commercial libre en dessous d'un seuil de chiffre d'affaires annuel (10 millions de dollars), au-delà il faut contacter Liquid AI. Ce n'est pas de l'Apache 2.0, relisez le texte avant un déploiement en entreprise.

#Ce que change l'architecture hybride LFM

Le kit IA Locale

Ton ChatGPT privé et gratuit sur ta machine en 1 heure — LM Studio, Ollama, Open WebUI, tes documents, sans cloud.

Espace en ligne à vie
PDF + fichiers
Remboursé 30 j

Le kit IA Locale →ou tous les kits à vie — 49 € →

LFM2 empile 16 blocs. Dix sont des blocs de convolution courte à double porte (double-gated short-range convolution), six sont des blocs d'attention à requêtes groupées (grouped query attention, GQA) comme dans un transformer moderne. Liquid AI décrit ces blocs de convolution comme des opérateurs LIV (linear input-varying) : les poids appliqués à chaque position dépendent de l'entrée, ce qui donne au bloc une forme de sélectivité proche de celle des modèles à espace d'états (Mamba) ou des RNN modernes, sans leur état récurrent complexe.

Concrètement, un bloc de convolution ne regarde que quelques tokens voisins. Son coût par token est constant, quel que soit le contexte déjà produit, et il n'a rien à stocker dans un KV cache. Seuls les six blocs d'attention conservent un cache, contre 28 ou 36 couches dans un transformer de taille comparable. Deux conséquences directes sur CPU :

Décodage plus rapide: Générer un token consiste surtout à relire les poids et le KV cache depuis la RAM. Avec moins de cache à relire, la bande passante mémoire, qui est le vrai goulot d'étranglement d'un CPU, est mieux utilisée.
Prefill efficace: Ingérer un prompt de 4 000 tokens (un document pour du RAG, un historique de chat) coûte proportionnellement moins que sur un transformer complet, car dix blocs sur seize travaillent en fenêtre locale.
Mémoire stable: La consommation grimpe lentement avec le contexte : le KV cache de six couches reste petit, ce qui compte sur un téléphone ou une carte à 4 ou 8 Go de RAM partagée.
Contexte natif 32k: LFM2 a été entraîné avec une fenêtre de 32 768 tokens (128k sur certaines variantes plus récentes), assez pour du résumé et du RAG légers.

Côté entraînement, Liquid AI a utilisé environ 10 000 milliards de tokens pour la première génération LFM2, avec un mélange dominé par l'anglais, environ 20 % de données multilingues (dont le français, l'allemand, l'espagnol, l'arabe, le chinois, le japonais et le coréen) et un peu de code, plus une distillation depuis le LFM1-7B interne. C'est pour cela qu'un LFM2-1,2B tient une conversation en français correcte, ce qui n'est pas acquis pour tous les modèles de cette taille.

Hybride, pas révolution

LFM2 n'abandonne pas l'attention : les six blocs GQA gardent la capacité à relier deux passages éloignés du contexte. C'est le même compromis que Jamba (Mamba + attention) ou les récents modèles Granite 4 d'IBM, appliqué à des tailles beaucoup plus petites. La différence se joue sur le ratio et sur l'opérateur de convolution choisi.

#La famille LFM2 : tailles et variantes

Toutes les variantes partagent la même architecture de base et le même format de chat (balises im_start/im_end à la ChatML). Voici celles qui comptent pour un usage edge, avec le poids approximatif du fichier GGUF en Q4_K_M, ce qui correspond à peu près à la RAM occupée par les poids sur CPU.

LFM2-350M: Environ 250 Mo en Q4. Classification, extraction, réécriture courte. Tourne sur presque n'importe quoi, y compris un Raspberry Pi ou un vieux portable.
LFM2-700M: Environ 450 Mo en Q4. Le bon compromis pour un téléphone récent ou un assistant très léger.
LFM2-1.2B: Environ 730 Mo en Q4. Le modèle de référence de la famille : chat, résumé, RAG simple, appels d'outils. C'est celui que ce guide installe.
LFM2-2.6B: Environ 1,5 Go en Q4. Sorti fin 2025, nettement plus solide en raisonnement et en multilingue, encore très à l'aise sur un portable sans GPU.
LFM2-8B-A1B: Mixture of Experts : 8,3B de paramètres au total, environ 1,5B actifs par token. Autour de 5 Go en Q4 : il faut la RAM d'un 8B, mais la vitesse reste celle d'un petit modèle.
Variantes spécialisées: LFM2-VL (vision, 450M et 1,6B), LFM2-Audio, et des déclinaisons fine-tunées pour l'extraction de données, le RAG ou les appels d'outils. La génération LFM2.5 (à partir de janvier 2026) reprend l'architecture avec un entraînement prolongé ; le catalogue du site recense ses fiches, dont les 2,6B et 7B.

→

Quel modèle choisir ?

Sur un portable ou mini-PC avec 8 Go de RAM : commencez par le 1,2B, montez au 2,6B si la qualité ne suffit pas. Sur 16 Go : le 8B-A1B est le plus capable tout en restant rapide. Sur téléphone ou Raspberry Pi : 350M ou 700M.

#Prérequis

Rien d'exotique. Le point important est d'avoir une version récente du moteur d'inférence : le support de l'architecture LFM2 a été ajouté à llama.cpp en juillet 2025 et à Hugging Face Transformers dans la version 4.54. Les versions d'Ollama et de LM Studio publiées depuis reprennent ce support, à condition de les mettre à jour.

Machine: N'importe quel PC ou Mac récent. Un CPU 4 cœurs et 8 Go de RAM suffisent pour le 1,2B ; comptez 16 Go pour le 8B-A1B.
Ollama à jour: Ollama écoute par défaut sur http://localhost:11434. Mettez-le à jour avant de tirer le modèle : une version antérieure à l'été 2025 refusera le GGUF avec une erreur d'architecture inconnue.
Ou llama.cpp: Un binaire récent (compilé ou téléchargé depuis les releases GitHub) donne accès à llama-cli, llama-server et surtout llama-bench pour mesurer la vitesse.
Python facultatif: Pour utiliser les poids originaux (non quantifiés) avec Transformers ≥ 4.54, par exemple pour du fine-tuning ou un export vers un SDK mobile.

#Installer et tester LFM2 en local

Liquid AI publie ses modèles sur Hugging Face sous l'organisation LiquidAI, avec pour chaque taille un dépôt de poids originaux (LiquidAI/LFM2-1.2B) et un dépôt GGUF déjà quantifié (LiquidAI/LFM2-1.2B-GGUF). Le chemin le plus simple consiste à tirer directement ce GGUF dans Ollama, sans passer par un Modelfile.

01
Mettre Ollama à jour
Sur Linux, relancez le script d'installation officiel ; sur macOS et Windows, l'application se met à jour d'elle-même ou via son menu. Vérifiez avec ollama --version.
02
Tirer le GGUF depuis Hugging Face
La syntaxe hf.co/organisation/dépôt:quantification fonctionne avec n'importe quel dépôt GGUF public. Pour LFM2-1.2B en Q4_K_M, le téléchargement pèse environ 730 Mo.
03
Lancer un premier chat
ollama run ouvre une session interactive. Posez une question en français pour vérifier la qualité de la langue avant de creuser.
04
Forcer le CPU pour comparer
Si votre machine a un GPU, vous pouvez le désactiver pour ce modèle avec le paramètre num_gpu à 0 et observer le comportement réel en CPU pur.
05
Brancher une interface
Le modèle apparaît aussitôt dans Open WebUI, LM Studio ou tout client compatible OpenAI pointé sur le port 11434.

Terminal — Ollama

# Vérifier la version (doit être récente, été 2025 ou plus)
ollama --version

# Tirer LFM2-1.2B quantifié en Q4_K_M depuis Hugging Face
ollama pull hf.co/LiquidAI/LFM2-1.2B-GGUF:Q4_K_M

# Premier chat
ollama run hf.co/LiquidAI/LFM2-1.2B-GGUF:Q4_K_M

# Même chose en CPU pur, même si un GPU est présent
ollama run hf.co/LiquidAI/LFM2-1.2B-GGUF:Q4_K_M
>>> /set parameter num_gpu 0
>>> Résume en trois phrases ce qu'est un modèle de langage.

Le nom hf.co/LiquidAI/LFM2-1.2B-GGUF:Q4_K_M est long à taper ; créez un alias local avec ollama cp pour obtenir un simple lfm2:1.2b. Pour les autres tailles, remplacez 1.2B par 350M, 700M ou 2.6B, et pour le MoE utilisez le dépôt LiquidAI/LFM2-8B-A1B-GGUF.

Terminal — alias et API

# Alias court
ollama cp hf.co/LiquidAI/LFM2-1.2B-GGUF:Q4_K_M lfm2:1.2b

# Appel API (compatible avec n'importe quel client Ollama)
curl http://localhost:11434/api/chat -d '{
  "model": "lfm2:1.2b",
  "messages": [{"role": "user", "content": "Explique la différence entre RAM et VRAM en deux phrases."}],
  "options": {"temperature": 0.3, "min_p": 0.15, "repeat_penalty": 1.05},
  "stream": false
}'

→

Les réglages recommandés par Liquid AI

La fiche officielle conseille temperature 0.3, min_p 0.15 et repetition_penalty 1.05. Avec les valeurs par défaut d'Ollama (temperature 0.8), un modèle de 1,2B part plus facilement en boucle ou en hors-sujet. Fixez ces trois paramètres dans un Modelfile si vous utilisez LFM2 en production.

Si vous préférez llama.cpp directement, la commande llama-cli accepte le même dépôt Hugging Face avec l'option -hf. C'est aussi la voie à privilégier pour un serveur minimaliste sur une carte ARM, où llama-server tourne avec une empreinte plus faible qu'Ollama.

Terminal — llama.cpp

# Chat interactif, téléchargement automatique du GGUF
llama-cli -hf LiquidAI/LFM2-1.2B-GGUF:Q4_K_M -cnv \
  --temp 0.3 --min-p 0.15 --repeat-penalty 1.05 -t 8

# Serveur API OpenAI-compatible sur le port 8080
llama-server -hf LiquidAI/LFM2-1.2B-GGUF:Q4_K_M -c 8192 -t 8

Enfin, pour un script Python avec les poids originaux en bfloat16, Transformers suffit. Comptez environ 2,5 Go de RAM pour le 1,2B en bf16 ; sur CPU, ce chemin est bien plus lent que llama.cpp et ne sert qu'au développement.

Python — Transformers ≥ 4.54

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "LiquidAI/LFM2-1.2B"
tok = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype="bfloat16")

messages = [{"role": "user", "content": "Qu'est-ce qu'un modèle hybride convolution + attention ?"}]
inputs = tok.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt")
out = model.generate(inputs, max_new_tokens=200, do_sample=True, temperature=0.3, min_p=0.15, repetition_penalty=1.05)
print(tok.decode(out[0][inputs.shape[1]:], skip_special_tokens=True))

#Vitesse sur CPU pur : les chiffres réels

Sur CPU, deux nombres comptent : la vitesse de prefill (tokens du prompt traités par seconde, ce qui détermine le temps avant le premier mot) et la vitesse de génération (tokens produits par seconde). Le bon outil pour les mesurer proprement est llama-bench, livré avec llama.cpp : il isole les deux phases et répète les mesures. Forcez le CPU avec -ngl 0 même si un GPU est présent.

Terminal — mesurer

# Télécharger le GGUF une fois (llama-cli -hf le met en cache) puis :
llama-bench -m ~/.cache/llama.cpp/LiquidAI_LFM2-1.2B-GGUF_LFM2-1.2B-Q4_K_M.gguf \
  -ngl 0 -t 8 -p 512 -n 128

# Sortie : une ligne pp512 (prefill) et une ligne tg128 (génération), en tokens/s

# Comparer avec un transformer de taille voisine
llama-bench -m ~/.cache/llama.cpp/Qwen_Qwen3-1.7B-GGUF_Qwen3-1.7B-Q4_K_M.gguf -ngl 0 -t 8 -p 512 -n 128

Les ordres de grandeur ci-dessous correspondent à ce qu'on observe avec llama.cpp en Q4_K_M, tous cœurs physiques utilisés, sur des machines courantes. Ils ne remplacent pas votre propre mesure : la bande passante mémoire (DDR4 contre DDR5, nombre de canaux) fait varier le résultat du simple au double entre deux PC de même génération.

Portable récent (8 cœurs, DDR5): LFM2-1.2B : 40 à 70 tokens/s en génération, plusieurs centaines de tokens/s en prefill. Le 350M dépasse les 100 tokens/s. Le 2,6B tourne autour de 25 à 40 tokens/s.
PC de bureau 4 à 6 cœurs, DDR4: LFM2-1.2B : 20 à 35 tokens/s, largement au-dessus de la vitesse de lecture. Un Qwen3-1,7B sur la même machine tombe plutôt à 12 à 20 tokens/s.
Mac Apple Silicon (CPU seul): Comparable au portable DDR5 grâce à la mémoire unifiée ; en pratique vous laisserez Metal accélérer, mais LFM2 reste confortable même CPU seul sur un MacBook Air.
Raspberry Pi 5 (8 Go): LFM2-1.2B : 8 à 12 tokens/s ; LFM2-350M : 25 à 35 tokens/s. C'est le terrain où l'écart avec un transformer classique est le plus visible.
LFM2-8B-A1B: Sur 16 Go de RAM DDR5, comptez 30 à 50 tokens/s : seuls 1,5B de paramètres travaillent par token, mais les 5 Go de poids doivent tenir en mémoire.

Le point qui fait la différence à l'usage, c'est le prefill. Sur un transformer 1,7B, ingérer un document de 4 000 tokens sur CPU prend souvent 15 à 30 secondes avant la première réponse ; LFM2-1.2B divise ce délai d'un facteur proche de deux dans les tests publiés par Liquid AI, ce qui rend un RAG local sur CPU réellement utilisable au lieu de simplement possible.

Le nombre de threads n'est pas « tous les cœurs »

Sur un CPU hybride (Intel Core avec cœurs P et E, Apple Silicon), fixer -t au nombre total de cœurs logiques dégrade souvent la vitesse. Testez avec le nombre de cœurs performants uniquement (par exemple -t 8 sur un 8P+16E) et comparez : la différence peut atteindre 30 %.

#Pour quels usages préférer LFM2

LFM2 n'est pas un remplaçant de Qwen3-8B ou de Gemma 3 12B. Sur GPU avec de la VRAM, un transformer plus gros sera plus intelligent, point. L'intérêt de LFM2 apparaît dès que le matériel est la contrainte : pas de GPU, peu de RAM, une batterie à ménager, ou un volume de requêtes à absorber à coût constant.

Assistant sur portable sans GPU: Un chat fluide sur un ultraportable, sans ventilateur qui s'emballe. Le 1,2B ou le 2,6B répondent plus vite qu'on ne lit.
Traitement en lot sur serveur CPU: Classer des tickets, extraire des champs, réécrire des descriptions produit : des milliers de requêtes courtes par heure sur une VM sans GPU, avec le 350M ou le 700M.
RAG local léger: Prefill rapide + contexte 32k : indexer des notes ou une documentation interne et répondre sur CPU en quelques secondes.
Embarqué et domotique: Raspberry Pi, mini-PC industriel, boîtier domotique : interpréter une commande vocale transcrite, générer une réponse courte, appeler un outil.
Mobile: Liquid AI propose son SDK LEAP (Liquid Edge AI Platform) pour iOS et Android, et l'application Apollo pour tester les modèles sur téléphone. Les GGUF fonctionnent aussi dans les apps basées sur llama.cpp.
Appels d'outils: Les variantes instruct de LFM2 supportent nativement le function calling avec des balises dédiées, ce qui en fait un petit routeur d'agent économique.

À l'inverse, gardez un transformer classique quand vous avez un GPU et de la VRAM à remplir, quand la tâche demande du raisonnement long (maths, code complexe), ou quand vous dépendez d'un écosystème de fine-tunes très fourni : Qwen et Llama gardent une longueur d'avance sur ce terrain.

Et face à SmolLM3, Gemma 3 1B ou Qwen3-0.6B ?

À taille égale, LFM2 est en général un peu meilleur sur les benchmarks et nettement plus rapide sur CPU. La contrepartie est la licence LFM Open License, moins permissive qu'Apache 2.0 pour une grande entreprise, et un écosystème plus jeune : moins de fine-tunes communautaires, moins de retours d'expérience.

#Limites et dépannage

Erreur « unknown model architecture: lfm2 »: Votre moteur est trop ancien. Mettez à jour Ollama, LM Studio ou recompilez llama.cpp depuis une version d'après juillet 2025.
Réponses qui tournent en boucle: Baissez la température à 0,3 et activez min_p 0.15 et repeat_penalty 1.05, les valeurs recommandées par Liquid AI. Les petits modèles sont sensibles aux réglages par défaut.
Vitesse décevante: Vérifiez avec ollama ps que le modèle est bien entièrement chargé, réduisez le nombre de threads aux cœurs performants, et fermez les applications qui saturent la bande passante mémoire (navigateur avec des dizaines d'onglets, par exemple).
Mauvais français: Le 350M reste limité en français ; passez au 1,2B ou au 2,6B, entraînés avec une part multilingue plus exploitable.
Quantification trop agressive: Sur un modèle de 350M ou 700M, un Q4 abîme davantage la qualité que sur un 7B. Préférez Q8_0 pour les plus petites tailles : le fichier reste minuscule (moins de 800 Mo pour le 700M).
Licence en entreprise: Au-delà du seuil de chiffre d'affaires fixé par la LFM Open License, l'usage commercial nécessite un accord avec Liquid AI. Vérifiez avant de mettre en production.

#Pour aller plus loin

LFM2 prend tout son sens dans un montage sans GPU ou sur petite machine. Ces guides du site complètent celui-ci :

LLM en local sans GPU (CPU): Les modèles recommandés par quantité de RAM et les benchmarks tokens/s sur CPU, pour situer LFM2 face aux alternatives.
Importer un modèle GGUF de Hugging Face dans Ollama: Tout sur la syntaxe hf.co, les Modelfiles et les alias, utile pour figer les paramètres recommandés de LFM2.
LLM sur Raspberry Pi 5: Le cas d'usage embarqué par excellence, où la vitesse de LFM2 fait la différence.

Ce guide vous a aidé ?

Un retour, une erreur, une précision ? Faites-nous signe, ça améliore le guide pour tout le monde.

Les kits QuelLLMLe guide de référence par usage

IA Locale Copilote Local Agents Locaux RAG Local IA en Entreprise IA Sans Filtre Mac Images IA

Tous les kits à vie — 49 €

Suite logique

Premiers pas · 10 min

LFM2 de Liquid AI : l'architecture alternative pour l'edge