ONNX Runtime GPU

Inférence ML multiplateforme, accélérée par le matériel — déployez n’importe quel modèle depuis n’importe quel framework

ONNX Runtime (ORT) est le moteur d’inférence open source de Microsoft pour les modèles ONNX (Open Neural Network Exchange). Il fournit une inférence accélérée par le matériel sur les CPU, les GPU et les accélérateurs spécialisés via une API unifiée. Que votre modèle ait été entraîné dans PyTorch, TensorFlow, Scikit-learn ou XGBoost — si vous pouvez l’exporter au format ONNX, ORT peut l’exécuter plus rapidement.

GitHub : microsoft/onnxruntime — 14 k+ ⭐

---

Pourquoi ONNX Runtime ?

Fonctionnalité	ONNX Runtime	TorchScript	TensorFlow Serving
Indépendant du framework	✅	❌ PyTorch uniquement	❌ TF uniquement
Accélération GPU	✅ CUDA/TensorRT	✅	✅
Quantification INT8/FP16	✅	Partiel	Partiel
Déploiement mobile/en périphérie	✅	Limité	Limité
Fusion d’opérateurs	✅	Partiel	✅
Intégration facile	✅ Python/C++/Java	Python	Python/gRPC

Avantage clé : ONNX Runtime avec le fournisseur d’exécution CUDA offre généralement un gain de vitesse de 1,5 à 3x par rapport à l’inférence PyTorch native pour les modèles de vision par ordinateur et de NLP.

---

Fournisseurs d’exécution pris en charge

ONNX Runtime prend en charge plusieurs backends matériels (fournisseurs d’exécution) :

Fournisseur	Matériel	Cas d’utilisation
CUDAExecutionProvider	GPU NVIDIA	Inférence GPU générale
TensorrtExecutionProvider	GPU NVIDIA	Débit maximal
CPUExecutionProvider	CPU	Secours / périphérie
ROCMExecutionProvider	GPU AMD	Matériel AMD
CoreMLExecutionProvider	Apple Silicon	macOS/iOS
OpenVINOExecutionProvider	Intel	CPU/GPU Intel

---

Prérequis

• Compte Clore.ai avec location de GPU

• Connaissances de base en Python

• Un modèle entraîné (PyTorch, TensorFlow ou ONNX déjà exporté)

---

Étape 1 — Louer un GPU sur Clore.ai

1. Accédez à clore.ai → Place de marché

2. N’importe quel GPU NVIDIA fonctionne — d’une RTX 3070 pour les petits modèles à une A100 pour les grands transformeurs

3. Pour les modèles de transformeurs : RTX 4090 ou A100 recommandée

4. Pour la vision par ordinateur : Une RTX 3090 ou RTX 4090 suffit

---

Étape 2 — Déployer votre conteneur

ONNX Runtime n’a pas de conteneur officiel précompilé, mais l’image de base NVIDIA CUDA est idéale :

Image Docker :

nvcr.io/nvidia/cuda:12.8.1-cudnn-devel-ubuntu22.04

Ports :

22

Variables d'environnement :

NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility

Sinon, utilisez pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime qui inclut CUDA et un environnement Python prêt pour l’installation d’ORT.

---

Étape 3 — Installer ONNX Runtime avec prise en charge GPU

ssh root@<server-ip> -p <ssh-port>

# Mettre à jour les paquets
apt-get update && apt-get install -y \\
    python3-pip \\
    python3-dev \\
    wget \
    git \
    libgomp1

# Installer ONNX Runtime avec prise en charge CUDA
pip install onnxruntime-gpu

# Installer les paquets de support
pip install \\
    onnx \\
    numpy \
    Pillow \
    transformers \\
    torch \
    torchvision \\
    fastapi \
    uvicorn

# Vérifier l'installation
python3 << 'EOF'
import onnxruntime as ort
print(f"Version ORT : {ort.__version__}")
print(f"Fournisseurs disponibles : {ort.get_available_providers()}")
# Doit inclure : CUDAExecutionProvider, TensorrtExecutionProvider, CPUExecutionProvider
EOF

---

Étape 4 — Exporter votre modèle au format ONNX

Exportation d’un modèle PyTorch

