week6_NN_강미경.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'weights': [0.13436424411240122, 0.8474337369372327, 0.763774618976614]}]\n",
      "[{'weights': [0.2550690257394217, 0.49543508709194095]}, {'weights': [0.4494910647887381, 0.651592972722763]}]\n"
     ]
    }
   ],
   "source": [
    "from random import seed\n",
    "from random import random\n",
    "import numpy as np\n",
    " \n",
    "# 네트워크 초기 설정\n",
    "def initialize_network(n_inputs, n_hidden, n_outputs): \n",
    "    network = list()\n",
    "    hidden_layer = [{'weights':[random() for i in range(n_inputs + 1)]} for i in range(n_hidden)] #입력 노드의 개수 + bias 만큼 가중치를 생성함. \n",
    "    network.append(hidden_layer)\n",
    "    output_layer = [{'weights':[random() for i in range(n_hidden + 1)]} for i in range(n_outputs)] #은닉 노드의 개수 + bias 만큼 가중치를 생성함. \n",
    "    network.append(output_layer)\n",
    "    return network\n",
    " \n",
    "seed(1)\n",
    "network = initialize_network(2, 1, 2) \n",
    "# 입력노드는 2개, 은닉노드는 1개, 부류는 두 개로 초기 네트워크를 설정함.\n",
    "# hidden_layer : 입력노드의 수는 2개 이기 때문에 총 세 개 생성 (bias, x1, x2의 가중치), 은닉노드는 한 개 이기 때문에 한 세트 생성. \n",
    "# output_layer : 은닉노드의 수는 1개 이기 때문에 총 두 개 생성 (bias, h1), 클래스는 두 개이기 때문에 가중치가 각 클래스에 따른 두 세트로 생성됨.\n",
    "\n",
    "#초기 설정한 네트워크를 확인함.\n",
    "for layer in network:\n",
    "    print(layer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#순전파 함수\n",
    "def activate(weights, inputs): #각각의 입력값과 가중치를 곱해서 더해주는 함수\n",
    "    activation = weights[-1] #bias의 가중치는 곱해줄 게 없기 때문에 초기에 먼저 더해줌.\n",
    "    for i in range(len(weights)-1): #bias를 제외한 각각의 입력노드 요소에 접근\n",
    "        activation += weights[i] * inputs[i]  # 가중치와 입력값을 곱해서 activation에 더해준다.\n",
    "    return activation #그걸 반환해준다 !! \n",
    "\n",
    "def sigmoid(activation):\n",
    "    return 1.0 / (1.0 + np.exp(-activation)) # 시그모이드 구현\n",
    "\n",
    "def forward_propagate(network, row): \n",
    "    inputs = row \n",
    "    for layer in network: #입력노드의 가중치부터 은닉노드의 가중치까지 순차적으로 접근\n",
    "        new_inputs = [] \n",
    "        for neuron in layer: #해당 노드의 가중치에 각각 접근\n",
    "            activation = activate(neuron['weights'], inputs) #해당 노드의 가중치를 activate 함수의 결과로 반환받음.\n",
    "            neuron['output'] = sigmoid(activation) # 나온 계산 값을 그대로 쓰나요? ==> 아니요! 활성함수인 시그모이드에 넣었어용 ^--^\n",
    "            new_inputs.append(neuron['output']) # new_input은 다음 히든층에 들어갈 값이죠? ==> 네 맞아요 input에 대한 출력값이고 이는 즉 다음 레이어의 입력값이 됩니다.\n",
    "        inputs = new_inputs #다음 노드의 입력값이 되도록 inputs 값을 업데이트 해줍니다. \n",
    "    return inputs #그걸 반환해준다!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**여기까지는 순전파 학습과정이었습니다. 이 과정이 끝나면 가중치가 바뀌나요?  \n",
    "답변을 답변의 근거 코딩 결과와 함께 보여주세요.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.6629970129852887, 0.7253160725279748]\n"
     ]
    }
   ],
   "source": [
    "row = [1, 0, None]\n",
    "output = forward_propagate(network, row)\n",
    "print(output) #부류가 2개였으니까 각 부류에 대한 outputs값이 두 개 나옵니다. 0과 1 이렇게만 나오는 줄 알았는데 시그모이드가 연속형이라 이런 값이 나오나봐요!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid_derivative(output):\n",
    "    return output * (1.0 - output) # 시그모이드 미분 (y(1-y))\n",
    "\n",
    "def backward_propagate_error(network, expected):\n",
    "    \n",
    "    for i in reversed(range(len(network))): #reversed이기 때문에 0, 1 순서로 실행되는 것이 아니라 1, 0순서로 실행, 첫 실행의 i는 1이다.\n",
    "        layer = network[i]\n",
    "        errors = []\n",
    "        if i != len(network)-1: \n",
    "            for j in range(len(layer)):\n",
    "                error = 0.0\n",
    "                for neuron in network[i + 1]:\n",
    "                    error += (neuron['weights'][j] * neuron['delta'])\n",
    "                errors.append(error) \n",
    "        else: #이거부터 실행됨. 역전이니까!\n",
    "            for j in range(len(layer)):\n",
    "                neuron = layer[j] \n",
    "                errors.append(expected[j] - neuron['output']) # 역전파시 오차는 어떻게 설정했나요? ==> 실제값에서 출력값(output)를 뺀 값으로 설정했습니다!\n",
    "        for j in range(len(layer)):\n",
    "            neuron = layer[j]\n",
    "            neuron['delta'] =  errors[j] * sigmoid_derivative(neuron['output'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'weights': [0.13436424411240122, 0.8474337369372327, 0.763774618976614], 'output': 0.7105668883115941, 'delta': -0.002711797799238243}]\n",
      "[{'weights': [0.2550690257394217, 0.49543508709194095], 'output': 0.6629970129852887, 'delta': -0.14813473120687762}, {'weights': [0.4494910647887381, 0.651592972722763], 'output': 0.7253160725279748, 'delta': 0.05472601157879688}]\n"
     ]
    }
   ],
   "source": [
    "expected = [0, 1]\n",
    "\n",
    "backward_propagate_error(network, expected)\n",
    "for layer in network:\n",
    "    print(layer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def weights_update(network, row, l_rate): #가중치를 업데이트하자!!\n",
    "    for i in range(len(network)):\n",
    "        inputs = row[:-1]\n",
    "        if i != 0:\n",
    "            inputs = [neuron['output'] for neuron in network[i - 1]]\n",
    "        for neuron in network[i]:\n",
    "            for j in range(len(inputs)):\n",
    "                neuron['weights'][j] += l_rate * neuron['delta'] * inputs[j]\n",
    "            neuron['weights'][-1] += l_rate * neuron['delta'] # 퍼셉트론 학습 규칙\n",
    "            \n",
    "\n",
    "def train_network(network, train, l_rate, n_epoch, n_outputs):\n",
    "    for epoch in range(n_epoch):\n",
    "        sum_error = 0\n",
    "        for row in train:\n",
    "            outputs = forward_propagate(network, row) # 순전파 \n",
    "            expected = [0 for i in range(n_outputs)]\n",
    "            expected[row[-1]] = 1\n",
    "            sum_error += sum([(expected[i]-outputs[i])**2 for i in range(len(expected))]) # 예측값의 오차 합\n",
    "            backward_propagate_error(network, expected) #구한 expected 값을 이용해 역전파를 수행\n",
    "            weights_update(network, row, l_rate) \n",
    "        print('>epoch=%d, lrate=%.3f, error=%.3f' % (epoch, l_rate, sum_error))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed(1)\n",
    "dataset = [[2.7810836,2.550537003,0],\n",
    "    [1.465489372,2.362125076,0],\n",
    "    [3.396561688,4.400293529,0],\n",
    "    [1.38807019,1.850220317,0],\n",
    "    [3.06407232,3.005305973,0],\n",
    "    [7.627531214,2.759262235,1],\n",
    "    [5.332441248,2.088626775,1],\n",
    "    [6.922596716,1.77106367,1],\n",
    "    [8.675418651,-0.242068655,1],\n",
    "    [7.673756466,3.508563011,1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'weights': [0.13436424411240122, 0.8474337369372327, 0.763774618976614]}, {'weights': [0.2550690257394217, 0.49543508709194095, 0.4494910647887381]}]\n",
      "[{'weights': [0.651592972722763, 0.7887233511355132, 0.0938595867742349]}, {'weights': [0.02834747652200631, 0.8357651039198697, 0.43276706790505337]}]\n",
      ">epoch=0, lrate=0.500, error=6.350\n",
      ">epoch=1, lrate=0.500, error=5.531\n",
      ">epoch=2, lrate=0.500, error=5.221\n",
      ">epoch=3, lrate=0.500, error=4.951\n",
      ">epoch=4, lrate=0.500, error=4.519\n",
      ">epoch=5, lrate=0.500, error=4.173\n",
      ">epoch=6, lrate=0.500, error=3.835\n",
      ">epoch=7, lrate=0.500, error=3.506\n",
      ">epoch=8, lrate=0.500, error=3.192\n",
      ">epoch=9, lrate=0.500, error=2.898\n",
      ">epoch=10, lrate=0.500, error=2.626\n",
      ">epoch=11, lrate=0.500, error=2.377\n",
      ">epoch=12, lrate=0.500, error=2.153\n",
      ">epoch=13, lrate=0.500, error=1.953\n",
      ">epoch=14, lrate=0.500, error=1.774\n",
      ">epoch=15, lrate=0.500, error=1.614\n",
      ">epoch=16, lrate=0.500, error=1.472\n",
      ">epoch=17, lrate=0.500, error=1.346\n",
      ">epoch=18, lrate=0.500, error=1.233\n",
      ">epoch=19, lrate=0.500, error=1.132\n",
      "[{'weights': [-1.4688375095432327, 1.850887325439514, 1.0858178629550297], 'output': 0.029980305604426185, 'delta': -0.0059546604162323625}, {'weights': [0.37711098142462157, -0.0625909894552989, 0.2765123702642716], 'output': 0.9456229000211323, 'delta': 0.0026279652850863837}]\n",
      "[{'weights': [2.515394649397849, -0.3391927502445985, -0.9671565426390275], 'output': 0.23648794202357587, 'delta': -0.04270059278364587}, {'weights': [-2.5584149848484263, 1.0036422106209202, 0.42383086467582715], 'output': 0.7790535202438367, 'delta': 0.03803132596437354}]\n"
     ]
    }
   ],
   "source": [
    "n_inputs = 2 # 뉴럴렛의 입력노드로 뭐가 들어가죠? 그럼 입력 노드의 개수는? ==> 입력노드는 feature 개수입니다!! 2입니다!!\n",
    "n_outputs = 2 # 뉴럴렛의 출력노드의 개수는 뭐라고 했죠? ==> 부류의 개수입니다!! 여기서는 0과 1이니까 2입니다!!\n",
    "network = initialize_network(n_inputs, 2, n_outputs)\n",
    "\n",
    "for layer in network:\n",
    "    print(layer)\n",
    "    \n",
    "train_network(network, dataset, 0.5, 20, n_outputs) # 자유롭게 설정하고 최적을 찾아보세요.\n",
    "\n",
    "# 학습된(최적화)된 네트워크가 초기 네트워크와 달리 어떻게 변하였는지 출력하시오. (layer별로, hint : for문))\n",
    "\n",
    "for layer in network:\n",
    "    print(layer)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 학습한 네트워크로 예측값을 뽑아보자.\n",
    "def predict(network, row):\n",
    "    outputs = forward_propagate(network, row)\n",
    "    return outputs.index(max(outputs)) \n",
    "# 순전파 결과에서 어떤것이 최종 아웃풋이 되나요? \n",
    "# ==> outputs은 활성함수(시그모이드)를 통해 나온 값으로 0일 때, 1일 때로 나누어져 있습니다 \n",
    "# 그리고 그 중 더 값이 큰 쪽의 인덱스를 반환하여 그 값을 최종 아웃풋으로 사용하는 것 같습니다!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "실제값=0, 예측값=0\n",
      "실제값=0, 예측값=0\n",
      "실제값=0, 예측값=0\n",
      "실제값=0, 예측값=0\n",
      "실제값=0, 예측값=0\n",
      "실제값=1, 예측값=1\n",
      "실제값=1, 예측값=1\n",
      "실제값=1, 예측값=1\n",
      "실제값=1, 예측값=1\n",
      "실제값=1, 예측값=1\n"
     ]
    }
   ],
   "source": [
    "# 네트워크가 잘 학습되었는지 확인해보자. \n",
    "\n",
    "for row in dataset:\n",
    "    prediction = predict(network, row) # 앞서 최적(학습)시킨 네트워크로 잘 학습되었는지 평가 \n",
    "    print('실제값=%d, 예측값=%d' % (row[-1], prediction))\n",
    "\n",
    "    #예측이 Perfect하다!!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 제가 수식적인 부분을 완전히 이해하지 못해서 주석을 많이 못달았어요 ㅠㅠ  \n",
    " \n",
    "그래도 강의 자료 올려주신 것과 추가로 인강도 들어가며 뉴럴 네트워크 많이 공부하려고 했다는 점만 알아주세요,,,  \n",
    "\n",
    "험난한 이 시국에 코로나 조심하시구요 쉬는 동안 더 공부해가겠습니다!!  \n",
    "\n",
    "앙상블 때부터 좋은 강의 해주셔서 너무 감사해요 과제하면서 많이 배워갑니다!! :>>> ♡\n"
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}