LFM2-24B-A2B

Déployez LFM2-24B-A2B de Liquid AI sur Clore.ai — architecture hybride SSM+Attention avec 24B paramètres au total / 2B actifs

LFM2-24B-A2B représente une avancée majeure en modélisation de langage efficace grâce à l’architecture hybride de Liquid AI Modèle d’espace d’état + attention architecture. Avec 24 milliards de paramètres au total mais seulement 2 milliards actifs par jeton, il offre des performances impressionnantes tout en nécessitant seulement ~6 Go de VRAM pour l’inférence FP16. Le modèle atteint ~350 tok/s sur une RTX 4090, ce qui en fait l’un des grands modèles de langage les plus rapides disponibles.

En un coup d'œil

• Taille du modèle: 24 milliards au total / 2 milliards de paramètres actifs (hybride SSM+Attention)

• Licence: Licence ouverte de Liquid AI (gratuite pour un usage non commercial, licence commerciale disponible)

• Contexte: 32K jetons

• Performances: Comparable aux modèles denses 7B-13B

• VRAM: ~6 Go en FP16, ~3 Go en INT8

• Vitesse: ~350 tok/s sur RTX 4090, ~200 tok/s sur RTX 3090

Pourquoi LFM2-24B-A2B ?

Architecture révolutionnaire: LFM2-24B-A2B combine des modèles d’espace d’état (SSM) avec des mécanismes d’attention sélective. Les SSM gèrent efficacement le traitement séquentiel tandis que les couches d’attention se concentrent sur le raisonnement complexe. Cette approche hybride atteint la qualité des grands modèles avec l’efficacité des petits modèles.

Vitesse exceptionnelle: La conception à 2 milliards de paramètres actifs permet une inférence ultra-rapide. Contrairement aux modèles traditionnels où tous les paramètres s’activent, LFM2 n’engage sélectivement que les composants nécessaires, ce qui permet d’atteindre plus de 350 jetons/seconde sur du matériel grand public.

Économe en mémoire: Avec seulement 6 Go de VRAM en FP16, LFM2-24B-A2B fonctionne confortablement sur des GPU de milieu de gamme. Cela le rend idéal pour le déploiement en périphérie, les environnements de développement et les configurations de production soucieuses des coûts.

Innovation de Liquid AI: Développé par Liquid AI (fondé par des chercheurs du MIT), LFM2 représente une recherche de pointe en architecture neuronale. La conception hybride SSM+Attention pourrait être l’avenir de la modélisation de langage efficace.

Note sur la licence: La licence ouverte de Liquid AI autorise une utilisation gratuite non commerciale. Un déploiement commercial nécessite une licence distincte de Liquid AI. Ceci est pas MIT — vérifiez les conditions de licence avant toute utilisation en production.

Recommandations GPU

GPU	VRAM	Performances	Coût journalier*
RTX 3060 12 Go	12 Go	~180 tok/s	~$0.80
RTX 3070	8 Go	~220 tok/s	~$0.90
RTX 4060 Ti	16 Go	~300 tok/s	~$1.20
RTX 4090	24GB	~350 tok/s	~$2.10
RTX 3090	24GB	~200 tok/s	~$1.10
A100 40 Go	40 Go	~400 tok/s	~$3.50

Meilleur rapport qualité-prix: La RTX 4060 Ti 16 Go offre un excellent rapport performance/prix. Vitesse maximale: La RTX 4090 libère tout le potentiel de LFM2.

*Prix estimés sur la place de marché Clore.ai

Déployer avec vLLM

Installer vLLM

pip install vllm>=0.6.0
# ou la version la plus récente
pip install git+https://github.com/vllm-project/vllm.git

Configuration sur GPU unique

vllm serve liquid-ai/LFM2-24B-A2B \\
  --model liquid-ai/LFM2-24B-A2B \\
  --tensor-parallel-size 1 \\
  --dtype float16 \
  --max-model-len 32768 \
  --served-model-name lfm2-24b \\
  --trust-remote-code \\
  --disable-log-stats

Interroger le serveur

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1", 
    api_key="EMPTY"
)

