Einstieg in die Polars-GPU-Beschleunigung: Abfragen bis zu 13× schneller

Verstehen der Integration von NVIDIA RAPIDS cuDF

Die Nachfrage nach schnellerer Datenverarbeitung und -analyse ist in den letzten Jahren rasant gestiegen, da Datensätze auf Hunderte Millionen oder sogar Milliarden Zeilen angewachsen sind. Um diese Herausforderung zu meistern, verlagert sich die Datenverarbeitung von klassischen CPU-Workloads hin zu GPU-beschleunigtem Rechnen. Hier kommt NVIDIA RAPIDS cuDF ins Spiel.

NVIDIA RAPIDS ist eine Open-Source-Suite von Bibliotheken für GPU-beschleunigte Data Science und Analytics. RAPIDS nutzt die massive Parallelität von NVIDIA GPUs, um typischerweise CPU-gebundene Aufgaben zu beschleunigen und Daten-Workflows zu straffen. 

Innerhalb von RAPIDS ist cuDF die Bibliothek für DataFrame-Operationen. cuDF erweitert die vertraute DataFrame-Abstraktion in den GPU-Speicher und lässt sich ohne große Codeänderungen in Daten-Workflows integrieren. Die Bibliothek unterstützt alle zentralen Operationen auf DataFrames: Filtern, Aggregieren, Mergen und Sortieren – alles GPU-beschleunigt.

NVIDIA und Polars haben soeben die Open-Beta der Python Polars GPU Engine angekündigt, angetrieben von RAPIDS cuDF. Dieses Feature ist ein großer Sprung für High-Performance-Datenverarbeitung und liefert Polars-Nutzenden mit NVIDIA GPUs bis zu 13× schnellere Workflows!

High-Level-Design der Polars API inklusive GPU Engine. Bildquelle: Polars

Mit der GPU Engine können Polars-Nutzende wählen, auf welchem Engine-Typ ihre Workloads laufen. Der Polars-Optimizer unterstützt alle Engines und entscheidet dynamisch, welche Abfragen auf der GPU oder CPU ausgeführt werden.

Die Polars GPU Engine: Ein Game-Changer

Du hast jetzt Kontext zu Polars, der NVIDIA RAPIDS cuDF Bibliothek und deren Integration in die Python Polars API. Was bedeutet das konkret für Entwicklerinnen, Entwickler und Data Scientists?

Hier eine Zusammenfassung dessen, was die Polars GPU Engine ermöglicht:

• Integration mit der Python Polars Lazy API: Übergib einfach engine="gpu" an die collect()-Operation in der Lazy API von Polars, um GPU-Verarbeitung ohne große Codeänderungen zu aktivieren.
• Interaktive Verarbeitung großer Datensätze: Die GPU Engine lässt Hunderte Millionen Zeilen interaktiv wirken. Mit nur einer GPU bewältigst du Datenvolumen, für die sonst komplexere und langsamere Lösungen nötig wären.
• Konsequent auf Effizienz getrimmt: Die Polars GPU Engine nutzt den Polars-Optimizer voll aus, um Ausführungen maximal effizient zu gestalten und Zeit sowie Speicher zu minimieren.
• Eleganter CPU-Fallback: Wenn bestimmte Abfragen nicht auf der GPU unterstützt werden, greift automatisch die CPU ein. Dein Workflow bleibt nahtlos, da die Engine bei Bedarf automatisch zurückfällt.

Wie sehen die Ergebnisse bisher aus? Schauen wir rein. 

Die Polars GPU Engine beschleunigt Datenverarbeitung bis zu 13×. Bildquelle: Polars

Der obige Benchmark zeigt eindrucksvoll, dass die Polars GPU Engine Abfragen um bis zu 13× beschleunigt.