import torch
import torch.nn as nn
import onnx

# Exemple : exporter ResNet50
model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet50', pretrained=True)
model.eval()

# Créer une entrée factice (batch=1, image RGB 224x224)
dummy_input = torch.randn(1, 3, 224, 224)

# Exporter au format ONNX
torch.onnx.export(
    model,
    dummy_input,
    "resnet50.onnx",
    export_params=True,
    opset_version=17,              # Utiliser l’opset stable le plus récent
    do_constant_folding=True,      # Optimiser les opérateurs constants
    input_names=["input"],
    output_names=["output"],
    dynamic_axes={
        "input": {0: "batch_size"},    # Batch dynamique
        "output": {0: "batch_size"}
    }
)
print("Modèle exporté avec succès !")

# Vérifier le modèle exporté
onnx_model = onnx.load("resnet50.onnx")
onnx.checker.check_model(onnx_model)
print("Le modèle ONNX est valide !")

Exportation HuggingFace Transformers

# Installer optimum pour l’export ONNX de HuggingFace
pip install optimum[exporters]

# Exporter BERT pour la classification de texte
optimum-cli export onnx \\
    --model bert-base-uncased \\
    --task text-classification \\
    ./bert_onnx/

# Exporter avec optimisation
optimum-cli export onnx \\
    --model microsoft/phi-2 \\
    --task text-generation \\
    --optimize O2 \\
    ./phi2_onnx/

Exporter avec l’optimisation ORT

from optimum.onnxruntime import ORTModelForSequenceClassification
from optimum.onnxruntime.configuration import OptimizationConfig, ORTConfig
from optimum.onnxruntime import ORTOptimizer

# Charger et optimiser
model = ORTModelForSequenceClassification.from_pretrained(
    "distilbert-base-uncased-finetuned-sst-2-english",
    export=True
)

optimizer = ORTOptimizer.from_pretrained(model)
optimization_config = OptimizationConfig(
    optimization_level=2,
    optimize_for_gpu=True,
    fp16=True
)

optimizer.optimize(
    save_dir="./distilbert_optimized",
    optimization_config=optimization_config
)

---

Étape 5 — Exécuter l’inférence avec ONNX Runtime

Inférence GPU de base

import onnxruntime as ort
import numpy as np
from PIL import Image
import torchvision.transforms as transforms

# Configurer la session avec les fournisseurs d’exécution GPU
# Les fournisseurs sont essayés dans l’ordre — CUDA d’abord, puis repli sur CPU
providers = [
    ("CUDAExecutionProvider", {
        "device_id": 0,
        "arena_extend_strategy": "kNextPowerOfTwo",
        "gpu_mem_limit": 4 * 1024 * 1024 * 1024,  # limite de 4 Go
        "cudnn_conv_algo_search": "EXHAUSTIVE",
        "do_copy_in_default_stream": True,
    }),
    "CPUExecutionProvider"
]

# Options de session pour les performances
opts = ort.SessionOptions()
opts.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
opts.intra_op_num_threads = 8
opts.execution_mode = ort.ExecutionMode.ORT_PARALLEL

# Charger le modèle
session = ort.InferenceSession(
    "resnet50.onnx",
    sess_options=opts,
    providers=providers
)

print(f"Exécution sur : {session.get_providers()}")

# Préparer l’entrée
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

img = Image.open("test_image.jpg").convert("RGB")
img_tensor = transform(img).unsqueeze(0).numpy()

# Exécuter l’inférence
outputs = session.run(None, {"input": img_tensor})
probabilities = outputs[0][0]
top5_idx = probabilities.argsort()[-5:][::-1]
print("Top 5 prédictions :", top5_idx, probabilities[top5_idx])

Inférence par lot pour le débit

import onnxruntime as ort
import numpy as np
import time

session = ort.InferenceSession(
    "resnet50.onnx",
    providers=["CUDAExecutionProvider"]
)

# Réchauffer le GPU
dummy = np.random.randn(1, 3, 224, 224).astype(np.float32)
for _ in range(10):
    session.run(None, {"input": dummy})

