> 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/llama33.md).

# Llama 3.3 70B

Exécutez le modèle Llama 3.3 70B de Meta sur les GPU Clore.ai

{% hint style="info" %}
**Nouvelle version disponible !** Publié par Meta [**Llama 4**](/guides/guides_v2-fr/modeles-de-langage/llama4.md) en avril 2025 avec l'architecture MoE — Scout (17B actifs, tient sur une RTX 4090) offre une qualité similaire pour une fraction de la VRAM. Envisagez une mise à niveau.
{% endhint %}

Le modèle 70B le plus récent et le plus efficace 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 [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Pourquoi Llama 3.3 ?

* **Meilleur modèle 70B** - Égale les 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** - Utilisation commerciale gratuite

## Présentation du modèle

| Spécification          | Valeur                          |
| ---------------------- | ------------------------------- |
| Paramètres             | 70B                             |
| Longueur de 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 |

### Performances par rapport aux 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

{% hint style="warning" %}
**Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai.** Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez [bare metal](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement.
{% endhint %}

| Configuration   | VRAM   | Performances | Coût                                                      |
| --------------- | ------ | ------------ | --------------------------------------------------------- |
| Quantifié en Q4 | 40 Go  | Bon          | A100 40 Go ([bare metal](https://clore.ai/bare-metal))    |
| Quantifié en Q8 | 70GB   | Meilleur     | A100 80GB ([bare metal](https://clore.ai/bare-metal))     |
| FP16 complet    | 140 Go | Meilleur     | 2x A100 80 Go ([bare metal](https://clore.ai/bare-metal)) |

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

## 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. Accédez à **Mes commandes** la page
2. Cliquez sur votre commande
3. Trouvez le `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://YOUR_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 mode interactif
ollama run llama3.3

# Ou servir l'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 40 Go 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 la 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 utile."},
        {"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)
```

### 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": "Écrivez un scraper web Python 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 compiler
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

# Lancer 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 40 Go   | 25-30 | -     | -     |
| A100 80 Go   | 35-40 | 25-30 | -     |
| 2x A100 80GB | 50-60 | 40-45 | 30-35 |
| H100 80 Go   | 60-70 | 45-50 | 35-40 |

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

| GPU          | Q4       | FP16     |
| ------------ | -------- | -------- |
| A100 40 Go   | 0.8-1.2s | -        |
| A100 80 Go   | 0.6-0.9s | -        |
| 2x A100 80GB | 0.4-0.6s | 0.8-1.0s |

### Longueur du contexte vs VRAM

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

## Cas d’usage

### 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éez une API REST en FastAPI avec authentification utilisateur à l'aide de jetons JWT"}
]
```

### Analyse de document (long contexte)

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

messages = [
    {"role": "system", "content": "Vous êtes un analyste de documents. 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 : 'Le renard brun rapide saute par-dessus le chien paresseux'"}
]
```

### Raisonnement et analyse

```python
messages = [
    {"role": "system", "content": "Réfléchissez étape par étape. Montrez votre raisonnement."},
    {"role": "user", "content": "Un train quitte la station A à 9 h 00 à 60 mph. Un autre train quitte la station B (située à 300 miles) à 10 h 00 en se dirigeant vers la station 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 efficacement plusieurs requêtes
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

| Fonctionnalité | 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          |
| Maths          | 77.0          | 68.0          | 80.0         | 60.0          |
| Contexte       | 128K          | 128K          | 128K         | 64K           |
| Langues        | 8             | 8             | 29           | 8             |
| Licence        | Ouvrez        | Ouvrez        | Ouvrez       | Ouvrez        |

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

## Dépannage

### Mémoire insuffisante

```bash
# Utiliser 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 des tenseurs
--tensor-parallel-size 2
```

### Première réponse lente

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

### Accès à Hugging Face

```bash
# Se connecter à HF (requis pour un modèle à accès 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 | jetons/$ |
| ------------- | --------------- | ------- | -------- |
| Petit budget  | A100 40GB (Q4)  | \~$0.17 | \~530K   |
| Équilibré     | A100 80 Go (Q4) | \~$0.25 | \~500K   |
| Performances  | 2x A100 80GB    | \~$0.50 | \~360K   |
| Maximum       | H100 80 Go      | \~$0.50 | \~500K   |

## Étapes suivantes

* [Guide vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) - Déploiement en production
* [Guide Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) - Configuration locale facile
* [Configuration multi-GPU](/guides/guides_v2-fr/avance/multi-gpu-setup.md) - Passer à des modèles plus grands
* [Intégration API](/guides/guides_v2-fr/avance/api-integration.md) - Créer des applications


---

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