Wichtig ist aber: Polars auf einer GPU ist nicht automatisch immer schneller als auf der CPU – insbesondere bei einfachen, wenig rechenintensiven Abfragen. Oft limitiert hier die Lesegeschwindigkeit von der Festplatte. Wenn I/O der Flaschenhals ist, bringt GPU-Beschleunigung naturgemäß weniger Vorteile.

Für komplexere Operationen hingegen liefert die GPU Engine deutliche Speedups – ideal bei großen Datensätzen oder Abfragen mit Joins, Group-bys und String-Verarbeitung.

Das Zusammenspiel von CPU und GPU

Besonders überzeugend an der Integration ist ihre Flexibilität. Wie erwähnt, kann der Optimizer je nach Komplexität zwischen CPU- und GPU-Ausführung wechseln. Aber wie funktioniert dieser Übergang genau?

Polars ohne GPU-Beschleunigung

Bei der Ausführung auf der CPU folgt Polars einer strukturierten, stark optimierten Pipeline. Grob passiert Folgendes:

1. DSL (domänenspezifische Sprache): Aus deinem Code erzeugt Polars zunächst eine strukturierte Abfragebeschreibung, ähnlich einem Syntaxbaum. Sie legt fest, welche Operationen – etwa Filtern, Gruppieren, Aggregieren – ausgeführt werden sollen.
2. IR (Intermediate Representation): Die Abfrage wird in einen detaillierten Ausführungsplan überführt und auf Korrektheit sowie passende Schemas geprüft. Das bildet die Grundlage der Verarbeitung.
3. Optimizer: Der Optimizer verbessert den Plan, ordnet Operationen um und entfernt Überflüssiges. Beispielsweise wird Filtern vor Joins oder Aggregationen gezogen, um die Datenmenge früh zu reduzieren.
4. Optimierte IR: Der verbesserte Plan wird finalisiert und ist bereit für die Ausführung durch die Polars-Engine.
5. Polars In-Memory-Engine (CPU-Ausführung): Abschließend führt die In-Memory-Engine den optimierten Plan vollständig auf der CPU aus. Trotz aller Optimierungen kann das bei großen Datensätzen dauern, da CPUs nur begrenzt parallel arbeiten.

Polars mit GPU-Beschleunigung

Wenn du GPU-Beschleunigung aktivierst, indem du engine="gpu" an .collect() übergibst, bleibt der Ablauf oberflächlich gleich. Hinter den Kulissen prüfen zusätzliche Schritte, welche Teile via cuDF auf die GPU ausgelagert werden können:

1. DSL (domänenspezifische Sprache): Wie im CPU-Modus erzeugt Polars die strukturierte Abfragebeschreibung – unabhängig davon, ob CPU oder GPU zum Einsatz kommt.
2. IR (Intermediate Representation): Polars baut daraus den Ausführungsplan und prüft Schemas und Korrektheit. Die IR ist zu diesem Zeitpunkt noch engine-neutral.
3. Optimizer: Der Optimizer arbeitet wie im CPU-Fall: Er ordnet für maximale Effizienz um und entfernt Redundanz. Der Plan bleibt zunächst allgemein optimiert.
4. Optimierte IR: Der Plan ist final – jetzt prüft die Engine, welche Teile auf die GPU ausgelagert werden können.
5. cuDF-Callback (GPU-Check): Hier passiert die Magie. Der cuDF-Callback entscheidet, welche Operationen GPU-geeignet sind, und passt den Plan entsprechend an.
6. Polars In-Memory-Engine (GPU- und CPU-Ausführung): Die Engine führt den Plan aus: GPU-geeignete Abfragen laufen auf der GPU, nicht unterstützte Teile fallen automatisch auf die CPU zurück.

Dieses hybride Ausführungsmodell – bei dem GPU und CPU Hand in Hand arbeiten – macht Polars äußerst flexibel. Du profitierst von GPU-Beschleunigung, ohne bei nicht unterstützten Abfragen Kompromisse eingehen zu müssen. Der Release-Blogpost von Polars erklärt die Technik dahinter im Detail.

