Quanto do Seu Fluxo de Data Science Já Roda em GPU? Parte 1: Preparação de Dados

Quanto do seu fluxo de trabalho em Data Science já pode rodar em GPU?

Grande parte da discussão sobre GPUs gira em torno de deep learning e grandes modelos de linguagem. Mas muitos cientistas de dados ainda passam a maior parte do tempo trabalhando com dados tabulares — e esses fluxos tradicionalmente rodam em CPU. A boa notícia: em 2026, a aceleração por GPU já está disponível em praticamente toda a stack de data science em Python, muitas vezes sem nenhuma mudança de código.

Neste primeiro artigo de uma série, exploramos como acelerar a preparação de dados — a etapa que mais consome tempo no dia a dia de um cientista de dados — usando GPUs.

cuDF: pandas com esteroides de GPU

Se você trabalha com pandas, o cuDF (parte do conjunto RAPIDS da NVIDIA) oferece uma API praticamente idêntica, mas executando operações na GPU. A sintaxe é familiar para quem já usa pandas:

import cudf
df_gpu = cudf.read_parquet("dados.parquet")
df_gpu.info()

Uma vez que os dados estão na memória da GPU, operações como groupby, agregações e joins rodam com aceleração significativa. Em benchmarks com 9-10 milhões de linhas do dataset NYC Yellow Taxi, as operações em GPU mostraram ganhos expressivos de velocidade.

A movimentação entre CPU e GPU é simples:

# GPU → CPU
df_cpu = df_gpu.to_pandas()

# CPU → GPU
df_gpu = cudf.from_pandas(df_cpu)

cudf.pandas: zero mudanças de código

Para quem tem pipelines existentes em pandas, o cudf.pandas é um acelerador que funciona como um drop-in. Basta uma linha no início do script:

%load_ext cudf.pandas
import pandas as pd  # agora acelerado por GPU!

Cada operação é primeiro tentada na GPU via cuDF. Se não for suportada, o sistema automaticamente faz fallback para pandas na CPU. O profiler integrado mostra exatamente quais operações rodaram em GPU e quais caíram para CPU:

%%cudf.pandas.profile
resultado = df.groupby("categoria").valor.mean()

Isso significa que bibliotecas como Plotly Express continuam funcionando sem modificações — os dados processados na GPU são passados diretamente para visualização.

Polars com engine GPU

O Polars já é conhecido por seu engine de DataFrame rápido. Agora, com o engine GPU alimentado por cuDF, você pode ativar aceleração com uma única flag:

query = pl.scan_parquet("dados.parquet") \
    .group_by("categoria") \
    .agg(pl.col("valor").sum())
    
resultado = query.collect(engine="gpu")

Se a query contiver operações não suportadas, o Polars automaticamente faz fallback para CPU. Para múltiplas GPUs, o RayEngine escala automaticamente:

from cudf_polars.engine.ray import RayEngine
with RayEngine() as engine:
    resultado = query.collect(engine=engine)

Quando a GPU realmente vale a pena

Os benchmarks mostram que GPUs são mais úteis para operações pesadas: filtros, joins, agregações groupby e ordenação. Para datasets pequenos, a CPU geralmente é tão rápida quanto — a sobrecarga de mover dados para a GPU pode anular o ganho.

A boa notícia é que bibliotecas como cuDF e cudf.pandas eliminam a necessidade de reescrever bases de código inteiras. Você pode alternar entre GPU e CPU conforme a carga de trabalho, gastando menos tempo esperando queries terminarem e mais tempo resolvendo problemas reais.

No próximo artigo da série, vamos explorar a aceleração por GPU para bibliotecas de machine learning e ver quanto código realmente precisa mudar para acelerar o treinamento de modelos.