Reconstruction de l'affiche de propagande soviétique par PyTorch x VAEGAN

Aperçu

Dans la continuité de la dernière fois, nous mettons en œuvre diverses choses en tant que pratique de programmation. Cette fois, j'utiliserai VAEGAN pour reconstruire l'affiche de propagande. (Soudain, pourquoi l'Union soviétique? C'est vraiment juste un passe-temps. Il n'y a pas de revendications politiques.)

Si vous avez des suggestions techniques, je vous serais reconnaissant de bien vouloir commenter. Ce que vous pouvez comprendre dans cet article, c'est le niveau de reconstruction du VAEGAN et les points à garder à l'esprit lors de l'apprentissage du GAN.

** Le flux de reconstruction est le suivant. ** **

1. Collectez des affiches de propagande (données d'apprentissage)
2. Apprenez avec VAEGAN
3. Reconstruisez les données à l'aide du modèle entraîné

De plus, l'implémentation de VAEGAN de PyTorch est basée sur ici. Merci beaucoup.

À propos du VAEGAN

Autoencoding beyond pixels using a learned similarity metric Dans un GAN simple normal, il existe deux modèles, Générateur et Discriminateur, et ils peuvent apprendre par un apprentissage hostile l'un à l'autre, de sorte qu'un bon Générateur puisse apprendre. Cependant, le problème avec le GAN est que l'entrée ** Generator est un bruit aléatoire. ** Ce que je veux dire, c'est que l'entrée est aléatoire, donc je veux ces données explicitement! Même ainsi, il n'est pas possible de générer les données ciblées avec un GAN normal. VAEGAN, en revanche, est conçu pour vous permettre de reconstruire explicitement les données que vous souhaitez. Cela signifie que le générateur a été remplacé par VAE. Cela permet de reconstruire explicitement des données proches des données d'entrée. Cette fois, je reconstruirai explicitement les données des affiches de style soviétique.

Collecter des données d'entraînement

J'ai utilisé Image Downloader. Cette extension pour Chrome est incroyablement utile lors de la collecte de données d'entraînement. c'est recommandé. Et j'ai rassemblé environ 300 feuilles des données suivantes.

Non, ce sentiment d'avant-garde est merveilleux! (C'est juste un passe-temps)

Apprenez avec VAEGAN

Pour la mise en œuvre, je me suis essentiellement référé à ce qui précède. Cependant, il y avait des moments où je ne pouvais pas bien apprendre tel quel (la reconstruction a échoué), alors je fais quelques corrections. ** Il existe deux types principaux: la fonction d'erreur et la définition du modèle. ** **

La fonction d'erreur a changé L_llike de Enc_loss dans train.py en aucun comme suit. De plus, le L_gan_fake de Dec_loss a été modifié sans lui. Les deux L_llike et L_gan_fake ci-dessus semblent incorporer les fonctionnalités de Discriminator dans la fonction d'erreur. Dans mon environnement, il n'était malheureusement pas possible de converger avec la version originale ...

train.py

# Enc_loss ---
    Enc_loss = L_prior + L_recon 
    Enc_loss.backward()
    Enc_optimizer.step()
    Enc_running_loss += Enc_loss.item()

    # train Decoder ===
    Dec_optimizer.zero_grad()

    x_real = Variable(data)
    z_fake_p = Variable(torch.randn(opt.batch_size, opt.nz))
    if opt.use_gpu:
      x_real = x_real.cuda()
      z_fake_p = z_fake_p.cuda()
    x_fake, mu, logvar = G(x_real)

    # L_gan ---
    y_real_loss = bce_loss(D(x_real), t_fake)
    y_fake_loss = bce_loss(D(x_fake), t_real)
    y_fake_p_loss = bce_loss(D(G.decoder(z_fake_p)), t_real)
    L_gan_fake = (y_real_loss + y_fake_loss + y_fake_p_loss) / 3.0

    # L_llike ---
    L_recon = opt.gamma * l1_loss(x_fake, x_real)
    L_llike = l1_loss(D.feature(x_fake), D.feature(x_real))

    # Dec_loss ---
    Dec_loss = L_recon + L_llike
    Dec_loss.backward()
    Dec_optimizer.step()
    Dec_running_loss += Dec_loss.item()

Dans la définition du modèle, les principaux changements sont que la fonction d'activation de chaque modèle est définie sur LeakyReLU et que BatchNorm2d de Discriminator est supprimé. En outre, la taille d'entrée est de 128 x 128 et le canal est de 3 car il s'agit d'une image couleur.

Reconstruire les données à l'aide d'un modèle entraîné

J'ai tourné train.py et enregistré le résultat de la reconstruction toutes les 100 époques dans le répertoire des journaux. Calculé avec epoch = 1000, batchsize = 16 et dimension variable latente = 32. Le résultat de la reconstruction est le suivant. La partie supérieure de chaque image est l'image d'entrée et la partie inférieure est le résultat de sortie de VAEGAN.

100epoch 300epoch 600epoch 1000epoch

Considération

VAEGAN Je pensais honnêtement que c'était incroyable. À la 100e époque, le résultat de la reconstruction est flou, mais si vous tournez 1000epoch, vous pouvez le reproduire parfaitement de sorte qu'il n'y ait presque aucune différence avec la chose réelle (entrée). Le papier VAEGAN mentionné au début de cet article a également fait une comparaison avec la VAE, et je savais qu'il pouvait être reconstruit de manière extrêmement soignée, mais cette vérification m'a fait réaliser à nouveau. ** Mais il y a beaucoup de choses à garder à l'esprit lors de l'apprentissage du GAN. ** ** Tout d'abord, l'apprentissage du GAN a tendance à être compliqué et difficile à stabiliser, nous devons donc prêter attention à la transition de Loss of Discriminator et à d'autres modèles. Les cas qui ne fonctionnent pas sont la perte du discriminateur convergeant à un rythme énorme, ou l'autre perte ne convergeant pas du tout et plutôt divergente. Cette fois, il y a eu un cas où Discriminator a convergé brusquement, j'ai donc supprimé BatchNorm2d de Discriminator. De plus, il semble que Leaky ReLU soit utilisé plutôt que ReLU dans les modèles récents de GAN. En outre, here est également utile comme contre-mesure pour les situations où l'apprentissage du GAN ne se passe pas bien.