Erste Schritte mit der Polars GPU Engine

Jetzt zum spannendsten Teil! In diesem Abschnitt zeige ich dir Schritt für Schritt, wie du deine Umgebung einrichtest und GPU-beschleunigte Datenverarbeitung nutzt.

Am einfachsten startest du mit diesem Google-Colab-Notebook. 

Colab bietet kostenlose, wenn auch begrenzte GPU-Nutzung – praktisch, wenn du nicht direkt Zugriff auf eine GPU hast. Wenn du das Notebook verwendest, starten wir unten bei Schritt 2; die vorherigen Schritte kannst du überspringen.

Voraussetzungen

Bevor du die Polars GPU Engine installierst, stelle sicher, dass dein System die Anforderungen für NVIDIA RAPIDS cuDF erfüllt. Alle nötigen Spezifikationen – inklusive GPU-Kompatibilität und Treiberanforderungen – findest du in der RAPIDS-Dokumentation.

1. Virtuelle Umgebung erstellen (empfohlen)

Für den Start mit der Polars GPU Engine empfiehlt es sich, eine virtuelle Umgebung anzulegen, um Abhängigkeiten sauber zu isolieren. 

Ich nutze hier conda, du kannst aber auch deinen bevorzugten Paketmanager verwenden.

Zusätzlich zu Python kannst du JupyterLab in die Umgebung aufnehmen – ideal für interaktive Exploration und schnelle Analysen.

conda create -n polars-gpu -c conda-forge python=3.11 jupyterlab

Aktiviere die Umgebung anschließend so:

conda activate polars-gpu

2. Polars GPU Engine installieren

Aktiviere jetzt die GPU-Beschleunigung, indem du Polars samt GPU Engine installierst. Damit werden auch cuDF und weitere Abhängigkeiten für NVIDIA GPUs eingerichtet:

pip install -U polars[gpu] --extra-index-url=https://pypi.nvidia.com

Nach der Installation fühlt sich die Arbeit mit Polars auf der GPU ähnlich an wie auf der CPU – nur eben deutlich schneller bei komplexen oder datenintensiven Workflows.

Wie bereits erklärt, optimiert die Polars-Engine den Ausführungsplan automatisch, nutzt die NVIDIA GPU bestmöglich und reduziert den Speicherverbrauch. Für Abfragen ohne GPU-Support greift ein eleganter CPU-Fallback – dein Workflow läuft ohne Unterbrechung weiter.

Lass uns die Engine mit ein paar einfachen Beispielen in Aktion sehen!

Ein paar Abfragen mit der Polars GPU Engine ausführen

Für diese Demo nutzen wir einen 22-GB-Datensatz mit simulierten Finanztransaktionen von Kaggle. NVIDIA hostet ihn in einem Google Cloud Storage (GCS) Bucket, was schnelle Downloads sicherstellt.

Lade den Datensatz zunächst herunter:

!wget https://storage.googleapis.com/rapidsai/polars-demo/transactions.parquet -O transactions.parquet

Da dieser Datensatz von Kaggle stammt, gelten die lizenz- und nutzungsrechtlichen Bedingungen des jeweiligen Kaggle-Datensatzes.

Lass uns den Datensatz mit Polars laden und das Schema prüfen:

import polars as pl
from polars.testing import assert_frame_equal

transactions = pl.scan_parquet("transactions.parquet")
transactions.collect_schema()

Hier die Ausgabe:

Schema([('CUST_ID', String),
        ('START_DATE', Date),
        ('END_DATE', Date),
        ('TRANS_ID', String),
        ('DATE', Date),
        ('YEAR', Int64),
        ('MONTH', Int64),
        ('DAY', Int64),
        ('EXP_TYPE', String),
        ('AMOUNT', Float64)])

Nun berechnen wir das gesamte Transaktionsvolumen, indem wir die Spalte AMOUNT summieren. Zuerst ohne GPU-Beschleunigung:

