{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "id": "n-HmiNnY3rlq" }, "outputs": [], "source": [ "import tensorflow as tf\n", "from tensorflow import keras\n", "from tensorflow.keras import layers\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import os\n", "from IPython.display import clear_output\n", "from ipywidgets import interact, interactive, fixed, interact_manual\n", "import ipywidgets as widgets\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# datos" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "id": "_i8vg7XP52TJ" }, "outputs": [], "source": [ "path = 'AnimeDCGAN'\n", "data_path = path +'/anime_faces'\n", "weights_path = path+'/weights'\n", "numpy_path= path+'/np_images'\n", "IMG_SIZE = (64,64)\n", "latent_dim = 100\n", "BATCH_SIZE = 128" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "AuIxNNqO3rlq", "outputId": "3435fa8f-369c-4c5a-f917-20fd19f6bfc7" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Found 63565 files belonging to 1 classes.\n" ] } ], "source": [ "dataset = keras.preprocessing.image_dataset_from_directory(\n", " data_path , label_mode=None, image_size=IMG_SIZE, batch_size=BATCH_SIZE\n", ")\n", "dataset = dataset.map(lambda x: x / 255.0)\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 265 }, "id": "FsX7zHBI3rlr", "outputId": "88d7959a-4f9b-4b52-ed09-43191d6522c8" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(128, 64, 64, 3)\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "for x in dataset:\n", " plt.axis(\"off\")\n", " plt.imshow((x.numpy() * 255).astype(\"int32\")[0])\n", " print(x.shape)\n", " break" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# modelo" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## creacion" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "9rOo5zYy3rlr", "outputId": "b4b20a55-7a10-4e19-9856-a24b75d22c89" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model: \"sequential\"\n", "_________________________________________________________________\n", " Layer (type) Output Shape Param # \n", "=================================================================\n", " conv2d (Conv2D) (None, 32, 32, 64) 1728 \n", " \n", " leaky_re_lu (LeakyReLU) (None, 32, 32, 64) 0 \n", " \n", " conv2d_1 (Conv2D) (None, 16, 16, 128) 73728 \n", " \n", " batch_normalization (BatchN (None, 16, 16, 128) 512 \n", " ormalization) \n", " \n", " leaky_re_lu_1 (LeakyReLU) (None, 16, 16, 128) 0 \n", " \n", " conv2d_2 (Conv2D) (None, 8, 8, 256) 819200 \n", " \n", " batch_normalization_1 (Batc (None, 8, 8, 256) 1024 \n", " hNormalization) \n", " \n", " leaky_re_lu_2 (LeakyReLU) (None, 8, 8, 256) 0 \n", " \n", " conv2d_3 (Conv2D) (None, 4, 4, 512) 3276800 \n", " \n", " batch_normalization_2 (Batc (None, 4, 4, 512) 2048 \n", " hNormalization) \n", " \n", " leaky_re_lu_3 (LeakyReLU) (None, 4, 4, 512) 0 \n", " \n", " conv2d_4 (Conv2D) (None, 1, 1, 1) 8192 \n", " \n", " flatten (Flatten) (None, 1) 0 \n", " \n", " activation (Activation) (None, 1) 0 \n", " \n", "=================================================================\n", "Total params: 4,183,232\n", "Trainable params: 4,181,440\n", "Non-trainable params: 1,792\n", "_________________________________________________________________\n" ] } ], "source": [ "def discriminator():\n", " init = tf.keras.initializers.RandomNormal(stddev=0.02)\n", "\n", " model = keras.models.Sequential()\n", " \n", "\n", " model.add(layers.Conv2D(64,kernel_size=3,strides=2,padding='same',use_bias=False,input_shape=(IMG_SIZE[0],IMG_SIZE[1],3),kernel_initializer=init))\n", " model.add(layers.LeakyReLU(alpha=0.2)) \n", "\n", " model.add(layers.Conv2D(128,kernel_size=3,strides=2,padding='same',use_bias=False,kernel_initializer=init))\n", " model.add(layers.BatchNormalization())\n", " model.add(layers.LeakyReLU(alpha=0.2)) \n", "\n", " model.add(layers.Conv2D(256,kernel_size=5,strides=2,padding='same',use_bias=False,kernel_initializer=init))\n", " model.add(layers.BatchNormalization())\n", " model.add(layers.LeakyReLU(alpha=0.2))\n", "\n", " model.add(layers.Conv2D(512,kernel_size=5,strides=2,padding='same',use_bias=False,kernel_initializer=init))\n", " model.add(layers.BatchNormalization())\n", " model.add(layers.LeakyReLU(alpha=0.2)) \n", " \n", " model.add(layers.Conv2D(1,kernel_size=4,strides=1,padding='valid',use_bias=False,kernel_initializer=init))\n", " model.add(layers.Flatten())\n", " model.add(layers.Activation('sigmoid'))\n", " return model\n", "discriminator = discriminator()\n", "discriminator.summary()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "z_mste_43rls", "outputId": "e3df3669-e9b1-44ae-c3cd-888a40215cff" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model: \"sequential_1\"\n", "_________________________________________________________________\n", " Layer (type) Output Shape Param # \n", "=================================================================\n", " dense (Dense) (None, 16384) 1654784 \n", " \n", " batch_normalization_3 (Batc (None, 16384) 65536 \n", " hNormalization) \n", " \n", " re_lu (ReLU) (None, 16384) 0 \n", " \n", " reshape (Reshape) (None, 4, 4, 1024) 0 \n", " \n", " conv2d_transpose (Conv2DTra (None, 8, 8, 512) 13107200 \n", " nspose) \n", " \n", " batch_normalization_4 (Batc (None, 8, 8, 512) 2048 \n", " hNormalization) \n", " \n", " re_lu_1 (ReLU) (None, 8, 8, 512) 0 \n", " \n", " conv2d_transpose_1 (Conv2DT (None, 16, 16, 256) 3276800 \n", " ranspose) \n", " \n", " batch_normalization_5 (Batc (None, 16, 16, 256) 1024 \n", " hNormalization) \n", " \n", " re_lu_2 (ReLU) (None, 16, 16, 256) 0 \n", " \n", " conv2d_transpose_2 (Conv2DT (None, 32, 32, 128) 294912 \n", " ranspose) \n", " \n", " batch_normalization_6 (Batc (None, 32, 32, 128) 512 \n", " hNormalization) \n", " \n", " re_lu_3 (ReLU) (None, 32, 32, 128) 0 \n", " \n", " conv2d_transpose_3 (Conv2DT (None, 64, 64, 3) 3456 \n", " ranspose) \n", " \n", " activation_1 (Activation) (None, 64, 64, 3) 0 \n", " \n", "=================================================================\n", "Total params: 18,406,272\n", "Trainable params: 18,371,712\n", "Non-trainable params: 34,560\n", "_________________________________________________________________\n" ] } ], "source": [ "def generator():\n", " init = tf.keras.initializers.RandomNormal(stddev=0.02)\n", "\n", " model = keras.models.Sequential()\n", " \n", " model.add(layers.Dense(4*4*1024,kernel_initializer=init,input_dim=latent_dim))\n", " model.add(layers.BatchNormalization())\n", " model.add(layers.ReLU())\n", " model.add(layers.Reshape((4,4,1024))) \n", "\n", " \n", " model.add(layers.Conv2DTranspose(512,kernel_size=5,strides=2,padding='same',use_bias=False,kernel_initializer=init))\n", " model.add(layers.BatchNormalization())\n", " model.add(layers.ReLU()) \n", " \n", " model.add(layers.Conv2DTranspose(256,kernel_size=5,strides=2,padding='same',use_bias=False,kernel_initializer=init))\n", " model.add(layers.BatchNormalization())\n", " model.add(layers.ReLU()) \n", " \n", " model.add(layers.Conv2DTranspose(128,kernel_size=3,strides=2,padding='same',use_bias=False,kernel_initializer=init))\n", " model.add(layers.BatchNormalization())\n", " model.add(layers.ReLU()) \n", "\n", " model.add(layers.Conv2DTranspose(3,kernel_size=3,strides=2,padding='same',use_bias=False,kernel_initializer=init))\n", " model.add(layers.Activation('tanh')) \n", " return model\n", "generator = generator()\n", "generator.summary()" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "id": "O0opsFYj3rlt" }, "outputs": [], "source": [ "class GAN(keras.Model):\n", " def __init__(self, discriminator, generator, latent_dim):\n", " super(GAN, self).__init__()\n", " self.discriminator = discriminator\n", " self.generator = generator\n", " self.latent_dim = latent_dim\n", " \n", "\n", " def compile(self, d_optimizer, g_optimizer, loss_fn):\n", " super(GAN, self).compile()\n", " self.d_optimizer = d_optimizer\n", " self.g_optimizer = g_optimizer\n", " self.loss_fn = loss_fn\n", " self.d_loss_metric = keras.metrics.Mean(name=\"d_loss\")\n", " self.g_loss_metric = keras.metrics.Mean(name=\"g_loss\")\n", "\n", " @property\n", " def metrics(self):\n", " return [self.d_loss_metric, self.g_loss_metric]\n", "\n", " def train_step(self, real_images):\n", " \n", " batch_size = tf.shape(real_images)[0]\n", " noise = tf.random.normal(shape=(batch_size, self.latent_dim))\n", "\n", " \n", " with tf.GradientTape() as disc_tape1:\n", " generated_images = self.generator(noise, training=True)\n", "\n", " real_output = self.discriminator(real_images, training=True)\n", " real_targets = tf.ones_like(real_output)\n", " d_loss = self.loss_fn(real_targets, real_output)\n", "\n", " gradients_of_disc1 = disc_tape1.gradient(d_loss, self.discriminator.trainable_variables)\n", " self.d_optimizer.apply_gradients(zip(gradients_of_disc1,self.discriminator.trainable_variables))\n", " \n", " \n", " with tf.GradientTape() as disc_tape2:\n", " fake_output = self.discriminator(generated_images, training=True)\n", " fake_targets = tf.zeros_like(fake_output)\n", " disc_loss2 = self.loss_fn(fake_targets, fake_output)\n", " gradients_of_disc2 = disc_tape2.gradient(disc_loss2, self.discriminator.trainable_variables)\n", " self.d_optimizer.apply_gradients(zip(gradients_of_disc2,self.discriminator.trainable_variables))\n", "\n", "\n", " with tf.GradientTape() as gen_tape:\n", " generated_images = self.generator(noise, training=True)\n", " fake_output = self.discriminator(generated_images, training=True)\n", " real_targets = tf.ones_like(fake_output)\n", " gen_loss = self.loss_fn(real_targets, fake_output)\n", "\n", " gradients_of_gen = gen_tape.gradient(gen_loss, self.generator.trainable_variables)\n", " self.g_optimizer.apply_gradients(zip(gradients_of_gen,self.generator.trainable_variables)) \n", "\n", " self.d_loss_metric.update_state(d_loss)\n", " self.g_loss_metric.update_state(gen_loss)\n", " return {\n", " \"d_loss\": self.d_loss_metric.result(),\n", " \"g_loss\": self.g_loss_metric.result(),\n", " }" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "id": "AUbyezGK3rlu" }, "outputs": [], "source": [ "class GANMonitor(keras.callbacks.Callback):\n", " def __init__(self, num_img=3, latent_dim=100,path='generadas',test_vector=None):\n", " self.num_img = num_img\n", " self.latent_dim = latent_dim\n", " self.path = path\n", " \n", "\n", " if not os.path.exists(path):\n", " os.makedirs(path)\n", " if not os.path.exists(path+'/img_training_gen'):\n", " os.makedirs(path+'/img_training_gen')\n", " if not os.path.exists(path+'/weights_auto_save'):\n", " os.makedirs(path+'/weights_auto_save')\n", " if not os.path.exists(numpy_path):\n", " os.makedirs(numpy_path)\n", " \n", " if test_vector is None :\n", " self.random_latent_vectors = tf.random.normal(shape=(self.num_img, self.latent_dim))\n", " np.save(numpy_path+'/origen',self.random_latent_vectors )\n", " else :\n", " self.random_latent_vectors = test_vector\n", " def on_epoch_end(self, epoch, logs=None):\n", " clear_output(wait=True)\n", " if(epoch%10==0):\n", " self.model.save_weights(f'{self.path}/weights_auto_save/{epoch}', save_format='tf')\n", " \n", " generated_images = self.model.generator(self.random_latent_vectors)\n", " generated_images *= 255\n", " generated_images.numpy()\n", " for i in range(self.num_img):\n", " img = keras.preprocessing.image.array_to_img(generated_images[i])\n", " plt.imshow((generated_images[i].numpy()).astype(\"int32\"))\n", " img.save(f'{self.path}/img_training_gen/generated_img_{epoch}_{i}.png')\n", " plt.show()\n", " \n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## entrenamiento" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "3AhjV0T_3rlu", "outputId": "a5cc1c5b-337d-4471-e96a-a1ab97062a9c" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\franz\\.conda\\envs\\tf-gpu\\lib\\site-packages\\keras\\optimizer_v2\\adam.py:105: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n", " super(Adam, self).__init__(name, **kwargs)\n" ] } ], "source": [ "gan = GAN(discriminator=discriminator, generator=generator, latent_dim=latent_dim)\n", "gan.compile(\n", " d_optimizer=tf.keras.optimizers.Adam(lr = 0.0002, beta_1 = 0.5, beta_2 = 0.999 ),\n", " g_optimizer=tf.keras.optimizers.Adam(lr = 0.0002, beta_1 = 0.5, beta_2 = 0.999 ),\n", " loss_fn=keras.losses.BinaryCrossentropy(),\n", ")\n", "callback = GANMonitor(1, path = path)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# resultados modelo " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# load weights\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gan.load_weights(weights_path+'/weights')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## img random " ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "id": "0QPNo21R3rlv" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "test_vect = tf.random.normal(shape=(2, latent_dim))\n", "test = generator.predict(test_vect)\n", "original = test[0]\n", "plt.imshow(test[0])\n", "np.save(numpy_path+'/random',test_vect[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## modificar imagen random" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "from ipywidgets import GridspecLayout,Button,Layout\n", "from matplotlib import pyplot as plt\n", "import ipywidgets as w\n", "from IPython.display import display, clear_output\n", "output = w.Output()\n", "\n", "\n", "\n", "def dict_to_arr(d): \n", " dictlist=[]\n", " for x in d.items():\n", " temp = x[1]\n", " dictlist.append(temp)\n", " return dictlist\n", "def on_button_clicked_random(): \n", " seed = tf.random.normal(shape=(2, latent_dim))[0]\n", " for i , s in enumerate(sliders):\n", " s.value = seed[i]\n", " return seed\n", "def create_grid(kwargs,latent_dim, columnas = 10):\n", " grid = GridspecLayout(10, 11)\n", " filas = latent_dim//columnas \n", " for i in range(filas):\n", " for j in range(columnas):\n", " if (i-1)*filas+(j-1) >= latent_dim:\n", " break\n", " grid[i, j] = sliders[(i-1)*10+(j-1)]\n", " return grid \n", "def update_chart(change):\n", " with output:\n", " clear_output()\n", " x = [s.value for s in sliders]\n", " test_vect = np.zeros(shape=(2, latent_dim))\n", " test_vect[0] = tf.convert_to_tensor(x, dtype=tf.float32)\n", " test = generator.predict(test_vect)\n", "\n", " f = plt.figure()\n", " f.add_subplot(1,2, 1)\n", " plt.imshow(test[0])\n", " f.add_subplot(1,2, 2)\n", " plt.imshow(original)\n", " plt.show(block=True)\n", " \n", " \n", "def funtion_to_sliders(sliders): \n", " for s in sliders:\n", " s.observe(update_chart, 'value')\n", " return sliders\n", "def guardar_numpy(b):\n", " with output:\n", " x = [s.value for s in sliders]\n", " x = np.array(x)\n", " np.save(numpy_path+'/modificada',x)\n", "\n", "seed =test_vect[0]\n", "\n", "kwargs = {'seed[{}]'.format(i) : \n", " widgets.FloatSlider( min = -1.0, \n", " max = 1.0, \n", " step = 0.01, \n", " value = seed[i]) \n", " for i in range(latent_dim)}\n", "\n", "sliders = dict_to_arr(kwargs)\n", "sliders = funtion_to_sliders(sliders)\n", "grid = create_grid(kwargs,latent_dim)\n", "\n", "guardar = widgets.Button(description=\"guardar\")\n", "guardar.on_click(guardar_numpy)\n", "\n", "random = widgets.Button(description=\"random\")\n", "random.on_click(on_button_clicked_random)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8c2c123919ef4de9b3ce38f3f4300383", "version_major": 2, "version_minor": 0 }, "text/plain": [ "VBox(children=(GridspecLayout(children=(FloatSlider(value=-0.20623274147510529, layout=Layout(grid_area='widge…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "w.VBox([grid,output,guardar,random])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# train\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 337 }, "id": "CGYGTWXi3rlv", "outputId": "0558b7d5-0dfd-477b-e5b1-866de9c4a249" }, "outputs": [], "source": [ "epochs = 100 \n", "training = gan.fit(\n", " dataset, epochs=epochs, callbacks=callback \n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# save weights" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "y2zjFEML3rlv" }, "outputs": [], "source": [ "gan.save_weights('weights/weights_new', save_format='tf')" ] } ], "metadata": { "accelerator": "GPU", "colab": { "collapsed_sections": [], "name": "SIMPLE_DCGAN", "provenance": [] }, "interpreter": { "hash": "3af8d5c17c834a5715d68deec2bf9936116d60d2d90b474f74600ac6ca4ca936" }, "kernelspec": { "display_name": "Python 3.10.1 64-bit", "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.7" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 0 }