learn_pytorch_40_pytorch实战项目之卷积自编码器基于MNIST数据集.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1 什么是卷积自编码器 ？\n",
    "卷积自编码器和全连接自编码器的区别在于，卷积自编码器的encoder和decoder都使用的是卷积神经网络，在encoder部分使用卷积核、池化操作，在decoder部分使用反卷积和反池化操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2 使用卷积自编码器生成MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms\n",
    "from torch.utils.data import DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image batch dimensions: torch.Size([128, 1, 28, 28])\n",
      "Image label dimensions: torch.Size([128])\n"
     ]
    }
   ],
   "source": [
    "# Hyperparameters\n",
    "random_seed = 456\n",
    "learning_rate = 0.005\n",
    "num_epochs = 10\n",
    "batch_size = 128\n",
    "\n",
    "\n",
    "##########################\n",
    "### MNIST DATASET\n",
    "##########################\n",
    "\n",
    "# Note transforms.ToTensor() scales input images\n",
    "# to 0-1 range\n",
    "train_dataset = datasets.MNIST(root='data', \n",
    "                               train=True, \n",
    "                               transform=transforms.ToTensor(),\n",
    "                               download=True)\n",
    "\n",
    "test_dataset = datasets.MNIST(root='data', \n",
    "                              train=False, \n",
    "                              transform=transforms.ToTensor())\n",
    "\n",
    "\n",
    "train_loader = DataLoader(dataset=train_dataset, \n",
    "                          batch_size=batch_size, \n",
    "                          shuffle=True)\n",
    "\n",
    "test_loader = DataLoader(dataset=test_dataset, \n",
    "                         batch_size=batch_size, \n",
    "                         shuffle=False)\n",
    "\n",
    "# Checking the dataset\n",
    "for images, labels in train_loader:  \n",
    "    print('Image batch dimensions:', images.shape)\n",
    "    print('Image label dimensions:', labels.shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvolutionalAutoencoder(torch.nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "        super(ConvolutionalAutoencoder, self).__init__()\n",
    "        \n",
    "        # calculate same padding:\n",
    "        # (w - k + 2*p)/s + 1 = o\n",
    "        # => p = (s(o-1) - w + k)/2\n",
    "        \n",
    "        ### ENCODER\n",
    "        \n",
    "        # 28x28x1 => 28x28x4\n",
    "        self.conv_1 = torch.nn.Conv2d(in_channels=1,\n",
    "                                      out_channels=4,\n",
    "                                      kernel_size=(3, 3),\n",
    "                                      stride=(1, 1),\n",
    "                                      # (1(28-1) - 28 + 3) / 2 = 1\n",
    "                                      padding=1) \n",
    "        # 28x28x4 => 14x14x4                              \n",
    "        self.pool_1 = torch.nn.MaxPool2d(kernel_size=(2, 2),\n",
    "                                         stride=(2, 2),\n",
    "                                         # (2(14-1) - 28 + 2) / 2 = 0\n",
    "                                         padding=0)                                       \n",
    "        # 14x14x4 => 14x14x8\n",
    "        self.conv_2 = torch.nn.Conv2d(in_channels=4,\n",
    "                                      out_channels=8,\n",
    "                                      kernel_size=(3, 3),\n",
    "                                      stride=(1, 1),\n",
    "                                      # (1(14-1) - 14 + 3) / 2 = 1\n",
    "                                      padding=1)                 \n",
    "        # 14x14x8 => 7x7x8                             \n",
    "        self.pool_2 = torch.nn.MaxPool2d(kernel_size=(2, 2),\n",
    "                                         stride=(2, 2),\n",
    "                                         # (2(7-1) - 14 + 2) / 2 = 0\n",
    "                                         padding=0)\n",
    "        \n",
    "        ### DECODER\n",
    "                                         \n",
    "        # 7x7x8 => 15x15x4                          \n",
    "        self.deconv_1 = torch.nn.ConvTranspose2d(in_channels=8,\n",
    "                                                 out_channels=4,\n",
    "                                                 kernel_size=(3, 3),\n",
    "                                                 stride=(2, 2),\n",
    "                                                 padding=0)\n",
    "        \n",
    "        # 15x15x4  => 31x31x1                           \n",
    "        self.deconv_2 = torch.nn.ConvTranspose2d(in_channels=4,\n",
    "                                                 out_channels=1,\n",
    "                                                 kernel_size=(3, 3),\n",
    "                                                 stride=(2, 2),\n",
    "                                                 padding=0)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        \n",
    "        ### ENCODER\n",
    "        x = self.conv_1(x)\n",
    "        x = F.leaky_relu(x)\n",
    "        x = self.pool_1(x)\n",
    "        x = self.conv_2(x)\n",
    "        x = F.leaky_relu(x)\n",
    "        x = self.pool_2(x)\n",
    "        \n",
    "        ### DECODER\n",
    "        x = self.deconv_1(x)\n",
    "        x = F.leaky_relu(x)\n",
    "        x = self.deconv_2(x)\n",
    "        x = F.leaky_relu(x)\n",
    "        logits = x[:, :, 2:30, 2:30]\n",
    "        probas = torch.sigmoid(logits)\n",
    "        return logits, probas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "torch.manual_seed(random_seed)\n",
    "model = ConvolutionalAutoencoder()\n",
    "model = model.to(device)\n",
    "\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 001/010 | Batch 000/468 | Cost: 0.7191\n",
      "Epoch: 001/010 | Batch 050/468 | Cost: 0.6911\n",
      "Epoch: 001/010 | Batch 100/468 | Cost: 0.5994\n",
      "Epoch: 001/010 | Batch 150/468 | Cost: 0.3594\n",
      "Epoch: 001/010 | Batch 200/468 | Cost: 0.3035\n",
      "Epoch: 001/010 | Batch 250/468 | Cost: 0.2480\n",
      "Epoch: 001/010 | Batch 300/468 | Cost: 0.2085\n",
      "Epoch: 001/010 | Batch 350/468 | Cost: 0.1780\n",
      "Epoch: 001/010 | Batch 400/468 | Cost: 0.1589\n",
      "Epoch: 001/010 | Batch 450/468 | Cost: 0.1533\n",
      "Time elapsed: 0.68 min\n",
      "Epoch: 002/010 | Batch 000/468 | Cost: 0.1445\n",
      "Epoch: 002/010 | Batch 050/468 | Cost: 0.1367\n",
      "Epoch: 002/010 | Batch 100/468 | Cost: 0.1362\n",
      "Epoch: 002/010 | Batch 150/468 | Cost: 0.1290\n",
      "Epoch: 002/010 | Batch 200/468 | Cost: 0.1288\n",
      "Epoch: 002/010 | Batch 250/468 | Cost: 0.1242\n",
      "Epoch: 002/010 | Batch 300/468 | Cost: 0.1227\n",
      "Epoch: 002/010 | Batch 350/468 | Cost: 0.1238\n",
      "Epoch: 002/010 | Batch 400/468 | Cost: 0.1238\n",
      "Epoch: 002/010 | Batch 450/468 | Cost: 0.1193\n",
      "Time elapsed: 1.40 min\n",
      "Epoch: 003/010 | Batch 000/468 | Cost: 0.1194\n",
      "Epoch: 003/010 | Batch 050/468 | Cost: 0.1197\n",
      "Epoch: 003/010 | Batch 100/468 | Cost: 0.1214\n",
      "Epoch: 003/010 | Batch 150/468 | Cost: 0.1165\n",
      "Epoch: 003/010 | Batch 200/468 | Cost: 0.1114\n",
      "Epoch: 003/010 | Batch 250/468 | Cost: 0.1143\n",
      "Epoch: 003/010 | Batch 300/468 | Cost: 0.1092\n",
      "Epoch: 003/010 | Batch 350/468 | Cost: 0.1163\n",
      "Epoch: 003/010 | Batch 400/468 | Cost: 0.1143\n",
      "Epoch: 003/010 | Batch 450/468 | Cost: 0.1071\n",
      "Time elapsed: 2.11 min\n",
      "Epoch: 004/010 | Batch 000/468 | Cost: 0.1119\n",
      "Epoch: 004/010 | Batch 050/468 | Cost: 0.1131\n",
      "Epoch: 004/010 | Batch 100/468 | Cost: 0.1043\n",
      "Epoch: 004/010 | Batch 150/468 | Cost: 0.1100\n",
      "Epoch: 004/010 | Batch 200/468 | Cost: 0.1104\n",
      "Epoch: 004/010 | Batch 250/468 | Cost: 0.1097\n",
      "Epoch: 004/010 | Batch 300/468 | Cost: 0.1105\n",
      "Epoch: 004/010 | Batch 350/468 | Cost: 0.1087\n",
      "Epoch: 004/010 | Batch 400/468 | Cost: 0.1040\n",
      "Epoch: 004/010 | Batch 450/468 | Cost: 0.1097\n",
      "Time elapsed: 2.84 min\n",
      "Epoch: 005/010 | Batch 000/468 | Cost: 0.1045\n",
      "Epoch: 005/010 | Batch 050/468 | Cost: 0.1030\n",
      "Epoch: 005/010 | Batch 100/468 | Cost: 0.1028\n",
      "Epoch: 005/010 | Batch 150/468 | Cost: 0.1062\n",
      "Epoch: 005/010 | Batch 200/468 | Cost: 0.1056\n",
      "Epoch: 005/010 | Batch 250/468 | Cost: 0.1046\n",
      "Epoch: 005/010 | Batch 300/468 | Cost: 0.1074\n",
      "Epoch: 005/010 | Batch 350/468 | Cost: 0.1063\n",
      "Epoch: 005/010 | Batch 400/468 | Cost: 0.1027\n",
      "Epoch: 005/010 | Batch 450/468 | Cost: 0.1074\n",
      "Time elapsed: 3.56 min\n",
      "Epoch: 006/010 | Batch 000/468 | Cost: 0.1051\n",
      "Epoch: 006/010 | Batch 050/468 | Cost: 0.0981\n",
      "Epoch: 006/010 | Batch 100/468 | Cost: 0.1032\n",
      "Epoch: 006/010 | Batch 150/468 | Cost: 0.1062\n",
      "Epoch: 006/010 | Batch 200/468 | Cost: 0.1046\n",
      "Epoch: 006/010 | Batch 250/468 | Cost: 0.1015\n",
      "Epoch: 006/010 | Batch 300/468 | Cost: 0.0993\n",
      "Epoch: 006/010 | Batch 350/468 | Cost: 0.1011\n",
      "Epoch: 006/010 | Batch 400/468 | Cost: 0.1020\n",
      "Epoch: 006/010 | Batch 450/468 | Cost: 0.1044\n",
      "Time elapsed: 4.29 min\n",
      "Epoch: 007/010 | Batch 000/468 | Cost: 0.0979\n",
      "Epoch: 007/010 | Batch 050/468 | Cost: 0.0978\n",
      "Epoch: 007/010 | Batch 100/468 | Cost: 0.1003\n",
      "Epoch: 007/010 | Batch 150/468 | Cost: 0.1019\n",
      "Epoch: 007/010 | Batch 200/468 | Cost: 0.1006\n",
      "Epoch: 007/010 | Batch 250/468 | Cost: 0.0941\n",
      "Epoch: 007/010 | Batch 300/468 | Cost: 0.0966\n",
      "Epoch: 007/010 | Batch 350/468 | Cost: 0.1012\n",
      "Epoch: 007/010 | Batch 400/468 | Cost: 0.0987\n",
      "Epoch: 007/010 | Batch 450/468 | Cost: 0.0987\n",
      "Time elapsed: 5.00 min\n",
      "Epoch: 008/010 | Batch 000/468 | Cost: 0.1012\n",
      "Epoch: 008/010 | Batch 050/468 | Cost: 0.0991\n",
      "Epoch: 008/010 | Batch 100/468 | Cost: 0.0986\n",
      "Epoch: 008/010 | Batch 150/468 | Cost: 0.0972\n",
      "Epoch: 008/010 | Batch 200/468 | Cost: 0.0983\n",
      "Epoch: 008/010 | Batch 250/468 | Cost: 0.0954\n",
      "Epoch: 008/010 | Batch 300/468 | Cost: 0.0953\n",
      "Epoch: 008/010 | Batch 350/468 | Cost: 0.0922\n",
      "Epoch: 008/010 | Batch 400/468 | Cost: 0.0979\n",
      "Epoch: 008/010 | Batch 450/468 | Cost: 0.0967\n",
      "Time elapsed: 5.72 min\n",
      "Epoch: 009/010 | Batch 000/468 | Cost: 0.0980\n",
      "Epoch: 009/010 | Batch 050/468 | Cost: 0.0950\n",
      "Epoch: 009/010 | Batch 100/468 | Cost: 0.0997\n",
      "Epoch: 009/010 | Batch 150/468 | Cost: 0.0971\n",
      "Epoch: 009/010 | Batch 200/468 | Cost: 0.0967\n",
      "Epoch: 009/010 | Batch 250/468 | Cost: 0.0959\n",
      "Epoch: 009/010 | Batch 300/468 | Cost: 0.0939\n",
      "Epoch: 009/010 | Batch 350/468 | Cost: 0.0974\n",
      "Epoch: 009/010 | Batch 400/468 | Cost: 0.0971\n",
      "Epoch: 009/010 | Batch 450/468 | Cost: 0.0970\n",
      "Time elapsed: 6.43 min\n",
      "Epoch: 010/010 | Batch 000/468 | Cost: 0.0966\n",
      "Epoch: 010/010 | Batch 050/468 | Cost: 0.0962\n",
      "Epoch: 010/010 | Batch 100/468 | Cost: 0.0965\n",
      "Epoch: 010/010 | Batch 150/468 | Cost: 0.0942\n",
      "Epoch: 010/010 | Batch 200/468 | Cost: 0.0972\n",
      "Epoch: 010/010 | Batch 250/468 | Cost: 0.0953\n",
      "Epoch: 010/010 | Batch 300/468 | Cost: 0.0994\n",
      "Epoch: 010/010 | Batch 350/468 | Cost: 0.0901\n",
      "Epoch: 010/010 | Batch 400/468 | Cost: 0.0958\n",
      "Epoch: 010/010 | Batch 450/468 | Cost: 0.0948\n",
      "Time elapsed: 7.15 min\n",
      "Total Training Time: 7.15 min\n"
     ]
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "for epoch in range(num_epochs):\n",
    "    for batch_idx, (features, targets) in enumerate(train_loader):\n",
    "        \n",
    "        # don't need labels, only the images (features)\n",
    "        features = features.to(device)\n",
    "\n",
    "        ### FORWARD AND BACK PROP\n",
    "        logits, decoded = model(features)\n",
    "        cost = F.binary_cross_entropy_with_logits(logits, features)\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        cost.backward()\n",
    "        \n",
    "        ### UPDATE MODEL PARAMETERS\n",
    "        optimizer.step()\n",
    "        \n",
    "        ### LOGGING\n",
    "        if not batch_idx % 50:\n",
    "            print ('Epoch: %03d/%03d | Batch %03d/%03d | Cost: %.4f' \n",
    "                   %(epoch+1, num_epochs, batch_idx, \n",
    "                     len(train_dataset)//batch_size, cost))\n",
    "            \n",
    "    print('Time elapsed: %.2f min' % ((time.time() - start_time)/60))\n",
    "    \n",
    "print('Total Training Time: %.2f min' % ((time.time() - start_time)/60))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x180 with 30 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "##########################\n",
    "### VISUALIZATION\n",
    "##########################\n",
    "\n",
    "n_images = 15\n",
    "image_width = 28\n",
    "\n",
    "fig, axes = plt.subplots(nrows=2, ncols=n_images, \n",
    "                         sharex=True, sharey=True, figsize=(20, 2.5))\n",
    "orig_images = features[:n_images]\n",
    "decoded_images = decoded[:n_images]\n",
    "\n",
    "for i in range(n_images):\n",
    "    for ax, img in zip(axes, [orig_images, decoded_images]):\n",
    "        curr_img = img[i].detach().to(torch.device('cpu'))\n",
    "        ax[i].imshow(curr_img.view((image_width, image_width)), cmap='binary')"
   ]
  },
  {
   "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
}