Sé que Numpy puede usar diferentes backends como OpenBLAS o MKL. También he leído que MKL está muy optimizado para Intel, por lo que generalmente la gente sugiere usar OpenBLAS en AMD, ¿verdad?

Yo uso el siguiente código de prueba:

 import numpy as np def testfunc(x): np.random.seed(x) X = np.random.randn(2000, 4000) np.linalg.eigh(X @ XT) %timeit testfunc(0)

He probado este código usando diferentes CPU:

• En Intel Xeon E5-1650 v3 , este código funciona en 0,7 s con 6 de 12 núcleos .
• En AMD Ryzen 5 2600 , este código funciona en 1,45 s con los 12 núcleos .
• En AMD Ryzen Threadripper 3970X , este código funciona en 1,55 s con los 64 núcleos .

Estoy usando el mismo entorno Conda en los tres sistemas. Según np.show_config() , el sistema Intel usa el backend MKL para Numpy ( library libraries = ['mkl_rt', 'pthread'] ), mientras que los sistemas AMD usan OpenBLAS ( library libraries = ['openblas', 'openblas'] ) . El uso del núcleo de la CPU se determinó observando top de un shell de Linux:

• Para la CPU Intel Xeon E5-1650 v3 (6 núcleos físicos), muestra 12 núcleos (6 inactivos).
• Para la CPU AMD Ryzen 5 2600 (6 núcleos físicos), muestra 12 núcleos (ninguno inactivo).
• Para la CPU AMD Ryzen Threadripper 3970X (32 núcleos físicos), muestra 64 núcleos (ninguno inactivo).

Las anteriores observaciones dan lugar a las siguientes preguntas:

1. ¿Es normal que el álgebra lineal en las CPU AMD actualizadas que usan OpenBLAS sea mucho más lento que en un Intel Xeon de seis años? (también abordado en la Actualización 3)
2. A juzgar por las observaciones de la carga de la CPU, parece que Numpy utiliza el entorno multinúcleo en los tres casos. ¿Cómo puede ser que el Threadripper sea incluso más lento que el Ryzen 5, a pesar de que tiene casi seis veces más núcleos físicos? (ver también Actualización 3)
3. ¿Hay algo que se pueda hacer para acelerar los cálculos en Threadripper? (respondido parcialmente en la Actualización 2)

Actualización 1: la versión de OpenBLAS es 0.3.6. Leí en alguna parte que la actualización a una versión más nueva podría ayudar, sin embargo, con OpenBLAS actualizado a 0.3.10, el rendimiento de testfunc sigue siendo de 1,55 s en AMD Ryzen Threadripper 3970X.

Actualización 2: el uso del backend MKL para Numpy junto con la variable de entorno MKL_DEBUG_CPU_TYPE=5 (como se describe aquí ) reduce el tiempo de ejecución de testfunc en AMD Ryzen Threadripper 3970X a solo 0,52 s, lo que en realidad es más o menos satisfactorio. FTR, configurar esta variable a través de ~/.profile no funcionó para mí en Ubuntu 20.04. Además, configurar la variable desde dentro de Jupyter no funcionó. Entonces, en lugar de eso, lo puse en ~/.bashrc , que funciona ahora. De todos modos, con un rendimiento un 35 % más rápido que un Intel Xeon antiguo, ¿es esto todo lo que obtenemos o podemos sacarle más partido?

Actualización 3: juego con la cantidad de subprocesos utilizados por MKL/OpenBLAS:

Los tiempos de ejecución se informan en segundos. El mejor resultado de cada columna está subrayado. Usé OpenBLAS 0.3.6 para esta prueba. Las conclusiones de esta prueba:

• El rendimiento de un solo núcleo de Threadripper usando OpenBLAS es un poco mejor que el rendimiento de un solo núcleo de Xeon (11 % más rápido), sin embargo, su rendimiento de un solo núcleo es incluso mejor cuando se usa MKL (34 % más rápido).
• El rendimiento multinúcleo del Threadripper con OpenBLAS es ridículamente peor que el rendimiento multinúcleo del Xeon. ¿Que esta pasando aqui?
• El Threadripper funciona mejor en general que el Xeon , cuando se usa MKL (entre un 26 % y un 38 % más rápido que el Xeon). El mejor rendimiento general lo logra Threadripper usando 16 hilos y MKL (36% más rápido que Xeon).

Actualización 4: Solo para aclaración. No, no creo que (a) esto o (b) aquello responda a esta pregunta. (a) sugiere que "OpenBLAS funciona casi tan bien como MKL" , lo cual es una fuerte contradicción con los números que observé. Según mis números, OpenBLAS funciona ridículamente peor que MKL. La pregunta es por qué. (a) y (b) ambos sugieren usar MKL_DEBUG_CPU_TYPE=5 junto con MKL para lograr el máximo rendimiento. Esto podría ser correcto, pero tampoco explica por qué OpenBLAS es tan lento. Tampoco explica por qué, incluso con MKL y MKL_DEBUG_CPU_TYPE=5 , el Threadripper de 32 núcleos es solo un 36 % más rápido que el Xeon de 6 núcleos de seis años .