> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/lfm2-24b.md).

# 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

```bash
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

```bash
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

```python
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 :

```bash
# 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

```python
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

```dockerfile
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 :

```bash
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 :

```python
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

```bash
# 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

```bash
# 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 :

```bash
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 :

```bash
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](https://huggingface.co/liquid-ai/LFM2-24B-A2B)
* [Entreprise Liquid AI](https://liquid.ai/)
* [Article sur l’architecture SSM](https://arxiv.org/abs/2312.00752)
* [Licence Liquid AI](https://liquid.ai/licensing)
* [Prise en charge SSM de vLLM](https://docs.vllm.ai/en/latest/models/supported_models.html#liquid-ai)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/lfm2-24b.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.