{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "8f698687", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "# Install the necessary dependencies\n", "\n", "import os\n", "import sys\n", "!{sys.executable} -m pip install --quiet pandas scikit-learn numpy matplotlib jupyterlab_myst ipython" ] }, { "cell_type": "markdown", "id": "60f0fa29", "metadata": { "tags": [ "remove-cell" ] }, "source": [ "---\n", "license:\n", " code: MIT\n", " content: CC-BY-4.0\n", "github: https://github.com/ocademy-ai/machine-learning\n", "venue: By Ocademy\n", "open_access: true\n", "bibliography:\n", " - https://raw.githubusercontent.com/ocademy-ai/machine-learning/main/open-machine-learning-jupyter-book/references.bib\n", "---" ] }, { "cell_type": "markdown", "id": "9339a744", "metadata": {}, "source": [ "\n", "# Generative adversarial networks \n", "\n", "Generative adversarial networks (GANs) emerge as the virtuosos of artificial creativity, painting canvases with pixels rather than pigments. At their genesis, GANs were forged with a singular mission: to breathe life into the digital realm, conjuring new data from the ethereal depths of probability distributions. Their pioneering design was a symphony of innovation, orchestrating a duel between two neural networks in a ballet of creation and critique.\n", "\n", "Picture this: on one side of the stage stands the Generator, a prodigious apprentice armed with brushes of binary. Its purpose, its raison d'être, is to craft masterpieces ex nihilo, stitching together pixels with mathematical finesse. With each iteration, it tiptoes closer to perfection, learning the intricate tapestry of the training set distribution like a virtuoso studying the score.\n", "\n" ] }, { "cell_type": "markdown", "id": "95b339e7", "metadata": {}, "source": [ "Opposing it, the Discerner awaits—the arbiter of authenticity, the gatekeeper of verisimilitude. Trained to discern the genuine from the counterfeit, it scrutinizes each creation with a discerning eye, sniffing out flaws and imperfections like a seasoned art critic.\n", "\n", "The dance begins. With each pass, the Generator's strokes grow bolder, its compositions more intricate, as it strives to outwit its adversary. Meanwhile, the Discerner stands vigilant, its discriminating gaze sharpened by every encounter. Back and forth they go, locked in an eternal tango of creation and critique.\n", "\n", "And then, a breakthrough. In a moment of revelation, the Generator unveils a masterpiece—a synthesis of pixels so sublime, so lifelike, that even the Discerner is momentarily deceived. In that fleeting instant, the boundaries of possibility expand, as the digital canvas is imbued with the spark of innovation.\n", "\n", "Such is the essence of GANs—a testament to the power of adversarial collaboration, where artistry and algorithm converge to redefine the boundaries of creativity. From images to text, from music to medicine, their domain knows no bounds, as they continue to shape the future of artificial intelligence, one pixel at a time." ] }, { "cell_type": "markdown", "id": "869d0fb6", "metadata": { "attributes": { "classes": [ "seealso" ], "id": "" } }, "source": [ "GAN is proposed in 2005, the paper is Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, Yoshua Bengio. \"Generative Adversarial Networks\", arxiv:1406.2661." ] }, { "cell_type": "markdown", "id": "c0a2c105", "metadata": {}, "source": [ "## Code" ] }, { "cell_type": "code", "execution_count": 3, "id": "76b87585", "metadata": { "attributes": { "classes": [ "code-cell" ], "id": "" } }, "outputs": [], "source": [ "import tensorflow as tf\n", "import requests\n", "import numpy as np\n", "import os\n", "\n", "import matplotlib.pyplot as plt\n", "import matplotlib.gridspec as gridspec\n", "import warnings\n", "\n", "warnings.filterwarnings(\"ignore\")\n", "%matplotlib inline\n", "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", "plt.rcParams['image.interpolation'] = 'nearest'\n", "plt.rcParams['image.cmap'] = 'gray'" ] }, { "cell_type": "markdown", "id": "cbdc72d1", "metadata": {}, "source": [ "### Function of displaying a grid of images" ] }, { "cell_type": "code", "execution_count": 4, "id": "ea2cc36d", "metadata": {}, "outputs": [], "source": [ "def show_images(images):\n", " images = np.reshape(images, [images.shape[0], -1]) # images reshape to (batch_size, D)\n", " sqrtn = int(np.ceil(np.sqrt(images.shape[0])))\n", " sqrtimg = int(np.ceil(np.sqrt(images.shape[1])))\n", "\n", " fig = plt.figure(figsize=(sqrtn, sqrtn))\n", " gs = gridspec.GridSpec(sqrtn, sqrtn)\n", " gs.update(wspace=0.05, hspace=0.05)\n", "\n", " for i, img in enumerate(images):\n", " ax = plt.subplot(gs[i])\n", " plt.axis('off')\n", " ax.set_xticklabels([])\n", " ax.set_yticklabels([])\n", " ax.set_aspect('equal')\n", " plt.imshow(img.reshape([sqrtimg,sqrtimg]))\n", " return" ] }, { "cell_type": "markdown", "id": "1d62f36a", "metadata": {}, "source": [ "### Functions of pre-processing and post-processing images" ] }, { "cell_type": "code", "execution_count": 5, "id": "baf5da2f", "metadata": {}, "outputs": [], "source": [ "def preprocess_img(x):\n", " return 2 * x - 1.0\n", "\n", "def deprocess_img(x):\n", " return (x + 1.0) / 2.0\n", "\n", "def rel_error(x,y):\n", " return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n", "\n", "def count_params(model):\n", " \"\"\"Count the number of parameters in the current TensorFlow graph \"\"\"\n", " param_count = np.sum([np.prod(p.shape) for p in model.weights])\n", " return param_count\n" ] }, { "cell_type": "markdown", "id": "4f05dae0", "metadata": {}, "source": [ "### Download a file from a URL using the requests library" ] }, { "cell_type": "code", "execution_count": 6, "id": "dde6f381", "metadata": {}, "outputs": [], "source": [ "url = 'https://static-1300131294.cos.ap-shanghai.myqcloud.com/data/deep-learning/Gan/gan-checks-tf.npz'\n", "response = requests.get(url)\n", "with open('gan-checks-tf.npz', 'wb') as f:\n", " f.write(response.content)\n", "\n", "# Now you can use np.load on the downloaded file\n", "answers = np.load('gan-checks-tf.npz')\n", "\n", "NOISE_DIM = 96" ] }, { "cell_type": "markdown", "id": "804c555b", "metadata": {}, "source": [ "### Load Data" ] }, { "cell_type": "code", "execution_count": 7, "id": "2dd987e4", "metadata": { "attributes": { "classes": [ "code-cell" ], "id": "" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "class MNIST(object):\n", " def __init__(self, batch_size, shuffle=False):\n", " \"\"\"\n", " Construct an iterator object over the MNIST data\n", " \n", " Inputs:\n", " - batch_size: Integer giving number of elements per minibatch\n", " - shuffle: (optional) Boolean, whether to shuffle the data on each epoch\n", " \"\"\"\n", " train, _ = tf.keras.datasets.mnist.load_data()\n", " X, y = train\n", " X = X.astype(np.float32)/255\n", " X = X.reshape((X.shape[0], -1))\n", " self.X, self.y = X, y\n", " self.batch_size, self.shuffle = batch_size, shuffle\n", "\n", " def __iter__(self):\n", " N, B = self.X.shape[0], self.batch_size\n", " idxs = np.arange(N)\n", " if self.shuffle:\n", " np.random.shuffle(idxs)\n", " return iter((self.X[i:i+B], self.y[i:i+B]) for i in range(0, N, B)) \n", "mnist = MNIST(batch_size=25) \n", "show_images(mnist.X[:25])" ] }, { "cell_type": "markdown", "id": "8ba9325f", "metadata": {}, "source": [ "### Compute the leaky ReLU activation function" ] }, { "cell_type": "code", "execution_count": 8, "id": "604c3002", "metadata": { "attributes": { "classes": [ "code-cell" ], "id": "" } }, "outputs": [], "source": [ "def leaky_relu(x, alpha=0.01):\n", " x = tf.nn.leaky_relu(x,alpha)\n", " return x\n", " pass" ] }, { "cell_type": "markdown", "id": "3e82e2f5", "metadata": {}, "source": [ "### Generate random uniform noise from -1 to 1" ] }, { "cell_type": "code", "execution_count": 9, "id": "2563e36a", "metadata": {}, "outputs": [], "source": [ "def sample_noise(batch_size, dim):\n", " noise = tf.random.uniform([batch_size,dim],minval = -1,maxval = 1)\n", " return noise\n", " pass" ] }, { "cell_type": "markdown", "id": "96d2dad0", "metadata": {}, "source": [ "### Compute discriminator score for a batch of input images" ] }, { "cell_type": "code", "execution_count": 10, "id": "e950fbc7", "metadata": {}, "outputs": [], "source": [ "def discriminator():\n", " model = tf.keras.models.Sequential([\n", " tf.keras.layers.InputLayer(784),\n", " tf.keras.layers.Dense(256),\n", " tf.keras.layers.LeakyReLU(0.01),\n", " tf.keras.layers.Dense(256),\n", " tf.keras.layers.LeakyReLU(0.01),\n", " tf.keras.layers.Dense(1)\n", " ])\n", " return model" ] }, { "cell_type": "code", "execution_count": 12, "id": "864cd630", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Correct number of parameters in discriminator.\n" ] } ], "source": [ "warnings.filterwarnings(\"ignore\")\n", "def test_discriminator(true_count=267009):\n", " model = discriminator()\n", " cur_count = count_params(model)\n", " if cur_count != true_count:\n", " print('Incorrect number of parameters in discriminator. {0} instead of {1}. Check your achitecture.'.format(cur_count,true_count))\n", " else:\n", " print('Correct number of parameters in discriminator.')\n", " \n", "test_discriminator()" ] }, { "cell_type": "markdown", "id": "250f34ac", "metadata": {}, "source": [ "### Compute generator score for a batch of input images" ] }, { "cell_type": "code", "execution_count": 13, "id": "efea74b4", "metadata": {}, "outputs": [], "source": [ "def generator(noise_dim=NOISE_DIM):\n", " model = tf.keras.models.Sequential([\n", " tf.keras.layers.InputLayer(noise_dim),\n", " tf.keras.layers.Dense(1024),\n", " tf.keras.layers.ReLU(),\n", " tf.keras.layers.Dense(1024),\n", " tf.keras.layers.ReLU(),\n", " tf.keras.layers.Dense(784,activation = tf.nn.tanh)\n", " ])\n", " return model" ] }, { "cell_type": "code", "execution_count": 14, "id": "5a30503c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Correct number of parameters in generator.\n" ] } ], "source": [ "def test_generator(true_count=1858320):\n", " model = generator(4)\n", " cur_count = count_params(model)\n", " if cur_count != true_count:\n", " print('Incorrect number of parameters in generator. {0} instead of {1}. Check your achitecture.'.format(cur_count,true_count))\n", " else:\n", " print('Correct number of parameters in generator.')\n", " \n", "test_generator()" ] }, { "cell_type": "markdown", "id": "a26b4468", "metadata": {}, "source": [ "### Compute the discriminator loss" ] }, { "cell_type": "code", "execution_count": 15, "id": "9a0f2af2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Maximum error in d_loss: 6.02597e-17\n" ] } ], "source": [ "def discriminator_loss(logits_real, logits_fake):\n", "\n", " loss = None\n", " cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)\n", " # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n", " real_loss = cross_entropy(tf.ones_like(logits_real), logits_real)\n", " fake_loss = cross_entropy(tf.zeros_like(logits_fake), logits_fake)\n", " loss = real_loss + fake_loss\n", " # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n", " return loss\n", "\n", "def test_discriminator_loss(logits_real, logits_fake, d_loss_true):\n", " d_loss = discriminator_loss(tf.constant(logits_real),\n", " tf.constant(logits_fake))\n", " print(\"Maximum error in d_loss: %g\"%rel_error(d_loss_true, d_loss))\n", "\n", "test_discriminator_loss(answers['logits_real'], answers['logits_fake'],\n", " answers['d_loss_true'])" ] }, { "cell_type": "markdown", "id": "16eb22cb", "metadata": {}, "source": [ "### Compute the generator loss" ] }, { "cell_type": "code", "execution_count": 16, "id": "eee79bf3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Maximum error in g_loss: 7.19722e-17\n" ] } ], "source": [ "def generator_loss(logits_fake):\n", " loss = None\n", " cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)\n", " # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n", " loss = cross_entropy(tf.ones_like(logits_fake), logits_fake)\n", " # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n", " return loss\n", "\n", "def test_generator_loss(logits_fake, g_loss_true):\n", " g_loss = generator_loss(tf.constant(logits_fake))\n", " print(\"Maximum error in g_loss: %g\"%rel_error(g_loss_true, g_loss))\n", "\n", "test_generator_loss(answers['logits_fake'], answers['g_loss_true'])" ] }, { "cell_type": "markdown", "id": "0c951711", "metadata": {}, "source": [ "### Create solvers for GAN training" ] }, { "cell_type": "code", "execution_count": 17, "id": "2d946dfd", "metadata": { "attributes": { "classes": [ "code-cell" ], "id": "" } }, "outputs": [], "source": [ "def get_solvers(learning_rate=1e-3, beta1=0.5):\n", " D_solver = None\n", " G_solver = None\n", " D_solver = tf.optimizers.Adam(learning_rate,beta1)\n", " G_solver = tf.optimizers.Adam(learning_rate,beta1)\n", " pass\n", " return D_solver, G_solver" ] }, { "cell_type": "markdown", "id": "8064735b", "metadata": {}, "source": [ "### Train a GAN for a certain number of epochs" ] }, { "cell_type": "code", "execution_count": 23, "id": "d72ae344", "metadata": {}, "outputs": [], "source": [ "def run_a_gan(D, G, D_solver, G_solver, discriminator_loss, generator_loss,\\\n", " show_every=1000, print_every=20, batch_size=16, num_epochs=3, noise_size=96):\n", " mnist = MNIST(batch_size=batch_size, shuffle=True)\n", " \n", " iter_count = 0\n", " for epoch in range(num_epochs):\n", " for (x, _) in mnist:\n", " with tf.GradientTape() as tape:\n", " real_data = x\n", " logits_real = D(preprocess_img(real_data))\n", "\n", " g_fake_seed = sample_noise(batch_size, noise_size)\n", " fake_images = G(g_fake_seed)\n", " logits_fake = D(tf.reshape(fake_images, [batch_size, 784]))\n", " d_total_error = discriminator_loss(logits_real, logits_fake)\n", " d_gradients = tape.gradient(d_total_error, D.trainable_variables) \n", " D_solver.apply_gradients(zip(d_gradients, D.trainable_variables))\n", " \n", " with tf.GradientTape() as tape:\n", " g_fake_seed = sample_noise(batch_size, noise_size)\n", " fake_images = G(g_fake_seed)\n", "\n", " gen_logits_fake = D(tf.reshape(fake_images, [batch_size, 784]))\n", " g_error = generator_loss(gen_logits_fake)\n", " g_gradients = tape.gradient(g_error, G.trainable_variables) \n", " G_solver.apply_gradients(zip(g_gradients, G.trainable_variables))\n", "\n", " if (iter_count % show_every == 0):\n", " print('Epoch: {}, Iter: {}, D: {:.4}, G:{:.4}'.format(epoch, iter_count,d_total_error,g_error))\n", " imgs_numpy = fake_images.cpu().numpy()\n", " show_images(imgs_numpy[0:30])\n", " plt.show()\n", " iter_count += 1\n", " \n", " # random noise fed into our generator\n", " z = sample_noise(batch_size, noise_size)\n", " # generated images\n", " G_sample = G(z)\n", " print('Final images')\n", " show_images(G_sample[:16])\n", " plt.show()\n" ] }, { "cell_type": "code", "execution_count": 24, "id": "940e38e7", "metadata": { "attributes": { "classes": [ "code-cell" ], "id": "" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 0, Iter: 0, D: 1.14, G:0.6946\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 0, Iter: 1000, D: 0.7591, G:2.441\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 0, Iter: 2000, D: 0.9709, G:0.9196\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 0, Iter: 3000, D: 1.2, G:2.018\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 1, Iter: 4000, D: 1.199, G:1.177\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 1, Iter: 5000, D: 1.263, G:1.492\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 1, Iter: 6000, D: 1.287, G:0.8328\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 1, Iter: 7000, D: 1.295, G:1.124\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 2, Iter: 8000, D: 1.302, G:1.125\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 2, Iter: 9000, D: 1.118, G:0.6758\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 2, Iter: 10000, D: 1.173, G:0.7965\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 2, Iter: 11000, D: 1.351, G:0.9481\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Final images\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "warnings.filterwarnings(\"ignore\")\n", "# Make the discriminator\n", "D = discriminator()\n", "\n", "# Make the generator\n", "G = generator()\n", "\n", "# Use the function you wrote earlier to get optimizers for the Discriminator and the Generator\n", "D_solver, G_solver = get_solvers()\n", "\n", "# Run it!\n", "run_a_gan(D, G, D_solver, G_solver, discriminator_loss, generator_loss)" ] }, { "cell_type": "markdown", "id": "6774af8c", "metadata": {}, "source": [ "## Your turn! 🚀\n", "\n", "Implement TODO part of the code in this notebook.\n", "\n", "Assignment - [Art by gan](../assignments/deep-learning/gan/art-by-gan.ipynb)\n", "\n", "## Acknowledgments\n", "\n", "Thanks to [Sebastian Raschka](https://github.com/rasbt) for creating the open-source project [stat453-deep-learning-ss20](https://github.com/rasbt/stat453-deep-learning-ss20) and [Diego Gomez](https://github.com/diegoalejogm) for creating the open-source project [gans](https://github.com/diegoalejogm/gans). They inspire the majority of the content in this chapter.\n" ] } ], "metadata": { "kernelspec": { "display_name": "utseusgpu", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.18" } }, "nbformat": 4, "nbformat_minor": 5 }