A4.4 - Deep Learning: GANs - [LINFO2262] Machine Learning: classification and evaluation

A4.4 - Deep Learning: GANs

In the previous tasks of the project, you have learned how to build and train neural networks to classify images. In this question, you will explore a different type of neural network architecture, called Generative Adversarial Networks (GANs), that can be used to generate images (often called deep fakes).

GANs are composed of two neural networks, a generator and a discriminator, that are trained together in an adversarial way. The generator takes as input a random noise vector and generates an image, while the discriminator takes as input an image classifies it as real (from the training set) or fake (generated by the generator). The generator is trained to fool the discriminator, while the discriminator is trained to correctly classify real and fake images.

https://inginious.info.ucl.ac.be/course/LINFO2262/A4-4/gan.png

Disclaimer

GAN (Generative Adversarial Network) methodology has previously been used to produce deepfakes capable of deceiving people. By studying GANs in this project, we do not endorse or encourage such deceptive applications. On the contrary, training a robust discriminator represents one promising avenue for automating the detection of fake images — illustrating how the min-max framework at the heart of GAN learning reflects an ongoing race between generation and detection.

Students should be fully aware of this broader context and are under no circumstances encouraged to misuse these techniques. Any such misuse would be their sole responsibility and may carry serious legal consequences.

You can load the data with the following code snippet. Note that, for this task, you will only need the training images, and not the labels. You may also load the test images to assess the quality of your discriminator.

x_train = np.load("p4_2026_svhn_train.npz")["images"].transpose(3, 0, 1, 2)
x_test = np.load("p4_2026_svhn_test.npz")["images"].transpose(3, 0, 1, 2)

Paste this command into your terminal:

The password to connect is

Question 1: A Generative Adversarial Network template

Graded question with feedback [20 points]

We provide you with a template for a GAN architecture, that you can use as a starting point to implement your own GAN. This template is not complete, and you will need to fill the missing parts where the TODO comments are located. Do not change the other parts of the provided code.

Complete this template with your code, following the instructions in the comments. Train your generator and discriminator on the training set, and make sure both models are good, i.e., the generator can generate images that look like the ones in the training set, and the discriminator can distinguish real images from fake images.

Submit your code here by replacing the template with your own implementation. Note that x_train will be loaded on Inginious when evaluating your code but you cannot access it or modify it here.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
from sklearn.metrics import accuracy_score


def create_discriminator():
    model = keras.Sequential()

    # TODO: specify input shape
    model.add(keras.Input(shape=...))

    # TODO: add a Conv2D layer and a ReLU or LeakyReLU layer
    model.add(...)
    model.add(...)

    # TODO: optional: add more blocks of Conv2D and ReLU or LeakyReLU layers
    ...

    # TODO: add a dense layer with a single output unit and no activation function, this will be the output of the discriminator
    model.add(layers.Flatten())
    model.add(...)

    return model


