# Llama 3.3 70B

{% hint style="info" %}
**Nouvelle version disponible !** Meta a publié [**Llama 4**](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/llama4) en avril 2025 avec une architecture MoE — Scout (17B active, tient sur RTX 4090) offre une qualité similaire avec une fraction de la VRAM. Envisagez une mise à niveau.
{% endhint %}

Le dernier et plus efficace modèle 70B de Meta sur les GPU CLORE.AI.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Pourquoi Llama 3.3 ?

* **Meilleur modèle 70B** - Équivaut aux performances de Llama 3.1 405B pour une fraction du coût
* **Multilingue** - Prend en charge 8 langues nativement
* **Contexte 128K** - Traitement de longs documents
* **Poids ouverts** - Gratuit pour un usage commercial

## Aperçu du modèle

| Spécification          | Valeur                          |
| ---------------------- | ------------------------------- |
| Paramètres             | 70B                             |
| Longueur du contexte   | 128K tokens                     |
| Données d'entraînement | 15T+ tokens                     |
| Langues                | EN, DE, FR, IT, PT, HI, ES, TH  |
| Licence                | Licence communautaire Llama 3.3 |

### Performance vs autres modèles

| Benchmark   | Llama 3.3 70B | Llama 3.1 405B | GPT-4o |
| ----------- | ------------- | -------------- | ------ |
| MMLU        | 86.0          | 87.3           | 88.7   |
| HumanEval   | 88.4          | 89.0           | 90.2   |
| MATH        | 77.0          | 73.8           | 76.6   |
| Multilingue | 91.1          | 91.6           | -      |

## Exigences GPU

| Configuration | VRAM   | Performances | Coût                      |
| ------------- | ------ | ------------ | ------------------------- |
| Quantifié Q4  | 40Go   | Bon          | A100 40GB (\~0,17 $/h)    |
| Quantifié Q8  | 70Go   | Meilleur     | A100 80GB (\~0,25 $/h)    |
| FP16 complet  | 140 Go | Meilleur     | 2x A100 80GB (\~0,50 $/h) |

**Recommandé :** A100 40GB avec quantification Q4 pour le meilleur rapport prix/performance.

## Déploiement rapide sur CLORE.AI

### Utilisation d'Ollama (le plus simple)

**Image Docker :**

```
ollama/ollama
```

**Ports :**

```
22/tcp
11434/http
```

**Après le déploiement :**

```bash
ollama pull llama3.3
ollama run llama3.3
```

### Utilisation de vLLM (Production)

**Image Docker :**

```
vllm/vllm-openai:latest
```

**Ports :**

```
22/tcp
8000/http
```

**Commande :**

```bash
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-70B-Instruct \
    --tensor-parallel-size 1 \
    --max-model-len 32768 \
    --host 0.0.0.0
```

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://VOTRE_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

## Méthodes d'installation

### Méthode 1 : Ollama (Recommandé pour les tests)

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

# Récupérer Llama 3.3 (télécharge automatiquement la version Q4)
ollama pull llama3.3

# Exécuter en interactif
ollama run llama3.3

# Ou servir via API
ollama serve
```

**Utilisation de l'API :**

```bash
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.3",
  "prompt": "Explique l'informatique quantique en termes simples"
}'
```

### Méthode 2 : vLLM (Production)

```bash
pip install vllm

# GPU unique (A100 40GB avec quantification AWQ)
python -m vllm.entrypoints.openai.api_server \
    --model casperhansen/llama-3.3-70b-instruct-awq \
    --quantization awq \
    --max-model-len 16384 \
    --host 0.0.0.0

# Multi-GPU (2x A100 pour précision complète)
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-70B-Instruct \
    --tensor-parallel-size 2 \
    --max-model-len 32768 \
    --host 0.0.0.0
```

**Utilisation de l'API (compatible OpenAI) :**

```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-3.3-70B-Instruct",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant serviable."},
        {"role": "user", "content": "Écris une fonction Python pour calculer les nombres de Fibonacci"}
    ],
    temperature=0.7,
    max_tokens=1024
)

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

### Méthode 3 : Transformers + bitsandbytes

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

# Configuration de quantification 4 bits
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

model_id = "meta-llama/Llama-3.3-70B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto"
)

# Générer
messages = [
    {"role": "system", "content": "Vous êtes un assistant de codage utile."},
    {"role": "user", "content": "Écris un scraper web en Python en utilisant BeautifulSoup"}
]

input_ids = tokenizer.apply_chat_template(
    messages,
    return_tensors="pt"
).to("cuda")