# Mesurer les tailles de lot
for batch_size in [1, 4, 8, 16, 32, 64]:
    inputs = np.random.randn(batch_size, 3, 224, 224).astype(np.float32)
    
    start = time.time()
    n_iter = 100
    for _ in range(n_iter):
        session.run(None, {"input": inputs})
    elapsed = time.time() - start
    
    throughput = (batch_size * n_iter) / elapsed
    latency = (elapsed / n_iter) * 1000  # ms
    
    print(f"Lot {batch_size:3d} : {throughput:7.1f} img/s, {latency:.1f} ms/lot")

---

Étape 6 — Fournisseur d’exécution TensorRT (performances maximales)

Pour les GPU NVIDIA, TensorRT EP offre des performances encore meilleures :

import onnxruntime as ort
import numpy as np

# Configuration du fournisseur d’exécution TensorRT
tensorrt_provider_options = {
    "trt_max_workspace_size": 4 * 1024 * 1024 * 1024,  # 4 Go
    "trt_fp16_enable": True,          # Activer FP16 pour une inférence plus rapide
    "trt_int8_enable": False,
    "trt_engine_cache_enable": True,   # Mettre en cache les moteurs compilés
    "trt_engine_cache_path": "/tmp/trt_cache",
    "trt_max_partition_iterations": 1000,
    "trt_min_subgraph_size": 1,
    "trt_timing_cache_enable": True,
}

providers = [
    ("TensorrtExecutionProvider", tensorrt_provider_options),
    ("CUDAExecutionProvider", {"device_id": 0}),
    "CPUExecutionProvider"
]

session = ort.InferenceSession("resnet50.onnx", providers=providers)
print("Fournisseur actif :", session.get_providers()[0])

# La première exécution compile le moteur TensorRT (peut prendre 1 à 3 minutes)
# Les exécutions suivantes utilisent le moteur en cache et sont très rapides

Compilation du moteur TensorRT se produit lors de la première inférence et peut prendre 1 à 5 minutes. Activez la mise en cache (trt_engine_cache_enable: True) afin que le moteur compilé soit réutilisé entre les sessions.

---

Étape 7 — Quantification INT8 pour une vitesse maximale

from onnxruntime.quantization import quantize_dynamic, quantize_static, QuantType
import onnxruntime as ort
import numpy as np

# Quantification dynamique INT8 (aucune donnée d’étalonnage requise)
quantize_dynamic(
    model_input="resnet50.onnx",
    model_output="resnet50_int8_dynamic.onnx",
    weight_type=QuantType.QInt8
)

# Quantification statique INT8 (nécessite des données d’étalonnage)
from onnxruntime.quantization import CalibrationDataReader

class ImageCalibrationReader(CalibrationDataReader):
    def __init__(self, data_dir, input_name="input"):
        self.data_dir = data_dir
        self.input_name = input_name
        self.images = self._load_images()
        self.idx = 0
    
    def _load_images(self):
        # Charger 100 images d’étalonnage
        import glob, torchvision.transforms as T
        from PIL import Image
        transform = T.Compose([T.Resize(256), T.CenterCrop(224), T.ToTensor()])
        images = []
        for path in glob.glob(f"{self.data_dir}/*.jpg")[:100]:
            img = Image.open(path).convert("RGB")
            images.append(transform(img).numpy())
        return images
    
    def get_next(self):
        if self.idx >= len(self.images):
            return None
        data = {self.input_name: self.images[self.idx:self.idx+1]}
        self.idx += 1
        return data

from onnxruntime.quantization import quantize_static, QuantFormat
quantize_static(
    model_input="resnet50.onnx",
    model_output="resnet50_int8_static.onnx",
    calibration_data_reader=ImageCalibrationReader("/data/calibration_images"),
    quant_format=QuantFormat.QDQ,
    weight_type=QuantType.QInt8
)

---

Étape 8 — Construire une API d’inférence

cat > /workspace/onnx_api.py << 'EOF'
from fastapi import FastAPI, File, UploadFile
from fastapi.responses import JSONResponse
import onnxruntime as ort
import numpy as np
from PIL import Image
import io
import torchvision.transforms as transforms
import json

app = FastAPI(title="API d’inférence ONNX Runtime")

# Charger le modèle au démarrage
session = ort.InferenceSession(
    "resnet50.onnx",
    providers=["CUDAExecutionProvider", "CPUExecutionProvider"]
)

