Mistral & Mixtral

Exécutez les modèles Mistral et Mixtral sur les GPU Clore.ai

Des versions plus récentes disponibles ! Découvrez Mistral Small 3.1 (24B, Apache 2.0, tient sur RTX 4090) et Mistral Large 3 (675B MoE, de niveau frontier).

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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

Visitez CLORE.AI Marketplace
Filtrer par type de GPU, VRAM et prix
Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)
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
Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC
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

8 Go

Usage général

Mistral-7B-Instruct

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 :

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:

Aller à la Mes commandes page
Cliquez sur votre commande
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)


# 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

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

pip install transformers accelerate

Mistral-7B avec Transformers

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

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

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


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

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

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

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 :

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

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

120

150

Mistral-7B Q4

110

160

200

Mixtral-8x7B FP16

Mixtral-8x7B Q4

Mixtral-8x22B Q4

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

15Go

9 Go

5Go

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

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

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

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 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 - Service en production
composant Ollama - Déploiement facile
DeepSeek-V3 - Meilleur modèle de raisonnement
Qwen2.5 - Alternative multilingue

PrécédentLlama 3.3 70B SuivantDeepSeek Coder

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagLocation sur CLORE.AI

hashtagAccédez à votre serveur

hashtagAperçu du modèle

hashtagDéploiement rapide

hashtagAccéder à votre service

hashtagOptions d'installation

hashtagUtilisation d'Ollama (le plus simple)

hashtagUtilisation de vLLM

hashtagUtilisation de Transformers

hashtagMistral-7B avec Transformers

hashtagMixtral-8x7B

hashtagModèles quantifiés (moins de VRAM)

hashtagQuantification 4 bits

hashtagGGUF avec llama.cpp

hashtagServeur vLLM (Production)

hashtagAPI compatible OpenAI

hashtagStreaming

hashtagAppel de fonction

hashtagInterface Gradio

hashtagComparaison des performances

hashtagDébit (tokens/sec)

hashtagTemps jusqu'au premier token (TTFT)

hashtagLongueur du contexte vs VRAM (Mistral-7B)

hashtagExigences VRAM

hashtagCas d'utilisation

hashtagGénération de code

hashtagAnalyse de données

hashtagÉcriture créative

hashtagDépannage

hashtagMémoire insuffisante

hashtagGénération lente

hashtagMauvaise qualité de sortie

hashtagEstimation des coûts

hashtagProchaines étapes

Location sur CLORE.AI

Accédez à votre serveur

Aperçu du modèle

Déploiement rapide

Accéder à votre service

Options d'installation

Utilisation d'Ollama (le plus simple)

Utilisation de vLLM

Utilisation de Transformers

Mistral-7B avec Transformers

Mixtral-8x7B

Modèles quantifiés (moins de VRAM)

Quantification 4 bits

GGUF avec llama.cpp

Serveur vLLM (Production)

API compatible OpenAI

Streaming

Appel de fonction

Interface Gradio

Comparaison des performances

Débit (tokens/sec)

Temps jusqu'au premier token (TTFT)

Longueur du contexte vs VRAM (Mistral-7B)

Exigences VRAM

Cas d'utilisation

Génération de code

Analyse de données

Écriture créative

Dépannage

Mémoire insuffisante

Génération lente

Mauvaise qualité de sortie

Estimation des coûts

Prochaines étapes