NVIDIA RAPIDS: Data Science auf GPUs be­schleu­ni­gen

NVIDIA RAPIDS ist eine Open-Source-Plattform, die Data-Science- und Machine-Learning-Workflows direkt auf NVIDIA-GPUs ausführt. Ziel ist es, bekannte Python-Bi­blio­the­ken wie pandas, scikit-learn oder NetworkX teilweise durch GPU-be­schleu­nig­te Al­ter­na­ti­ven zu ersetzen, ohne dass be­stehen­der Code voll­stän­dig neu ge­schrie­ben werden muss. Dadurch lassen sich viele Da­ten­ana­ly­sen und Machine-Learning-Prozesse deutlich schneller ausführen.

Was genau ist NVIDIA RAPIDS?

Viele Data-Science-Projekte bestehen aus mehreren Schritten: Daten einlesen, be­rei­ni­gen, trans­for­mie­ren, ana­ly­sie­ren und an­schlie­ßend für Machine-Learning-Modelle vor­be­rei­ten. Häufig werden diese Aufgaben auf CPUs aus­ge­führt, obwohl GPUs we­sent­lich mehr parallele Re­chen­leis­tung bieten.

Genau hier setzt RAPIDS an. Die Plattform stellt GPU-native Bi­blio­the­ken bereit, die bekannte Python-Werkzeuge nach­bil­den und gleich­zei­tig die Re­chen­leis­tung moderner NVIDIA-GPUs nutzen. Dadurch können viele be­stehen­de Workflows mit ver­gleichs­wei­se geringem An­pas­sungs­auf­wand be­schleu­nigt werden.

Die wich­tigs­ten RAPIDS-Bi­blio­the­ken

RAPIDS verfolgt das Ziel, bekannte Data-Science-Werkzeuge möglichst nahtlos auf GPUs zu über­tra­gen. Viele Funk­tio­nen ori­en­tie­ren sich deshalb bewusst an eta­blier­ten Python-Bi­blio­the­ken. Ent­wick­le­rin­nen und Ent­wick­ler sowie Data Sci­en­tists können dadurch häufig große Teile ihres be­stehen­den Codes wei­ter­ver­wen­den und dennoch von einer er­heb­li­chen Be­schleu­ni­gung pro­fi­tie­ren.

cuDF: pandas auf der GPU

cuDF ist die GPU-be­schleu­nig­te DataFrame-Bi­blio­thek von RAPIDS. Sie ori­en­tiert sich stark an der bekannten Python pandas-API und er­mög­licht die Ver­ar­bei­tung großer Da­ten­sät­ze direkt im Gra­fik­spei­cher. Viele Ope­ra­tio­nen wie Filtern, Sortieren, Grup­pie­ren oder Zu­sam­men­füh­ren von Tabellen funk­tio­nie­ren ähnlich wie in pandas. Dadurch können be­stehen­de Skripte häufig mit nur wenigen An­pas­sun­gen auf cuDF um­ge­stellt werden.

Anstatt Daten ständig zwischen CPU und GPU zu ver­schie­ben, ver­blei­ben die Da­ten­sät­ze während der Ver­ar­bei­tung im Gra­fik­spei­cher. Das reduziert Über­tra­gungs­zei­ten und ver­bes­sert die Ge­samt­leis­tung vieler Workflows erheblich. Besonders bei Da­ten­sät­zen mit mehreren Millionen oder sogar Mil­li­ar­den Zeilen kann sich die Ver­ar­bei­tung deutlich be­schleu­ni­gen. Auch CSV-, Parquet- und ORC-Dateien lassen sich direkt über cuDF einlesen.

Seit neueren RAPIDS-Versionen er­mög­licht cudf.pandas zudem eine Zero-Code-Change-Be­schleu­ni­gung vieler pandas-Workflows. Dadurch können be­stehen­de An­wen­dun­gen häufig ohne Än­de­run­gen am Quellcode von der Re­chen­leis­tung von NVIDIA-GPUs pro­fi­tie­ren. Nicht un­ter­stütz­te Ope­ra­tio­nen fallen auf pandas zurück. Für viele An­wen­de­rin­nen und Anwender fungiert cuDF deshalb als Drop-in-Al­ter­na­ti­ve zu pandas. Zwar sind nicht sämtliche pandas-Funk­tio­nen voll­stän­dig identisch im­ple­men­tiert, die grund­le­gen­den DataFrame-Ope­ra­tio­nen lassen sich jedoch ohne größere Än­de­run­gen über­neh­men.

