vqvae

Vector quantizado AutoEncoder variacional

Esta é uma implementação de Pytorch do vetor quantizado autoencoder variacional (https://arxiv.org/abs/1711.00937).

Você pode encontrar a implementação original do autor no TensorFlow aqui com um exemplo que você pode executar em um notebook Jupyter.

Instalando dependências

Para instalar dependências, crie um ambiente condá ou virtual com o Python 3 e execute pip install -r requirements.txt .

Correndo o VQ VAE

Para executar o VQ-VAE, simplesmente execute python3 main.py Certifique -se de incluir o sinalizador -save se você deseja salvar seu modelo. Você também pode adicionar parâmetros na linha de comando. Os valores padrão são especificados abaixo:

 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

O VQ VAE possui os seguintes componentes fundamentais do modelo:

1. Uma classe Encoder que define o mapa x -> z_e
2. Uma classe VectorQuantizer que transforma a saída do codificador em um vetor discreto de um hot que é o índice do vetor de incorporação mais próximo z_e -> z_q
3. Uma classe Decoder que define o mapa z_q -> x_hat e reconstrua a imagem original

As classes do codificador / decodificador são pilhas convolucionais convolucionais e inversas, que incluem blocos residuais em sua arquitetura, consulte o papel Resnet. Os modelos residuais são definidos pelas classes ResidualLayer e ResidualStack .

Esses componentes estão organizados na seguinte estrutura de pastas:

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

Pixelcnn - Amostragem do espaço latente VQ VAE

Para amostrar do espaço latente, ajustamos um pixelcnn nos valores latentes de pixels z_ij . O truque aqui é reconhecer que o VQ VAE mapeia uma imagem para um espaço latente que tenha a mesma estrutura que uma imagem de 1 canal. Por exemplo, se você executar os parâmetros VQ VQ padrão, você rgb mapa imagens de forma (32,32,3) em um espaço latente com forma (8,8,1) , o que é equivalente a uma imagem em escala de cinza de 8x8. Portanto, você pode usar um pixelcnn para ajustar uma distribuição sobre os valores "Pixel" do espaço latente de 1 canal 8x8.

Para treinar o pixelcnn em representações latentes, primeiro você precisa seguir estas etapas:

1. Treine o VQ VAE no seu conjunto de dados de escolha
2. Use parâmetros VQ VQ salvos para codificar seu conjunto de dados e salvar representações de espaço latente discretas com a API np.save . No quantizer.py esta é a variável min_encoding_indices .
3. Especifique o caminho para o seu conjunto de dados de espaço latente salvo na função utils.load_latent_block .
4. Execute o script Pixelcnn

Para executar o pixelcnn, basta digitar

python pixelcnn/gated_pixelcnn.py

bem como quaisquer parâmetros (consulte as declarações argparse). O conjunto de dados padrão é LATENT_BLOCK , que só funcionará se você tiver treinado seu VQ VAE e salvou as representações latentes.