Aan de slag met Polars GPU-versnelling: 13x snellere queries

De NVIDIA RAPIDS cuDF-integratie begrijpen

De vraag naar snellere dataverwerking en -analyse is de afgelopen jaren exponentieel gegroeid, omdat datasets zijn opgeschaald naar honderden miljoenen of zelfs miljarden rijen. Om deze uitdaging aan te gaan, verschuift het data science-veld steeds meer van traditionele CPU-gebaseerde verwerking naar GPU-versnelde computing. Daar komt NVIDIA RAPIDS cuDF om de hoek.

NVIDIA RAPIDS is een opensourcebibliotheekensuite voor GPU-versnelde data science en analytics. RAPIDS is ontworpen om dataworkflows te stroomlijnen door de massale parallelliteit van NVIDIA GPU’s te benutten om taken te versnellen die doorgaans CPU-bound zijn. 

Binnen RAPIDS is cuDF de bibliotheek die verantwoordelijk is voor DataFrame-bewerkingen. cuDF breidt de vertrouwde DataFrame-abstrahering uit naar GPU-geheugen, zodat je het zonder grote codewijzigingen in je workflows kunt integreren. De bibliotheek ondersteunt alle kernbewerkingen die data scientists op DataFrames uitvoeren: filteren, aggregeren, mergen en sorteren — allemaal GPU-aangedreven voor snelheid.

NVIDIA en Polars hebben zojuist de open-bètarelease aangekondigd van de Python Polars GPU-engine, aangedreven door RAPIDS cuDF. Deze nieuwe functie is een grote sprong voorwaarts voor high-performance dataverwerking en levert tot 13x snellere workflows voor Polars-gebruikers met NVIDIA GPU’s!

High-level ontwerp van de Polars API, inclusief een GPU-engine. Bron: Polars

Met de toevoeging van de GPU-engine kunnen Polars-gebruikers kiezen op welke engine hun workloads draaien. De Polars-optimizer ondersteunt alle engines en bepaalt dynamisch welke queries op de GPU of CPU kunnen worden uitgevoerd.

De Polars GPU-engine: een gamechanger

Je hebt nu wat context over Polars en de NVIDIA RAPIDS cuDF-bibliotheek, hoe ze integreren en via de Python Polars API beschikbaar zijn. Maar wat betekent dit voor developers en data scientists?

Hier is een samenvatting van wat de Polars GPU-engine mogelijk maakt:

• Integratie met de Python Polars Lazy API: gebruikers kunnen simpelweg engine="gpu" meegeven aan de collect()-operatie in de Lazy API van Polars, zodat GPU-verwerking werkt zonder grote codewijzigingen.
• Interactieve verwerking van grote datasets: de GPU-engine is ontworpen om het verwerken van honderden miljoenen rijen data interactief te laten aanvoelen. Met één GPU kun je enorme datavolumes aan die anders complexere en tragere oplossingen vereisen.
• Geoptimaliseerd voor efficiëntie: de Polars GPU-engine benut de Polars-optimizer volledig om zo efficiënt mogelijk uit te voeren, met minimale verwerkingstijd en geheugengebruik.
• Vriendelijke CPU-terugval: als bepaalde queries niet op de GPU worden ondersteund, valt de engine terug op de CPU. Zo blijft de workflow ononderbroken en wordt automatisch naar CPU-verwerking geschakeld wanneer nodig.

Wat zijn de resultaten tot nu toe? Laten we kijken. 

Polars GPU-engine versnelt dataverwerking tot 13x. Bron: Polars

De benchmark hierboven toont de indrukwekkende capaciteiten van de Polars GPU-engine door queries tot 13x te versnellen.

Het is echter belangrijk om te beseffen dat Polars op een GPU niet altijd sneller is dan op een CPU, zeker niet bij eenvoudigere, weinig rekenintensieve queries. In zulke gevallen wordt de performance vaak beperkt door de snelheid waarmee data van schijf wordt gelezen. GPU-versnelling biedt dan minder voordeel wanneer input/output (I/O) de primaire bottleneck is.

Dat gezegd hebbende levert de GPU-engine aanzienlijke versnellingen op voor complexere databewerkingen. Het is daarmee een waardevol hulpmiddel voor teams die werken met grote datasets of queries met joins, group-bys en stringverwerking.

De interactie tussen CPU en GPU

Een van de meest overtuigende kenmerken van deze integratie is de flexibiliteit. Zoals eerder genoemd kan de optimizer schakelen tussen CPU- en GPU-uitvoering op basis van de complexiteit van je queries. Maar hoe werkt die overgang precies?

