Pour commencer j'utilise un notebook jupyter et voici comment j'importe mes données:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
%%time
import pymongo
from pymongo import MongoClient
connection         = MongoClient()
db                 = connection.adb
games=list(db.Collection.find({}).limit(100000))
ça prend Wall time: 54.7 s à être fait, tandis que la taille de l'objet games est de:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
import sys
sys.getsizeof(games) ##879840 bytes, so 0.87984 MB
L'objet games est une liste de dictionnaires puisqu'il est issue d'un tas de fichiers json. Notons que les 100 000 fichiers ici sont proches de ce que la collection comporte en entier: 143 403 fichiers.

Maintenant concernant le code ci-dessous avec lequel je fais un dask.dataframe prend 9min 37s.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import dask.dataframe as dd
import pandas as pd
 
def fonction_df(game):
    try:
        df=pd.DataFrame(game, index=[game['_id']]*len(game['rank']))        
        return df
    except:
        print('problem with:{}'.format(game['_id']))
 
dfs=list(map(lambda game: 
      fonction_df_dask(game),
      games)) ##list of dictionnaries where each one is a game
 
df=delayed(dd.concat)(dfs,axis=0,interleave_partitions=True)
Le type de df est dask.delayed.Delayed et sa taille vaut 160 bytes. D'ailleurs quelque soit le nombre de fichiers importé, 100 ou même 1000,
Code : Sélectionner tout - Visualiser dans une fenêtre à part
sys.getsizeof(df)
indique toujours 160 bytes.

Maintenant pour éviter une saturation de la mémoire je vais appliquer la méthode compute() sur df mais avec un échantillon encore plus réduit de 100 fichiers.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
type(df.compute()) # donne un objet dask.dataframe.core.DataFrame.
Sa taille se réduit encore par rapport à précédemment:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
 sys.getsizeof(df.compute())
112 bytes.

Mais un objet dask.dataframe.core.DataFrame n'est pas très utile à la visualisation des données, comme vous pouvez le voir ci-dessous:

npartitions=471 _id A B ...
1 object object object ...
2 ... ... ... ...
... ... ... ... ...
100 ... ... ... ...

Dask Name: concat-indexed, 445568 tasks

Pour avoir un dataframe utilisable pour jeter un oeil sur les données j'utilise
Code : Sélectionner tout - Visualiser dans une fenêtre à part
df.compute().compute()
. La taille des données pour les 100 fichiers passent à 3.42MB, et devient un objet pandas.core.frame.DataFrame tel que c'est dit dans la documentation de dask d'ailleurs. J'imagine donc qu'avec la totalité des fichiers 143 403 files on atteindrait environ 3.4GB et même un peu plus.

Mais le soucis pour 100 fichiers c'est que ces 3.42MB lui prenne 43s à être executé avec df.compute().compute(). En tentant de passer à 1000 fichiers ça prenait trop de temps j'ai interrompu le kernel. Cette fois la taille dépend vraiment du nombre de fichiers importés.
Pourtant en regardant mon gestionnaire de tâches j'ai 3085Mo de disponibles avant de lancer ces opérations.

La taile de 3.42MB me semble ridicule par rapport à au 3Go disponibles et ça prend presque 1 minute. Pour 34.2MB ça prend un temps pas possible que j'ai même pas pu calculé. Comment est-ce possible?