Now, it could be that something in the 50,000th is very large, and that's causing the OOM, so to test this I'd first try:
file_list_chunks = list(divide_chunks(file_list_1,20000))[30000:]
If it fails at 10,000 this will confirm whether 20k is too big a chunksize, or if it fails at 50,000 again, there is an issue with the code...
Okay, onto the code...
Firstly, you don't need the explicit list constructor, it's much better in python to iterate rather than generate the entire the list into memory.
file_list_chunks = list(divide_chunks(file_list_1,20000))
# becomes
file_list_chunks = divide_chunks(file_list_1,20000)
I think you might be misusing ThreadPool here:
Prevents any more tasks from being submitted to the pool. Once all the tasks have been completed the worker processes will exit.
This reads like close might have some thinks still running, although I guess this is safe it feels a little un-pythonic, it's better to use the context manager for ThreadPool:
with ThreadPool(64) as pool:
results = pool.map(get_image_features,f)
# etc.
The explicit dels in python aren't actually guaranteed to free memory.
You should collect after the join/after the with:
with ThreadPool(..):
...
pool.join()
gc.collect()
You could also try chunk this into smaller pieces e.g. 10,000 or even smaller!
Hammer 1
One thing, I would consider doing here, instead of using pandas DataFrames and large lists is to use a SQL database, you can do this locally with sqlite3:
import sqlite3
conn = sqlite3.connect(':memory:', check_same_thread=False) # or, use a file e.g. 'image-features.db'
and use context manager:
with conn:
conn.execute('''CREATE TABLE images
(filename text, features text)''')
with conn:
# Insert a row of data
conn.execute("INSERT INTO images VALUES ('my-image.png','feature1,feature2')")
That way, we won't have to handle the large list objects or DataFrame.
You can pass the connection to each of the threads... you might have to something a little weird like:
results = pool.map(get_image_features, zip(itertools.repeat(conn), f))
Then, after the calculation is complete you can select all from the database, into which ever format you like. E.g. using read_sql.
Hammer 2
Use a subprocess here, rather than running this in the same instance of python "shell out" to another.
Since you can pass start and end to python as sys.args, you can slice these:
# main.py
# a for loop to iterate over this
subprocess.check_call(["python", "chunk.py", "0", "20000"])
# chunk.py a b
for count,f in enumerate(file_list_chunks):
if count < int(sys.argv[1]) or count > int(sys.argv[2]):
pass
# do stuff
That way, the subprocess will properly clean up python (there's no way there'll be memory leaks, since the process will be terminated).
My bet is that Hammer 1 is the way to go, it feels like you're gluing up a lot of data, and reading it into python lists unnecessarily, and using sqlite3 (or some other database) completely avoids that.
proc.get_memory_info()to compare memory usage before and after a GC. You might also be unwittingly fragmenting your heap, which the python GC may or may not defragment for you (resulting in increasing memory usage even when you "delete and collect" those dead objects).get_image_features? What you're doing in your snippet is fine.