# ONNX Runtime GPU : Pourquoi faut‑il le compiler soi‑même ? Avant de plonger dans le processus de compilation, clarifions quelques concepts. ## **Qu’est‑ce que onnxruntime_gpu ?** {#sec-9ff1a09e9e89} **ONNX Runtime (ORT)** est un moteur d’inférence AI optimisé. Après avoir converti un modèle créé avec PyTorch ou TensorFlow au format `.onnx`, il permet de l’exécuter sur divers matériels le plus rapidement possible. La version `onnxruntime_gpu` exploite **CUDA** et **cuDNN** des GPU NVIDIA pour maximiser les performances. ![image of onnxruntime](/media/whitedec/blog_img/35245efd929e4132a695bf5bd2ad1d45.webp) ## Pourquoi est‑elle si souvent utilisée avec les modèles génératifs (image/vidéo) ? {#sec-5c0018e3e915} Des modèles comme Stable Diffusion ou Whisper sont massifs et très coûteux en calcul. ORT propose les optimisations suivantes : * **Graph Optimization :** réduction des opérations inutiles et fusion de plusieurs opérations (Operator Fusion). * **Memory Management :** gestion efficace de la mémoire GPU, même pour les modèles volumineux. * **Hardware Acceleration :** combinaison avec des accélérateurs comme TensorRT, offrant plusieurs fois la vitesse d’un exécution pure PyTorch. ## Pourquoi les utilisateurs aarch64 (ARM) doivent‑ils compiler à partir des sources ? {#sec-665d2400b756} Normalement, `pip install onnxruntime-gpu` suffit, mais ce n’est pas le cas pour **aarch64**. 1. **Absence de binaire :** les roues officielles sur PyPI sont principalement destinées à x86_64. 2. **Support des nouvelles architectures :** des spécifications récentes comme **CUDA 13.0** ou **Compute Capability 12.1 (Blackwell)** ne sont souvent pas prises en charge par les versions officielles. 3. **Optimisation maximale :** pour adapter les options de compilation aux particularités d’une machine (ex. : DGX Spark), la compilation manuelle est indispensable. --- ## Compiler ONNX Runtime GPU sur DGX‑Spark (aarch64) {#sec-556ead64bd44} Voici le processus que j’ai suivi, basé sur mon expérience. ### 1. Vérification de l’environnement (Environment Check) {#sec-dbf99788fe3f} Commencez par identifier les spécifications de votre système. J’utilise un DGX‑Spark avec GPU Grace‑Blackwell. | Élément | Valeur | | --- | --- | | **OS/Arch** | Linux aarch64 | | **GPU** | NVIDIA GB10 (Blackwell) | | **CUDA** | 13.0 (V13.0.88) | | **Python** | 3.12.3 | | **Compute Cap** | 12.1 | ```bash # Vérifier les informations du GPU nvidia-smi # Vérifier la version de CUDA nvcc --version ``` ### 2. Installer cuDNN manquant {#sec-6aab9c2c470c} Comme `cuDNN` n’était pas présent, je l’ai installé via `pip` sous forme de bibliothèque Python, puis j’ai récupéré son chemin. ```bash # Installer cuDNN pour CUDA 13 pip install nvidia-cudnn-cu13 # Afficher le chemin d’installation (script Python) python3 -c "import site, os; print(os.path.join(site.getsitepackages()[0], 'nvidia/cudnn'))" ``` Ensuite, définissez les variables d’environnement afin que le script de compilation trouve cuDNN. ```bash export CUDA_HOME=/usr/local/cuda export CUDNN_HOME=/home/jesse/onnxruntime/venv/lib/python3.12/site-packages/nvidia/cudnn export PATH=$CUDA_HOME/bin:$PATH export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$CUDNN_HOME/lib:$LD_LIBRARY_PATH export CUDACXX=$CUDA_HOME/bin/nvcc ``` ### 3. Compiler les sources d’ONNX Runtime {#sec-cad4f78d6b48} C’est le cœur du processus. Indiquez l’architecture Blackwell (`121`) et le nouveau chemin CUDA dans le script `build.sh`. ```bash ./build.sh \ --config Release \ --update --build \ --parallel \ --build_wheel \ --use_cuda \ --cuda_home $CUDA_HOME \ --cudnn_home $CUDNN_HOME \ --skip_tests \ --cmake_generator Ninja \ --cmake_extra_defines CMAKE_CUDA_ARCHITECTURES=121 \ --cmake_extra_defines CMAKE_CUDA_FLAGS="-I/usr/local/cuda/include/cccl" \ --cmake_extra_defines CMAKE_CXX_FLAGS="-I/usr/local/cuda/include/cccl" ``` > **Astuce :** ajouter `CMAKE_CUDA_FLAGS` évite les erreurs d’inclusion liées à `CCCL`. ### 4. Vérifier le résultat et installer {#sec-410f01ad96da} Une fois le build terminé, un fichier `.whl` dédié à `aarch64` apparaît dans `build/Linux/Release/dist/`. ```bash # Lister le fichier wheel généré ls -lh build/Linux/Release/dist/onnxruntime_gpu-*.whl # Installer le wheel pip install build/Linux/Release/dist/onnxruntime_gpu-1.25.0-cp312-cp312-linux_aarch64.whl ``` ### 5. Validation finale {#sec-d3ac8cb2ba46} Assurez‑vous que la bibliothèque reconnait bien le GPU. ```python import onnxruntime as ort print("ORT version:", ort.__version__) print("Available providers:", ort.get_available_providers()) ``` **Résultat attendu** : `['CUDAExecutionProvider', 'CPUExecutionProvider']`. Si c’est le cas, félicitations ! 🎉 --- ## Conclusion {#sec-dfe0bb0b5f26} Le fichier wheel energy‑crafted peut être réutilisé dans vos images Docker via la commande `COPY`, ce qui simplifie les déploiements futurs. Bien que la compilation ménage `aarch64` avec CUDA récent soit ardue, une fois réalisée, elle offre des performances incomparables pour les modèles génératifs AI. J’espère que ce guide éclairera les utilisateurs de DGX‑Spark !