Création d'un programme de génération d'images MNIST par DCGAN (tutoriel tensorflow)

Que sont GAN et DCGAN?

Cette fois, j'ai découvert le GAN (Generative adversarial networks), qui est un algorithme indispensable dans le domaine du deep learning. GAN est une technologie créée par un chercheur américain appelé lan Goodfellow en 2014. En entraînant deux réseaux de manière hostile, un réseau qui génère des données indiscernables de la réalité. C'est. En japonais, il est directement traduit par réseau de génération d'hostilité, mais ** le nom est comme cuisine 2, et je l'aime parce que c'est cool. ** **

Cette fois, j'ai résumé ma propre interprétation de DCGAN, qui est mentionnée sous forme de tutoriel dans l'URL tensorflow. https://www.tensorflow.org/tutorials/generative/dcgan?hl=ja Ce tutoriel traite d'un algorithme qui génère des MNIST (nombres manuscrits) à l'aide d'une technique appelée DCGAN (Deep Convolutional GAN).

DCGAN est un modèle de génération proposé dans un article présenté à ICLR2016 (AI field conference). La différence avec le soi-disant GAN est qu'il utilise Deep Convolutional = convolution sans effectuer une couche entièrement connectée (Affine). Le modèle de couche entièrement connecté a pour caractéristique que le coefficient de pondération est très grand et qu'il est facile de surapprendre, mais il semble que le surapprentissage peut être évité s'il est composé uniquement par convolution. En revanche, la convergence a tendance à être lente.

URL utile pour le GAN en général https://blog.negativemind.com/2019/09/07/deep-convolutional-gan/

Qu'est-ce que le module future?

gan.py

from __future__ import absolute_import, division, print_function, unicode_literals

Dans Python 2.6 et versions ultérieures, ce code vous permet de modifier le comportement de certaines fonctions et instructions en fonction du comportement de la série Python 3. Je comprends qu'il est lu lorsque vous souhaitez utiliser des fonctions de la série 3 dans la série Python 2.

À propos des bibliothèques et modules chargés

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

J'ai chargé imageio et PIL (Pillow) en tant que bibliothèques pour le traitement des images. OpenCV est célèbre en tant que bibliothèque de traitement d'image, mais Pillow est plus simple et plus facile à comprendre. J'ai également chargé glob en tant que module qui peut obtenir le chemin du fichier. Vous pouvez utiliser des caractères spéciaux tels que des caractères génériques * pour obtenir des chemins tels que des noms de fichiers et des noms de dossiers qui remplissent les conditions d'une liste ou d'un itérateur.

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

Vient ensuite le module IPython.display, qui a la possibilité d'intégrer de l'audio et de la vidéo sur un ordinateur portable.

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

Charger le jeu de données

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]

Cette fois, MNSIT (image numérique manuscrite) est lu à partir du jeu de données keras. Ils sont répertoriés sous forme de séquence et seront normalisés.

gan.py

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

Base de données

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

Définition du modèle de générateur

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

Définition du modèle de discriminateur

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/

Définition de la fonction de perte

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)

Généralement, pour entraîner un modèle de réseau neuronal, ajustez les paramètres de poids de sorte que le gradient des paramètres de poids de cette fonction de perte devienne plus petit. Définissez une fonction qui augmente la capacité du côté Discriminateur à faire la distinction entre authentique et faux, et augmente la capacité du côté Générateur de tromper le Discriminateur. Cette partie est la définition qui représente la technologie propre au GAN.

Définition de la fonction de formation

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)

Image après calcul

Après 10 époques

Après 30 époques

Après 50 époques

Puisqu'elle a dépassé 30 époques, l'image semble assez numérique. Dans mon environnement *, cela a pris environ 5 minutes pour 1 époque, donc cela a pris environ 250 minutes. Profitez de Google Colab, qui possède une interface graphique. ..

• Environnement PC actuel PC:Windows 10 Home CPU:Intel Core i7 3.6GHz RAM:8GB

À la fin

C'est la première fois que j'implémente le GAN, mais je l'ai apprécié car c'est un programme qui démontre pleinement les fonctions de calcul pour lesquelles les ordinateurs sont bons, y compris la réflexion et les calculs. De nombreux modèles ont été proposés pour les générateurs, les classificateurs et le concept de fonctions de perte, je voudrais donc les apprendre et les résumer un par un.

J'ai mis tous les codes ici. https://github.com/Fumio-eisan/dcgan20200306