Gfyuki

I just got a neural network to run and although it doesn't raise any exceptions, I'm left with a horrible mess after 80 to 100 epochs:

After 100 epochs:

I just got a neural network to run and although it doesn't raise any exceptions, I'm left with a horrible mess after 80 to 100 epochs:

After 100 epochs:

I am trying to generate a synthetic image of a cat from my own database of cat photos that I compiled using a crawler. I am using an adapted code originally intended for the MNSIT handwritten digits database (hence the shape of the grid).

The network doesn't appear to be training, generating or discriminating properly because the epochs aren't taking long at all and what is being produced is very poor.

To be clear, I've tried to adapt another author's code that I found online and I've added other snippets of code to try to get it to work. It's evident that my 'FrankenNet' has fallen to bits and my 'bolt it together and see what happens' approach has its limitations. In the future I plan to be more efficient and logical with how I learn Python because my experimental method has proved to be both time consuming and unpredictable.

Maybe I haven't loaded in the data correctly or perhaps there are a few other issues such as converting the data to a numpy array?

For the simple fact that I don't know exactly what is causing this (I have limited experience in programming), and because there are no exceptions raised when I run the program, I will offer the entire code below.

I'd love some advice because I really want to generate something and I've spent a long time trying to work it out through trial and error with no results. I'd especially appreciate some specific suggestions about what lines I need to change, add or remove to get this beast up to scratch.

Thank you for your time!

import os

import numpy as np

from sklearn.model_selection import train_test_split

import matplotlib



matplotlib.use("TkAgg")

from matplotlib import pyplot as plt

from tqdm import tqdm

from keras.layers import Input

from keras.models import Model, Sequential

from keras.layers.core import Dense, Dropout

from keras.layers.advanced_activations import LeakyReLU

from keras.optimizers import Adam

from keras import initializers



os.environ["KERAS_BACKEND"] = "tensorflow"

   np.random.seed(10)

random_dim = 100

from os import listdir

from PIL import Image as PImage





def loadImages(path):

    # return array of images

    imagesList = listdir(path)

    loadedImages = 

    for image in imagesList:

        img = PImage.open(path + image)

        loadedImages.append(img)

    return loadedImages





DATASET_NAME = 'cats'

ROOT_DIR = '/Users/Darren/desktop'

DATASET_DIR = f'{ROOT_DIR}/{DATASET_NAME}'

input_files = [os.path.join(dp, f) for dp, dn, fn in 

os.walk(os.path.expanduser(f'{DATASET_DIR}/processed')) for f in fn

               if f != '.DS_Store']

imgs = np.ndarray(shape=(len(input_files), 100, 100, 3),

                  dtype=np.int)

for i, input_file in enumerate(input_files):

    # print('processing file: {}'.format(input_file))

    image = imread(input_file)

    imgs[i] = image

    # your images in an array

    imgs = loadImages(path)



PATH = os.getcwd()



train_path = PATH + '/cats/train'

train_batch = os.listdir(train_path)

x_train = 



# if data are in form of images

img_path = train_path

test_path = PATH + '/cats/test'

test_batch = os.listdir(test_path)

x_test = 



# finally converting list into numpy array

x_train = np.array(x_train)

x_test = np.array(x_test)



def get_optimizer():

    return Adam(lr=0.0002, beta_1=0.5)





def get_generator(optimizer):

    generator = Sequential()

    generator.add(Dense(256, input_dim=random_dim, 

    kernel_initializer=initializers.RandomNormal(stddev=0.02)))

    generator.add(LeakyReLU(0.2))

    generator.add(Dense(512))

    generator.add(LeakyReLU(0.2))

    generator.add(Dense(1024))

    generator.add(LeakyReLU(0.2))

    generator.add(Dense(784, activation='tanh'))

    generator.compile(loss='binary_crossentropy', optimizer=optimizer)

    return generator





def get_discriminator(optimizer):

    discriminator = Sequential()

    discriminator.add(Dense(1024, input_dim=784, 

    kernel_initializer=initializers.RandomNormal(stddev=0.02)))

    discriminator.add(LeakyReLU(0.2))

    discriminator.add(Dropout(0.3))

    discriminator.add(Dense(512))

    discriminator.add(LeakyReLU(0.2))

    discriminator.add(Dropout(0.3))

    discriminator.add(Dense(256))

    discriminator.add(LeakyReLU(0.2))

    discriminator.add(Dropout(0.3))

    discriminator.add(Dense(1, activation='sigmoid'))

    discriminator.compile(loss='binary_crossentropy', optimizer=optimizer)

    return discriminator





def get_gan_network(discriminator, random_dim, generator, optimizer):

    discriminator.trainable = False

    gan_input = Input(shape=(random_dim,))

    x = generator(gan_input)

    gan_output = discriminator(x)

    gan = Model(inputs=gan_input, outputs=gan_output)

    gan.compile(loss='binary_crossentropy', optimizer=optimizer)

    return gan





def plot_generated_images(epoch, generator, examples=100, dim=(10, 10), 

figsize=(10, 10)):

    noise = np.random.normal(0, 1, size=[examples, random_dim])

    generated_images = generator.predict(noise)

    generated_images = generated_images.reshape(examples, 28, 28)

    plt.figure(figsize=figsize)

    for i in range(generated_images.shape[0]):

        plt.subplot(dim[0], dim[1], i + 1)

        plt.imshow(generated_images[i], interpolation='nearest', cmap='gray_r')

        plt.axis('off')

    plt.tight_layout()

    plt.savefig('gan_generated_image_epoch_%d.png' % epoch)





def train(epochs=1, batch_size=128):

    batch_count = x_train.shape[0] // batch_size

    adam = get_optimizer()

    generator = get_generator(adam)

    discriminator = get_discriminator(adam)

    gan = get_gan_network(discriminator, random_dim, generator, adam)

    for e in range(1, epochs + 1):

        print('-' * 15, 'Epoch %d' % e, '-' * 15)

        for _ in tqdm(range(batch_count)):

            noise = np.random.normal(0, 1, size=[batch_size, random_dim])

            image_batch = x_train[np.random.randint(0, x_train.shape[0], size=batch_size)]

            generated_images = generator.predict(noise)

            X = np.concatenate([image_batch, generated_images])

            y_dis = np.zeros(2 * batch_size)

            y_dis[:batch_size] = 0.9

            discriminator.trainable = True

            discriminator.train_on_batch(X, y_dis)

            noise = np.random.normal(0, 1, size=[batch_size, random_dim])

            y_gen = np.ones(batch_size)

            discriminator.trainable = False

            gan.train_on_batch(noise, y_gen)

        if e == 1 or e % 20 == 0:

            plot_generated_images(e, generator)





if __name__ == '__main__':

    train(400, 128)