2. 퍼셉트론.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "34469855",
   "metadata": {},
   "source": [
    "# 퍼셉트론\n",
    "\n",
    "이번 장에서는 퍼셉트론 알고리즘에 대해 설명한다.\n",
    "퍼셉트론은 신경망(딥러닝)의 기원이 되는 알고리즘이다.\n",
    "퍼셉트론의 구조를 배우는 것은 신경망과 딥러닝으로 나아가는 데 중요한 아이디어를 배우는 일\n",
    "\n",
    "## 퍼셉트론이란?\n",
    "\n",
    "- 퍼셉트론은 다수의 신호를 입력으로 받아 하나의 신호를 출력함\n",
    "    - 신호는 전류나 강물처럼 흐름이 있는 것을 상상하면 좋음\n",
    "    - 퍼셉트론 신호도 흐름을 만들고 정보를 앞으로 전달\n",
    "    - 그렇지만 실제 전류와는 달리 퍼셉트론은 신호가 흐른다, 신호가 흐르지 않는다의 두 가지 값을 가진다.\n",
    "        - 1을 '신호가 흐른다', 0을 '신호가 흐르지 않는다'라고 가정할 것임\n",
    "    \n",
    "- 교재 49p 그림 참고\n",
    "    - x1, x2는 입력 신호, y는 출력 신호, w1과 w2는 가중치를 의미\n",
    "    - 그림의 원은 뉴런 혹은 노드라고 부름\n",
    "    - 입력 신호가 뉴런에 보내질 때에는 각각 고유한 가중치가 곱해짐(w1x1, w2x2)\n",
    "    - 뉴런에서 보내온 신호으 ㅣ총합이 정해진 한계를 넘어설 때만 1을 출력한다. (= 뉴런이 활성화한다)\n",
    "        - 여기서는 이 한계를 \"임계값\"이라고 표현\n",
    "    - 이상을 수식으로 나타내면;\n",
    "    \n",
    "    $y =\n",
    "    \\begin{cases}\n",
    "    y = 0 (w_1w_2 + w_2x_2) \\le 𝜽 \\\\\n",
    "    y = 1 (w_1x_1 + w_2x_2) > 𝜽\n",
    "    \\end{cases}$\n",
    " \n",
    " - 퍼셉트론은 복수의 입력 신호 각각에 고유한 가중치를 부여\n",
    " \n",
    " ## 단순한 논리 회로\n",
    " \n",
    " ### AND 게이트\n",
    " \n",
    " $\\begin{array}{|c|c|c|} x_1 & x_2 & y \\\\\n",
    " \\hline\n",
    " 0 & 0 & 0 \\\\\n",
    " 1 & 0 & 0 \\\\\n",
    " 0 & 1 & 0 \\\\\n",
    " 1 & 1 & 0 \\\\\n",
    " \\end{array}$\n",
    " \n",
    " \n",
    " - 위와 같은 입력 신호와 출력 신호의 대응 표를 진리표라고 한다.\n",
    " - AND 게이트는 입력이 둘이고 출력이 하나\n",
    "     - 두 입력이 모두 1일 때만 1을 출력하고, 그 외에는 0을 출력한다\n",
    "     \n",
    " - 우리가 원하는 것은 이 AND 게이트를 퍼셉트론으로 표현하는 것\n",
    "     - 그러기 위해서는 $w_1, w_2, 𝜽$ 의 값을 정하는 것.\n",
    " \n",
    " - 위 그림을 만족하는 매개변수 조합 $(w_1, w_2, 𝜽)$은 무수히 많다.\n",
    "     - 가령 (0.5, 0.5, 0.7), (0.5, 0.5, 0.8), (1.0,1.0,1.0) 때 모두 조건을 만족\n",
    "     - 매개변수를 이렇게 설정하면 $x_1$과 $x_2$ 모두 1일 때만 가중 신호의 총합이 주어진 임계값을 웃돌게 된다.\n",
    "     \n",
    " ### NAND 게이트와 OR 게이트\n",
    " \n",
    " 1. NAND 게이트\n",
    "     - NAND는 Not AND를 의미하며, AND 게이트의 출력을 뒤집은 것이 된다.\n",
    "     \n",
    " $\\begin{array}{|c|c|c|} x_1 & x_2 & y \\\\\n",
    " \\hline\n",
    " 0 & 0 & 1 \\\\\n",
    " 1 & 0 & 1 \\\\\n",
    " 0 & 1 & 1 \\\\\n",
    " 1 & 1 & 0 \\\\\n",
    " \\end{array}$\n",
    "\n",
    "\n",
    "\n",
    " 2. OR 게이트\n",
    "    - OR 게이트는 입력 신호 중 하나 이상이 1이면 출력이 1이 되는 논리 회로이다.\n",
    "    \n",
    " $\\begin{array}{|c|c|c|} x_1 & x_2 & y \\\\\n",
    " \\hline\n",
    " 0 & 0 & 0 \\\\\n",
    " 1 & 0 & 1 \\\\\n",
    " 0 & 1 & 1 \\\\\n",
    " 1 & 1 & 1 \\\\\n",
    " \\end{array}$\n",
    " \n",
    " \n",
    " - 이상과 같이 퍼셉트론으로 AND, NAND, OR 논리 회로를 표현할 수 있다.\n",
    " - 중요한 점은 퍼셉트론의 구조는 세 게이트에서 모두 똑같다는 것!\n",
    "     - 세 가지 게이트에서 다른 것은 매개변수(가중치와 임계값)의 값뿐이다.\n",
    "     \n",
    "     \n",
    "## 퍼셉트론 구현하기\n",
    "\n",
    "### 간단한 구현\n",
    "\n",
    "논리 회로를 파이썬으로 구현해보자. $x_1$과 $x_2$를 인수로 받는 AND 함수이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "84ab55ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "def AND(x1, x2):\n",
    "    w1, w2, theta = 0.5, 0.5, 0.7\n",
    "    tmp = x1*w1 + x2*w2\n",
    "    if tmp <= theta:\n",
    "        return 0\n",
    "    elif tmp > theta:\n",
    "        return 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ae930ce",
   "metadata": {},
   "source": [
    "- 매개변수 w1, w2, theta는 함수 안에서 초기화되고, 가중치를 곱한 입력의 총합이 임계값을 넘으면 1 반환, 넘지 않으면 0을 반환한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "14c541f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND(0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "604a1eaa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "753152ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND(1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4fa4af33",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND(1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7609adbf",
   "metadata": {},
   "source": [
    "### 가중치와 편향 도입\n",
    "\n",
    "앞에서 구현한 AND 게아트를 수정해보자.\n",
    "\n",
    "$ y =\n",
    "\\begin{cases}\n",
    "0 (b + w_! * x_1 + w_2 * x_2 \\le 0) \\\\\n",
    "1 (b + w_1 * x_1 + w_2 * x_2 > 0)\n",
    "\\end{cases}$\n",
    "\n",
    "위 식은 기호 표기만 바꿨을 뿐, 의미는 같다.\n",
    "b는 편향(biases)라고 하며, $w_1, w_2$은 그대로 가중치이다.\n",
    "\n",
    "퍼셉트론은 입력 신호에 가중치를 곱한 값과 편향을 합하여, 그 값이 0을 넘으면 1을, 그렇지 않으면 0을 출력한다.\n",
    "앞에서 다룬 식에서 임계치를 -(편향)으로 대체한 값이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "012b3069",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.5])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.array([0,1])\n",
    "w = np.array([0.5, 0.5])\n",
    "b = -0.7\n",
    "w*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e1f02fe0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(w*x) # 행렬끼리의 곱의 합"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "494e9399",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.19999999999999996"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(w*x) + b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01cbe997",
   "metadata": {},
   "source": [
    "따라서 가중치와 편향을 도입한 AND 게이트는 다음과 같이 구현할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c00ce8b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def AND (x1, x2): # def 다음에 \":\" 붙이는 것 잊지 말기!\n",
    "    x = np.array([x1, x2]) # 아까의 vector가 아닌 다차원 계산을 위해 행렬로 변수를 넣는다.\n",
    "    w = np.array([0.5, 0.5]) # x와 마찬가지.\n",
    "    b = -0.7\n",
    "    tmp = np.sum(x*w) + b\n",
    "    if tmp > 0: # if와 else에도 \":\"을 붙여야 한다.\n",
    "        return 1\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "72873cce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND (1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "cb2d9f62",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b1820a54",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND(1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ea2e08e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND(0,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b60889a5",
   "metadata": {},
   "source": [
    "### NAND 게이트와 OR 게이트의 구현\n",
    "\n",
    "#### 1. NAND 게이트"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "3948a518",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "def NAND(x1, x2):\n",
    "    x = np.array([x1, x2])\n",
    "    w = np.array([-0.5, -0.5])\n",
    "    b = 0.7\n",
    "    tmp = np.sum(x*w) + b\n",
    "    if tmp > 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "    \n",
    "NAND(1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "ad96759a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NAND(1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1b8070a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NAND(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "eebf607d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NAND(0,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03c03660",
   "metadata": {},
   "source": [
    "#### 2. OR 게이트"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4e508507",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def OR(x1, x2): # 들여쓰기를 할 때 :을 쓴다고 생각하면 될 듯\n",
    "    x = np.array([x1, x2])\n",
    "    w = np.array([0.6, 0.6])\n",
    "    b = -0.5\n",
    "    tmp = np.sum(x*w) + b\n",
    "    if tmp > 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "OR(1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "5e43dd04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "OR(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b8e93da1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "OR(1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e2035298",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "OR(0,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7be11f87",
   "metadata": {},
   "source": [
    "## 퍼셉트론의 한계\n",
    "\n",
    "퍼셉트론을 이용하면 AND, NAND, OR의 논리 회로를 구현할 수 있다.\n",
    "계속해서 XOR 게이트를 생각해보자.\n",
    "\n",
    "### 도전! XOR 게이트\n",
    "\n",
    "XOR 게이트는 배타적 논리합이라는 논리 회로이다.\n",
    "\n",
    "$\\begin{array}{|c|c|c|} x_1 & x_2 & y \\\\\n",
    " \\hline\n",
    " 0 & 0 & 0 \\\\\n",
    " 1 & 0 & 1 \\\\\n",
    " 0 & 1 & 1 \\\\\n",
    " 1 & 1 & 0 \\\\\n",
    " \\end{array}$\n",
    " \n",
    " \n",
    " 위와 같이 x1 x2 중 한 쪽이 1일 때만 1을 출력한다. (배타적이라는 것은 자기 외에는 거부한다는 것)\n",
    " \n",
    "\n",
    "- 위에서 구현한 퍼셉트론은 모두 선형으로 표현 가능하다. $(x_1, x_2, w_1, w_2)$의 선형 결합으로 표현할 수 있었다는 말\n",
    "- 그렇지만 XOR 게이트는 선형결합으로 표현 불가능하다. 그림 예는 교재 참고\n",
    "    - 따라서 XOR 게이트를 표현하려면 비선형으로 나누는 것을 생각해야 한다.\n",
    "    - 곡선의 영역을 **비선형 영역** 직선의 영역을 **선형 영역**이라고 한다. \n",
    "        - 선형, 비선형은 기계학습 분야에서 자주 쓰이는 용어이니 익숙해질 것.\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa9e9d0a",
   "metadata": {},
   "source": [
    "## 다층 퍼셉트론이 출동한다면\n",
    "\n",
    "- 퍼셉트론으로는 XOR 게아트를 표현할 수 없었음\n",
    "- 그렇지만 퍼셉트론의 '층을 쌓는' **다층 퍼셉트론**으로 XOR 게이트를 구현할 수 있다.\n",
    "    - 여기서에서는 층을 한 번 더 쌓아서 XOR을 표현할 것이다.\n",
    "    \n",
    "### 기존 게이트 조합하기\n",
    "\n",
    "- 첫 번쨰 방법은 AND, NAND, OR 게이트를 조합하는 것\n",
    "    - XOR 게이트를 구현하는 방법은 첫 번째로는 OR 게이트와 NAND 게이트를 활용하고, 이 결과를 AND 게이트에 넣는 것이다.\n",
    "    \n",
    "- 이와 같은 방법의 진리표는 다음과 같다.\n",
    "\n",
    "$$\\begin{array}{c|c|c|c|c|} x_! & x_2 & x_1 & x_2 & y \\\\\n",
    "\\hline\n",
    "0 & 0 & 1 & 0 & 0 \\\\\n",
    "1 & 0 & 1 & 1 & 1 \\\\\n",
    "0 & 1 & 1 & 1 & 1 \\\\\n",
    "1 & 1 & 0 & 1 & 0 \\\\\n",
    "\\end{array}$$\n",
    "\n",
    "### XOR 게이트 구현하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "8c3054ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def XOR (x1, x2):\n",
    "    s1 = NAND (x1, x2)\n",
    "    s2 = OR (x1, x2)\n",
    "    y = AND (s1, s2)\n",
    "    return y\n",
    "\n",
    "XOR(0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f664224a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "XOR(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "9cfd039a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "XOR(1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "99e8df1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "XOR(1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bab4d88",
   "metadata": {},
   "source": [
    "위와 같은 2층 퍼셉트론에서는 0층에서 1층으로 신호가 전달되고, 이어서 1층에서 2층으로 신호가 전달된다.\n",
    "\n",
    "이와 같은 다층 퍼셉트론으로 **단층 퍼셉트론으로는 표현하지 못한 것을 층을 하나 늘려 구현**할 수 있었음.\n",
    "퍼셉트론은 층을 쌓아 더 다양한 것을 표현할 수 있다.\n",
    "\n",
    "## NAND에서 컴퓨터까지\n",
    "\n",
    "- 다층 퍼셉트론은 지금까지 보아온 회로보다 복잡한 회로를 만들 수 있다.\n",
    "- 이를테면 컴퓨터는 NAND 게이트의 조합만으로 만들 수 있다. \n",
    "    - 이론 상 2층 퍼셉트론으로도 컴퓨터를 만들 수 있음\n",
    "    - 비선형인 시그모이드 함수를 활성화 함수로 이용하면 임의의 함수로 표현할 수 있다는 것이 증명되었음\n",
    "        - 하지만 2층 퍼셉트론 구조에서 **가중치를 적절히 설정**하여 컴퓨터를 만들기란 어렵다.\n",
    "   \n",
    "   \n",
    "# 정리 코드\n",
    "\n",
    "## AND 게이트"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "8638fb34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "def AND(x1, x2):\n",
    "    x = np.array([x1, x2])\n",
    "    w = np.array([0.5, 0.5])\n",
    "    b = -0.7\n",
    "    tmp = np.sum(x*w) + b\n",
    "    if tmp > 0:\n",
    "        return 1\n",
    "    if tmp < 0:\n",
    "        return 0\n",
    "    \n",
    "AND(0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "48d574e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "8f7d3baf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND(1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "c612cdac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND(1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd556e29",
   "metadata": {},
   "source": [
    "## NAND 게이트 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "2db6b3fc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def NAND(x1, x2):\n",
    "    x = np.array([x1, x2])\n",
    "    w = np.array([-0.5, -0.5])\n",
    "    b = 0.7\n",
    "    tmp = np.sum(x*w) + b\n",
    "    if tmp > 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "    \n",
    "NAND(0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "80024ecf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NAND(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "4b810acb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NAND(1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "57ee51be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NAND(1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "489801c7",
   "metadata": {},
   "source": [
    "## OR 게이트 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "465cad36",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def OR(x1, x2):\n",
    "    x = np.array([x1, x2])\n",
    "    w = np.array([0.5, 0.5])\n",
    "    b = -0.3\n",
    "    tmp = np.sum(x*w) + b\n",
    "    if tmp > 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "    \n",
    "OR(0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "551bc9c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "OR(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "4cf5cc81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "OR(1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "754b4bb9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "OR(1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b51ad327",
   "metadata": {},
   "source": [
    "## XOR 게이트 : 다층 퍼셉트론"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "5000902e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def XOR(x1, x2):\n",
    "    s1 = OR(x1, x2)\n",
    "    s2 = NAND(x1, x2)\n",
    "    y = AND(s1, s2)\n",
    "    return y\n",
    "\n",
    "XOR(0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "1921c312",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "XOR(1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "1a4010a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "XOR(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "22cd7fcc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "XOR(1,1)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}