diff --git a/gan/gen_images/img_0.png b/gan/gen_images/img_0.png new file mode 100644 index 00000000..be8bd637 Binary files /dev/null and b/gan/gen_images/img_0.png differ diff --git a/gan/gen_images/img_100.png b/gan/gen_images/img_100.png new file mode 100644 index 00000000..091505f9 Binary files /dev/null and b/gan/gen_images/img_100.png differ diff --git a/gan/gen_images/img_200.png b/gan/gen_images/img_200.png new file mode 100644 index 00000000..a3f9c3c6 Binary files /dev/null and b/gan/gen_images/img_200.png differ diff --git a/gan/gen_images/img_300.png b/gan/gen_images/img_300.png new file mode 100644 index 00000000..c036a48e Binary files /dev/null and b/gan/gen_images/img_300.png differ diff --git a/gan/gen_images/img_400.png b/gan/gen_images/img_400.png new file mode 100644 index 00000000..f4bdea81 Binary files /dev/null and b/gan/gen_images/img_400.png differ diff --git a/gan/main.py b/gan/main.py new file mode 100644 index 00000000..5aea6254 --- /dev/null +++ b/gan/main.py @@ -0,0 +1,195 @@ +import mnist + +import argparse + +import mlx.core as mx +import mlx.nn as nn +import mlx.optimizers as optim + +from tqdm import tqdm +import numpy as np +import matplotlib.pyplot as plt + +# Generator Block +def GenBlock(in_dim:int,out_dim:int): + return nn.Sequential( + nn.Linear(in_dim,out_dim), + nn.BatchNorm(out_dim, 0.8), + nn.LeakyReLU(0.2) + ) + +# Generator Model +class Generator(nn.Module): + + def __init__(self, z_dim:int = 32, im_dim:int = 784, hidden_dim: int = 256): + super(Generator, self).__init__() + + self.gen = nn.Sequential( + GenBlock(z_dim, hidden_dim), + GenBlock(hidden_dim, hidden_dim * 2), + GenBlock(hidden_dim * 2, hidden_dim * 4), + + nn.Linear(hidden_dim * 4,im_dim), + ) + + def __call__(self, noise): + x = self.gen(noise) + return mx.tanh(x) + +# make 2D noise with shape n_samples x z_dim +def get_noise(n_samples:list[int], z_dim:int)->list[int]: + return mx.random.normal(shape=(n_samples, z_dim)) + +#---------------------------------------------# + +# Discriminator Block +def DisBlock(in_dim:int,out_dim:int): + return nn.Sequential( + nn.Linear(in_dim,out_dim), + nn.LeakyReLU(negative_slope=0.2), + nn.Dropout(0.3), + ) + +# Discriminator Model +class Discriminator(nn.Module): + + def __init__(self,im_dim:int = 784, hidden_dim:int = 256): + super(Discriminator, self).__init__() + + self.disc = nn.Sequential( + DisBlock(im_dim, hidden_dim * 4), + DisBlock(hidden_dim * 4, hidden_dim * 2), + DisBlock(hidden_dim * 2, hidden_dim), + + nn.Linear(hidden_dim,1), + nn.Sigmoid() + ) + + def __call__(self, noise): + return self.disc(noise) + +# Discriminator Loss +def disc_loss(gen, disc, real, num_images, z_dim): + + noise = mx.array(get_noise(num_images, z_dim)) + fake_images = gen(noise) + + fake_disc = disc(fake_images) + + fake_labels = mx.zeros((fake_images.shape[0],1)) + + fake_loss = mx.mean(nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True)) + + real_disc = mx.array(disc(real)) + real_labels = mx.ones((real.shape[0],1)) + + real_loss = mx.mean(nn.losses.binary_cross_entropy(real_disc,real_labels,with_logits=True)) + + disc_loss = (fake_loss + real_loss) / 2.0 + + return disc_loss + +# Genearator Loss +def gen_loss(gen, disc, num_images, z_dim): + + noise = mx.array(get_noise(num_images, z_dim)) + + fake_images = gen(noise) + fake_disc = mx.array(disc(fake_images)) + + fake_labels = mx.ones((fake_images.shape[0],1)) + + gen_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True) + + return mx.mean(gen_loss) + +# make batch of images +def batch_iterate(batch_size: int, ipt: list[int])-> list[int]: + perm = np.random.permutation(len(ipt)) + for s in range(0, len(ipt), batch_size): + ids = perm[s : s + batch_size] + yield ipt[ids] + +# plot batch of images at epoch steps +def show_images(epoch_num:int,imgs:list[int],num_imgs:int = 25): + if (imgs.shape[0] > 0): + fig,axes = plt.subplots(5, 5, figsize=(5, 5)) + + for i, ax in enumerate(axes.flat): + img = mx.array(imgs[i]).reshape(28,28) + ax.imshow(img,cmap='gray') + ax.axis('off') + plt.tight_layout() + plt.savefig('gen_images/img_{}.png'.format(epoch_num)) + plt.show() + +def main(args:dict): + seed = 42 + n_epochs = 500 + z_dim = 128 + batch_size = 128 + lr = 2e-5 + + mx.random.seed(seed) + + # Load the data + train_images,*_ = map(np.array, getattr(mnist,'mnist')()) + + # Normalization images => [-1,1] + train_images = train_images * 2.0 - 1.0 + + gen = Generator(z_dim) + mx.eval(gen.parameters()) + gen_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.999]) + + disc = Discriminator() + mx.eval(disc.parameters()) + disc_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.999]) + + # TODO training... + + D_loss_grad = nn.value_and_grad(disc, disc_loss) + G_loss_grad = nn.value_and_grad(gen, gen_loss) + + for epoch in tqdm(range(n_epochs)): + + for idx,real in enumerate(batch_iterate(batch_size, train_images)): + + # TODO Train Discriminator + D_loss,D_grads = D_loss_grad(gen, disc,mx.array(real), batch_size, z_dim) + + # Update optimizer + disc_opt.update(disc, D_grads) + + # Update gradients + mx.eval(disc.parameters(), disc_opt.state) + + # TODO Train Generator + G_loss,G_grads = G_loss_grad(gen, disc, batch_size, z_dim) + + # Update optimizer + gen_opt.update(gen, G_grads) + + # Update gradients + mx.eval(gen.parameters(), gen_opt.state) + + if epoch%100==0: + print("Epoch: {}, iteration: {}, Discriminator Loss:{}, Generator Loss: {}".format(epoch,idx,D_loss,G_loss)) + fake_noise = mx.array(get_noise(batch_size, z_dim)) + fake = gen(fake_noise) + show_images(epoch,fake) + +if __name__ == "__main__": + parser = argparse.ArgumentParser("Train a simple GAN on MNIST with MLX.") + parser.add_argument("--gpu", action="store_true", help="Use the Metal back-end.") + parser.add_argument( + "--dataset", + type=str, + default="mnist", + choices=["mnist", "fashion_mnist"], + help="The dataset to use.", + ) + args = parser.parse_args() + if not args.gpu: + mx.set_default_device(mx.cpu) + main(args) diff --git a/gan/mnist.py b/gan/mnist.py new file mode 100644 index 00000000..c5f920e6 --- /dev/null +++ b/gan/mnist.py @@ -0,0 +1,83 @@ +# Copyright © 2023 Apple Inc. + +import gzip +import os +import pickle +from urllib import request + +import numpy as np + + +def mnist( + save_dir="/tmp", + base_url="https://raw.githubusercontent.com/fgnt/mnist/master/", + filename="mnist.pkl", +): + """ + Load the MNIST dataset in 4 tensors: train images, train labels, + test images, and test labels. + + Checks `save_dir` for already downloaded data otherwise downloads. + + Download code modified from: + https://github.com/hsjeong5/MNIST-for-Numpy + """ + + def download_and_save(save_file): + filename = [ + ["training_images", "train-images-idx3-ubyte.gz"], + ["test_images", "t10k-images-idx3-ubyte.gz"], + ["training_labels", "train-labels-idx1-ubyte.gz"], + ["test_labels", "t10k-labels-idx1-ubyte.gz"], + ] + + mnist = {} + for name in filename: + out_file = os.path.join("/tmp", name[1]) + request.urlretrieve(base_url + name[1], out_file) + for name in filename[:2]: + out_file = os.path.join("/tmp", name[1]) + with gzip.open(out_file, "rb") as f: + mnist[name[0]] = np.frombuffer(f.read(), np.uint8, offset=16).reshape( + -1, 28 * 28 + ) + for name in filename[-2:]: + out_file = os.path.join("/tmp", name[1]) + with gzip.open(out_file, "rb") as f: + mnist[name[0]] = np.frombuffer(f.read(), np.uint8, offset=8) + with open(save_file, "wb") as f: + pickle.dump(mnist, f) + + save_file = os.path.join(save_dir, filename) + if not os.path.exists(save_file): + download_and_save(save_file) + with open(save_file, "rb") as f: + mnist = pickle.load(f) + + def preproc(x): + return x.astype(np.float32) / 255.0 + + mnist["training_images"] = preproc(mnist["training_images"]) + mnist["test_images"] = preproc(mnist["test_images"]) + return ( + mnist["training_images"], + mnist["training_labels"].astype(np.uint32), + mnist["test_images"], + mnist["test_labels"].astype(np.uint32), + ) + + +def fashion_mnist(save_dir="/tmp"): + return mnist( + save_dir, + base_url="http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/", + filename="fashion_mnist.pkl", + ) + + +if __name__ == "__main__": + train_x, train_y, test_x, test_y = mnist() + assert train_x.shape == (60000, 28 * 28), "Wrong training set size" + assert train_y.shape == (60000,), "Wrong training set size" + assert test_x.shape == (10000, 28 * 28), "Wrong test set size" + assert test_y.shape == (10000,), "Wrong test set size" diff --git a/gan/playground.ipynb b/gan/playground.ipynb new file mode 100644 index 00000000..a829a2d1 --- /dev/null +++ b/gan/playground.ipynb @@ -0,0 +1,636 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Import Library" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import mnist" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import mlx.core as mx\n", + "import mlx.nn as nn\n", + "import mlx.optimizers as optim\n", + "\n", + "from tqdm import tqdm\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# mx.set_default_device(mx.gpu)\n", + "mx.random.seed(42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# GAN Architecture" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generator 👨🏻‍🎨" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def GenBlock(in_dim:int,out_dim:int):\n", + " \n", + " return nn.Sequential(\n", + " nn.Linear(in_dim,out_dim),\n", + " nn.BatchNorm(out_dim, 0.8),\n", + " nn.LeakyReLU(0.2)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class Generator(nn.Module):\n", + "\n", + " def __init__(self, z_dim:int = 32, im_dim:int = 784, hidden_dim: int = 256):\n", + " super(Generator, self).__init__()\n", + "\n", + " self.gen = nn.Sequential(\n", + " GenBlock(z_dim, hidden_dim),\n", + " GenBlock(hidden_dim, hidden_dim * 2),\n", + " GenBlock(hidden_dim * 2, hidden_dim * 4),\n", + "\n", + " nn.Linear(hidden_dim * 4,im_dim),\n", + " )\n", + " \n", + " def __call__(self, noise):\n", + " x = self.gen(noise)\n", + " return mx.tanh(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Generator(\n", + " (gen): Sequential(\n", + " (layers.0): Sequential(\n", + " (layers.0): Linear(input_dims=100, output_dims=256, bias=True)\n", + " (layers.1): BatchNorm(256, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.2): LeakyReLU()\n", + " )\n", + " (layers.1): Sequential(\n", + " (layers.0): Linear(input_dims=256, output_dims=512, bias=True)\n", + " (layers.1): BatchNorm(512, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.2): LeakyReLU()\n", + " )\n", + " (layers.2): Sequential(\n", + " (layers.0): Linear(input_dims=512, output_dims=1024, bias=True)\n", + " (layers.1): BatchNorm(1024, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.2): LeakyReLU()\n", + " )\n", + " (layers.3): Linear(input_dims=1024, output_dims=784, bias=True)\n", + " )\n", + ")" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gen = Generator(100)\n", + "gen" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# make 2D noise with shape n_samples x z_dim\n", + "def get_noise(n_samples:list[int], z_dim:int)->list[int]:\n", + " return mx.random.normal(shape=(n_samples, z_dim))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "img = get_noise(28,28)\n", + "plt.imshow(img, cmap='gray')\n", + "plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discriminator 🕵🏻‍♂️" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def DisBlock(in_dim:int,out_dim:int):\n", + " return nn.Sequential(\n", + " nn.Linear(in_dim,out_dim),\n", + " nn.LeakyReLU(negative_slope=0.2),\n", + " nn.Dropout(0.3),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "class Discriminator(nn.Module):\n", + "\n", + " def __init__(self,im_dim:int = 784, hidden_dim:int = 256):\n", + " super(Discriminator, self).__init__()\n", + "\n", + " self.disc = nn.Sequential(\n", + " DisBlock(im_dim, hidden_dim * 4),\n", + " DisBlock(hidden_dim * 4, hidden_dim * 2),\n", + " DisBlock(hidden_dim * 2, hidden_dim),\n", + " \n", + " nn.Linear(hidden_dim,1),\n", + " nn.Sigmoid()\n", + " )\n", + " \n", + " \n", + " def __call__(self, noise):\n", + " return self.disc(noise)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Discriminator(\n", + " (disc): Sequential(\n", + " (layers.0): Sequential(\n", + " (layers.0): Linear(input_dims=784, output_dims=1024, bias=True)\n", + " (layers.1): LeakyReLU()\n", + " (layers.2): Dropout(p=0.30000000000000004)\n", + " )\n", + " (layers.1): Sequential(\n", + " (layers.0): Linear(input_dims=1024, output_dims=512, bias=True)\n", + " (layers.1): LeakyReLU()\n", + " (layers.2): Dropout(p=0.30000000000000004)\n", + " )\n", + " (layers.2): Sequential(\n", + " (layers.0): Linear(input_dims=512, output_dims=256, bias=True)\n", + " (layers.1): LeakyReLU()\n", + " (layers.2): Dropout(p=0.30000000000000004)\n", + " )\n", + " (layers.3): Linear(input_dims=256, output_dims=1, bias=True)\n", + " (layers.4): Sigmoid()\n", + " )\n", + ")" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "disc = Discriminator()\n", + "disc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model Training 🏋🏻‍♂️" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Losses" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Discriminator Loss" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def disc_loss(gen, disc, real, num_images, z_dim):\n", + " \n", + " noise = mx.array(get_noise(num_images, z_dim))\n", + " fake_images = gen(noise)\n", + " \n", + " fake_disc = disc(fake_images)\n", + " \n", + " fake_labels = mx.zeros((fake_images.shape[0],1))\n", + " \n", + " fake_loss = mx.mean(nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True))\n", + " \n", + " real_disc = mx.array(disc(real))\n", + " real_labels = mx.ones((real.shape[0],1))\n", + " \n", + " real_loss = mx.mean(nn.losses.binary_cross_entropy(real_disc,real_labels,with_logits=True))\n", + " \n", + " disc_loss = (fake_loss + real_loss) / 2.0\n", + "\n", + " return disc_loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Generator Loss" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def gen_loss(gen, disc, num_images, z_dim):\n", + "\n", + " noise = mx.array(get_noise(num_images, z_dim))\n", + " \n", + " fake_images = gen(noise)\n", + " fake_disc = mx.array(disc(fake_images))\n", + "\n", + " fake_labels = mx.ones((fake_images.shape[0],1))\n", + " \n", + " gen_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True)\n", + " \n", + " return mx.mean(gen_loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Get only the training images\n", + "train_images,train_labels,*_ = map(np.array, mnist.mnist())" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Normalize the images to fall between -1,1\n", + "train_images = train_images * 2.0 - 1.0" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaEAAAGdCAYAAAC7EMwUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAaI0lEQVR4nO3df2jU9x3H8dfVH1d1lytBk7vUmGVF202dpWrVYP3R1cxApf4oWMtGZEPa+YOJ/cGsDNNBjdgpRdI6V0amW239Y9a6KdUMTXRkijpdRYtYjDOdCcFM72LUSMxnf4hHz1j1e975vkueD/iCufu+vY/ffuvTby75xueccwIAwMBD1gsAAHRfRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJjpab2AW3V0dOjcuXMKBALy+XzWywEAeOScU0tLi/Ly8vTQQ3e+1km7CJ07d075+fnWywAA3Kf6+noNHDjwjvuk3afjAoGA9RIAAElwL3+fpyxCH3zwgQoLC/Xwww9r5MiR2rdv3z3N8Sk4AOga7uXv85REaPPmzVq8eLGWLVumI0eO6JlnnlFJSYnOnj2bipcDAGQoXyruoj1mzBg99dRTWrduXeyx73//+5o+fbrKy8vvOBuNRhUMBpO9JADAAxaJRJSVlXXHfZJ+JXTt2jUdPnxYxcXFcY8XFxertra20/5tbW2KRqNxGwCge0h6hM6fP6/r168rNzc37vHc3Fw1NjZ22r+8vFzBYDC28ZVxANB9pOwLE259Q8o5d9s3qZYuXapIJBLb6uvrU7UkAECaSfr3CfXv3189evTodNXT1NTU6epIkvx+v/x+f7KXAQDIAEm/Eurdu7dGjhypqqqquMerqqpUVFSU7JcDAGSwlNwxYcmSJfrpT3+qUaNGady4cfr973+vs2fP6tVXX03FywEAMlRKIjR79mw1NzfrN7/5jRoaGjRs2DDt2LFDBQUFqXg5AECGSsn3Cd0Pvk8IALoGk+8TAgDgXhEhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmCFCAAAzRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmCFCAAAzRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZIgQAMEOEAABmelovAEgnPXr08DwTDAZTsJLkWLhwYUJzffv29Tzz+OOPe55ZsGCB55nf/va3nmfmzJnjeUaSrl696nlm5cqVnmfefvttzzNdBVdCAAAzRAgAYCbpESorK5PP54vbQqFQsl8GANAFpOQ9oaFDh+rvf/977ONEPs8OAOj6UhKhnj17cvUDALirlLwndOrUKeXl5amwsFAvvfSSTp8+/a37trW1KRqNxm0AgO4h6REaM2aMNm7cqJ07d+rDDz9UY2OjioqK1NzcfNv9y8vLFQwGY1t+fn6ylwQASFNJj1BJSYlmzZql4cOH67nnntP27dslSRs2bLjt/kuXLlUkEolt9fX1yV4SACBNpfybVfv166fhw4fr1KlTt33e7/fL7/enehkAgDSU8u8Tamtr05dffqlwOJzqlwIAZJikR+j1119XTU2N6urqdODAAb344ouKRqMqLS1N9ksBADJc0j8d9/XXX2vOnDk6f/68BgwYoLFjx2r//v0qKChI9ksBADJc0iP0ySefJPu3RJoaNGiQ55nevXt7nikqKvI8M378eM8zkvTII494npk1a1ZCr9XVfP31155n1q5d63lmxowZnmdaWlo8z0jSv//9b88zNTU1Cb1Wd8W94wAAZogQAMAMEQIAmCFCAAAzRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAMz7nnLNexDdFo1EFg0HrZXQrTz75ZEJzu3fv9jzDf9vM0NHR4XnmZz/7meeZS5cueZ5JRENDQ0JzFy5c8Dxz8uTJhF6rK4pEIsrKyrrjPlwJAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZIgQAMEOEAABmiBAAwExP6wXA3tmzZxOaa25u9jzDXbRvOHDggOeZixcvep6ZPHmy5xlJunbtmueZP/3pTwm9Fro3roQAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADPcwBT63//+l9DcG2+84Xnm+eef9zxz5MgRzzNr1671PJOoo0ePep6ZMmWK55nW1lbPM0OHDvU8I0m//OUvE5oDvOJKCABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmCFCAAAzRAgAYIYIAQDMECEAgBkiBAAw43POOetFfFM0GlUwGLReBlIkKyvL80xLS4vnmfXr13uekaSf//znnmd+8pOfeJ75+OOPPc8AmSYSidz1/3muhAAAZogQAMCM5wjt3btX06ZNU15ennw+n7Zu3Rr3vHNOZWVlysvLU58+fTRp0iQdP348WesFAHQhniPU2tqqESNGqKKi4rbPr1q1SmvWrFFFRYUOHjyoUCikKVOmJPR5fQBA1+b5J6uWlJSopKTkts855/Tee+9p2bJlmjlzpiRpw4YNys3N1aZNm/TKK6/c32oBAF1KUt8TqqurU2Njo4qLi2OP+f1+TZw4UbW1tbedaWtrUzQajdsAAN1DUiPU2NgoScrNzY17PDc3N/bcrcrLyxUMBmNbfn5+MpcEAEhjKfnqOJ/PF/exc67TYzctXbpUkUgkttXX16diSQCANOT5PaE7CYVCkm5cEYXD4djjTU1Nna6ObvL7/fL7/clcBgAgQyT1SqiwsFChUEhVVVWxx65du6aamhoVFRUl86UAAF2A5yuhS5cu6auvvop9XFdXp6NHjyo7O1uDBg3S4sWLtWLFCg0ePFiDBw/WihUr1LdvX7388stJXTgAIPN5jtChQ4c0efLk2MdLliyRJJWWluqPf/yj3nzzTV25ckXz58/XhQsXNGbMGO3atUuBQCB5qwYAdAncwBRd0rvvvpvQ3M1/VHlRU1Pjeea5557zPNPR0eF5BrDEDUwBAGmNCAEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZriLNrqkfv36JTT317/+1fPMxIkTPc+UlJR4ntm1a5fnGcASd9EGAKQ1IgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMNzAFvuGxxx7zPPOvf/3L88zFixc9z+zZs8fzzKFDhzzPSNL777/veSbN/ipBGuAGpgCAtEaEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmOEGpsB9mjFjhueZyspKzzOBQMDzTKLeeustzzMbN270PNPQ0OB5BpmDG5gCANIaEQIAmCFCAAAzRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGG5gCBoYNG+Z5Zs2aNZ5nfvSjH3meSdT69es9z7zzzjueZ/773/96noENbmAKAEhrRAgAYMZzhPbu3atp06YpLy9PPp9PW7dujXt+7ty58vl8cdvYsWOTtV4AQBfiOUKtra0aMWKEKioqvnWfqVOnqqGhIbbt2LHjvhYJAOiaenodKCkpUUlJyR338fv9CoVCCS8KANA9pOQ9oerqauXk5GjIkCGaN2+empqavnXftrY2RaPRuA0A0D0kPUIlJSX66KOPtHv3bq1evVoHDx7Us88+q7a2ttvuX15ermAwGNvy8/OTvSQAQJry/Om4u5k9e3bs18OGDdOoUaNUUFCg7du3a+bMmZ32X7p0qZYsWRL7OBqNEiIA6CaSHqFbhcNhFRQU6NSpU7d93u/3y+/3p3oZAIA0lPLvE2publZ9fb3C4XCqXwoAkGE8XwldunRJX331Vezjuro6HT16VNnZ2crOzlZZWZlmzZqlcDisM2fO6K233lL//v01Y8aMpC4cAJD5PEfo0KFDmjx5cuzjm+/nlJaWat26dTp27Jg2btyoixcvKhwOa/Lkydq8ebMCgUDyVg0A6BK4gSmQIR555BHPM9OmTUvotSorKz3P+Hw+zzO7d+/2PDNlyhTPM7DBDUwBAGmNCAEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZriLNoBO2traPM/07On9BzW3t7d7nvnxj3/seaa6utrzDO4fd9EGAKQ1IgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMCM9zsOArhvP/zhDz3PvPjii55nRo8e7XlGSuxmpIk4ceKE55m9e/emYCWwwpUQAMAMEQIAmCFCAAAzRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGG5gC3/D44497nlm4cKHnmZkzZ3qeCYVCnmcepOvXr3ueaWho8DzT0dHheQbpiyshAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMNzBF2kvkxp1z5sxJ6LUSuRnpd7/73YReK50dOnTI88w777zjeWbbtm2eZ9C1cCUEADBDhAAAZjxFqLy8XKNHj1YgEFBOTo6mT5+ukydPxu3jnFNZWZny8vLUp08fTZo0ScePH0/qogEAXYOnCNXU1GjBggXav3+/qqqq1N7eruLiYrW2tsb2WbVqldasWaOKigodPHhQoVBIU6ZMUUtLS9IXDwDIbJ6+MOHzzz+P+7iyslI5OTk6fPiwJkyYIOec3nvvPS1btiz2kyM3bNig3Nxcbdq0Sa+88kryVg4AyHj39Z5QJBKRJGVnZ0uS6urq1NjYqOLi4tg+fr9fEydOVG1t7W1/j7a2NkWj0bgNANA9JBwh55yWLFmi8ePHa9iwYZKkxsZGSVJubm7cvrm5ubHnblVeXq5gMBjb8vPzE10SACDDJByhhQsX6osvvtDHH3/c6Tmfzxf3sXOu02M3LV26VJFIJLbV19cnuiQAQIZJ6JtVFy1apG3btmnv3r0aOHBg7PGb31TY2NiocDgce7ypqanT1dFNfr9ffr8/kWUAADKcpysh55wWLlyoLVu2aPfu3SosLIx7vrCwUKFQSFVVVbHHrl27ppqaGhUVFSVnxQCALsPTldCCBQu0adMmffbZZwoEArH3eYLBoPr06SOfz6fFixdrxYoVGjx4sAYPHqwVK1aob9++evnll1PyBwAAZC5PEVq3bp0kadKkSXGPV1ZWau7cuZKkN998U1euXNH8+fN14cIFjRkzRrt27VIgEEjKggEAXYfPOeesF/FN0WhUwWDQehm4B9/2Pt+d/OAHP/A8U1FR4XnmiSee8DyT7g4cOOB55t13303otT777DPPMx0dHQm9FrquSCSirKysO+7DveMAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABgJqGfrIr0lZ2d7Xlm/fr1Cb3Wk08+6Xnme9/7XkKvlc5qa2s9z6xevdrzzM6dOz3PXLlyxfMM8CBxJQQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmOEGpg/ImDFjPM+88cYbnmeefvppzzOPPvqo55l0d/ny5YTm1q5d63lmxYoVnmdaW1s9zwBdEVdCAAAzRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZbmD6gMyYMeOBzDxIJ06c8Dzzt7/9zfNMe3u755nVq1d7npGkixcvJjQHIDFcCQEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZnzOOWe9iG+KRqMKBoPWywAA3KdIJKKsrKw77sOVEADADBECAJjxFKHy8nKNHj1agUBAOTk5mj59uk6ePBm3z9y5c+Xz+eK2sWPHJnXRAICuwVOEampqtGDBAu3fv19VVVVqb29XcXGxWltb4/abOnWqGhoaYtuOHTuSumgAQNfg6Serfv7553EfV1ZWKicnR4cPH9aECRNij/v9foVCoeSsEADQZd3Xe0KRSESSlJ2dHfd4dXW1cnJyNGTIEM2bN09NTU3f+nu0tbUpGo3GbQCA7iHhL9F2zumFF17QhQsXtG/fvtjjmzdv1ne+8x0VFBSorq5Ov/71r9Xe3q7Dhw/L7/d3+n3Kysr09ttvJ/4nAACkpXv5Em25BM2fP98VFBS4+vr6O+537tw516tXL/eXv/zlts9fvXrVRSKR2FZfX+8ksbGxsbFl+BaJRO7aEk/vCd20aNEibdu2TXv37tXAgQPvuG84HFZBQYFOnTp12+f9fv9tr5AAAF2fpwg557Ro0SJ9+umnqq6uVmFh4V1nmpubVV9fr3A4nPAiAQBdk6cvTFiwYIH+/Oc/a9OmTQoEAmpsbFRjY6OuXLkiSbp06ZJef/11/fOf/9SZM2dUXV2tadOmqX///poxY0ZK/gAAgAzm5X0gfcvn/SorK51zzl2+fNkVFxe7AQMGuF69erlBgwa50tJSd/bs2Xt+jUgkYv55TDY2Nja2+9/u5T0hbmAKAEgJbmAKAEhrRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmCFCAAAzaRch55z1EgAASXAvf5+nXYRaWlqslwAASIJ7+fvc59Ls0qOjo0Pnzp1TIBCQz+eLey4ajSo/P1/19fXKysoyWqE9jsMNHIcbOA43cBxuSIfj4JxTS0uL8vLy9NBDd77W6fmA1nTPHnroIQ0cOPCO+2RlZXXrk+wmjsMNHIcbOA43cBxusD4OwWDwnvZLu0/HAQC6DyIEADCTURHy+/1avny5/H6/9VJMcRxu4DjcwHG4geNwQ6Ydh7T7wgQAQPeRUVdCAICuhQgBAMwQIQCAGSIEADCTURH64IMPVFhYqIcfflgjR47Uvn37rJf0QJWVlcnn88VtoVDIelkpt3fvXk2bNk15eXny+XzaunVr3PPOOZWVlSkvL099+vTRpEmTdPz4cZvFptDdjsPcuXM7nR9jx461WWyKlJeXa/To0QoEAsrJydH06dN18uTJuH26w/lwL8chU86HjInQ5s2btXjxYi1btkxHjhzRM888o5KSEp09e9Z6aQ/U0KFD1dDQENuOHTtmvaSUa21t1YgRI1RRUXHb51etWqU1a9aooqJCBw8eVCgU0pQpU7rcfQjvdhwkaerUqXHnx44dOx7gClOvpqZGCxYs0P79+1VVVaX29nYVFxertbU1tk93OB/u5ThIGXI+uAzx9NNPu1dffTXusSeeeML96le/MlrRg7d8+XI3YsQI62WYkuQ+/fTT2McdHR0uFAq5lStXxh67evWqCwaD7ne/+53BCh+MW4+Dc86Vlpa6F154wWQ9VpqampwkV1NT45zrvufDrcfBucw5HzLiSujatWs6fPiwiouL4x4vLi5WbW2t0apsnDp1Snl5eSosLNRLL72k06dPWy/JVF1dnRobG+PODb/fr4kTJ3a7c0OSqqurlZOToyFDhmjevHlqamqyXlJKRSIRSVJ2drak7ns+3HocbsqE8yEjInT+/Hldv35dubm5cY/n5uaqsbHRaFUP3pgxY7Rx40bt3LlTH374oRobG1VUVKTm5mbrpZm5+d+/u58bklRSUqKPPvpIu3fv1urVq3Xw4EE9++yzamtrs15aSjjntGTJEo0fP17Dhg2T1D3Ph9sdBylzzoe0u4v2ndz6ox2cc50e68pKSkpivx4+fLjGjRunxx57TBs2bNCSJUsMV2avu58bkjR79uzYr4cNG6ZRo0apoKBA27dv18yZMw1XlhoLFy7UF198oX/84x+dnutO58O3HYdMOR8y4kqof//+6tGjR6d/yTQ1NXX6F0930q9fPw0fPlynTp2yXoqZm18dyLnRWTgcVkFBQZc8PxYtWqRt27Zpz549cT/6pbudD992HG4nXc+HjIhQ7969NXLkSFVVVcU9XlVVpaKiIqNV2Wtra9OXX36pcDhsvRQzhYWFCoVCcefGtWvXVFNT063PDUlqbm5WfX19lzo/nHNauHChtmzZot27d6uwsDDu+e5yPtztONxO2p4Phl8U4cknn3zievXq5f7whz+4EydOuMWLF7t+/fq5M2fOWC/tgXnttddcdXW1O336tNu/f797/vnnXSAQ6PLHoKWlxR05csQdOXLESXJr1qxxR44ccf/5z3+cc86tXLnSBYNBt2XLFnfs2DE3Z84cFw6HXTQaNV55ct3pOLS0tLjXXnvN1dbWurq6Ordnzx43btw49+ijj3ap4/CLX/zCBYNBV11d7RoaGmLb5cuXY/t0h/Phbschk86HjImQc869//77rqCgwPXu3ds99dRTcV+O2B3Mnj3bhcNh16tXL5eXl+dmzpzpjh8/br2slNuzZ4+T1GkrLS11zt34stzly5e7UCjk/H6/mzBhgjt27JjtolPgTsfh8uXLrri42A0YMMD16tXLDRo0yJWWlrqzZ89aLzupbvfnl+QqKytj+3SH8+FuxyGTzgd+lAMAwExGvCcEAOiaiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmCFCAAAz/wdVbyhNmNF0pQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(train_images[0].reshape(28,28),cmap='gray')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def batch_iterate(batch_size: int, ipt: list[int])-> list[int]:\n", + " perm = np.random.permutation(len(ipt))\n", + " for s in range(0, len(ipt), batch_size):\n", + " ids = perm[s : s + batch_size]\n", + " yield ipt[ids]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "def show_images(epoch_num:int,imgs:list[int],num_imgs:int = 25):\n", + " if (imgs.shape[0] > 0): \n", + " fig,axes = plt.subplots(5, 5, figsize=(5, 5))\n", + " \n", + " for i, ax in enumerate(axes.flat):\n", + " img = mx.array(imgs[i]).reshape(28,28)\n", + " ax.imshow(img,cmap='gray')\n", + " ax.axis('off')\n", + " plt.tight_layout()\n", + " plt.savefig('gen_images/img_{}.png'.format(epoch_num))\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training Cycle" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "lr = 2e-5\n", + "z_dim = 128\n", + "\n", + "gen = Generator(z_dim)\n", + "mx.eval(gen.parameters())\n", + "gen_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.999]) #,betas=[0.5, 0.9]\n", + "\n", + "disc = Discriminator()\n", + "mx.eval(disc.parameters())\n", + "disc_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.999])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/500 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 100/500 [10:18<38:54, 5.84s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 100, iteration: 468, Discriminator Loss:array(0.536409, dtype=float32), Generator Loss: array(0.665009, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 200/500 [20:10<29:27, 5.89s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 200, iteration: 468, Discriminator Loss:array(0.556644, dtype=float32), Generator Loss: array(0.689756, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 300/500 [30:02<18:58, 5.69s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 300, iteration: 468, Discriminator Loss:array(0.58722, dtype=float32), Generator Loss: array(0.661292, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 400/500 [39:54<10:08, 6.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 400, iteration: 468, Discriminator Loss:array(0.587837, dtype=float32), Generator Loss: array(0.683923, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [49:45<00:00, 5.97s/it]\n" + ] + } + ], + "source": [ + "# Set your parameters\n", + "n_epochs = 500\n", + "display_step = 5000\n", + "cur_step = 0\n", + "\n", + "batch_size = 128 # 128\n", + "\n", + "D_loss_grad = nn.value_and_grad(disc, disc_loss)\n", + "G_loss_grad = nn.value_and_grad(gen, gen_loss)\n", + "\n", + "\n", + "for epoch in tqdm(range(n_epochs)):\n", + "\n", + " for idx,real in enumerate(batch_iterate(batch_size, train_images)):\n", + " \n", + " # TODO Train Discriminator\n", + " D_loss,D_grads = D_loss_grad(gen, disc,mx.array(real), batch_size, z_dim)\n", + "\n", + " # Update optimizer\n", + " disc_opt.update(disc, D_grads)\n", + " \n", + " # Update gradients\n", + " mx.eval(disc.parameters(), disc_opt.state)\n", + "\n", + " # TODO Train Generator\n", + " G_loss,G_grads = G_loss_grad(gen, disc, batch_size, z_dim)\n", + " \n", + " # Update optimizer\n", + " gen_opt.update(gen, G_grads)\n", + " \n", + " # Update gradients\n", + " mx.eval(gen.parameters(), gen_opt.state) \n", + " \n", + " if epoch%100==0:\n", + " print(\"Epoch: {}, iteration: {}, Discriminator Loss:{}, Generator Loss: {}\".format(epoch,idx,D_loss,G_loss))\n", + " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", + " fake = gen(fake_noise)\n", + " show_images(epoch,fake)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.10.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}