Pour commencer j'utilise un notebook jupyter et voici comment j'importe mes données:
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:
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.
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, 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.
type(df.compute()) # donne un objet dask.dataframe.core.DataFrame.
Sa taille se réduit encore par rapport à précédemment:
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 . 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?
Comment est-ce possible de saturer la mémoire avec un dataset de taille inférieure à la mémoire?
Répondre avec citation
Envoyé par wiztricks
Partager