[PYTHON] Erstellung eines MNIST-Bilderzeugungsprogramms durch DCGAN (Tensorflow-Tutorial)

Was sind GAN und DCGAN?

Dieses Mal lernte ich GAN (Generative Adversarial Networks) kennen, einen unverzichtbaren Algorithmus im Bereich des Deep Learning. GAN ist eine Technologie, die 2014 von einem amerikanischen Forscher namens Lan Goodfellow entwickelt wurde. Durch das feindliche Training zweier Netzwerke wird ein Netzwerk generiert, das Daten generiert, die nicht von der Realität zu unterscheiden sind. Das ist. Auf Japanisch wird es direkt als Netzwerk zur Erzeugung von Feindseligkeiten übersetzt, aber ** der Name ist wie in Küche 2, und ich mag es, weil es cool ist. ** ** **

Dieses Mal habe ich meine eigene Interpretation von DCGAN zusammengefasst, die als Tutorial in der Tensorflow-URL erwähnt wird. https://www.tensorflow.org/tutorials/generative/dcgan?hl=ja Dieses Tutorial befasst sich mit einem Algorithmus, der MNIST (handgeschriebene Zahlen) mithilfe einer Technik namens DCGAN (Deep Convolutional GAN) generiert.

DCGAN ist ein Generationsmodell, das in einem auf der ICLR2016 (AI-Feldkonferenz) vorgestellten Papier vorgeschlagen wurde. Der Unterschied zum sogenannten GAN besteht darin, dass es Deep Convolutional = Convolution verwendet, ohne eine vollständig verbundene Schicht (Affine) auszuführen. Das vollständig verbundene Schichtmodell hat das Merkmal, dass der Gewichtungskoeffizient sehr groß ist und leicht zu überlernen ist, aber es scheint, dass ein Überlernen verhindert werden kann, wenn es nur durch Faltung zusammengesetzt wird. Andererseits ist die Konvergenz tendenziell langsam.

URL, die für GAN im Allgemeinen hilfreich war https://blog.negativemind.com/2019/09/07/deep-convolutional-gan/

Was ist das Modul future?

gan.py

from __future__ import absolute_import, division, print_function, unicode_literals

In Python 2.6 und höher können Sie mit diesem Code das Verhalten einiger Funktionen und Anweisungen in das Verhalten der Python 3-Serie ändern. Ich verstehe, dass es gelesen wird, wenn Sie 3 Serienfunktionen in Python 2-Serien verwenden möchten.

Über geladene Bibliotheken und Module

gan.py

import tensorflow as tf
import glob
import imageio
import matplotlib.pyplot as plt
import numpy as np
import os
import PIL
from tensorflow.keras import layers
import time

from IPython import display

Ich habe imageio und PIL (Pillow) als Bibliotheken für die Verarbeitung von Bildern geladen. OpenCV ist als Bildverarbeitungsbibliothek bekannt, aber Pillow soll einfacheren und verständlicheren Code haben. Ich habe glob auch als Modul geladen, das den Pfadnamen der Datei erhalten kann. Sie können Sonderzeichen wie Platzhalter * verwenden, um Pfade wie Dateinamen und Ordnernamen abzurufen, die die Bedingungen in einer Liste oder einem Iterator erfüllen.

https://note.nkmk.me/python-glob-usage/

Als nächstes folgt das IPython.display-Modul, mit dem Audio und Video in ein Notebook eingebettet werden können.

https://knowledge.sakura.ad.jp/17727/

Datensatz laden

gan.py

(train_images, train_labels), (_, _) = tf.keras.datasets.mnist.load_data()

train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
train_images = (train_images - 127.5) / 127.5 # Normalize the images to [-1, 1]

Dieses Mal wird MNSIT (handgeschriebenes Zahlenbild) aus dem Keras-Datensatz gelesen. Sie werden als Sequenz aufgelistet und standardisiert.

gan.py

BUFFER_SIZE =60000
BATCH_SIZE =256
train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)

Datensatz

https://qiita.com/Suguru_Toyohara/items/820b0dad955ecd91c7f3

