05_FUN_AI_Docs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GAN\n",
    "\n",
    "## 用語解説\n",
    "\n",
    "GAN Generative Adversarial Network 敵対的生成ネットワーク "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 用語説明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 実装解説\n",
    "今回はDCGANというモデルを実装していく\n",
    "DCGANとは、Deep Convolutional Generatorを用いるGANの一種だ。もう1つの特徴として、活性化関数にLeakyReLUを用いることが挙げられる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ライブラリのインポート\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import (Dataset, DataLoader, TensorDataset)\n",
    "from torchvision.datasets import ImageFolder\n",
    "from torchvision.utils import save_image\n",
    "from torchvision import transforms\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "import tqdm from tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Writer will output to ./runs/ directory by default\n",
    "writer = SummaryWriter('./param/05_3/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_data = ImageFolder(\n",
    "    \"/home/t4t5u0/Documents/2020_fun_ai_docs/dataset/05/img\",\n",
    "    transform=transforms.Compose([\n",
    "        transforms.Resize(80),\n",
    "        transforms.CenterCrop(64),\n",
    "        transforms.ToTensor()  \n",
    "    ])\n",
    ")\n",
    "\n",
    "batch_size = 128\n",
    "img_loader = DataLoader(img_data, \n",
    "                        batch_size=batch_size, \n",
    "                        shuffle=True,\n",
    "                        num_workers=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nz = 100 # 潜在特徴量ベクトルの大きさ\n",
    "ngf =32 # Generator を介して伝播されるfeature map の深度\n",
    "\n",
    "class Geneartor(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Geneartor, self).__init__()\n",
    "        self.main = nn.Sequential(\n",
    "            nn.ConvTranspose2d(nz, ngf*8, 4, 1, 0, bias=False),\n",
    "            nn.BatchNorm2d(ngf*8),\n",
    "           # nn.ReLU(inplace=True),\n",
    "            nn.LeakyReLU(0.01,inplace=True),\n",
    "            \n",
    "            nn.ConvTranspose2d(ngf*8, ngf*4, 4, 2, 1, bias=False),\n",
    "            nn.BatchNorm2d(ngf*4),\n",
    "           # nn.ReLU(inplace=True),\n",
    "            nn.LeakyReLU(0.01,inplace=True),\n",
    "            \n",
    "            nn.ConvTranspose2d(ngf*4, ngf*2, 4, 2, 1, bias=False),\n",
    "            nn.BatchNorm2d(ngf*2),\n",
    "           # nn.ReLU(inplace=True),\n",
    "            nn.LeakyReLU(0.01,inplace=True),\n",
    "            \n",
    "            nn.ConvTranspose2d(ngf*2, ngf, 4, 2, 1, bias=False),\n",
    "            nn.BatchNorm2d(ngf),\n",
    "            # nn.ReLU(inplace=True),\n",
    "            nn.LeakyReLU(0.01,inplace=True),\n",
    "            \n",
    "            nn.ConvTranspose2d(ngf, 3, 4, 2, 1, bias=False),\n",
    "            nn.Tanh()\n",
    "        )\n",
    "    def forward(self, x):\n",
    "        return self.main(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![fig1](./fig/05/dcgan_generator.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ndf = 32\n",
    "\n",
    "class Discremenator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Discremenator, self).__init__()\n",
    "        self.main = nn.Sequential(\n",
    "            nn.Conv2d(3, ndf, 4, 2, 1, bias=False),\n",
    "            nn.LeakyReLU(0.2, inplace=True),\n",
    "            \n",
    "            nn.Conv2d(ndf, ndf*2, 4, 2, 1, bias=False),\n",
    "            nn.BatchNorm2d(ndf*2),\n",
    "            nn.LeakyReLU(0.2, inplace=True),\n",
    "            \n",
    "            nn.Conv2d(ndf*2, ndf*4, 4, 2, 1, bias=False),\n",
    "            nn.BatchNorm2d(ndf*4),\n",
    "            nn.LeakyReLU(0.2, inplace=True),\n",
    "            \n",
    "            nn.Conv2d(ndf*4, ndf*8, 4, 2, 1, bias=False),\n",
    "            nn.BatchNorm2d(ndf*8),\n",
    "            nn.LeakyReLU(0.2, inplace=True),\n",
    "            \n",
    "            nn.Conv2d( ndf*8, 1, 4, 1, 0, bias=False),\n",
    "            #nn.Sigmoid()\n",
    "        )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        out = self.main(x)\n",
    "        return out.squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#訓練関数を作成する\n",
    "d = Discremenator().to('cuda:0')\n",
    "g = Geneartor().to('cuda:0')\n",
    "\n",
    "#Adamのパラメータは原著参考\n",
    "opt_d = optim.Adam(d.parameters(), lr=0.0002, betas=(0.5, 0.999))\n",
    "\n",
    "opt_g = optim.Adam(g.parameters(), lr= 0.0002, betas=(0.5, 0.999))\n",
    "\n",
    "#交差エントロピー誤差を計算するための補助変数\n",
    "ones = torch.ones(batch_size).to('cuda:0')\n",
    "zeros = torch.zeros(batch_size).to('cuda:0')\n",
    "#loss_fnc = nn.BCEWithLogitsLoss()\n",
    "loss_fnc = nn.MSELoss()\n",
    "\n",
    "#モニタリング用の変数 z\n",
    "fixed_z = torch.randn(batch_size, nz, 1, 1).to('cuda:0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from statistics import mean\n",
    "\n",
    "def train_dcgan(g, d, opt_g, opt_d, loader, writer):\n",
    "    # 生成モデル\n",
    "    log_loss_g = []\n",
    "    log_loss_d = []\n",
    "    for real_img, _ in tqdm.tqdm(loader):\n",
    "        batch_len = len(real_img)\n",
    "        \n",
    "        real_img = real_img.to('cuda:0')\n",
    "        \n",
    "        z = torch.randn(batch_len, nz, 1, 1).to('cuda:0')\n",
    "        fake_img = g(z)\n",
    "        \n",
    "        fake_img_tensor = fake_img.detach()\n",
    "        \n",
    "        out = d(fake_img)\n",
    "        loss_g = loss_fnc(out, ones[:batch_len])\n",
    "        log_loss_g.append(loss_g.item())\n",
    "        \n",
    "        # 勾配をクリアしてから微分とパラメータ更新を行う\n",
    "        d.zero_grad()\n",
    "        g.zero_grad()\n",
    "        loss_g.backward()\n",
    "        opt_g.step()\n",
    "        \n",
    "        # 実際の画像に対する識別モデルの評価関数を計算\n",
    "        real_out = d(real_img)\n",
    "        loss_d_real  = loss_fnc(real_out, ones[:batch_len])\n",
    "        \n",
    "        # PyTorchでは同じTensorを含んだ計算グラフに対して\n",
    "        # 2回backwardを行うことができないから保存してあった\n",
    "        # Tensorを使用して無駄な計算を省く\n",
    "        fake_img = fake_img_tensor\n",
    "        \n",
    "        # 偽画像に対する識別モデルの評価関数の計算\n",
    "        fake_out = d(fake_img_tensor)\n",
    "        loss_d_fake = loss_fnc(fake_out, zeros[:batch_len])\n",
    "        \n",
    "        # 真偽の評価関数の合計値\n",
    "        loss_d = loss_d_real + loss_d_fake\n",
    "        log_loss_d.append(loss_d.item())\n",
    "        \n",
    "        # 識別モデルの微分計算とパラメータ更新\n",
    "        d.zero_grad()\n",
    "        g.zero_grad()\n",
    "        loss_d.backward()\n",
    "        opt_d.step()\n",
    "        \n",
    "        if writer is not None:\n",
    "            writer.add_scalars('loss', {\n",
    "                'D':log_loss_d[-1], 'G':log_loss_g[-1]\n",
    "                }, epoch)\n",
    "        \n",
    "    return mean(log_loss_g), mean(log_loss_d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for epoch in range(3000):\n",
    "    train_dcgan(g, d, opt_g, opt_d, img_loader, writer)\n",
    "    \n",
    "    if epoch%10 == 0:\n",
    "        # パラメータの保存\n",
    "        torch.save(\n",
    "            g.state_dict(),\n",
    "            \"./param/05_3/g_{:03d}.prm\".format(epoch),\n",
    "            pickle_protocol = 4\n",
    "        )\n",
    "        torch.save(\n",
    "            d.state_dict(),\n",
    "            \"./param/05_3/d_{:03d}.prm\".format(epoch),\n",
    "            pickle_protocol = 4\n",
    "        )\n",
    "        generated_img = g(fixed_z)\n",
    "        generated_img = g(fixed_z)\n",
    "        save_image(generated_img,\n",
    "                  \"./param/05_3/{:04d}.jpg\".format(epoch)\n",
    "        )\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "演習"
   ]
  }
 ],
 "metadata": {
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}