vqvae

Autoencoder variacional cuantificado de vector

Esta es una implementación de Pytorch del Autoencoder variacional cuantificado de vectores (https://arxiv.org/abs/1711.00937).

Puede encontrar la implementación original del autor en TensorFlow aquí con un ejemplo que puede ejecutar en un cuaderno Jupyter.

Instalación de dependencias

Para instalar dependencias, cree una condena o un entorno virtual con Python 3 y luego ejecute pip install -r requirements.txt .

Ejecutando el VQ VAE

Para ejecutar el VQ-VAE simplemente ejecute python3 main.py Asegúrese de incluir la bandera -save si desea guardar su modelo. También puede agregar parámetros en la línea de comando. Los valores predeterminados se especifican a continuación:

 parser . add_argument ( "--batch_size" , type = int , default = 32 )
parser . add_argument ( "--n_updates" , type = int , default = 5000 )
parser . add_argument ( "--n_hiddens" , type = int , default = 128 )
parser . add_argument ( "--n_residual_hiddens" , type = int , default = 32 )
parser . add_argument ( "--n_residual_layers" , type = int , default = 2 )
parser . add_argument ( "--embedding_dim" , type = int , default = 64 )
parser . add_argument ( "--n_embeddings" , type = int , default = 512 )
parser . add_argument ( "--beta" , type = float , default = .25 )
parser . add_argument ( "--learning_rate" , type = float , default = 3e-4 )
parser . add_argument ( "--log_interval" , type = int , default = 50 )

Modelos

El VQ VAE tiene los siguientes componentes del modelo fundamental:

1. Una clase Encoder que define el mapa x -> z_e
2. Una clase VectorQuantizer que transforma la salida del codificador en un vector discreto de un solo estado que es el índice del vector de incrustación más cercano z_e -> z_q
3. Una clase Decoder que define el mapa z_q -> x_hat y reconstruye la imagen original

Las clases de codificadores / decodificadores son pilas convolucionales convolucionales e inversas, que incluyen bloques residuales en su arquitectura, ver documento resnet. Los modelos residuales están definidos por las clases ResidualLayer y ResidualStack .

Estos componentes están organizados en la siguiente estructura de carpeta:

 models/
    - decoder.py -> Decoder
    - encoder.py -> Encoder
    - quantizer.py -> VectorQuantizer
    - residual.py -> ResidualLayer, ResidualStack
    - vqvae.py -> VQVAE

Pixelcnn - Muestreo del espacio latente VQ VAE

Para probar desde el espacio latente, se ajustamos a un PixelCnn sobre los valores de píxeles latentes z_ij . El truco aquí es reconocer que el VQ VAE asigna una imagen a un espacio latente que tiene la misma estructura que una imagen de 1 canal. Por ejemplo, si ejecuta los parámetros VQ VQ VQ predeterminados, RGB mapeará imágenes de forma (32,32,3) a un espacio latente con forma (8,8,1) , que es equivalente a una imagen de escala de grises 8x8. Por lo tanto, puede usar un PixelCNN para adaptarse a una distribución sobre los valores de "píxeles" del espacio latente de 1 canal de 8x8.

Para entrenar el Pixelcnn en representaciones latentes, primero debe seguir estos pasos:

1. Entrena el VQ VAE en tu conjunto de datos de elección
2. Use los parámetros de VQ VQ VA para codificar su conjunto de datos y guardar representaciones discretas de espacio latente con la API np.save . En quantizer.py esta es la variable min_encoding_indices .
3. Especifique la ruta a su conjunto de datos de espacio latente guardado en la función utils.load_latent_block .
4. Ejecute el script Pixelcnn

Para ejecutar el PixelCnn, simplemente escriba

python pixelcnn/gated_pixelcnn.py

así como cualquier parámetro (ver las declaraciones Argparse). El conjunto de datos predeterminado es LATENT_BLOCK , que solo funcionará si ha capacitado su VQ VAE y ha guardado las representaciones latentes.