# Llama 4 (Scout et Maverick)

Lancement de Llama 4 par Meta en avril 2025 marque un changement fondamental vers **Mixture of Experts (MoE)** architecture. Au lieu d'activer tous les paramètres pour chaque token, Llama 4 oriente chaque token vers des sous-réseaux spécialisés « experts » — offrant des performances de pointe à une fraction du coût de calcul. Deux modèles à poids ouverts sont disponibles : **Scout** (idéal pour un seul GPU) et **Maverick** (puissance multi-GPU).

## Principales caractéristiques

* **Architecture MoE**: Seulement 17B de paramètres actifs par token (sur 109B/400B au total)
* **Fenêtres de contexte massives**: Scout prend en charge 10M de tokens, Maverick prend en charge 1M de tokens
* **Nativement multimodal**: Comprend à la fois le texte et les images dès la sortie de la boîte
* **Deux modèles**: Scout (16 experts, adapté au single-GPU) et Maverick (128 experts, multi-GPU)
* **Performances compétitives**: Scout égalise Gemma 3 27B ; Maverick rivalise avec des modèles de la classe GPT-4o
* **Poids ouverts**: Licence Llama Community (gratuite pour la plupart des usages commerciaux)

## Variantes de modèle

| Modèle       | Paramètres totaux | Paramètres actifs | Experts | Contexte | VRAM minimale (Q4) | VRAM minimale (FP16) |
| ------------ | ----------------- | ----------------- | ------- | -------- | ------------------ | -------------------- |
| **Scout**    | 109B              | 17B               | 16      | 10M      | 12Go               | 80Go                 |
| **Maverick** | 400B              | 17B               | 128     | 1M       | 48GB (multi)       | 320GB (multi)        |

## Exigences

| Composant | Scout (Q4)  | Scout (FP16) | Maverick (Q4) |
| --------- | ----------- | ------------ | ------------- |
| GPU       | 1× RTX 4090 | 1× H100      | 4× RTX 4090   |
| VRAM      | 24 Go       | 80Go         | 4×24GB        |
| RAM       | 32Go        | 64Go         | 128Go         |
| Disque    | 50GB        | 120GB        | 250Go         |
| CUDA      | 11.8+       | 12.0+        | 12.0+         |

**GPU recommandé par Clore.ai**: RTX 4090 24GB (\~0,5–2 $/jour) pour Scout — meilleur rapport qualité/prix

## Démarrage rapide avec Ollama

La façon la plus rapide de faire tourner Llama 4 :

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

# Exécuter Scout (quantifié, ~12GB VRAM)
ollama run llama4-scout

# Pour un contexte plus long (utilise plus de VRAM)
ollama run llama4-scout --ctx-size 32768
```

### Ollama en tant que serveur API

```bash
# Démarrer le serveur en arrière-plan
ollama serve &

# Télécharger le modèle
ollama pull llama4-scout

# Interroger via une API compatible OpenAI
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama4-scout",
    "messages": [{"role": "user", "content": "Expliquez l'architecture MoE en 3 phrases"}]
  }'
```

## Configuration vLLM (Production)

Pour des charges de production nécessitant un débit plus élevé :

```bash
# Installer vLLM
pip install vllm

# Servir Scout sur un seul GPU (quantifié)
vllm serve meta-llama/Llama-4-Scout-17B-16E-Instruct \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90

# Servir Scout sur 2 GPUs (contexte plus long)
vllm serve meta-llama/Llama-4-Scout-17B-16E-Instruct \
  --tensor-parallel-size 2 \
  --max-model-len 128000 \
  --gpu-memory-utilization 0.90

# Servir Maverick sur 4 GPUs
vllm serve meta-llama/Llama-4-Maverick-17B-128E-Instruct \
  --tensor-parallel-size 4 \
  --max-model-len 65536
```

### Interroger le serveur vLLM

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model="meta-llama/Llama-4-Scout-17B-16E-Instruct",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant serviable."},
        {"role": "user", "content": "Écrivez une fonction Python pour calculer les nombres de Fibonacci"}
    ],
    temperature=0.7,
    max_tokens=1024
)
print(response.choices[0].message.content)
```

## HuggingFace Transformers

```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "meta-llama/Llama-4-Scout-17B-16E-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True  # quantification 4 bits pour les GPU 24GB
)

messages = [
    {"role": "system", "content": "Vous êtes un assistant de codage utile."},
    {"role": "user", "content": "Écrivez une API REST avec FastAPI qui gère une liste de tâches (todo)"}
]

input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
output = model.generate(input_ids, max_new_tokens=2048, temperature=0.7, do_sample=True)
print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True))
```

## Démarrage rapide Docker

```bash
# Utilisation de l'image Docker vLLM
docker run --gpus all -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:latest \
  --model meta-llama/Llama-4-Scout-17B-16E-Instruct \
  --max-model-len 32768
```

## Pourquoi MoE est important sur Clore.ai

Les modèles denses traditionnels (comme Llama 3.3 70B) nécessitent une VRAM massive parce que tous les 70B paramètres sont actifs. Llama 4 Scout a 109B au total mais n'active que 17B par token — ce qui signifie :

* **Même qualité que les modèles denses de 70B+** à une fraction du coût en VRAM
* **Tient sur un seul RTX 4090** en mode quantifié
* **Contexte de 10M de tokens** — traiter des bases de code entières, des documents longs, des livres
* **Moins cher à louer** — 0,5–2 $/jour au lieu de 6–12 $/jour pour les modèles 70B

## Conseils pour les utilisateurs de Clore.ai

* **Commencez avec Scout Q4**: Meilleur rapport qualité/prix sur RTX 4090 — 0,5–2 $/jour, couvre 95 % des cas d'utilisation
* **Utilisez `--max-model-len` judicieusement**: Ne définissez pas le contexte plus haut que nécessaire — cela réserve de la VRAM. Commencez à 8192, augmentez si besoin
* **Parallélisme tensoriel pour Maverick**: Louez des machines 4× RTX 4090 pour Maverick ; utilisez `--tensor-parallel-size 4`
* **Connexion HuggingFace requise**: `huggingface-cli login` — vous devez d'abord accepter la licence Llama sur HF
* **Ollama pour tests rapides, vLLM pour production**: Ollama est plus rapide à configurer ; vLLM offre un débit plus élevé pour la mise en service d'API
* **Surveillez la mémoire GPU**: `watch nvidia-smi` — les modèles MoE peuvent provoquer des pics de VRAM sur de longues séquences

## Dépannage

| Problème                          | Solution                                                                                |
| --------------------------------- | --------------------------------------------------------------------------------------- |
| `OutOfMemoryError`                | Réduire `--max-model-len`, utilisez la quantification Q4, ou mettez à niveau le GPU     |
| Échec du téléchargement du modèle | Exécutez `huggingface-cli login` et acceptez la licence Llama 4 sur hf.co               |
| Génération lente                  | Assurez-vous que le GPU est utilisé (`nvidia-smi`); vérifiez `--gpu-memory-utilization` |
| vLLM plante au démarrage          | Réduisez la longueur du contexte ; assurez-vous que CUDA 11.8+ est installé             |
| Ollama affiche le mauvais modèle  | Exécutez `ollama list` pour vérifier ; `ollama rm` + `ollama pull` pour retélécharger   |

## Lectures complémentaires

* [Article de blog Meta Llama 4](https://llama.meta.com/)
* [Fiche modèle HuggingFace](https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E-Instruct)
* [Documentation vLLM](https://docs.vllm.ai/)
* [Bibliothèque de modèles Ollama](https://ollama.com/library/llama4-scout)