J'ai implémenté CycleGAN (1)

J'ai essayé d'implémenter CycleGAN sur Linux

Cette fois, j'ai essayé d'implémenter CycleGAN. Fondamentalement, nous allons l'implémenter en fonction du code publié sur github. Sur cette page, nous expliquerons et implémenterons un papier léger. J'aimerais le faire la prochaine fois que je l'appliquerai en utilisant mon propre ensemble de données.

--À propos de CycleGAN --Implémentation sous Linux

C'est facile, mais je vais l'expliquer en fonction des deux éléments ci-dessus.

À propos de CycleGAN

Papier: https://arxiv.org/pdf/1703.10593.pdf J'expliquerai d'après ce papier.

introduction

CycleGAN est un Réseau Adversaire Génératif (GAN) qui permet la conversion de style. La figure ci-dessus est décrite dans l'article, mais si vous souhaitez effectuer une conversion de style (peinture couleur) comme indiqué à gauche, apprendre à utiliser avec des paires d'images d'entrée et de sortie telles que ** pix2pix ** La méthode a été adoptée. En d'autres termes, une correspondance biunivoque, comme indiqué dans Paired sur la figure, est requise. D'autre part, une méthode qui permet la conversion de style non apparié comme indiqué à droite a également été proposée. Dans la méthode Unpaired, il était nécessaire de définir divers espaces de distance tels que l'espace d'étiquette de classe, l'espace de fonction d'image et l'espace de pixel pour chaque tâche de conversion de style, et de les utiliser pour rapprocher l'entrée et la sortie.

Par conséquent, ** CycleGAN ** a été proposé comme une méthode qui ne nécessite pas une image de paire un à un et qui n'a pas besoin de changer la méthode d'apprentissage en fonction de la tâche. Voici les images converties par ** CycleGAN **. Des images telles que des paysages ont été transformées dans le style des peintres de renommée mondiale Monet et Gogh. Cela ne peut pas être fait avec un apprentissage qui nécessite des paires comme ** pix2pix **. Car, pour prendre une photo du paysage dessiné par Gogh et al., Il faut passer le temps. Et il permet également la conversion entre le zèbre et le cheval, et la conversion entre l'été et l'hiver. Avec ** CycleGAN **, vous pouvez apprendre la conversion de style sans changer la méthode d'apprentissage en fonction de la tâche.

Fonction objective

L'introduction de la ** perte de consistance de cycle ** rend cela possible. C'est le cœur de cette méthode, donc je l'expliquerai plus tard. L'image ci-dessus montre la perte utilisée dans ** Cycle-GAN **. Premièrement, ** (a) ** devient ** Perte conflictuelle **, qui est la perte générale de ** GAN **. Formulé par la formule ci-dessus, dans le premier terme, Discriminator signifie identifier les données réelles * y * à partir de la chose réelle. Le deuxième terme signifie que les données générées par le générateur sont fausses. La formation est effectuée de manière à ce que cette ** perte contradictoire ** soit maximisée (correctement identifiée) pour le discriminateur et minimisée (mal identifiée) pour le générateur. Pour Discriminator, la maximisation du premier terme signifie que la valeur de probabilité des données réelles * y * est identifiée comme 1 (authentique). En outre, le sens de maximiser le deuxième terme est d'identifier la valeur de probabilité du faux * G (z) * généré en utilisant * G () * pour * z * comme 0 (faux). Pour Generator, le contraire est vrai. Le but est de créer * G () * que le discriminateur ne peut pas identifier. Lors de la maximisation / minimisation de ceux-ci, l'un est fixe. En effectuant alternativement cette maximisation et cette minimisation, nous procéderons à l'apprentissage. Faites ceci pour les deux domaines. Autrement dit, <img width = "134" alt = "comment 2020-05-23 160615.png " src = "https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/642312" /be5f6f1c-6454-ec9c-6140-e4ded0610b8f.png "> et <img width =" 135 "alt =" comment 2020-05-23 160533.png "src =" https: //qiita-image-store.s3. Cela signifie que nous optimiserons pour ap-northeast-1.amazonaws.com/0/642312/5cb2a163-436d-2f39-72c4-c9405cf63283.png ">.

