[PYTHON] Ich habe CycleGAN (1) implementiert.

Ich habe versucht, CycleGAN unter Linux zu implementieren

Dieses Mal habe ich versucht, CycleGAN zu implementieren. Grundsätzlich werden wir es basierend auf dem auf github veröffentlichten Code implementieren. Auf dieser Seite erklären und implementieren wir ein Light Paper. Ich möchte es das nächste Mal tun, wenn ich es mit meinem eigenen Datensatz anwende.

• Über CycleGAN
• Implementierung unter Linux

Es ist einfach, aber ich werde es anhand der beiden oben genannten Punkte erklären.

Über CycleGAN

Papier: https://arxiv.org/pdf/1703.10593.pdf Ich werde nach diesem Papier erklären.

Einführung

CycleGAN ist ein generatives Adversarial Network (GAN), das die Stilkonvertierung ermöglicht. Die obige Abbildung wird in diesem Artikel beschrieben. Wenn Sie jedoch eine Stilkonvertierung (Farbmalerei) wie links gezeigt durchführen möchten, lernen Sie die Verwendung mit Eingabe- und Ausgabebildpaaren wie ** pix2pix **. Die Methode wurde übernommen. Mit anderen Worten ist eine Eins-zu-Eins-Entsprechung erforderlich, wie in der Abbildung unter "Gepaart" gezeigt. Andererseits wurde auch eine Methode vorgeschlagen, die eine ungepaarte Stilkonvertierung ermöglicht, wie rechts gezeigt. Bei der ungepaarten Methode mussten verschiedene Abstandsräume wie Klassenbeschriftungsraum, Bildmerkmalsraum und Pixelraum für jede Stilkonvertierungsaufgabe definiert und verwendet werden, um die Eingabe und Ausgabe näher zusammenzubringen.

Daher wurde ** CycleGAN ** als eine solche Methode vorgeschlagen, die kein Eins-zu-Eins-Paar-Bild erfordert und die Lernmethode nicht entsprechend der Aufgabe ändern muss. Hier sind die von ** CycleGAN ** konvertierten Bilder. Bilder wie Landschaften wurden in den Stil der weltberühmten Maler Monet und Gogh verwandelt. Dies kann nicht mit Lernen erreicht werden, das Paare wie ** pix2pix ** erfordert. Denn um ein Bild von der von Gogh et al. Gezeichneten Landschaft zu machen, muss man sich Zeit nehmen. Außerdem ermöglicht es die Konvertierung zwischen Zebra und Pferd sowie die Konvertierung zwischen Sommer und Winter. Mit ** CycleGAN ** können Sie die Stilkonvertierung lernen, ohne die Lernmethode entsprechend der Aufgabe zu ändern.

Zielfunktion

Die Einführung von ** Cycle-Consustency Loss ** macht dies möglich. Dies ist das Herzstück dieser Methode, daher werde ich sie später erläutern. Das Bild oben zeigt den in ** Cycle-GAN ** verwendeten Verlust. Erstens wird ** (a) ** zu ** Adversarial Loss **, was der allgemeine Verlust von ** GAN ** ist. Durch die obige Formel formuliert, bedeutet Diskriminator im ersten Term, die realen Daten * y * von der realen Sache zu identifizieren. Der zweite Begriff bedeutet, die vom Generator erzeugten Daten als Fälschung zu identifizieren. Das Training wird so durchgeführt, dass dieser ** gegnerische Verlust ** für den Diskriminator maximiert (korrekt identifiziert) und für den Generator minimiert (falsch identifiziert) wird. Für Discriminator bedeutet die Maximierung des ersten Terms, dass der Wahrscheinlichkeitswert realer Daten * y * als 1 (echt) identifiziert wird. Die Bedeutung der Maximierung des zweiten Terms besteht auch darin, den Wahrscheinlichkeitswert der Fälschung * G (z) * zu identifizieren, die durch Verwendung von * G () * für * z * als 0 (Fälschung) erzeugt wird. Für Generator ist das Gegenteil der Fall. Der Zweck besteht darin, * G () * zu erstellen, das der Diskriminator nicht identifizieren kann. Wenn diese maximiert / minimiert werden, ist einer festgelegt. Indem wir diese Maximierung und Minimierung abwechselnd durchführen, werden wir mit dem Lernen fortfahren. Tun Sie dies für beide Domänen. Das heißt, <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 "> und <img width =" 135 "alt =" comment 2020-05-23 160533.png "src =" https: //qiita-image-store.s3. Dies bedeutet, dass wir für ap-northeast-1.amazonaws.com/0/642312/5cb2a163-436d-2f39-72c4-c9405cf63283.png "> optimieren.

