dcgan_jason_web.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras.datasets import fashion_mnist\n",
    "from tensorflow.keras import layers\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython import display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.7.0\n",
      "PhysicalDevice(name='/physical_device:CPU:0', device_type='CPU')\n",
      "PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')\n"
     ]
    }
   ],
   "source": [
    "print(tf.__version__)\n",
    "for device in tf.config.list_physical_devices():\n",
    "    print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train : (60000, 28, 28) (60000,)\n",
      "Test : (10000, 28, 28) (10000,)\n"
     ]
    }
   ],
   "source": [
    "(trainX, trainy), (testX, testy) = fashion_mnist.load_data()\n",
    "\n",
    "print(\"Train :\", trainX.shape, trainy.shape)\n",
    "print(\"Test :\", testX.shape, testy.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1343abad550>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(trainX[5], cmap='gray_r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def define_discriminator(in_shape=(28, 28, 1)):\n",
    "\n",
    "    model = keras.Sequential()\n",
    "    model.add(layers.Conv2D(128, (3, 3), strides=(2, 2), padding='same', input_shape=in_shape))\n",
    "    model.add(layers.LeakyReLU(alpha=0.2))\n",
    "    \n",
    "    model.add(layers.Conv2D(128, (3, 3), strides=(2, 2), padding='same'))\n",
    "    model.add(layers.LeakyReLU(alpha=0.2))\n",
    "\n",
    "    model.add(layers.Flatten())\n",
    "    model.add(layers.Dropout(0.4))\n",
    "    model.add(layers.Dense(1, activation='sigmoid'))\n",
    "\n",
    "    opt = keras.optimizers.Adam(learning_rate=0.0002, beta_1=0.5)\n",
    "    model.compile(\n",
    "        loss='binary_crossentropy',\n",
    "        optimizer=opt,\n",
    "        metrics=['accuracy'])\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def define_generator(latent_dim):\n",
    "\n",
    "    model = keras.Sequential()\n",
    "    model.add(layers.Dense(units=128*7*7, input_dim=latent_dim))\n",
    "    model.add(layers.LeakyReLU(alpha=0.2))\n",
    "    model.add(layers.Reshape((7, 7, 128)))\n",
    "\n",
    "    model.add(layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same'))\n",
    "    model.add(layers.LeakyReLU(alpha=0.2))\n",
    "\n",
    "    model.add(layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same'))\n",
    "    model.add(layers.LeakyReLU(alpha=0.2))\n",
    "\n",
    "    model.add(layers.Conv2D(1, (7, 7), activation='tanh', padding='same'))\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def define_gan(generator, discriminator):\n",
    "\n",
    "    discriminator.trainable = False\n",
    "\n",
    "    model = keras.Sequential()\n",
    "    model.add(generator)\n",
    "    model.add(discriminator)\n",
    "\n",
    "    opt = keras.optimizers.Adam(learning_rate=0.0002, beta_1=0.5)\n",
    "\n",
    "    model.compile(\n",
    "        loss='binary_crossentropy',\n",
    "        optimizer=opt\n",
    "    )\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_real_samples():\n",
    "\n",
    "    (trainX, _), (_, _) = fashion_mnist.load_data()\n",
    "    X = np.expand_dims(trainX, axis=-1).astype('float32')\n",
    "    X = (X -127.5) / 127.5\n",
    "\n",
    "    return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_real_samples(dataset, n_sample):\n",
    "\n",
    "    ix = np.random.randint(0, dataset.shape[0], n_sample)\n",
    "    X = dataset[ix]\n",
    "    y = tf.ones(shape=(n_sample, 1))\n",
    "\n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_latent_points(latent_dim, n_sample):\n",
    "\n",
    "    x_input = tf.random.normal(shape=(n_sample, latent_dim))\n",
    "\n",
    "    return x_input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_fake_samples(generator, latent_dim, n_sample):\n",
    "\n",
    "    x_input = generate_latent_points(latent_dim, n_sample)\n",
    "    X = generator.predict(x_input)\n",
    "    y = tf.zeros((n_sample, 1))\n",
    "\n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(G, D, GAN, dataset, latent_dim, n_epoch=100, n_batch=128):\n",
    "\n",
    "    batch_per_epoch = int(dataset.shape[0] / n_batch)\n",
    "    half_batch = int(n_batch / 2)\n",
    "\n",
    "    D_LOSS = []\n",
    "    G_LOSS = []\n",
    "    for epoch in range(n_epoch):\n",
    "        for iteration in range(batch_per_epoch):\n",
    "\n",
    "            X_real, y_real = generate_real_samples(dataset, half_batch)\n",
    "            D_loss1, _ = D.train_on_batch(X_real, y_real)\n",
    "            X_Fake, y_fake = generate_fake_samples(G, latent_dim, half_batch)\n",
    "            D_loss2, _ = D.train_on_batch(X_Fake, y_fake)\n",
    "\n",
    "            X_gan = generate_latent_points(latent_dim, n_batch)\n",
    "            y_gan = tf.ones((n_batch, 1))\n",
    "            G_loss = GAN.train_on_batch(X_gan, y_gan)\n",
    "\n",
    "            if iteration % 100 == 0:\n",
    "                print('>%d, %d/%d, d_total=%.3f, g=%.3f' %\n",
    "\t\t\t\t    (epoch+1, iteration+1, batch_per_epoch, D_loss1+D_loss2, G_loss))\n",
    "                generate_and_save_images(G, latent_dim)\n",
    "                display.clear_output(wait=True)\n",
    "            \n",
    "                \n",
    "            D_LOSS.append(D_loss1+D_loss2)\n",
    "            G_LOSS.append(G_loss)\n",
    "    \n",
    "    G.save('Generator.h5')\n",
    "\n",
    "    return D_LOSS, G_LOSS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_and_save_images(G, latent_dim=100):\n",
    "\n",
    "  z = generate_latent_points(latent_dim, 16)\n",
    "  predictions = G(z, training=False)\n",
    "\n",
    "  fig = plt.figure(figsize=(12, 12))\n",
    "\n",
    "  for i in range(predictions.shape[0]):\n",
    "      plt.subplot(4, 4, i+1)\n",
    "      plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')\n",
    "      plt.axis('off')\n",
    "\n",
    "  # plt.savefig('fakeimage_fashionmnist/image_at_epoch_{:04d}.png'.format(epoch))\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
     ]
    }
   ],
   "source": [
    "latent_dim = 100\n",
    "D = define_discriminator()\n",
    "G = define_generator(latent_dim)\n",
    "GAN = define_gan(G, D)\n",
    "\n",
    "dataset = load_real_samples()\n",
    "D_LOSS, G_LOSS = train(G, D, GAN, dataset, latent_dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(D_LOSS,)\n",
    "plt.plot(G_LOSS,)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tensorflow.keras.models import load_model\n",
    "\n",
    "saved_generator = load_model('generator.h5')\n",
    "batch_size = 3\n",
    "noise = tf.random.normal(shape=(batch_size, 100))\n",
    "imgs = saved_generator(noise, training=False)\n",
    "# print(imgs.shape)\n",
    "# print(type(imgs))\n",
    "fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(12, 6))\n",
    "for i, img in enumerate(imgs):\n",
    "    axes[i].imshow(img.numpy().reshape((28,28)), cmap='gray_r')\n",
    "    axes[i].axis('off')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "d2c0232beea39a074b56d23e38f61c9c88a0e4015a71ff632c65f04e034ee566"
  },
  "kernelspec": {
   "display_name": "Python 3.8.12 64-bit ('tensorflowgpu': conda)",
   "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.8.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}