Ensuite, parlons de ** (b) ** et ** (c) **. Ceci est appelé ** Perte de consistance de cycle ** et est exprimé par la formule suivante. Dans cette première section, * x * est généré en utilisant * G () * et * G (x) * est retourné au domaine d'origine en utilisant * F () *. * F (G (x) )) * Est correctement * x *, en utilisant la norme L1. Dans la deuxième section, vous faites le contraire. L'idée est simple.

Enfin, combinez ** (a) à (c) **, Réglez la fonction objectif comme indiqué ici. En résolvant ce problème d'optimisation, vous pouvez apprendre les * G * et * F * souhaités.

Résultat expérimental

Si vous voulez voir plus de résultats, veuillez consulter l'article.

Implémentation sous Linux

Code public https://github.com/xhujoy/CycleGAN-tensorflow

Environnement de montage

• Ubuntu 18.04 LTS
• Python 3.6
• PyTorch 0.4.0
• Tensorflow 1.4.0
• numpy 1.11.0
• scipy 0.17.0
• pillow 3.3.0

Implémenté dans un ensemble de données public

Tout d'abord, clonez git dans n'importe quel répertoire. Puis passez au répertoire CycleGAN-tensorflow /. Cette fois, nous allons télécharger l'ensemble de données ** horse2zebra ** qui a également été utilisé dans l'article.

$ git clone https://github.com/xhujoy/CycleGAN-tensorflow
$ cd CycleGAN-tensorflow/
$ bash ./download_dataset.sh horse2zebra

Apprentissage

Ensuite, nous nous entraînerons avec l'ensemble de données téléchargé ** horse2zebra **.

$ CUDA_VISIBLE_DEVICES=0 python main.py --dataset_dir=horse2zebra

Lorsque vous spécifiez le GPU, spécifiez-le avec CUDA_VISIBLE_DEVICES =. L'apprentissage commence.

Epoch: [ 0] [   0/1067] time: 14.2652
Epoch: [ 0] [   1/1067] time: 16.9671
Epoch: [ 0] [   2/1067] time: 17.6442
Epoch: [ 0] [   3/1067] time: 18.3194
Epoch: [ 0] [   4/1067] time: 19.0001
Epoch: [ 0] [   5/1067] time: 19.6724
Epoch: [ 0] [   6/1067] time: 20.3511
Epoch: [ 0] [   7/1067] time: 21.0326
Epoch: [ 0] [   8/1067] time: 21.7106
Epoch: [ 0] [   9/1067] time: 22.3866
Epoch: [ 0] [  10/1067] time: 23.0501
Epoch: [ 0] [  11/1067] time: 23.7298
.
.
.

Par défaut, Epoch est défini sur 200 fois. Vous pouvez modifier cela en fonction de l'ensemble de données que vous appliquez. Si vous n'apprenez pas les transformations qui font une si grande différence, vous pouvez essayer de réduire Epoch. Notez qu'il y a testA /, testB /, trainA / et trainB / dans le répertoire téléchargé datasets / horse2zebra /, et il y a des images dans chaque répertoire. ____ Est à l'intérieur. Même pendant l'apprentissage, s'il n'y a aucune donnée dans testA / ou testB /, l'erreur suivante sera générée.

ValueError: Cannot feed value of shape (1, 256, 256, 6) for Tensor 'real_A_and_B_images:0', which has shape '(?, 512, 512, 6)'

Soyez prudent lorsque vous créez et implémentez votre propre ensemble de données.

tester

Le test se fait avec la commande suivante.

$ CUDA_VISIBLE_DEVICES=0 python main.py --dataset_dir=horse2zebra --phase=test --which_direction=AtoB

Spécifiez AtoB ou BtoA avec l'option --which_direction =. Les images dans datasets / horse2zebra / testA ou datasets / horse2zebra / testB sont converties et enregistrées danstest /. Chaque image est facile à comprendre et est marquée par ʻAtoB_ouBtoA_`.

Voici un exemple des résultats du test.

• horse2zebra (AtoB)

• zebra2horse (BtoA) La conversion se fait fermement. c'est bien. Ce qui précède est l'implémentation sous Linux. La prochaine fois, j'aimerais l'appliquer à mon propre ensemble de données.

Matériel de référence

Papier: https://arxiv.org/pdf/1703.10593.pdf Github：https://github.com/xhujoy/CycleGAN-tensorflow