¿Por qué NumPy en lugar de listas de Python?

Question

¿Vale la pena mi aprendizaje NumPy?

Tengo aproximadamente 100 series de mercados financieros, y voy a crear una matriz de cubos de 100x100x100 = 1 millón de celdas. Estaré retrocediendo (3 variables) cada x con cada y y z, para llenar la matriz con errores estándar.

He oído que para las "matrices grandes" debería usar NumPy en lugar de las listas de Python, por razones de rendimiento y escalabilidad. La cosa es que sé que Python enumera y parece que funcionan para mí.

¿Vale la pena cambiar la escala del problema anterior a NumPy?

¿Qué sucede si tengo 1000 series (es decir, 1 mil millones de celdas de coma flotante en el cubo)?

Answer 1

Las matrices de NumPy son más compactas que las listas de Python; una lista de listas como las que describes en Python tomaría al menos 20 MB o menos, mientras que una matriz NumPy 3D con flotantes de precisión simple encajaría 4 MB. El acceso en lectura y escritura de artículos también es más rápido con NumPy.

Tal vez no te importa mucho por solo un millón de células, pero definitivamente lo harías por un billón de celdas; ninguno de los enfoques encajaría en una arquitectura de 32 bits, pero con compilaciones de 64 bits, NumPy se saldría con la suya 4 GB más o menos, Python solo necesitaría al menos alrededor de 12 GB (muchos punteros que duplican su tamaño), ¡una pieza de hardware mucho más costosa!

La diferencia se debe principalmente a la "indirecta": una lista de Python es una matriz de punteros a objetos Python, al menos 4 bytes por puntero más 16 bytes incluso para el objeto Python más pequeño (4 para tipo puntero, 4 para recuento de referencias, 4 para el valor, y los asignadores de memoria redondean hasta 16). Una matriz NumPy es una matriz de valores uniformes: los números de precisión simple toman 4 bytes cada uno, los de precisión doble, 8 bytes. ¡Menos flexible, pero usted paga sustancialmente por la flexibilidad de las listas estándar de Python!

Answer 2

NumPy no solo es más eficiente; también es más conveniente. Obtienes muchas operaciones vectoriales y matriciales de forma gratuita, lo que a veces te permite evitar el trabajo innecesario. Y también se implementan de manera eficiente.

Por ejemplo, se podía leer su cubo directamente desde un archivo en una matriz:

x = numpy.fromfile(file=open("data"), dtype=float).reshape((100, 100, 100)) 

Suma a lo largo de la segunda dimensión:

s = x.sum(axis=1) 

Encuentre el cual las células están por encima de un umbral:

(x > 0.5).nonzero() 

Elimine todas las divisiones con índices par a lo largo de la tercera dimensión:

x[:, :, ::2] 

Además, muchas bibliotecas útiles funcionan con matrices NumPy. Por ejemplo, bibliotecas de análisis estadístico y visualización.

Incluso si no tiene problemas de rendimiento, aprender NumPy vale la pena el esfuerzo.

Answer 3

Tenga en cuenta también que no hay soporte para series de tiempo basado en NumPy en los scikits series temporales:

http://pytseries.sourceforge.net

Para la regresión, estoy bastante seguro de NumPy será órdenes de magnitud más rápido y más conveniente que las listas incluso para el problema 100^3.

Answer 4

Alex mencionó la eficiencia de la memoria, y Roberto menciona la conveniencia, y ambos son buenos puntos. Para algunas ideas más, mencionaré velocidad y funcionalidad.

Funcionalidad: Se integra mucho con NumPy, FFT, convoluciones, búsquedas rápidas, estadísticas básicas, álgebra lineal, histogramas, etc. Y realmente, ¿quién puede vivir sin FFT?

Velocidad: Aquí hay una prueba para hacer una suma sobre una lista y una matriz NumPy, que muestra que la suma en la matriz NumPy es 10 veces más rápida (en esta prueba, el millaje puede variar).

from numpy import arange 
from timeit import Timer 

Nelements = 10000 
Ntimeits = 10000 

x = arange(Nelements) 
y = range(Nelements) 

t_numpy = Timer("x.sum()", "from __main__ import x") 
t_list = Timer("sum(y)", "from __main__ import y") 
print("numpy: %.3e" % (t_numpy.timeit(Ntimeits)/Ntimeits,)) 
print("list: %.3e" % (t_list.timeit(Ntimeits)/Ntimeits,)) 

la que en mis sistemas (mientras estoy ejecutando una copia de seguridad) da:

numpy: 3.004e-05 
list: 5.363e-04 

Answer 5

velocidad en cuanto no estoy tan seguro de. Aquí está un ejemplo rápido: He creado una función (de x) que devuelve una lista de números primos entre 2 y x:

• función de Python regular utilizando listas:

  def findprimeupto(x): 
      primes = [] 
      n_primes = [] 
  
      for i in range(2, x): 
  
       if not (i in n_primes): 
        primes.append(i) 
        n_primes.append(i) 
  
       for j in range(len(primes)): 
        if i > n_primes[j]: 
         n_primes[j] += primes[j] 
  
      return primes 
  
  import time 
  start_time = time.time() 
  findprimeupto(10000) 
  print("--- %s seconds ---" % str(time.time() - start_time)) 
  

• y utilizando la función de Python C-como matrices NumPy:

  import numpy 
  
  def findprimeupto(x): 
  
      primes = numpy.array(numpy.zeros(x), dtype=numpy.int32) 
      n_primes = numpy.array(numpy.zeros(x), dtype=numpy.int32) 
      primeslen = 0 
  
      for i in range(2, x): 
  
       flag = 1 
       for j in range(primeslen): 
        if n_primes[j] == i: 
         flag = 0 
         break 
  
       if flag: 
        primes[primeslen] = i 
        n_primes[primeslen] = i 
        primeslen += 1 
  
       for j in range(primeslen): 
        if i > n_primes[j]: 
         n_primes[j] += primes[j] 
  
      return [primeslen, primes] 
  
  
  import time 
  
  start_time = time.time() 
  
  result = findprimeupto(10000) 
  
  #for i in range(result[0]): 
  # print('{:d} '.format(result[1][i]), end="") 
  
  print() 
  print("--- %s seconds ---" % str(time.time() - start_time)) 
  

El anterior aplicación, supuestamente lenta usando las listas, es ejecutado en 0.6 segundos y la posterior, supuestamente rápida implementación de NumPy, necesita 50 segundos. Si alguien puede señalar por qué lo agradecería mucho.

BTW, programa C puro que es más o menos una copia de la versión de NumPy de la función se ejecuta en menos de 0.04   s. La velocidad de C es aún más evidente con grandes x:

#include <stdio.h> 
    #include <stdlib.h> 
    #include <time.h> 

    void findprimesupto(int n, int *primeslen, int *primes, int *n_primes) { 
     int i, j, flag; 

     *primeslen = 0; 

     for (i=2; i <= n; i++) { 
      for (j=0, flag=1; j < *primeslen; j++) 
       if (n_primes[j] == i) { 
        flag = 0; 
        break; 
       } 
      if (flag) { 
       primes[*primeslen] = i; 
       n_primes[*primeslen] = i; 
       (*primeslen)++; 
      } 
      for (j=0; j < *primeslen; j++) 
       if (i > n_primes[j]) 
        n_primes[j] += primes[j]; 
     } 
    } 

    int main() { 
     int n = 10000, primeslen = 0, i; 
     int *primes, *n_primes; 
     clock_t start, diff; 

     start = clock(); 
     primes = malloc(n * sizeof(int)); 
     n_primes = malloc(n * sizeof(int)); 

     findprimesupto(n, &primeslen, primes, n_primes); 

     /* for (i=0; i < primeslen; i++) 
      printf("%d ", primes[i]); 

     printf("\n"); 
     */ 

     diff = clock() - start; 
     printf("Time: %f s\n", (float) diff/(float) CLOCKS_PER_SEC); 

     free(primes); 
     free(n_primes); 

     return 0; 
    } 

Answer 6

Aquí hay una buena respuesta de la FAQ en el scipy.org website:

¿Qué ventajas ofrecen las matrices NumPy sobre listas (anidada) Python?

Las listas de Python son contenedores eficaces de uso general. Admiten (bastante) eficiente inserción, eliminación, adición y concatenación, y la lista de Python las hace fáciles de construir y manipular.Sin embargo, tienen ciertas limitaciones: no admiten operaciones "vectorizadas" como la adición y multiplicación de elementos, y el hecho de que pueden contener objetos de diferentes tipos significa que Python debe almacenar información de tipo para cada elemento, y debe ejecutar código de despacho de tipo cuando se opera en cada elemento. Este también significa que muy pocas operaciones de lista pueden llevarse a cabo mediante bucles de C eficientes - cada iteración requeriría verificaciones de tipo y otras contabilidad de Python API.