def create_generator():
    noise_dim = 100

    model = keras.Sequential()

    # TODO: specify input shape
    model.add(keras.Input(shape=...))

    # TODO: specify a Dense layer
    model.add(layers.Dense(..., use_bias=False))

    # TODO: add a batch normalization layer and a ReLU or LeakyReLU layer
    model.add(...)
    model.add(...)

    # TODO: add a reshape layer to reshape the output to be in 3 dimensions (for example, 4x4x128)
    model.add(...)

    # TODO: add a block of Conv2DTranspose, BatchNormalization, and ReLU or LeakyReLU layers
    # in Conv2DTranspose, always use padding="same" and use_bias=False
    model.add(...)
    model.add(...)
    model.add(...)

    # TODO: [optional] add more blocks of Conv2DTranspose, BatchNormalization, and ReLU or LeakyRelU layers if you want
    ...

    # TODO: add a final Conv2DTranspose layer using a tanh activation function, still with padding="same" and use_bias=False.
    # The final output MUST have a shape of 32x32x3, see how you can use the strides to arrive to this output shape.
    model.add(...)
    return model


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

    noise_dim = 100

    bce_from_logits = tf.keras.losses.BinaryCrossentropy(from_logits=True)

    # TODO: create the generator and discriminator
    generator = ...
    discriminator = ...

    # scale the train images
    train_images = train_images.astype('float32')
    train_images = (train_images - 127.5) / 127.5  # Normalize the images to [-1, 1]
    train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(len(train_images)).batch(batch_size)

    # TODO: create the optimizers for the generator and discriminator
    # use the Adam optimizer with a learning rate of 1e-4
    generator_optimizer = ...
    discriminator_optimizer = ...

    for epoch in range(epochs):
        for image_batch in train_dataset:

            # TODO: sample random noise for the generator input
            noise = tf.random.normal([..., ...])

            with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:

                # TODO: generate images using the generator
                # you must set training=True when calling the model!
                generated_images = ...

                # TODO: get the discriminator output for the real and generated images
                # you must set training=True when calling the model!
                real_output = ...
                fake_output = ...

                # create the labels for real and fake images
                real_labels = tf.ones_like(real_output)
                fake_labels = tf.zeros_like(fake_output)

                # compute the loss for the generator model
                gen_loss = bce_from_logits(real_labels, fake_output)

                # TODO: compute the loss for the discriminator model
                # in this case, the loss is the sum of the loss on real images
                # and the loss on generated images
                real_loss = ...
                fake_loss = ...
                disc_loss = real_loss + fake_loss

            # compute and apply the gradients for the generator and discriminator
            gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
            gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
            generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
            discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))

    # TODO: save your models after training
    generator.save("generator.keras")
    discriminator.save("discriminator.keras")

    return generator, discriminator


def generate_images(generator, num_images):
    noise_dim = 100
    # TODO: sample random noise for the generator input
    noise = tf.random.normal([..., ...])

    # TODO: generate images using the generator
    # you must set training=False when calling the model!
    generated_images = ...

    generated_images = (generated_images + 1.0) / 2.0  # Convert back to [0, 1]
    return generated_images.numpy()


def evaluate_discriminator(discriminator, real_images, fake_images):
    assert real_images.shape == fake_images.shape

    # The discriminator is trained on images normalized to [-1, 1].
    real_images = real_images.astype(np.float32)
    if real_images.max() > 1.0:
        real_images = (real_images - 127.5) / 127.5

    fake_images = fake_images.astype(np.float32)
    # `generate_images()` returns [0, 1]; convert to [-1, 1] for the discriminator.
    if fake_images.min() >= 0.0 and fake_images.max() <= 1.0:
        fake_images = fake_images * 2.0 - 1.0

    # TODO: create the labels for real and fake images
    real_labels = ...
    fake_labels = ...

    # TODO: compute the predictions of the discriminator
    real_predictions = ...
    fake_predictions = ...

    # concatenate predictions and labels
    predictions = np.concatenate([real_predictions, fake_predictions], axis=0)
    labels = np.concatenate([real_labels, fake_labels], axis=0)
    predicted_labels = (predictions > 0).astype(int)  # Threshold at 0 for binary classification

    # TODO: compute the accuracy of the discriminator
    acc = ...
    return acc

Question 2: Upload your generator model

Test question [40 points]

Upload here your trained generator model.

Your generator will be evaluated on how well it can generate images that fool a discriminator we designed. This question will be evaluated after the deadline. Therefore, it is your job to make sure that your generator is trained correctly and generate images that look like the ones in the training set.

You will receive grade proportional to how well your generator can fool our discriminator.

Max file size: 238.4 MiB
Allowed extensions: .keras

Question 3: Upload your discriminator model

Test question [40 points]

Upload here your trained discriminator model.

Your discriminator will be evaluated on how well it can distinguish real images from fake images generated by our generator. This question will be evaluated after the deadline. Therefore, it is your job to make sure that your discriminator is trained correctly and can distinguish real images from fake images.

You will receive grade proportional to how well your discriminator can distinguish real images from fake images.

Max file size: 238.4 MiB
Allowed extensions: .keras

Author(s)	Pierre Dupont, Benoit Ronval
Deadline	12/04/2026 23:00:00
Abgabenlimit	No limitation

Information

Einloggen