Als nächstes sprechen wir über ** (b) ** und ** (c) **. Dies wird als ** Zykluskonsustenzverlust ** bezeichnet und durch die folgende Formel ausgedrückt. In diesem ersten Abschnitt wird * x * mit * G () * generiert und * G (x) * mit * F () * an die ursprüngliche Domäne zurückgegeben. * F (G (x)) )) * Ist richtig * x *, unter Verwendung der L1-Norm. Im zweiten Abschnitt machen Sie das Gegenteil. Die Idee ist einfach.

Schließlich kombinieren Sie ** (a) bis (c) **, Stellen Sie die Zielfunktion wie hier gezeigt ein. Durch Lösen dieses Optimierungsproblems können Sie die gewünschten * G * und * F * lernen.

Versuchsergebnis

Wenn Sie weitere Ergebnisse sehen möchten, schauen Sie sich bitte das Papier an.

Implementierung unter Linux

Öffentlicher Code https://github.com/xhujoy/CycleGAN-tensorflow

Montageumgebung

• 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

Im öffentlichen Datensatz implementiert

Klonen Sie git zunächst in ein beliebiges Verzeichnis. Wechseln Sie dann in das Verzeichnis "CycleGAN-tensorflow /". Dieses Mal werden wir den Datensatz ** Horse2zebra ** herunterladen, der auch in dem Artikel verwendet wurde.

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

Lernen

Als nächstes werden wir mit dem heruntergeladenen ** Horse2zebra ** -Datensatz trainieren.

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

Wenn Sie die GPU angeben, geben Sie sie mit CUDA_VISIBLE_DEVICES = an. Lernen beginnt.

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
.
.
.

Standardmäßig ist Epoche auf 200 Mal eingestellt. Sie können dies entsprechend dem von Ihnen angewendeten Datensatz ändern. Wenn Sie keine Transformationen lernen, die einen so großen Unterschied machen, können Sie versuchen, Epoche zu reduzieren. Beachten Sie, dass sich im heruntergeladenen Verzeichnis "datasets / Horse2zebra /" "testA /", "testB /", "trainA /" und "trainB /" befinden und dass sich in jedem Verzeichnis Bilder befinden. ____ ist drinnen. Selbst zum Zeitpunkt des Lernens wird der folgende Fehler ausgegeben, wenn weder in testA / noch in testB / Daten vorhanden sind.

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

Seien Sie vorsichtig, wenn Sie Ihren eigenen Datensatz erstellen und implementieren.

Prüfung

Der Test wird mit dem folgenden Befehl durchgeführt.

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

Geben Sie AtoB oder BtoA mit der Option --which_direction = an. Die Bilder in "Datensätze / Horse2zebra / TestA" oder "Datensätze / Horse2zebra / TestB" werden konvertiert und in "Test /" gespeichert. Jedes Bild ist leicht zu verstehen und mit "AtoB_" oder "BtoA_" gekennzeichnet.

Das Folgende ist ein Beispiel für die Testergebnisse.

• horse2zebra (AtoB)

• zebra2horse (BtoA) Die Konvertierung erfolgt fest. Es ist großartig. Das Obige ist die Implementierung unter Linux. Das nächste Mal möchte ich es auf meinen eigenen Datensatz anwenden.

Referenzmaterial

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