3.卷积神经网络及图片处理.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([20, 33, 51, 202])\n"
     ]
    }
   ],
   "source": [
    "# 卷积神经网络最初用来处理图片信息，后来扩展到处理文本等其他领域\n",
    "# 卷积神经网络两个主要操作：卷积和池化，前者过滤得到合理的扫描图，后者扫描子图并计算子图的过滤值。\n",
    "# 卷积神经网络存在不全（pad）、膨胀（dilate）和步幅（stride）\n",
    "\n",
    "# 不同维度的卷积：torch.nn.Conv1d, torch.nn.Conv2d, torch.nn.Conv3d\n",
    "# 不同维度的转置卷积： torch.nn.ConvTranspose1d, torch.nn.ConvTranspose2d, torch.nn.ConvTranspose3d\n",
    "\n",
    "import torch\n",
    "\n",
    "# 二维卷积的操作\n",
    "input = torch.randn(20,16,100,200)\n",
    "conv = torch.nn.Conv2d(in_channels=16, out_channels=33, kernel_size=(3,3), stride=(2,1), \n",
    "                       padding=(4,2), dilation=(3,1))\n",
    "output = conv(input)\n",
    "# 50*100 二维张量上进行扫描 （ 50(0) +2pad）/2=26, ( 100(0) +2)/1=102\n",
    "# 100*200 二维张量上进行扫描 （ 100(0) +2pad）/2=51, (200(0) +2)/1=202\n",
    "# dilation 空洞卷积， 1表示距离为1，2表示之间差距一个空格，3表示之间差距两个空格\n",
    "print(output.shape)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output: tensor([[[2., 4.]]])\n",
      "input_: tensor([[[0., 2., 0., 4.]]])\n",
      "input__: tensor([[[2., 2., 4., 4.]]])\n"
     ]
    }
   ],
   "source": [
    "# 池化-下采样，反池化-上采样\n",
    "\n",
    "# 不同维度的最大池化：torch.nn.MaxPool1d, torch.nn.MaxPool2d, torch.nn.MaxPool3d\n",
    "# 不同维度的自适应最大池化： torch.nn.AdaptiveMaxPool1d, torch.nn.AdaptiveMaxPool2d, torch.nn.AdaptiveMaxPool3d\n",
    "# 不同维度的平均池化：torch.nn.AvgPool1d, torch.nn.AvgPool2d, torch.nn.AvgPool3d\n",
    "# 不同维度的l池化： torch.nn.LPPool1d, torch.nn.LPPool2d\n",
    "# 不同维度的最大反池化：torch.nn.MaxMUnpool1d, torch.nn.MaxUnpool2d, torch.nn.MaxUnpool3d\n",
    "\n",
    "# 最近邻上采样（维度：1，2，3），线性上采样（维度：linear, bilinear, trilinear）\n",
    "\n",
    "import torch\n",
    "\n",
    "# 一维池化\n",
    "input = torch.tensor([[[1,2,3,4,5]]], dtype=torch.float32)\n",
    "pool = torch.nn.MaxPool1d(kernel_size=2, stride=2, return_indices=True) # 记住位置，方便后续反池化\n",
    "output, indices = pool(input) # 最大池化的最大元素对应的原位置信息\n",
    "print('output:', output)\n",
    "# max([1,2])=2, max([3,4])=4\n",
    "\n",
    "# 一维反池化\n",
    "unpool = torch.nn.MaxUnpool1d(kernel_size=2, stride=2)\n",
    "input_ = unpool(output, indices) # 恢复那些（除最大元素位置外）其他位置元素为0值，没有上采样\n",
    "print('input_:', input_)\n",
    "\n",
    "# 最近邻上采样\n",
    "upsample = torch.nn.Upsample(scale_factor=2, mode='nearest') # 每个元素重复几倍\n",
    "input__ = upsample(output) # 恢复那些（除最大元素位置外）其他位置元素为，最近最大元素值\n",
    "print('input__:', input__)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0., 0., 0., 0., 0.],\n",
      "        [0., 1., 2., 3., 0.],\n",
      "        [0., 4., 5., 6., 0.],\n",
      "        [0., 0., 0., 0., 0.]])\n",
      "tensor([[0., 0., 0., 0., 0.],\n",
      "        [0., 1., 2., 3., 0.],\n",
      "        [0., 4., 5., 6., 0.],\n",
      "        [0., 0., 0., 0., 0.]])\n",
      "tensor([[3., 2., 1., 2., 3., 2., 1.],\n",
      "        [6., 5., 4., 5., 6., 5., 4.]])\n"
     ]
    }
   ],
   "source": [
    "# 补全pad\n",
    "# 常数补全：torch.nn.ConstantPad2d, torch.nn.ZeroPad2d （指定数字）\n",
    "# 重复补全：torch.nn.ReplicationPad2d （最后一个元素复制）\n",
    "# 反射补全：torch.nn.RelectionPad2d, torch.nn.ReflectionPad3d (从最后一个元素开始逆向填充，对称)\n",
    "\n",
    "import torch\n",
    "\n",
    "input = torch.tensor([[1,2,3], [4,5,6]], dtype=torch.float32)\n",
    "print(torch.nn.ConstantPad2d(padding=[1,1,1,1], value=0)(input))\n",
    "print(torch.nn.ZeroPad2d(padding=[1,1,1,1])(input))\n",
    "print(torch.nn.ReflectionPad2d(padding=[2,2])(input))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_loader: 600\n",
      "test_loader: 100\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第0次迭代第0批次下：训练损失为2.3026509284973145，测试准确率为0.1128\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "600it [15:01,  1.50s/it]\n",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第1次迭代第0批次下：训练损失为2.331150531768799，测试准确率为0.098\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "600it [15:14,  1.52s/it]\n",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第2次迭代第0批次下：训练损失为2.331150531768799，测试准确率为0.098\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "600it [15:13,  1.52s/it]\n",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第3次迭代第0批次下：训练损失为2.331150531768799，测试准确率为0.098\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "600it [15:10,  1.52s/it]\n",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第4次迭代第0批次下：训练损失为2.331150531768799，测试准确率为0.098\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "600it [15:32,  1.55s/it]\n",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第5次迭代第0批次下：训练损失为2.331150531768799，测试准确率为0.098\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "600it [15:13,  1.52s/it]\n",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第6次迭代第0批次下：训练损失为2.331150531768799，测试准确率为0.098\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "600it [15:11,  1.52s/it]\n",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第7次迭代第0批次下：训练损失为2.331150531768799，测试准确率为0.098\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "600it [15:21,  1.54s/it]\n",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第8次迭代第0批次下：训练损失为2.331150531768799，测试准确率为0.098\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "600it [15:39,  1.57s/it]\n",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第9次迭代第0批次下：训练损失为2.331150531768799，测试准确率为0.098\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "600it [15:37,  1.56s/it]\n"
     ]
    }
   ],
   "source": [
    "# 基于卷积神经网络的图片分类\n",
    "# 采用MNIST数据集(28*28像素)\n",
    "\n",
    "from tqdm import tqdm\n",
    "import torch\n",
    "import torchvision.datasets\n",
    "import torchvision.transforms\n",
    "\n",
    "# model\n",
    "class Net(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.conv = torch.nn.Sequential(\n",
    "            torch.nn.Conv2d(1, 64, kernel_size=3, padding=1),\n",
    "            torch.nn.ReLU(),\n",
    "            torch.nn.Conv2d(64, 128, kernel_size=3, padding=1),\n",
    "            torch.nn.ReLU(),\n",
    "            torch.nn.MaxPool2d(stride=2, kernel_size=2))\n",
    "        self.dense = torch.nn.Sequential(\n",
    "            torch.nn.Linear(128*14*14, 1024),\n",
    "            torch.nn.ReLU(),\n",
    "            torch.nn.Dropout(p=0.5),\n",
    "            torch.nn.Linear(1024,10),\n",
    "            torch.nn.Softmax(-1))\n",
    "    def forward(self, x):\n",
    "        x1 = self.conv(x)\n",
    "        x2 = x1.view(-1, 128*14*14)\n",
    "        return self.dense(x2)\n",
    "\n",
    "# data\n",
    "train_data = torchvision.datasets.MNIST('./data/mnist', train=True, transform=torchvision.transforms.ToTensor(),\n",
    "                                       download=True)\n",
    "test_data = torchvision.datasets.MNIST('./data/mnist', train=False, transform=torchvision.transforms.ToTensor(),\n",
    "                                      download=True)\n",
    "batch_size = 100\n",
    "train_loader = torch.utils.data.DataLoader(dataset=train_data, batch_size=batch_size)\n",
    "test_loader = torch.utils.data.DataLoader(dataset=test_data, batch_size=batch_size)\n",
    "print('train_loader:', len(train_loader))\n",
    "print('test_loader:', len(test_loader))\n",
    "\n",
    "net = Net()\n",
    "\n",
    "criterion = torch.nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(net.parameters(), lr=0.01)\n",
    "\n",
    "for step in range(10):\n",
    "    for idx, (images, labels) in tqdm(enumerate(train_loader)):\n",
    "        optimizer.zero_grad()\n",
    "        output = net(images)\n",
    "        loss = criterion(output, labels)\n",
    "        if idx==0:\n",
    "            correct, total = 0, 0\n",
    "            for images_, labels_ in test_loader:\n",
    "                output_ = net(images_)\n",
    "                output__ = torch.argmax(output_, 1)\n",
    "                total += labels_.size(0)\n",
    "                correct += (output__==labels_).sum().item()\n",
    "            print('第{}次迭代第{}批次下：训练损失为{}，测试准确率为{}'.format(step, idx, loss.item(), correct/total))\n",
    "        loss.backward()\n",
    "        optimizer.step()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f793083eba8>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 读取图片\n",
    "\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "panda = np.array(Image.open('./data/fake_images/0.png').resize((224, 224)))\n",
    "panda_tensor = torch.from_numpy(panda)\n",
    "plt.imshow(panda)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading: \"https://download.pytorch.org/models/vgg16-397923af.pth\" to /Users/fubin/.cache/torch/hub/checkpoints/vgg16-397923af.pth\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "71e0832e72654841985ea99bc4ffee76",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0.00/528M [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 利用register_forward_hook来可视化中间层\n",
    "\n",
    "from torchvision import models, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "import torch\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from torchvision.datasets import ImageFolder\n",
    "\n",
    "# image = Image.open('./data/fake_images/0.png').resize((224, 224))\n",
    "# image = np.array(Image.open('./data/fake_images/0.png').resize((224, 224)))\n",
    "# image_tensor = torch.from_numpy(image)\n",
    "\n",
    "simple_transform = transforms.Compose([transforms.Resize((224, 224)),\n",
    "                                       transforms.ToTensor(),\n",
    "                                       transforms.Normalize([0.485, 0.456, 0.406],\n",
    "                                                            [0.229, 0.224, 0.225])])\n",
    "data = ImageFolder(\"./data/fake_images/\", simple_transform)\n",
    "\n",
    "train = DataLoader(data, batch_size=1,  shuffle=False, num_workers=5)\n",
    "\n",
    "vggmodel = models.vgg16(pretrained=True)\n",
    "\n",
    "class LayerActivations():\n",
    "    features = None\n",
    "    def __init__(self, model, layer_num):\n",
    "        self.hook = model[layer_num].register_forward_hook(self.hook_fn)\n",
    "    def hook_fn(self, module, input, output):\n",
    "        self.features = output.cpu()\n",
    "    def remove(self):\n",
    "        self.hook.remove()\n",
    "\n",
    "# 可视化第0层\n",
    "convout = LayerActivations(vggmodel.features, 0)\n",
    "# out = vggmodel(torch.autograd.Variable(image_tensor))\n",
    "img = next(iter(train))\n",
    "out = vggmodel(torch.autograd.Variable(img))\n",
    "\n",
    "convout.remove()\n",
    "features = convout.features\n",
    "\n",
    "ig = plt.figure(figsize=(20, 50))\n",
    "fig.subplots_adjust(left=0, right=1, bottom=0, top=0.8, hspace=0, wspace=0.2)\n",
    "for i in range(5):\n",
    "    ax = fig.add_subplot(12, 5, i+1, xticks=[], yticks=[])\n",
    "    ax.imshow(out[0][i].detach().numpy(), cmap=\"gray\")\n",
    "    \n",
    "plt.show()"
   ]
  },
  {
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}