Workstations · Datos
Ciencia de datos y analítica: RAM, GPU para DataFrames y SSD
Cuánta RAM necesita de verdad un DataFrame, por qué pandas usa un núcleo y Polars y DuckDB todos, cuándo cuDF en GPU compensa y qué pasa cuando el dataset no cabe en memoria.
Un análisis de datos casi nunca calcula mucho: mueve mucho. Filtrar, agrupar, unir y ordenar tablas consiste en recorrer columnas enteras haciendo una operación trivial por elemento, así que el hardware que manda es el que mueve bytes, no el que multiplica. Eso convierte la RAM en la primera cifra a mirar, el ancho de banda de memoria en la segunda, el SSD en la red de seguridad cuando la tabla no cabe, y la GPU en un caso particular que compensa solo cuando el dataset cabe en la VRAM. Este artículo cubre pandas, Polars, DuckDB, RAPIDS cuDF, XGBoost y LightGBM con esa lente.
Qué hace un DataFrame con el hardware
Una tabla en memoria es un conjunto de columnas contiguas. Un groupby con una suma lee cada valor una vez, lo suma a un acumulador y lo olvida: una operación por cada 8 bytes leídos, o menos. Un join es peor, porque además salta por una tabla hash que no cabe en caché. La intensidad aritmética de todo esto ronda 0,1 operaciones por byte, muy por debajo del punto de cruce de cualquier CPU moderna en el modelo roofline. El programa está limitado por memoria desde la primera fila.
Por eso el tamaño del dataset en bytes es la cifra de partida de cualquier decisión de compra, y se calcula a mano.
Tamaño de una tabla en memoria (formato columnar, sin overhead)
bytes = filas × Σ bytes por columna (int64/float64 = 8 · int32/float32 = 4 · categoría = 1-4 · string = longitud + 4)
100 M filas × (8 col × 8 B + 2 col × 4 B) = 7,2 GB
Cien millones de filas con ocho columnas float64 y dos int32 ocupan 100 000 000 × 72 B = 7,2GB. Las cadenas rompen la cuenta: en Arrow (Polars, DuckDB, pandas con dtype string[pyarrow]) una columna de texto ocupa sus bytes UTF-8 más un offset de 4 bytes por fila; en pandas clásico con object, cada celda es un objeto Python de 50 bytes o más. Una columna de textos de 10 caracteres cuesta 1,4 GB en Arrow y más de 6 GB en pandas clásico para las mismas cien millones de filas.
Sobre ese tamaño base se apilan las copias temporales. Ordenar necesita una segunda copia. Un merge materializa las claves y el resultado. Un apply con funciones Python crea un objeto por fila. La memoria de pico de un análisis es varias veces la del dataset, y cuánto exactamente depende del motor.
RAM: la cifra que manda
Wes McKinney, creador de pandas, escribió en 2017 la regla que sigue vigente para su biblioteca: conviene tener entre 5 y 10 veces la RAM del tamaño del dataset. Su ejemplo: 10 GB de datos piden 64-128 GB de RAM. Las causas son las que acabamos de ver: cadenas como objetos Python (la cadena 'wes' ocupa 52 bytes), fragmentación del heap, temporales que duplican o triplican la huella, y el BlockManager interno que consolida columnas copiándolas.
Polars y DuckDB usan Arrow o formatos columnares propios, tipos compactos y ejecución en streaming: la huella típica es de 1 a 3 veces el dataset, y ambos pueden derramar operaciones al disco cuando se pasan. Con ellos la regla de McKinney se relaja, pero la RAM sigue siendo el techo del tamaño de la tabla que puedes tener cómodamente en memoria a la vez, que es lo que define la experiencia en un notebook.
RAM orientativa para un dataset de 10 GB
Barras en el punto medio de cada rango. La cifra real depende de cuántas columnas de texto y cuántas copias intermedias haga tu código.
La consecuencia práctica en septiembre de 2026 es incómoda. La DDR5 ronda los 13-18 $/GB en retail y un kit de 32 GB DDR5-6000 cuesta unos 400 $, tras subidas de hasta un 500 % en doce meses por el desvío de obleas a HBM. Pasar de 64 a 128 GB en un sobremesa cuesta hoy lo que hace dos años costaba la CPU. Aun así, es la ampliación con más retorno para quien vive en pandas: cada gigabyte que falta se paga en swapping, en MemoryError y en tiempo del analista.
Núcleos: uno, o todos
pandas ejecuta cada operación en un hilo. Polars y DuckDB reparten cada consulta entre todos los núcleos y, además, la planifican: reordenan filtros, proyectan solo las columnas necesarias y encadenan operaciones sin materializar intermedios. La combinación de ambas cosas produce diferencias de dos órdenes de magnitud en el mismo hardware.
PDS-H SF-10 · tiempo total, menos es mejor
Benchmark publicado por Polars: la configuración de los competidores la eligió una de las partes. A escala 100, DuckDB (19,65 s) y Polars streaming (23,94 s) cambian el orden y pandas queda fuera por tiempo.
Que el reparto entre núcleos funcione no significa que los núcleos escalen sin límite. Como en simulación, todos los hilos comparten el mismo grifo de memoria. Un Ryzen 9 9950X con dos canales DDR5-5600 tiene 89,6GB/s para 16 núcleos: 5,6 GB/s por núcleo. Un Threadripper 9980X con cuatro canales DDR5-6400 tiene 204,8GB/s para 64 núcleos: 3,2 GB/s por núcleo. En un groupby sobre columnas numéricas la segunda máquina va más rápido, pero no cuatro veces más; los hilos extra acaban esperando a la DRAM. Un Threadripper PRO 9995WX con ocho canales (409,6GB/s) sí escala, y además admite hasta 2 TB de RDIMM ECC, que es la verdadera razón de comprarlo para datos: la tabla cabe.
| Equipo | Núcleos | Hilos | Canales | MT/s | Ancho de banda (GB/s) | L3 (MB) | Lanes PCIe |
|---|---|---|---|---|---|---|---|
| AMD Ryzen 9 9950X | 16 | 32 | 2 | 5 600 | 89,6 | 64 | 24 |
| Intel Core Ultra 9 285K | 24 | 24 | 2 | 6 400 | 102 | 36 | 20 |
| AMD Ryzen Threadripper 9970X | 32 | 64 | 4 | 6 400 | 205 | 128 | 80 |
| AMD Ryzen Threadripper 9980X | 64 | 128 | 4 | 6 400 | 205 | 256 | 80 |
| AMD Ryzen Threadripper PRO 9995WX | 96 | 192 | 8 | 6 400 | 410 | 384 | 128 |
| Apple M4 Max (16 núcleos CPU / 40 GPU) | 16 | 16 | 8 | 8 533 | 546 | — | — |
Núcleos, canales y ancho de banda de RAM de las plataformas habituales para analítica (fuente: src/data/cpus.json).
El Apple M4 Max merece una nota. Con 546GB/s de memoria unificada y hasta 128 GB, un groupby en Polars sobre una tabla de 40 GB va, en teoría, seis veces más deprisa que en un sobremesa con dos canales. En la práctica el sistema, el navegador y el kernel del notebook se comen parte de esos 128 GB, y no hay ampliación posible después de la compra.
GPU para DataFrames: cuDF y el techo de la VRAM
RAPIDS cuDF ejecuta las operaciones de pandas y Polars en la GPU. Con cudf.pandas no cambias código: el módulo intercepta las llamadas, las ejecuta en GPU cuando puede y vuelve a pandas en CPU cuando no (un apply con una función Python arbitraria, por ejemplo). La aceleración viene de dos sitios. El primero es el ancho de banda: una RTX 5090 mueve 1 792GB/s frente a los 89,6GB/s de un sobremesa, veinte veces más. El segundo son los miles de hilos que barren una columna en paralelo. Para una carga limitada por memoria, el primero es el que cuenta.
El techo es la capacidad. La tabla y sus intermedios tienen que caber en la VRAM: 16 GB en una RTX 5070 Ti o 5080, 32 GB en una 5090, 96 GB en una RTX PRO 6000 Blackwell. Con la regla de 2-3× de huella para un motor columnar, una 5090 trabaja cómoda con tablas de 10-15 GB; una RTX PRO 6000, con tablas de 30-45 GB. Por encima, cuDF puede usar memoria gestionada (managed memory) y paginar contra la RAM del sistema por PCIe, y entonces el ancho de banda efectivo cae a los 63 GB/s del bus, por debajo de una CPU con cuatro canales.
Coste de mover la tabla a la GPU
segundos = bytes ÷ ancho de banda PCIe por sentido
7,2 GB ÷ 63 GB/s (PCIe 5.0 ×16) = 0,11 s
La tabla de 7,2 GB del primer ejemplo tarda 0,11 s en subir a una RTX 5090 por PCIe 5.0 ×16; por PCIe 4.0 ×16 (31,5GB/s por sentido), 0,23 s. Un groupby sobre esa tabla en CPU a 89,6 GB/s tarda del orden de 0,08 s por pasada; en GPU a 1 792 GB/s, 0,004 s. La GPU solo gana si la tabla se queda en VRAM y encadenas muchas operaciones sobre ella. Subirla, hacer una operación y bajarla es más lento que no moverla.
Cuando el dataset no cabe: NVMe y formatos columnares
Hay dos maneras de trabajar con una tabla mayor que la RAM. La primera es leer solo lo necesario: los formatos columnares como Parquet guardan cada columna aparte, con estadísticas por bloque, de modo que una consulta que usa tres columnas de cincuenta y filtra por fecha lee del disco un 5 % del fichero. La segunda es procesar en streaming: Polars (motor streaming) y DuckDB recorren el fichero por trozos y derraman al disco los operadores que necesitan ver todos los datos a la vez. DuckDB documenta cuáles: GROUP BY, JOIN, ORDER BY y las funciones de ventana; y avisa de que dos de esos operadores bloqueantes en la misma consulta pueden agotar la memoria igualmente. Por defecto se limita a una fracción de la RAM del sistema (del orden del 80 %, cifra aproximada) y usa un directorio temporal en disco para el resto.
Con el derrame activo, el SSD sustituye a la RAM, y la relación de velocidades es la que decide cuánto tarda.
Tiempo de una pasada completa sobre el fichero
segundos = tamaño del fichero ÷ lectura secuencial
100 GB ÷ 7,45 GB/s (990 PRO) = 13,4 s · 100 GB ÷ 89,6 GB/s (RAM) = 1,1 s
Un Parquet de 100 GB se recorre entero en 13,4 s desde un NVMe PCIe 4.0 y en unos 7 s desde uno PCIe 5.0 (14 500 MB/s). Desde RAM, 1,1 s. El disco es doce veces más lento que la memoria, pero doce veces más lento que un segundo es asumible; lo que no es asumible es multiplicar ese coste por cada JOIN que derrama. Y ese caudal solo se alcanza con lecturas secuenciales grandes: un motor columnar las hace, un acceso fila a fila no.
Tiempo de recorrer el dataset entero
- NVMe PCIe 4.0 (7,45 GB/s)
- NVMe PCIe 5.0 (14,5 GB/s)
- RAM 2 canales (89,6 GB/s)
- RAM 8 canales (409,6 GB/s)
Dos matices sobre el disco. El primero: el CSV no es un formato de trabajo. Parsear texto es una carga de CPU, no de disco, y un CSV de 10 GB tarda más en leerse que un Parquet de 3 GB con los mismos datos (la compresión de Parquet frente a CSV suele quedar entre 3 y 10×, según los tipos, cifra orientativa). Convierte una vez y trabaja siempre sobre Parquet o Arrow. El segundo: el derrame escribe además de leer, y la escritura sostenida de un NVMe cae a 1,5-2 GB/s cuando se agota la caché SLC (ver almacenamiento). Un SSD de 4 TB con DRAM propia y buena escritura sostenida es mejor disco temporal que uno de 1 TB muy rápido en la caja.
XGBoost y LightGBM: donde la GPU sí decide
El entrenamiento de gradient boosting es distinto de la manipulación de tablas. El algoritmo hist construye histogramas de gradientes por característica y por nodo, miles de veces, y ese trabajo sí se reparte bien entre los miles de hilos de una GPU. En XGBoost se activa con device="cuda" y tree_method="hist"; LightGBM tiene su propio backend CUDA. Las ganancias típicas frente a una CPU de sobremesa son de un orden de magnitud en datasets de millones de filas, aunque ni la documentación de XGBoost ni la de LightGBM publican una cifra oficial con hardware nombrado: mídelo con tus datos.
La VRAM vuelve a ser el límite, y aquí las cuentas son más favorables. XGBoost guarda la matriz en formato ELLPACK cuantizado, que ocupa alrededor de una cuarta parte del CSR en punto flotante según su documentación; QuantileDMatrix construye esa representación directamente sin pasar por la copia intermedia, y un iterador de datos permite entrenar con matrices mayores que la VRAM a costa de tráfico por PCIe. Un dataset de 50 millones de filas y 100 características en float32 son 20 GB en bruto y unos 5 GB cuantizados: cabe en una RTX 5070 Ti de 16 GB con margen para los histogramas.
Para inferencia de modelos ya entrenados, y para scikit-learn en general, la GPU aporta poco: los modelos lineales, los árboles individuales y la mayor parte del preprocesado son cargas de un solo hilo o de memoria, donde vuelve a mandar la CPU con buena frecuencia y buen ancho de banda.
Notebooks: la RAM se gasta dos veces
Un notebook de Jupyter mantiene vivo el kernel con todas las variables que has ido creando: el DataFrame original, la copia filtrada, el resultado del merge, la figura que renderizaste hace una hora. Nada se libera hasta que borras la referencia o reinicias. Es habitual que un análisis sobre 8 GB de datos ocupe 40 GB de RAM en el kernel sin que ninguna operación individual necesite más de 16. Añade el navegador, VS Code o JupyterLab con su servidor, y un segundo kernel abierto para otra cosa.
Esto tiene dos consecuencias de compra. La primera es que la regla de 3× o 6× del apartado de RAM es por kernel, y en la práctica trabajas con dos. La segunda es que un solo hilo rápido importa: mucho código de notebook es Python puro (bucles, apply, matplotlib), y ahí una CPU con 5,7 GHz de boost y buena L3, como el Ryzen 9 9950X o el Core Ultra 9 285K, responde mejor que un Threadripper de 64 núcleos a 3,2 GHz de base. Un 9950X3D con 128 MB de L3 acelera además las tablas hash de los join medianos.
Cuándo no hace falta GPU
Para la mayor parte del trabajo de analítica, no. Si tus tablas caben en RAM y usas Polars o DuckDB, la CPU con todos sus núcleos y dos canales DDR5 recorre 10 GB en un décimo de segundo; la GPU lo haría en cinco milésimas, y el analista no notará la diferencia porque el cuello de botella es él. La GPU compensa en tres casos concretos: entrenamiento de gradient boosting sobre millones de filas, cadenas largas de operaciones sobre una tabla que cabe en VRAM y que ejecutas muchas veces (un pipeline de features que corre cada noche), y deep learning, que ya es otro artículo.
Lo que debes recordar
- La analítica está limitada por memoria: manda la RAM (capacidad) y después el ancho de banda; los FLOPS no cuentan.
- pandas necesita 5-10× el tamaño del dataset en RAM; Polars y DuckDB, 1-3×, y usan todos los núcleos. En PDS-H SF-10 pandas tarda 94 veces más que Polars streaming en la misma máquina.
- cuDF acelera por el ancho de banda (1 792 frente a 89,6 GB/s), pero el dataset y sus intermedios tienen que caber en la VRAM; compara siempre contra Polars o DuckDB, no contra pandas.
- Cuando la tabla no cabe: Parquet, streaming y un NVMe grande con buena escritura sostenida. Una pasada de 100 GB cuesta 13 s desde PCIe 4.0 y 1 s desde RAM.
- XGBoost y LightGBM en GPU son el caso donde una tarjeta de 16 GB sí cambia el día; para el resto de scikit-learn, no.
Para mirar en una ficha técnica
- Capacidad máxima de RAM y número de módulos: en sobremesa, 128 GB con dos módulos de 64 GB a velocidad plena; 192 GB con cuatro. Trampa: con cuatro módulos AMD baja a DDR5-3600 oficial, y pierdes ancho de banda.
- Canales de memoria y MT/s: dos en sobremesa, cuatro en Threadripper, ocho en PRO y Xeon W. Trampa: 64 núcleos con cuatro canales rinden menos de lo que sugieren en
groupby. - VRAM en GB: es el techo de cuDF y de XGBoost en GPU. Trampa: «hasta 150× más rápido» se mide contra pandas de un hilo.
- Escritura sostenida y caché SLC del NVMe: el derrame a disco escribe; la cifra de la caja no dura. Trampa: un disco DRAM-less QLC baja de 500 MB/s cuando se llena la caché.
Fuentes
- Polars — PDS-H benchmark results (junio de 2025) — tiempos totales SF-10 y SF-100 de Polars, DuckDB, Dask, PySpark y pandas en AWS c7a.24xlarge.
- Wes McKinney — Apache Arrow and the «10 Things I Hate About pandas» (2017) — regla de 5-10× de RAM, 52 bytes por cadena
'wes', temporales y BlockManager. - NVIDIA — cudf.pandas, documentación — modo de aceleración sin cambiar código y fallback a CPU.
- XGBoost — GPU Support — parámetros
device="cuda"ytree_method="hist", formato ELLPACK (~1/4 del CSR),QuantileDMatrixe iteradores de datos. - DuckDB — How to Tune Workloads — operadores que derraman a disco (
GROUP BY,JOIN,ORDER BY, ventana), directorio temporal y límite de varios operadores bloqueantes. - Samsung 990 PRO — especificaciones — 7 450 MB/s de lectura secuencial (vía el artículo de almacenamiento del sitio).
- Fichas de AMD (Ryzen 9 9950X, Threadripper 9970X/9980X, Threadripper PRO 9995WX), Intel (Core Ultra 9 285K), Apple (M4 Max) y NVIDIA (RTX 5090, RTX PRO 6000 Blackwell) recogidas en
src/data/cpus.json,gpus.json,memory-tech.jsoneinterconnects.json, con sus notas de origen.