Reducir la huella de memoria numpy en aplicaciones de larga ejecución

En mi aplicación se generan y se llenan con datos cien arreglos numpy (1000 elementos complejos cada uno). Luego, en muchas iteraciones, los elementos de la matriz se modifican una y otra vez. Después de la generación inicial, el monitor del sistema reporta alrededor de 50 Mb de uso de RAM. Aunque no estoy generando nuevos arreglos, la huella sigue creciendo en alrededor de 40 Mb por iteración.

Aprendí aquí , que el recolector de basura no maneja matrices numpy. Así que asumo que algunos arreglos temporales que estoy generando para manipular datos no se recostackn correctamente.

Aquí dice que desafortunadamente guppy.hpy (). Heap () no ayuda con la creación de perfiles.

¿Cómo puedo identificar la fuente del problema y, idealmente, mantener el consumo constante en cualquier cantidad de iteraciones?

Sospecho que puedo estar generando copias al asignar elementos de matriz como se describe aquí , que luego no se recolectan como basura.

    ¿Puedo eliminar manualmente las matrices temporales de números para ayudar a la recolección de basura?

    [Actualización 1]: código de muestra

    Este bit de código se llama miles de veces. Cada vez, la huella aumenta. No puedo ver por qué, porque a mi entender solo se trata de leer matrices existentes y manipular otras matrices existentes. ¿Alguna de estas operaciones de rebanado está haciendo algo involuntario? (Disculpe la longitud de la línea. Puedo simplificarla, pero también podría estar ocultando mis errores).

    for ts in np.arange(numTimeslots): for fc in np.arange(numFreqChunks): interfencep = np.sum( np.dot(np.dot(self.baseStations[bs].cells[cell].CSI_OFDMA[:,:,fc,ts] ,np.diag(cell.OFDMA_power[:,fc,ts])),self.baseStations[bs].cells[cell].CSI_OFDMA[:,:,fc,ts].conj().T) for bs in self.baseStations for cell in bs.cells if cell != self._cell) noisep = np.eye(self.antennas) * (self.noisePower / numFreqChunks) self.OFDMA_interferenceCovar[:,:,fc,ts] = noisep + interfencep self.OFDMA_EC[:,:,fc,ts] = (np.dot(np.dot(self.OFDMA_CSI[:,:,fc,ts],linalg.inv(noisep+interfencep)),self.OFDMA_CSI[:,:,fc,ts].conj().T)) eigs = linalg.eig(self.OFDMA_EC[:,:,fc,ts])[0] self.OFDMA_SINR[:,fc,ts] = np.real(eigs) 

    [Actualización 2]: Para aquellos curiosos, esto es parte de un simulador de red móvil. Ejecutándose en virtualenv, Python 2.7.3, Numpy 1.6.2, SciPy 0.11.0b1

    [Actualización 3]: A través de comentarlo y verificar el monitor del sistema, puedo identificar la línea ‘interferp = …’ como culpable. Se asigna memoria significativa que no se libera. ¿Pero por qué?

    Tuve el mismo tipo de problema. Lamentablemente no encontré ninguna solución. Lo único que me funcionó fue refactorizar el código en una pequeña función aislada. Esas funciones deben realizarse para que pueda convencerme de que no guardo ninguna referencia a las matrices que evitan que el recolector de basura las recoja. Debe tener especial cuidado con las vistas de matriz que se generan al segmentar, etc.

    Con el fin de hacer que el código sea más eficiente en memoria y menos propenso a las memory leaks, a menudo me pareció útil usar el argumento out = keyword proporcionado por muchas funciones numpy.

    Mediante el uso del monitor del sistema y la inspección / comentario del código, encontré la pérdida de memoria. Fue causado por la comparación de una matriz numpy con una lista vacía en un archivo diferente. Buscaré en la filtración en un lugar diferente y votaré para eliminar esta pregunta, ya que me parece demasiado específica para ayudar a alguien más.

    [Actualización 1]: Nueva pregunta que describe la fuente del problema: ¿Por qué la comparación de una matriz numpy con una lista consume tanta memoria?