Diminuer la taille des objets cPickle

Je suis en cours d'exécution du code qui crée des objets volumineux, contenant plusieurs classes définies par l'utilisateur, qui je dois alors sérialiser pour une utilisation ultérieure. De ce que je peux dire, seulement le décapage est suffisamment polyvalent pour mes besoins. J'ai été en utilisant cPickle pour les stocker, mais les objets qu'il génère sont environ 40G de taille, à partir du code qui s'exécute dans 500 mo de mémoire. La vitesse de la sérialisation n'est pas un problème, mais la taille de l'objet. Existe-il des conseils ou d'autres processus que je peux utiliser pour faire les cornichons petits?

source d'informationauteur ddn

Si vous devez utiliser un cornichon et aucune autre méthode de sérialisation qui fonctionne pour vous, vous pouvez toujours la pipe le cornichon par bzip2. Le seul problème est que bzip2 est un peu slowish... gzip devrait être plus rapide, mais la taille du fichier est presque 2x plus grand:

In [1]: class Test(object):
            def __init__(self):
                self.x = 3841984789317471348934788731984731749374
                self.y = 'kdjsaflkjda;sjfkdjsf;klsdjakfjdafjdskfl;adsjfl;dasjf;ljfdlf'
        l = [Test() for i in range(1000000)]

In [2]: import cPickle as pickle          
        with open('test.pickle', 'wb') as f:
            pickle.dump(l, f)
        !ls -lh test.pickle
-rw-r--r--  1 viktor  staff    88M Aug 27 22:45 test.pickle

In [3]: import bz2
        import cPickle as pickle
        with bz2.BZ2File('test.pbz2', 'w') as f:
            pickle.dump(l, f)
        !ls -lh test.pbz2
-rw-r--r--  1 viktor  staff   2.3M Aug 27 22:47 test.pbz2

In [4]: import gzip
        import cPickle as pickle
        with gzip.GzipFile('test.pgz', 'w') as f:
            pickle.dump(l, f)
        !ls -lh test.pgz
-rw-r--r--  1 viktor  staff   4.8M Aug 27 22:51 test.pgz

Nous voyons donc que la taille du fichier de la bzip2 est presque 40x plus petits, gzip est 20x plus petits. Et gzip est assez proche de performances brutes cPickle, comme vous pouvez le voir:

cPickle : best of 3: 18.9 s per loop
bzip2   : best of 3: 54.6 s per loop
gzip    : best of 3: 24.4 s per loop

Vous pouvez combiner votre cPickle dump appel avec un zipfile:

import cPickle
import gzip

def save_zipped_pickle(obj, filename, protocol=-1):
    with gzip.open(filename, 'wb') as f:
        cPickle.dump(obj, f, protocol)

Et de re-charger une zippée marinés objet:

def load_zipped_pickle(filename):
    with gzip.open(filename, 'rb') as f:
        loaded_object = cPickle.load(f)
        return loaded_object

2

Vous pourriez vouloir utiliser un plus efficace de décapage protocole.

Comme de maintenant, il y a trois pickle protocoles:
- Protocole de la version 0 est l'origine protocole ASCII et est rétro-compatible avec les anciennes versions de Python.
- Le protocole version 1 est l'ancien format binaire, qui est également compatible avec les versions antérieures de Python.
- Protocole version 2 a été introduit en Python 2.3. Il fournit beaucoup plus efficace de décapage de la nouvelle-classes de style.
et, en outre, le protocole par défaut est 0, la moins efficace:

Si un protocole n'est pas spécifié, le protocole 0 est utilisé. Si le protocole est spécifié comme une valeur négative ou HIGHEST_PROTOCOL, la plus haute version de protocole disponible sera utilisé.

Nous allons vérifier la différence de taille entre l'utilisation de la dernière protocole, qui est actuellement le protocole 2 (la plus efficace) et utilisant le protocole de 0 (par défaut) pour un exemple au hasard. Notez que j'utilise le protocole=-1 ici, pour nous assurer de toujours utiliser la dernière protocole, et que je l'importation cPickle pour nous assurer d'utiliser la plus rapide C mise en œuvre:
```
import numpy
from sys import getsizeof
import cPickle as pickle

# Create list of 10 arrays of size 100x100
a = [numpy.random.random((100, 100)) for _ in xrange(10)]

# Pickle to a string in two ways
str_old = pickle.dumps(a, protocol=0)
str_new = pickle.dumps(a, protocol=-1)

# Measure size of strings
size_old = getsizeof(str_old)
size_new = getsizeof(str_new)

# Print size (in kilobytes) using old, using new, and the ratio
print size_old / 1024.0, size_new / 1024.0, size_old / float(size_new)
```
L'impression que je reçois est:
```
2172.27246094 781.703125 2.77889698975
```
Indiquant que le décapage à l'aide de l'ancien protocole utilisé 2172KB, le décapage en utilisant le nouveau protocole utilisé 782KB et la différence est un facteur de x2.8. Notez que ce facteur est spécifique à cet exemple - vos résultats peuvent varier, en fonction de l'objet sont de décapage.

Vous devez vous connecter pour publier un commentaire.