MLC-LLM

Déploiement universel de LLM grâce à la compilation ML — exécutez n'importe quel grand modèle de langage sur n'importe quel matériel avec des performances maximales grâce à la compilation d'apprentissage automatique.

🌟 20 000+ étoiles GitHub | Maintenu par l'équipe MLC AI | Licence Apache-2.0

Qu'est-ce que MLC-LLM ?

MLC-LLM (compilation d'apprentissage automatique pour les grands modèles de langage) est un cadre universel qui permet le déploiement efficace de grands modèles de langage sur divers backends matériels. En s'appuyant sur TVM (Tensor Virtual Machine) comme backend de compilation, MLC-LLM compile directement les modèles LLM en code natif pour le matériel — obtenant des performances quasi optimales sans ingénierie spécifique au matériel.

Principales capacités

Prise en charge universelle du matériel — NVIDIA CUDA, AMD ROCm, Apple Metal, Vulkan, WebGPU
API REST compatible avec OpenAI — remplacement direct pour les flux de travail existants
Plusieurs formats de modèles — Llama, Mistral, Gemma, Phi, Qwen, Falcon, et plus encore
Quantification 4 bits / 8 bits — exécutez de grands modèles sur des GPU grand public
Interface de chat — interface Web intégrée pour des tests immédiats
Outils Python et CLI — options d'intégration flexibles

Pourquoi utiliser MLC-LLM sur Clore.ai ?

La place de marché GPU de Clore.ai vous donne accès à des GPU NVIDIA haute performance à des tarifs de location compétitifs. L'approche de compilation de MLC-LLM tire un débit maximal de chaque GPU — ce qui le rend idéal pour :

Inférence d'API de production à grande échelle
Recherche et benchmarking selon les tailles de modèles
Service rentable avec des modèles quantifiés
Déploiement de plusieurs modèles sur une seule instance GPU

Démarrage rapide sur Clore.ai

Étape 1 : Trouver un serveur GPU

Accédez à clore.ai place de marché
Filtrer les serveurs : GPU NVIDIA, minimum 8 Go de VRAM (16 Go+ recommandés pour les modèles 7B+)
Pour des performances optimales : RTX 3090, RTX 4090, A100 ou H100

Étape 2 : Déployer MLC-LLM

Remarque : MLC-LLM ne publie pas d'image Docker précompilée officielle sur Docker Hub. L'approche de déploiement recommandée consiste à utiliser une image de base NVIDIA CUDA et à installer MLC-LLM via pip. Utilisez nvidia/cuda:12.8.1-devel-ubuntu22.04 comme image de base sur Clore.ai.

Utilisez une image de base NVIDIA CUDA dans la configuration de votre commande Clore.ai :

Image Docker : nvidia/cuda:12.8.1-devel-ubuntu22.04

Mappages de ports :

Port du conteneur

Objectif

22

Accès SSH

8000

Serveur API REST

Variables d'environnement recommandées :

MLC_MODEL=HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC
MLC_HOST=0.0.0.0
MLC_PORT=8000

Script de démarrage (à exécuter après SSH) :

pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121

Étape 3 : Se connecter via SSH

ssh root@<clore-node-ip> -p <assigned-ssh-port>

Installation et configuration

Option A : Utiliser des modèles précompilés (le plus rapide)

MLC-AI maintient une bibliothèque de modèles précompilés sur Hugging Face. Aucune compilation nécessaire :

# Récupérez et exécutez un Llama 3 8B précompilé (quantifié en 4 bits)
python -m mlc_llm serve HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \\
  --host 0.0.0.0 \
  --port 8000

Option B : Compiler votre propre modèle

Pour des modèles personnalisés ou des exigences de quantification spécifiques :

# Étape 1 : Convertir les poids du modèle
python -m mlc_llm convert_weight \\
  ./path/to/model \\
  --quantization q4f16_1 \\
  --output ./compiled/model-q4f16_1

# Étape 2 : Générer la configuration du modèle
python -m mlc_llm gen_config \\
  ./path/to/model \\
  --quantization q4f16_1 \\
  --conv-template llama-3 \\
  --output ./compiled/model-q4f16_1

# Étape 3 : Compiler le modèle
python -m mlc_llm compile \\
  ./compiled/model-q4f16_1/mlc-chat-config.json \\
  --device cuda \\
  --output ./compiled/model-q4f16_1/lib.so

Temps de compilation : La compilation d'un modèle 7B prend généralement 10 à 30 minutes au premier lancement. Les artefacts compilés sont mis en cache et réutilisés lors des lancements suivants.

Exécution du serveur API

Démarrer le serveur compatible OpenAI

python -m mlc_llm serve \\
  HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \\
  --host 0.0.0.0 \
  --port 8000 \\
  --max-batch-size 4 \\
  --max-total-sequence-length 8192

Sortie de démarrage du serveur

[2024-01-01 12:00:00] INFO : Chargement du modèle depuis HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC
[2024-01-01 12:00:15] INFO : Modèle chargé avec succès
[2024-01-01 12:00:15] INFO : Démarrage du serveur sur 0.0.0.0:8000
[2024-01-01 12:00:15] INFO : API compatible OpenAI disponible à http://0.0.0.0:8000/v1

Points de terminaison API disponibles

Point de terminaison

Méthode

Description

/v1/chat/completions

POST

Complétions de chat (format OpenAI)

/v1/completions

POST

Complétions de texte

/v1/models

GET

Lister les modèles disponibles

/v1/debug/dump_event_trace

GET

Débogage des performances

Exemples d'utilisation de l'API

Complétions de chat (Python)

from openai import OpenAI

# Pointez vers votre serveur Clore.ai
client = OpenAI(
    base_url="http://<clore-node-ip>:<api-port>/v1",
    api_key="none"  # MLC-LLM ne nécessite pas d'authentification par défaut
)

response = client.chat.completions.create(
    model="Llama-3-8B-Instruct-q4f16_1-MLC",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant utile."},
        {"role": "user", "content": "Expliquez l'informatique quantique en termes simples."}
    ],
    temperature=0.7,
    max_tokens=512
)

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

