Pickle dump énorme fichier sans erreur de mémoire

Je suis l'auteur d'un paquet appelé klepto (et également l'auteur de dill).
klepto est construit pour stocker et récupérer des objets dans une manière très simple, et fournit une simple interface du dictionnaire de bases de données, la mémoire cache, et le stockage sur le disque. Ci-dessous, je montre stockage d'objets volumineux dans un "répertoire de l'archive", qui est un système de fichiers de répertoire avec un fichier par entrée. - Je choisir pour sérialiser les objets (c'est lent, mais il utilise dill, de sorte que vous pouvez stocker presque n'importe quel objet), et je choisis un cache. À l'aide d'un cache mémoire me permet d'avoir un accès rapide au répertoire de l'archive, sans avoir à obtenir l'intégralité de l'archive dans la mémoire. L'interaction avec une base de données ou le fichier peut être lent, mais l'interaction avec la mémoire est rapide... et vous pouvez remplir la mémoire cache que vous le souhaitez à partir de l'archive.

>>> import klepto
>>> d = klepto.archives.dir_archive('stuff', cached=True, serialized=True)
>>> d
dir_archive('stuff', {}, cached=True)
>>> import numpy
>>> # add three entries to the memory cache
>>> d['big1'] = numpy.arange(1000)
>>> d['big2'] = numpy.arange(1000)
>>> d['big3'] = numpy.arange(1000)
>>> # dump from memory cache to the on-disk archive
>>> d.dump()
>>> # clear the memory cache
>>> d.clear()
>>> d
dir_archive('stuff', {}, cached=True)
>>> # only load one entry to the cache from the archive
>>> d.load('big1')
>>> d['big1'][-3:]
array([997, 998, 999])
>>> 

klepto fournit rapide et flexible l'accès à de grandes quantités d'espace de stockage, et si l'archive permet en parallèle d'accès (par exemple, certaines bases de données), alors vous pouvez lire les résultats en parallèle. Il est également facile de partager les résultats dans les différents processus parallèles ou sur des machines différentes. Ici, j'ai créer un deuxième archive instance, a souligné le même répertoire de l'archive. Il est facile de passer les clés entre les deux objets, et fonctionne de la même façon à partir d'un autre processus.

>>> f = klepto.archives.dir_archive('stuff', cached=True, serialized=True)
>>> f
dir_archive('stuff', {}, cached=True)
>>> # add some small objects to the first cache  
>>> d['small1'] = lambda x:x**2
>>> d['small2'] = (1,2,3)
>>> # dump the objects to the archive
>>> d.dump()
>>> # load one of the small objects to the second cache
>>> f.load('small2')
>>> f       
dir_archive('stuff', {'small2': (1, 2, 3)}, cached=True)

Vous pouvez aussi choisir parmi différents niveaux de compression de fichiers, et si
vous voulez que les fichiers soient mappés en mémoire. Il ya beaucoup de différents
options, à la fois pour les fichiers backend et pilotes de base de données. L'interface
est identique, cependant.

Par rapport à vos autres questions au sujet de la collecte des ordures et la modification de certaines parties du dictionnaire, les deux sont possibles avec klepto, que vous pouvez charger et supprimer des objets de la mémoire cache, de vidage, de charge et de synchronisation avec l'archive backend, ou de tout autre dictionnaire de méthodes.

Voir plus de tutoriel ici: https://github.com/mmckerns/tlkklp

Obtenir klepto ici: https://github.com/uqfoundation

OriginalL'auteur Mike McKerns

Si vos clés et des valeurs de chaîne, vous pouvez utiliser l'une de l'embedded persistante clé-valeur moteurs de stockage disponible en Python à la bibliothèque standard. Exemple de la anydbm module docs:

import anydbm

# Open database, creating it if necessary.
db = anydbm.open('cache', 'c')

# Record some values
db['www.python.org'] = 'Python Website'
db['www.cnn.com'] = 'Cable News Network'

# Loop through contents.  Other dictionary methods
# such as .keys(), .values() also work.
for k, v in db.iteritems():
    print k, '\t', v

# Storing a non-string key or value will raise an exception (most
# likely a TypeError).
db['www.yahoo.com'] = 4

# Close when done.
db.close()

OriginalL'auteur Imran

J'ai eu une erreur de la mémoire et résolu en utilisant le protocole=2:


cPickle.dump(obj, file, protocol=2)


OriginalL'auteur denfromufa

J'ai récemment eu ce problème. Après avoir essayé cpickle avec l'ASCII et le protocole binaire 2, j'ai trouvé que ma SVM auprès de la sci-kit d'apprendre formés sur+ de 20 go de données n'a pas été le décapage due à une erreur de mémoire. Cependant, l'aneth paquet semble résoudre le problème. L'aneth ne va pas créer de nombreuses améliorations pour un dictionnaire, mais il peut aider avec le streaming. Il est destiné à flux marinés octets à travers un réseau.

import dill

with open(path,'wb') as fp:
    dill.dump(outpath,fp)
    dill.load(fp)

Si l'efficacité est un problème, essayez de chargement/sauvegarde d'une base de données. Dans ce cas, votre solution de stockage peut être un problème. 123 mo Pandas doit être fine. Toutefois, si la machine est limitée de mémoire de SQL offre rapide,optimisé, sac opérations sur les données, généralement avec multithread de soutien.
Mon poly noyau svm enregistré.

OriginalL'auteur Andrew Scott Evans

Cela peut sembler trivial, mais essayez d'utiliser le 64 bits Python si vous n'êtes pas.

OriginalL'auteur lyron