Polars zonder GPU-versnelling

Als je Polars op de CPU draait, volgt de engine een gestructureerde en sterk geoptimaliseerde pijplijn om databewerkingen uit te voeren. Globaal zijn dit de stappen:

1. DSL (domain-specific language): de Polars-engine maakt eerst een gestructureerde queryschets van je code, vergelijkbaar met een abstracte syntaxisboom. Deze schets bepaalt de volgorde van bewerkingen zoals filteren, groeperen en aggregeren.
2. IR (intermediate representation): vervolgens zet Polars de schets om in een gedetailleerd uitvoerplan en controleert of alle bewerkingen kloppen en de dataschema’s matchen. Dit vormt de basis voor de verwerking.
3. Optimizer: de optimizer verbetert het plan door bewerkingen te herschikken en overbodige stappen te verwijderen. Zo kan filteren bijvoorbeeld vóór joins of aggregaties worden geplaatst om de dataset eerder te verkleinen. Dit zorgt voor maximale efficiëntie vóór de uitvoering.
4. Geoptimaliseerde IR: na optimalisatie wordt het verbeterde uitvoerplan gefinaliseerd en klaargemaakt voor verwerking door de Polars-engine. Dit is het blauwdrukplan voor de uitvoering.
5. Polars in-memory engine (CPU-uitvoering): tenslotte voert de in-memory engine van Polars het geoptimaliseerde plan volledig op de CPU uit. Ondanks de optimalisaties kan dit veel tijd kosten bij grote datasets, omdat CPU’s data sequentieel of met beperkte parallelliteit verwerken.

Polars met GPU-versnelling

Wanneer je GPU-versnelling inschakelt door engine="gpu" aan de .collect()-methode door te geven, blijft het proces aan de oppervlakte grotendeels hetzelfde, maar met extra checks en optimalisaties achter de schermen om te bepalen hoeveel van de workload via cuDF naar de GPU kan worden uitbesteed:

1. DSL (domain-specific language): net als in CPU-modus begint Polars met het creëren van een gestructureerde queryschets. Deze is hetzelfde of je op CPU of GPU draait en legt de gewenste bewerkingen vast.
2. IR (intermediate representation): Polars zet de schets om in een uitvoerplan en controleert de correctheid en schema’s. De IR blijft hier nog engine-neutraal: er is nog geen keuze gemaakt tussen CPU of GPU.
3. Optimizer: de optimizer werkt zoals bij CPU-uitvoering, herordent voor maximale efficiëntie en verwijdert redundantie. Het plan is nu algemeen geoptimaliseerd.
4. Geoptimaliseerde IR: het geoptimaliseerde plan wordt gefinaliseerd zoals bij CPU-uitvoering. Met GPU ingeschakeld controleert de engine nu of delen van dit plan naar de GPU kunnen worden uitbesteed.
5. cuDF-callback (GPU-check): hier gebeurt de magie! De cuDF-callback bepaalt of de GPU het uitvoerplan aankan. Sommige bewerkingen lenen zich uitstekend voor GPU-versnelling, andere niet. De callback past het plan aan om de GPU te gebruiken voor ondersteunde bewerkingen.
6. Polars in-memory engine (GPU- en CPU-uitvoering): uiteindelijk voert de Polars in-memory engine het plan uit. De GPU verwerkt queries die kunnen worden versneld, terwijl niet-ondersteunde queries terugvallen op de CPU.

Dit hybride uitvoermodel — waarbij GPU en CPU samen worden ingezet — maakt Polars zeer flexibel. Je profiteert van GPU-versnelling zonder compatibiliteit op te offeren voor queries die niet op de GPU worden ondersteund. De Polars releaseblogpost gaat hier dieper technisch op in.

Aan de slag met de Polars GPU-engine

Eindelijk het leukste deel! In dit hoofdstuk doorloop ik de stappen om je omgeving in te richten en te profiteren van GPU-versnelde dataverwerking.

De meest rechttoe rechtaan manier is om mee te doen met dit Google Colab-notebook. 

Colab biedt gratis, beperkte GPU-tijd, handig als je niet direct toegang hebt tot een GPU. Gebruik je het notebook, dan beginnen we vanaf stap 2 hieronder en kun je de eerdere stappen overslaan.

Vereisten