Réponse en streaming

stream = client.chat.completions.create(
    model="Llama-3-8B-Instruct-q4f16_1-MLC",
    messages=[{"role": "user", "content": "Écrivez une courte histoire sur l'IA."}],
    stream=True,
    max_tokens=1024
)

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

Exemple cURL

curl http://<clore-node-ip>:<api-port>/v1/chat/completions \\
  -H "Content-Type: application/json" \
  -d '{
    "model": "Llama-3-8B-Instruct-q4f16_1-MLC",
    "messages": [
      {"role": "user", "content": "Combien font 2+2 ?"}
    ],
    "temperature": 0.7,
    "max_tokens": 100
  }'

Modèles précompilés disponibles

MLC-AI fournit des modèles compilés prêts à l'emploi sur Hugging Face :

Série Llama 3

# 8B Instruct (recommandé pour la plupart des cas d'utilisation)
HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC

# 70B Instruct (nécessite 40 Go+ de VRAM ou plusieurs GPU)
HF://mlc-ai/Llama-3-70B-Instruct-q4f16_1-MLC

Mistral / Mixtral

HF://mlc-ai/Mistral-7B-Instruct-v0.3-q4f16_1-MLC
HF://mlc-ai/Mixtral-8x7B-Instruct-v0.1-q4f16_1-MLC

Gemma

HF://mlc-ai/gemma-2b-it-q4f16_1-MLC
HF://mlc-ai/gemma-7b-it-q4f16_1-MLC

Phi

HF://mlc-ai/phi-2-q4f16_1-MLC
HF://mlc-ai/Phi-3-mini-4k-instruct-q4f16_1-MLC

Liste complète des modèles : Parcourez tous les modèles précompilés sur huggingface.co/mlc-ai

Options de quantification

MLC-LLM prend en charge plusieurs schémas de quantification. Choisissez selon votre budget VRAM :

Quantification

Bits

Qualité

VRAM (7B)

VRAM (13B)

q4f16_1

4 bits

★★★★☆

~4 Go

~7 Go

q4f32_1

4 bits (accumulation f32)

★★★★☆

~4 Go

~7 Go

q8f16_1

8 bits

★★★★★

~8 Go

~14 Go

q0f16

16 bits (sans quantification)

★★★★★

~14 Go

~26 Go

q0f32

32 bits (sans quantification)

★★★★★

~28 Go

~52 Go

Recommandation VRAM : Laissez toujours 2 à 3 Go de marge pour l'overhead CUDA et le cache KV. Un modèle 7B avec q4f16_1 nécessite environ 6 à 7 Go au total pour une charge de travail typique.

Déploiement multi-GPU

Pour les grands modèles (70B+) nécessitant plusieurs GPU :

# Activez le parallélisme de tenseurs sur 2 GPU
python -m mlc_llm serve \\
  HF://mlc-ai/Llama-3-70B-Instruct-q4f16_1-MLC \\
  --host 0.0.0.0 \
  --port 8000 \\
  --tensor-parallel-shards 2

Vérifiez la topologie du GPU avant le déploiement :

nvidia-smi topo -m  # Vérifier la connectivité NVLink/PCIe

Meilleures performances : Le multi-GPU fonctionne mieux avec des cartes connectées en NVLink (par ex. paires A100 80 Go SXM). Les GPU connectés en PCIe montreront des goulots d'étranglement sur les grands modèles.

Interface de chat Web

MLC-LLM inclut une UI Web intégrée, accessible dès que le serveur est en cours d'exécution :

# Démarrer le serveur avec l'UI Web activée
python -m mlc_llm serve \\
  HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \\
  --host 0.0.0.0 \
  --port 8000 \\
  --enable-debug  # Facultatif : active le point de terminaison de débogage

