Acelere el procesamiento de datos entre 30 y 40 veces con NVIDIA RAPIDS en TrueFoundry

‍Acelere el procesamiento de datos entre 30 y 40 veces con NVIDIA RAPIDS en TrueFoundry

Los proyectos actuales de aprendizaje automático de nivel empresarial suelen implicar el procesamiento de conjuntos de datos a gran escala, lo que plantea desafíos para los marcos tradicionales basados en CPU, como los pandas, que suelen tener problemas con los cuellos de botella de rendimiento. NVIDIA RAPIDS ofrece una solución revolucionaria, que aprovecha Paralelismo de GPU para acelerar el procesamiento de datos de forma espectacular. En este análisis técnico detallado, analizaremos cómo RAPIDS puede impulsar sus flujos de trabajo de datos de la siguiente manera 30—40 × y demuestre cómo TrueFoundry simplifica el aprovechamiento sin problemas del procesamiento de datos acelerado por la GPU.

Introducción al procesamiento de datos acelerado por GPU con NVIDIA RAPIDS

NVIDIA RAPIDS incluye varias bibliotecas clave, cada una diseñada para acelerar aspectos específicos del proceso de ciencia de datos al aprovechar la potencia de la GPU. En la siguiente tabla se ofrece una breve descripción de estos componentes principales:

Vamos a elegir una de las bibliotecas más utilizadas en las empresas para la ingeniería de datos

cuDF: marcos de datos acelerados por GPU para la preparación de datos

1. El cuDF sirve como Biblioteca GPU DataFrame, que proporciona capacidades aceleradas para tareas comunes de manipulación de datos, como cargar, unir, agregar, filtrar y transformar datos en general.
2. Su diseño ofrece una API similar a la de los pandas, que es muy familiar para los ingenieros y científicos de datos, lo que facilita una transición sin problemas a los flujos de trabajo acelerados por GPU.
3. Un avance notable es el «modo acelerador de pandas»», lo que permite la aceleración de la GPU con cambios de código mínimos o «nulos» en los flujos de trabajo de los pandas existentes.

Sin embargo, históricamente, las GPU no han sido las más fáciles de integrar en los flujos de trabajo de datos. Hablamos con los líderes de ingeniería de datos de tres empresas que queremos dirigir Rapids en producción (una empresa de tecnología financiera incluida en la lista Fortune 500, un unicornio del aprendizaje en línea y una conocida plataforma de preguntas y respuestas), escuchamos el mismo estribillo: «En cada sprint descubrimos un trabajo más que se arruinó porque CUDA 11.8 se apoderó de un solo trabajador. Dos veces al mes reconstruimos nuestras cerraduras Conda. » — Director de plataforma de datos, FinTech

‍El desafío tradicional: instalar y ejecutar RAPIDS

Si alguna vez has intentado instalar RAPIDS en tu propia máquina o en una instancia de nube genérica, sabes que puede ser doloroso. RAPIDS tiene dependencias de versión específicas (versiones del kit de herramientas CUDA, versiones exactas de Python y de biblioteca, etc.), lo que significa que una combinación incorrecta puede provocar errores crípticos.

Esto es factible, pero está lejos de ser sencillo: la configuración del entorno puede llevar mucho tiempo y mezclar RAPIDS con otros paquetes de Python puede provocar fácilmente conflictos de dependencia. De hecho, el mantenimiento de un archivo requirements.txt para RAPIDS a menudo requiere anclarlo versiones muy específicas de NumPy, pandas, scikit-learn, etc., y las discrepancias pueden romper tu código. Toda esta sobrecarga de configuración es una barrera si su objetivo es simplemente acelerar el procesamiento de datos.‍

Uso de Google Collab

Google Colab ofrece la integración con RAPIDS. Los tiempos de ejecución de GPU de Colab proporcionan controladores y versiones CUDA compatibles, lo que elimina la configuración manual. Mientras `! pip install rapids-cuda12.0` sigue siendo necesario. Colab gestiona las dependencias, lo que permite un uso rápido de cuDF y CuML acelerados por GPU sin instalaciones locales complejas.

Sin embargo, la mayoría de las veces, los sistemas de aprendizaje automático de nivel empresarial requieren algo más que un IDE de codificación, que no proporciona.

‍La aceleración de la GPU es más fácil en TrueFoundry

TrueFoundry aborda estas barreras tradicionales, lo que hace que RAPIDS sea fácil de usar y administrar:

Entornos de GPU preconfigurados: TrueFoundry proporciona un entorno gestionado del kit de herramientas NVIDIA CUDA 12.x. Solo necesita ejecutar este portátil y pip install rapids <cuda version>

Aprovisionamiento de GPU bajo demanda: Seleccione fácilmente las GPU (in situ o bajo demanda) directamente desde la interfaz de TrueFoundry. La plataforma administra automáticamente las instalaciones de los controladores y las configuraciones de dependencias.

Integración con Docker: Las imágenes de Docker prediseñadas con RAPIDS permiten un acceso inmediato sin gastos de instalación.