response = client.chat.completions.create(
    model="lfm2-24b",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant IA utile spécialisé dans les explications techniques."},
        {"role": "user", "content": "Expliquez les différences entre les modèles d’espace d’état et les Transformers traditionnels"}
    ],
    max_tokens=1024,
    temperature=0.7
)

print(response.choices[0].message.content)

Déployer avec Ollama

Ollama offre le chemin de déploiement le plus simple :

# Installer Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Récupérer le modèle LFM2
ollama pull liquid-ai/lfm2:24b

# Exécuter en mode interactif
ollama run liquid-ai/lfm2:24b

# Mode API
ollama serve

Utilisation de l’API Ollama

import requests

# Complétion simple
response = requests.post('http://localhost:11434/api/generate',
    json={
        'model': 'liquid-ai/lfm2:24b',
        'prompt': 'Écrivez une fonction Python pour calculer les nombres de Fibonacci en utilisant la mémoïsation',
        'stream': False
    }
)

print(response.json()['response'])

# Format de chat
chat_response = requests.post('http://localhost:11434/api/chat',
    json={
        'model': 'liquid-ai/lfm2:24b',
        'messages': [
            {'role': 'user', 'content': 'Expliquez l’intrication quantique en termes simples'}
        ],
        'stream': False
    }
)

print(chat_response.json()['message']['content'])

Modèle Docker

FROM nvidia/cuda:12.8.1-devel-ubuntu22.04

