LFM2-24B-A2B

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

LFM2-24B-A2B représente une percée dans la modélisation linguistique efficace grâce à l'approche 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 ne nécessitant qu'environ 6 Go de VRAM pour l'inférence en FP16. Le modèle atteint ~350 tok/s sur RTX 4090, ce qui en fait l'un des modèles de grande taille les plus rapides disponibles.

En un coup d'œil

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

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

• Contexte: 32K jetons

• Performance: Concurrent avec des modèles denses 7B-13B

• VRAM: ~6GB FP16, ~3GB 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 le traitement séquentiel efficacement 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 avec 2B 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, aboutissant à plus de 350 tokens/seconde sur du matériel grand public.

Mémoire efficace: Avec seulement 6GB 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 Liquid AI: Développé par Liquid AI (fondée 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 linguistique efficace.

Note sur la licence: La Licence Ouverte Liquid AI permet une utilisation non commerciale gratuite. Le déploiement commercial nécessite une licence séparée de Liquid AI. Ceci est pas MIT — vérifiez les conditions de licence avant une utilisation en production.

Recommandations GPU

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

Meilleur rapport qualité-prix: RTX 4060 Ti 16GB offre d'excellentes performances par dollar. Vitesse maximale: RTX 4090 libère le plein potentiel de LFM2.

*Prix estimés du marché Clore.ai

Déployer avec vLLM

Installer vLLM

pip install vllm>=0.6.0
# ou la dernière version
pip install git+https://github.com/vllm-project/vllm.git

Configuration 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 transformeurs traditionnels"}
    ],
    max_tokens=1024,
    temperature=0.7
)

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

Déployer avec Ollama

Ollama fournit 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 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.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 (optionnel)
# 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"Prompt: {prompt[:30]}...")
        print(f"Tokens: {tokens}, Time: {duration:.2f}s, Speed: {tokens/duration:.1f} tok/s\n")
    
    avg_speed = total_tokens / total_time
    print(f"Vitesse moyenne : {avg_speed:.1f} tokens/seconde")
    return avg_speed

# Exécuter le test de vitesse
speed_test()

Quantification pour réduire la VRAM

Pour les GPU ayant 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 à ~3GB 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 8GB :

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 :

Évolutivité linéaire: Les SSM s'échelonnent linéairement avec la longueur de la séquence, tandis que les transformeurs traditionnels s'échelonnent de manière quadratique. Cela permet un traitement efficace des longs contextes.

Attention sélective: Seuls les jetons critiques déclenchent les mécanismes d'attention complets, réduisant la charge de calcul.

Efficacité mémoire: La conception avec 2B de paramètres actifs signifie que la plupart des 24B paramètres restent dormants pendant l'inférence, réduisant 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, atteignant un débit plus élevé que les mécanismes purement basés sur l'attention.

Conseils pour les utilisateurs de Clore.ai

• Orientation GPU unique: LFM2-24B-A2B est optimisé pour le déploiement sur un seul GPU. Les configurations multi-GPU n'apportent pas d'avantages significatifs.

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

• Paramètres 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 des lots pour plusieurs requêtes simultanées plutôt que d'utiliser plusieurs GPU.

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

Dépannage

Problème	Solution
ImportError : liquid_transformers	Installer : pip install git+https://github.com/LiquidAI-project/liquid-transformers.git
Démarrage lent	Pré-télécharger : huggingface-cli download liquid-ai/LFM2-24B-A2B
Erreur OutOfMemory	Utilisez la version quantifiée ou réduisez 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 de performance

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

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

Ressources

• LFM2-24B-A2B sur Hugging Face

• Entreprise Liquid AI

• Article sur l'architecture SSM

• Licences Liquid AI

• Support SSM de vLLM