# Mistral et Mixtral

{% hint style="info" %}
**Des versions plus récentes disponibles !** Découvrez [**Mistral Small 3.1**](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/mistral-small) (24B, Apache 2.0, tient sur RTX 4090) et [**Mistral Large 3**](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/mistral-large3) (675B MoE, de niveau frontier).
{% endhint %}

Exécutez les modèles Mistral et Mixtral pour une génération de texte de haute qualité.

{% 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 %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces Web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<adresse-proxy>`

## Aperçu du modèle

| Modèle              | Paramètres           | VRAM   | Spécialité             |
| ------------------- | -------------------- | ------ | ---------------------- |
| Mistral-7B          | 7B                   | 8 Go   | Usage général          |
| Mistral-7B-Instruct | 7B                   | 8 Go   | Chat/instruction       |
| Mixtral-8x7B        | 46,7B (12,9B actifs) | 24 Go  | MoE, meilleure qualité |
| Mixtral-8x22B       | 141B                 | 80 Go+ | Plus grand MoE         |

## Déploiement rapide

**Image Docker :**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime
```

**Ports :**

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

**Commande :**

```bash
pip install vllm && \
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --port 8000
```

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

## Options d'installation

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

```bash

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

# Exécuter Mistral
ollama run mistral

# Exécuter Mixtral
ollama run mixtral
```

### Utilisation de vLLM

```bash
pip install vllm

# Démarrer le serveur
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --dtype float16
```

### Utilisation de Transformers

```bash
pip install transformers accelerate
```

## Mistral-7B avec Transformers

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

model_id = "mistralai/Mistral-7B-Instruct-v0.2"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

messages = [
    {"role": "user", "content": "Expliquez l'informatique quantique en termes simples"}
]

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

outputs = model.generate(
    inputs,
    max_new_tokens=500,
    do_sample=True,
    temperature=0.7,
    top_p=0.95
)

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

## Mixtral-8x7B

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

model_id = "mistralai/Mixtral-8x7B-Instruct-v0.1"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

messages = [
    {"role": "user", "content": "Écrivez une fonction Python pour calculer les nombres de Fibonacci"}
]

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

outputs = model.generate(
    inputs,
    max_new_tokens=1000,
    do_sample=True,
    temperature=0.7
)

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

## Modèles quantifiés (moins de VRAM)

### Quantification 4 bits

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

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_quant_type="nf4"
)

model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mixtral-8x7B-Instruct-v0.1",
    quantization_config=quantization_config,
    device_map="auto"
)
```

### GGUF avec llama.cpp

```bash

# Télécharger le modèle GGUF
wget https://huggingface.co/bartowski/Mistral-7B-Instruct-v0.3-GGUF/resolve/main/Mistral-7B-Instruct-v0.3-Q4_K_M.gguf

# Exécuter avec llama.cpp
./main -m Mistral-7B-Instruct-v0.3-Q4_K_M.gguf \
    -p "Expliquez l'apprentissage automatique" \
    -n 500
```

## Serveur vLLM (Production)

```bash
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --dtype float16 \
    --max-model-len 8192 \
    --gpu-memory-utilization 0.9
```

### API compatible OpenAI

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="non-nécessaire"
)

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[
        {"role": "user", "content": "Quelle est la capitale de la France ?"}
    ],
    temperature=0.7,
    max_tokens=500
)

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

## Streaming

```python
from openai import OpenAI

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

stream = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Écrivez une histoire sur un robot"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
```

## Appel de fonction

Mistral prend en charge l'appel de fonctions :

```python
from openai import OpenAI

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtenir la météo pour un lieu",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Quel temps fait-il à Paris ?"}],
    tools=tools
)

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

## Interface Gradio

