> 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

> 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

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

### Configuration 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 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 :

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

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

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

```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 8GB :

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

**É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](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)
* [Licences Liquid AI](https://liquid.ai/licensing)
* [Support 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:

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

The question should be specific, self-contained, and written in natural language.
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.