¿Cómo descomprimir el archivo pkl?

Tengo un archivo pkl del conjunto de datos MNIST, que consta de imágenes de dígitos escritas a mano.

Me gustaría echar un vistazo a cada una de esas imágenes de dígitos, así que necesito descomprimir el archivo pkl, excepto que no puedo averiguar cómo.

¿Hay alguna forma de descomprimir / descomprimir el archivo pkl?

En general

Su pklarchivo es, de hecho, un picklearchivo serializado , lo que significa que se ha descargado utilizando el picklemódulo de Python .

Para eliminar el encurtido de los datos puede:

import pickle


with open('serialized.pkl', 'rb') as f:
    data = pickle.load(f)

Para el conjunto de datos MNIST

La nota gzipsolo es necesaria si el archivo está comprimido:

import gzip
import pickle


with gzip.open('mnist.pkl.gz', 'rb') as f:
    train_set, valid_set, test_set = pickle.load(f)

Donde cada conjunto se puede dividir aún más (es decir, para el conjunto de entrenamiento):

train_x, train_y = train_set

Esas serían las entradas (dígitos) y salidas (etiquetas) de sus conjuntos.

Si desea mostrar los dígitos:

import matplotlib.cm as cm
import matplotlib.pyplot as plt


plt.imshow(train_x[0].reshape((28, 28)), cmap=cm.Greys_r)
plt.show()

La otra alternativa sería mirar los datos originales:

http://yann.lecun.com/exdb/mnist/

Pero eso será más difícil, ya que deberá crear un programa para leer los datos binarios en esos archivos. Así que te recomiendo que uses Python y cargues los datos con pickle. Como has visto, es muy fácil. ;-)

Práctico de una sola línea

pkl() (
  python -c 'import pickle,sys;d=pickle.load(open(sys.argv[1],"rb"));print(d)' "$1"
)
pkl my.pkl

Imprimirá __str__para el objeto en escabeche.

El problema genérico de visualizar un objeto, por supuesto, no está definido, por lo que si __str__no es suficiente, necesitará un script personalizado.

En caso de que desee trabajar con los archivos MNIST originales, así es como puede deserializarlos.

Si aún no ha descargado los archivos, hágalo primero ejecutando lo siguiente en la terminal:

wget http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
wget http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
wget http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
wget http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz

Luego guarde lo siguiente como deserialize.pyy ejecútelo.

import numpy as np
import gzip

IMG_DIM = 28

def decode_image_file(fname):
    result = []
    n_bytes_per_img = IMG_DIM*IMG_DIM

    with gzip.open(fname, 'rb') as f:
        bytes_ = f.read()
        data = bytes_[16:]

        if len(data) % n_bytes_per_img != 0:
            raise Exception('Something wrong with the file')

        result = np.frombuffer(data, dtype=np.uint8).reshape(
            len(bytes_)//n_bytes_per_img, n_bytes_per_img)

    return result

def decode_label_file(fname):
    result = []

    with gzip.open(fname, 'rb') as f:
        bytes_ = f.read()
        data = bytes_[8:]

        result = np.frombuffer(data, dtype=np.uint8)

    return result

train_images = decode_image_file('train-images-idx3-ubyte.gz')
train_labels = decode_label_file('train-labels-idx1-ubyte.gz')

test_images = decode_image_file('t10k-images-idx3-ubyte.gz')
test_labels = decode_label_file('t10k-labels-idx1-ubyte.gz')

El script no normaliza los valores de los píxeles como en el archivo decapado. Para hacer eso, todo lo que tienes que hacer es

train_images = train_images/255
test_images = test_images/255

El pepinillo (y gzip debe utilizar el módulo si el archivo está comprimido)

NOTA: Estos ya están en la biblioteca estándar de Python. No es necesario instalar nada nuevo