Benchmarking Scientific Python Libraries: rendimiento y precisión

No existe una única biblioteca científica de Python «mejor». La elección correcta depende de su tarea, su escala de datos y su hardware. El uso de NumPy para cargas de trabajo de GPU, o JAX para pequeñas operaciones de marco de datos en memoria, desperdiciará el rendimiento. Por el contrario, alcanzar a Cupy para las matemáticas de matriz simple agrega complejidad sin beneficio. El ecosistema científico de Python se ha fragmentado en bibliotecas competitivas optimizadas para diferentes cargas de trabajo, y comprender qué biblioteca realmente resuelve su problema de manera eficiente es el cuello de botella que la mayoría de los investigadores nunca abordan.

Este artículo presenta datos de referencia completos que comparan Numpy, Scipy, Jax, PyTorch, Cupy, Pandas, Polars, Dask y DuckDB en todas las operaciones de matrices, procesamiento de datos, álgebra lineal, aceleración de GPU, optimización, interpolación y funciones especiales. Cada reclamo está respaldado por mediciones de tiempo publicadas de referencias reales.

Comida clave

• Jax y PyTorch dominan las operaciones de la matriz a escala — La GPU de PyTorch es hasta 50 × más rápida que Numpy para las operaciones de los elementos en tensores grandes, pero Numpy sigue siendo más rápido para las pequeñas matrices debido a la reducción de JIT y el envío Sobrecarga.
• Polares es el marco de datos en memoria más rápido: los polares son 5–30 veces más rápidos que los pandas en cargas de trabajo reales y usa una fracción de la memoria. Dask es más lento que los pandas en datos pequeños a medianos y solo es apropiado para cargas de trabajo distribuidas fuera de la memoria.
• Numpy y SciPy comparten la misma precisión numérica: ambos usan BLAS/LAPACK debajo del capó, produciendo resultados idénticos en coma flotante. La diferencia es API Surface: Scipy ofrece rutinas especializadas y una mejor estabilidad numérica para matrices mal condicionadas.
• Cupy es un puerto numpy práctico para GPU — CUPY proporciona matrices compatibles con números con cambios de código mínimos, entregando 10 a 100 × aceleraciones para matrices grandes, pero incurre en una sobrecarga de transferencia de memoria de GPU que lo hace más lento que numpy para matrices menores de ~10.000 elementos.
• Scipy sigue siendo el valor predeterminado para la optimización y las funciones especiales — Ningún competidor serio coincide con su cobertura de scipy.optimize, scipy.special y scipy.interpolate.

Operaciones de matriz: Numpy vs JAX vs PyTorch

Las operaciones de arreglos son el pan y la mantequilla de la computación científica: matemáticas de elementos, multiplicación de matriz, FFT y clasificación. Aquí es donde la aceleración de GPU y la compilación JIT hacen su diferencia más dramática.

Operaciones de elementos (elementos 1M, 100 iteraciones)

Fuente: La completa referencia de Vincent Roger de Numpy/JAX/PyTorch en cinco operaciones.

La GPU de PyTorch es aproximadamente 50 × más rápida que Numpy para las operaciones de los elementos en grandes tensores. La CPU JAX y la GPU aterrizan en tiempos esencialmente idénticos (~0,155 s) para esta carga de trabajo, lo que sugiere que las matrices no son lo suficientemente grandes para que la ruta de la GPU supere la compilación de la CPU XLA. Esto significa que la ventaja de la GPU de Jax se manifiesta principalmente a escalas más grandes o operaciones intensivas en cálculo.

Multiplicación de matriz (2000×2000, 50 iteraciones)

Las cinco configuraciones aterrizan dentro del 15% entre sí (3,4 a 4,0 s). Para la multiplicación de matrices, las diferencias de rendimiento son mínimas entre las bibliotecas. Las implementaciones de BLAS y los núcleos optimizados dominan, lo que hace que la elección de la biblioteca sea menos importante que el hardware y la configuración de BLAS.

