Classical autoencoder-mnist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import torch\n",
    "import torchvision\n",
    "from torch.autograd import Variable\n",
    "\n",
    "from architecture import MNIST_autoencoder as mnist\n",
    "from functionalities import filemanager as fm\n",
    "from functionalities import dataloader as dl\n",
    "from functionalities import gpu \n",
    "from functionalities import plot as pl\n",
    "from functionalities import trainer as tr\n",
    "from tqdm import tqdm_notebook as tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pretraining Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "num_epoch = 100\n",
    "batch_size = 128\n",
    "lr_init = 1e-3\n",
    "milestones = [10 * x for x in range(1, 11)]\n",
    "latent_dim_lst = [1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64]\n",
    "number_dev = 0\n",
    "get_model = mnist.mnist_autoencoder\n",
    "modelname = \"mnist_classic_bottleneck\"\n",
    "\n",
    "device = gpu.get_device(number_dev)\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "trainset, testset, classes = dl.load_mnist()\n",
    "trainloader, validloader, testloader = dl.make_dataloaders(trainset, testset, batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tr.train_bottleneck_classic(num_epoch, get_model, modelname, milestones, latent_dim_lst, trainloader,\n",
    "                     validloader, testloader, lr_init=lr_init, device=device, mnist=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot Reconstruction and Difference Images Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "num_img = 100\n",
    "grid_row_size = 10\n",
    "\n",
    "img, label = next(iter(testloader))\n",
    "img = img.view(img.size(0), -1)\n",
    "img = Variable(img).cuda()\n",
    "\n",
    "for i in latent_dim_lst:\n",
    "    print('bottleneck dimension: {}'.format(i))\n",
    "    model = fm.load_model('{}_{}'.format(modelname, i))\n",
    "    output = model(img)\n",
    "\n",
    "    \n",
    "    original = pl.to_img(img.cpu().data, [1, 28, 28]) \n",
    "    pic = pl.to_img(output.cpu().data, [1, 28, 28])\n",
    "\n",
    "    print(\"Original Image:\")\n",
    "    pl.imshow(torchvision.utils.make_grid(original[:num_img].detach(), grid_row_size), filename=\"com_classic_mnist_{}_original\".format(i))\n",
    "    print(\"Reconstructed Image:\")\n",
    "    pl.imshow(torchvision.utils.make_grid(pic[:num_img].detach(), grid_row_size), filename=\"com_classic_mnist_{}_reconstructed\".format(i))\n",
    "    print(\"Difference:\")\n",
    "    diff_img = (original - pic + 1) / 2\n",
    "    pl.imshow(torchvision.utils.make_grid(diff_img[:num_img].detach(), grid_row_size), filename=\"com_classic_mnist_{}_difference\".format(i))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot Recontruction Loss against Bottleneck Size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train, test = fm.load_variable(\"{}_bottleneck\".format(modelname))\n",
    "y = [train, test]\n",
    "x = []\n",
    "for loss in y:\n",
    "    x.append([1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64])\n",
    "\n",
    "pl.plot(latent_dim_lst, y, 'bottleneck size', 'loss', ['train', 'test'], 'Train & Test Reconstruction Loss History', 'loss_l1_bottleneck') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Repeat for classic 1024"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pretraining Setup\n",
    "num_epoch = 100\n",
    "batch_size = 128\n",
    "lr_init = 1e-3\n",
    "milestones = [10 * x for x in range(1, 11)]\n",
    "latent_dim_lst = [1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64]\n",
    "number_dev = 0\n",
    "get_model = mnist.mnist_autoencoder_1024\n",
    "modelname = \"mnist_classic_1024_bottleneck\"\n",
    "\n",
    "device = gpu.get_device(number_dev)\n",
    "print(device)\n",
    "\n",
    "trainset, testset, classes = dl.load_mnist()\n",
    "trainloader, validloader, testloader = dl.make_dataloaders(trainset, testset, batch_size)\n",
    "\n",
    "# Training\n",
    "tr.train_bottleneck_classic(num_epoch, get_model, modelname, milestones, latent_dim_lst, trainloader,\n",
    "                     validloader, testloader, lr_init=lr_init, device=device, mnist=True)\n",
    "\n",
    "# Plot Reconstruction and Difference Images Examples\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "num_img = 100\n",
    "grid_row_size = 10\n",
    "\n",
    "img, label = next(iter(testloader))\n",
    "img = img.view(img.size(0), -1)\n",
    "img = Variable(img).cuda()\n",
    "\n",
    "for i in latent_dim_lst:\n",
    "    print('bottleneck dimension: {}'.format(i))\n",
    "    model = fm.load_model('{}_{}'.format(modelname, i))\n",
    "    output = model(img)\n",
    "\n",
    "    \n",
    "    original = pl.to_img(img.cpu().data, [1, 28, 28]) \n",
    "    pic = pl.to_img(output.cpu().data, [1, 28, 28])\n",
    "\n",
    "    print(\"Original Image:\")\n",
    "    pl.imshow(torchvision.utils.make_grid(original[:num_img].detach(), grid_row_size), filename=\"com_classic_mnist_{}_original\".format(i))\n",
    "    print(\"Reconstructed Image:\")\n",
    "    pl.imshow(torchvision.utils.make_grid(pic[:num_img].detach(), grid_row_size), filename=\"com_classic_mnist_{}_reconstructed\".format(i))\n",
    "    print(\"Difference:\")\n",
    "    diff_img = (original - pic + 1) / 2\n",
    "    pl.imshow(torchvision.utils.make_grid(diff_img[:num_img].detach(), grid_row_size), filename=\"com_classic_mnist_{}_difference\".format(i))\n",
    "    \n",
    "# Plot Recontruction Loss against Bottleneck Size\n",
    "train, test = fm.load_variable(\"{}_bottleneck\".format(modelname))\n",
    "y = [train, test]\n",
    "x = []\n",
    "for loss in y:\n",
    "    x.append([1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64])\n",
    "\n",
    "pl.plot(latent_dim_lst, y, 'bottleneck size', 'loss', ['train', 'test'], 'Train & Test Reconstruction Loss History', 'loss_l1_bottleneck') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Repeat for classic 2048"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pretraining Setup\n",
    "num_epoch = 100\n",
    "batch_size = 128\n",
    "lr_init = 1e-3\n",
    "milestones = [10 * x for x in range(1, 11)]\n",
    "latent_dim_lst = [1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64]\n",
    "number_dev = 0\n",
    "get_model = mnist.mnist_autoencoder_2048\n",
    "modelname = \"mnist_classic_2048_bottleneck\"\n",
    "\n",
    "device = gpu.get_device(number_dev)\n",
    "print(device)\n",
    "\n",
    "trainset, testset, classes = dl.load_mnist()\n",
    "trainloader, validloader, testloader = dl.make_dataloaders(trainset, testset, batch_size)\n",
    "\n",
    "# Training\n",
    "tr.train_bottleneck_classic(num_epoch, get_model, modelname, milestones, latent_dim_lst, trainloader,\n",
    "                     validloader, testloader, lr_init=lr_init, device=device, mnist=True)\n",
    "\n",
    "# Plot Reconstruction and Difference Images Examples\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "num_img = 100\n",
    "grid_row_size = 10\n",
    "\n",
    "img, label = next(iter(testloader))\n",
    "img = img.view(img.size(0), -1)\n",
    "img = Variable(img).cuda()\n",
    "\n",
    "for i in latent_dim_lst:\n",
    "    print('bottleneck dimension: {}'.format(i))\n",
    "    model = fm.load_model('{}_{}'.format(modelname, i))\n",
    "    output = model(img)\n",
    "\n",
    "    \n",
    "    original = pl.to_img(img.cpu().data, [1, 28, 28]) \n",
    "    pic = pl.to_img(output.cpu().data, [1, 28, 28])\n",
    "\n",
    "    print(\"Original Image:\")\n",
    "    pl.imshow(torchvision.utils.make_grid(original[:num_img].detach(), grid_row_size), filename=\"com_classic_mnist_{}_original\".format(i))\n",
    "    print(\"Reconstructed Image:\")\n",
    "    pl.imshow(torchvision.utils.make_grid(pic[:num_img].detach(), grid_row_size), filename=\"com_classic_mnist_{}_reconstructed\".format(i))\n",
    "    print(\"Difference:\")\n",
    "    diff_img = (original - pic + 1) / 2\n",
    "    pl.imshow(torchvision.utils.make_grid(diff_img[:num_img].detach(), grid_row_size), filename=\"com_classic_mnist_{}_difference\".format(i))\n",
    "    \n",
    "# Plot Recontruction Loss against Bottleneck Size\n",
    "train, test = fm.load_variable(\"{}_bottleneck\".format(modelname))\n",
    "y = [train, test]\n",
    "x = []\n",
    "for loss in y:\n",
    "    x.append([1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64])\n",
    "\n",
    "pl.plot(latent_dim_lst, y, 'bottleneck size', 'loss', ['train', 'test'], 'Train & Test Reconstruction Loss History', 'loss_l1_bottleneck') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Repeat for deep classic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pretraining Setup\n",
    "num_epoch = 100\n",
    "batch_size = 128\n",
    "lr_init = 1e-3\n",
    "milestones = [10 * x for x in range(1, 11)]\n",
    "latent_dim_lst = [1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64]\n",
    "number_dev = 0\n",
    "get_model = mnist.mnist_autoencoder_deep_1024\n",
    "modelname = \"mnist_classic_deep_bottleneck\"\n",
    "\n",
    "device = gpu.get_device(number_dev)\n",
    "print(device)\n",
    "\n",
    "trainset, testset, classes = dl.load_mnist()\n",
    "trainloader, validloader, testloader = dl.make_dataloaders(trainset, testset, batch_size)\n",
    "\n",
    "# Training\n",
    "tr.train_bottleneck_classic(num_epoch, get_model, modelname, milestones, latent_dim_lst, trainloader,\n",
    "                     validloader, testloader, lr_init=lr_init, device=device, mnist=True)\n",
    "\n",
    "# Plot Reconstruction and Difference Images Examples\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "num_img = 100\n",
    "grid_row_size = 10\n",
    "\n",
    "img, label = next(iter(testloader))\n",
    "img = img.view(img.size(0), -1)\n",
    "img = Variable(img).cuda()\n",
    "\n",
    "for i in latent_dim_lst:\n",
    "    print('bottleneck dimension: {}'.format(i))\n",
    "    model = fm.load_model('{}_{}'.format(modelname, i))\n",
    "    output = model(img)\n",
    "\n",
    "    \n",
    "    original = pl.to_img(img.cpu().data, [1, 28, 28]) \n",
    "    pic = pl.to_img(output.cpu().data, [1, 28, 28])\n",
    "\n",
    "    print(\"Original Image:\")\n",
    "    pl.imshow(torchvision.utils.make_grid(original[:num_img].detach(), grid_row_size), filename=\"com_classic_mnist_{}_original\".format(i))\n",
    "    print(\"Reconstructed Image:\")\n",
    "    pl.imshow(torchvision.utils.make_grid(pic[:num_img].detach(), grid_row_size), filename=\"com_classic_mnist_{}_reconstructed\".format(i))\n",
    "    print(\"Difference:\")\n",
    "    diff_img = (original - pic + 1) / 2\n",
    "    pl.imshow(torchvision.utils.make_grid(diff_img[:num_img].detach(), grid_row_size), filename=\"com_classic_mnist_{}_difference\".format(i))\n",
    "    \n",
    "# Plot Recontruction Loss against Bottleneck Size\n",
    "train, test = fm.load_variable(\"{}_bottleneck\".format(modelname))\n",
    "y = [train, test]\n",
    "x = []\n",
    "for loss in y:\n",
    "    x.append([1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64])\n",
    "\n",
    "pl.plot(latent_dim_lst, y, 'bottleneck size', 'loss', ['train', 'test'], 'Train & Test Reconstruction Loss History', 'loss_l1_bottleneck') "
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}