# Llama 3.3 70B

{% hint style="info" %}
**Nouvelle version disponible !** Meta a publié [**Llama 4**](/guides/guides_v2-fr/modeles-de-langage/llama4.md) 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é](/guides/guides_v2-fr/modeles-de-langage/vllm.md) - Déploiement en production
* [Guide Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) - Installation locale facile
* [Configuration Multi-GPU](/guides/guides_v2-fr/avance/multi-gpu-setup.md) - Monter en charge vers des modèles plus grands
* [ ](/guides/guides_v2-fr/avance/api-integration.md) - Construire des applications


---

# Agent Instructions: 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/llama33.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.