Generatormodelldefinition

gan.py

def make_generator_model():
    model = tf.keras.Sequential()
    model.add(layers.Dense(7*7*256, use_bias=False, input_shape=(100,)))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())

    model.add(layers.Reshape((7, 7, 256)))
    assert model.output_shape == (None, 7, 7, 256) # Note: None is the batch size

    model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))
    assert model.output_shape == (None, 7, 7, 128)
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())

    model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))
    assert model.output_shape == (None, 14, 14, 64)
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())

    model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
    assert model.output_shape == (None, 28, 28, 1)

    return model

Definition des Diskriminatormodells

gan.py

def make_discriminator_model():
    model = tf.keras.Sequential()
    model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same',
                                     input_shape=[28, 28, 1]))
    model.add(layers.LeakyReLU())
    model.add(layers.Dropout(0.3))

    model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))
    model.add(layers.LeakyReLU())
    model.add(layers.Dropout(0.3))

    model.add(layers.Flatten())
    model.add(layers.Dense(1))

    return model

https://www.slideshare.net/HiroyaKato1/gandcgan-188544721 https://www.hellocybernetics.tech/entry/2018/05/28/180012 https://keras.io/ja/getting-started/sequential-model-guide/

Definition der Verlustfunktion

gan.py

def discriminator_loss(real_output, fake_output):
    real_loss = cross_entropy(tf.ones_like(real_output), real_output)
    fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)
    total_loss = real_loss + fake_loss
    return total_loss

def generator_loss(fake_output):
    return cross_entropy(tf.ones_like(fake_output), fake_output)

Um ein neuronales Netzwerkmodell zu trainieren, passen Sie im Allgemeinen die Gewichtsparameter so an, dass der Gradient der Gewichtsparameter dieser Verlustfunktion kleiner wird. Definieren Sie eine Funktion, die die Fähigkeit der Diskriminatorseite erhöht, zwischen echt und falsch zu unterscheiden, und die Fähigkeit der Generatorseite erhöht, den Diskriminator zu täuschen. Dieser Teil ist die Definition, die die Technologie darstellt, die GAN eigen ist.

Definition der Trainingsfunktion

gan.py

EPOCHS =50
noise_dim = 100
num_examples_to_generate = 16
seed= tf.random.normal([num_examples_to_generate,noise_dim])

def train(dataset, epochs):
  for epoch in range(epochs):
    start = time.time()

    for image_batch in dataset:
      train_step(image_batch)

    # Produce images for the GIF as we go
    display.clear_output(wait=True)
    generate_and_save_images(generator,
                             epoch + 1,
                             seed)

    # Save the model every 15 epochs
    if (epoch + 1) % 15 == 0:
      checkpoint.save(file_prefix = checkpoint_prefix)

    print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))

  # Generate after the final epoch
  display.clear_output(wait=True)
  generate_and_save_images(generator,
                           epochs,
                           seed)

Bild nach Berechnung

Nach 10 Epochen

Nach 30 Epochen

Nach 50 Epochen

Da es 30 Epochen überschritten hat, sieht das Bild ziemlich numerisch aus. In meiner Umgebung * dauerte es ungefähr 5 Minuten für eine Epoche, also ungefähr 250 Minuten. Nutzen Sie Google Colab mit einer grafischen Benutzeroberfläche. ..

• Aktuelle PC-Umgebung PC:Windows 10 Home CPU:Intel Core i7 3.6GHz RAM:8GB

Am Ende

Dies ist das erste Mal, dass ich GAN implementiert habe, aber es hat mir Spaß gemacht, weil es ein Programm ist, das die Berechnungsfunktionen, in denen Computer gut sind, einschließlich Denken und Berechnen, vollständig demonstriert. Viele Modelle wurden für Generatoren, Klassifikatoren und das Konzept der Verlustfunktionen vorgeschlagen, daher möchte ich sie einzeln lernen und zusammenfassen.

Ich habe alle Codes hier eingegeben. https://github.com/Fumio-eisan/dcgan20200306