Eu tive um problema semelhante ao ler um gráfico de um arquivo. O processamento incluiu o cálculo de uma matriz flutuante de 200 000 x 200 000 (uma linha de cada vez) que não cabia na memória. Tentando liberar a memória entre os cálculos usando gc.collect()
o aspecto relacionado à memória do problema, mas resultou em problemas de desempenho: não sei por que, embora a quantidade de memória usada permanecesse constante, cada nova chamada gc.collect()
levava mais tempo do que o anterior. Tão rapidamente que a coleta de lixo levou a maior parte do tempo computacional.
Para corrigir os problemas de memória e desempenho, mudei para o uso de um truque de multithreading que li uma vez em algum lugar (desculpe, não consigo mais encontrar a postagem relacionada). Antes eu estava lendo cada linha do arquivo em um for
loop grande , processando-o e executando de gc.collect()
vez em quando para liberar espaço de memória. Agora, chamo uma função que lê e processa um pedaço do arquivo em um novo thread. Quando o segmento termina, a memória é automaticamente liberada sem o problema de desempenho estranho.
Praticamente funciona assim:
from dask import delayed # this module wraps the multithreading
def f(storage, index, chunk_size): # the processing function
# read the chunk of size chunk_size starting at index in the file
# process it using data in storage if needed
# append data needed for further computations to storage
return storage
partial_result = delayed([]) # put into the delayed() the constructor for your data structure
# I personally use "delayed(nx.Graph())" since I am creating a networkx Graph
chunk_size = 100 # ideally you want this as big as possible while still enabling the computations to fit in memory
for index in range(0, len(file), chunk_size):
# we indicates to dask that we will want to apply f to the parameters partial_result, index, chunk_size
partial_result = delayed(f)(partial_result, index, chunk_size)
# no computations are done yet !
# dask will spawn a thread to run f(partial_result, index, chunk_size) once we call partial_result.compute()
# passing the previous "partial_result" variable in the parameters assures a chunk will only be processed after the previous one is done
# it also allows you to use the results of the processing of the previous chunks in the file if needed
# this launches all the computations
result = partial_result.compute()
# one thread is spawned for each "delayed" one at a time to compute its result
# dask then closes the tread, which solves the memory freeing issue
# the strange performance issue with gc.collect() is also avoided