Duke_ML_HW_4.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/defnecirci/HIBIT-2020/blob/master/Duke_ML_HW_4.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "I9WmebshvT5j"
      },
      "outputs": [],
      "source": [
        "import pickle\n",
        "import os\n",
        "from sklearn.model_selection import train_test_split\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "from scipy.optimize import approx_fprime\n",
        "from numpy.linalg import norm"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ic7T8b0gvY9F",
        "outputId": "82e24f47-c02a-4ba7-aafa-062053159c0e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at ./drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount(\"./drive\")\n",
        "path_prefix = \"./drive/My Drive\"\n",
        "import numpy as np\n",
        "import pandas as pd"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DXDtcHhwvZVf"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KfXBo3m7unEC"
      },
      "source": [
        "Question 4"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5kJBr5bAuqLT"
      },
      "source": [
        "4.1 check the code\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 601
        },
        "id": "4-7igyreulqm",
        "outputId": "a270847b-ff39-4720-affa-750a2e49d684"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 200 entries, 0 to 199\n",
            "Data columns (total 2 columns):\n",
            " #   Column          Non-Null Count  Dtype\n",
            "---  ------          --------------  -----\n",
            " 0   Annual_Income   200 non-null    int64\n",
            " 1   Spending_Score  200 non-null    int64\n",
            "dtypes: int64(2)\n",
            "memory usage: 3.2 KB\n",
            "None\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "     Annual_Income  Spending_Score\n",
              "0               15              39\n",
              "1               15              81\n",
              "2               16               6\n",
              "3               16              77\n",
              "4               17              40\n",
              "..             ...             ...\n",
              "195            120              79\n",
              "196            126              28\n",
              "197            126              74\n",
              "198            137              18\n",
              "199            137              83\n",
              "\n",
              "[200 rows x 2 columns]"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-ac3daf7c-f22b-4c5a-92b4-8857ac8f604f\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Annual_Income</th>\n",
              "      <th>Spending_Score</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>15</td>\n",
              "      <td>39</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>15</td>\n",
              "      <td>81</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>16</td>\n",
              "      <td>6</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>16</td>\n",
              "      <td>77</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>17</td>\n",
              "      <td>40</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>195</th>\n",
              "      <td>120</td>\n",
              "      <td>79</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>196</th>\n",
              "      <td>126</td>\n",
              "      <td>28</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>197</th>\n",
              "      <td>126</td>\n",
              "      <td>74</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>198</th>\n",
              "      <td>137</td>\n",
              "      <td>18</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>199</th>\n",
              "      <td>137</td>\n",
              "      <td>83</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>200 rows × 2 columns</p>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-ac3daf7c-f22b-4c5a-92b4-8857ac8f604f')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-ac3daf7c-f22b-4c5a-92b4-8857ac8f604f button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-ac3daf7c-f22b-4c5a-92b4-8857ac8f604f');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "mall_customers_df = pd.read_csv('mall_customers.csv')\n",
        "print(mall_customers_df.info())\n",
        "mall_customers_df"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 280
        },
        "id": "DCU49WsRvqCB",
        "outputId": "e0e4fadb-3186-4bfe-98b4-35d4d5f66636"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "#now\n",
        "ax1 = mall_customers_df.plot.scatter(x='Annual_Income',\n",
        "                       y='Spending_Score',\n",
        "                       c='DarkBlue')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X4wM3HfR6O4m"
      },
      "source": [
        "4.2\n",
        "\n",
        "The one on the lower left represents customers with low annual income and low spending score,  upper left represents customers with low annual income and high spending score, lower right represents customers with high annual income and low spending score, upper right represents customers with high annual income and high spending score, and the ones in the middle represent customers with medium annual income and medium spending score.\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nTeRXR9D6PuU"
      },
      "outputs": [],
      "source": [
        "#np.random.seed(45)\n",
        "def euclideandistance(point,center_of_cluster):\n",
        "  \n",
        "  return np.linalg.norm(point-center_of_cluster,2)\n",
        "\n",
        "\n",
        "def cluster_assignments(points, centers_of_clusterers):\n",
        "    \n",
        "    cluster_assignments = []\n",
        "    for point in points:\n",
        "        distances = []\n",
        "        for center in centers_of_clusterers:\n",
        "            distance = euclideandistance(point,center)\n",
        "            distances.append(distance)\n",
        "\n",
        "        assignment = np.argmin(distances)\n",
        "        cluster_assignments.append(assignment)\n",
        "\n",
        "    return cluster_assignments    \n",
        "    \n",
        "def  new_cluster_assignments(points, centers_of_clusterers, cluster_assignments, k):\n",
        "    new_centers = np.zeros((k,2))\n",
        "\n",
        "    for cluster_number in range(k):\n",
        "        points_in_cluster = []\n",
        "        for j in range(len(input)):\n",
        "                if (cluster_assignments[j] == cluster_number):\n",
        "                    points_in_cluster.append(input[j])\n",
        "\n",
        "        center = np.mean(points_in_cluster, axis=0)\n",
        "        #new_centers.append(center)\n",
        "        new_centers[cluster_number,:]= center\n",
        "\n",
        "    return new_centers\n",
        "\n",
        "def loss(points, assignments, centers_of_cluster):\n",
        "    loss= 0   \n",
        "    for i in range(len(points)):\n",
        "        center_of_cluster= centers_of_cluster[assignments[i]]\n",
        "        distance = np.linalg.norm(points[i]-center_of_cluster,2)\n",
        "        loss= loss + distance**2\n",
        "           \n",
        "    return loss\n",
        "    \n",
        "def kmeans(points,k):\n",
        "    new_clusters= []\n",
        "    \n",
        "    \n",
        "    random_index = np.random.choice(len(points), k, replace=False)  \n",
        "    cluster_centers = points[random_index, :]\n",
        "\n",
        "    max_iteration = 3000\n",
        "    for iteration in range(max_iteration):\n",
        "        new_clusters = cluster_assignments(input, cluster_centers)        \n",
        "        cluster_centers = new_cluster_assignments(input, cluster_centers, new_clusters, k)        \n",
        "     \n",
        "    return  new_clusters, cluster_centers"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "input = mall_customers_df.to_numpy()\n",
        "#input = mall_customers_df\n",
        "k = 5\n",
        "cluster_assignments, cluster_centers = kmeans(input,k)\n",
        "def find_nums(cluster_assignments,num):\n",
        "  indices = [i for i, x in enumerate(cluster_assignments) if x == num]\n",
        "  return indices\n",
        " \n"
      ],
      "metadata": {
        "id": "U7rwfsd-VV7B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9_ngYB9IV7Ax",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        },
        "outputId": "ea874cf3-f3b7-4613-85ef-d0cfa80dcad4"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f2f8d59f580>"
            ]
          },
          "metadata": {},
          "execution_count": 23
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "plt.scatter(mall_customers_df.iloc[find_nums(cluster_assignments,0),0], mall_customers_df.iloc[find_nums(cluster_assignments,0),1],c = 'r')\n",
        "plt.scatter(mall_customers_df.iloc[find_nums(cluster_assignments,1),0], mall_customers_df.iloc[find_nums(cluster_assignments,1),1],c = 'b')\n",
        "plt.scatter(mall_customers_df.iloc[find_nums(cluster_assignments,2),0], mall_customers_df.iloc[find_nums(cluster_assignments,2),1],c = 'g')\n",
        "plt.scatter(mall_customers_df.iloc[find_nums(cluster_assignments,3),0], mall_customers_df.iloc[find_nums(cluster_assignments,3),1],c = 'y')\n",
        "plt.scatter(mall_customers_df.iloc[find_nums(cluster_assignments,4),0], mall_customers_df.iloc[find_nums(cluster_assignments,4),1],c = 'c')\n",
        "\n",
        "plt.scatter(cluster_centers[:,0].tolist(),cluster_centers[:,1].tolist(), color=\"black\",label=\"center\")\n",
        "plt.legend()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_cbQ98AtV970"
      },
      "outputs": [],
      "source": [
        "loss_for_implementation = loss(input,cluster_assignments,cluster_centers)\n",
        "print('Loss = ', loss_for_implementation)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "89f3A4rGWDuY"
      },
      "outputs": [],
      "source": [
        "print('Centers = ', cluster_centers)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "S-wyrDhPWGDb"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a_ibN3Nr58_j"
      },
      "source": [
        "4.3 Note that it is generally a good idea to perform multiple replicates for k-means.\n",
        "\n",
        "\n",
        "yorum!!!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B-MFe6tpwN2X",
        "outputId": "76de1663-bfa7-4fa6-e87d-92a627bccca7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cluster assignment for each point in the dataset are:  [4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4\n",
            " 2 4 2 4 2 4 1 4 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
            " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
            " 1 1 1 1 1 1 1 1 1 1 1 1 0 3 0 1 0 3 0 3 0 1 0 3 0 3 0 3 0 3 0 1 0 3 0 3 0\n",
            " 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3\n",
            " 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0]\n",
            "Cluster centers are:  [[86.53846154 82.12820513]\n",
            " [55.2962963  49.51851852]\n",
            " [25.72727273 79.36363636]\n",
            " [88.2        17.11428571]\n",
            " [26.30434783 20.91304348]]\n"
          ]
        }
      ],
      "source": [
        "from sklearn.cluster import KMeans\n",
        "#default distance metric is euclidian distance in scikit learn\n",
        "kmeans = KMeans(n_clusters=5, init=\"random\").fit(mall_customers_df)\n",
        "print(\"Cluster assignment for each point in the dataset are: \",kmeans.labels_)\n",
        "print(\"Cluster centers are: \", kmeans.cluster_centers_)\n",
        "#array([[10.,  2.],\n",
        "#       [ 1.,  2.]])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TnQD8tX14S8n",
        "outputId": "3c3c6055-3173-4bcc-e879-2d33d97d5292"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False, False, False,  True, False,  True,\n",
              "       False,  True, False,  True, False,  True, False,  True, False,\n",
              "        True, False,  True, False,  True, False,  True, False,  True,\n",
              "       False,  True, False,  True, False,  True, False,  True, False,\n",
              "        True, False,  True, False,  True, False,  True, False,  True,\n",
              "       False,  True, False,  True, False,  True, False,  True, False,\n",
              "        True, False,  True, False,  True, False,  True, False,  True,\n",
              "       False,  True, False,  True, False,  True, False,  True, False,\n",
              "        True, False,  True, False,  True, False,  True, False,  True,\n",
              "       False,  True])"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ],
      "source": [
        "kmeans.labels_==0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "isT7X3Gj4aQD",
        "outputId": "3e705704-0941-405e-e132-025db1b37a5d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4\n",
            " 2 4 2 4 2 4 1 4 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
            " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
            " 1 1 1 1 1 1 1 1 1 1 1 1 0 3 0 1 0 3 0 3 0 1 0 3 0 3 0 3 0 3 0 1 0 3 0 3 0\n",
            " 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3\n",
            " 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0]\n"
          ]
        }
      ],
      "source": [
        "kmeans.labels_\n",
        "print(kmeans.labels_)\n",
        "mall_customers_df =mall_customers_df.to_numpy()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kuF5WVZ85Xlr"
      },
      "source": [
        "Center of the each cluster is indicated by a black dot."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        },
        "id": "Cql_mH7x1j4g",
        "outputId": "bb0906bb-dfe5-4560-8061-3cd02cf92a69"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fb01028d520>"
            ]
          },
          "metadata": {},
          "execution_count": 72
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "plt.scatter(mall_customers_df[kmeans.labels_==0,0], mall_customers_df[kmeans.labels_==0,1],c = 'r')\n",
        "plt.scatter(mall_customers_df[kmeans.labels_==1,0], mall_customers_df[kmeans.labels_==1,1],c = 'b')\n",
        "plt.scatter(mall_customers_df[kmeans.labels_==2,0], mall_customers_df[kmeans.labels_==2,1],c = 'g')\n",
        "plt.scatter(mall_customers_df[kmeans.labels_==3,0], mall_customers_df[kmeans.labels_==3,1],c = 'y')\n",
        "plt.scatter(mall_customers_df[kmeans.labels_==4,0], mall_customers_df[kmeans.labels_==4,1],c = 'c')\n",
        "plt.scatter(kmeans.cluster_centers_[:,0],kmeans.cluster_centers_[:,1], color=\"black\",label=\"center\")\n",
        "plt.legend()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9oEbVbpi6JHa"
      },
      "source": [
        "4.4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H1W4NGK9zvQP"
      },
      "outputs": [],
      "source": [
        "#np.random.seed(45)\n",
        "def manhattandistance(point,center_of_cluster):\n",
        "  \n",
        "  return np.linalg.norm(point-center_of_cluster,1)\n",
        "\n",
        "\n",
        "def cluster_assignments(points, centers_of_clusterers):\n",
        "    \n",
        "    cluster_assignments = []\n",
        "    for point in points:\n",
        "        distances = []\n",
        "        for center in centers_of_clusterers:\n",
        "            distance = manhattandistance(point,center)\n",
        "            distances.append(distance)\n",
        "\n",
        "        assignment = np.argmin(distances)\n",
        "        cluster_assignments.append(assignment)\n",
        "\n",
        "    return cluster_assignments    \n",
        "    \n",
        "def  new_cluster_assignments(points, centers_of_clusterers, cluster_assignments, k):\n",
        "    new_centers = np.zeros((k,2))\n",
        "\n",
        "    for cluster_number in range(k):\n",
        "        points_in_cluster = []\n",
        "        for j in range(len(input)):\n",
        "                if (cluster_assignments[j] == cluster_number):\n",
        "                    points_in_cluster.append(input[j])\n",
        "\n",
        "        center = np.median(points_in_cluster, axis=0)\n",
        "        #new_centers.append(center)\n",
        "        new_centers[cluster_number,:]= center\n",
        "\n",
        "    return new_centers\n",
        "\n",
        "def loss(points, assignments, centers_of_cluster):\n",
        "    loss= 0   \n",
        "    for i in range(len(points)):\n",
        "        center_of_cluster= centers_of_cluster[assignments[i]]\n",
        "        distance = np.linalg.norm(points[i]-center_of_cluster,1)\n",
        "        loss= loss + distance**2\n",
        "           \n",
        "    return loss\n",
        "    \n",
        "def kmeans(points,k):\n",
        "    new_clusters= []\n",
        "    \n",
        "    \n",
        "    random_index = np.random.choice(len(points), k, replace=False)  \n",
        "    cluster_centers = points[random_index, :]\n",
        "\n",
        "    max_iteration = 3000\n",
        "    for iteration in range(max_iteration):\n",
        "        new_clusters = cluster_assignments(input, cluster_centers)        \n",
        "        cluster_centers = new_cluster_assignments(input, cluster_centers, new_clusters, k)        \n",
        "     \n",
        "    return  new_clusters, cluster_centers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ABtEWM5h1fRR"
      },
      "outputs": [],
      "source": [
        "input = mall_customers_df.to_numpy()\n",
        "#input = mall_customers_df\n",
        "k = 5\n",
        "cluster_assignments, cluster_centers = kmeans(input,k)\n",
        "def find_nums(cluster_assignments,num):\n",
        "  indices = [i for i, x in enumerate(cluster_assignments) if x == num]\n",
        "  return indices\n",
        " "
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.scatter(mall_customers_df.iloc[find_nums(cluster_assignments,0),0], mall_customers_df.iloc[find_nums(cluster_assignments,0),1],c = 'r')\n",
        "plt.scatter(mall_customers_df.iloc[find_nums(cluster_assignments,1),0], mall_customers_df.iloc[find_nums(cluster_assignments,1),1],c = 'b')\n",
        "plt.scatter(mall_customers_df.iloc[find_nums(cluster_assignments,2),0], mall_customers_df.iloc[find_nums(cluster_assignments,2),1],c = 'g')\n",
        "plt.scatter(mall_customers_df.iloc[find_nums(cluster_assignments,3),0], mall_customers_df.iloc[find_nums(cluster_assignments,3),1],c = 'y')\n",
        "plt.scatter(mall_customers_df.iloc[find_nums(cluster_assignments,4),0], mall_customers_df.iloc[find_nums(cluster_assignments,4),1],c = 'c')\n",
        "\n",
        "\n",
        "#plt.scatter(mall_customers_df[cluster_assignments==1,0], mall_customers_df[cluster_assignments==1,1],c = 'b')\n",
        "#plt.scatter(mall_customers_df[cluster_assignments==2,0], mall_customers_df[cluster_assignments==2,1],c = 'g')\n",
        "#plt.scatter(mall_customers_df[cluster_assignments==3,0], mall_customers_df[cluster_assignments==3,1],c = 'y')\n",
        "#plt.scatter(mall_customers_df[cluster_assignments==4,0], mall_customers_df[cluster_assignments==4,1],c = 'c')\n",
        "plt.scatter(cluster_centers[:,0].tolist(),cluster_centers[:,1].tolist(), color=\"black\",label=\"center\")\n",
        "plt.legend()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        },
        "id": "KFj0mYEVhwvb",
        "outputId": "8ae7cc34-6114-46f5-f634-8ae44aded57e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f2f8d59f970>"
            ]
          },
          "metadata": {},
          "execution_count": 26
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JP1kthcWRIDc"
      },
      "source": [
        "5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GgdjvLYPRNmv"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import torch.optim as optim\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from torch.utils.data.dataset import random_split\n",
        "from torchvision import datasets\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import PIL"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2_eOiJkbRQ-h"
      },
      "outputs": [],
      "source": [
        "##Do Not Touch This Cell\n",
        "\n",
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(3, 8, 5)\n",
        "        self.conv2 = nn.Conv2d(8, 16, 3)\n",
        "        self.bn1 = nn.BatchNorm2d(8)\n",
        "        self.bn2 = nn.BatchNorm2d(16)\n",
        "        self.fc1 = nn.Linear(16*6*6, 120)\n",
        "        self.fc2 = nn.Linear(120, 84)\n",
        "        self.fc3 = nn.Linear(84, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        out = F.relu(self.bn1(self.conv1(x)))\n",
        "        out = F.max_pool2d(out, 2)\n",
        "        out = F.relu(self.bn2(self.conv2(out)))\n",
        "        out = F.max_pool2d(out, 2)\n",
        "        out = out.view(out.size(0), -1)\n",
        "        out = F.relu(self.fc1(out))\n",
        "        out = F.relu(self.fc2(out))\n",
        "        out = self.fc3(out)\n",
        "        return out"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zNAZSiPHRRDe",
        "outputId": "f378af0e-5924-4515-cf4d-bbf0472a9db2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Train on CPU...\n"
          ]
        }
      ],
      "source": [
        "##Do Not Touch This Cell\n",
        "\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "net = Net().to(device)\n",
        "optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.5)\n",
        "if device =='cuda':\n",
        "    print(\"Train on GPU...\")\n",
        "else:\n",
        "    print(\"Train on CPU...\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FTZIWU3oRRJf",
        "outputId": "aa30d29f-bbd8-404a-d411-329a15a45673"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<torch._C.Generator at 0x7f7cbcb65310>"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "##Do Not Touch This Cell\n",
        "max_epochs = 50\n",
        "\n",
        "random_seed = 671\n",
        "torch.manual_seed(random_seed)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102,
          "referenced_widgets": [
            "8f696108c08643048dff9363850eb239",
            "d7fb3e89fb344566b1989819e37520c1",
            "66a3593b42ae4a88b2af58f65404ab3e",
            "b7668c4d4a574452a8c5dbf035794dc2",
            "599ecc0b38084f11bc7fd69dd9d334b4",
            "19b57ba00ba848a6a6734896a35f734a",
            "f88de0b1740141d7a56accec10ccdf94",
            "4f5feb7f8be3473aad94440e82cd70c3",
            "ab858ddb0334423f885c8a7e12402d02",
            "38483ae7003d456da86902c387082eb6",
            "75ee320ea462427e93a172e58c5daba2"
          ]
        },
        "id": "ORSw7XdERX1E",
        "outputId": "dbc16f94-eac3-4fcb-8874-d3139493dd29"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "8f696108c08643048dff9363850eb239",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/170498071 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Extracting ./data/cifar-10-python.tar.gz to ./data\n",
            "Files already downloaded and verified\n"
          ]
        }
      ],
      "source": [
        "train_transform = transforms.Compose(\n",
        "     [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])\n",
        "\n",
        "test_transform = transforms.Compose(\n",
        "     [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])\n",
        "\n",
        "dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=train_transform)\n",
        "##TODO: Split the set into 80% train, 20% validation (there are 50K total images)\n",
        "train_num = int(0.8 * len(dataset))\n",
        "val_num = len(dataset)-train_num\n",
        "train_set, val_set = random_split(dataset, [train_num, val_num])\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(train_set, batch_size=128, shuffle=True)\n",
        "val_loader = torch.utils.data.DataLoader(val_set, batch_size=128, shuffle=False)\n",
        "\n",
        "test_set = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=test_transform)\n",
        "test_loader = torch.utils.data.DataLoader(test_set, batch_size=1, shuffle=False)\n",
        "\n",
        "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "SpvFcZJ-SDgu",
        "outputId": "333275c9-aab9-4d5e-fd33-5980fb37e0c9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[epoch 1] loss: 0.00293 accuracy: 0.8709 val loss: 0.00982 val accuracy: 0.6657\n",
            "[epoch 2] loss: 0.00279 accuracy: 0.8756 val loss: 0.00975 val accuracy: 0.6724\n",
            "[epoch 3] loss: 0.00280 accuracy: 0.8752 val loss: 0.01042 val accuracy: 0.6590\n",
            "[epoch 4] loss: 0.00263 accuracy: 0.8830 val loss: 0.01038 val accuracy: 0.6631\n",
            "[epoch 5] loss: 0.00259 accuracy: 0.8855 val loss: 0.01066 val accuracy: 0.6546\n",
            "[epoch 6] loss: 0.00250 accuracy: 0.8890 val loss: 0.01055 val accuracy: 0.6514\n",
            "[epoch 7] loss: 0.00240 accuracy: 0.8938 val loss: 0.01159 val accuracy: 0.6474\n",
            "[epoch 8] loss: 0.00230 accuracy: 0.8981 val loss: 0.01150 val accuracy: 0.6554\n",
            "[epoch 9] loss: 0.00221 accuracy: 0.9030 val loss: 0.01101 val accuracy: 0.6717\n",
            "[epoch 10] loss: 0.00215 accuracy: 0.9059 val loss: 0.01211 val accuracy: 0.6505\n",
            "[epoch 11] loss: 0.00207 accuracy: 0.9080 val loss: 0.01155 val accuracy: 0.6588\n",
            "[epoch 12] loss: 0.00197 accuracy: 0.9138 val loss: 0.01195 val accuracy: 0.6552\n",
            "[epoch 13] loss: 0.00199 accuracy: 0.9111 val loss: 0.01283 val accuracy: 0.6443\n",
            "[epoch 14] loss: 0.00194 accuracy: 0.9139 val loss: 0.01198 val accuracy: 0.6631\n",
            "[epoch 15] loss: 0.00180 accuracy: 0.9209 val loss: 0.01243 val accuracy: 0.6619\n",
            "[epoch 16] loss: 0.00178 accuracy: 0.9222 val loss: 0.01277 val accuracy: 0.6520\n",
            "[epoch 17] loss: 0.00170 accuracy: 0.9246 val loss: 0.01318 val accuracy: 0.6542\n",
            "[epoch 18] loss: 0.00165 accuracy: 0.9268 val loss: 0.01297 val accuracy: 0.6565\n",
            "[epoch 19] loss: 0.00156 accuracy: 0.9316 val loss: 0.01469 val accuracy: 0.6389\n",
            "[epoch 20] loss: 0.00155 accuracy: 0.9313 val loss: 0.01462 val accuracy: 0.6432\n",
            "[epoch 21] loss: 0.00149 accuracy: 0.9339 val loss: 0.01338 val accuracy: 0.6590\n",
            "[epoch 22] loss: 0.00137 accuracy: 0.9399 val loss: 0.01458 val accuracy: 0.6424\n",
            "[epoch 23] loss: 0.00137 accuracy: 0.9398 val loss: 0.01505 val accuracy: 0.6419\n",
            "[epoch 24] loss: 0.00135 accuracy: 0.9399 val loss: 0.01410 val accuracy: 0.6521\n",
            "[epoch 25] loss: 0.00123 accuracy: 0.9466 val loss: 0.01530 val accuracy: 0.6439\n",
            "[epoch 26] loss: 0.00120 accuracy: 0.9472 val loss: 0.01515 val accuracy: 0.6500\n",
            "[epoch 27] loss: 0.00121 accuracy: 0.9477 val loss: 0.01522 val accuracy: 0.6454\n",
            "[epoch 28] loss: 0.00111 accuracy: 0.9518 val loss: 0.01514 val accuracy: 0.6522\n",
            "[epoch 29] loss: 0.00108 accuracy: 0.9540 val loss: 0.01700 val accuracy: 0.6252\n",
            "[epoch 30] loss: 0.00107 accuracy: 0.9526 val loss: 0.01667 val accuracy: 0.6398\n",
            "[epoch 31] loss: 0.00098 accuracy: 0.9577 val loss: 0.01612 val accuracy: 0.6514\n",
            "[epoch 32] loss: 0.00092 accuracy: 0.9611 val loss: 0.01638 val accuracy: 0.6479\n",
            "[epoch 33] loss: 0.00096 accuracy: 0.9585 val loss: 0.01753 val accuracy: 0.6430\n",
            "[epoch 34] loss: 0.00092 accuracy: 0.9610 val loss: 0.01748 val accuracy: 0.6414\n",
            "[epoch 35] loss: 0.00087 accuracy: 0.9627 val loss: 0.01712 val accuracy: 0.6516\n",
            "[epoch 36] loss: 0.00073 accuracy: 0.9701 val loss: 0.01764 val accuracy: 0.6477\n",
            "[epoch 37] loss: 0.00077 accuracy: 0.9670 val loss: 0.01763 val accuracy: 0.6452\n",
            "[epoch 38] loss: 0.00072 accuracy: 0.9702 val loss: 0.01773 val accuracy: 0.6501\n",
            "[epoch 39] loss: 0.00077 accuracy: 0.9673 val loss: 0.01827 val accuracy: 0.6445\n",
            "[epoch 40] loss: 0.00072 accuracy: 0.9705 val loss: 0.01909 val accuracy: 0.6424\n",
            "[epoch 41] loss: 0.00077 accuracy: 0.9672 val loss: 0.01856 val accuracy: 0.6461\n",
            "[epoch 42] loss: 0.00069 accuracy: 0.9708 val loss: 0.01856 val accuracy: 0.6489\n",
            "[epoch 43] loss: 0.00054 accuracy: 0.9794 val loss: 0.01870 val accuracy: 0.6509\n",
            "[epoch 44] loss: 0.00049 accuracy: 0.9817 val loss: 0.01942 val accuracy: 0.6489\n",
            "[epoch 45] loss: 0.00048 accuracy: 0.9826 val loss: 0.01887 val accuracy: 0.6501\n",
            "[epoch 46] loss: 0.00046 accuracy: 0.9826 val loss: 0.01984 val accuracy: 0.6493\n",
            "[epoch 47] loss: 0.00053 accuracy: 0.9791 val loss: 0.01982 val accuracy: 0.6510\n",
            "[epoch 48] loss: 0.00049 accuracy: 0.9804 val loss: 0.02034 val accuracy: 0.6438\n",
            "[epoch 49] loss: 0.00052 accuracy: 0.9792 val loss: 0.02616 val accuracy: 0.6030\n",
            "[epoch 50] loss: 0.00070 accuracy: 0.9693 val loss: 0.02086 val accuracy: 0.6418\n"
          ]
        }
      ],
      "source": [
        "loss_list, acc_list = [], []\n",
        "loss_list_val, acc_list_val = [], []\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "for epoch in range(max_epochs):\n",
        "    #TODO: set the net to train mode:\n",
        "    net.train()\n",
        "    epoch_loss = 0.0\n",
        "    correct = 0\n",
        "\n",
        "    for batch_idx, (data, labels) in enumerate(train_loader):\n",
        "        data, labels = data.to(device), labels.to(device)\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "        ##TODO: pass the data into the network and store the output\n",
        "        output = net(data)\n",
        "        ##TODO: Calculate the cross entropy loss between the output and target \n",
        "        loss = criterion(output, labels)\n",
        "        ##TODO: Perform backpropagation\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        ##TODO: Get the prediction from the output\n",
        "        _, pred = torch.max(output, dim=1)\n",
        "\n",
        "        ##TODO: Calculate the correct number and add the number to correct\n",
        "        correct += (pred == labels).sum().item()\n",
        "       \n",
        "        ##TODO: Add the loss to epoch_loss.\n",
        "        epoch_loss += loss\n",
        "    ##TODO: calculate the average loss  \n",
        "    avg_loss = epoch_loss/len(train_set)\n",
        "    ##TODO: calculate the average accuracy\n",
        "    avg_acc = correct/len(train_set)\n",
        "    ##TODO: append average epoch loss to loss list\n",
        "    loss_list.append(avg_loss)\n",
        "    ##TODO: append average accuracy to accuracy list\n",
        "    acc_list.append(avg_acc)\n",
        "    # validation\n",
        "    ##TODO: set the model to eval mode\n",
        "    net.eval()\n",
        "    with torch.no_grad():\n",
        "        loss_val = 0.0\n",
        "        correct_val = 0\n",
        "        for batch_idx, (data, labels) in enumerate(val_loader):\n",
        "            data, labels = data.to(device), labels.to(device)\n",
        "            ##TODO: pass the data into the network and store the output\n",
        "            output = net(data)\n",
        "            ##TODO: Calculate the cross entropy loss between the output and target \n",
        "            loss = criterion(output, labels)\n",
        "            ##TODO: Get the prediction from the output\n",
        "            _, pred = torch.max(output, dim=1)\n",
        "            ##TODO: Calculate the correct number and add the number to correct_val\n",
        "            correct_val += (pred == labels).sum().item()\n",
        "            ##TODO: Add the loss to loss_val\n",
        "            loss_val += loss\n",
        "        ##TODO: calculate the average loss of validation\n",
        "        avg_loss_val = loss_val/len(val_set)\n",
        "        ##TODO: calculate the average accuracy of validation\n",
        "        avg_acc_val = correct_val/len(val_set)\n",
        "        ##TODO: append average epoch loss to loss list of validation\n",
        "        loss_list_val.append(avg_loss_val)\n",
        "        ##TODO: append average accuracy to accuracy list of validation\n",
        "        acc_list_val.append(avg_acc_val)\n",
        "    print('[epoch %d] loss: %.5f accuracy: %.4f val loss: %.5f val accuracy: %.4f' % (epoch + 1, avg_loss, avg_acc, avg_loss_val, avg_acc_val))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "YNt6FJqhSJNG"
      },
      "outputs": [],
      "source": [
        "for i in range(len(loss_list)):\n",
        "  loss_list[i] = torch.Tensor.detach(loss_list[i])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "TWk0K5cJSJ1I",
        "outputId": "01cd6884-803f-4136-a891-fbbfb840abe3"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "##TODO: Plot the training losses and validation losses\n",
        "epoch = range(1,max_epochs+1)\n",
        "plt.plot(epoch, loss_list, label = 'Training Set')\n",
        "plt.plot(epoch, loss_list_val, label = 'Validation Set')\n",
        "plt.ylabel('Loss')\n",
        "plt.xlabel('Epoch number')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "raX0Sj0dSN1b",
        "outputId": "43b1c5d0-ae12-41a8-e974-e34bef8cdb9d"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "##TODO: Plot the training accuracies and validation accuracies\n",
        "plt.plot(epoch, acc_list, label = 'Training Set')\n",
        "plt.plot(epoch, acc_list_val, label = 'Validation Set')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.xlabel('Epoch number')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "KZcZbB0TSQ7R",
        "outputId": "0a4ec5b6-6f28-4e96-a1b1-a379d0c7db31"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy on the 10000 test images: 62.73 %\n"
          ]
        }
      ],
      "source": [
        "#Test\n",
        "true_labels = []\n",
        "predictions = []\n",
        "correct_test = 0\n",
        "net.eval()\n",
        "with torch.no_grad():\n",
        "    for batch_idx, (data, label) in enumerate(test_loader):\n",
        "        data, label = data.to(device), label.to(device)\n",
        "        ##TODO: pass the data into the network and store the output\n",
        "        output = net(data)\n",
        "        ##TODO: Get the prediction from the output\n",
        "        _, pred = torch.max(output, dim=1)\n",
        "        ##TODO: Calculate the correct number and add the number to correct_test\n",
        "        correct_test += (pred == label).sum().item()\n",
        "        ##TODO: update predictions list and true label list\n",
        "        ##We can directly append the value because here batch_size=1\n",
        "        predictions.append(pred)\n",
        "        true_labels.append(label)\n",
        "\n",
        "print('Accuracy on the 10000 test images: %.2f %%' % (100 * correct_test / len(test_set)))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "J25pclswSW2Z",
        "outputId": "77394090-8495-4028-e396-ff34f43639de"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[643,  34,  85,  28,  18,  22,  18,   8,  94,  50],\n",
              "       [ 28, 787,  11,  13,   3,  10,  16,   1,  40,  91],\n",
              "       [ 76,  10, 564,  78,  66, 114,  49,  14,  14,  15],\n",
              "       [ 26,  14, 102, 423,  42, 295,  52,  19,  10,  17],\n",
              "       [ 19,   5, 134,  94, 509, 114,  54,  45,  18,   8],\n",
              "       [ 19,   6,  81, 132,  30, 667,  26,  24,   5,  10],\n",
              "       [  5,  13,  75,  89,  35,  92, 666,   6,  12,   7],\n",
              "       [ 13,   6,  67,  69,  78, 151,   8, 572,   8,  28],\n",
              "       [ 66,  70,  31,  16,   7,  13,   7,   1, 751,  38],\n",
              "       [ 39, 122,  14,  28,  10,  23,   6,  12,  55, 691]])"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "##TODO: print the confusion matrix of test set\n",
        "##You can use sklearn.metrics.confusion_matrix\n",
        "from sklearn.metrics import confusion_matrix\n",
        "for i in range(len(true_labels)):\n",
        "  predictions[i] = predictions[i].numpy()\n",
        "  true_labels[i] = true_labels[i].numpy()\n",
        "\n",
        "confusion_matrix(true_labels, predictions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vHKUzhsj1eIT"
      },
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "19b57ba00ba848a6a6734896a35f734a": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "38483ae7003d456da86902c387082eb6": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "4f5feb7f8be3473aad94440e82cd70c3": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "599ecc0b38084f11bc7fd69dd9d334b4": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "66a3593b42ae4a88b2af58f65404ab3e": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_4f5feb7f8be3473aad94440e82cd70c3",
            "max": 170498071,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_ab858ddb0334423f885c8a7e12402d02",
            "value": 170498071
          }
        },
        "75ee320ea462427e93a172e58c5daba2": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "8f696108c08643048dff9363850eb239": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_d7fb3e89fb344566b1989819e37520c1",
              "IPY_MODEL_66a3593b42ae4a88b2af58f65404ab3e",
              "IPY_MODEL_b7668c4d4a574452a8c5dbf035794dc2"
            ],
            "layout": "IPY_MODEL_599ecc0b38084f11bc7fd69dd9d334b4"
          }
        },
        "ab858ddb0334423f885c8a7e12402d02": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "b7668c4d4a574452a8c5dbf035794dc2": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_38483ae7003d456da86902c387082eb6",
            "placeholder": "​",
            "style": "IPY_MODEL_75ee320ea462427e93a172e58c5daba2",
            "value": " 170498071/170498071 [00:10&lt;00:00, 17487205.24it/s]"
          }
        },
        "d7fb3e89fb344566b1989819e37520c1": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_19b57ba00ba848a6a6734896a35f734a",
            "placeholder": "​",
            "style": "IPY_MODEL_f88de0b1740141d7a56accec10ccdf94",
            "value": "100%"
          }
        },
        "f88de0b1740141d7a56accec10ccdf94": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}