Mulai Menggunakan Akselerasi GPU Polars: Kueri 13x Lebih Cepat

Memahami Integrasi NVIDIA RAPIDS cuDF

Permintaan untuk pemrosesan dan analisis data yang lebih cepat meningkat pesat dalam beberapa tahun terakhir seiring dataset berkembang hingga ratusan juta bahkan miliaran baris. Untuk mengatasi tantangan ini, bidang data science semakin beralih dari pemrosesan berbasis CPU tradisional ke komputasi yang dipercepat GPU. Di sinilah NVIDIA RAPIDS cuDF berperan.

NVIDIA RAPIDS adalah rangkaian pustaka open-source yang memungkinkan data science dan analitik dipercepat GPU. Intinya, RAPIDS dirancang untuk menyederhanakan alur kerja data dengan memanfaatkan paralelisme masif GPU NVIDIA guna mempercepat tugas-tugas yang biasanya terikat CPU. 

Di dalam RAPIDS, cuDF adalah pustaka yang bertanggung jawab atas operasi DataFrame. cuDF memperluas abstraksi DataFrame yang familier ke memori GPU, sehingga dapat diintegrasikan ke alur kerja data tanpa perubahan kode yang ekstensif. Pustaka ini mendukung semua operasi kunci yang dilakukan data scientist pada DataFrame: pemfilteran, agregasi, penggabungan, dan pengurutan—semuanya didukung GPU untuk kecepatan.

NVIDIA dan Polars baru saja mengumumkan rilis open beta untuk mesin GPU Polars di Python, didukung oleh RAPIDS cuDF. Fitur baru ini menandai lompatan besar untuk pemrosesan data berkinerja tinggi, menghadirkan alur kerja hingga 13x lebih cepat bagi pengguna Polars dengan GPU NVIDIA!

Desain tingkat tinggi API Polars, termasuk mesin GPU. Sumber gambar: Polars

Dengan tambahan mesin GPU, pengguna Polars dapat memilih mesin mana yang akan menjalankan beban kerja data mereka. Optimizer Polars mendukung semua mesin, secara dinamis menentukan kueri mana yang dapat dieksekusi di GPU atau CPU.

Mesin GPU Polars: Pengubah Permainan

Sekarang Anda sudah memahami konteks Polars dan pustaka NVIDIA RAPIDS cuDF serta bagaimana keduanya terintegrasi dan tersedia melalui API Polars di Python. Lalu apa artinya ini bagi developer dan data scientist?

Berikut ringkasan kemampuan yang dihadirkan mesin GPU Polars:

• Integrasi dengan Python Polars Lazy API: Pengguna cukup meneruskan engine="gpu" ke operasi collect() di Lazy API Polars, sehingga pemrosesan GPU aktif tanpa perubahan kode yang signifikan.
• Pemrosesan interaktif untuk dataset besar: Mesin GPU dirancang agar pemrosesan ratusan juta baris data terasa interaktif. Dengan satu GPU, Anda dapat menangani volume data masif yang biasanya memerlukan solusi lebih kompleks dan lebih lambat.
• Dioptimalkan untuk efisiensi: Mesin GPU Polars sepenuhnya memanfaatkan optimizer Polars untuk memastikan eksekusi seefisien mungkin, meminimalkan waktu pemrosesan dan penggunaan memori.
• Fallback CPU yang mulus: Jika ada kueri tertentu yang belum didukung di GPU, mesin ini menyertakan fallback ke CPU. Hal ini memastikan alur kerja tetap berjalan, dengan otomatis beralih ke pemrosesan CPU saat diperlukan.

Lalu, bagaimana hasilnya sejauh ini? Mari kita lihat. 

Mesin GPU Polars mempercepat pemrosesan data hingga 13x. Sumber gambar: Polars

Benchmark di atas menunjukkan kemampuan mengesankan dari mesin GPU Polars dengan mempercepat kueri hingga 13x.

Namun, penting untuk dicatat bahwa menggunakan Polars di GPU tidak selalu dijamin lebih cepat daripada di CPU, terutama untuk kueri yang lebih sederhana dan tidak intensif komputasi. Dalam kasus seperti ini, kinerja sering dibatasi oleh kecepatan membaca data dari disk, yang berarti akselerasi GPU kurang memberi keuntungan saat operasi input/output (I/O) menjadi kendala utama.

Meski demikian, mesin GPU memberikan peningkatan kecepatan yang signifikan untuk operasi data yang lebih kompleks, menjadikannya alat berharga bagi tim yang menangani dataset besar atau kueri yang melibatkan join, group-by, dan pemrosesan string.

Interaksi antara CPU dan GPU

Salah satu fitur paling menarik dari integrasi baru ini adalah fleksibilitasnya. Seperti disebutkan sebelumnya, optimizer dapat beralih antara eksekusi CPU dan GPU berdasarkan kompleksitas kueri Anda. Namun, bagaimana tepatnya transisi ini bekerja?

Polars tanpa akselerasi GPU

Saat menjalankan Polars di CPU, mesinnya mengikuti pipeline yang terstruktur dan sangat dioptimalkan untuk mengeksekusi operasi data. Proses ini kurang lebih melibatkan langkah-langkah berikut:

