[PYTHON] GAN: DCGAN Part3 - Wasserstein GAN verstehen

Ziel

Dies ist eine Fortsetzung von DCGAN mit dem Microsoft Cognitive Toolkit (CNTK).

In Teil 3 werden wir WassersteinGAN von CNTK anhand der in Teil 1 erstellten Bilddaten trainieren. Es wird davon ausgegangen, dass CNTK und NVIDIA GPU CUDA installiert sind.

Einführung

GAN: DCGAN Part2-Training DCGAN-Modell befasste sich mit dem Gesichtsgenerierungsmodell von Deep Convolutional Generative Adversarial Network (DCGAN), daher haben wir Wasserstein GAN in Teil 3 erstellt. Und trainieren.

Wasserstein GAN Die diesmal implementierte Netzwerkstruktur von Wasserstein GAN [1] entspricht der von Teil2.

Wasserstein GAN verwendet jedoch nicht die Sigmoid-Funktion in der Ausgabeschicht von Discriminator, weshalb Discriminator als kritisch bezeichnet wird. Diese Implementierung ersetzt auch alle Critic Batch Normalizations durch Layer Normalization [2].

Der Unterschied zwischen dem ursprünglichen GAN [3] (nennen wir es Vanilla GAN (VGAN)) und Wasserstein GAN (WGAN) wird später erläutert.

Einstellungen im Training

Der Anfangswert der Parameter der Translokationsfaltung / Faltungsschicht wurde auf die Normalverteilung [4] mit einer Varianz von 0,02 eingestellt.

Die diesmal implementierte Verlustfunktion ist in der folgenden Gleichung dargestellt. [5]

