Generatives kontradiktorisches Netzwerk, KI verwandelt Bilder in Comic-Stil

Hallo zusammen.

Jeder spielt kürzlich mit KI-Malerei. Ich habe auf GitHub ein Open-Source-Projekt gefunden, das ich mit Ihnen teilen möchte.

Das heute geteilte Projekt wird mit GAN​ Generative Adversarial Network umgesetzt. Wir haben bereits viele Artikel über die Prinzipien und die Praxis von GAN geteilt. Freunde, die mehr wissen möchten, können historische Artikel lesen.

Der Quellcode und der Datensatz sind am Ende des Artikels verfügbar. Lassen Sie uns erklären, wie das Projekt trainiert und ausgeführt wird.

1. Bereiten Sie die Umgebung vor

Installieren Sie tensorflow-gpu 1.15.0, verwenden Sie 2080Ti als GPU-Grafikkarte und cuda Version 10.0.

Laden Sie den Quellcode des Projekts AnimeGANv2 von Git herunter.

Nach dem Einrichten der Umgebung müssen Sie noch den Datensatz und vgg19 vorbereiten.

Laden Sie die komprimierte Datei dataset.zip herunter, die 6.000 echte Bilder und 2.000 Comic-Bilder für das GAN-Training enthält.

vgg19 wird zur Berechnung des Verlusts verwendet, der im Folgenden ausführlich vorgestellt wird.

2. Netzwerkmodell

Generatives gegnerisches Netzwerk muss zwei Modelle definieren, eines ist der Generator und das andere ist der Diskriminator.

Das Generatornetzwerk ist wie folgt definiert:

with tf.variable_scope('A'):
inputs = Conv2DNormLReLU(inputs, 32, 7)
inputs = Conv2DNormLReLU(inputs, 64, strides=2)
inputs = Conv2DNormLReLU(inputs, 64)

with tf.variable_scope('B'):
inputs = Conv2DNormLReLU(inputs, 128, strides=2)
inputs = Conv2DNormLReLU(inputs, 128)

with tf.variable_scope('C'):
inputs = Conv2DNormLReLU(inputs, 128)
inputs = self.InvertedRes_block(inputs, 2, 256, 1, 'r1')
inputs = self.InvertedRes_block(inputs, 2, 256, 1, 'r2')
inputs = self.InvertedRes_block(inputs, 2, 256, 1, 'r3')
inputs = self.InvertedRes_block(inputs, 2, 256, 1, 'r4')
inputs = Conv2DNormLReLU(inputs, 128)

with tf.variable_scope('D'):
inputs = Unsample(inputs, 128)
inputs = Conv2DNormLReLU(inputs, 128)

with tf.variable_scope('E'):
inputs = Unsample(inputs,64)
inputs = Conv2DNormLReLU(inputs, 64)
inputs = Conv2DNormLReLU(inputs, 32, 7)
with tf.variable_scope('out_layer'):
out = Conv2D(inputs, filters =3, kernel_size=1, strides=1)
self.fake = tf.tanh(out)

Das Hauptmodul im Generator ist der umgekehrte Restblock

Die Reststruktur (a) und der umgekehrte Restblock (b)

Die Diskriminatornetzwerkstruktur ist wie folgt:

def D_net(x_init,ch, n_dis,sn, scope, reuse):
channel = ch // 2
with tf.variable_scope(scope, reuse=reuse):
x = conv(x_init, channel, kernel=3, stride=1, pad=1, use_bias=False, sn=sn, scope='conv_0')
x = lrelu(x, 0.2)

for i in range(1, n_dis):
x = conv(x, channel * 2, kernel=3, stride=2, pad=1, use_bias=False, sn=sn, scope='conv_s2_' + str(i))
x = lrelu(x, 0.2)

x = conv(x, channel * 4, kernel=3, stride=1, pad=1, use_bias=False, sn=sn, scope='conv_s1_' + str(i))
x = layer_norm(x, scope='1_norm_' + str(i))
x = lrelu(x, 0.2)

channel = channel * 2

x = conv(x, channel * 2, kernel=3, stride=1, pad=1, use_bias=False, sn=sn, scope='last_conv')
x = layer_norm(x, scope='2_ins_norm')
x = lrelu(x, 0.2)

x = conv(x, channels=1, kernel=3, stride=1, pad=1, use_bias=False, sn=sn, scope='D_logit')

return x

3. Verlust

Vor der Berechnung des Verlusts wird das Bild mithilfe des VGG19-Netzwerks vektorisiert. Dieser Vorgang ähnelt ein wenig dem Einbettungsvorgang im NLP. Bei

Eembedding​ geht es um die Umwandlung von Wörtern in Vektoren, und bei VGG19 geht es um die Umwandlung von Bildern in Vektoren.

VGG19-Definition

Die Logik zur Berechnung des Verlustanteils lautet wie folgt:

def con_sty_loss(vgg, real, anime, fake):

# 真实Generatives kontradiktorisches Netzwerk, KI verwandelt Bilder in Comic-Stil向量化
vgg.build(real)
real_feature_map = vgg.conv4_4_no_activation

# 生成Generatives kontradiktorisches Netzwerk, KI verwandelt Bilder in Comic-Stil向量化
vgg.build(fake)
fake_feature_map = vgg.conv4_4_no_activation

# 漫画风格向量化
vgg.build(anime[:fake_feature_map.shape[0]])
anime_feature_map = vgg.conv4_4_no_activation

# 真实Generatives kontradiktorisches Netzwerk, KI verwandelt Bilder in Comic-Stil与生成Generatives kontradiktorisches Netzwerk, KI verwandelt Bilder in Comic-Stil的损失
c_loss = L1_loss(real_feature_map, fake_feature_map)
# 漫画风格与生成Generatives kontradiktorisches Netzwerk, KI verwandelt Bilder in Comic-Stil的损失
s_loss = style_loss(anime_feature_map, fake_feature_map)

return c_loss, s_loss

Hier wird vgg19 verwendet, um den Verlust des realen Bildes (Parameter real) bzw. des generierten Bildes (Parameter fake) zu berechnen. Das erzeugte Bild (Parameter Fake) und der Verlust des Comic-Stils (Parameter Anime).

c_loss, s_loss = con_sty_loss(self.vgg, self.real, self.anime_gray, self.generated)
t_loss = self.con_weight * c_loss + self.sty_weight * s_loss + color_loss(self.real,self.generated) * self.color_weight + tv_loss

Geben Sie diesen beiden Verlusten schließlich unterschiedliche Gewichte, damit die vom Generator generierten Bilder nicht nur das Aussehen der echten Bilder beibehalten, sondern auch in den Comic-Stil migrieren

4Führen Sie den folgenden Befehl aus Projektverzeichnis Nachdem Sie das Training gestartet

python train.py --dataset Hayao --epoch 101 --init_epoch 10

und erfolgreich ausgeführt haben, können Sie die Daten sehen.

Gleichzeitig sieht man aber auch, dass die Verluste zurückgehen.

Der Quellcode und der Datensatz wurden gepackt. Wenn Sie ihn benötigen, hinterlassen Sie einfach eine Nachricht im Kommentarbereich.

Wenn Sie der Meinung sind, dass dieser Artikel für Sie nützlich ist, klicken Sie bitte darauf und lesen Sie ihn, um mich zu ermutigen, auch in Zukunft hervorragende Python+KI-Projekte zu teilen.

Das obige ist der detaillierte Inhalt vonGeneratives kontradiktorisches Netzwerk, KI verwandelt Bilder in Comic-Stil. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!