cuML: scikit-learn auf der GPU

cuML ist die Machine-Learning-Bi­blio­thek von RAPIDS. Sie bietet GPU-be­schleu­nig­te Im­ple­men­tie­run­gen vieler bekannter Al­go­rith­men aus dem scikit-learn-Ökosystem. Dazu gehören unter anderem lineare Re­gres­si­on, Random Forests, k-Means-Clus­te­ring, PCA, UMAP und ver­schie­de­ne Klas­si­fi­ka­ti­ons­ver­fah­ren. Die APIs ori­en­tie­ren sich bewusst an scikit-learn, sodass bekannte Methoden wie fit(), predict() oder transform() weiterhin verwendet werden können.

Dadurch können be­stehen­de Machine-Learning-Projekte mit minimalem An­pas­sungs­auf­wand auf GPUs migriert werden. Ins­be­son­de­re bei großen Trai­nings­da­ten­sät­zen lassen sich Trai­nings­zei­ten erheblich re­du­zie­ren. Ein weiterer Vorteil besteht darin, dass die Daten direkt in GPU-Spei­cher­struk­tu­ren ver­blei­ben können. Zu­sätz­li­che Kon­ver­tie­run­gen zwischen CPU- und GPU-Da­ten­for­ma­ten entfallen. Mit cuml.accel bietet RAPIDS außerdem einen Zero-Code-Change-Modus für viele scikit-learn-, UMAP- und HDBSCAN-Workloads. Die Funktion befindet sich aktuell noch in der Open-Beta-Phase. Un­ter­stütz­te Al­go­rith­men und Esti­ma­to­ren werden auf der GPU aus­ge­führt, während nicht un­ter­stütz­te Ope­ra­tio­nen auf die jeweilige CPU-Im­ple­men­tie­rung zu­rück­fal­len. Dadurch können be­stehen­de Machine-Learning-Projekte häufig ohne direkte Code­än­de­run­gen be­schleu­nigt werden, sofern die ver­wen­de­ten Verfahren und Da­ten­struk­tu­ren un­ter­stützt werden.

cuGraph: NetworkX auf der GPU

cuGraph erweitert RAPIDS um leis­tungs­fä­hi­ge Gra­ph­ana­ly­sen auf GPUs. Die Bi­blio­thek richtet sich an An­wen­den­de, die komplexe Netz­werk­struk­tu­ren ana­ly­sie­ren möchten. Typische An­wen­dungs­fäl­le sind soziale Netzwerke, Be­trugs­er­ken­nung, Emp­feh­lungs­al­go­rith­men oder Netz­werk­op­ti­mie­rung. cuGraph bietet sowohl eine eigene Graph-API als auch mit nx-cugraph ein NetworkX-Backend, das be­stehen­de NetworkX-An­wen­dun­gen per Zero-Code-Change be­schleu­nigt. Dazu gehören bei­spiels­wei­se PageRank, Breadth-First Search, Shortest Path oder Community Detection. Große Graphen können dadurch we­sent­lich schneller ana­ly­siert werden als auf her­kömm­li­chen CPUs.

Gerade bei Millionen oder Mil­li­ar­den von Knoten und Kanten wird die Par­al­le­li­sie­rung der GPU besonders deutlich. Aufgaben, die auf CPUs Stunden benötigen würden, lassen sich teilweise innerhalb weniger Minuten ausführen. Für Ent­wick­le­rin­nen und Ent­wick­ler, die bereits mit NetworkX arbeiten, reduziert die ähnliche API den Umstieg erheblich. Be­stehen­der Code kann häufig mit über­schau­ba­rem Aufwand angepasst werden.

