gistlib - implement a machine learning model to generate images of cats in python

To generate images of cats using a machine learning model in Python, we can use a Generative Adversarial Network (GAN) algorithm. The GAN comprises of two models: a generator that creates new images and a discriminator that evaluates its authenticity. The models are trained together in an adversarial setting where the generator tries to fool the discriminator by generating realistic images while the discriminator tries to correctly identify generated images from real ones.

To implement this algorithm, we can use the TensorFlow library. Here is a high-level overview of the code:

Import necessary libraries


main.py
import tensorflow as tf
from tensorflow.keras.layers import Dense, Reshape, Flatten, Conv2D, Conv2DTranspose
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import Adam
import numpy as np
import matplotlib.pyplot as plt
252 chars
7 lines

Load and preprocess the dataset


main.py
# Download the dataset
(train_images, train_labels), (_, _) = tf.keras.datasets.cifar10.load_data()

# Normalize the pixel values and scale to (-1, 1)
train_images = (train_images - 127.5) / 127.5

# Convert images to tensors
train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(60000).batch(BATCH_SIZE)
324 chars
9 lines

Define the generator and discriminator models


main.py
def make_generator_model():
    model = Sequential()
    model.add(Dense(7*7*256, use_bias=False, input_shape=(NOISE_DIM,)))
    model.add(Reshape((7, 7, 256)))
    
    model.add(Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))
    model.add(tf.keras.layers.BatchNormalization())
    model.add(tf.keras.layers.LeakyReLU())

    model.add(Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))
    model.add(tf.keras.layers.BatchNormalization())
    model.add(tf.keras.layers.LeakyReLU())

    model.add(Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))

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

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

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

    return model
1146 chars
31 lines

Define the loss functions and optimizers


main.py
cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)

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)

generator_optimizer = Adam(LEARNING_RATE)
discriminator_optimizer = Adam(LEARNING_RATE)
510 chars
14 lines

Train the models


main.py
for epoch in range(EPOCHS):
    for image_batch in train_dataset:
        
        # Train the discriminator
        noise = tf.random.normal([BATCH_SIZE, NOISE_DIM])
        generated_images = generator(noise, training=True)
        real_output = discriminator(image_batch, training=True)
        fake_output = discriminator(generated_images, training=True)
        disc_loss = discriminator_loss(real_output, fake_output)
        gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
        discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))

        # Train the generator
        noise = tf.random.normal([BATCH_SIZE, NOISE_DIM])
        with tf.GradientTape() as gen_tape:
            generated_images = generator(noise, training=True)
            fake_output = discriminator(generated_images, training=True)
            gen_loss = generator_loss(fake_output)
        gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
        generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
1158 chars
21 lines

Generate new cat images


main.py
def generate_and_save_images(model, epoch, test_input):
    # Generate images from the model
    predictions = model(test_input, training=False)
    fig = plt.figure(figsize=(4, 4))

    # Plot the generated images
    for i in range(predictions.shape[0]):
        plt.subplot(4, 4, i+1)
        plt.imshow((predictions[i, :, :, :] + 1) / 2)
        plt.axis('off')

    # Save the figure
    plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
    plt.show()

# Generate a random noise input
noise = tf.random.normal([16, NOISE_DIM])

# Generate the images and save
generate_and_save_images(generator, 0, noise)
616 chars
21 lines

This code will create a GAN model that can generate images of cats using deep learning techniques, with TensorFlow library.

implement a machine learning model to generate images of cats in python

similar python code snippets

related categories