```python
import gradio as gr
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "mistralai/Mistral-7B-Instruct-v0.2"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

def chat(message, history, temperature, max_tokens):
    messages = []
    for h in history:
        messages.append({"role": "user", "content": h[0]})
        messages.append({"role": "assistant", "content": h[1]})
    messages.append({"role": "user", "content": message})

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

    outputs = model.generate(
        inputs,
        max_new_tokens=max_tokens,
        temperature=temperature,
        do_sample=True
    )

    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    # Extraire la réponse de l'assistant
    return response.split("[/INST]")[-1].strip()

demo = gr.ChatInterface(
    fn=chat,
    additional_inputs=[
        gr.Slider(0.1, 2.0, value=0.7, label="Température"),
        gr.Slider(100, 2000, value=500, step=100, label="Max Tokens")
    ],
    title="Mistral-7B Chat"
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## Comparaison des performances

### Débit (tokens/sec)

| Modèle            | RTX 3060 | RTX 3090 | RTX 4090 | A100 40GB |
| ----------------- | -------- | -------- | -------- | --------- |
| Mistral-7B FP16   | 45       | 80       | 120      | 150       |
| Mistral-7B Q4     | 70       | 110      | 160      | 200       |
| Mixtral-8x7B FP16 | -        | -        | 30       | 60        |
| Mixtral-8x7B Q4   | -        | 25       | 50       | 80        |
| Mixtral-8x22B Q4  | -        | -        | -        | 25        |

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

| Modèle        | RTX 3090 | RTX 4090 | A100  |
| ------------- | -------- | -------- | ----- |
| Mistral-7B    | 80 ms    | 50 ms    | 35 ms |
| Mixtral-8x7B  | -        | 150ms    | 90 ms |
| Mixtral-8x22B | -        | -        | 200ms |

### Longueur du contexte vs VRAM (Mistral-7B)

| Contexte | FP16  | Q8    | Q4    |
| -------- | ----- | ----- | ----- |
| 4K       | 15Go  | 9 Go  | 5Go   |
| 8K       | 18Go  | 11 Go | 7 Go  |
| 16K      | 24 Go | 15Go  | 9 Go  |
| 32K      | 36 Go | 22Go  | 14 Go |

## Exigences VRAM

| Modèle        | FP16   | 8 bits | 4 bits |
| ------------- | ------ | ------ | ------ |
| Mistral-7B    | 14 Go  | 8 Go   | 5Go    |
| Mixtral-8x7B  | 90 Go  | 45 Go  | 24 Go  |
| Mixtral-8x22B | 180 Go | 90 Go  | 48Go   |

## Cas d'utilisation

### Génération de code

```python
prompt = """
Écrire une classe Python pour un client d'API REST avec :
- Gestion de l'authentification
- Logique de réessai
- Gestion des erreurs
"""
```

### Analyse de données

```python
prompt = """
Analysez ces données et fournissez des insights :
Ventes T1 : 100 K$
Ventes T2 : 150 K$
Ventes T3 : 120 K$
Ventes T4 : 200 K$
"""
```

### Écriture créative

```python
prompt = """
Écrivez une courte histoire sur une IA qui devient consciente d'elle-même,
dans le style d'Isaac Asimov.
"""
```

## Dépannage

### Mémoire insuffisante

* Utilisez la quantification 4 bits
* Utilisez Mistral-7B au lieu de Mixtral
* Réduire max\_model\_len

### Génération lente

* Utilisez vLLM pour la production
* Activer l'attention flash
* Utiliser le parallélisme tensoriel pour multi-GPU

### Mauvaise qualité de sortie

* Ajustez la température (0.1-0.9)
* Utilisez la variante instruct
* Meilleurs prompts système

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

| GPU       | Tarif horaire | Tarif journalier | Session de 4 heures |
| --------- | ------------- | ---------------- | ------------------- |
| RTX 3060  | \~$0.03       | \~$0.70          | \~$0.12             |
| RTX 3090  | \~$0.06       | \~$1.50          | \~$0.25             |
| RTX 4090  | \~$0.10       | \~$2.30          | \~$0.40             |
| A100 40GB | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80GB | \~$0.25       | \~$6.00          | \~$1.00             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* [vLLM](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/vllm) - Service en production
* [composant Ollama](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/ollama) - Déploiement facile
* [DeepSeek-V3](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/deepseek-v3) - Meilleur modèle de raisonnement
* [Qwen2.5](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/qwen25) - Alternative multilingue