# ONNX Runtime GPU: Waarom zelf bouwen?

Voordat we in de bouw duiken, laten we eerst een paar concepten verduidelijken.

## **wat is onnxruntime_gpu?** {#sec-9ff1a09e9e89}

**ONNX Runtime (ORT)** is een geoptimaliseerde AI‑inference‑engine. Modellen die je in PyTorch of TensorFlow maakt, converteer je naar het `.onnx`‑formaat, waarna ORT ze zo snel mogelijk op diverse hardware kan uitvoeren. De variant `onnxruntime_gpu` maakt gebruik van NVIDIA‑GPU's met **CUDA** en **cuDNN** om de rekensnelheid te maximaliseren.


![image of onnxruntime](/media/whitedec/blog_img/35245efd929e4132a695bf5bd2ad1d45.webp)


## Waarom wordt het vaak gebruikt bij AI‑generatiemodellen (beeld/video)? {#sec-5c0018e3e915}

Modellen zoals Stable Diffusion en Whisper hebben enorme aantallen parameters en vereisen veel rekenkracht. ORT biedt de volgende optimalisaties:

* **Graph Optimization:** Overbodige bewerkingen worden verwijderd en meerdere operaties worden samengevoegd (Operator Fusion).
* **Memory Management:** GPU‑geheugen wordt efficiënt beheerd, zodat zelfs grote modellen soepel draaien.
* **Hardware Acceleration:** Door te combineren met accelerators zoals TensorRT kun je meerdere malen sneller presteren dan met zuivere PyTorch.

## Waarom moeten aarch64‑gebruikers zelf compileren? {#sec-665d2400b756}

Normaal gesproken kun je `pip install onnxruntime-gpu` uitvoeren, maar voor **aarch64** werkt dat niet zonder meer.

1. **Ontbrekende binaire bestanden:** De officiële wheel‑bestanden op PyPI zijn voornamelijk voor x86_64.
2. **Ondersteuning voor nieuwe architecturen:** Recente specificaties zoals **CUDA 13.0** of **Compute Capability 12.1 (Blackwell)** worden vaak nog niet door de reguliere releases gedekt.
3. **Geoptimaliseerde builds:** Als je specifieke optimalisaties wilt voor jouw machine (bijv. DGX Spark), is zelf bouwen de enige oplossing.

---

## ONNX Runtime GPU bouwen op DGX‑Spark (aarch64) {#sec-556ead64bd44}

Hier deel ik mijn eigen stappenplan.

### 1. Omgeving controleren (Environment Check) {#sec-dbf99788fe3f}

Eerst de hardware‑specificaties bekijken. Ik gebruikte een DGX‑Spark met een Grace‑Blackwell GPU.

| Item | Informatie |
| --- | --- |
| **OS/Arch** | Linux aarch64 |
| **GPU** | NVIDIA GB10 (Blackwell) |
| **CUDA** | 13.0 (V13.0.88) |
| **Python** | 3.12.3 |
| **Compute Cap** | 12.1 |

```bash
# GPU‑info
nvidia-smi
# CUDA‑versie
nvcc --version
```

### 2. Ontbrekende componenten: cuDNN installeren {#sec-6aab9c2c470c}

Omdat `cuDNN` niet aanwezig was, installeerde ik het eerst via pip en stelde vervolgens de juiste paden in.

```bash
# cuDNN voor CUDA 13
pip install nvidia-cudnn-cu13

# Installatielocatie bekijken (Python‑script)
python3 -c "import site, os; print(os.path.join(site.getsitepackages()[0], 'nvidia/cudnn'))"
```

Daarna de omgevingsvariabelen configureren zodat het build‑script cuDNN kan vinden.

```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. ONNX Runtime vanuit broncode bouwen {#sec-cad4f78d6b48}

Dit is de kernstap. In `build.sh` geef je de Blackwell‑architectuur (`121`) en de aangepaste CUDA‑paden op.

```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"
```

> **Tip:** Het toevoegen van `CMAKE_CUDA_FLAGS` voorkomt include‑fouten gerelateerd aan `CCCL`.

### 4. Resultaat controleren en installeren {#sec-410f01ad96da}

Na een succesvolle build vind je een aarch64‑specifiek `.whl`‑bestand onder `build/Linux/Release/dist/`.

```bash
# Wheel bekijken
ls -lh build/Linux/Release/dist/onnxruntime_gpu-*.whl

# Installeren
pip install build/Linux/Release/dist/onnxruntime_gpu-1.25.0-cp312-cp312-linux_aarch64.whl
```

### 5. Verificatie {#sec-d3ac8cb2ba46}

Controleer of de bibliotheek de GPU herkent.

```python
import onnxruntime as ort
print("ORT versie:", ort.__version__)
print("Beschikbare providers:", ort.get_available_providers())
```

**Resultaat:** Als `['CUDAExecutionProvider', 'CPUExecutionProvider']` verschijnt, is alles correct! 🎉

---

## Afsluiting {#sec-dfe0bb0b5f26}

Het gegenereerde wheel‑bestand kun je later in een Docker‑image opnemen met een `COPY`‑commando, zodat je het opnieuw kunt gebruiken. Bouwen op aarch64 met de nieuwste CUDA‑versie is lastig, maar een eenmaal werkende setup levert ongeëvenaarde prestaties voor generatieve AI‑modellen.

Ik hoop dat deze gids DGX‑Spark‑gebruikers een helder pad biedt!