Chap 7-CNN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8a189668",
   "metadata": {},
   "source": [
    "# 합성곱 신경망(Convolutional Neural Network, CNN)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4a9c604",
   "metadata": {},
   "source": [
    "- 완전연결: 인접하는 계층의 모든 뉴런과 결합됨\n",
    "<br><br>\n",
    "<완전 계층의 문제점>\n",
    "    - 데이터의 형상이 무시됨.\n",
    "    - 모든 입력 데이터를 동등한 뉴런(같은 차원의 뉴런)으로 취급하여 형상에 담긴 정보를 살릴 수 없음"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b971dfad",
   "metadata": {},
   "source": [
    "### 용어 정리\n",
    "<b><br><br>\n",
    "- 특징맵: CNN에서 합성곱 계층의 입출력 데이터<br><br>\n",
    "- 단일 곱셈-누산(fused multiplu-add FMA): 입력과 필터에서 대응하는 원소끼리 곱한 후 그 총합을 구함<br><br>\n",
    "- 필터: 커널<br><br>\n",
    "- 합성곱 연산: 필터의 윈도우를 일정 간격으로 이동해가며 입력데이터에 적용<br><br>\n",
    "- 패딩: 입력 데이터 주변을 특정 값(예컨대 0)으로 채움, 출력 크기를 조정할 목적으로 사용<br><br>\n",
    "- 스트라이드: 필터를 적용하는 위치의 간격<br><br>\n",
    "- 풀링: 세로, 가로 방향의 공간을 줄이는 연산<br><br>\n",
    "- im2col: 입력 데이터를 필터링(가중치 계산)하기 좋게 전개하는(펼치는) <br>\n",
    "</b>\n",
    "\n",
    "\n",
    "$$ OH = \\frac{H+2P-FH}{S}+1\\$$\n",
    "\n",
    "$$ OW = \\frac{W+2P-FW}{S}+1\\$$\n",
    "<br><br>필터의 채널 수는 입력 데이터의 채널 수와 같도록 설정해야 함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e955f393",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 1, 28, 28)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### 7.4.1 4차원 배열\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "x = np.random.rand(10,1,28,28)\n",
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "86cf8292",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 28, 28)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4f033933",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 28, 28)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8d8d9878",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(28, 28)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0,0].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2de57fc",
   "metadata": {},
   "source": [
    "### im2col"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c2760998",
   "metadata": {},
   "outputs": [],
   "source": [
    "#input_data: (데이터 수, 채널 수, 높이, 너비)의 4차원 배열로 이뤄진 입력 데이터\n",
    "#filter_h: 필터의 높이\n",
    "#filter_w: 필터의 너비\n",
    "#strid: 스트라이드\n",
    "#pad: 패딩\n",
    "def im2col(input_data, filter_h, filter_w, stride=1, pad=0):\n",
    "    \"\"\"다수의 이미지를 입력받아 2차원 배열로 변환한다(평탄화).\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    input_data : 4차원 배열 형태의 입력 데이터(이미지 수, 채널 수, 높이, 너비)\n",
    "    filter_h : 필터의 높이\n",
    "    filter_w : 필터의 너비\n",
    "    stride : 스트라이드\n",
    "    pad : 패딩\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    col : 2차원 배열\n",
    "    \"\"\"\n",
    "    N, C, H, W = input_data.shape\n",
    "    out_h = (H + 2*pad - filter_h)//stride + 1\n",
    "    out_w = (W + 2*pad - filter_w)//stride + 1\n",
    "\n",
    "    img = np.pad(input_data, [(0,0), (0,0), (pad, pad), (pad, pad)], 'constant')\n",
    "    col = np.zeros((N, C, filter_h, filter_w, out_h, out_w))\n",
    "\n",
    "    for y in range(filter_h):\n",
    "        y_max = y + stride*out_h\n",
    "        for x in range(filter_w):\n",
    "            x_max = x + stride*out_w\n",
    "            col[:, :, y, x, :, :] = img[:, :, y:y_max:stride, x:x_max:stride]\n",
    "\n",
    "    col = col.transpose(0, 4, 5, 1, 2, 3).reshape(N*out_h*out_w, -1)\n",
    "    return col"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0d6335be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(9, 75)\n"
     ]
    }
   ],
   "source": [
    "import sys, os\n",
    "sys.path.append(os.pardir)\n",
    "x1 = np.random.rand(1,3,7,7)#input data\n",
    "col1 = im2col(x1,5,5,stride=1,pad=0)#2차원 행렬로 출력\n",
    "print(col1.shape)#필터 크기와 동일(3x5x5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2c7921e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(90, 75)\n"
     ]
    }
   ],
   "source": [
    "x2 = np.random.rand(10,3,7,7)#데이터 10개, input data\n",
    "col2 = im2col(x2,5,5,stride=1,pad=0)\n",
    "print(col2.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7265dc9c",
   "metadata": {},
   "source": [
    "#### 합성곱 계층"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f93dc6b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Convolution:\n",
    "    def __init__(self,W,b,stride=1,pad=0):\n",
    "        self.W = W#가중치\n",
    "        self.b = b#편향\n",
    "        self.stride = stride#스트라이드\n",
    "        self.pad = pad#패딩\n",
    "    \n",
    "    def forward(self,x):\n",
    "        FN,X,FH,FW = self.W.shape#필터개수,채널,필터높이,필터너비\n",
    "        N,C,H,W = x.shape\n",
    "        out_h = int(1+(H+2*self.pad-FH)/self.stride)#출력높이\n",
    "        out_w = int(1+(W+2*self.pad-FW)/self.stride)#출력너비\n",
    "        \n",
    "        col = im2col(x,FW,FW,self.stride,self.pad)\n",
    "        col_w = self.W.reshape(FN,-1).T#필터 전개; 2차원배열로 전개\n",
    "        out = np.dot(col,col_W)+self.b#행렬 곱\n",
    "        \n",
    "        #축 순서 변경하기\n",
    "        out = out.reshape(N,out_h,out_w,-1).transpose(0,3,1,2)#N,H,W,C -> N,C,H,W\n",
    "        \n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2f2bed8",
   "metadata": {},
   "source": [
    "#### 풀링 계층\n",
    "1. 입력데이터를 전개한다\n",
    "2. 행별 최대값을 구한다\n",
    "3. 적절한 모양으로 성형한다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e7147ded",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pooling:#풀링 계층\n",
    "    def __init__(self,pool_h,pool_w,stride=1,pad=0):\n",
    "        self.pool_h = pool_h#풀링 높이\n",
    "        self.pool_w = pool_w#풀링 너비\n",
    "        self.stride = stride#스트라이드\n",
    "        self.pad = pad#패딩\n",
    "        \n",
    "    def forward(self,x):\n",
    "        N,C,H,W = x.shape#데이터 개수,채널,높이,너비\n",
    "        out_h = int(1+(H-self.pool_h)/self.stride)\n",
    "        out_w = int(1+(W-self.pool_w)/self.stride)\n",
    "        \n",
    "        #1. 전개\n",
    "        col = im2col(x,self.pool_h,self.pool_w,self.stride,self.pad)\n",
    "        col = col.reshape(-1,self.pool_h*self.pool_w)#2차원 행렬\n",
    "        \n",
    "        #2. 최대값\n",
    "        out = np.max(col,axis=1)\n",
    "        \n",
    "        #3. 성형\n",
    "        out = out.reshape(N,out_h,out_w,C).transpose(0,3,1,2)\n",
    "        \n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d1dbfc3c",
   "metadata": {},
   "outputs": [
    {
     "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": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.image import imread\n",
    "from PIL import Image\n",
    "import requests\n",
    "url = \"https://blog.kakaocdn.net/dn/WRuhc/btqQmO95Bbo/qCFeT9DKhHKQhKWkDcu9D1/img.png\"\n",
    "\n",
    "im = Image.open(requests.get(url, stream=True).raw)\n",
    "plt.imshow(im)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de51fabf",
   "metadata": {},
   "source": [
    "### 필요한 함수들"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "0b3c53c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_output_size(input_size, filter_size, stride=1, pad=0):\n",
    "    return (input_size + 2*pad - filter_size) / stride + 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0ab95c0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def relu(x):\n",
    "    return np.maximum(0, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c6bdc481",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Relu:\n",
    "    def __init__(self):\n",
    "        self.mask = None\n",
    "\n",
    "    def forward(self, x):\n",
    "        self.mask = (x <= 0)\n",
    "        out = x.copy()\n",
    "        out[self.mask] = 0\n",
    "\n",
    "        return out\n",
    "\n",
    "    def backward(self, dout):\n",
    "        dout[self.mask] = 0\n",
    "        dx = dout\n",
    "\n",
    "        return dx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2f08d551",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Affine:\n",
    "    def __init__(self, W, b):\n",
    "        self.W = W\n",
    "        self.b = b\n",
    "        \n",
    "        self.x = None\n",
    "        self.original_x_shape = None\n",
    "        # 가중치와 편향 매개변수의 미분\n",
    "        self.dW = None\n",
    "        self.db = None\n",
    "\n",
    "    def forward(self, x):\n",
    "        # 텐서 대응\n",
    "        self.original_x_shape = x.shape\n",
    "        x = x.reshape(x.shape[0], -1)\n",
    "        self.x = x\n",
    "\n",
    "        out = np.dot(self.x, self.W) + self.b\n",
    "\n",
    "        return out\n",
    "\n",
    "    def backward(self, dout):\n",
    "        dx = np.dot(dout, self.W.T)\n",
    "        self.dW = np.dot(self.x.T, dout)\n",
    "        self.db = np.sum(dout, axis=0)\n",
    "        \n",
    "        dx = dx.reshape(*self.original_x_shape)  # 입력 데이터 모양 변경(텐서 대응)\n",
    "        return dx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "8d664b8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SoftmaxWithLoss:\n",
    "    def __init__(self):\n",
    "        self.loss = None # 손실함수\n",
    "        self.y = None    # softmax의 출력\n",
    "        self.t = None    # 정답 레이블(원-핫 인코딩 형태)\n",
    "        \n",
    "    def forward(self, x, t):\n",
    "        self.t = t\n",
    "        self.y = softmax(x)\n",
    "        self.loss = cross_entropy_error(self.y, self.t)\n",
    "        \n",
    "        return self.loss\n",
    "\n",
    "    def backward(self, dout=1):\n",
    "        batch_size = self.t.shape[0]\n",
    "        if self.t.size == self.y.size: # 정답 레이블이 원-핫 인코딩 형태일 때\n",
    "            dx = (self.y - self.t) / batch_size\n",
    "        else:\n",
    "            dx = self.y.copy()\n",
    "            dx[np.arange(batch_size), self.t] -= 1\n",
    "            dx = dx / batch_size\n",
    "        \n",
    "        return dx\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "31e77982",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pooling:\n",
    "    def __init__(self, pool_h, pool_w, stride=1, pad=0):\n",
    "        self.pool_h = pool_h\n",
    "        self.pool_w = pool_w\n",
    "        self.stride = stride\n",
    "        self.pad = pad\n",
    "        \n",
    "        self.x = None\n",
    "        self.arg_max = None\n",
    "\n",
    "    def forward(self, x):\n",
    "        N, C, H, W = x.shape\n",
    "        out_h = int(1 + (H - self.pool_h) / self.stride)\n",
    "        out_w = int(1 + (W - self.pool_w) / self.stride)\n",
    "\n",
    "        col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad)\n",
    "        col = col.reshape(-1, self.pool_h*self.pool_w)\n",
    "\n",
    "        arg_max = np.argmax(col, axis=1)\n",
    "        out = np.max(col, axis=1)\n",
    "        out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2)\n",
    "\n",
    "        self.x = x\n",
    "        self.arg_max = arg_max\n",
    "\n",
    "        return out\n",
    "\n",
    "    def backward(self, dout):\n",
    "        dout = dout.transpose(0, 2, 3, 1)\n",
    "        \n",
    "        pool_size = self.pool_h * self.pool_w\n",
    "        dmax = np.zeros((dout.size, pool_size))\n",
    "        dmax[np.arange(self.arg_max.size), self.arg_max.flatten()] = dout.flatten()\n",
    "        dmax = dmax.reshape(dout.shape + (pool_size,)) \n",
    "        \n",
    "        dcol = dmax.reshape(dmax.shape[0] * dmax.shape[1] * dmax.shape[2], -1)\n",
    "        dx = col2im(dcol, self.x.shape, self.pool_h, self.pool_w, self.stride, self.pad)\n",
    "        \n",
    "        return dx"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b054ca6",
   "metadata": {},
   "source": [
    "$$ input $$\n",
    "$$\\downarrow$$\n",
    "$$conv-relu-pooling$$\n",
    "$$\\downarrow$$\n",
    "$$affine-relu$$\n",
    "$$\\downarrow$$\n",
    "$$affine-softmax$$\n",
    "$$\\downarrow$$\n",
    "$$output$$\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "594f3df5",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class SImpleConvNet:\n",
    "    \n",
    "    def __init__(self,input_dim = (1,28,28),#입력데이터 차원\n",
    "                conv_param = {'filter_num':30,'filter_size':5,\n",
    "                             'pad':0, 'stride':1},#합성곱 계층의 하이퍼 파라미터(딕셔너리 형태)\n",
    "                hidden_size = 100,\n",
    "                output_size = 10,\n",
    "                weight_init_std = 0.01):\n",
    "        filter_num = conv_param['filter_num']#꺼냄\n",
    "        filter_size = conv_param['filter_size']\n",
    "        filter_pad = conv_param['pad']\n",
    "        filter_stride = conv_param['stride']\n",
    "        input_size = input_dim[1]\n",
    "        conv_output_size = (input_size-filter_size+2*filter_pad)/filter_stride+1\n",
    "        pool_output_size = int(filter_num*(conv_output_size/2)*(conv_output_size/2))#풀링 계층 출력 크기\n",
    "    \n",
    "        #가중치 매개변수 초기화\n",
    "        self.params = {}\n",
    "        self.params['W1'] = weight_init_std * np.random.randn(filter_num, input_dim[0],filter_size,filter_size)#매개변수 초기화\n",
    "        self.params['b1'] = np.zeros(filter_num)\n",
    "        self.params['W2'] = weight_init_std * np.random.randn(pool_output_size,hidden_size)\n",
    "        self.params['b2'] = np.zeros(hidden_size)\n",
    "        self.params['W3'] = weight_init_std*np.random.randn(hidden_size,output_size)\n",
    "        self.params['b3'] = np.zeros(output_size)\n",
    "        \n",
    "        #CNN을 구성하는 계층들 생성\n",
    "        self.layers = OrderedDict()\n",
    "        self.layers['Conv1'] = Convolution(self.params['W1'],\n",
    "                                          self.params['b1'],\n",
    "                                          conv_param['stride'],\n",
    "                                          conv_param['pad'])#합성곱계층\n",
    "        self.layers['Relu1'] = Relu()\n",
    "        self.layers['Pool1'] = Pooling(pool_h=2, pool_w=2, stride=2)#풀링계층\n",
    "        self.layers['Affine1'] = Affine(self.params['W2'],self.params['b2'])#완전연결1\n",
    "        self.layers['Relu2'] = Relu()\n",
    "        self.layers['Affine2'] = Affine(self.params['W3'],self.params['b3'])#완전연결2\n",
    "        \n",
    "        self.last_layer = SoftmaxwithLoss()\n",
    "    \n",
    "    def predict(self,x):#추론\n",
    "        for layer in self.layers.values():\n",
    "            x = layer.forward(x)\n",
    "        return x\n",
    "    \n",
    "    def loss(self,x,t):#손실함수의 값\n",
    "        y = self.predict(x)\n",
    "        return self.last_layer.forward(y,t)\n",
    "    \n",
    "    def gradient(self,x,t):#오차역전파법을 통한 기울기 구하기\n",
    "        #순전파\n",
    "        self.loss(x,t)\n",
    "        \n",
    "        #역전파\n",
    "        dout = 1\n",
    "        dout = self.last_layer.backward(dout)\n",
    "        \n",
    "        layers = list(self.layers.values())\n",
    "        layers.reverse()#거꾸로\n",
    "        for layer in layers:\n",
    "            dout = layer.backward(dout)\n",
    "            \n",
    "        #결과 저장\n",
    "        grads = {}\n",
    "        grads['W1'] = self.layers['Conv1'].dW\n",
    "        grads['b1'] = self.layers['Conv1'].db\n",
    "        grads['W2'] = self.layers['Affine1'].dW\n",
    "        grads['b2'] = self.layers['Affine1'].db\n",
    "        grads['W3'] = self.layers['Affine2'].dW\n",
    "        grads['b3'] = self.layers['Affine2'].db\n",
    "        \n",
    "        return grads"
   ]
  }
 ],
 "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}