Da­ten­for­ma­te und In­ter­ope­ra­bi­li­tät

Ein wichtiger Baustein des RAPIDS-Öko­sys­tems ist Apache Arrow. Dabei handelt es sich um ein spal­ten­ori­en­tier­tes Spei­cher­for­mat, das für den schnellen Austausch großer Da­ten­men­gen ent­wi­ckelt wurde. Arrow er­mög­licht es un­ter­schied­li­chen An­wen­dun­gen, Daten effizient zu teilen, ohne diese ständig kopieren oder kon­ver­tie­ren zu müssen. Vor allem cuDF und libcudf arbeiten mit spal­ten­ori­en­tier­ten, Apache-Arrow-kom­pa­ti­blen Da­ten­struk­tu­ren. Dadurch lassen sich ta­bel­la­ri­sche Daten effizient zwischen GPU-be­schleu­nig­ten Kom­po­nen­ten und anderen Data-Science-Werk­zeu­gen aus­tau­schen.

Die In­te­gra­ti­on mit PyTorch er­mög­licht bei­spiels­wei­se die direkte Nutzung von RAPIDS-Daten in Deep-Learning-Pipelines. Da­ten­sät­ze können auf der GPU vor­be­rei­tet und an­schlie­ßend un­mit­tel­bar für das Training neu­ro­na­ler Netze verwendet werden. Auch Dask, dask.distributed und Dask-CUDA werden umfassend un­ter­stützt. Dadurch lassen sich RAPIDS-Workloads auf mehrere GPUs oder sogar mehrere Server verteilen, wenn die In­fra­struk­tur ent­spre­chend ein­ge­rich­tet ist.

Zu­sätz­lich exis­tie­ren In­te­gra­tio­nen für Apache Spark. Über ent­spre­chen­de Be­schleu­ni­gungs-Plugins können Spark-Workloads von GPU-Res­sour­cen pro­fi­tie­ren, ohne dass komplette An­wen­dun­gen neu ent­wi­ckelt werden müssen. Durch diese Offenheit lässt sich RAPIDS in be­stehen­de Da­ten­platt­for­men in­te­grie­ren. Un­ter­neh­men können dadurch GPU-Be­schleu­ni­gung nutzen, ohne ihre gesamte In­fra­struk­tur aus­tau­schen zu müssen.

Warum die Da­ten­vor­be­rei­tung oft wichtiger ist als das Mo­dell­trai­ning

Viele An­fän­ge­rin­nen und Anfänger kon­zen­trie­ren sich vor allem auf die Trai­nings­ge­schwin­dig­keit eines Machine-Learning-Modells. In der Praxis macht das ei­gent­li­che Training jedoch häufig nur einen Teil des gesamten Workflows aus. Ein er­heb­li­cher Anteil der Pro­jekt­zeit entfällt auf Da­ten­auf­be­rei­tung, Da­ten­be­rei­ni­gung und Feature En­gi­nee­ring. Rohdaten müssen geprüft, kor­ri­giert, gefiltert und trans­for­miert werden.

Bei großen Da­ten­sät­zen kann dieser Schritt deutlich mehr Zeit be­an­spru­chen als das spätere Training. Selbst hoch­op­ti­mier­te Modelle helfen wenig, wenn die Da­ten­vor­be­rei­tung zum Fla­schen­hals wird. Genau hier entfaltet RAPIDS seinen größten Nutzen. Viele DataFrame-Ope­ra­tio­nen lassen sich massiv par­al­le­li­sie­ren und pro­fi­tie­ren stark von der Ar­chi­tek­tur aktueller GPUs.

Wenn Da­ten­be­rei­ni­gung statt mehrerer Stunden nur noch wenige Minuten benötigt, verkürzt sich die gesamte Ent­wick­lungs­zeit eines Projekts erheblich. Darüber hinaus können Data Sci­en­tists schneller neue Ideen testen. Mehr Ex­pe­ri­men­te bedeuten häufig auch bessere Modelle. Kürzere War­te­zei­ten ver­bes­sern zudem die Pro­duk­ti­vi­tät von Teams. Ent­schei­dun­gen können schneller getroffen und Er­geb­nis­se früher be­reit­ge­stellt werden.

