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, GPU et accélérateurs spécialisés via une API unifiée. Que votre modèle ait été entraîné avec PyTorch, TensorFlow, Scikit-learn ou XGBoost — si vous pouvez l'exporter au format ONNX, ORT peut l'exécuter plus rapidement.

GitHub : microsoft/onnxruntime — 14K+ ⭐

---

Pourquoi ONNX Runtime ?

Fonctionnalité	ONNX Runtime	TorchScript	TensorFlow Serving
Agnostique au framework	✅	❌ uniquement PyTorch	❌ uniquement TF
Accélération GPU	✅ CUDA/TensorRT	✅	✅
Quantification INT8/FP16	✅	Partiel	Partiel
Déploiement mobile/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 1,5–3x d'accélération par rapport à l'inférence native PyTorch 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	Repli / 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 Python de base

• Un modèle entraîné (PyTorch, TensorFlow ou ONNX pré-exporté)

---

Étape 1 — Louez un GPU sur Clore.ai

1. Aller à clore.ai → Place de marché

2. N'importe quel GPU NVIDIA convient — de la RTX 3070 pour les petits modèles à l'A100 pour les grands transformeurs

3. Pour les modèles de type transformer : RTX 4090 ou A100 recommandés

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

---

Étape 2 — Déployez votre conteneur

ONNX Runtime n'a pas de conteneur pré-construit officiel, mais la base NVIDIA CUDA est idéale :

Image Docker :

nvcr.io/nvidia/cuda:12.2.0-cudnn8-devel-ubuntu22.04

Ports :

22

Variables d’environnement :

NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility

Alternativement, utilisez pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime qui inclut CUDA et un environnement Python prêt pour l'installation d'ORT.

---

Étape 3 — Installez ONNX Runtime avec le support 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 le support 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"ORT Version: {ort.__version__}")
print(f"Fournisseurs disponibles : {ort.get_available_providers()}")
# Devrait inclure : CUDAExecutionProvider, TensorrtExecutionProvider, CPUExecutionProvider
EOF

---

Étape 4 — Exportez votre modèle en ONNX

Exportation de 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 en ONNX
torch.onnx.export(
    model,
    dummy_input,
    "resnet50.onnx",
    export_params=True,
    opset_version=17,              # Utiliser la dernière version stable de l'opset
    do_constant_folding=True,      # Optimiser les constantes
    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 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 basique

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 4GB
        "cudnn_conv_algo_search": "EXHAUSTIVE",
        "do_copy_in_default_stream": True,
    }),
    "CPUExecutionProvider"
]

# Options de session pour la performance
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 lots pour le débit

import onnxruntime as ort
import numpy as np
import time

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

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

# Mesurer des tailles de batch
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"Batch {batch_size:3d}: {throughput:7.1f} img/sec, {latency:.1f}ms/batch")

---

Étape 6 — Fournisseur d'exécution TensorRT (performance maximale)

Pour les GPU NVIDIA, le fournisseur TensorRT 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,  # 4GB
    "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

La 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 INT8 dynamique (aucune donnée d'étalonnage requise)
quantize_dynamic(
    model_input="resnet50.onnx",
    model_output="resnet50_int8_dynamic.onnx",
    weight_type=QuantType.QInt8
)

# Quantification INT8 statique (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 labels 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 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/sec)
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é (pas 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 le fournisseur CUDA
providers = ["CUDAExecutionProvider"]  # Ignorer le fournisseur TensorRT

Erreurs de mismatch de shape

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

for output in session.get_outputs():
    print(f"Sortie : {output.name}, shape : {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 : Classer 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

• ONNX Runtime GitHub

• Documentation ONNX Runtime

• Hugging Face Optimum

• ONNX Model Zoo — Modèles pré-exportés

• Netron — Visualiseur de modèles ONNX

• API Python ONNX Runtime

---

ONNX Runtime sur Clore.ai est le choix idéal pour les services d'inférence en production qui doivent servir des modèles provenant 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 (24GB)	~$0.12/gpu/hr
Inférence en production	RTX 4090 (24GB)	~$0.70/gpu/hr
Déploiement à grande échelle	A100 80GB	~$1.20/gpu/hr

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