\max_{C} \mathbb{E}_{x \sim p_{r}(x)}[C(x)] - \mathbb{E}_{z \sim p_z(z)}[C(G(z))] + \lambda \mathbb{E}_{x' \sim p_{x'}(x')}(||\nabla_{x'} C(x')||_2 - 1)^2 \\
\min_{G} -\mathbb{E}_{z \sim p_z(z)}[C(G(z))] \\
x' = \epsilon x + (1 - \epsilon) G(z), \epsilon \sim U[0, 1]

Wobei $ C $ und $ G $ Critic bzw. Generator darstellen, $ x $ das Eingabebild ist, $ z $ die latente Variable ist, $ p_r $ die Verteilung realer Bilddaten ist und $ p_z $ das gefälschte Bild ist. Die vorherige Verteilung, die die Daten erzeugt, $ U $, repräsentiert eine gleichmäßige Verteilung. Diesmal habe ich Wasserstein GAN mit Gradientenstrafe [5] implementiert und $ \ lambda $ auf 10 gesetzt.

Adam [6] wurde als Optimierungsalgorithmus sowohl für den Generator als auch für den Diskriminator verwendet. Die Lernrate wurde auf 1e-4 gesetzt, Adams Hyperparameter $ β_1 $ wurde auf 0,0 gesetzt und $ β_2 $ wurde auf den Standardwert von CNTK gesetzt.

Das Modelltraining führte 50.000 Iterationen mit Mini-Batch-Training der Mini-Batch-Größe 16 durch.

Implementierung

Ausführungsumgebung

Hardware-

・ CPU Intel (R) Core (TM) i7-6700K 4,00 GHz ・ GPU NVIDIA GeForce GTX 1060 6 GB

Software

・ Windows 10 Pro 1909 ・ CUDA 10.0 ・ CuDNN 7.6 ・ Python 3.6.6 ・ Cntk-gpu 2.7 ・ Opencv-Contrib-Python 4.1.1.26 ・ Numpy 1.17.3 ・ Pandas 0.25.0

Programm zum Ausführen

Das Schulungsprogramm ist auf [GitHub] verfügbar (https://github.com/sho-watari/GAN/tree/master/WassersteinGAN).

wgan_training.py

Kommentar

Obwohl es an einigen Stellen an Beweisen und Genauigkeit mangelt, möchte ich mein Verständnis der Mathematik von GAN vertiefen.

Dazu beginnen wir mit den Wahrscheinlichkeitsskalen Kullback-Leibler-Divergenz und Jensen-Shannon-Divergenz.

Kullback-Leibler divergence and Jensen-Shannon divergence

** Kullback-Leibler-Divergenz ** ist ein Maß für die beiden Wahrscheinlichkeitsverteilungen $ P (x) und Q (x) $. $ H $ steht für Entropie.

\begin{align}
D_{KL} (P || Q) &= \sum_x P(x) \log \frac{P(x)}{Q(x)}  \\
&= H(P, Q) - H(P)
\end{align}

Die KL-Divergenz hat jedoch keine SymmetrieD_{KL} (P || Q) \neq D_{KL} (Q || P)ist.

Die Entropie $ H $ wird durch die folgende Formel ausgedrückt.

H(P, Q) = \mathbb{E}_{x \sim P(x)} [- \log Q(x)] \\
H(P) = \mathbb{E}_{x \sim P(x)} [- \log P(x)]

Wenn die Notation damit leicht geändert wird, kann sie wie folgt ausgedrückt werden.

\begin{align}
D_{KL} (P || Q) &= H(P, Q) - H(P) \\
&= \mathbb{E}_{x \sim P(x)} [- \log Q(x)] - \mathbb{E}_{x \sim P(x)} [- \log P(x)] \\
&= \mathbb{E}_{x \sim P(x)} [- \log Q(x) - (- \log P(x))] \\
&= \mathbb{E}_{x \sim P(x)} [\log P(x) - \log Q(x)] \\
\end{align}

Andererseits ist die Jensen-Shannon-Divergenz, die eine abgeleitete Version der KL-Divergenz ist, wie folgt definiert.

D_{JS} (P || Q) = \frac{1}{2} D_{KL} (P || M) + \frac{1}{2} D_{KL} (Q || M) \\
M = \frac{P + Q}{2}

JS-Divergenz hat Symmetrie und ist $ 0 \ leq D_ {JS} \ leq 1 $. Wenn daher die JS-Divergenz groß ist, sind die beiden Verteilungen nicht ähnlich, und umgekehrt sind die beiden Verteilungen ähnlich, wenn die JS-Divergenz klein ist.

Vanilla GAN Das Generierungsmodell einschließlich GAN zielt darauf ab, ein solches Generierungsmodell basierend auf der Hypothese zu erwerben, dass die tatsächlich beobachteten Daten ein Generierungsmodell haben.

Zunächst seien $ D und G $ Diskriminator, Generator, $ p_r $ die Verteilung realer Daten und $ p_z $ die vorherige Verteilung zur Erzeugung gefälschter Daten. Die Auswertungsfunktionen von Diskriminator und Generator seien außerdem $ V_D und V_G $.

In Anbetracht der Tatsache, dass Discriminator ein Problem bei der Unterscheidung zwischen echten und gefälschten Daten darstellt, kann die Bewertungsfunktion von Discriminator durch die folgende Formel ausgedrückt werden.

V_D = \mathbb{E}_{x \sim p_r(x)}[\log D(x)] + \mathbb{E}_{z \sim p_z(z)}[\log (1 - D(G(z)))]

Wenn wir ein Nullsummenspiel einführen, bei dem die Summe der Verstärkungen der Diskriminator- und Generator-Bewertungsfunktionen 0 ist, ist es natürlich, die Generator-Bewertungsfunktion wie folgt zu definieren.

V_G = - V_D

Hier ist bekannt, dass das Nash-Gleichgewicht des Nullsummenspiels (die Lösung, die das lokale Minimum für $ V_D $ und das lokale Minimum für $ V_G $ ist) die Minimax-Lösung ist, sodass die Verlustfunktion von VGAN definiert ist.

\min_G \max_D V(G, D) = \mathbb{E}_{x \sim p_r(x)}[\log D(x)] + \mathbb{E}_{z \sim p_z(z)}[\log (1 - D(G(z)))]

Nun müssen wir zeigen, dass das Optimierungsproblem in der obigen Gleichung eine eindeutige Lösung $ G ^ * $ hat, nämlich $ p_g = p_r $. Zu diesem Zeitpunkt wird die folgende Formel als implizites Verständnis verwendet.

\mathbb{E}_{z \sim p_z(z)}[\log (1 - D(G(z)))] = \mathbb{E}_{x \sim p_g(x)}[\log (1 - D(x))]

Betrachtet man die Verlustfunktion von VGAN als kontinuierliche Funktion,

\begin{align}
V(G, D) &= \int_x p_r(x) \log(D(x))dx + \int_z p_z(z) \log(1 - D(G(z)))dz \\
&= \int_x p_r(x) \log(D(x)) + p_g(x) \log(1 - D(x))dx
\end{align}

In Anbetracht des kritischen Punktes der Funktion $ f (y) = a \ log y + b \ log (1-y) $ wird hier also von 0 unterschieden

f'(y) = 0 \Rightarrow \frac{a}{y} - \frac{b}{1 - y} = 0 \Rightarrow y = \frac{a}{a + b}

Wenn man die doppelte Differenzierung in $ \ frac {a} {a + b} $ betrachtet, kann man auch sehen, dass es nach oben konvex ist, weil es $ a, b \ in (0, 1) $ ist.

f'' \left( \frac{a}{a + b} \right) = - \frac{a}{(\frac{a}{a + b})^2} - \frac{b}{(1 - \frac{a}{a + b})^2} < 0

Daher ist $ \ frac {a} {a + b} $ das Maximum. Deshalb,

\begin{align}
V(G, D) &= \int_x p_r(x) \log(D(x))dx + \int_z p_z(z) \log(1 - D(G(z)))dz \\
&\leq \int_x \max_y p_r(x) \log(D(x)) + p_g(x) \log(1 - D(x))dx
\end{align}

Es stellt sich heraus, dass der Maximalwert ist, wenn $ D_ {G} (x) = \ frac {p_r} {p_r + p_g} $, was eine ausreichend eindeutige Lösung ist. Es ist jedoch nicht möglich, die optimale Lösung für $ D $ zu finden. Weil es keine Möglichkeit gibt, die wahre Verteilung der realen Daten $ p_r $ zu kennen. Es stellt sich jedoch heraus, dass $ p_r $ die Existenz einer optimalen Lösung für $ G $ anzeigt und dass sich das Training auf die Annäherung an $ D $ konzentrieren sollte.

Als nächstes möchte ich bei der Betrachtung der optimalen Lösung für Generator wiederholen, dass das endgültige Ziel von GAN $ p_g = p_r $ ist. Zu diesem Zeitpunkt ist $ D_ {G} ^ {*} $

D_{G}^{*} = \frac{p_r}{p_r + p_g} = \frac{1}{2}

Es wird sein. Angesichts des Generatorminimierungsproblems, wenn $ D_ {G} ^ {*} $ erhalten wird,

\begin{align}
\max_D V(G, D_{G}^{*}) &= \mathbb{E}_{x \sim p_r(x)}[\log D_{G}^{*}(x)] + \mathbb{E}_{z \sim p_z(z)}[\log (1 - D_{G}^{*}(G(z)))] \\
&= \mathbb{E}_{x \sim p_r(x)}[\log D_{G}^{*}(x)] + \mathbb{E}_{x \sim p_g(x)}[\log (1 - D_{G}^{*}(x))] \\
&= \mathbb{E}_{x \sim p_r(x)} \left[\log \frac{p_r}{p_r + p_g} \right] + \mathbb{E}_{x \sim p_g(x)} \left[\log \frac{p_g}{p_r + p_g} \right] \\
&= \mathbb{E}_{x \sim p_r(x)} [\log p_r - \log (p_r + p_g)] + \mathbb{E}_{x \sim p_g(x)} [\log p_g - \log (p_r + p_g)] \\
&= \mathbb{E}_{x \sim p_r(x)} \left[\log p_r - \log \left(\frac{p_r + p_g}{2} \cdot 2 \right) \right] + \mathbb{E}_{x \sim p_g(x)} \left[\log p_g - \log \left(\frac{p_r + p_g}{2} \cdot 2 \right) \right] \\
&= \mathbb{E}_{x \sim p_r(x)} \left[\log p_r - \log \left(\frac{p_r + p_g}{2} \right) - \log 2 \right] + \mathbb{E}_{x \sim p_g(x)} \left[\log p_g - \log \left(\frac{p_r + p_g}{2} \right) - \log 2 \right] \\
&= \mathbb{E}_{x \sim p_r(x)} \left[\log p_r - \log \left(\frac{p_r + p_g}{2} \right) \right] + \mathbb{E}_{x \sim p_r(x)} [- \log 2] + \mathbb{E}_{x \sim p_g(x)} \left[\log p_g - \log \left(\frac{p_r + p_g}{2} \right) \right] + \mathbb{E}_{x \sim p_g(x)} [ - \log 2] \\
\end{align}

Hier mit KL-Divergenz,

\begin{align}
\max_D V(G, D_{G}^{*}) = D_{KL} \left(p_r \middle| \middle| \frac{p_r + p_g}{2} \right) + D_{KL} \left(p_g \middle| \middle| \frac{p_r + p_g}{2} \right) - \log 4
\end{align}

Wenn außerdem $ \ frac {p_r + p_g} {2} = M $, dann aus der JS-Divergenz,

\max_D V(G, D_{G}^{*}) = 2 \cdot D_{JS} (p_r || p_g) - \log 4

Wenn also $ p_g = p_r $ ist, stellen wir fest, dass wir $ - \ log 4 $ als Kandidaten für das globale Minimum haben, und gleichzeitig können wir uns das Problem der Generatorminimierung als Minimierung der JS-Divergenz vorstellen.

Aus dem obigen theoretischen Hintergrund ist es möglich, das Generierungsmodell mit ausreichender Ausdruckskraft und realen Daten zu lernen, aber es ist immer noch schwierig, GAN zu trainieren.

Wasserstein GAN In einem Artikel, in dem GAN [7] analysiert wurde, wurde der Grund für die Schwierigkeit des VGAN-Trainings klargestellt, und die Autoren dieses Papiers schlugen WGAN [[1]](# reference) als Lösung vor. # Es ist eine Referenz.

In VGAN skalierte Generator schließlich auf JS-Divergenz, in WGAN jedoch auf Wasserstein-Entfernung.

Die Wasserstein-Entfernung, auch als Earth-Mover-Entfernung (EM) bezeichnet, ist ein Maß, das auf Transportoptimierungsproblemen basiert und die Kosten für die Annäherung einer Wahrscheinlichkeitsverteilung an eine andere darstellt.

W(p_r, p_g) = \inf_{\gamma \in \Pi(p_r, p_g)} \mathbb{E}_{(x, y) \sim \gamma} [||x - y||]

Der Wasserstein-Abstand hat vorteilhafte Eigenschaften, die bei KL-Divergenz oder JS-Divergenz nicht zu finden sind. Wenn sich die beiden Wahrscheinlichkeitsverteilungen nicht überlappen, divergiert die KL-Divergenz und die JS-Divergenz beträgt $ \ log 2 $, was sie nicht unterscheidbar macht, aber der Wasserstein-Abstand hat einen glatten Wert und daher einen Gradienten. Die Optimierung ist gesetzlich stabil.

Und die Wasserstein-Distanz wird basierend auf der Kantorovich-Rubinstein-Dualität transformiert, um eine Verlustfunktion wie die folgende zu erhalten. Wo $ C, G $ für Critic, Generator steht.

\min_G \max_{||C||_L \leq K} \mathbb{E}_{x \sim p_r(x)}[C(x)] - \mathbb{E}_{z \sim p_z(z)}[C(G(z))]

Die Wasserstein-Entfernung unterliegt jedoch einer Einschränkung, die als Lipshitz-Kontinuität bezeichnet wird, und wir verwenden die Methode zum Abschneiden des Gewichtsparameters, um dies zu gewährleisten.

Da das Abschneiden des Gewichts jedoch eine Brute-Force-Methode ist, kann das Training fehlschlagen, und als Abhilfe wurde eine Gradientenstrafe [5] vorgeschlagen.

Die Gradientenstrafe nutzt die Tatsache aus, dass in der optimierten Kritik die L2-Norm des Gradienten für jeden Punkt zwischen den realen und den generierten Daten 1 ist, und die Verlustfunktion nutzt die Tatsache aus, dass die L2-Norm des Gradienten nicht 1 ist. Ist ein Weg zu bestrafen.

\lambda \mathbb{E}_{x' \sim p_{x'}(x')}(||\nabla_{x'} C(x')||_2 - 1)^2

Jeder Punkt $ x '$ zwischen den realen Daten und den generierten Daten wird durch ein Bild dargestellt, das eine zufällige Mischung aus den realen Bilddaten und den vom Generator generierten Bilddaten ist.

x' = \epsilon x + (1 - \epsilon) G(z), \epsilon \sim U[0, 1]

Außerdem sind Gewichtsbeschneidung und Gradientenstrafe zu restriktiv und verringern die Ausdruckskraft des Generators. Daher verwendet DRAGAN [[8]](] einen Regularisierungsterm, der die L2-Norm des Gradienten in der Nähe realer Daten nahe 1 bringt. #) Wird ebenfalls vorgeschlagen.

Ergebnis

Diskriminator- und Generatorverlustfunktionen

Die folgende Abbildung zeigt eine Visualisierung jeder Verlustfunktion während des Trainings. Die horizontale Achse repräsentiert die Anzahl der Wiederholungen und die vertikale Achse repräsentiert den Wert der Verlustfunktion. Die Werte von Critic und Generator sind sehr groß.

Generierte Bilder und Übergänge während des Trainings

Die folgende Abbildung zeigt das vom trainierten Generator erzeugte Gesichtsbild. Einige Bilder sind trotz der Funktion mit großem Verlust fehlgeschlagen, aber sie scheinen ein besser aussehendes Gesichtsbild zu erzeugen als Teil 2.

Die folgende Abbildung zeigt den Übergang der Bilderzeugung während des Trainings mit Animation.

Quantitative Bewertung anhand des Inception Score

Als ich den Inception Score [10] mit Inception-v3 [9] wie in Teil 2 gemessen habe, wurden die folgenden Ergebnisse erhalten.

Inception Score 2.14

Referenz

CNTK 206 Part C: Wasserstein and Loss Sensitive GAN with CIFAR Data

GAN : DCGAN Part1 - Scraping Web images GAN : DCGAN Part2 - Training DCGAN model

1. Martin Arjovsky, Soumith Chintala, and Leon Bottou, "Wasserstein GAN", arXiv preprint arXiv:1701.07875 (2017).
2. Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E. Hinton. "Layer Normalization", arXiv preprint arXiv:1607.06450 (2016).
3. Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mira, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. "Generative Adversarial Nets", Advances in neural information processing systems. 2014, pp 2672-2680.
4. Alec Radford, Luke Metz, and Soumith Chintal. "Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks", arXiv preprint arXiv:1511.06434 (2015).
5. Ishaan Gulrahani, Faruk Ahmed, Martin Arjovsky, Vincent DuMoulin, and Aron Courville. "Improved Training of Wasserstein GANs", Neural Information Processing Systems (NIPS). 2017, pp 5767-5777.
6. Diederik P. Kingma and Jimmy Lei Ba. "Adam: A method for stochastic optimization", arXiv preprint arXiv:1412.6980 (2014).
7. Martin Arjovsky and Leon Bottou, "Towards Princiled Methods for Training Generative Adversarial Networks", International Conference on Learning Representations (ICLR). 2017.
8. Naveen Kodali, Hacob Avernethy, James Hays, and Zsolt Kira, "On Covergence and Stability of GANs", arXiv preprint arXiv:1705.07215.
9. Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. "Rethinking the Inception Architecture for Computer Vision", The IEEE Conference on Computer Vision and Pattern Recognition (CVPR). 2016, pp 2818-2826.
10. Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen, "Improved Techniques for Training GANs", Neural Information Processing Systems. 2016. pp 2234-2242.