Computación de gradiente (10.000 elementos, 20 iteraciones)

La diferenciación automática de PyTorch es 1000 × más rápida que calcular gradientes a través de la diferencia finita con NumPy. Esta es la diferencia entre el cálculo del gradiente analítico y la aproximación numérica, una ventaja arquitectónica fundamental para cualquiera que realice problemas de optimización o inversa.

FFT (elementos de 1M, 50 iteraciones)

La GPU de PyTorch es aproximadamente 43× más rápida que Numpy para FFT. La CPU JAX y la GPU vuelven a converger con un tiempo idéntico, lo que confirma el patrón visto con las operaciones de elementos. El FFT de Numpy sigue siendo competente para los flujos de trabajo solo de CPU, pero las bibliotecas aceleradas por GPU dominan a escala.

Clasificación (1M elementos, 50 iteraciones)

La clasificación es donde la implementación de la CPU PyTorch es claramente más débil: 9.5× más lenta que la CPU Numpy. Esta es una debilidad de implementación específica en la ruta de clasificación de CPU de PyTorch, no una limitación fundamental. La GPU de PyTorch domina la clasificación (0,054 s), pero la CPU PyTorch es un valor atípico entre todas las operaciones probadas.

Lo que recomendamos para las operaciones de matrices

Si sus matrices superan los 100 000 elementos y tiene acceso a GPU, utilice GPU PyTorch o GPU JAX para matemáticas, FFT y clasificación en cuanto a elementos. Si necesita cálculo de gradiente (por ejemplo, para optimización o análisis de sensibilidad), el autodiff de PyTorch es de orden de magnitud más rápido que la diferencia finita manual.

Para pequeños arreglos o entornos de CPU, numpy sigue siendo la opción más simple y confiable. La brecha de rendimiento entre las bibliotecas Numpy y las compiladas JIT es despreciable para matrices de ~10 000 elementos.

Procesamiento de datos: Pandas vs Polars vs Dask vs DuckDB

Las operaciones de DataFrame dominan el flujo de trabajo de discusión de datos en Python científico: filtrado, agrupación, agregación y unión de datos de simulación tabulares. El paisaje aquí ha cambiado drásticamente desde 2024.

Operaciones CSV en 10m filas

Fuente: StatusNeo Benchmark de las operaciones CSV de 10M-fila.

Polars es 2,9 × más rápido en lectura y 11,6 × más rápido en escritura que pandas en CSV de 10 m. Dask es más lento que los pandas al escribir (46,55 s frente a 35,32 s) debido a la sobrecarga de partición. La lectura de Dask es aproximadamente equivalente a pandas, lo que confirma que el valor de Dask está estrictamente en una escala de memoria insuficiente.

Filtrado a gran escala (csv de 9 GB, 67 m de filas)

Fuente: Benchmark codecéntrico con una metodología detallada que incluye ejecuciones en frío/caliente y perfiles de memoria.

En el filtrado a gran escala con filas de 67M y 9 GB de datos, los polares con streaming Lazy + streaming utiliza una memoria de pico de ~0,5 GB. Pandas carga todo el conjunto de datos (~14 GB) y DuckDB (un motor SQL) usa ~0,3 GB. Los polares casi coinciden con DuckDB en ejecución en caliente a pesar de que DuckDB es una base de datos SQL: la brecha se reduce a ~100 MB de diferencia de memoria máxima.

Operaciones de clasificación

Polars aprovecha la paralelización y el diseño de la memoria de Arrow para ofrecer aceleraciones Los pandas fundamentalmente no pueden coincidir en las operaciones de clasificación. Pandas de un solo hilo es un cuello de botella bien documentado.

Cuándo elegir qué biblioteca de DataFrame

Lo que recomendamos para el procesamiento de datos

