Ch03.Neural_network.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import sys, os\n",
    "sys.path.append(os.pardir)\n",
    "from inputs.dataset.mnist import load_mnist\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 신경망\n",
    "---\n",
    "## 3.1 퍼셉트론에서 신경망으로\n",
    "신경망은 가장 왼쪽 줄을 **입력층**, 맨 오른쪽 줄을 **출력층**, 중간 줄을 **은닉층** 이라고 한다.  \n",
    "\n",
    "### 3.1.1 신경망의 예\n",
    "만약 3줄의 입력층, 은닉층, 출력층이 있다고 가정할 때, 가중치를 갖는 층은 2개뿐이기 때문에 2층 신경망이라고 한다.  \n",
    "\n",
    "### 3.1.2 퍼셉트론 복습\n",
    "다음 식은 $x_1$과 $x_2$라는 두 신호를 입력받아 $y$를 출력하는 퍼셉트론이다.\n",
    "\n",
    "**[식 3.1]**  \n",
    "$\n",
    "y=\n",
    "\\begin{cases}\n",
    "0 & (b + w_1x_1 + w_2x_2 \\le 0) \\\\\n",
    "1 & (b + w_1x_1 + w_2x_2 > 0)\n",
    "\\end{cases}\n",
    "$\n",
    "\n",
    "여기서 b 는 **편향**을 나타내는 매개변수로, 뉴런이 얼마나 쉽게 활성화되느냐를 제어한다.  \n",
    "한편, $w_1$과 $w_2$는 각 신호의 **가중치**를 나타내는 매개변수로, 각 신호의 영향력을 제어한다.\n",
    "\n",
    "위의 식을 조금 더, 간결하게 작성해보자.  \n",
    "\n",
    "**[식 3.2]**  \n",
    "$\n",
    "y = h(b + w_1x_1 + w_2x_2)\n",
    "$\n",
    "\n",
    "**[식 3.3]**  \n",
    "$\n",
    "h(x) = \n",
    "\\begin{cases}\n",
    "0 & (x \\le 0) \\\\\n",
    "1 & (x > 0)\n",
    "\\end{cases}\n",
    "$\n",
    "\n",
    "입력 신호의 총합이 $h(x)$라는 함수를 거쳐 변환되어, 그 변환된 값이 y의 출력이 됨을 보여준다.  \n",
    "\n",
    "### 3.1.3 활성화 함수의 등장\n",
    "조금 전 $h(x)$라는 함수가 등장했는데, 이처럼 입력 신호의 총합을 출력 신호로 변환하는 함수를 일반적으로 **활성화 함수**<sup>activation function</sup>라 한다.\n",
    "[식 3.2]를 다시 써보면 다음과 같이 2단계로 나눌 수 있다.\n",
    "\n",
    "**[식 3.4]**  \n",
    "$a = b + w_1x_1 + w_2x_2$\n",
    "\n",
    "**[식 3.5]**  \n",
    "$y = h(a)$\n",
    "\n",
    "즉, 가중치 신호를 조합한 결과가 a라는 노드가 되고, 활성화 함수 h()를 통과하여 y라는 노드로 변환되는 과정이다.  \n",
    "뉴런과 노드는 동일한 의미이다.\n",
    "\n",
    "**※ 주의사항**\n",
    "- **단순 퍼셉트론**은 단층 네트워크에서 계단 함수(임계값을 경계로 출력이 바뀌는 함수)를 활성화 함수로 사용한 모델을 의미.\n",
    "- **다층 퍼셉트론**은 신경망(여러 층으로 구성되고 시그모이드 함수 등의 매끈한 활성화 함수를 사용하는 네트워크)을 의미."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 활성화 함수\n",
    "**[식 3.3]** 과 같은 활성화 함수는 임계값을 경계로 출력이 바뀌는데, 이런 함수를 **계단 함수**<sup>step function</sup>라 한다.  \n",
    "그래서 \"퍼셉트론에서는 활성화 함수로 계단 함수를 사용한다.\"라고 할 수 있다.  \n",
    "\n",
    "### 3.2.1 시그모이드 함수\n",
    "다음은 신경망에서 자주 이용하는 활성화 함수인 **시그모이드 함수**<sup>sigmoid function</sup>를 나타낸 식이다.\n",
    "\n",
    "**[식 3.6]**  \n",
    "$\n",
    "\\begin{align}\n",
    "h(x)=\\frac{1}{1+exp(-x)}\n",
    "\\end{align}\n",
    "$\n",
    "\n",
    "[식 3.6]에서 exp(-x)는 $e^{-x}$를 뜻하며, e는 자연상수로 2.7182... 의 값을 갖는 실수다.  \n",
    "앞서 이야기한 퍼셉트론과 신경망의 주된 차이는 이 활성화 함수다.  \n",
    "\n",
    "### 3.2.2 계단 함수 구현하기\n",
    "계단 함수는 [식3.3]과 같이 입력이 0을 넘으면 1을 출력하고, 그 외에는 0을 출력하는 함수이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def step_function(x):\n",
    "    if x > 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 실수만 처리 가능하다.\n",
    "display(step_function(10))\n",
    "\n",
    "# 인자로 넘겨받는 다음 함수는 넘파이 배열을 인수로 넣을 수는 없다. (에러발생)\n",
    "# display(step_function(np.array([1, 5, -10])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def step_function(x):\n",
    "    y = x > 0\n",
    "    return y.astype(np.int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 0])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(step_function(np.array([1, 5, -10])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.3 계단 함수의 그래프"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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": [
    "def step_function(x):\n",
    "    return np.array(x > 0, dtype=np.int)\n",
    "\n",
    "x = np.arange(-5.0, 5.0, 0.1)\n",
    "y = step_function(x)\n",
    "\n",
    "plt.plot(x, y)\n",
    "plt.ylim(-0.1, 1.1)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.4 시그모이드 함수 구현하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    return 1 / (1 + np.exp(-x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.26894142, 0.73105858, 0.88079708])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([-1.0, 1.0, 2.0])\n",
    "sigmoid(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 0.5       , 0.33333333])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 시그모이드 함수 원리\n",
    "# (1 + np.exp(-x)) 는 결국 넘파이 배열을 반환해주고, 이는 브로드 캐스트 기능을 통하여 연산된 넘파이 배열 결과로 반환한다.\n",
    "t = np.array([1.0, 2.0, 3.0])\n",
    "1 / t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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": [
    "x = np.arange(-5.0, 5.0, 0.1)\n",
    "y = sigmoid(x)\n",
    "\n",
    "plt.plot(x, y)\n",
    "plt.ylim(-0.1, 1.1)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 짚고가기\n",
    "시그모이드란 'S자 모양'이라는 뜻이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.5 시그모이드 함수와 계단 함수 비교\n",
    "* 시그모이드 함수  \n",
    "    - 부드러운 곡선 형태\n",
    "    - 출력이 연속적으로 변화\n",
    "    - 실수를 반환함  \n",
    "    \n",
    "    \n",
    "* 계단 함수\n",
    "    - 0 또는 1을 반환\n",
    "    \n",
    "    \n",
    "* 공통점\n",
    "    - 입력이 작을 때는 출력이 0에 가깝다(혹은 0이 되는)\n",
    "    - 입력이 커지면 출력이 1에 가깝다(혹은 1이되는)\n",
    "    - 비선형 함수\n",
    "    \n",
    "    \n",
    "* 차이점\n",
    "    - 매끄러움"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.6 비선형 함수\n",
    "**※ NOTE**  \n",
    "함수란 어떤 값을 입력하면 그에 따른 값을 돌려주는 '변환기'이다. 이 변환기에 무언갈 입력했을 때 출력이 입력의 상수배만큼 변하는 함수를 **선형 함수**라고 한다. 수식으로는 $f(x) = ax + b$이고, 이때 a와 b는 상수이다. 그래서 선형 함수는 곧은 1개의 직선이 된다. **비선형 함수**는 직선 1개로는 그릴 수 없는 함수를 말한다.\n",
    "\n",
    "신경망에서는 활성화 함수로 비선형 함수를 사용해야 한다. 왜냐하면 신경망의 층을 깊게하는 의미가 없기 때문이다.  \n",
    "선형 함수인 $h(x) = cx$를 활성화 함수로 사용한 3층 네트워크를 떠올려보자. 이를 식으로 표현하면 $y = h(h(h(x)))$가 된다.  \n",
    "$y = c * c * c * x$처럼 곱셈을 세 번 수행하지만, 실은 $y(x) = ax$와 같은 식이다. $a = c^3$이라고만 하면 끝이기 때문이다.\n",
    "\n",
    "그러므로, 활성화 함수로는 비선형 함수를 사용한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.7 ReLU 함수\n",
    "시그모이드 함수는 신경망 분야에서 오래전부터 이용해왔으나, 최근에는 **ReLU**<sup>Rectified Linear Unit, 렐루</sup> 함수를 주로 이용한다.  \n",
    "ReLU는 입력이 0을 넘으면 그 입력을 그대로 출력하고, 0 이하이면 0을 출력하는 함수다.\n",
    "\n",
    "**[식 3.7]**  \n",
    "$\n",
    "h(x)=\n",
    "\\begin{cases}\n",
    "x & (x > 0) \\\\\n",
    "0 & (x <=0)\n",
    "\\end{cases}\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def relu(x):\n",
    "    return np.maximum(0, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 다차원 배열의 계산\n",
    "### 3.3.1 다차원 배열"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "A 배열의 차원 1\n",
      "A 배열의 행과 열 (4,)\n",
      "A 배열의 행과 열 중 행의 개수 4\n"
     ]
    }
   ],
   "source": [
    "A = np.array([1, 2, 3, 4])\n",
    "print(A)\n",
    "\n",
    "print(\"A 배열의 차원\", np.ndim(A))\n",
    "print(\"A 배열의 행과 열\", A.shape)\n",
    "print(\"A 배열의 행과 열 중 행의 개수\", A.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "B 배열의 차원 2\n",
      "B 배열의 행과 열 (3, 2)\n",
      "B 배열의 행과 열 중 행의 개수 3\n"
     ]
    }
   ],
   "source": [
    "B = np.array([[1,2], [3,4], [5,6]])\n",
    "print(B)\n",
    "\n",
    "print(\"B 배열의 차원\", np.ndim(B))\n",
    "print(\"B 배열의 행과 열\", B.shape)\n",
    "print(\"B 배열의 행과 열 중 행의 개수\", B.shape[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.2 행렬의 곱"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[19, 22],\n",
       "       [43, 50]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1, 2], [3, 4]])\n",
    "B = np.array([[5, 6], [7, 8]])\n",
    "\n",
    "np.dot(A, B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[22, 28],\n",
       "       [49, 64]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "B = np.array([[1, 2], [3, 4], [5, 6]])\n",
    "\n",
    "np.dot(A, B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ※ 주의할점\n",
    "행렬 A 의 1번째 차원의 원소 수(열 수)와 행렬 B의 0번째 차원의 원소 수(행 수)가 같아야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "(2, 2)\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(A.shape)\n",
    "\n",
    "C = np.array([[1,2], [3,4]])\n",
    "print(C.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 다음과 같은 에러발생\n",
    "# np.dot(A, C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.3 신경망에서의 행렬 곱"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2]\n",
      "(2,)\n",
      "[[1 3 5]\n",
      " [2 4 6]]\n",
      "(2, 3)\n",
      "[ 5 11 17]\n"
     ]
    }
   ],
   "source": [
    "X = np.array([1, 2])\n",
    "print(X)\n",
    "print(X.shape)\n",
    "\n",
    "W = np.array([[1, 3, 5], [2, 4, 6]])\n",
    "print(W)\n",
    "print(W.shape)\n",
    "\n",
    "y = np.dot(X, W)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4 3층 신경망 구현하기\n",
    "### 3.4.2 각 층의 신호 전달 구현하기\n",
    "\n",
    "**[식 3.8]**  \n",
    "$a_1^{(1)} = w_{11}^{(1)}x_1 + w_{12}^{(1)}x_2 + b_1^{(1)}$\n",
    "\n",
    "행렬의 곱을 이용하여 1층의 '가중치 부분'을 다음 식처럼 간소화할 수 있다.\n",
    "\n",
    "**[식 3.9]**  \n",
    "$A^{(1)} = XW^{(1)} + B^{(1)}$\n",
    "\n",
    "\n",
    "$\n",
    "A^{(1)} = (a_1^{(1)} \\space a_2^{(1)} \\space a_1^{(1)}), \\space X = (x_1 \\space x_2), \\space B^{(1)} = (b_1^{(1)} \\space  b_2^{(1)} \\space  b_3^{(1)})\n",
    "$\n",
    "\n",
    "$\n",
    "W^{(1)} =\n",
    "\\left (\n",
    "\\begin{align}\n",
    "w_{(11)} \\space w_{(12)} \\space w_{(13)} \\\\\n",
    "w_{(21)} \\space w_{(22)} \\space w_{(23)}\n",
    "\\end{align}\n",
    "\\right )\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "(3,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.3, 0.7, 1.1])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.array([1.0, 0.5])\n",
    "W1 = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])\n",
    "B1 = np.array([0.1, 0.2, 0.3])\n",
    "\n",
    "print(W1.shape)\n",
    "print(B1.shape)\n",
    "\n",
    "A1 = np.dot(X, W1) + B1\n",
    "A1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.57444252, 0.66818777, 0.75026011])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z1 = sigmoid(A1)\n",
    "Z1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.51615984, 1.21402696])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "W2 = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])\n",
    "B2 = np.array([0.1, 0.2])\n",
    "\n",
    "A2 = np.dot(Z1, W2) + B2\n",
    "A2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.62624937, 0.7710107 ])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z2 = sigmoid(A2)\n",
    "Z2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def identity_function(x):\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.31682708, 0.69627909])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "W3 = np.array([[0.1, 0.3], [0.2, 0.4]])\n",
    "B3 = np.array([0.1, 0.2])\n",
    "\n",
    "A3 = np.dot(Z2, W3) + B3\n",
    "A3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.31682708, 0.69627909])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y = identity_function(A3)\n",
    "Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.3 구현 정리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.31682708 0.69627909]\n"
     ]
    }
   ],
   "source": [
    "def init_network():\n",
    "    network = {}\n",
    "    network['W1'] = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])\n",
    "    network['b1'] = np.array([0.1, 0.2, 0.3])\n",
    "    network['W2'] = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])\n",
    "    network['b2'] = np.array([0.1, 0.2])\n",
    "    network['W3'] = np.array([[0.1, 0.3], [0.2, 0.4]])\n",
    "    network['b3'] = np.array([0.1, 0.2])\n",
    "    \n",
    "    return network\n",
    "\n",
    "def forword(network, x):\n",
    "    W1, W2, W3 = network['W1'], network['W2'], network['W3']\n",
    "    b1, b2, b3 = network['b1'], network['b2'], network['b3']\n",
    "    \n",
    "    a1 = np.dot(x, W1) + b1\n",
    "    z1 = sigmoid(a1)\n",
    "    \n",
    "    a2 = np.dot(z1, W2) + b2\n",
    "    z2 = sigmoid(a2)\n",
    "    \n",
    "    a3 = np.dot(z2, W3) + b3\n",
    "    y = identity_function(a3)\n",
    "    \n",
    "    return y\n",
    "\n",
    "network = init_network()\n",
    "x = np.array([1.0, 0.5])\n",
    "y = forword(network, x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.5 출력층 설계하기\n",
    "**※ NOTE**  \n",
    "기계학습은 **분류**<sup>classification</sup>와 **회귀**<sup>regression</sup>로 나뉜다. 분류는 데이터가 어느 클래스에 속하느냐는 문제이다.\n",
    "사진 속 인물의 성별을 분류하는 문제가 여기에 속한다. 한편, 회귀는 입력 데이터에서 (연속적인) 수치를 예측하는 문제이다. 사진 속 인물의 몸무게를 예측하는 문제가 회귀이다.\n",
    "\n",
    "### 3.5.1 항등 함수와 소프트맥스 함수 구현하기\n",
    "**항등 함수**<sup>idetity function</sup>는 입력을 그대로 출력한다.  \n",
    "한편, 분류에서 사용하는 **소프트맥스 함수**<sup>softmax function</sup>의 식은 다음과 같다.\n",
    "\n",
    "**[식 3.10]**  \n",
    "$\n",
    "\\begin{align}\n",
    "y_k =\n",
    "\\frac{exp(a_k)}{\\sum_{i=1}^n exp(a_i)}\n",
    "\\end{align}\n",
    "$\n",
    "\n",
    "- exp(x) 는 $e^x$을 뜻하는 지수 함수<sup>exponential function</sup>(e는 자연상수)\n",
    "- n은 출력층의 뉴런 수\n",
    "- $y_k$는 k번째 출력\n",
    "- 소프트맥스 함수의 분자는 입력 신호 $a_k$의 지수 함수\n",
    "- 소프트맥스 함수의 분모는 모든 입력 신호의 지수 함수의 합"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.34985881 18.17414537 54.59815003]\n",
      "74.1221542101633\n",
      "[0.01821127 0.24519181 0.73659691]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([0.3, 2.9, 4.0])\n",
    "exp_a = np.exp(a)\n",
    "print(exp_a)\n",
    "\n",
    "sum_exp_a = np.sum(exp_a)\n",
    "print(sum_exp_a)\n",
    "\n",
    "y = exp_a / sum_exp_a\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax(a):\n",
    "    exp_a = np.exp(a)\n",
    "    sum_exp_a = np.sum(exp_a)\n",
    "    y = exp_a / sum_exp_a\n",
    "    \n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5.2 소프트맥스 함수 구현 시 주의점\n",
    "소프트맥스 함수는 지수 함수를 사용하는데, 지수 함수란 것이 쉽게 아주 매우 큰 값을 내뱉는다. 그리고 이런 큰 값을 가지고 나눌경우 결과 수치가 '불안정'해진다.\n",
    "\n",
    "**[식 3.11]**  \n",
    "$\n",
    "\\begin{align}\n",
    "y_k =\n",
    "\\frac{exp(a_k)}{\\sum_{i=1}^n exp(a_i)} & = \\frac{Cexp(a_k)}{C\\sum_{i=1}^n exp(a_i)} \\\\\n",
    "                                       & = \\frac{exp(a_k + logC)}{\\sum_{i=1}^n exp(a_i + logC)} \\\\\n",
    "                                       & = \\frac{exp(a_k + C^\\prime)}{\\sum_{i=1}^n exp(a_i + C^\\prime)}\n",
    "\\end{align}\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[nan nan nan]\n",
      "[9.99954600e-01 4.53978686e-05 2.06106005e-09]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\python37\\lib\\site-packages\\ipykernel_launcher.py:2: RuntimeWarning: overflow encountered in exp\n",
      "  \n",
      "c:\\python37\\lib\\site-packages\\ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in true_divide\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "a = np.array([1010, 1000, 990])\n",
    "print(np.exp(a) / np.sum(np.exp(a)))\n",
    "\n",
    "# 지수 함수는 매우 큰 값을 내뱉어 nan 을 출력하므로, 보정해주는 작업을 거친다.\n",
    "a = np.array([1010, 1000, 990])\n",
    "c = np.max(a)\n",
    "print(np.exp(a - c) / np.sum(np.exp(a - c)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax(a):\n",
    "    c = np.max(a)\n",
    "    exp_a = np.exp(a - c)\n",
    "    sum_exp_a = np.sum(exp_a)\n",
    "    y = exp_a / sum_exp_a\n",
    "    \n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5.3 소프트맥스 함수의 특징"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.01821127 0.24519181 0.73659691]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0.3, 2.9, 4.0])\n",
    "y = softmax(a)\n",
    "print(y)\n",
    "\n",
    "np.sum(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "소프트맥스 함수의 출력은 0에서 1.0 사이의 실수이다. 또, 출력의 총합은 1이다.  \n",
    "이 성질 덕분에 소프트맥스 함수의 출력을 '확률'로 해석할 수 있다. 즉, 소프트맥스 함수를 이용함으로써 문제를 확률적(통계적)으로 대응할 수 있게 되는 것이다.\n",
    "\n",
    "여기서 주의점으로, 소프트맥스 함수를 ㅈ넉용해도 각 원소의 대소 관계는 변하지 않는다. 지수 함수 $y = exp(x)$가 단조 증가 함수 이기 때문이다.  \n",
    "→ 단조 증가 함수란 정의역 원소 a, b가 $a \\le b$일 때, $f(a) \\le f(b)$가 성립하는 함수\n",
    "\n",
    "**※ NOTE**  \n",
    "기계학습의 문제 풀이는 **학습**과 **추론**<sup>inference</sup>의 두 단계를 거쳐 이뤄진다. 학습 단계에서 모델을 학습하고, 추론 단계에서 앞서 학습한 모델로 미지의 데이터에 대해서 추론(분류)을 수행한다.  \n",
    "추론 단계에서는 출력층의 소프트맥스 함수를 생략하는 것이 일반적이며, 신경망을 학습시킬 때는 출력층에서 소프트맥스 함수를 사용한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5.4 출력층의 뉴런 수 정하기\n",
    "출력층의 뉴런 수는 풀려는 문제에 맞게 적절히 정해야 한다. 예를 들어 입력 이미지를 숫자 0부터 9까지 하나로 분류하는 문제라면 뉴런을 10개로 설정한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.6 손글씨 숫자 인식\n",
    "추론 과정을 신경망의 **순전파**<sup>forward popagation</sup>라고 한다.\n",
    "\n",
    "**※ NOTE**  \n",
    "기계학습과 마찬가지로 신경망도 두 단계를 거쳐 문제를 해결한다.  \n",
    "먼저 훈련 데이터(학습 데이터)를 사용해 가중치 매개변수를 학습하고, 추론 단계에서는 앞서 학습한 매개변수를 사용하여 입력 데이터를 분류한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6.1 MNIST 데이터셋"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converting train-images-idx3-ubyte.gz to NumPy Array ...\n",
      "Done\n",
      "Converting train-labels-idx1-ubyte.gz to NumPy Array ...\n",
      "Done\n",
      "Converting t10k-images-idx3-ubyte.gz to NumPy Array ...\n",
      "Done\n",
      "Converting t10k-labels-idx1-ubyte.gz to NumPy Array ...\n",
      "Done\n",
      "Creating pickle file ...\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "# (훈련 이미지, 훈련 레이블), (시험 이미지, 시험 레이블)\n",
    "(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(60000, 784)\n",
      "(60000,)\n",
      "(10000, 784)\n",
      "(10000,)\n"
     ]
    }
   ],
   "source": [
    "print(x_train.shape)\n",
    "print(t_train.shape)\n",
    "print(x_test.shape)\n",
    "print(t_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mSignature:\u001b[0m \u001b[0mload_mnist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnormalize\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mflatten\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mone_hot_label\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mDocstring:\u001b[0m\n",
       "MNIST 데이터셋 읽기\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "normalize : 이미지의 픽셀 값을 0.0~1.0 사이의 값으로 정규화할지 정한다.\n",
       "one_hot_label : \n",
       "    one_hot_label이 True면、레이블을 원-핫(one-hot) 배열로 돌려준다.\n",
       "    one-hot 배열은 예를 들어 [0,0,1,0,0,0,0,0,0,0]처럼 한 원소만 1인 배열이다.\n",
       "flatten : 입력 이미지를 1차원 배열로 만들지를 정한다. \n",
       "\n",
       "Returns\n",
       "-------\n",
       "(훈련 이미지, 훈련 레이블), (시험 이미지, 시험 레이블)\n",
       "\u001b[1;31mFile:\u001b[0m      d:\\deep-learning-from-scratch\\inputs\\dataset\\mnist.py\n",
       "\u001b[1;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "load_mnist?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**※ NOTE**  \n",
    "파이썬에는 pickle<sup>피클</sup>라는 기능이 존재한다. 이는 프로그램 실행 중에 특정 객체를 파일로 저장하는 기능이다.  \n",
    "저장해둔 pickle 파일을 로드하면 실행 당시의 객체를 즉시 복원할 수 있다. load_mnist() 함수에서도 2번째 이후의 읽기시에 pickle을 이용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def img_show(img):\n",
    "    pil_img = Image.fromarray(np.uint8(img))\n",
    "    pil_img.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "(784,)\n",
      "(28, 28)\n"
     ]
    }
   ],
   "source": [
    "# (훈련 이미지, 훈련 레이블), (시험 이미지, 시험 레이블)\n",
    "(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)\n",
    "\n",
    "img = x_train[0]\n",
    "label = t_train[0]\n",
    "print(label)\n",
    "\n",
    "print(img.shape)\n",
    "img = img.reshape(28, 28)\n",
    "print(img.shape)\n",
    "\n",
    "img_show(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6.2 신경망의 추론 처리\n",
    "입력층 뉴런을 784개, 출력층 뉴런을 10개로 구성한다. 입력층 뉴런이 784개인 이유는 이미지 크기가 $28 \\times 28 = 784$이기 때문이고,  \n",
    "출력층 뉴런이 10개인 이유는 이 문제가 0 ~ 9까지 숫자를 구분하기 때문이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    return 1 / (1 + np.exp(-x))\n",
    "\n",
    "def sotfmax(x):\n",
    "    c = np.max(x)\n",
    "    exp_x = np.exp(x - c)\n",
    "    sum_exp_x = np.sum(exp_x)\n",
    "    \n",
    "    y = exp_x / sum_exp_x\n",
    "    \n",
    "    return y\n",
    "\n",
    "def get_data():\n",
    "    (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)\n",
    "\n",
    "    return x_test, t_test\n",
    "\n",
    "def init_network():\n",
    "    with open(\"./inputs/dataset/sample_weight.pkl\", 'rb') as f:\n",
    "        network = pickle.load(f)\n",
    "        \n",
    "    return network\n",
    "\n",
    "def predict(network, x):\n",
    "    W1, W2, W3 = network['W1'], network['W2'], network['W3']\n",
    "    b1, b2, b3 = network['b1'], network['b2'], network['b3']\n",
    "    \n",
    "    a1 = np.dot(x, W1) + b1\n",
    "    z1 = sigmoid(a1)\n",
    "    \n",
    "    a2 = np.dot(z1, W2) + b2\n",
    "    z2 = sigmoid(a2)\n",
    "    \n",
    "    a3 = np.dot(z2, W3) + b3\n",
    "    y = sotfmax(a3)\n",
    "    \n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:0.9352\n"
     ]
    }
   ],
   "source": [
    "x, t = get_data()\n",
    "network = init_network()\n",
    "\n",
    "accuracy_cnt = 0\n",
    "\n",
    "for i in range(len(x)):\n",
    "    y = predict(network, x[i])\n",
    "    p = np.argmax(y)\n",
    "    if p == t[i]:\n",
    "        accuracy_cnt += 1\n",
    "    \n",
    "print(\"Accuracy:\" + str(float(accuracy_cnt) / len(x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "normalize = True 로 설정하면 0 ~ 255 범위인 각 필셀의 값을 0.0 ~ 1.0 범위로 변환한다.  \n",
    "이처럼 특정 범위로 변환하는 처리를 **정규화**<sup>normalization</sup>라 하고, 신경망의 입력 데이터에 특정 변환을 가하는 것을 **전처리**<sup>pre-processing</sup>라 한다.  \n",
    "여기에서는 입력 이미지 데이터에 대한 전처리 작업으로 정규화를 수행한 셈이다.\n",
    "\n",
    "**※ NOTE**  \n",
    "그 외에도 전체 데이터를 균일하게 분포시키는 데이터 **백색화**<sup>whitening</sup> 등도 존재한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6.3 배치 처리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 784)\n",
      "(784,)\n",
      "(784, 50)\n",
      "(50, 100)\n",
      "(100, 10)\n"
     ]
    }
   ],
   "source": [
    "x, _ = get_data()\n",
    "network = init_network()\n",
    "\n",
    "W1, W2, W3 = network['W1'], network['W2'], network['W3']\n",
    "print(x.shape)\n",
    "print(x[0].shape)\n",
    "print(W1.shape)\n",
    "print(W2.shape)\n",
    "print(W3.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "하나로 묶은 입력 데이터를 **배치**<sup>batch</sup>라 한다.\n",
    "\n",
    "**※ NOTE**  \n",
    "수치 계산 라이브러리 대부분이 큰 배열을 효율적으로 처리할 수 있도록 고도로 최적화되어 있다.  \n",
    "또한 느린 I/O를 통해 데이터를 읽는 횟수가 줄기 때문에 배치 처리를 수행함으로써 얻는 이점이 커지게 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:0.9352\n"
     ]
    }
   ],
   "source": [
    "x, t = get_data()\n",
    "network = init_network()\n",
    "\n",
    "batch_size = 100\n",
    "accuracy_cnt = 0\n",
    "\n",
    "for i in range(0, len(x), batch_size):\n",
    "    x_batch = x[i:i+batch_size]\n",
    "    y_batch = predict(network, x_batch)\n",
    "    p = np.argmax(y_batch, axis=1)\n",
    "    \n",
    "    accuracy_cnt += np.sum(p == t[i:i+batch_size])\n",
    "    \n",
    "print(\"Accuracy:\" + str(float(accuracy_cnt) / len(x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.7 정리\n",
    "신경망은 각 층의 뉴런들이 다음 층의 뉴런으로 신호를 전달한다는 점에서 앞 장의 퍼셉트론과 같다.  \n",
    "하지만 신경망에서는 활성화 함수로 시그모이드 함수를, 퍼셉트론에서는 계단 함수를 활성화 함수로 사용했다.  \n",
    "이 차이가 신경망 학습에 중요한 점이다."
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}