Accédez à l'UI à : http://<clore-node-ip>:<api-port>

Réglage des performances

Optimiser la taille des lots

# Augmentez la taille des lots pour un débit plus élevé (nécessite plus de VRAM)
python -m mlc_llm serve \\
  HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \\
  --host 0.0.0.0 \
  --port 8000 \\
  --max-batch-size 8 \\
  --max-total-sequence-length 16384 \\
  --prefill-chunk-size 2048

Surveiller l'utilisation du GPU

# Dans un terminal séparé
watch -n 1 nvidia-smi

# Surveillance plus détaillée
nvidia-smi dmon -s u  # Métriques d'utilisation en continu

Mesurer le débit

import time
from openai import OpenAI

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

start = time.time()
response = client.chat.completions.create(
    model="Llama-3-8B-Instruct-q4f16_1-MLC",
    messages=[{"role": "user", "content": "Comptez de 1 à 100"}],
    max_tokens=512
)
elapsed = time.time() - start

tokens = response.usage.completion_tokens
print(f"Débit : {tokens/elapsed:.1f} tokens/s")

Configuration Docker Compose

Pour un déploiement prêt pour la production sur Clore.ai utilisant une image de base NVIDIA CUDA avec MLC-LLM installé via pip :

version: '3.8'
services:
  mlc-llm :
    image: nvidia/cuda:12.8.1-devel-ubuntu22.04
    runtime: nvidia
    environment :
      - NVIDIA_VISIBLE_DEVICES=all
    ports:
      - "8000:8000"
    volumes:
      - ./models:/root/models
      - mlc-cache:/root/.cache/mlc_llm
    command: >
      bash -c "pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121 &&
      python -m mlc_llm serve
      HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC
      --host 0.0.0.0
      --port 8000
      --max-batch-size 4"
    restart: unless-stopped

volumes:
  mlc-cache :

Dépannage

Échec du téléchargement du modèle

# Vérifier la connectivité Internet
curl -I https://huggingface.co

# Télécharger manuellement avec huggingface-cli
pip install huggingface_hub
huggingface-cli download mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC

Manque de mémoire (OOM)

# Réduire la longueur du contexte
python -m mlc_llm serve MODEL \\
  --max-total-sequence-length 4096  # Réduire par rapport à la valeur par défaut

# Utiliser une quantification plus agressive
# Passer de q8f16_1 à q4f16_1

Incompatibilité de version CUDA

# Vérifier la version de CUDA
nvcc --version
nvidia-smi | grep CUDA

# Pour les serveurs CUDA 12.8, installez :
pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121

# Pour les serveurs CUDA 13.x, installez :
pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu122 mlc-ai-nightly-cu122

Piège courant : Les wheels pip de MLC-LLM sont spécifiques à la version de CUDA. Assurez-vous d'installer la bonne variante correspondant à la version CUDA de votre serveur. Consultez les wheels disponibles sur mlc.ai/wheels.

Serveur inaccessible

# Vérifier que le port est à l'écoute
ss -tlnp | grep 8000

# Vérifier le pare-feu
iptables -L -n | grep 8000

# Tester d'abord localement
curl http://localhost:8000/v1/models

Recommandations GPU Clore.ai

L'approche de compilation de MLC-LLM offre un débit quasi optimal sur chaque niveau de GPU. Choisissez en fonction de la taille du modèle et du budget :

GPU

VRAM

Prix Clore.ai

Idéal pour

Débit (Llama 3 8B Q4)

RTX 3090

24 Go

0,07–0,21 $/h

Modèles 7B–13B, service à petit budget

~85 tok/s

RTX 4090

24 Go

0,14–0,42 $/h

Modèles 7B–34B, service rapide

~140 tok/s

A100 40 Go

40 Go

bare metal

34B–70B, API de production

~110 tok/s

A100 80 Go

80 Go

bare metal

70B+, service multi-modèles

~130 tok/s

H100 SXM

80 Go

~1,04 $/h

Débit maximal, FP8

~280 tok/s

Point de départ recommandé : La RTX 3090 à 0,07 à 0,21 $/h offre le meilleur rapport performance-prix pour le service Llama 3 8B et Mistral 7B via MLC-LLM. Les noyaux compilés extraient une utilisation quasi maximale des GPU grand public.

Pour les modèles 70B (par ex. Llama 3 70B Q4) : utilisez une A100 40 Go (bare metal) ou deux RTX 3090 via le parallélisme de tenseurs.

Ressources

📦 Wheels pip : mlc.ai/wheels (installation via pip, aucune image Docker Hub disponible)
🐙 GitHub : github.com/mlc-ai/mlc-llm
📚 Documentation : llm.mlc.ai/docs
🤗 Modèles précompilés : huggingface.co/mlc-ai
💬 Discord : discord.gg/9Xpy2HGBuD

PrécédentPasserelle IA LiteLLM

SuivantPowerInfer

Mis à jour il y a 1 mois

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