Para el procesamiento de datos en memoria, use Polars. Las aceleraciones (5–30 ×), el ahorro de memoria y la eficiencia energética son reales y documentadas. Polars with Lazy + Streaming coincide con el tiempo de ejecución de DuckDB en carreras calientes mientras mantiene la ergonomía similar a los pandas.

Dask solo es apropiado para cargas de trabajo distribuidas fuera de la memoria. Si su conjunto de datos encaja en la memoria, Dask será más lento que los polares y, a menudo, más lento que los pandas debido a la sobrecarga de partición. El Benchmark StatusNeo muestra explícitamente Dask Writing CSV en 46.55 S vs Pandas 35.32 S — DAsk no es una optimización del rendimiento para las cargas de trabajo en memoria.

Álgebra lineal: numpy vs scipy

El álgebra lineal es donde ambas bibliotecas comparten el mismo backend BLAS/LAPACK pero divergen en la superficie API, la estabilidad numérica y las rutinas especializadas.

Precisión compartida

Tanto numpy.linalg como scipy.linalg usan blas/lapack debajo del capó. esto significa:

• Precisión de coma flotante idéntica (float32 y float64)
• Resultados idénticos para las mismas operaciones cuando ambas bibliotecas soportan la misma rutina
• No hay ventaja numérica inherente a ninguna de las dos bibliotecas para operaciones básicas

Rendimiento por tamaño de matriz

Numpy es más rápido para las operaciones básicas en matrices pequeñas a medianas. SciPy proporciona rutinas especializadas que Numpy no ofrece: descomposiciones de Schur, descomposiciones LQ, descomposiciones polares, solucionadores de matriz con bandas y solucionadores iterativos escasos (GMRES, BICGSTAB).

Estabilidad numérica

Scipy’s scipy.linalg maneja mejor las matrices mal condicionadas con estrategias de verificación de condiciones más completas y estrategias de respaldo. El submódulo scipy.sparse.linalg evita la pérdida de precisión catastrófica para sistemas escasos de gran tamaño, una distinción crítica para los solucionadores de PDE y los métodos de elementos finitos.

Lo que recomendamos para Álgebra Lineal

Use numpy.linalg para operaciones básicas en matrices de pequeña a mediana donde la velocidad importa y los números de condición se portan bien. Use scipy.linalg cuando necesite descomposiciones especializadas, solucionadores escasos o estabilidad numérica en matrices mal condicionadas. Comparten el mismo backend blas/lapack, por lo que está eligiendo la superficie y la seguridad de la API, no la precisión.

Aceleración de GPU: Cupy vs PyTorch vs Jax

La aceleración de GPU es cada vez más central para Python científico. Las tres opciones principales: CUPY (GPU compatible con Numpy), GPU PyTorch y GPU JAX, cada una tiene distintas compensaciones.

Tamaño de matriz frente a rendimiento

CUPY proporciona matrices de GPU compatibles con Numpy con aceleraciones de 10 a 100 × para grandes arreglos. Sin embargo, para matrices menores de ~ 10.000 elementos, la sobrecarga de transferencia de memoria de GPU hace que CuPy sea más lento que la CPU numpí. La aceleración escala con el tamaño de la matriz: esta es una compensación fundamental de la aceleración de GPU.

Rendimiento específico de la arquitectura

Fuente: ARXIV Paper comparando CUPY vs PyTorch en la arquitectura de la tolva.

PyTorch supera a CUPY en aproximadamente un 20% en las GPU H100, con un rendimiento similar en GH200. La aceleración de 10 veces sobre la CPU para operaciones grandes es consistente en todas las arquitecturas.

Lo que recomendamos para la aceleración de GPU

Si está portando el código numpy existente y desea cambios mínimos, utilice CUPY. Es un reemplazo directo con una sintaxis numpí familiar. Si necesita el mejor rendimiento de GPU sin procesar y está creando un nuevo código, utilice GPU PyTorch en arquitecturas modernas. Si necesita diferenciación automática junto con la aceleración de GPU, utilice la GPU JAX.