1. DSL (domain-specific language): Mesin Polars terlebih dahulu membuat kerangka kueri terstruktur dari kode Anda, mirip dengan pohon sintaksis bahasa pemrograman. Kerangka ini mendefinisikan urutan operasi yang ingin Anda lakukan, seperti pemfilteran, pengelompokan, dan agregasi.
2. IR (intermediate representation): Selanjutnya, Polars mengonversi kerangka kueri menjadi rencana eksekusi yang terperinci, memastikan semua operasi benar dan skema data selaras. Langkah ini menyiapkan fondasi bagaimana Polars akan memproses data.
3. Optimizer: Optimizer memperbaiki rencana eksekusi dengan menyusun ulang operasi dan menghapus langkah yang tidak perlu. Misalnya, pemfilteran dapat dipindahkan sebelum join atau agregasi untuk mengurangi ukuran dataset lebih awal. Optimisasi ini memastikan rencana seefisien mungkin sebelum dieksekusi.
4. IR yang dioptimalkan: Setelah dioptimalkan, rencana eksekusi yang telah diperbaiki difinalisasi dan siap diproses oleh mesin Polars. Rencana ini menjadi cetak biru bagaimana Polars akan menjalankan setiap operasi pada data.
5. Mesin in-memory Polars (eksekusi CPU): Terakhir, mesin in-memory Polars mengeksekusi rencana yang dioptimalkan sepenuhnya di CPU. Terlepas dari optimisasi performa tinggi Polars, langkah ini bisa memakan waktu cukup lama jika Anda bekerja dengan dataset besar, karena CPU memproses data secara berurutan atau dengan paralelisme terbatas.

Polars dengan akselerasi GPU

Saat Anda mengaktifkan akselerasi GPU dengan meneruskan engine="gpu" ke metode .collect(), prosesnya pada dasarnya tetap sama di permukaan tetapi dengan pemeriksaan dan optimisasi tambahan di balik layar untuk menentukan seberapa besar beban kerja yang dapat dialihkan ke GPU melalui cuDF:

1. DSL (domain-specific language): Sama seperti mode CPU, Polars memulai dengan membuat kerangka kueri terstruktur dari kode Anda. Kerangka ini sama baik Anda menjalankan di CPU maupun GPU, menangkap operasi yang ingin Anda lakukan.
2. IR (intermediate representation): Polars mengonversi kerangka tersebut menjadi rencana eksekusi, memeriksa kebenaran dan memastikan skema data valid. IR tetap netral pada tahap ini, karena mesin belum memutuskan apakah CPU atau GPU yang akan menangani operasi.
3. Optimizer: Optimizer bekerja seperti pada eksekusi CPU, menyusun ulang operasi agar maksimal efisien, dan menghapus langkah yang redundan. Pada titik ini, rencana masih dioptimalkan untuk eksekusi umum.
4. IR yang dioptimalkan: Rencana yang dioptimalkan difinalisasi seperti pada eksekusi CPU. Namun, dengan akselerasi GPU diaktifkan, mesin kini memeriksa apakah bagian dari rencana ini bisa dialihkan ke GPU.
5. Callback cuDF (pemeriksaan GPU): Di sinilah keajaiban terjadi! Callback cuDF menentukan apakah GPU dapat menangani rencana eksekusi. Operasi tertentu secara alami cocok untuk akselerasi GPU, sementara yang lain mungkin tidak. Callback memodifikasi rencana untuk menggunakan GPU pada operasi yang didukung.
6. Mesin in-memory Polars (eksekusi GPU dan CPU): Terakhir, mesin in-memory Polars mengeksekusi rencana tersebut. GPU menangani kueri yang dapat dipercepat GPU, sementara kueri yang tidak dapat ditangani GPU akan kembali ke CPU.

Model eksekusi hibrida ini—di mana GPU dan CPU digunakan bersama—membuat Polars sangat fleksibel. Anda mendapatkan manfaat akselerasi GPU tanpa mengorbankan kompatibilitas untuk kueri yang belum didukung di GPU. Tulisan rilis Polars menjelaskan ini dengan detail teknis yang lebih mendalam.

Memulai dengan Mesin GPU Polars

Bagian paling menarik akhirnya tiba! Pada bagian ini, saya akan memandu langkah-langkah yang diperlukan untuk menyiapkan lingkungan Anda dan mulai memanfaatkan pemrosesan data yang dipercepat GPU.

Cara paling sederhana untuk mulai adalah mengikuti notebook Google Colab ini. 

Colab menawarkan penggunaan GPU gratis terbatas, sangat berguna jika Anda belum memiliki akses GPU. Jika Anda menggunakan notebook yang disediakan, kita mulai dari langkah 2 di bawah ini, sehingga Anda bisa melewati langkah sebelumnya.

Prasyarat

Sebelum memasang mesin GPU Polars, pastikan sistem Anda memenuhi persyaratan untuk NVIDIA RAPIDS cuDF. Anda dapat meninjau spesifikasi sistem yang diperlukan, termasuk kompatibilitas GPU dan persyaratan driver, di halaman dokumentasi RAPIDS.