Besonders bei ex­plo­ra­ti­ver Da­ten­ana­ly­se wird dieser Vorteil deutlich. An­wen­den­de können in­ter­ak­ti­ver arbeiten und um­fang­rei­che Da­ten­sät­ze nahezu in Echtzeit un­ter­su­chen. In vielen Un­ter­neh­men entstehen die größten Zeit­ge­win­ne daher nicht beim Mo­dell­trai­ning selbst, sondern bereits in den vor­ge­la­ger­ten Da­ten­pro­zes­sen. RAPIDS adres­siert genau diesen Bereich und be­schleu­nigt diesen Teil des Workflows.

Hardware-Vor­aus­set­zun­gen

RAPIDS setzt moderne NVIDIA-GPUs mit CUDA-Un­ter­stüt­zung voraus. Konkret benötigen aktuelle RAPIDS-Versionen min­des­tens eine GPU der NVIDIA-Volta-Ge­ne­ra­ti­on oder neuer, also Compute Ca­pa­bi­li­ty 7.0+. CUDA ist die von NVIDIA ent­wi­ckel­te Plattform, mit der sich re­chen­in­ten­si­ve Aufgaben wie Data Science, Machine Learning oder wis­sen­schaft­li­che Si­mu­la­tio­nen parallel auf Tausenden GPU-Kernen ausführen lassen. Dadurch können geeignete Workloads deutlich schneller ver­ar­bei­tet werden als auf klas­si­schen CPUs.

Für pro­duk­ti­ve Data-Science-Workloads sind aus­rei­chend Gra­fik­spei­cher und aktuelle Treiber besonders wichtig. Als Aus­gangs­punkt sind 16 GB VRAM sinnvoll; die tat­säch­li­chen An­for­de­run­gen hängen jedoch vom Datensatz, den ver­wen­de­ten Al­go­rith­men und der Par­al­le­li­sie­rung ab. Für größere Da­ten­sät­ze oder Multi-GPU-Um­ge­bun­gen sind 24 GB, 48 GB oder mehr emp­feh­lens­wert.

Emp­foh­le­ne GPU-Klassen:

• NVIDIA RTX 4070 Ti SUPER (16 GB)
• NVIDIA RTX 4080 SUPER (16 GB)
• NVIDIA RTX 4090 (24 GB)
• NVIDIA RTX 5090 (32 GB)
• NVIDIA L4 (24 GB)
• NVIDIA L40S (48 GB)
• NVIDIA RTX PRO 6000 Blackwell (96 GB)
• NVIDIA A100 (40 GB oder 80 GB)
• NVIDIA H100 (80 GB)
• NVIDIA H200 (141 GB)
• NVIDIA B200 (192 GB)
• NVIDIA B300 / Blackwell Ultra (288 GB)

Wie viel Zeit können Data Sci­en­tists sparen?

Der konkrete Ge­schwin­dig­keits­ge­winn hängt stark von Datensatz, Al­go­rith­mus und Hardware ab. Ins­be­son­de­re Da­ten­auf­be­rei­tung, Ag­gre­ga­tio­nen und Machine-Learning-Training pro­fi­tie­ren von der hohen Par­al­le­li­tät moderner GPUs. Dadurch verkürzen sich Ana­ly­se­pro­zes­se deutlich.

Weniger Wartezeit bedeutet gleich­zei­tig mehr Pro­duk­ti­vi­tät. Data Sci­en­tists können mehr Ex­pe­ri­men­te durch­füh­ren und Er­geb­nis­se schneller bewerten. Auch iterative Ent­wick­lungs­pro­zes­se werden be­schleu­nigt. Än­de­run­gen an Features oder Modellen lassen sich häufiger testen. Dadurch sinkt die Zeit bis zum pro­duk­ti­ven Einsatz neuer Modelle. Un­ter­neh­men können Er­kennt­nis­se schneller in ge­schäft­li­che Ent­schei­dun­gen umsetzen.