outputs = model.generate(
    input_ids,
    max_new_tokens=512,
    temperature=0.7,
    do_sample=True
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

### Méthode 4 : llama.cpp (hybride CPU+GPU)

```bash
# Cloner et construire
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make LLAMA_CUDA=1

# Télécharger le modèle GGUF
wget https://huggingface.co/bartowski/Llama-3.3-70B-Instruct-GGUF/resolve/main/Llama-3.3-70B-Instruct-Q4_K_M.gguf

# Démarrer le serveur
./llama-server \
    -m Llama-3.3-70B-Instruct-Q4_K_M.gguf \
    -c 8192 \
    -ngl 80 \
    --host 0.0.0.0 \
    --port 8080
```

## Benchmarks

### Débit (tokens/seconde)

| GPU          | Q4    | Q8    | FP16  |
| ------------ | ----- | ----- | ----- |
| A100 40GB    | 25-30 | -     | -     |
| A100 80GB    | 35-40 | 25-30 | -     |
| 2x A100 80Go | 50-60 | 40-45 | 30-35 |
| H100 80GB    | 60-70 | 45-50 | 35-40 |

### Temps jusqu'au premier token (TTFT)

| GPU          | Q4       | FP16     |
| ------------ | -------- | -------- |
| A100 40GB    | 0,8-1,2s | -        |
| A100 80GB    | 0,6-0,9s | -        |
| 2x A100 80Go | 0,4-0,6s | 0,8-1,0s |

### Longueur du contexte vs VRAM

| Contexte | VRAM Q4 | VRAM Q8 |
| -------- | ------- | ------- |
| 4K       | 38GB    | 72Go    |
| 8K       | 40Go    | 75GB    |
| 16K      | 44GB    | 80GB    |
| 32K      | 52GB    | 90GB    |
| 64K      | 68 Go   | 110GB   |
| 128K     | 100GB   | 150Go   |

## Cas d'utilisation

### Génération de code

```python
messages = [
    {"role": "system", "content": "Vous êtes un programmeur expert. Écrivez un code propre, efficace et bien documenté."},
    {"role": "user", "content": "Crée une API REST avec FastAPI et une authentification utilisateur utilisant des tokens JWT"}
]
```

### Analyse de documents (long contexte)

```python
# Charger un long document
with open("large_document.txt") as f:
    document = f.read()

messages = [
    {"role": "system", "content": "Vous êtes un analyste de document. Fournissez une analyse détaillée et précise."},
    {"role": "user", "content": f"Analysez ce document et fournissez un résumé avec les points clés:\n\n{document}"}
]
```

### Tâches multilingues

```python
messages = [
    {"role": "system", "content": "Vous êtes un assistant multilingue."},
    {"role": "user", "content": "Traduisez ceci en allemand, français et espagnol : 'The quick brown fox jumps over the lazy dog'"}
]
```

### Raisonnement et analyse

```python
messages = [
    {"role": "system", "content": "Pensez étape par étape. Montrez votre raisonnement."},
    {"role": "user", "content": "Un train quitte la gare A à 9h00 en roulant à 60 mph. Un autre train quitte la gare B (à 300 miles) à 10h00 en direction de la gare A à 90 mph. Quand et où se rencontrent-ils ?"}
]
```

## Conseils d'optimisation

### Optimisation de la mémoire

```python
# vLLM avec optimisation de la mémoire
python -m vllm.entrypoints.openai.api_server \
    --model casperhansen/llama-3.3-70b-instruct-awq \
    --quantization awq \
    --gpu-memory-utilization 0.95 \
    --max-model-len 8192
```

### Optimisation de la vitesse

```python
# Activer Flash Attention
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-70B-Instruct \
    --tensor-parallel-size 2 \
    --enable-prefix-caching
```

### Traitement par lots

```python
# Traiter plusieurs requêtes efficacement
responses = client.chat.completions.create(
    model="meta-llama/Llama-3.3-70B-Instruct",
    messages=messages,
    n=4,  # Générer 4 réponses
    temperature=0.8
)
```

## Comparaison avec d'autres modèles

| Fonction      | Llama 3.3 70B | Llama 3.1 70B | Qwen 2.5 72B | Mixtral 8x22B |
| ------------- | ------------- | ------------- | ------------ | ------------- |
| MMLU          | 86.0          | 83.6          | 85.3         | 77.8          |
| Programmation | 88.4          | 80.5          | 85.4         | 75.5          |
| Mathématiques | 77.0          | 68.0          | 80.0         | 60.0          |
| Contexte      | 128K          | 128K          | 128K         | 64K           |
| Langues       | 8             | 8             | 29           | 8             |
| Licence       | Ouvrir        | Ouvrir        | Ouvrir       | Ouvrir        |

**Verdict :** Llama 3.3 70B offre les meilleures performances globales de sa catégorie, en particulier pour les tâches de programmation et de raisonnement.

## Dépannage

### Mémoire insuffisante

```bash
# Utilisez la quantification AWQ (la plus économe en mémoire)
--model casperhansen/llama-3.3-70b-instruct-awq --quantization awq

# Réduire la longueur du contexte
--max-model-len 8192

# Utiliser le parallélisme tensoriel
--tensor-parallel-size 2
```

### Première réponse lente

* La première requête charge le modèle sur le GPU - attendre 30-60 secondes
* Utilisez `--enable-prefix-caching` pour des requêtes ultérieures plus rapides
* Pré-chauffer avec une requête factice

### Accès Hugging Face

```bash
# Connexion à HF (requise pour le modèle restreint)
huggingface-cli login

# Ou définir une variable d'environnement
export HUGGING_FACE_HUB_TOKEN=hf_xxxxx
```

## Estimation des coûts

| Configuration | GPU            | $/heure | tokens/$ |
| ------------- | -------------- | ------- | -------- |
| Économique    | A100 40GB (Q4) | \~$0.17 | \~530K   |
| Équilibré     | A100 80GB (Q4) | \~$0.25 | \~500K   |
| Performances  | 2x A100 80Go   | \~$0.50 | \~360K   |
| Maximum       | H100 80GB      | \~$0.50 | \~500K   |

## Prochaines étapes

* [- Débit le plus élevé](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/vllm) - Déploiement en production
* [Guide Ollama](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/ollama) - Installation locale facile
* [Configuration Multi-GPU](https://docs.clore.ai/guides/guides_v2-fr/avance/multi-gpu-setup) - Monter en charge vers des modèles plus grands
* [ ](https://docs.clore.ai/guides/guides_v2-fr/avance/api-integration) - Construire des applications