1. Buat lingkungan virtual (disarankan)

Untuk mulai menggunakan mesin GPU Polars, praktik terbaiknya adalah membuat lingkungan virtual untuk mengisolasi dependensi proyek Anda. 

Saya menggunakan conda untuk contoh ini, tetapi silakan gunakan pengelola paket pilihan Anda.

Selain Python, Anda dapat menyertakan JupyterLab di lingkungan untuk eksplorasi data interaktif dan pengembangan, yang sangat berguna untuk menjalankan potongan kode kecil dan menganalisis dataset secara langsung.

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

Setelah membuat lingkungan virtual, aktifkan dengan:

conda activate polars-gpu

2. Pasang mesin GPU Polars

Sekarang, mari aktifkan akselerasi GPU dengan memasang Polars dan mesin GPU. Ini juga akan menyiapkan cuDF dan dependensi lain yang diperlukan untuk menggunakan GPU NVIDIA:

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

Setelah mesin GPU Polars terpasang, menggunakan Polars di GPU akan terasa mirip dengan bekerja di CPU tetapi dengan hasil yang jauh lebih cepat untuk alur kerja yang kompleks atau berat data.

Seperti dijelaskan sebelumnya, mesin Polars secara otomatis mengoptimalkan rencana eksekusi, sepenuhnya memanfaatkan GPU NVIDIA untuk mempercepat operasi dan meminimalkan penggunaan memori. Untuk kueri yang tidak mendukung akselerasi GPU, mesin GPU Polars memiliki fallback CPU yang mulus, memastikan alur kerja tetap berjalan tanpa gangguan.

Mari kita coba mesinnya dengan beberapa contoh sederhana!

Menjalankan Beberapa Kueri dengan Mesin GPU Polars

Untuk demonstrasi ini, kita akan menggunakan dataset 22GB berisi transaksi keuangan simulasi dari Kaggle. NVIDIA meng-host dataset ini di bucket Google Cloud Storage (GCS), memastikan kecepatan unduh yang cepat.

Untuk memulai, unduh datasetnya:

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

Karena dataset ini bersumber dari Kaggle, maka tunduk pada lisensi dan ketentuan penggunaan khusus dataset Kaggle.

Mari muat dataset menggunakan Polars dan periksa skemanya:

import polars as pl
from polars.testing import assert_frame_equal

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

Berikut keluarannya:

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

Sekarang, mari hitung total volume transaksi dengan menjumlahkan kolom AMOUNT. Pertama, coba tanpa akselerasi GPU:

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

Keluaran:

AMOUNT
f64
3.6183e9

Itu total volume transaksi yang tinggi! Mari jalankan kueri yang sama di GPU:

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

Keluaran:

AMOUNT
f64
3.6183e9

Untuk operasi sederhana seperti ini, CPU dan GPU menghasilkan hasil yang sama dengan kecepatan serupa, karena kueri tidak cukup intensif komputasi untuk banyak mendapat manfaat dari akselerasi GPU. Namun, GPU akan unggul saat menangani kueri yang lebih kompleks.

Sekarang, mari beralih ke kueri yang lebih kompleks. Pada kueri ini, kita mengelompokkan transaksi berdasarkan ID pelanggan (CUST_ID), menjumlahkan total jumlah transaksi, lalu mengurutkan hasilnya berdasarkan pembelanja tertinggi. 

Pertama, kita jalankan di CPU:

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

Berikut keluarannya:

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

Sekarang, jalankan kueri yang sama di 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

Keluaran:

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

Seperti terlihat, menggunakan GPU untuk kueri yang lebih kompleks memberikan peningkatan performa yang signifikan, mengurangi waktu eksekusi dari 6,04 detik di CPU menjadi hanya 353 milidetik di GPU!

Contoh ini menunjukkan peningkatan performa yang kuat yang diberikan mesin GPU Polars untuk operasi data skala besar. 

Anda dapat menemukan contoh yang lebih lanjut di notebook Colab pendamping.

Kesimpulan

Mesin GPU Polars, didukung oleh NVIDIA RAPIDS cuDF, menghadirkan peningkatan kecepatan yang mengesankan, dengan pemrosesan data hingga 13x lebih cepat untuk operasi yang kompleks. Untuk dataset skala besar, Polars menawarkan keunggulan jelas dibanding pustaka DataFrame tradisional.

Walaupun tidak setiap kueri akan sama-sama diuntungkan dari akselerasi GPU, Polars tetap merupakan alat yang kuat bagi siapa pun yang bekerja dengan dataset besar. Kemudahan integrasi, dikombinasikan dengan model eksekusi hibrida CPU-GPU, menjadikan Polars kandidat kuat untuk alur kerja data modern.

Jika Anda tertarik mengembangkan keterampilan manipulasi data, khususnya dengan Pandas, saya sangat merekomendasikan kursus berikut:

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

Sumber-sumber ini akan memberi Anda dasar yang kuat yang melengkapi kemampuan tangguh dari alat seperti Polars!