Para problemas con menos de 10 000 elementos, péguese con CPU Numpy: no se amortizará la sobrecarga de transferencia de GPU.

Optimización, funciones especiales e interpolación

Este es el territorio indiscutible de Scipy. Ningún competidor serio coincide con su cobertura.

scipy.optimizar

scipy.optimize proporciona un conjunto completo: minimize, least_squares, métodos de búsqueda de raíces (Brent, Newton) y optimización restringida. La API es madura, bien documentada y ampliamente probada.

scipy.especial

scipy.special proporciona funciones de Bessel, funciones gamma, funciones de error y docenas de funciones matemáticas especiales utilizadas en la ciencia computacional. Estas rutinas están optimizadas numéricamente y están disponibles tanto en formas escalares como vectorizadas.

scipy.interpolar

scipy.interpolate proporciona interp1d, RegularGridInterpolator, CubicSpline y interpoladores de función de base radial. Tenga en cuenta que el problema de rendimiento bien documentado: RegularGridInterpolator es 10–1000 × más lento que las implementaciones anteriores para los modos de interpolación lineal y cúbica. Este es un problema de scipy conocido (github #18010).

Lo que recomendamos para la optimización e interpolación

Usar scipy — No existe una alternativa viable en una cobertura equivalente. Para RegularGridInterpolator, tenga en cuenta el problema de rendimiento cúbico/lineal y considere alternativas como scipy.interpolate.CubicSpline para datos 1D o scipy.interpolate.RBFInterpolator para datos dispersos si el rendimiento es crítico.

Cálculo basado en bucle: NUMBA vs JIT JIT

Los bucles de Python son famosos por ser lentos. Numba y Jax abordan esto a través de la compilación JIT, pero con diferentes compensaciones.

Rendimiento de bucle secuencial

Numba ofrece 5 a 15 × aceleraciones en raw numpy para bucles secuenciales. La primera ejecución incluye sobrecarga de compilación JIT (0,1623 s para la primera ejecución), pero las siguientes ejecuciones son rápidas (0,0704 s).

Máximo vectorizado sobre 3000×3000 cuadrícula

JAX proporciona el mejor rendimiento compilado JIT (0.0004 s). vmap de JAX evita matrices intermedias, proporcionando velocidad y eficiencia de memoria. NUMBA con prange entrega 0.0328 s en una cuadrícula de 3000 × 3000: una aceleración de 7.7 × sobre numpy con paralelización.

Lo que recomendamos para el cálculo de bucle

• JAX JIT es la opción más rápida (0.0004 s vs numpy 0.2535 s) y usa vmap para evitar matrices intermedias. Lo mejor para proyectos nuevos o cuando puedas reestructurar el código.
• Numba con prange proporciona la mejor relación de legibilidad a rendimiento (0,0328 s) y compila en código de máquina con cambios mínimos en el código numpy existente. Lo mejor para portar el código de bucle pesado existente.
• Numpy es el más simple pero más lento para los bucles. Utilice operaciones vectorizadas cuando sea posible; Retroceda a NUMBA cuando la vectorización no es factible.

La matriz de decisión compuesta

El ecosistema científico de Python está fragmentado por diseño. Cada biblioteca sobresale en cargas de trabajo específicas. Utilice esta matriz para elegir la herramienta correcta:

Cuándo elegir X vs Y

numpy vs scipy

Elija Numpy para las operaciones básicas de la matriz, álgebra lineal de pequeña a mediana y cuando necesite la dependencia más simple posible. Elija scipy cuando necesite solucionadores especializados (matrices con bandas, métodos iterativos escasos), estabilidad numérica en problemas mal condicionados o funciones fuera de la API de Numpy.

Polar vs Pandas

Elija Polares para todo el procesamiento de datos en memoria donde importen el rendimiento y la eficiencia de la memoria. Elija Pandas cuando necesite compatibilidad con ecosistemas (por ejemplo, una biblioteca específica que solo admita marcos de datos de Pandas) o trabaje con conjuntos de datos pequeños a medianos donde la diferencia de velocidad es insignificante.

GPU de Cupy vs PyTorch

Elija cupy cuando desee una sintaxis compatible con Numpy y esté migrando el código existente. Elija GPU PyTorch cuando necesite el mejor rendimiento sin procesar en el hardware moderno de NVIDIA y esté creando un nuevo código.

Jax vs Numba

Elija JAX cuando necesite el rendimiento más rápido posible (0.0004 s vs numba 0.0328 s) y esté dispuesto a reestructurar el código alrededor de la compilación XLA y vmap. Elija Numba cuando necesite cambios de código mínimos, buena legibilidad y una curva de aprendizaje más suave.

Uso de memoria y eficiencia energética

La huella de memoria es importante para la reproducibilidad y para la ejecución de simulaciones en hardware restringido.

• Pandas carga conjuntos de datos completos en la memoria (~14 GB para filas de 67 millones).
• Polares con streaming Lazy + utiliza una memoria de pico de ~0,5 GB en el mismo conjunto de datos.
• DuckDB utiliza una memoria de pico de ~0,3 GB pero requiere una sintaxis SQL.

Fuente: Benchmark codecéntrico con perfiles de memoria detallados.

Polars usa aproximadamente 8× menos energía que los pandas en grandes conjuntos de datos. Esto es consecuente para los investigadores centrados en la sostenibilidad y para la eficiencia computacional a escala.

Precisión numérica y estabilidad

Todas las bibliotecas de referencia utilizan aritmética de coma flotante IEEE 754 con la misma precisión. La distinción clave es la estabilidad numérica: qué tan bien una biblioteca maneja matrices mal condicionadas, sistemas casi singulares y entradas de casos de límite.

• scipy proporciona una verificación de condiciones más completa, estrategias de respaldo y rutinas especializadas para problemas numéricamente desafiantes.
• Numpy delega directamente a BLAS/LAPACK, lo cual es excelente para problemas bien acondicionados pero menos defensivo.
• Jax y PyTorch utilizan diferentes convenciones de punto flotante (JAX tiene como valor predeterminado float32 en muchos contextos, PyTorch tiene como valor predeterminado Float64). Verifique siempre la consistencia de DType.
• cupy refleja el comportamiento de punto flotante de Numpy pero con la aceleración de GPU.

Para simulaciones de investigación-grado donde la reproducibilidad numérica es esencial, siempre documente la precisión del punto flotante y valide los resultados entre las bibliotecas cuando sea posible.

Lo que recomendamos: Orientación práctica

Esto es lo que elegiría para un flujo de trabajo de investigación típico:

1. Operaciones de matriz y aceleración de GPU: GPU de PyTorch para velocidad sin procesar, GPU JAX para Autodiff, CUPY para GPU compatible con Numpy sin refactorización.
2. Procesamiento de datos: Polares con streaming Lazy + para todos los flujos de trabajo en memoria. Dask solo para el cálculo distribuido fuera de la memoria.
3. Álgebra lineal: Numpy para operaciones básicas; Scipy para rutinas especializadas y estabilidad numérica.
4. Optimización, funciones especiales, interpolación: scipy. No hay competidor en cobertura equivalente.
5. Cálculo de bucle: numba para portar el código existente; JIT JIT para nuevo código donde el máximo rendimiento importa.

La biblioteca correcta depende de su tarea, escala y hardware específicos. Recomiendo comparar las bibliotecas que importan para su flujo de trabajo en datos representativos antes de confirmar. Una sesión de evaluación comparativa de 2 horas puede ahorrar meses de optimización iterativa.

Guías relacionadas

• performance de perfiles y optimización para solucionadores de PDE de Python — Aprenda cómo perfilar y optimizar PDE de Python Soludores que utilizan CPProfile, line_profiler y numba jit.
• Suites de referencia para solucionadores científicos: sciml, DOE escasos solucionadores y ASU Mittelmann: compare los recursos de referencia establecidos de Solver en todos los dominios ODE, PDE, escaso álgebra lineal y dominios de optimización.
• moose vs prisms-pf vs openphase — Comparar marcos líderes en ciencia de materiales computacionales para la simulación de campo de fase.

Pensamientos finales

El ecosistema científico de Python ofrece herramientas poderosas, pero ninguna biblioteca única sobresale en todo. Comprender las compensaciones de rendimiento y precisión entre Numpy, Scipy, Jax, PyTorch, Cupy, Polars, Pandas, Dask y DuckDB es esencial para una computación científica eficiente. Compare su carga de trabajo específica, mida el rendimiento real y elija la biblioteca que ofrezca la precisión requerida dentro de su presupuesto computacional.

Si necesita ayuda para seleccionar y optimizar las bibliotecas científicas de Python para su flujo de trabajo de investigación específico, ofrecemos servicios de consultoría para guiarlo a través de la selección de bibliotecas, perfiles de rendimiento y estrategias de optimización adaptadas a sus problemas de cálculo. Póngase en contacto con nuestro equipo para discutir su proyecto.

Referencias y fuentes

1. Benchmark numpy/jax/pytorch de Vincent Roger — Comparación completa en cinco operaciones a pequeña y gran escala con especificaciones de hardware y notas de metodología. Fuente de referencia
2. Comparación de Quantecon Numpy/Numba/Jax — Lectura de referencia comparando NumPy, Numba y JAX con datos de tiempo explícitos para operaciones vectorizadas y secuenciales. fuente de referencia
3. Pithonalchemist Polars/Pandas 2026 Benchmark — Comparación de carga de trabajo real que muestra los polares de 5 a 30 × más rápido que los pandas con una brecha cada vez mayor a medida que crecen los datos. fuente de referencia
4. Benchmark de DuckDB/DataFrame de 9 GB de referencia CSV con ejecuciones en frío/en caliente, perfiles de memoria y comentarios del equipo Polars. origen de referencia
5. Batalla de statusneo dataframe — Operaciones CSV de 10 m de fila: Polars, Pandas, Comparación de Dask. benchmark Fuente
6. Jax Docs Benchmarking — Documentación oficial de evaluación comparativa de JAX con el momento exacto de la GPU. origen de referencia
7. Papel ARXIV: Cupy vs PyTorch en Hopper — Benchmark de GPU que compara CUPY y PyTorch en arquitecturas H100 y GH200. origen de referencia
8. Seminario CERN: sustrato científico de Python (Ralf Gommers) — Análisis de patrones de rendimiento en bibliotecas científicas de Python en todas las instituciones de investigación. fuente del seminario
9. Algebra lineal numpy vs scipy (Github #23829) — Discusión comunitaria sobre el rendimiento y la estabilidad del álgebra lineal SCIPY vs SciPy. github #23829
10. Rendimiento de SciPy RegularGridInterpolator (Github #18010) — Problema conocido que documenta la regresión del rendimiento de la interpolación cúbica/lineal. github #18010
11. Comparación oficial de polares — Documentación oficial de los polares que compara los polares con Dask, DuckDB y Spark. docs de comparación de polares
12. Discusión de JAX: «¿Jax es más rápido que numpy?» — Discusión de GitHub que explica el rendimiento de la CPU en modo ansioso frente al rendimiento compilado por JIT. discusión de jax github
13. Documentación de escipia — Álgebra lineal — Documentación oficial para scipy.linalg y scipy.sparse.linalg. docs. scipy.linalg
14. Documentación SCIPY — Funciones especiales — Documentación oficial de scipy.special. scipy.docs especiales
15. Documentación de escipy — Interpolación — Documentación oficial de scipy.interpolate. scipy.Interpolar documentos