GAN256 - Heels Zippo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 5554,
     "status": "ok",
     "timestamp": 1536249955868,
     "user": {
      "displayName": "T0nberry King",
      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128",
      "userId": "112258111549280424883"
     },
     "user_tz": -480
    },
    "id": "yoNU5Mpw_tFa",
    "outputId": "d2f444ab-3ebe-40e0-e750-e78010561973"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Importing Images...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import random\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "from math import floor\n",
    "\n",
    "\n",
    "def zero():\n",
    "    return np.random.uniform(0.0, 0.01, size = [1])\n",
    "\n",
    "def one():\n",
    "    return np.random.uniform(0.99, 1.0, size = [1])\n",
    "\n",
    "def noise(n):\n",
    "    return np.random.uniform(-1.0, 1.0, size = [n, 4096])\n",
    "\n",
    "print(\"Importing Images...\")\n",
    "\n",
    "Images = []\n",
    "images_path = os.getcwd() + '\\images'\n",
    "files = os.listdir(images_path)\n",
    "for n in range(1, len(files)):\n",
    "    temp1 = Image.open(f\"images/{str(n).zfill(5)}.jpg\")\n",
    "                \n",
    "    temp = np.array(temp1.convert('RGB'), dtype='float32')\n",
    "    \n",
    "    Images.append(temp / 255)\n",
    "    \n",
    "    Images.append(np.flip(Images[-1], 1))\n",
    "    \n",
    "from keras.layers import Conv2D, LeakyReLU, BatchNormalization, Dense, AveragePooling2D, GaussianNoise\n",
    "from keras.layers import Reshape, UpSampling2D, Activation, Dropout, Flatten, Conv2DTranspose\n",
    "from keras.models import model_from_json, Sequential\n",
    "from keras.optimizers import Adam\n",
    "    \n",
    "class GAN(object):\n",
    "    \n",
    "    def __init__(self):\n",
    "        \n",
    "        #Models\n",
    "        self.D = None\n",
    "        self.G = None\n",
    "        \n",
    "        self.OD = None\n",
    "        \n",
    "        self.DM = None\n",
    "        self.AM = None\n",
    "        \n",
    "        #Config\n",
    "        self.LR = 0.0001\n",
    "        self.steps = 1\n",
    "        \n",
    "    def discriminator(self):\n",
    "        \n",
    "        if self.D:\n",
    "            return self.D\n",
    "        \n",
    "        self.D = Sequential()\n",
    "        \n",
    "        #add Gaussian noise to prevent Discriminator overfitting\n",
    "        self.D.add(GaussianNoise(0.2, input_shape = [256, 256, 3]))\n",
    "        \n",
    "        #256x256x3 Image\n",
    "        self.D.add(Conv2D(filters = 8, kernel_size = 3, padding = 'same'))\n",
    "        self.D.add(LeakyReLU(0.2))\n",
    "        self.D.add(Dropout(0.25))\n",
    "        self.D.add(AveragePooling2D())\n",
    "        \n",
    "        #128x128x8\n",
    "        self.D.add(Conv2D(filters = 16, kernel_size = 3, padding = 'same'))\n",
    "        self.D.add(BatchNormalization(momentum = 0.7))\n",
    "        self.D.add(LeakyReLU(0.2))\n",
    "        self.D.add(Dropout(0.25))\n",
    "        self.D.add(AveragePooling2D())\n",
    "        \n",
    "        #64x64x16\n",
    "        self.D.add(Conv2D(filters = 32, kernel_size = 3, padding = 'same'))\n",
    "        self.D.add(BatchNormalization(momentum = 0.7))\n",
    "        self.D.add(LeakyReLU(0.2))\n",
    "        self.D.add(Dropout(0.25))\n",
    "        self.D.add(AveragePooling2D())\n",
    "        \n",
    "        #32x32x32\n",
    "        self.D.add(Conv2D(filters = 64, kernel_size = 3, padding = 'same'))\n",
    "        self.D.add(BatchNormalization(momentum = 0.7))\n",
    "        self.D.add(LeakyReLU(0.2))\n",
    "        self.D.add(Dropout(0.25))\n",
    "        self.D.add(AveragePooling2D())\n",
    "        \n",
    "        #16x16x64\n",
    "        self.D.add(Conv2D(filters = 128, kernel_size = 3, padding = 'same'))\n",
    "        self.D.add(BatchNormalization(momentum = 0.7))\n",
    "        self.D.add(LeakyReLU(0.2))\n",
    "        self.D.add(Dropout(0.25))\n",
    "        self.D.add(AveragePooling2D())\n",
    "        \n",
    "        #8x8x128\n",
    "        self.D.add(Conv2D(filters = 256, kernel_size = 3, padding = 'same'))\n",
    "        self.D.add(BatchNormalization(momentum = 0.7))\n",
    "        self.D.add(LeakyReLU(0.2))\n",
    "        self.D.add(Dropout(0.25))\n",
    "        self.D.add(AveragePooling2D())\n",
    "        \n",
    "        #4x4x256\n",
    "        self.D.add(Flatten())\n",
    "        \n",
    "        #256\n",
    "        self.D.add(Dense(128))\n",
    "        self.D.add(LeakyReLU(0.2))\n",
    "        \n",
    "        self.D.add(Dense(1, activation = 'sigmoid'))\n",
    "        \n",
    "        return self.D\n",
    "    \n",
    "    def generator(self):\n",
    "        \n",
    "        if self.G:\n",
    "            return self.G\n",
    "        \n",
    "        self.G = Sequential()\n",
    "        \n",
    "        self.G.add(Reshape(target_shape = [1, 1, 4096], input_shape = [4096]))\n",
    "        \n",
    "        #1x1x4096 \n",
    "        self.G.add(Conv2DTranspose(filters = 256, kernel_size = 4))\n",
    "        self.G.add(Activation('relu'))\n",
    "        \n",
    "        #4x4x256 - kernel sized increased by 1\n",
    "        self.G.add(Conv2D(filters = 256, kernel_size = 4, padding = 'same'))\n",
    "        self.G.add(BatchNormalization(momentum = 0.7))\n",
    "        self.G.add(Activation('relu'))\n",
    "        self.G.add(UpSampling2D())\n",
    "        \n",
    "        #8x8x256 - kernel sized increased by 1\n",
    "        self.G.add(Conv2D(filters = 128, kernel_size = 4, padding = 'same'))\n",
    "        self.G.add(BatchNormalization(momentum = 0.7))\n",
    "        self.G.add(Activation('relu'))\n",
    "        self.G.add(UpSampling2D())\n",
    "        \n",
    "        #16x16x128\n",
    "        self.G.add(Conv2D(filters = 64, kernel_size = 3, padding = 'same'))\n",
    "        self.G.add(BatchNormalization(momentum = 0.7))\n",
    "        self.G.add(Activation('relu'))\n",
    "        self.G.add(UpSampling2D())\n",
    "        \n",
    "        #32x32x64\n",
    "        self.G.add(Conv2D(filters = 32, kernel_size = 3, padding = 'same'))\n",
    "        self.G.add(BatchNormalization(momentum = 0.7))\n",
    "        self.G.add(Activation('relu'))\n",
    "        self.G.add(UpSampling2D())\n",
    "        \n",
    "        #64x64x32\n",
    "        self.G.add(Conv2D(filters = 16, kernel_size = 3, padding = 'same'))\n",
    "        self.G.add(BatchNormalization(momentum = 0.7))\n",
    "        self.G.add(Activation('relu'))\n",
    "        self.G.add(UpSampling2D())\n",
    "        \n",
    "        #128x128x16\n",
    "        self.G.add(Conv2D(filters = 8, kernel_size = 3, padding = 'same'))\n",
    "        self.G.add(Activation('relu'))\n",
    "        self.G.add(UpSampling2D())\n",
    "        \n",
    "        #256x256x8\n",
    "        self.G.add(Conv2D(filters = 3, kernel_size = 3, padding = 'same'))\n",
    "        self.G.add(Activation('sigmoid'))\n",
    "        \n",
    "        return self.G\n",
    "    \n",
    "    def DisModel(self):\n",
    "        \n",
    "        if self.DM == None:\n",
    "            self.DM = Sequential()\n",
    "            self.DM.add(self.discriminator())\n",
    "        \n",
    "        self.DM.compile(optimizer = Adam(lr = self.LR * (0.85 ** floor(self.steps / 10000))), loss = 'binary_crossentropy')\n",
    "        \n",
    "        return self.DM\n",
    "    \n",
    "    def AdModel(self):\n",
    "        \n",
    "        if self.AM == None:\n",
    "            self.AM = Sequential()\n",
    "            self.AM.add(self.generator())\n",
    "            self.AM.add(self.discriminator())\n",
    "            \n",
    "        self.AM.compile(optimizer = Adam(lr = self.LR * (0.85 ** floor(self.steps / 10000))), loss = 'binary_crossentropy')\n",
    "        \n",
    "        return self.AM\n",
    "    \n",
    "    def sod(self):\n",
    "        \n",
    "        self.OD = self.D.get_weights()\n",
    "        \n",
    "    def lod(self):\n",
    "        \n",
    "        self.D.set_weights(self.OD)\n",
    "\n",
    "\n",
    "\n",
    "class Model_GAN(object):\n",
    "    \n",
    "    def __init__(self):\n",
    "        \n",
    "        self.GAN = GAN()\n",
    "        self.DisModel = self.GAN.DisModel()\n",
    "        self.AdModel = self.GAN.AdModel()\n",
    "        self.generator = self.GAN.generator()\n",
    "        \n",
    "    def train(self, batch = 16):\n",
    "        \n",
    "        (a, b) = self.train_dis(batch)\n",
    "        c = self.train_gen(batch)\n",
    "        \n",
    "        print(f\"D Real: {str(a)}, D Fake: {str(b)}, G All: {str(c)}\")\n",
    "        \n",
    "        if self.GAN.steps % 500 == 0:\n",
    "            self.save(floor(self.GAN.steps / 1000))\n",
    "            self.evaluate()\n",
    "            \n",
    "        if self.GAN.steps % 5000 == 0:\n",
    "            self.GAN.AM = None\n",
    "            self.GAN.DM = None\n",
    "            self.AdModel = self.GAN.AdModel()\n",
    "            self.DisModel = self.GAN.DisModel()\n",
    "        \n",
    "        self.GAN.steps = self.GAN.steps + 1\n",
    "        \n",
    "    def train_dis(self, batch):\n",
    "        \n",
    "        #Get Real Images\n",
    "        im_no = random.randint(0, len(Images) - batch - 1)\n",
    "        train_data = Images[im_no : im_no + int(batch / 2)]\n",
    "        label_data = []\n",
    "        for i in range(int(batch / 2)):\n",
    "            #label_data.append(one())\n",
    "            label_data.append(zero())\n",
    "            \n",
    "        d_loss_real = self.DisModel.train_on_batch(np.array(train_data), np.array(label_data))\n",
    "        \n",
    "        #Get Fake Images\n",
    "        train_data = self.generator.predict(noise(int(batch / 2)))\n",
    "        label_data = []\n",
    "        for i in range(int(batch / 2)):\n",
    "            #label_data.append(zero())\n",
    "            label_data.append(one())\n",
    "            \n",
    "        d_loss_fake = self.DisModel.train_on_batch(train_data, np.array(label_data))\n",
    "        \n",
    "        return (d_loss_real, d_loss_fake)\n",
    "        \n",
    "    def train_gen(self, batch):\n",
    "        \n",
    "        self.GAN.sod()\n",
    "        \n",
    "        label_data = []\n",
    "        for i in range(int(batch)):\n",
    "            #label_data.append(one())\n",
    "            label_data.append(zero())\n",
    "        \n",
    "        g_loss = self.AdModel.train_on_batch(noise(batch), np.array(label_data))\n",
    "        \n",
    "        self.GAN.lod()\n",
    "        \n",
    "        return g_loss\n",
    "        \n",
    "    def evaluate(self):\n",
    "        \n",
    "        im_no = random.randint(0, len(Images) - 1)\n",
    "        im1 = Images[im_no]\n",
    "        \n",
    "        im2 = self.generator.predict(noise(2))\n",
    "        \n",
    "        plt.figure(1)\n",
    "        plt.imshow(im1)\n",
    "        \n",
    "        plt.figure(2)\n",
    "        plt.imshow(im2[0])\n",
    "        \n",
    "        plt.figure(3)\n",
    "        plt.imshow(im2[1])\n",
    "        \n",
    "        plt.show()\n",
    "        \n",
    "    def save(self, num):\n",
    "        gen_json = self.GAN.G.to_json()\n",
    "        dis_json = self.GAN.D.to_json()\n",
    "\n",
    "        with open(\"Models/gen.json\", \"w+\") as json_file:\n",
    "            json_file.write(gen_json)\n",
    "\n",
    "        with open(\"Models/dis.json\", \"w+\") as json_file:\n",
    "            json_file.write(dis_json)\n",
    "\n",
    "        self.GAN.G.save_weights(\"Models/gen\"+str(num)+\".h5\")\n",
    "        self.GAN.D.save_weights(\"Models/dis\"+str(num)+\".h5\")\n",
    "\n",
    "        print(f\"Model number {str(num)} Saved!\")\n",
    "\n",
    "    def load(self, num):\n",
    "        steps1 = self.GAN.steps\n",
    "        \n",
    "        self.GAN = None\n",
    "        self.GAN = GAN()\n",
    "\n",
    "        #Generator\n",
    "        gen_file = open(\"Models/gen.json\", 'r')\n",
    "        gen_json = gen_file.read()\n",
    "        gen_file.close()\n",
    "        \n",
    "        self.GAN.G = model_from_json(gen_json)\n",
    "        self.GAN.G.load_weights(\"Models/gen\"+str(num)+\".h5\")\n",
    "\n",
    "        #Discriminator\n",
    "        dis_file = open(\"Models/dis.json\", 'r')\n",
    "        dis_json = dis_file.read()\n",
    "        dis_file.close()\n",
    "        \n",
    "        self.GAN.D = model_from_json(dis_json)\n",
    "        self.GAN.D.load_weights(\"Models/dis\"+str(num)+\".h5\")\n",
    "\n",
    "        #Reinitialize\n",
    "        self.generator = self.GAN.generator()\n",
    "        self.DisModel = self.GAN.DisModel()\n",
    "        self.AdModel = self.GAN.AdModel()\n",
    "        \n",
    "        self.GAN.steps = steps1\n",
    "        \n",
    "    def eval2(self, num = 0):\n",
    "        \n",
    "        im2 = self.generator.predict(noise(48))\n",
    "        \n",
    "        r1 = np.concatenate(im2[:8], axis = 1)\n",
    "        r2 = np.concatenate(im2[8:16], axis = 1)\n",
    "        r3 = np.concatenate(im2[16:24], axis = 1)\n",
    "        r4 = np.concatenate(im2[24:32], axis = 1)\n",
    "        r5 = np.concatenate(im2[32:40], axis = 1)\n",
    "        r6 = np.concatenate(im2[40:48], axis = 1)\n",
    "        \n",
    "        c1 = np.concatenate([r1, r2, r3, r4, r5, r6], axis = 0)\n",
    "        \n",
    "        x = Image.fromarray(np.uint8(c1*255))\n",
    "        \n",
    "        x.save(\"Results/i\"+str(num)+\".png\")\n",
    "        \n",
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5703"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.mkdir('Results')\n",
    "os.mkdir('Models')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#if training new model:\n",
    "model = Model_GAN() \n",
    "model.GAN.D.summary()\n",
    "model.GAN.G.summary()\n",
    "\n",
    "print(\"We're off! See you in a while!\")\n",
    "#model.GAN.steps = 165001\n",
    "while(model.GAN.steps < 500000):\n",
    "    \n",
    "    #print(\"\\n\\n\\n\\nRound \" + str(model.GAN.steps) + \":\")\n",
    "    model.train()\n",
    "    if model.GAN.steps % 500 == 0:\n",
    "        print(\"\\nRound: \" + str(model.GAN.steps))\n",
    "    \n",
    "    if model.GAN.steps % 1000 == 0:\n",
    "        print(\"\\n\\n\\n\\nRound \" + str(model.GAN.steps) + \":\")\n",
    "        model.eval2(int(model.GAN.steps / 1000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dWIUCYkGSrDV"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "name": "GAN256 - Amazon clothes.ipynb",
   "provenance": [
    {
     "file_id": "1dVTFdVYoOtNtZNY1uxeE2r_HQ_gbi7pf",
     "timestamp": 1536219257615
    }
   ],
   "toc_visible": true,
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}