# Charger les étiquettes de classes ImageNet
with open("imagenet_classes.json") as f:
    classes = json.load(f)

transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

@app.get("/health")
async def health():
    return {"status": "ok", "providers": session.get_providers()}

@app.post("/predict")
async def predict(file: UploadFile = File(...), topk: int = 5):
    image_data = await file.read()
    img = Image.open(io.BytesIO(image_data)).convert("RGB")
    tensor = transform(img).unsqueeze(0).numpy()
    
    outputs = session.run(None, {"input": tensor})[0][0]
    top_indices = outputs.argsort()[-topk:][::-1]
    
    results = [
        {"label": classes[str(i)], "score": float(outputs[i])}
        for i in top_indices
    ]
    return JSONResponse({"predictions": results})

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8080)
EOF

python3 /workspace/onnx_api.py &

# Tester l'API
curl -X POST "http://localhost:8080/predict" \\
    -H "accept: application/json" \\
    -F "file=@test_image.jpg"

---

Étape 9 — Surveiller l’utilisation du GPU

# Surveillance GPU en temps réel pendant l’inférence
watch -n 0.5 nvidia-smi

# Ou utilisez nvitop pour une meilleure interface
pip install nvitop
nvitop

---

Benchmarks de performance

Modèle	GPU	Fournisseur	Débit (inf/s)
ResNet50	RTX 4090	CUDA	~4,200
ResNet50	RTX 4090	TensorRT FP16	~8,500
BERT Base	RTX 4090	CUDA	~380
BERT Base	RTX 4090	TensorRT FP16	~720
YOLOv8n	RTX 3090	CUDA	~1,800
YOLOv8x	A100	TensorRT FP16	~920

---

Dépannage

Fournisseur CUDA non disponible

# Vérifier que CUDA ORT est installé (et non la version CPU uniquement)
pip uninstall onnxruntime
pip install onnxruntime-gpu

python3 -c "import onnxruntime as ort; print(ort.get_available_providers())"

Erreurs de compilation TensorRT

# Vérifier la compatibilité de la version TensorRT
python3 -c "import tensorrt; print(tensorrt.__version__)"

# Utiliser plutôt CUDA EP
providers = ["CUDAExecutionProvider"]  # Ignorer TensorRT EP

Erreurs de discordance de forme

# Vérifier les formes d’entrée/sortie du modèle
for input in session.get_inputs():
    print(f"Entrée : {input.name}, forme : {input.shape}, type : {input.type}")

for output in session.get_outputs():
    print(f"Sortie : {output.name}, forme : {output.shape}, type : {output.type}")

---

Avancé : pipeline multi-modèles

import onnxruntime as ort
import numpy as np

class MultiModelPipeline:
    def __init__(self):
        providers = ["CUDAExecutionProvider"]
        self.detector = ort.InferenceSession("detector.onnx", providers=providers)
        self.classifier = ort.InferenceSession("classifier.onnx", providers=providers)
    
    def run(self, image: np.ndarray) -> list:
        # Étape 1 : détection d’objets
        boxes = self.detector.run(None, {"image": image})[0]
        
        results = []
        for box in boxes:
            # Recadrer la région détectée
            crop = self._crop(image, box)
            
            # Étape 2 : classifier chaque région
            label = self.classifier.run(None, {"input": crop})[0]
            results.append({"box": box.tolist(), "label": int(label.argmax())})
        
        return results
    
    def _crop(self, image, box):
        x1, y1, x2, y2 = box.astype(int)
        return image[:, :, y1:y2, x1:x2]

pipeline = MultiModelPipeline()

---

Ressources supplémentaires

• GitHub d’ONNX Runtime

• Documentation ONNX Runtime

• Optimum de Hugging Face

• Zoo de modèles ONNX — Modèles préexportés

• Netron — visualiseur de modèles ONNX

• API Python d’ONNX Runtime

---

ONNX Runtime sur Clore.ai est le choix idéal pour les services d’inférence de production qui doivent servir des modèles issus de différents frameworks avec une efficacité GPU maximale.

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Inférence de production	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Déploiement à grande échelle	A100 80 Go	bare metal

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.