Zu­sätz­lich werden vor­han­de­ne Hardware-Res­sour­cen ef­fi­zi­en­ter genutzt. Statt große CPU-Cluster auf­zu­bau­en, können viele Aufgaben auf wenige leis­tungs­fä­hi­ge GPUs kon­zen­triert werden.

Besonders bei großen Da­ten­sät­zen steigt der Vorteil meist deutlich an. Je mehr Daten ver­ar­bei­tet werden müssen, desto stärker pro­fi­tie­ren viele Workloads von GPU-Be­schleu­ni­gung. RAPIDS ersetzt dabei nicht au­to­ma­tisch jede CPU-Aufgabe, kann jedoch zahl­rei­che Engpässe in modernen Data-Science-Pipelines be­sei­ti­gen.

MIG und Multi-GPU-Support

RAPIDS kann nicht nur eine einzelne GPU nutzen, sondern auch auf mehrere GPUs gleich­zei­tig skalieren. Dafür wird häufig Dask ein­ge­setzt, ein Framework für verteilte Da­ten­ver­ar­bei­tung. Dask verteilt Daten und Be­rech­nun­gen au­to­ma­tisch auf mehrere GPUs, sodass große Da­ten­sät­ze schneller ver­ar­bei­tet werden können. Dadurch skaliert die ver­füg­ba­re Re­chen­leis­tung deutlich mit der Anzahl der ein­ge­setz­ten GPUs.

In Re­chen­zen­tren kommt zu­sätz­lich häufig die NVIDIA-Tech­no­lo­gie MIG (Multi-Instance GPU) zum Einsatz. Mit MIG lässt sich eine physische GPU in mehrere von­ein­an­der un­ab­hän­gi­ge GPU-Instanzen aufteilen. So können mehrere User oder An­wen­dun­gen dieselbe GPU parallel verwenden, ohne sich ge­gen­sei­tig zu be­ein­flus­sen. Das ver­bes­sert die Aus­las­tung der Hardware und senkt die Kosten pro Workload. Für einen einzelnen großen RAPIDS-Workflow ist dagegen klas­si­sches Multi-GPU-Scaling mit Dask die passende Lösung.

In Kom­bi­na­ti­on mit Dask er­mög­licht RAPIDS den Aufbau ska­lier­ba­rer Da­ten­platt­for­men. Un­ter­neh­men können ihre In­fra­struk­tur dadurch schritt­wei­se erweitern, während be­stehen­de RAPIDS-Workflows weiterhin genutzt werden können.

In­stal­la­ti­on und Ökosystem

RAPIDS kann über ver­schie­de­ne Wege in­stal­liert werden. Die Plattform richtet sich sowohl an einzelne Ent­wick­le­rin­nen und Ent­wick­ler als auch an Un­ter­neh­men mit komplexen GPU-In­fra­struk­tu­ren.

In­stal­la­ti­on mit Conda

Conda ist der klas­si­sche In­stal­la­ti­ons­weg für RAPIDS. Die Ent­wi­ckeln­den stellen vor­kon­fi­gu­rier­te Pakete bereit, die viele Ab­hän­gig­kei­ten au­to­ma­tisch auflösen. Dadurch wird die Ein­rich­tung erheblich ver­ein­facht und An­wen­den­de müssen CUDA-Versionen und Bi­blio­the­ken nicht manuell zu­sam­men­su­chen.

Besonders für lokale Ent­wick­lungs­um­ge­bun­gen eignet sich Conda sehr gut. Neue Um­ge­bun­gen können isoliert erstellt und verwaltet werden. Auch ver­schie­de­ne RAPIDS-Versionen lassen sich parallel betreiben. Das er­leich­tert Tests und Upgrades. Für Ein­stei­ge­rin­nen und Ein­stei­ger stellt Conda daher meist den ein­fachs­ten Einstieg dar. Die In­stal­la­ti­on erfolgt mit wenigen Befehlen.

In­stal­la­ti­on mit pip