transactions.select(pl.col("AMOUNT").sum()).collect()

Ausgabe:

AMOUNT
f64
3.6183e9

Das ist ein hohes Gesamtvolumen! Jetzt dieselbe Abfrage auf der GPU:

transactions.select(pl.col("AMOUNT").sum()).collect(engine="gpu")

Ausgabe:

AMOUNT
f64
3.6183e9

Bei so einfachen Operationen liefern CPU und GPU dasselbe Ergebnis in ähnlicher Zeit, da die Abfrage nicht rechenintensiv genug ist, um stark von der GPU zu profitieren. Ihre Stärken spielt die GPU bei komplexeren Abfragen aus.

Weiter geht’s mit einer komplexeren Abfrage: Wir gruppieren Transaktionen nach Kundennummer (CUST_ID), summieren die Beträge und sortieren anschließend nach den höchsten Ausgaben. 

Zuerst auf der CPU:

%%time
res_cpu = (
   transactions
   .group_by("CUST_ID")
   .agg(pl.col("AMOUNT").sum())
   .sort(by="AMOUNT", descending=True)
   .head()
   .collect()
)
res_cpu

Hier die Ausgabe:

CPU times: user 4.63 s, sys: 3.75 s, total: 8.38 s
Wall time: 6.04 s
CUST_ID
AMOUNT
str
f64
"CA9UYOQ5DA"
2.0290e6
"CJUK2MTM5Q"
1.8115e6
"CYXX1NBIKL"
1.8082e6
"C6ILEYAYQ9"
1.7961e6
"CCNBC305GI"
1.7274e6

Jetzt dieselbe Abfrage auf der GPU:

%%time
res_gpu = (
   transactions
   .group_by("CUST_ID")
   .agg(pl.col("AMOUNT").sum())
   .sort(by="AMOUNT", descending=True)
   .head()
   .collect(engine="gpu")
)
res_gpu

Ausgabe:

CPU times: user 347 ms, sys: 0 ns, total: 347 ms
Wall time: 353 ms
shape: (5, 2)
CUST_ID
AMOUNT
str
f64
"CA9UYOQ5DA"
2.0290e6
"CJUK2MTM5Q"
1.8115e6
"CYXX1NBIKL"
1.8082e6
"C6ILEYAYQ9"
1.7961e6
"CCNBC305GI"
1.7274e6

Wie du siehst, bringt die GPU bei komplexeren Abfragen massive Vorteile: Die Laufzeit sinkt von 6,04 Sekunden auf der CPU auf nur 353 Millisekunden auf der GPU!

Dieses Beispiel zeigt, wie stark die Polars GPU Engine groß angelegte Datenoperationen beschleunigen kann. 

Weitere fortgeschrittene Beispiele findest du im zugehörigen Colab-Notebook.

Fazit

Die Polars GPU Engine, angetrieben von NVIDIA RAPIDS cuDF, bringt beeindruckende Geschwindigkeitsgewinne – bis zu 13× schnellere Verarbeitung bei komplexen Operationen. Für sehr große Datensätze bietet Polars klare Vorteile gegenüber klassischen DataFrame-Bibliotheken.

Nicht jede Abfrage profitiert gleichermaßen von GPU-Beschleunigung, doch Polars ist insgesamt ein starkes Werkzeug für alle, die mit großen Daten arbeiten. Die einfache Integration und das hybride CPU-GPU-Modell machen Polars zu einem Top-Kandidaten für moderne Daten-Workflows.

Wenn du deine Kompetenzen in der Datenmanipulation – insbesondere mit Pandas – ausbauen willst, kann ich dir diese Kurse sehr empfehlen:

• Data Manipulation with Pandas
• Streamlined Data Ingestion with Pandas
• Writing Efficient Code with Pandas

Diese Ressourcen liefern dir ein solides Fundament und ergänzen die starken Fähigkeiten von Tools wie Polars ideal!