Controleer vóór de installatie van de Polars GPU-engine of je systeem voldoet aan de vereisten voor NVIDIA RAPIDS cuDF. Bekijk de benodigde specificaties, waaronder GPU-compatibiliteit en driververeisten, op de RAPIDS-documentatiepagina.

1. Maak een virtuele omgeving (aanbevolen)

Om te beginnen met de Polars GPU-engine is het best practice om een virtuele omgeving te maken en je projectafhankelijkheden te isoleren. 

Ik gebruik hiervoor conda, maar gebruik gerust je eigen pakketmanager.

Naast Python kun je JupyterLab toevoegen voor interactieve data-exploratie en -ontwikkeling, ideaal voor het draaien van kleine codefragmenten en het on-the-fly analyseren van datasets.

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

Activeer na het aanmaken van de virtuele omgeving deze met:

conda activate polars-gpu

2. Installeer de Polars GPU-engine

Laten we nu GPU-versnelling inschakelen door Polars en de GPU-engine te installeren. Dit zet ook cuDF en andere benodigde afhankelijkheden op voor gebruik van NVIDIA GPU’s:

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

Zodra de Polars GPU-engine is geïnstalleerd, voelt werken met Polars op een GPU vergelijkbaar met de CPU, maar dan met veel snellere resultaten voor complexe of data-intensieve workflows.

Zoals eerder uitgelegd optimaliseert de Polars-engine het uitvoerplan automatisch en benut hij de NVIDIA GPU volledig om bewerkingen te versnellen en geheugengebruik te minimaliseren. Voor queries die niet worden ondersteund op de GPU, heeft de Polars GPU-engine een soepele CPU-terugval, zodat de workflow ononderbroken doorgaat.

Laten we de engine aan het werk zetten met een paar simpele voorbeelden!

Een paar queries draaien met de Polars GPU-engine

Voor deze demo gebruiken we een dataset van 22 GB met gesimuleerde financiële transacties van Kaggle. NVIDIA host de dataset in een Google Cloud Storage (GCS)-bucket voor snelle downloads.

Download eerst de dataset:

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

Omdat deze dataset afkomstig is van Kaggle valt hij onder een Kaggle-dataset-specifieke licentie en gebruiksvoorwaarden.

Laten we de dataset laden met Polars en het schema bekijken:

import polars as pl
from polars.testing import assert_frame_equal

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

Hier is de output:

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)])

Nu berekenen we het totale transactievolume door de kolom AMOUNT op te tellen. Eerst zonder GPU-versnelling:

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

Output:

AMOUNT
f64
3.6183e9

Dat is een hoog totaal transactievolume! Laten we dezelfde query op de GPU draaien:

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

Output:

AMOUNT
f64
3.6183e9

Voor simpele bewerkingen als deze leveren CPU en GPU hetzelfde resultaat in vergelijkbare tijd, omdat de query niet rekenintensief genoeg is om veel profijt te hebben van GPU-versnelling. De GPU schittert bij complexere queries.

Laten we nu een complexere query doen. We groeperen transacties op klant-ID (CUST_ID), sommeren de bedragen en sorteren vervolgens op de hoogste spenders. 

Eerst draaien we hem op de CPU:

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

Hier is de output:

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

Nu draaien we dezelfde query op de 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

Output:

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

Zoals je ziet levert de GPU bij complexere queries flinke performancewinst op: de uitvoeringstijd gaat van 6,04 seconden op de CPU naar slechts 353 milliseconden op de GPU!

Dit voorbeeld laat zien hoe krachtig de Polars GPU-engine is voor grootschalige databewerkingen. 

Meer geavanceerde voorbeelden vind je in het bijbehorende Colab-notebook.

Conclusie

De Polars GPU-engine, aangedreven door NVIDIA RAPIDS cuDF, levert indrukwekkende snelheidswinsten op, met tot 13x snellere dataverwerking bij complexe bewerkingen. Voor grootschalige datasets biedt Polars een duidelijk voordeel ten opzichte van traditionele DataFrame-bibliotheken.

Hoewel niet elke query evenveel profiteert van GPU-versnelling, blijft Polars een krachtig hulpmiddel voor iedereen die met grote datasets werkt. De eenvoudige integratie, gecombineerd met het hybride CPU-GPU-uitvoermodel, maakt Polars tot een sterke kandidaat voor moderne dataworkflows.

Als je je datamanipulatievaardigheden — vooral met Pandas — wilt ontwikkelen, raad ik deze cursussen van harte aan:

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

Deze bronnen geven je een solide basis die de krachtige mogelijkheden van tools als Polars mooi aanvult!