Mit neueren RAPIDS-Versionen wurde die In­stal­la­ti­on über pip deutlich ver­ein­facht. Seit RAPIDS 25.10 steht bei­spiels­wei­se cuML auch als vor­kom­pi­lier­te Python-Wheels über PyPI zur Verfügung. Dadurch können viele An­wen­den­de RAPIDS direkt mit den bekannten Python-Werk­zeu­gen in­stal­lie­ren, ohne eine voll­stän­di­ge Conda-Umgebung ein­rich­ten zu müssen.

Besonders für be­stehen­de Python-Projekte und moderne Ent­wick­lungs­um­ge­bun­gen ver­ein­facht dies den Einstieg erheblich. Dennoch müssen die ver­wen­de­te CUDA-Version, NVIDIA-Treiber und die Hardware weiterhin mit den An­for­de­run­gen der je­wei­li­gen RAPIDS-Version kom­pa­ti­bel sein. Für komplexe Data-Science-Um­ge­bun­gen und re­pro­du­zier­ba­re De­ploy­ments bleiben Conda-Um­ge­bun­gen und Container-Lösungen weiterhin beliebt.

Docker-Container

Docker er­mög­licht die Be­reit­stel­lung re­pro­du­zier­ba­rer RAPIDS-Um­ge­bun­gen. Alle be­nö­tig­ten Bi­blio­the­ken werden bereits im Container mit­ge­lie­fert. Dadurch entstehen weniger Kom­pa­ti­bi­li­täts­pro­ble­me zwischen ver­schie­de­nen Systemen und die Ent­wick­ler­teams können iden­ti­sche Um­ge­bun­gen nutzen.

Auch für Cloud-De­ploy­ments ist Docker besonders attraktiv. Container lassen sich einfach skalieren und au­to­ma­ti­sie­ren. In Ku­ber­netes-Um­ge­bun­gen gehört OCI-Container-Tech­no­lo­gie mitt­ler­wei­le zu den Stan­dard­werk­zeu­gen. Viele Un­ter­neh­men setzen RAPIDS daher bevorzugt in Container-Platt­for­men ein. Dadurch wird die Ver­wal­tung großer GPU-Land­schaf­ten ver­ein­facht.

NVIDIA NGC

NVIDIA NGC ist der of­fi­zi­el­le Container-Katalog von NVIDIA. Dort stellt NVIDIA re­gel­mä­ßig ak­tua­li­sier­te RAPIDS-Container bereit. Diese Images sind auf bestimmte CUDA-Versionen ab­ge­stimmt und werden kon­ti­nu­ier­lich gepflegt. Dadurch sinkt der Aufwand für die Wartung erheblich.

NGC eignet sich besonders für Un­ter­neh­men, For­schungs­ein­rich­tun­gen und Cloud-Um­ge­bun­gen. Neue Projekte können innerhalb weniger Minuten gestartet werden. Zudem enthält NGC zahl­rei­che weitere KI- und Data-Science-Frame­works. Dadurch entsteht ein um­fang­rei­ches GPU-Ökosystem aus einer Hand.

Fazit

RAPIDS bringt GPU-Be­schleu­ni­gung in viele zentrale Bereiche moderner Data-Science-Pipelines, ins­be­son­de­re Da­ten­auf­be­rei­tung, ta­bel­la­ri­sche Analysen, Machine Learning und Gra­ph­ana­ly­sen. Mit cuDF, cuML und cuGraph stehen GPU-be­schleu­nig­te Al­ter­na­ti­ven zu pandas, scikit-learn und NetworkX zur Verfügung, die sich bewusst an bekannten Python-APIs ori­en­tie­ren. Besonders die Be­schleu­ni­gung der Da­ten­vor­be­rei­tung kann er­heb­li­che Zeit­ge­win­ne er­mög­li­chen. Dank Apache Arrow, Dask, PyTorch und Apache Spark in­te­griert sich RAPIDS zudem nahtlos in be­stehen­de Da­ten­platt­for­men. Für Un­ter­neh­men und Data Sci­en­tists bietet RAPIDS damit einen ver­gleichs­wei­se einfachen Weg, GPU-Be­schleu­ni­gung in be­stehen­de Python-Workflows zu in­te­grie­ren.