# Installer Python 3.10
RUN apt-get update && apt-get install -y \
    python3.10 python3-pip curl && \\
    rm -rf /var/lib/apt/lists/*

# Installer vLLM
RUN pip install vllm>=0.6.0 transformers

# Définir l’environnement
ENV PYTHONUNBUFFERED=1

# Pré-télécharger le modèle (facultatif)
# RUN python3 -c "from transformers import AutoModel; AutoModel.from_pretrained('liquid-ai/LFM2-24B-A2B', trust_remote_code=True)"

EXPOSE 8000

CMD ["vllm", "serve", "liquid-ai/LFM2-24B-A2B", \\
     "--host", "0.0.0.0", \
     "--port", "8000", \\
     "--dtype", "float16", \\
     "--max-model-len", "16384", \\
     "--trust-remote-code"]

Construire et exécuter :

docker build -t lfm2-24b .
docker run --gpus all -p 8000:8000 lfm2-24b

Benchmark de vitesse

Testez la vitesse d’inférence exceptionnelle de LFM2 :

import time
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

def speed_test():
    prompts = [
        "Expliquez l’apprentissage automatique en un paragraphe",
        "Écrivez rapidement un algorithme de tri en Python",
        "Décrivez les avantages des énergies renouvelables",
        "Quelle est la capitale de la France et pourquoi est-elle importante ?",
        "Créez une structure de page HTML simple"
    ]
    
    total_tokens = 0
    total_time = 0
    
    for prompt in prompts:
        start_time = time.time()
        
        response = client.chat.completions.create(
            model="lfm2-24b",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=200,
            temperature=0.1
        )
        
        end_time = time.time()
        
        tokens = len(response.choices[0].message.content.split())
        duration = end_time - start_time
        
        total_tokens += tokens
        total_time += duration
        
        print(f"Invite : {prompt[:30]}...")
        print(f"Jetons : {tokens}, Temps : {duration:.2f}s, Vitesse : {tokens/duration:.1f} jetons/s\n")
    
    avg_speed = total_tokens / total_time
    print(f"Vitesse moyenne : {avg_speed:.1f} jetons/seconde")
    return avg_speed

# Exécuter le test de vitesse
speed_test()

Quantification pour réduire la VRAM

Pour les GPU disposant d’une VRAM limitée, utilisez des versions quantifiées :

Quantification GPTQ

# Installer auto-gptq
pip install auto-gptq

# Utiliser le modèle quantifié (réduit à ~3 Go de VRAM)
vllm serve liquid-ai/LFM2-24B-A2B-GPTQ \\
  --model liquid-ai/LFM2-24B-A2B-GPTQ \\
  --quantization gptq \\
  --dtype float16 \
  --max-model-len 16384

Quantification AWQ

# Installer autoawq
pip install autoawq

# Utiliser le modèle quantifié AWQ
vllm serve liquid-ai/LFM2-24B-A2B-AWQ \\
  --model liquid-ai/LFM2-24B-A2B-AWQ \\
  --quantization awq \\
  --dtype float16

Configuration avancée

Configuration optimisée pour la mémoire

Pour les GPU de 8 Go :

vllm serve liquid-ai/LFM2-24B-A2B \\
  --model liquid-ai/LFM2-24B-A2B \\
  --dtype float16 \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.85 \\
  --swap-space 4 \\
  --trust-remote-code

Configuration à haut débit

Pour les charges de production :

vllm serve liquid-ai/LFM2-24B-A2B \\
  --model liquid-ai/LFM2-24B-A2B \\
  --tensor-parallel-size 1 \\
  --max-num-seqs 32 \\
  --max-num-batched-tokens 8192 \\
  --dtype float16 \
  --trust-remote-code

Avantages de l’architecture SSM

L’hybride SSM+Attention de LFM2 offre des avantages uniques :

Mise à l’échelle linéaire: Les SSM se mettent à l’échelle linéairement avec la longueur de la séquence, alors que les Transformers traditionnels se mettent à l’échelle quadratiquement. Cela permet un traitement efficace des longs contextes.

Attention sélective: Seuls les jetons critiques déclenchent les mécanismes d’attention complets, ce qui réduit la charge de calcul.

Efficacité mémoire: La conception à 2 milliards de paramètres actifs signifie que la plupart des 24 milliards de paramètres restent inactifs pendant l’inférence, ce qui réduit drastiquement les besoins en bande passante mémoire.

Traitement séquentiel rapide: Les SSM excellent dans les tâches séquentielles comme la génération de texte, en atteignant un débit supérieur à celui des mécanismes d’attention purs.

Conseils pour les utilisateurs de Clore.ai

• Conçu pour un GPU unique: LFM2-24B-A2B est optimisé pour un déploiement sur un seul GPU. Les configurations multi-GPU n’apportent pas d’avantages significatifs.

• Longueur de contexte: Utilisez des contextes plus courts (8K-16K) pour une vitesse maximale. Les contextes plus longs réduisent l’avantage d’efficacité des SSM.

• Réglages de température: Des températures plus basses (0,1-0,3) maximisent la vitesse d’inférence en réduisant l’incertitude.

• Taille de lot: Augmentez la taille de lot pour plusieurs requêtes simultanées plutôt que d’utiliser plusieurs GPU.

• Conformité de la licence: Vérifiez les exigences de licence commerciale auprès de Liquid AI avant le déploiement en production.

Dépannage

Problème	Solution
ImportError: liquid_transformers	Installez : pip install git+https://github.com/LiquidAI-project/liquid-transformers.git
Démarrage lent	Pré-téléchargement : huggingface-cli download liquid-ai/LFM2-24B-A2B
OutOfMemoryError	Utiliser une version quantifiée ou réduire max-model-len
Réponses de mauvaise qualité	Vérifiez les restrictions de licence — certaines versions du modèle ont des capacités limitées
Erreurs de couche SSM	Mettre à jour transformers : pip install transformers>=4.45.0

Comparaison des performances

Modèle	Paramètres actifs	VRAM (FP16)	Vitesse (RTX 4090)
Llama 3.2 3B	3B	~6GB	~280 tok/s
Qwen2.5 7B	7B	~14 Go	~180 tok/s
LFM2-24B-A2B	2B	~6GB	~350 tok/s
Mistral 7B	7B	~14 Go	~200 tok/s
Phi-3.5 3.8B	3.8B	~8 Go	~250 tok/s

LFM2-24B-A2B obtient le meilleur ratio vitesse/VRAM de sa catégorie.

Ressources

• LFM2-24B-A2B sur Hugging Face

• Entreprise Liquid AI

• Article sur l’architecture SSM

• Licence Liquid AI

• Prise en charge SSM de vLLM