vqvae

Vector Autoencoder variationnel vectoriel

Il s'agit d'une implémentation Pytorch de l'autoencoder variationnel quantifié vectoriel (https://arxiv.org/abs/1711.00937).

Vous pouvez trouver l'implémentation originale de l'auteur dans TensorFlow ici avec un exemple que vous pouvez exécuter dans un cahier Jupyter.

Installation des dépendances

Pour installer des dépendances, créez un environnement conda ou virtuel avec Python 3, puis exécutez pip install -r requirements.txt .

Exécuter le vq vae

Pour exécuter le VQ-VAE, exécutez simplement python3 main.py Assurez-vous d'inclure l'indicateur -save si vous souhaitez enregistrer votre modèle. Vous pouvez également ajouter des paramètres dans la ligne de commande. Les valeurs par défaut sont spécifiées ci-dessous:

 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 )

Modèles

Le VQ VAE a les composantes du modèle fondamental suivantes:

1. Une classe Encoder qui définit la carte x -> z_e
2. Une classe de VectorQuantizer qui transforme la sortie du codeur en un vecteur à un hot discret qui est l'index du vecteur d'intégration le plus proche z_e -> z_q
3. Une classe Decoder qui définit la carte z_q -> x_hat et reconstruit l'image d'origine

Les classes d'encodeur / décodeur sont des piles convolutionnelles convolutionnelles et inverses, qui incluent des blocs résiduels dans leur architecture voir le papier RESNET. Les modèles résiduels sont définis par les classes ResidualLayer et ResidualStack .

Ces composants sont organisés dans la structure du dossier suivant:

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

Pixelcnn - échantillonnage de l'espace latent vq vae

Pour échantillonner à partir de l'espace latent, nous montons un pixelcnn sur les valeurs du pixel latent z_ij . L'astuce ici est de reconnaître que le VQ VAE mappe une image à un espace latent qui a la même structure qu'une image à 1 canal. Par exemple, si vous exécutez les paramètres VQ VAA par défaut, vous allez Map RVB Images de forme (32,32,3) vers un espace latent avec forme (8,8,1) , ce qui équivaut à une image 8x8 en niveaux de gris. Par conséquent, vous pouvez utiliser un pixelcnn pour ajuster une distribution sur les valeurs "pixels" de l'espace latent à 1 canal 8x8.

Pour entraîner le pixelcnn sur les représentations latentes, vous devez d'abord suivre ces étapes:

1. Former le VQ VAE sur votre ensemble de données de choix
2. Utilisez des paramètres VQ VQ enregistrés pour coder votre ensemble de données et enregistrer des représentations d'espace latente discrètes avec l'API np.save . Dans le quantizer.py il s'agit de la variable min_encoding_indices .
3. Spécifiez le chemin d'accès à votre ensemble de données d'espace latent enregistré dans utils.load_latent_block .
4. Exécutez le script Pixelcnn

Pour exécuter le pixelcnn, tapez simplement

python pixelcnn/gated_pixelcnn.py

ainsi que tous les paramètres (voir les instructions ArgParse). L'ensemble de données par défaut est LATENT_BLOCK qui ne fonctionnera que si vous avez formé votre VQ VAE et enregistré les représentations latentes.