El entorno integrado de TrueFoundry permite a los científicos de datos crear prototipos, desarrollar e implementar rápidamente canalizaciones aceleradas por GPU.

Optimización de hiperparámetros ha sido difícil de implementar en aplicaciones prácticas debido a los recursos necesarios para ejecutar tantos trabajos de capacitación distintos. También puedes ejecutar HPO usando Nvidia Rapids como Empleos en Truefoundry.

Ejemplo de extremo a extremo: Pandas contra cuDF en aproximadamente 1 mil millones de filas de taxis de Nueva York

A continuación se muestra el cuaderno exacto que utilizamos en TrueFoundry para encontrar el promedio promedio

import os, time, urllib.request
from pathlib import Path
import pandas as pd
import cudf
import dask_cudf
from dask.distributed import Client
from dask_cuda import LocalCUDACluster

# ----- CONFIG -------
MONTHS = pd.date_range("2018-01-01", "2021-07-01", freq="MS").strftime("%Y-%m").tolist()
DATA_DIR = Path("data")               # where Parquet files will live
REPEATS  = 3                         
TS_COL   = "tpep_pickup_datetime"
VAL_COL  = "total_amount"
BASE_URL = "https://d37ci6vzurychx.cloudfront.net/trip-data/"

‍ Cargar el conjunto de datos

def ensure_data():
    DATA_DIR.mkdir(exist_ok=True)
    files = []
    for m in MONTHS:
        fname = f"yellow_tripdata_{m}.parquet"
        out   = DATA_DIR/fname
        if not out.exists():
            url = BASE_URL + fname
            print(f"Downloading {fname} …")
            urllib.request.urlretrieve(url, out)
        files.append(str(out))
    return files
files = ensure_data()
print(f"→ {len(files)} files ready (≈{len(files)*23:,} M rows total)")

‍Definición del flujo de trabajo de Pandas

def pandas_workflow(files):
    dfs = [pd.read_parquet(f) for f in files]
    pdf = pd.concat(dfs, ignore_index=True)
    pdf["day"] = pd.to_datetime(pdf[TS_COL]).dt.date 
    return pdf.groupby("day")[VAL_COL].mean().max()

Ejecución en GPU: flujo de trabajo Dask + cUDF

# <code:dask-cudf-workflow>
from dask.distributed import Client
from dask_cuda import LocalCUDACluster
import dask_cudf, cudf

def dask_cudf_workflow(files):
    cluster = LocalCUDACluster()
    client  = Client(cluster)
    print("▶ Running on", len(client.ncores()), "GPU(s)")
    
    ddf = dask_cudf.read_parquet(files)
    ddf["day"] = ddf[TS_COL].dt.floor("D")
    # compute group→mean→max across the cluster
    result = (
        ddf
        .groupby("day")[VAL_COL]
        .mean()
        .max()
        .compute()
    )
    client.close()
    cluster.close()
    return result

Resultados

Incluso en una sola GPU, ya teníamos tiempos de ejecución inferiores a 10 segundos; al añadir GPU con Dask, se obtenía un escalado casi lineal hasta la saturación de la red.
Esto supone un aumento de 37 veces la productividad sin cambiar ni una sola línea de lógica empresarial. ¿Está preparado para reducir sus tiempos de procesamiento de minutos a segundos? Crea un cuaderno RAPIDS en TrueFoundry y comprueba la diferencia.

Más allá de la velocidad: escalabilidad y flujos de trabajo listos para la producción

La velocidad es fantástica, pero igual de importante es cómo integrar estos flujos de trabajo de GPU en su plataforma de datos general. Estas son algunas de las ventajas adicionales de usar RAPIDS en TrueFoundry:

• Escalado de múltiples GPU — Lance un clúster Dask-cudf en dos o más GPU con una sola especificación de trabajo. TrueFoundry aprovisiona el planificador y los trabajadores de forma automática, lo que proporciona ganancias de rendimiento casi lineales en conjuntos de datos que superan la memoria de una sola GPU.
  
  
• Promoción de oleoductos sin interrupciones — El mismo código de bloc de notas se puede convertir en un trabajo por lotes programado o incorporarse a un flujo de trabajo más amplio a través de la interfaz de usuario de TrueFoundry. La coherencia del entorno elimina la diferencia entre la exploración y la producción según la idea de que «funciona de forma local».
  
  
• Asignación de GPU rentable — Solicite GPU puntuales o bajo demanda, defina reglas de escalado automático y combine las etapas de CPU y GPU en una canalización. Los recursos se liberan cuando están inactivos, lo que garantiza que solo pagues por la aceleración que utilices.
  
  
• Observabilidad integrada — Los paneles de la plataforma muestran las métricas de uso de la GPU, el consumo de memoria, el rendimiento y los errores y la latencia, con enlaces de alerta para un ajuste proactivo y una planificación de la capacidad.

En conclusión, TrueFoundry cierra la brecha entre probar RAPIDS en sus datos e implementarlo de manera sólida y escalable. Obtendrá lo mejor de ambos mundos: aceleraciones extremas de NVIDIA RAPIDS y el fiabilidad y facilidad de uso de una plataforma gestionada.