Untitled10.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled10.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyOiVpIMYAfutvIMKiuUi9ju",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/dlguswn3659/class-MachineLearning/blob/master/Untitled10.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-sOoEaBxtNXA",
        "colab_type": "code",
        "outputId": "def056e7-abdf-473c-aef6-fbe9e8cfeb67",
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "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",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": ""
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 628
        }
      },
      "source": [
        "%matplotlib inline\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib as mpl\n",
        "import seaborn as sns\n",
        "import matplotlib.animation as animation\n",
        "import operator\n",
        "from scipy import stats \n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "from sklearn.datasets.samples_generator import make_regression \n",
        "import csv\n",
        "import math\n",
        "from google.colab import files\n",
        "\n",
        "uploaded = files.upload()\n",
        "\n",
        "file_data   = \"mnist.csv\"\n",
        "handle_file = open(file_data, \"r\")\n",
        "data        = handle_file.readlines()\n",
        "handle_file.close()\n",
        "\n",
        "size_row    = 28    # height of the image\n",
        "size_col    = 28    # width of the image\n",
        "\n",
        "num_image   = len(data)\n",
        "count       = 0     # count for the number of images\n",
        "\n",
        "#\n",
        "# normalize the values of the input data to be [0, 1]\n",
        "#\n",
        "def normalize(data):\n",
        "\n",
        "    data_normalized = (data - min(data)) / (max(data) - min(data))\n",
        "\n",
        "    return(data_normalized)\n",
        "\n",
        "#\n",
        "# example of distance function between two vectors x and y\n",
        "#\n",
        "def distance(x, y):\n",
        "\n",
        "    d = (x - y) ** 2\n",
        "    s = np.sum(d)\n",
        "    # r = np.sqrt(s)\n",
        "\n",
        "    return(s)\n",
        "\n",
        "#\n",
        "# make a matrix each column of which represents an images in a vector form\n",
        "#\n",
        "list_image  = np.empty((size_row * size_col, num_image), dtype=float)\n",
        "list_label  = np.empty(num_image, dtype=int)\n",
        "\n",
        "for line in data:\n",
        "\n",
        "    line_data   = line.split(',')\n",
        "    label       = line_data[0]\n",
        "    im_vector   = np.asfarray(line_data[1:])\n",
        "    im_vector   = normalize(im_vector)\n",
        "\n",
        "    list_label[count]       = label\n",
        "    list_image[:, count]    = im_vector\n",
        "\n",
        "    count += 1\n",
        "\n",
        "#\n",
        "# plot first 150 images out of 10,000 with their labels\n",
        "#\n",
        "f1 = plt.figure(1)\n",
        "\n",
        "for i in range(150):\n",
        "\n",
        "    label       = list_label[i]\n",
        "    im_vector   = list_image[:, i]\n",
        "    im_matrix   = im_vector.reshape((size_row, size_col))\n",
        "\n",
        "    plt.subplot(10, 15, i+1)\n",
        "    plt.title(label)\n",
        "    plt.imshow(im_matrix, cmap='Greys', interpolation='None')\n",
        "\n",
        "    frame   = plt.gca()\n",
        "    frame.axes.get_xaxis().set_visible(False)\n",
        "    frame.axes.get_yaxis().set_visible(False)\n",
        "\n",
        "\n",
        "#plt.show()\n",
        "\n",
        "#\n",
        "# plot the average image of all the images for each digit\n",
        "#\n",
        "f2 = plt.figure(2)\n",
        "\n",
        "im_average  = np.zeros((size_row * size_col, 10), dtype=float)\n",
        "im_count    = np.zeros(10, dtype=int)\n",
        "\n",
        "for i in range(num_image):\n",
        "\n",
        "    im_average[:, list_label[i]] += list_image[:, i]\n",
        "    im_count[list_label[i]] += 1\n",
        "\n",
        "for i in range(10):\n",
        "\n",
        "    im_average[:, i] /= im_count[i]\n",
        "\n",
        "    plt.subplot(2, 5, i+1)\n",
        "    plt.title(i)\n",
        "    plt.imshow(im_average[:,i].reshape((size_row, size_col)), cmap='Greys', interpolation='None')\n",
        "\n",
        "    frame   = plt.gca()\n",
        "    frame.axes.get_xaxis().set_visible(False)\n",
        "    frame.axes.get_yaxis().set_visible(False)\n",
        "\n",
        "plt.show()\n",
        "\n"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
            "  import pandas.util.testing as tm\n",
            "/usr/local/lib/python3.6/dist-packages/sklearn/utils/deprecation.py:144: FutureWarning: The sklearn.datasets.samples_generator module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.datasets. Anything that cannot be imported from sklearn.datasets is now part of the private API.\n",
            "  warnings.warn(message, FutureWarning)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-a1c6ddc6-b837-4e5f-bbcc-191c0aaeef17\" name=\"files[]\" multiple disabled />\n",
              "     <output id=\"result-a1c6ddc6-b837-4e5f-bbcc-191c0aaeef17\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Saving mnist.csv to mnist.csv\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 150 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 10 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b_YcDHFWIRFP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "theta = np.random.normal(size=(size_row*size_col))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DemnhlAQP0XJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def sigmoid(z): \n",
        "  g = 1 / (1 + np.exp(-z)) \n",
        "  \n",
        "  return g "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DRugdPmoP2G5",
        "colab_type": "code",
        "outputId": "92e44ed5-5c9b-4fea-8f1d-4c72dc4a8878",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "z_list = []\n",
        "for i in range(0, 10):\n",
        "  z_list.append(0.0)\n",
        "\n",
        "print(z_list)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xtbUZT3IP28F",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(0, num_image):\n",
        "  label       = list_label[i]\n",
        "  im_vector   = list_image[:, i]\n",
        "  im_matrix   = im_vector.reshape((size_row, size_col))\n",
        "  y = 0\n",
        "  for ny in range(0, size_row):\n",
        "      for nz in range(0, size_col):\n",
        "        y = y + theta[size_col*ny + nz]*im_matrix[ny][nz]\n",
        "  # print(y)\n",
        "  z_list[label] = z_list[label] + sigmoid(y)\n",
        "  # print(sigmoid(y))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OWQYa_g6P4H2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#평균내기\n",
        "\n",
        "# for i in range(0, 10):\n",
        "  # z_list[i] = z_list[i] / label_list[i]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WUWOjwQQTDdR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#first hidden layer로 가기 위한 초기 fully connected u 생성\n",
        "w_tmp = np.ones(shape=(1000, 197, 785))\n",
        "v_tmp = np.ones(shape=(1000, 50, 197))\n",
        "u_tmp = np.ones(shape=(1000, 10, 50))\n",
        "\n",
        "matrix_u = np.zeros((197, 785))  #197줄\n",
        "matrix_u[0][0] = 1               #y레이어의 bias를 위한 값 1\n",
        "\n",
        "for i in range(1, 197):\n",
        "  for j in range(0, 785):\n",
        "    matrix_u[i][j] = np.random.normal()\n",
        "\n",
        "\n",
        "# matrix_u[196][0] = 0            #줄, 칸\n",
        "##############################################\n",
        "matrix_v = np.zeros((50, 197))  #50줄\n",
        "matrix_v[0][0] = 1               #y레이어의 bias를 위한 값 1\n",
        "\n",
        "for i in range(1, 50):\n",
        "  for j in range(0, 197):\n",
        "    matrix_v[i][j] = np.random.normal()\n",
        "\n",
        "\n",
        "# matrix_v[196][0] = 0            #줄, 칸\n",
        "##############################################\n",
        "matrix_w = np.zeros((10, 50))  #10줄\n",
        "# matrix_w[0][0] = 1               #y레이어의 bias를 위한 값 1\n",
        "\n",
        "for i in range(0, 10):\n",
        "  for j in range(0, 50):\n",
        "    matrix_w[i][j] = np.random.normal()\n",
        "\n",
        "w_tmp = matrix_w\n",
        "v_tmp = matrix_v\n",
        "u_tmp = matrix_u\n",
        "\n",
        "# matrix_w[196][0] = 0            #줄, 칸\n",
        "\n",
        "# print(matrix)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "idHIKSRGY0p9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import operator\n",
        "\n",
        "y_ = np.ones((197, 1))\n",
        "\n",
        "x_list = np.ones(shape=(1000, 785, 1))\n",
        "\n",
        "y__list = np.ones(shape=(1000, 197, 1))\n",
        "z__list = np.ones(shape=(1000, 50, 1))\n",
        "h__list = np.ones(shape=(1000, 10, 1))\n",
        "\n",
        "y_list = np.ones(shape=(1000, 197, 1))\n",
        "z_list = np.ones(shape=(1000, 50, 1))\n",
        "h_list = np.ones(shape=(1000, 10, 1))\n",
        "l_list = np.zeros(shape=(1000, 10, 1))\n",
        "\n",
        "y_list_tmp = np.ones(shape=(1000, 197, 1))\n",
        "z_list_tmp = np.ones(shape=(1000, 50, 1))\n",
        "h_list_tmp = np.ones(shape=(1000, 10, 1))\n",
        "y__list_tmp = np.ones(shape=(1000, 197, 1))\n",
        "z__list_tmp = np.ones(shape=(1000, 50, 1))\n",
        "h__list_tmp = np.ones(shape=(1000, 10, 1))\n",
        "\n",
        "# w_tmp = np.ones(shape=(1000, 197, 785))\n",
        "# v_tmp = np.ones(shape=(1000, 50, 197))\n",
        "# u_tmp = np.ones(shape=(1000, 10, 50))\n",
        "\n",
        "# matrix_u = np.zeros((197, 785))  #197줄\n",
        "# matrix_u[0][0] = 1               #y레이어의 bias를 위한 값 1\n",
        "\n",
        "\n",
        "#training set 1000개에 대해서\n",
        "for i in range(0, 1000):\n",
        "  # print(i)\n",
        "  label       = list_label[i]\n",
        "  bias   = [1]       #bias 1\n",
        "  im_vector = np.concatenate((bias, list_image[:, i]), axis = None)\n",
        "\n",
        "  # print(type(list_image[: , i]))\n",
        "  # print(list_image[:, i])\n",
        "  # print(im_vector)\n",
        "  im_matrix   = im_vector.reshape((size_row*size_col + 1, 1))\n",
        "  \n",
        "  x_list[i] = im_matrix\n",
        "\n",
        "  y_ = np.dot(matrix_u, im_matrix)  #x와 가중치 u를 곱해서 y_를 만듦\n",
        "  y__list[i] = y_\n",
        "  \n",
        "  y_vector = np.ones((197,1)) #bias\n",
        "  for j in range (1, 197):\n",
        "    y_vector[j][0] = 1 / (1 + math.exp(-y_[j][0]))\n",
        "    # sigmoid(y_[j][0])  #sigmoid 함수를 적용해서 y_에서 y를 만듦\n",
        "\n",
        "  y   = y_vector.reshape((197, 1))\n",
        "  y_list[i] = y\n",
        "\n",
        "  z_  = np.dot(matrix_v, y)  #y와 가중치 v를 곱해서 z_를 만듦\n",
        "  z__list[i] = z_\n",
        "  z_vector = np.ones((50,1)) #bias\n",
        "  for j in range (1, 50):\n",
        "    z_vector[j][0] = 1 / (1 + math.exp(-z_[j][0]))  #sigmoid 함수를 적용해서 y_에서 y를 만듦\n",
        "\n",
        "  z   = z_vector.reshape((50, 1))\n",
        "  z_list[i] = z\n",
        "  \n",
        "  # print(z)\n",
        "\n",
        "  h_  = np.dot(matrix_w, z)  #z와 가중치 w를 곱해서 h_를 만듦\n",
        "  h__list[i] = h_\n",
        "  \n",
        "  h_vector = np.ones((10,1)) #bias\n",
        "  for j in range (0, 10):\n",
        "    h_vector[j][0] = 1 / (1 + math.exp(-h_[j][0]))  #sigmoid 함수를 적용해서 h_에서 h를 만듦\n",
        "\n",
        "  h   = h_vector.reshape((10, 1))\n",
        "  # tmp = h.ravel()\n",
        "  # max_value = max(tmp)\n",
        "  # print(max_value)\n",
        "  # max_index = tmp.index(max_value)\n",
        "  index, value = max(enumerate(h), key=operator.itemgetter(1))\n",
        "  h_list[i] = h\n",
        "  l_list[i][index] = 1\n",
        "  # print(l_list[i])\n",
        "  # print(h)\n",
        "\n",
        "  y_list_tmp[i] = y_list[i]\n",
        "  z_list_tmp[i] = z_list[i]\n",
        "  h_list_tmp[i] = h_list[i]\n",
        "  y__list_tmp[i] = y__list[i]\n",
        "  z__list_tmp[i] = z__list[i]\n",
        "  h__list_tmp[i] = h__list[i]\n",
        "\n",
        "# print(l_list)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i1AbB1lMv1yY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def objective_function(size, label_List, h_List):\n",
        "  result = 0.0\n",
        "  for i in range(0, size):\n",
        "    for k in range(0, 10):\n",
        "      result = result + ((-1)*label_List[i][k]*math.log(h_List[i][k][0]) - (1-label_List[i][k])*math.log(1-h_List[i][k][0]))\n",
        "  result = result / size\n",
        "\n",
        "  return result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z7uMF29V6ZAh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def w_gredient_descent(learning_rate, k_value, n_value, size, label_List):\n",
        "  result = 0.0\n",
        "  for i in range(0, size):\n",
        "    result = result + (z_list_tmp[i][n_value][0]*(sigmoid(h_list_tmp[i][k_value][0]) - label_List[i][k_value][0]))\n",
        "  result = result / size\n",
        "  result = result * learning_rate\n",
        "  final = w_tmp[k_value][n_value] - result\n",
        "\n",
        "  return final"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FQMnniqxLxzl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def v_gredient_descent(learning_rate, k_value, n_value, size, label_List):\n",
        "  result = 0.0\n",
        "  for i in range(0, size):\n",
        "    result = result + (y_list_tmp[i][n_value][0]*w_tmp[0][k_value]*(sigmoid(h_list_tmp[i][0][0]) - label_List[i][0][0])*(sigmoid(z__list_tmp[i][k_value][0])*(1 - sigmoid(z__list_tmp[i][k_value][0]))))\n",
        "  result = result / size\n",
        "  result = result * learning_rate\n",
        "  final = v_tmp[k_value][n_value] - result\n",
        "\n",
        "  return final"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UabSYhhIO6JU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def u_gredient_descent(learning_rate, k_value, n_value, size, label_List):\n",
        "  result = 0.0\n",
        "  for i in range(0, size):\n",
        "    result = result + (x_list[i][n_value][0]*w_tmp[0][1]*v_tmp[1][k_value]*(sigmoid(h_list_tmp[i][0][0]) - label_List[i][0][0])*(sigmoid(z__list_tmp[i][1][0])*(1 - sigmoid(z__list_tmp[i][1][0])))*(sigmoid(y__list_tmp[i][k_value][0])*(1 - sigmoid(y__list_tmp[i][k_value][0]))))\n",
        "  result = result / size\n",
        "  result = result * learning_rate\n",
        "  final = u_tmp[k_value][n_value] - result\n",
        "\n",
        "  return final"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0vn3FkYXStur",
        "colab_type": "code",
        "outputId": "33ec222a-c837-4c43-bfff-29fdae8fea9e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 55
        }
      },
      "source": [
        "#이제 여기에다가\n",
        "\n",
        "#iteration에 따라\n",
        "#cost function 값을 배열에 저장하고\n",
        "#세타값을 업데이트 시키고(위의 세개 함수 호출)\n",
        "#업데이트 시킨값을 다시 cost함수에 넣고\n",
        "#업데이트 시키고\n",
        "#이것을 반복하는 함수를 짠다.\n",
        "\n",
        "#아직 해야하는 것 : h값에 따라 가장 큰값의 index로 L값정하는거 위에 추가해야함.\n",
        "\n",
        "iteration = 500\n",
        "l_r = 0.1\n",
        "\n",
        "cost_history = np.zeros(iteration)\n",
        "\n",
        "total_number_of_predictions = 1000\n",
        "accuracy_history = np.zeros(iteration)\n",
        "\n",
        "# small_delta = np.ones(3)  #image_size, layer 2~4(3개)\n",
        "# greece_delta_w = np.ones(shape = (10, 50))\n",
        "# greece_delta_v = np.ones(shape = (50, 197))\n",
        "# greece_delta_u = np.ones(shape = (197, 785))\n",
        "\n",
        "label_group = np.zeros(shape = (1000, 10))\n",
        "\n",
        "for i in range(0, 1000):\n",
        "  label       = list_label[i]\n",
        "  im_vector   = list_image[:, i]\n",
        "\n",
        "  # X[i] = im_vector\n",
        "  # print(i)\n",
        "  # print(X[i])\n",
        "  label_group[i][label] = 1\n",
        "\n",
        "for t in range(0, iteration):\n",
        "  number_of_correct_predictions = 0\n",
        "  \n",
        "  print(t, end=' ')\n",
        "\n",
        "  # cost_history[t] = objective_function(1000, l_list, h_list_tmp)\n",
        "  result = 0.0\n",
        "  for i in range(0, 1000):\n",
        "    for k in range(0, 10):\n",
        "      # if h_list_tmp[i][k][0] <= 0:\n",
        "      # print(h_list_tmp[i][k][0])\n",
        "      result = result + ((-1)*label_group[i][k]*math.log(h_list[i][k][0]) - (1-label_group[i][k])*math.log(1-h_list[i][k][0]))\n",
        "  result = result / 1000\n",
        "  cost_history[t] = result\n",
        "\n",
        "# (1 / (1 + math.exp(-y__list_tmp[i][m][0])))\n",
        "#############################################\n",
        "  # for m in range(0, 10):\n",
        "  #   # print(m)\n",
        "  #   for n in range(0, 50):\n",
        "  #     # matrix_w[m][n] = w_gredient_descent(l_r, m, n, 1000, l_list)\n",
        "  #     result = 0.0\n",
        "  #     for i in range(0,1000):\n",
        "  #       result = result + (z_list_tmp[i][n][0]*((1 / (1 + math.exp(-h_list_tmp[i][m][0]))) - l_list[i][m][0]))\n",
        "  #     result = result / 1000\n",
        "  #     result = result * l_r\n",
        "  #     final = w_tmp[m][n] - result\n",
        "  #     matrix_w[m][n] = final\n",
        "\n",
        "  # for m in range(0, 50):\n",
        "  #   # print(m)\n",
        "  #   for n in range(0, 197):\n",
        "  #     # matrix_v[m][n] = v_gredient_descent(l_r, m, n, 1000, l_list)\n",
        "  #     result = 0.0\n",
        "  #     for i in range(0, 1000):\n",
        "  #       result = result + (y_list_tmp[i][n][0]*w_tmp[0][m]*((1 / (1 + math.exp(-h_list_tmp[i][0][0]))) - l_list[i][0][0])*((1 / (1 + math.exp(-z__list_tmp[i][m][0])))*(1 - (1 / (1 + math.exp(-z__list_tmp[i][m][0]))))))\n",
        "  #     result = result / 1000\n",
        "  #     result = result * l_r\n",
        "  #     final = v_tmp[m][n] - result\n",
        "  #     matrix_v[m][n] = final\n",
        "\n",
        "  # for m in range(0, 197):\n",
        "  #   # print(m)\n",
        "  #   for n in range(0, 785):\n",
        "  #     # matrix_u[m][n] = u_gredient_descent(l_r, m, n, 1000, l_list)\n",
        "  #     result = 0.0\n",
        "  #     for i in range(0, 1000):\n",
        "  #       result = result + (x_list[i][n][0]*w_tmp[0][1]*v_tmp[1][m]*((1 / (1 + math.exp(-h_list_tmp[i][0][0]))) - l_list[i][0][0])*((1 / (1 + math.exp(-z__list_tmp[i][1][0])))*(1 - (1 / (1 + math.exp(-z__list_tmp[i][1][0])))))*((1 / (1 + math.exp(-y__list_tmp[i][m][0])))*(1 - (1 / (1 + math.exp(-y__list_tmp[i][m][0]))))))\n",
        "  #     result = result / 1000\n",
        "  #     result = result * l_r\n",
        "  #     final = u_tmp[m][n] - result\n",
        "  #     matrix_u[m][n] = final\n",
        "#######################################################################\n",
        "##gradient descent\n",
        "  result_w = 0\n",
        "  result_v = 0\n",
        "  result_u = 0\n",
        "\n",
        "  for i in range(0, 1000):\n",
        "    small_delta_2 = np.zeros(shape = (10, 1))\n",
        "    for j in range(0, 10):\n",
        "      small_delta_2[j][0] = h_list[i][j] - label_group[i][j]\n",
        "    # print(h_list[i])\n",
        "    # print(label_group[i])\n",
        "    # small_delta_2 = h_list[i] - label_group[i] #여기 label_group 다시 봐야함.\n",
        "    small_delta_1 = np.dot(np.transpose(matrix_w), small_delta_2)\n",
        "    small_delta_0 = np.dot(np.transpose(matrix_v), small_delta_1)*(y_list_tmp[i]*(1 - y_list_tmp[i]))\n",
        "\n",
        "    # print(small_delta_2)\n",
        "    result_w = result_w + np.dot(small_delta_2, np.transpose(z_list[i]))\n",
        "    result_v = result_v + np.dot(small_delta_1, np.transpose(y_list[i]))\n",
        "    result_u = result_u + np.dot(small_delta_0, np.transpose(x_list[i]))\n",
        "\n",
        "  matrix_w = matrix_w - (result_w / 1000 *l_r)\n",
        "  matrix_v = matrix_v - (result_v / 1000 *l_r)\n",
        "  matrix_u = matrix_u - (result_u / 1000 *l_r)\n",
        "\n",
        "\n",
        "####################################################################\n",
        "\n",
        "  for k in range(0, 1000):\n",
        "  # print(i)\n",
        "    label       = list_label[k]\n",
        "    bias   = [1]       #bias 1\n",
        "    im_vector = np.concatenate((bias, list_image[:, k]), axis = None)\n",
        "\n",
        "    # print(type(list_image[: , k]))\n",
        "    # print(list_image[:, k])\n",
        "    # print(im_vector)\n",
        "    im_matrix   = im_vector.reshape((size_row*size_col + 1, 1))\n",
        "\n",
        "    y_ = np.dot(matrix_u, im_matrix)  #x와 가중치 u를 곱해서 y_를 만듦\n",
        "    y__list[k] = y_\n",
        "    \n",
        "    y_vector = np.ones((197,1)) #bias\n",
        "    for j in range (1, 197):\n",
        "      y_vector[j][0] = 1 / (1 + math.exp(-y_[j][0]))  #sigmoid 함수를 적용해서 y_에서 y를 만듦\n",
        "    \n",
        "    # print(y_vector) #시그모이드 값 확인\n",
        "    y   = y_vector.reshape((197, 1))\n",
        "    y_list[k] = y\n",
        "\n",
        "    z_  = np.dot(matrix_v, y)  #y와 가중치 v를 곱해서 z_를 만듦\n",
        "    z__list[k] = z_\n",
        "    z_vector = np.ones((50,1)) #bias\n",
        "    for j in range (1, 50):\n",
        "      z_vector[j][0] = 1 / (1 + math.exp(-z_[j][0]))  #sigmoid 함수를 적용해서 y_에서 y를 만듦\n",
        "\n",
        "    z   = z_vector.reshape((50, 1))\n",
        "    z_list[k] = z\n",
        "    \n",
        "    # print(z)\n",
        "\n",
        "    h_  = np.dot(matrix_w, z)  #z와 가중치 w를 곱해서 h_를 만듦\n",
        "    h__list[k] = h_\n",
        "    \n",
        "    h_vector = np.ones((10,1)) #bias\n",
        "    for j in range (0, 10):\n",
        "      h_vector[j][0] = 1 / (1 + math.exp(-h_[j][0]))  #sigmoid 함수를 적용해서 h_에서 h를 만듦\n",
        "\n",
        "    h   = h_vector.reshape((10, 1))\n",
        "    # print(h)\n",
        "    # tmp = h.ravel()\n",
        "    # max_value = max(tmp)\n",
        "    # print(max_value)\n",
        "    # max_index = tmp.index(max_value)\n",
        "    index, value = max(enumerate(h), key=operator.itemgetter(1))\n",
        "    h_list[k] = h\n",
        "    l_list[k][index] = 1\n",
        "    # print(l_list[i])\n",
        "    # print(h)\n",
        "    if index == label:\n",
        "      number_of_correct_predictions = number_of_correct_predictions + 1\n",
        "\n",
        "    y_list_tmp[k] = y_list[k]\n",
        "    z_list_tmp[k] = z_list[k]\n",
        "    h_list_tmp[k] = h_list[k]\n",
        "    y__list_tmp[k] = y__list[k]\n",
        "    z__list_tmp[k] = z__list[k]\n",
        "    h__list_tmp[k] = h__list[k]\n",
        "\n",
        "\n",
        "  accuracy_history[t] = number_of_correct_predictions/total_number_of_predictions*100\n",
        "  # print(accuracy_history[t])\n",
        "  t = t + 1"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kFfy7dv5_YR8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import operator\n",
        "\n",
        "y_ = np.ones((197, 1))\n",
        "\n",
        "x_list = np.ones(shape=(9000, 785, 1))\n",
        "\n",
        "y__list = np.ones(shape=(9000, 197, 1))\n",
        "z__list = np.ones(shape=(9000, 50, 1))\n",
        "h__list = np.ones(shape=(9000, 10, 1))\n",
        "\n",
        "y_list = np.ones(shape=(9000, 197, 1))\n",
        "z_list = np.ones(shape=(9000, 50, 1))\n",
        "h_list = np.ones(shape=(9000, 10, 1))\n",
        "l_list = np.zeros(shape=(9000, 10, 1))\n",
        "\n",
        "y_list_tmp = np.ones(shape=(9000, 197, 1))\n",
        "z_list_tmp = np.ones(shape=(9000, 50, 1))\n",
        "h_list_tmp = np.ones(shape=(9000, 10, 1))\n",
        "y__list_tmp = np.ones(shape=(9000, 197, 1))\n",
        "z__list_tmp = np.ones(shape=(9000, 50, 1))\n",
        "h__list_tmp = np.ones(shape=(9000, 10, 1))\n",
        "\n",
        "# w_tmp = np.ones(shape=(9000, 197, 785))\n",
        "# v_tmp = np.ones(shape=(9000, 50, 197))\n",
        "# u_tmp = np.ones(shape=(9000, 10, 50))\n",
        "\n",
        "# matrix_u = np.zeros((197, 785))  #197줄\n",
        "# matrix_u[0][0] = 1               #y레이어의 bias를 위한 값 1\n",
        "\n",
        "\n",
        "#training set 1000개에 대해서\n",
        "for i in range(0, 9000):\n",
        "  # print(i)\n",
        "  label       = list_label[i + 1000]\n",
        "  bias   = [1]       #bias 1\n",
        "  im_vector = np.concatenate((bias, list_image[:, i + 1000]), axis = None)\n",
        "\n",
        "  # print(type(list_image[: , i]))\n",
        "  # print(list_image[:, i])\n",
        "  # print(im_vector)\n",
        "  im_matrix   = im_vector.reshape((size_row*size_col + 1, 1))\n",
        "  \n",
        "  x_list[i] = im_matrix\n",
        "\n",
        "  y_ = np.dot(matrix_u, im_matrix)  #x와 가중치 u를 곱해서 y_를 만듦\n",
        "  y__list[i] = y_\n",
        "  \n",
        "  y_vector = np.ones((197,1)) #bias\n",
        "  for j in range (1, 197):\n",
        "    y_vector[j][0] = 1 / (1 + math.exp(-y_[j][0]))\n",
        "    # sigmoid(y_[j][0])  #sigmoid 함수를 적용해서 y_에서 y를 만듦\n",
        "\n",
        "  y   = y_vector.reshape((197, 1))\n",
        "  y_list[i] = y\n",
        "\n",
        "  z_  = np.dot(matrix_v, y)  #y와 가중치 v를 곱해서 z_를 만듦\n",
        "  z__list[i] = z_\n",
        "  z_vector = np.ones((50,1)) #bias\n",
        "  for j in range (1, 50):\n",
        "    z_vector[j][0] = 1 / (1 + math.exp(-z_[j][0]))  #sigmoid 함수를 적용해서 y_에서 y를 만듦\n",
        "\n",
        "  z   = z_vector.reshape((50, 1))\n",
        "  z_list[i] = z\n",
        "  \n",
        "  # print(z)\n",
        "\n",
        "  h_  = np.dot(matrix_w, z)  #z와 가중치 w를 곱해서 h_를 만듦\n",
        "  h__list[i] = h_\n",
        "  \n",
        "  h_vector = np.ones((10,1)) #bias\n",
        "  for j in range (0, 10):\n",
        "    h_vector[j][0] = 1 / (1 + math.exp(-h_[j][0]))  #sigmoid 함수를 적용해서 h_에서 h를 만듦\n",
        "\n",
        "  h   = h_vector.reshape((10, 1))\n",
        "  # tmp = h.ravel()\n",
        "  # max_value = max(tmp)\n",
        "  # print(max_value)\n",
        "  # max_index = tmp.index(max_value)\n",
        "  index, value = max(enumerate(h), key=operator.itemgetter(1))\n",
        "  h_list[i] = h\n",
        "  l_list[i][index] = 1\n",
        "  # print(l_list[i])\n",
        "  # print(h)\n",
        "\n",
        "  y_list_tmp[i] = y_list[i]\n",
        "  z_list_tmp[i] = z_list[i]\n",
        "  h_list_tmp[i] = h_list[i]\n",
        "  y__list_tmp[i] = y__list[i]\n",
        "  z__list_tmp[i] = z__list[i]\n",
        "  h__list_tmp[i] = h__list[i]\n",
        "\n",
        "# print(l_list)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nzuVCwhp-DLC",
        "colab_type": "code",
        "outputId": "14ac2655-6143-4eb2-e69f-af759d5c2f8b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 55
        }
      },
      "source": [
        "#test data!\n",
        "\n",
        "cost_history2 = np.zeros(iteration)\n",
        "\n",
        "total_number_of_predictions2 = 9000\n",
        "accuracy_history2 = np.zeros(iteration)\n",
        "\n",
        "# small_delta = np.ones(3)  #image_size, layer 2~4(3개)\n",
        "# greece_delta_w = np.ones(shape = (10, 50))\n",
        "# greece_delta_v = np.ones(shape = (50, 197))\n",
        "# greece_delta_u = np.ones(shape = (197, 785))\n",
        "\n",
        "label_group2 = np.zeros(shape = (9000, 10))\n",
        "\n",
        "for i in range(1000, 10000):\n",
        "  label       = list_label[i]\n",
        "  im_vector   = list_image[:, i]\n",
        "\n",
        "  # X[i] = im_vector\n",
        "  # print(i)\n",
        "  # print(X[i])\n",
        "  label_group2[i - 1000][label] = 1\n",
        "\n",
        "for t in range(0, iteration):\n",
        "  number_of_correct_predictions2 = 0\n",
        "  \n",
        "  print(t, end=' ')\n",
        "\n",
        "  # cost_history[t] = objective_function(1000, l_list, h_list_tmp)\n",
        "  result = 0.0\n",
        "  for i in range(0, 9000):\n",
        "    for k in range(0, 10):\n",
        "      # if h_list_tmp[i][k][0] <= 0:\n",
        "      # print(h_list_tmp[i][k][0])\n",
        "      result = result + ((-1)*label_group2[i][k]*math.log(h_list[i][k][0]) - (1-label_group2[i][k])*math.log(1-h_list[i][k][0]))\n",
        "  result = result / 9000\n",
        "  cost_history2[t] = result\n",
        "\n",
        "# (1 / (1 + math.exp(-y__list_tmp[i][m][0])))\n",
        "#############################################\n",
        "  # for m in range(0, 10):\n",
        "  #   # print(m)\n",
        "  #   for n in range(0, 50):\n",
        "  #     # matrix_w[m][n] = w_gredient_descent(l_r, m, n, 6000, l_list)\n",
        "  #     result = 0.0\n",
        "  #     for i in range(0,6000):\n",
        "  #       result = result + (z_list_tmp[i][n][0]*((1 / (1 + math.exp(-h_list_tmp[i][m][0]))) - l_list[i][m][0]))\n",
        "  #     result = result / 6000\n",
        "  #     result = result * l_r\n",
        "  #     final = w_tmp[m][n] - result\n",
        "  #     matrix_w[m][n] = final\n",
        "\n",
        "  # for m in range(0, 50):\n",
        "  #   # print(m)\n",
        "  #   for n in range(0, 197):\n",
        "  #     # matrix_v[m][n] = v_gredient_descent(l_r, m, n, 6000, l_list)\n",
        "  #     result = 0.0\n",
        "  #     for i in range(0, 6000):\n",
        "  #       result = result + (y_list_tmp[i][n][0]*w_tmp[0][m]*((1 / (1 + math.exp(-h_list_tmp[i][0][0]))) - l_list[i][0][0])*((1 / (1 + math.exp(-z__list_tmp[i][m][0])))*(1 - (1 / (1 + math.exp(-z__list_tmp[i][m][0]))))))\n",
        "  #     result = result / 6000\n",
        "  #     result = result * l_r\n",
        "  #     final = v_tmp[m][n] - result\n",
        "  #     matrix_v[m][n] = final\n",
        "\n",
        "  # for m in range(0, 197):\n",
        "  #   # print(m)\n",
        "  #   for n in range(0, 785):\n",
        "  #     # matrix_u[m][n] = u_gredient_descent(l_r, m, n, 6000, l_list)\n",
        "  #     result = 0.0\n",
        "  #     for i in range(0, 6000):\n",
        "  #       result = result + (x_list[i][n][0]*w_tmp[0][1]*v_tmp[1][m]*((1 / (1 + math.exp(-h_list_tmp[i][0][0]))) - l_list[i][0][0])*((1 / (1 + math.exp(-z__list_tmp[i][1][0])))*(1 - (1 / (1 + math.exp(-z__list_tmp[i][1][0])))))*((1 / (1 + math.exp(-y__list_tmp[i][m][0])))*(1 - (1 / (1 + math.exp(-y__list_tmp[i][m][0]))))))\n",
        "  #     result = result / 6000\n",
        "  #     result = result * l_r\n",
        "  #     final = u_tmp[m][n] - result\n",
        "  #     matrix_u[m][n] = final\n",
        "#######################################################################\n",
        "##gradient descent\n",
        "  result_w = 0\n",
        "  result_v = 0\n",
        "  result_u = 0\n",
        "\n",
        "  for i in range(0, 9000):\n",
        "    small_delta_2 = np.zeros(shape = (10, 1))\n",
        "    for j in range(0, 10):\n",
        "      small_delta_2[j][0] = h_list[i][j] - label_group2[i][j]\n",
        "    # print(h_list[i])\n",
        "    # print(label_group[i])\n",
        "    # small_delta_2 = h_list[i] - label_group[i] #여기 label_group 다시 봐야함.\n",
        "    small_delta_1 = np.dot(np.transpose(matrix_w), small_delta_2)\n",
        "    small_delta_0 = np.dot(np.transpose(matrix_v), small_delta_1)*(y_list_tmp[i]*(1 - y_list_tmp[i]))\n",
        "\n",
        "    # print(small_delta_2)\n",
        "    result_w = result_w + np.dot(small_delta_2, np.transpose(z_list[i]))\n",
        "    result_v = result_v + np.dot(small_delta_1, np.transpose(y_list[i]))\n",
        "    result_u = result_u + np.dot(small_delta_0, np.transpose(x_list[i]))\n",
        "\n",
        "  matrix_w = matrix_w - (result_w / 9000 *l_r)\n",
        "  matrix_v = matrix_v - (result_v / 9000 *l_r)\n",
        "  matrix_u = matrix_u - (result_u / 9000 *l_r)\n",
        "\n",
        "\n",
        "####################################################################\n",
        "\n",
        "  for k in range(0, 9000):\n",
        "  # print(i)\n",
        "    label       = list_label[k + 1000]\n",
        "    bias   = [1]       #bias 1\n",
        "    im_vector = np.concatenate((bias, list_image[:, k + 1000]), axis = None)\n",
        "\n",
        "    # print(type(list_image[: , k]))\n",
        "    # print(list_image[:, k])\n",
        "    # print(im_vector)\n",
        "    im_matrix   = im_vector.reshape((size_row*size_col + 1, 1))\n",
        "\n",
        "    y_ = np.dot(matrix_u, im_matrix)  #x와 가중치 u를 곱해서 y_를 만듦\n",
        "    y__list[k] = y_\n",
        "    \n",
        "    y_vector = np.ones((197,1)) #bias\n",
        "    for j in range (1, 197):\n",
        "      y_vector[j][0] = 1 / (1 + math.exp(-y_[j][0]))  #sigmoid 함수를 적용해서 y_에서 y를 만듦\n",
        "    \n",
        "    # print(y_vector) #시그모이드 값 확인\n",
        "    y   = y_vector.reshape((197, 1))\n",
        "    y_list[k] = y\n",
        "\n",
        "    z_  = np.dot(matrix_v, y)  #y와 가중치 v를 곱해서 z_를 만듦\n",
        "    z__list[k] = z_\n",
        "    z_vector = np.ones((50,1)) #bias\n",
        "    for j in range (1, 50):\n",
        "      z_vector[j][0] = 1 / (1 + math.exp(-z_[j][0]))  #sigmoid 함수를 적용해서 y_에서 y를 만듦\n",
        "\n",
        "    z   = z_vector.reshape((50, 1))\n",
        "    z_list[k] = z\n",
        "    \n",
        "    # print(z)\n",
        "\n",
        "    h_  = np.dot(matrix_w, z)  #z와 가중치 w를 곱해서 h_를 만듦\n",
        "    h__list[k] = h_\n",
        "    \n",
        "    h_vector = np.ones((10,1)) #bias\n",
        "    for j in range (0, 10):\n",
        "      h_vector[j][0] = 1 / (1 + math.exp(-h_[j][0]))  #sigmoid 함수를 적용해서 h_에서 h를 만듦\n",
        "\n",
        "    h   = h_vector.reshape((10, 1))\n",
        "    # print(h)\n",
        "    # tmp = h.ravel()\n",
        "    # max_value = max(tmp)\n",
        "    # print(max_value)\n",
        "    # max_index = tmp.index(max_value)\n",
        "    index, value = max(enumerate(h), key=operator.itemgetter(1))\n",
        "    h_list[k] = h\n",
        "    l_list[k][index] = 1\n",
        "    # print(l_list[i])\n",
        "    # print(h)\n",
        "    if index == label:\n",
        "      number_of_correct_predictions2 = number_of_correct_predictions2 + 1\n",
        "\n",
        "    y_list_tmp[k] = y_list[k]\n",
        "    z_list_tmp[k] = z_list[k]\n",
        "    h_list_tmp[k] = h_list[k]\n",
        "    y__list_tmp[k] = y__list[k]\n",
        "    z__list_tmp[k] = z__list[k]\n",
        "    h__list_tmp[k] = h__list[k]\n",
        "\n",
        "\n",
        "  accuracy_history2[t] = number_of_correct_predictions2/total_number_of_predictions2*100\n",
        "  # print(accuracy_history2[t])\n",
        "  t = t + 1"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "81J4ESnphg--",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "wrong_images_index = np.ones(9000)\n",
        "right_images_index = np.ones(9000)\n",
        "\n",
        "wrong_images_value = np.ones(9000)\n",
        "right_images_value = np.ones(9000)\n",
        "\n",
        "wrong_images_num = 0\n",
        "right_images_num = 0\n",
        "\n",
        "for k in range(0, 9000):\n",
        "  # print(i)\n",
        "    label       = list_label[k + 1000]\n",
        "    bias   = [1]       #bias 1\n",
        "    im_vector = np.concatenate((bias, list_image[:, k + 1000]), axis = None)\n",
        "\n",
        "    # print(type(list_image[: , k]))\n",
        "    # print(list_image[:, k])\n",
        "    # print(im_vector)\n",
        "    im_matrix   = im_vector.reshape((size_row*size_col + 1, 1))\n",
        "    # print(h_list[real_iter - 1][0])\n",
        "    index, value = max(enumerate(h_list[k]), key=operator.itemgetter(1))\n",
        "    \n",
        "\n",
        "    # print(l_list[i])\n",
        "    # print(h)\n",
        "    if index == label:\n",
        "      right_images_index[right_images_num] = int(k + 1000)\n",
        "      right_images_value[right_images_num] = int(index)\n",
        "      right_images_num = right_images_num + 1\n",
        "    else:\n",
        "      wrong_images_index[wrong_images_num] = int(k + 1000)\n",
        "      wrong_images_value[wrong_images_num] = int(index)\n",
        "      wrong_images_num = wrong_images_num + 1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pMcbWdbh98uY",
        "colab_type": "text"
      },
      "source": [
        "# **Machine Learning Assignment09** #\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "Name : 이현주\n",
        "\n",
        "Student # : 20184060"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "CwXihsOJgZ0R"
      },
      "source": [
        "# **1. Plot the loss curve [10pt]**\n",
        "\n",
        "- plot the training loss at every iteration of gradient descent using the training data in blue color (the first 6,000 images) [5pt]\n",
        "- plot the testing loss at every iteration of gradient descent using the testing data in red color (the rest 4,000 images) [5pt]\n",
        "- the both curves should be presented in one figure"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DTouPM3uAf8Q",
        "colab_type": "code",
        "outputId": "bf1f78c1-2b3d-470b-d925-67f711bcfffd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 497
        }
      },
      "source": [
        "#그 코드를 바탕으로 training loss plotting 하기.\n",
        "real_iter = iteration\n",
        "\n",
        "fig,ax = plt.subplots(figsize=(12,8))\n",
        "\n",
        "cost_tmp = np.zeros(real_iter)\n",
        "\n",
        "for i in range(0, real_iter):\n",
        "  cost_tmp[i] = cost_history[i]\n",
        "\n",
        "\n",
        "# print(cost_history[1])\n",
        "\n",
        "ax.set_ylabel('J(Theta)')\n",
        "ax.set_xlabel('Iterations')\n",
        "_=ax.plot(range(real_iter),cost_tmp,'b.', color = 'blue')\n",
        "_=ax.plot(range(real_iter),cost_history2,'b.', color = 'red')"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "OiKcfzyYgaCF"
      },
      "source": [
        "# **2. Plot the accuracy curve [10pt]**\n",
        "\n",
        "- plot the training accuracy (%) at every iteration of gradient descent using the training data in blue color (the first 6,000 images) [5pt]\n",
        "- plot the testing accuracy (%) at every iteration of gradient descent using the testing data in red color (the rest 4,000 images) [5pt]\n",
        "- the both curves should be presented in one figure"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fF1EODxQAhri",
        "colab_type": "code",
        "outputId": "6fec2bb3-3eba-464b-9523-00c5f326d273",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 497
        }
      },
      "source": [
        "#그 코드를 바탕으로 training loss plotting 하기.\n",
        "fig,ax = plt.subplots(figsize=(12,8))\n",
        "\n",
        "# print(cost_history[1])\n",
        "\n",
        "ac_tmp = np.zeros(real_iter)\n",
        "\n",
        "for i in range(0, real_iter):\n",
        "  ac_tmp[i] = accuracy_history[i]\n",
        "\n",
        "ax.set_ylabel('accuracy')\n",
        "ax.set_xlabel('Iterations')\n",
        "_=ax.plot(range(real_iter),ac_tmp,'b.', color = 'blue')\n",
        "_=ax.plot(range(real_iter),accuracy_history2,'b.', color = 'red')\n",
        "# print(ac_tmp)"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "hf4SrnjSgaXp"
      },
      "source": [
        "# **3. Plot the accuracy value [4pt]**\n",
        "\n",
        "- print the final training accuracy (%) using the training data (the first 6,000 images) [2pt]\n",
        "- print the final testing accuracy (%) using the testing data (the rest 4,000 images) [2pt]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B2tcQNdPAluv",
        "colab_type": "code",
        "outputId": "1fee3d34-f39e-408b-e334-be21f936b20a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "print(\"final training accuracy using the training data : \", end = '')\n",
        "print(accuracy_history[-1], end = '%\\n')\n",
        "\n",
        "print(\"final training accuracy using the testing data : \", end = '')\n",
        "print(accuracy_history2[-1], end = '%\\n')"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "final training accuracy using the training data : 98.0%\n",
            "final training accuracy using the testing data : 92.52222222222221%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "dCAltdEPhHY_"
      },
      "source": [
        "# **4. Plot the classification example [10pt]**\n",
        "\n",
        "- present 10 correctly classified testing images with their labels at the title of each sub-figure in 2x5 array [5pt]\n",
        "- present 10 misclassified testing images with their misclassified labels at the title of each sub-figure in 2x5 array [5pt]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qxLgEta7hU9c",
        "colab_type": "code",
        "outputId": "c788f24c-a17a-4cb2-ab52-1225fd4bbec0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 525
        }
      },
      "source": [
        "\n",
        "print(\"**correctly classified testing images**\")\n",
        "for i in range(10):\n",
        "    # print(int(right_images_index[i]))\n",
        "    # print(h_list[int(right_images_index[i])])\n",
        "    label       = list_label[int(right_images_index[i])]\n",
        "    im_vector   = list_image[:, int(right_images_index[i])]\n",
        "    im_matrix   = im_vector.reshape((size_row, size_col))\n",
        "\n",
        "    plt.subplot(2, 5, i+1)\n",
        "    plt.title(int(right_images_value[i]))\n",
        "    plt.imshow(im_matrix, cmap='Greys', interpolation='None')\n",
        "\n",
        "    frame   = plt.gca()\n",
        "    frame.axes.get_xaxis().set_visible(False)\n",
        "    frame.axes.get_yaxis().set_visible(False)\n",
        "\n",
        "plt.show()\n",
        "print(\"\\n\\n\\n**misclassified testing images**\")\n",
        "for i in range(10):\n",
        "    # print(int(wrong_images_index[i]))\n",
        "    # print(h_list[int(right_images_index[i])])\n",
        "    label       = list_label[int(wrong_images_index[i])]\n",
        "    im_vector   = list_image[:, int(wrong_images_index[i])]\n",
        "    im_matrix   = im_vector.reshape((size_row, size_col))\n",
        "\n",
        "    plt.subplot(2, 5, i+1)\n",
        "    plt.title(int(wrong_images_value[i]))\n",
        "    plt.imshow(im_matrix, cmap='Greys', interpolation='None')\n",
        "\n",
        "    frame   = plt.gca()\n",
        "    frame.axes.get_xaxis().set_visible(False)\n",
        "    frame.axes.get_yaxis().set_visible(False)\n",
        "\n",
        "plt.show()\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "**correctly classified testing images**\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWAAAADSCAYAAAB0FBqGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAbl0lEQVR4nO3de5jVVfXH8fcSSAREQxTFC5iKeDfFSxo/8opapiKmCN5LRUArL2mCqaBhTyWaYmUKoqZZIpqZWmIadDGpHz55wUuCyk/kkqCgouL+/XFY8505zMgMnHPWd875vJ6HZ2bOnDksvpyzZ529117bUkqIiEjlrRMdgIhIrdIALCISRAOwiEgQDcAiIkE0AIuIBNEALCISRAOwiEiQXA7AZraDmU01syVm9rKZHRMdUx6YWRczu8/MlpnZHDM7MTqmSGa2rpndsvJavGtm/2tmh0fHFc3M/mRmH5jZ0pV/ZkXHFM3MhpvZ02a23MwmRsfjcjcAm1lb4H7gQaALcCZwh5n1Cg0sH24EPgS6AYOBm8xsp9iQQrUFXgf6ARsAI4F7zKxnYEx5MTyl1Gnln+2jg8mB/wPGALdGB1Jf7gZgoDfQHbg2pbQipTQVmA6cFBtWLDPrCBwLjEopLU0pTQMeoIavS0ppWUrp8pTS7JTSJymlB4FXgT2jY5N8SSlNTilNARZFx1JfHgfgxhiwc3QQwXoBH6eUXqx320ygljPgBsysG4Xr9Gx0LDnwfTNbaGbTzexL0cFI4/I4AM8C5gMXmlk7MzuUwlvMDrFhhesEvFN02xJg/YBYcsfM2gF3ArellF6IjifYd4DPAZsDPwd+a2bbxIYkjcndAJxS+gg4GvgyMA84H7gHeCMyrhxYCnQuuq0z8G5ALLliZusAt1OYHx8eHE64lNLfU0rvppSWp5RuozCFd0R0XLKq3A3AACmlZ1JK/VJKG6WU+lP4bf5UdFzBXgTamtl29W7bjRp/u21mBtxCYWHy2JW/wKWhRGEaT3ImlwOwme1qZu3NrIOZXQBsBkwMDitUSmkZMBm40sw6mtn+wFEUMr9adhOwA3BkSun96GCimdmGZtZ/5eunrZkNBv4HeDg6tkgrr0V7oA3Qxq9PdFy5HIAprOy/SWEu+CDgkJTS8tiQcuEcYD0K1+UuYGhKqWYzYDPrAZwF7A7Mq1f3Ojg4tEjtKJRbLQAWAiOAo4sWb2vRSOB94GJgyMrPR4ZGBJgasouIxMhrBiwiUvU0AIuIBNEALCISRAOwiEgQDcAiIkFaVAfXtWvX1LNnzzKFkg+zZ89m4cKFzS5ar4VrAjBjxoyFKaWNm3NfXZPG1cJ10euncU09V1o0APfs2ZOnn366dFHlUJ8+fVp0/1q4JgBmNqe599U1aVwtXBe9fhrX1HNFUxAiIkE0AIuIBNEALCISRAOwiEgQDcAiIkE0AIuIBAnvhynN9+GHHwLwr3/9C4B9990XgNNOOw2A008/HYAvfvGLAdFVxrvvFg4A+d3vftfg9kGDBgGwzjqfnlM8//zzAPTqpUO2JZ4yYBGRIMqAW5GHHnoIgIEDBwJZtjdp0iQApk+fDsAVV1wBwAknnFDpEMvGs/4jjzwSgHnz5jX4vl+LwglFTdtnn30AOPfcc4HsWrVW48ePB2DYsGElebwbb7wRgHPOOackjxdp9OjRAFx22WUAPProowAccsghYTEVUwYsIhJEGXCOzZ07F4CxY8cCcMcdd3zq/V955RUALrroIqC6MuD11lsPgPff//Rj3w444AAA2rdvD8B7770HwBNPPAHAO++8A8DNN98MwNChQ+t+dtNNNy1hxOV17LHHAjB58uSSPq5n0gcddFDdbdtvv31J/45ymzlzJgDXX389kL078tePMmAREclvBjx//nwAXnyxcJbgcccdB2Rzfz7Xd+GFFwJwzTXXVDrEsvPs5qabbmr0+2eddVaDjz5/9/DD1XcAbu/evYFsnnvx4sWN3m/PPfcEoF27dkCW8Xbp0qXB/fz59cEHH5Q+2AoodeZb7LHHHqv7vLVlwD42rK4iJg/yH6GISJXSACwiEiS3UxC+mOKF8664zOjaa68FYL/99gPgqKOOqkB05eULR2PGjGn0++effz6w6rTLgAEDAHjggQcaPE6HDh3KEmcEn4pornXXXReAY445Bij/W/dq0ZrL0HbddVcApk2bBmTPmaeeegrIpp822WSTgOgaUgYsIhIkdxnwSSedBMBLL73UrPt//PHHQLZNtxqMGDECgEWLFjW43TchXHXVVY3+nB/t8vbbbwNw4oknAnDXXXcBWSlXLfnb3/4GZJnvJ598AmQLNCmlmMDK7IUXXgAaLqZB6TZstAbbbbddg699THnrrbcAZcAiIjUtdxmwl1C1bVsIbcqUKQDstddeAFx99dUAXHfddQHRlZc3mvFNA26rrbYCsnI0vzbFfK5r/fXXB+DBBx8Est/4tXD4ofvDH/4AZBsWikuTvEjfr21r4/P9xXPafruXjhWXkBXP7c6aNQvIMuX6GzCq1Xe/+10Afvvb3wZHogxYRCRMbjLgBQsWAFlh/PHHHw/AEUccAWRzdW+88UZAdJXhW4lnz54NZNmaz+E2d6usNx/59re/DWTZzRlnnFGyWPPKq2b8+eOVIM7nQM8++2wA2rRpU8HoSscz1eIM2L/2Jj1N8Uy4qUy5mnl1xIwZM4Bs804EZcAiIkFykwF///vfB2DZsmUA3HfffQD84Ac/ALL5mnvvvbfRn3/55ZfLHWLZeCVHcWtEn/f2ForNVZzNeBvLU045pe62puaRWytvVzlq1Cgg24JcbMcddwRab+brPINtqqphddUO/v1qaj/ZXL7WMmfOHEAZsIhITcpNGrT11ls3+NozmG7dujXr57fddtuSx1Qpy5cvB1Zdlf3Rj360Ro9XfCTR/fffDzSsla62DNh3DTbViMiPbfK5XynwTNjXCZp6h9ma/epXvwKydYE8UQYsIhIkN2nQqaeeCsCll14KwNKlSwOjqSxvDu6VHl7Hu9tuu63V4xbv8qqmXV/+rsF3+/nqf3ELQj96yHuGSOP8+nnddDVlwl4DvrrjqiIoAxYRCZKbDNizPt+h5L+BvYPRbbfdBmTNx19//XUgyxK9T0JrVHygpFcrrGnvBu8hUfwbP48ZwJp67rnngGx+u/gaeqP+K6+8MiC6yvEqhlL1eKjGbnEHH3wwAFtuuSWQjR3FB7tGUAYsIhIkNxmw87lg/+h1wePGjQOy317O5/b8EEbJ+me4HXbYAWj9ta+Q1fv6Dslinvl6TbUfTVStmqrf9Z1yxTXh3vvB+yE0lfH6XDC0/vngDTbYAMjeZTtfH4isgVYGLCISJHcZcDGf6/Oj2Z1nyP369at0SGXnR6971UJL526ffPLJBl8feOCBQHY6RGvi1Q7+0U8D8d4hzvtI+5xvtWe+xZqbxXlG7FltU8fbV+Nc8O233w7AHnvs0eB2P/i3V69eFY9JGbCISJDcZsDeFW3o0KFANhfs55t5plMNK/uHH344kHUvu/XWWwG4/PLLAejevXuzHsdPQchDn9NS8Z4gQ4YM+dT7+ZxmNWW+Pl9bX6m7lnkmXA2vo+Yq/rfec889AIwcObLisSgDFhEJkrsM2DNd7+3gpzl4naef+LvFFlsERFceXp+4zTbbAFlfYO/p8Otf/xpYfdcmPwFjxYoVDW4/+eSTSxdsGfk8L2SZ76BBg4BVd7j5yraf+VY8f/fnP/8ZgLlz5za43XstX3zxxSWKuvQ88/20E6C9/repaoeW/l0SQxmwiEiQ3GXAw4cPB7LM1/k5afvvv3/FYyo3r2H2XV0777wzAK+99hoAhx56KAB77703AAMHDmzw87/5zW8AmDp1KgCdOnUCYPTo0cCqp8PmlVe8QDbnW7zDzfk1811/Xvc7adIkINvl5HPC/nj161vzqjnZbFM735qbGfuJGat7HCkvZcAiIkFykwH7ir9nMDvttBOQZXVdu3YNiauSOnfuDGSnF/t85ZIlS4DspF//2FSdsD/OiBEjyhpvqbz55ptA07vbGjN//nwA+vbtC2TXwvtHe+3zN7/5TaB1nvbrVS1e4QGrr88tVU+Iajwhw89U9LUWP0XHT1Hxf3OXLl0qFpMyYBGRIBqARUSChE1B+FvGu+++G8gWjPztsy8sbbzxxgHRxfANFzNnzgSyxjK+ANnckqFdd921DNGVz4YbbgjAYYcdVnfb9OnTgawkr5g3FurRoweQld55I6JddtmlPMFWkC+gXX311at8r1xbhQcMGFCWx80Dn54644wzgGxqp7jEsZKUAYuIBAnLgL3kaPDgwQ1uf/zxx4HSb7lsTTp27AhkpUBearXvvvsC2eKc8wbuvljnC5mthTeenzBhwirf8wMVnb8z+vrXvw5A//79yxxdvPqvBd86vLoyspbyBb9aeN0VZ8CRlAGLiASpeAbsrRaLj073QvrWNn9ZTl5e5iV4XjZTS4qPEs/j0eIRvGTKP/r6gB8vv7rMuFRbmVsjf4d59NFHA9nBrt7oq5KUAYuIBKl4BvzXv/4VyOYrL7nkEiBrBVdLbfFESsUzWP9YjRspSsW3sft6QiRlwCIiQSqeAftvHZ/r9QxYma+I1BplwCIiQSqeAXv9oohIrVMGLCISxLwnQ7PubLYAmFO+cHKhR0qp2Q0oauSaQAuui65J42rkuuiaNK7R69KiAVhEREpHUxAiIkE0AIuIBNEALCISRAOwiEgQDcAiIkE0AIuIBNEALCISRAOwiEgQDcAiIkE0AIuIBNEALCISRAOwiEgQDcAiIkE0AIuIBNEALCISRAOwiEgQDcAiIkE0AIuIBNEALCISRAOwiEgQDcAiIkE0AIuIBNEALCISRAOwiEgQDcAiIkE0AIuIBNEALCISRAOwiEgQDcAiIkE0AIuIBNEALCISRAOwiEgQDcAiIkE0AIuIBNEALCISRAOwiEgQDcAiIkE0AIuIBNEALCISRAOwiEgQDcAiIkE0AIuIBNEALCISRAOwiEiQXA7AZraDmU01syVm9rKZHRMdUzQzW1r0Z4WZ/SQ6rmhm1tPMHjKzt81snpndYGZto+OKZGbDzexpM1tuZhOj48kLM+tiZveZ2TIzm2NmJ0bHlLsBeOWL537gQaALcCZwh5n1Cg0sWEqpk/8BNgXeB34dHFYejAfmA5sBuwP9gHNCI4r3f8AY4NboQHLmRuBDoBswGLjJzHaKDCh3AzDQG+gOXJtSWpFSmgpMB06KDStXjqUw6Pw5OpAc2Bq4J6X0QUppHvAwEPqiipZSmpxSmgIsio4lL8ysI4XXzaiU0tKU0jTgAYLHlTwOwI0xYOfoIHLkFGBSSilFB5ID44ATzKyDmW0OHE5hEBaprxfwcUrpxXq3zST4l3UeB+BZFLK7C82snZkdSuFtZYfYsPLBzHpQuB63RceSE09SeBG9A7wBPA1MCY1I8qgThedIfUuA9QNiqZO7ATil9BFwNPBlYB5wPnAPhReXFN4yTUspvRodSDQzW4dCtjsZ6Ah0BT4LXBMZl+TSUqBz0W2dgXcDYqmTuwEYIKX0TEqpX0ppo5RSf+BzwFPRceXEySj7dV2ArYAbUkrLU0qLgAnAEbFhSQ69CLQ1s+3q3bYb8GxQPEBOB2Az29XM2q+c17uAwgr3xOCwwpnZfsDmqPoBgJTSQuBVYKiZtTWzDSnMjz8TG1msldeiPdAGaLPytVTTpXkppWUU3ildaWYdzWx/4Cjg9si4cjkAU3ib/SaFueCDgENSSstjQ8qFU4DJKaXQt005MwA4DFgAvAx8BHwrNKJ4IymUKV4MDFn5+cjQiPLhHGA9CuPKXcDQlFJoBmxaSBcRiZHXDFhEpOppABYRCaIBWEQkiAZgEZEgGoBFRIK0qDawa9euqWfPnmUKJR9mz57NwoULrbn3r4VrAjBjxoyFKaWNm3NfXZPG1cJ10euncU09V1o0APfs2ZOnn366dFHlUJ8+fVp0/1q4JgBmNqe599U1aVwtXBe9fhrX1HNFUxAiIkE0AIuIBNEALCISRAOwiEgQDcAiIkFqukWdSLXx5lp/+tOfALj++usB+PnPfw7Axhs3u2qu1frwww8BGDduHAAXX3xxo/f76le/CsBPf/pTADbddNMKRNeQMmARkSDKgKVVeu+99wD4xS9+AcB5550HwI033gjAOefU5sn0y5YtA+Cggw5qcPuGG24IwIQJEyoeU6UsWLAAgK997WsAPPnkkwDsscceAIwaNQqABx98EIBbbrkFyJ5L48ePB2DbbbetUMTKgEVEwuQ2A164cCEAjz76KABjx44F4PDDDwfg3HPPBWDzzTcPiE6iTJs2DYBvfOMbALz4YuGU8XXWKeQS3/nOdwA46qijAD0/asFLL70EZP/ns2bNAuD8888H4MorrwSgffv2De53wAEHAHDSSScBsP/++wPwj3/8A4Ctttqq7LErAxYRCZKbDHjJkiVAtiJ53XXXATBv3rwG9/v3v/8NwA033ADAK6+8AsSsYJaaX4NPPvmkwe133nknAHfffTcAb775JgBLly4FYK+99gJg4MCBAAwZMgSAtm1z89+71mbOnAnAgQceCMCKFSuAbIV7yy23BGDYsGEAHHvssUBWBbD33ntXLlgpu48++qju84suugjIMt/+/fsDMGbMGAA+85nPNPoYb731VoOv/V33Aw88AMDw4cNLGHHjlAGLiATRACwiEiT8Peo777wDQK9evYCslMQdeuihAJx55pkA/POf/wSyRbkLLrgAgDvuuKP8wZbQBx98UPf56NGjAbj22msBWL58eaM/40X2Zg3brf7+979v8PFLX/oSUGj1Vy0uvfRSIJt6uOaaa4Ds///5558Hsmvz7rvvAtmUxbPPFk4f79GjR4UijvHGG29Eh1AREydOrPvcpwx22mknAO69916g6akH59NVr776KpCV6PlCrj+eL86t7vHWhDJgEZEgYRmwZ76epS1evBjIFlM8m+vduzeQlRkNGDAAgPnz5wPwyCOPAFnWuO6665Y79JLwraKQZfOyqueeew7I/p/dySef3ODrHXbYAYDJkycDsP766wNw8MEHA9kCZ7UrXrR23/rWtyocSXn5Jor6/F3Seuut16zH8IzWF2qPO+44INvE4s+dP/7xj0BWtlZKyoBFRIKEZcBebuaZ76BBg4BsO+AGG2zQ4P4ff/wxkG0j9Dm9119/Hcjm/FpLBlzO7Y7155dbOy838tK8rl27AllRfTFvsOJF+LWmqeN9/PXmr6/WyseL+nPdgwcPBrLSwzXVt29fAObOnQtkm3i+8pWvAPCXv/yl7r677bbbWv1dThmwiEiQsAzY53g9k/EVyKZWGv03uG9Bdj4v89nPfrYscZZLp06d6j73+UpvpOJzT8W8CsKbjXjlyOmnnw5km1I8y/G5rWqy0UYbAU1vMlm0aBGQPV+8CU337t0rEF28+hsU6quWdwS+JuCbkSCr+inVxiNv2fnYY48BcMQRRwBZxQ1klRfNnW9uijJgEZEgFc+AvVny7NmzgawRRlOZ7/vvvw/AVVdd1ej3vSlLmzZtShlm2dXfOv3CCy8A2bVpaRMQb73oWU5xhUBr5msB/k7Jt5t6huv14f6O4vHHHweyefB+/foB2dyxtE7+2rj88stX+d6RRx5Zlr/T54RPO+00IGt1CnDWWWcBMGnSpLX6O5QBi4gEqXgG7JmuZzbeGq6Yz2V5NlfcOMPrgr/whS+UJc5KWttGQr4rzL322msA9OnTZ60eNw+8Tvyhhx4Csp1tF154IZC9kxo6dCgAI0aMaPDzv/zlLysQZX75ukFr5+sjPi9bn8/zl8sPf/hDoOEY5C0w15YyYBGRIGFVEJ71eR8EX2n0uR5vR+n7uosdcsghQPXv7f80Pj/uNdDOqyqqie/H9zWD22+/Hcjm5erPz0H2/KjGa9ES3htjzpw5AGyzzTaR4aw1z+i9XwNAu3btyvp3+rt2f05Btvb01FNPAWve7lQZsIhIkLAM2Btp+77rLbbYAsjmfr0rmq9++1FE9913H5Dt/a9lTzzxBJBlwm677baLCKesvMbzZz/7GQB///vfgexIomJXXHEF0PqqY0rNM8ZnnnkGyObQW6viToCVVH/3qq9B+SEI3o2vY8eOLXpMZcAiIkHCMmDfvXLGGWcAcPPNNwPZbzjPfL3e07tZeberrbfeumKxSn54rw/P6JrqCeFHV+2zzz6VCSyn/PW02WabBUfS+nlNOWTjlndla2oH4uooAxYRCRJ+IobP6fk+az+G3udWvFrCT8bw3+jVUOO6tv773/8CWaewyPmxSvN/e1Muu+wyYPU7LWvFww8/DMDxxx8fHMma8TlXfwf04x//uO57fux8uash6uvQoUNJHkcZsIhIkPAM2LM27+zlH2X1vNuZZwfe0X9td9a1BsW9X/3rqVOnAtnJEN47YpdddqlgdHG8WshPh6iWnXC+c9Yz+Po9GLwOvkuXLmWN4e233677/Cc/+QmQzQuvaUasDFhEJEh4Brw6vrpYK6e9Nof/xi/ujzF8+HCg6cqAauB9YL3KwTNbz4i8Lvjzn/88AKNGjQJgypQpFY0zip/k6yeDeN9a7xLnz53WukNwxx13XOU2/7/1vtil5hVY/lyqz3fwrukagzJgEZEguc+A/Te298yV7N2Adz0rXiGuRn4m4Lhx44DseeFZiWf93bp1a/BzxV9XO68EKO754M8V3zXZWjNgz+wvueSSuttGjhwJZH1hfHdtS/m7bf941113Adl873/+85+6+955551Atu6yppQBi4gEyX0G7Hv+i+2+++4VjiS/PMvba6+9giMpH8+AvTer69y5M5BlxBMnTmzw/f3226/8weVQY3OlkHVF22STTSoZTslsv/32ANxwww11t/nah/cOHzt2LJCdrejZfnHXQO+46HxXW3GNee/evQGYMWNG3W2l6reiDFhEJIgGYBGRILmfgmjqrVQltx1KvEceeaTB177wOG3aNABOPfVUINuA4Q2yfUt7rTnhhBOAbMuut0v83ve+B8D9998PtN7X0dlnn133uZeA+eEO/lxwfqyVH1/lfJOKbwbzhUu/dsOGDQOyxl/lWORWBiwiEiT3GfBzzz0XHULu1F+AqBX1t4FC1oBozJgxQNZucciQIQCMHz8eaHmD7GrnR6x7g/tq4BswDjvsMAAmTJgAZItxvjhdvFHDjxjy9geeSZeq0U5zKAMWEQmS+1+D5T5yujV67733Gny9ePFiICuj8WbR1cS3HHsbUp/j9QYsfkiiH21V6zzzf/bZZ4MjqZzu3bsDWSMi/5hnyoBFRILkPgP2I2X69u0LZI3Za/mwxfPOOw/IVrK9WUg1Nx3fc889gaY35oi0RsqARUSC5D4D9npPP4Jdsm3Yfk38gNNaaMQuUk2UAYuIBMl9BixN88qARYsWBUciImtCGbCISBBryaF9ZrYAmFO+cHKhR0pp4+beuUauCbTguuiaNK5GrouuSeMavS4tGoBFRKR0NAUhIhJEA7CISBANwCIiQTQAi4gE0QAsIhJEA7CISBANwCIiQTQAi4gE0QAsIhLk/wF/u6HQDxhcPAAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 10 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "\n",
            "**misclassified testing images**\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 10 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}