tutorial - recorrer una matriz en python
Matrices muy grandes usando Python y NumPy (11)
¿Estás preguntando cómo manejar una matriz de elementos de 2,500,000,000 sin terabytes de RAM?
La forma de manejar 2 mil millones de elementos sin 8 mil millones de bytes de RAM es no mantener la matriz en la memoria.
Eso significa algoritmos mucho más sofisticados para obtenerlo del sistema de archivos en pedazos.
NumPy es una biblioteca extremadamente útil, y al usarla he descubierto que es capaz de manejar matrices que son bastante grandes (10000 x 10000) fácilmente, pero comienza a luchar con algo mucho más grande (tratando de crear una matriz de 50000 x 50000 falla). Obviamente, esto se debe a los requisitos de memoria masiva.
¿Existe alguna forma de crear enormes matrices de forma nativa en NumPy (digamos 1 millón por 1 millón) de alguna manera (sin tener varios terrabytes de RAM)?
A veces, una solución simple es usar un tipo personalizado para los elementos de su matriz. Según el rango de números que necesita, puede usar un tipo de dtype manual y especialmente más pequeño para sus artículos. Debido a que Numpy considera el tipo más grande para el objeto por defecto, esta podría ser una buena idea en muchos casos. Aquí hay un ejemplo:
In [70]: a = np.arange(5)
In [71]: a[0].dtype
Out[71]: dtype(''int64'')
In [72]: a.nbytes
Out[72]: 40
In [73]: a = np.arange(0, 2, 0.5)
In [74]: a[0].dtype
Out[74]: dtype(''float64'')
In [75]: a.nbytes
Out[75]: 32
Y con tipo personalizado:
In [80]: a = np.arange(5, dtype=np.int8)
In [81]: a.nbytes
Out[81]: 5
In [76]: a = np.arange(0, 2, 0.5, dtype=np.float16)
In [78]: a.nbytes
Out[78]: 8
Asegúrese de estar utilizando un sistema operativo de 64 bits y una versión de 64 bits de Python / NumPy. Tenga en cuenta que en las arquitecturas de 32 bits puede abordar típicamente 3 GB de memoria (con aproximadamente 1 GB de pérdida de E / S asignadas a la memoria, etc.).
Con arreglos de 64 bits y cosas más grandes que la RAM disponible, puede salirse con la suya con la memoria virtual, aunque las cosas serán más lentas si tiene que cambiar. Además, los mapas de memoria (vea numpy.memmap) son una forma de trabajar con archivos enormes en el disco sin cargarlos en la memoria, pero nuevamente, necesita tener un espacio de direcciones de 64 bits para que esto sea de mucha utilidad. PyTables hará la mayor parte de esto por ti también.
Debería poder usar numpy.memmap para mapear en memoria un archivo en el disco. Con la máquina más nueva de python y 64 bits, debe tener el espacio de direcciones necesario, sin cargar todo en la memoria. El sistema operativo debe manejar solo para mantener parte del archivo en la memoria.
Es un poco alfa, pero http://blaze.pydata.org/ parece estar trabajando para resolver esto.
La post Stefano Borini me hizo ver cuánto tiempo ya está en este tipo de cosas.
Eso es todo. Parece hacer básicamente lo que quieres. HDF5 le permitirá almacenar conjuntos de datos muy grandes, y luego acceder a ellos y usarlos de la misma forma que lo hace NumPy.
Para manejar matrices dispersas, necesitas el paquete scipy que se encuentra encima de numpy : mira here para obtener más detalles sobre las opciones de matriz scipy que scipy te brinda.
Por lo general, cuando tratamos con matrices grandes las implementamos como matrices dispersas .
No sé si numpy admite matrices dispersas, pero encontré this en this lugar.
Por lo que sé sobre numpy, no, pero podría estar equivocado.
Puedo proponerle esta solución alternativa: escriba la matriz en el disco y acceda en trozos. Te sugiero el formato de archivo HDF5. Si lo necesita de forma transparente, puede volver a implementar la interfaz ndarray para paginar la matriz almacenada en el disco en la memoria. Tenga cuidado si modifica los datos para volver a sincronizarlos en el disco.
PyTables y NumPy son el camino a seguir.
PyTables almacenará los datos en el disco en formato HDF, con compresión opcional. Mis conjuntos de datos a menudo tienen una compresión de 10x, que es útil cuando se trata de decenas o cientos de millones de filas. También es muy rápido; mi computadora portátil de 5 años de antigüedad puede atravesar los datos haciendo una agregación GROUP BY similar a SQL en 1,000,000 de filas / segundo. ¡No está mal para una solución basada en Python!
Acceder nuevamente a los datos como un recarray NumPy es tan simple como:
data = table[row_from:row_to]
La biblioteca HDF se encarga de leer los fragmentos relevantes de datos y convertirlos a NumPy.
numpy.array s están destinados a vivir en la memoria. Si quieres trabajar con matrices más grandes que tu RAM, tienes que trabajar en eso. Hay al menos dos enfoques que puede seguir:
- Pruebe con una representación matricial más eficiente que explote cualquier estructura especial que tengan sus matrices. Por ejemplo, como otros ya han señalado, existen estructuras de datos eficientes para matrices dispersas (matrices con muchos ceros), como
scipy.sparse.csc_matrix. - Modifique su algoritmo para trabajar en submatrices . Puede leer desde el disco solo los bloques de matriz que se usan actualmente en los cálculos. Los algoritmos diseñados para ejecutarse en clusters generalmente funcionan en bloque, ya que los datos se distribuyen en diferentes computadoras y se pasan solo cuando es necesario. Por ejemplo, el algoritmo Fox para la multiplicación de matrices (archivo PDF) .