Copy_of_StudentCopy_DoNotEdit_EmotionDetection_Section2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TiM6gYg0nhkY"
      },
      "source": [
        "<font color=\"#de3023\"><h1><b>REMINDER MAKE A COPY OF THIS NOTEBOOK, DO NOT EDIT</b></h1></font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H1K_OUCXfPzH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9ee82a98-e8f3-40e0-8959-b8758e4467ba"
      },
      "source": [
        "#@title Run this to download the data and setup our environment\n",
        "import cv2\n",
        "import dlib\n",
        "import gdown\n",
        "import pickle\n",
        "import warnings\n",
        "import itertools\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "\n",
        "import urllib.request\n",
        "\n",
        "from sklearn import metrics\n",
        "\n",
        "\n",
        "from scipy.spatial import distance\n",
        "from matplotlib import pyplot as plt\n",
        "from sklearn.decomposition import PCA\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.tree import DecisionTreeClassifier \n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "###Getting the csv data loaded\n",
        "!wget -O ./ferdata.csv \"https://storage.googleapis.com/inspirit-ai-data-bucket-1/Data/AI%20Scholars/Sessions%206%20-%2010%20(Projects)/Project%20-%20Emotion%20Detection/fer2013_5.csv\"\n",
        "\n",
        "###Getting the Dlib Shape predictor!\n",
        "!wget -O ./shape_predictor_68_face_landmarks.dat \"https://storage.googleapis.com/inspirit-ai-data-bucket-1/Data/AI%20Scholars/Sessions%206%20-%2010%20(Projects)/Project%20-%20Emotion%20Detection/shape_predictor_68_face_landmarks.dat\"\n",
        "\n",
        "###Getting the Xpure loaded\n",
        "!wget -O ./pureX.npy \"https://storage.googleapis.com/inspirit-ai-data-bucket-1/Data/AI%20Scholars/Sessions%206%20-%2010%20(Projects)/Project%20-%20Emotion%20Detection/pureX.npy\"\n",
        "\n",
        "###Getting the Xdata loaded\n",
        "!wget -O ./dataX.npy \"https://storage.googleapis.com/inspirit-ai-data-bucket-1/Data/AI%20Scholars/Sessions%206%20-%2010%20(Projects)/Project%20-%20Emotion%20Detection/dataX_edited.npy\"\n",
        "\n",
        "###Getting the Ydata loaded\n",
        "!wget -O ./dataY.npy \"https://storage.googleapis.com/inspirit-ai-data-bucket-1/Data/AI%20Scholars/Sessions%206%20-%2010%20(Projects)/Project%20-%20Emotion%20Detection/dataY.npy\"\n",
        "\n",
        "print (\"Data Downloaded!\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2021-07-01 05:29:09--  https://storage.googleapis.com/inspirit-ai-data-bucket-1/Data/AI%20Scholars/Sessions%206%20-%2010%20(Projects)/Project%20-%20Emotion%20Detection/fer2013_5.csv\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 172.217.193.128, 172.217.204.128, 172.217.203.128, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|172.217.193.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 167738172 (160M) [text/csv]\n",
            "Saving to: ‘./ferdata.csv’\n",
            "\n",
            "./ferdata.csv       100%[===================>] 159.97M   117MB/s    in 1.4s    \n",
            "\n",
            "2021-07-01 05:29:11 (117 MB/s) - ‘./ferdata.csv’ saved [167738172/167738172]\n",
            "\n",
            "--2021-07-01 05:29:11--  https://storage.googleapis.com/inspirit-ai-data-bucket-1/Data/AI%20Scholars/Sessions%206%20-%2010%20(Projects)/Project%20-%20Emotion%20Detection/shape_predictor_68_face_landmarks.dat\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 74.125.26.128, 172.217.193.128, 172.217.204.128, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|74.125.26.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 99693937 (95M) [application/octet-stream]\n",
            "Saving to: ‘./shape_predictor_68_face_landmarks.dat’\n",
            "\n",
            "./shape_predictor_6 100%[===================>]  95.08M  90.3MB/s    in 1.1s    \n",
            "\n",
            "2021-07-01 05:29:12 (90.3 MB/s) - ‘./shape_predictor_68_face_landmarks.dat’ saved [99693937/99693937]\n",
            "\n",
            "--2021-07-01 05:29:12--  https://storage.googleapis.com/inspirit-ai-data-bucket-1/Data/AI%20Scholars/Sessions%206%20-%2010%20(Projects)/Project%20-%20Emotion%20Detection/pureX.npy\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 74.125.141.128, 173.194.210.128, 173.194.211.128, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|74.125.141.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 46080128 (44M) [application/octet-stream]\n",
            "Saving to: ‘./pureX.npy’\n",
            "\n",
            "./pureX.npy         100%[===================>]  43.95M  91.0MB/s    in 0.5s    \n",
            "\n",
            "2021-07-01 05:29:13 (91.0 MB/s) - ‘./pureX.npy’ saved [46080128/46080128]\n",
            "\n",
            "--2021-07-01 05:29:13--  https://storage.googleapis.com/inspirit-ai-data-bucket-1/Data/AI%20Scholars/Sessions%206%20-%2010%20(Projects)/Project%20-%20Emotion%20Detection/dataX_edited.npy\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 172.217.193.128, 172.217.204.128, 172.217.203.128, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|172.217.193.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 364480128 (348M) [application/octet-stream]\n",
            "Saving to: ‘./dataX.npy’\n",
            "\n",
            "./dataX.npy         100%[===================>] 347.59M  99.5MB/s    in 3.5s    \n",
            "\n",
            "2021-07-01 05:29:16 (99.5 MB/s) - ‘./dataX.npy’ saved [364480128/364480128]\n",
            "\n",
            "--2021-07-01 05:29:16--  https://storage.googleapis.com/inspirit-ai-data-bucket-1/Data/AI%20Scholars/Sessions%206%20-%2010%20(Projects)/Project%20-%20Emotion%20Detection/dataY.npy\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 173.194.218.128, 64.233.170.128, 74.125.31.128, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|173.194.218.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 160128 (156K) [application/octet-stream]\n",
            "Saving to: ‘./dataY.npy’\n",
            "\n",
            "./dataY.npy         100%[===================>] 156.38K  --.-KB/s    in 0.001s  \n",
            "\n",
            "2021-07-01 05:29:17 (107 MB/s) - ‘./dataY.npy’ saved [160128/160128]\n",
            "\n",
            "Data Downloaded!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r-AYdejyX9Cg"
      },
      "source": [
        "c = 0\n",
        "for i in range(67,0,-1):\n",
        "  c += i\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6U-YonzaYKLv",
        "outputId": "f8df9d37-8df7-46cf-dfb0-0361121dcea4"
      },
      "source": [
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2278"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EIrowe2Atd1W"
      },
      "source": [
        "In this notebook we'll be:\n",
        "1.   Understanding the Feature Generation Process\n",
        "2.   Understanding, Visualizing, and Preparing the Data\n",
        "3.   Applying Machine Learning to Emotion Detection\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DtHdXOQqF_kA"
      },
      "source": [
        "#Milestone 1: Understanding Feature Generation Process"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KgB5l___P_Ja"
      },
      "source": [
        "## Instructor-led Discussion: Understanding the significance of Facial landmarks\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1b8i6ra4rG1T"
      },
      "source": [
        "Take a look at the images with facial landmarks superimposed over the faces!\n",
        "\n",
        "![alt text](https://upload.wikimedia.org/wikipedia/commons/0/0a/Dlib-face_landmark_detection.jpg)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xLn2UT8XiF3X"
      },
      "source": [
        "###Exercise 1A(Discussion) | Est Time: | Within a student group"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9mQpj-xyqNJr"
      },
      "source": [
        "#### Comment on positions of Facial Landmarks(FL) based on different emotion images? Can we used euclidean distance to distinguish between emotions?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dqw7wKpPSCUR"
      },
      "source": [
        "##Distance between Facial Landmarks\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bNftU_43j2AZ"
      },
      "source": [
        "Based on our discussion, we can use the euclidean distances of all facial landmarks with each other and use it as input (X) to our model to predict our emotions (Y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VKiMk58TjzKc"
      },
      "source": [
        "###Exercise 1B (Discussion) | Est Time: | Within a student group"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ex66YDjYjuRN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5c0971d4-94a2-482f-d20c-c13991b2da46"
      },
      "source": [
        "#@title Q1: Number of distance values after computing euclidean distances among facial landmarks? Q2: Number of distance values after computing euclidean distances (exclusive of distances of facial landmarks points with itself and repeats)? { display-mode: \"form\" }\n",
        "\n",
        "Q1 = \"4624\" #@param [\"2278\",\"4556\",\"4624\",\"68\",\"Fill Me In\"] \n",
        "\n",
        "Q2 = \"2278\" #@param [\"2278\",\"4556\",\"4624\",\"68\",\"Fill Me In\"] \n",
        "\n",
        "if Q1 == '4624': \n",
        "  print('Yes! 68 * 68 = 4624.') \n",
        "else: \n",
        "  print('Try Again')\n",
        "\n",
        "if Q2 == \"2278\": \n",
        "  print(\"Thats Right! If we exclude the distance of points with itself and repeats, we will have 67+66+65+...+1 = 2278 distance values\")\n",
        "else: \n",
        "  print('Try again!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Yes! 68 * 68 = 4624.\n",
            "Thats Right! If we exclude the distance of points with itself and repeats, we will have 67+66+65+...+1 = 2278 distance values\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UiQPTFiMG-Ly"
      },
      "source": [
        "###Exercise Takeaways!\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xNRbQK8A25Zu"
      },
      "source": [
        "Facial landmark distances can be used as features (X) into a model where the outputs (Y) are emotions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_TxlMtSqDMMw"
      },
      "source": [
        "## Instructor-led Discussion: Emotion Detection Pipeline"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOrucHQ3mFQv"
      },
      "source": [
        "The three main components of Emotion Detection are as follows:\n",
        "\n",
        "\n",
        "1.   Image Preprocessing\n",
        "2.   Feature Extraction\n",
        "3.   Feature Classification\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MTquSms-HhMX"
      },
      "source": [
        "# Milestone 2: Understand,Visualize and Prepare the Data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ml8XwGzOVvWX"
      },
      "source": [
        "### Dataset Background"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kPAqGjslU4T2"
      },
      "source": [
        "We will use modified version of the fer2013 dataset consisting of five emotion labels. \n",
        "\n",
        "The dataset is stored in a csvfile. Each row in the csvfile denotes an instance. \n",
        "Every instance has two column attributes : \n",
        "\n",
        "*   Pixels of the image stored in string format \n",
        "*   Integer encoding of the target label\n",
        "\n",
        "There are total of 20,000 images distributed equally across the five emotions. The images are 48\\*48 grayscale cropped images. The csvfile consists of flattened array of the image stored in form of a string\n",
        "\n",
        "The target labels are integer encoded in the csvfile.They are mapped as follows:\n",
        "\n",
        "*   0 ---> Angry\n",
        "*   1 ---> Happy\n",
        "*   2 ---> Sad\n",
        "*   3 ---> Surprise\n",
        "*   4 ---> Neutral\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kbQ9sErcYPil"
      },
      "source": [
        "### Load the dataset "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0bg16jaZu7vF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "72a6dab0-082e-45d4-9765-3d884ef5b8ba"
      },
      "source": [
        "#Integer to Label Mapping\n",
        "label_map = {0:\"ANGRY\",1:\"HAPPY\",2:\"SAD\",3:\"SURPRISE\",4:\"NEUTRAL\"}\n",
        "\n",
        "#Load the datala\n",
        "df = pd.read_csv(\"./ferdata.csv\")\n",
        "df.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<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>emotion</th>\n",
              "      <th>pixels</th>\n",
              "      <th>Usage</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>215 216 215 215 215 216 216 216 214 178 81 30 ...</td>\n",
              "      <td>Training</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>4</td>\n",
              "      <td>244 244 244 244 243 244 242 190 132 93 81 73 7...</td>\n",
              "      <td>Training</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>4</td>\n",
              "      <td>255 255 255 255 255 255 255 255 255 255 255 25...</td>\n",
              "      <td>Training</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>4</td>\n",
              "      <td>38 56 60 52 58 65 53 44 35 48 59 60 36 30 21 3...</td>\n",
              "      <td>Training</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>4</td>\n",
              "      <td>77 40 27 21 22 25 20 31 27 17 27 42 47 55 51 4...</td>\n",
              "      <td>Training</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   emotion                                             pixels     Usage\n",
              "0        0  215 216 215 215 215 216 216 216 214 178 81 30 ...  Training\n",
              "1        4  244 244 244 244 243 244 242 190 132 93 81 73 7...  Training\n",
              "2        4  255 255 255 255 255 255 255 255 255 255 255 25...  Training\n",
              "3        4  38 56 60 52 58 65 53 44 35 48 59 60 36 30 21 3...  Training\n",
              "4        4  77 40 27 21 22 25 20 31 27 17 27 42 47 55 51 4...  Training"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "emNk3kn7-SWh",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 306
        },
        "outputId": "592c1620-be70-45a4-e641-6c88afd95cad"
      },
      "source": [
        "# generate x labels for our plot\n",
        "emotion_labels = [label_map[i] for i in label_map.keys()]\n",
        "\n",
        "# generate counts for each emotion type\n",
        "emotion_counts = [np.sum(df[\"emotion\"] == i) for i in range(len(label_map))]\n",
        "\n",
        "# generate a bar plot for our emotion labels that has different colors \n",
        "[plt.bar(x = emotion_labels[i], height = emotion_counts[i] ) for i in range(len(emotion_labels))] \n",
        "\n",
        "# make the plot interpretable with x and y labels + title\n",
        "plt.xlabel('EMOTION LABEL')\n",
        "plt.ylabel('N OBSERVSATIONS')\n",
        "plt.title('A balanced distribution of emotions in our data set', y=1.05); "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEhCAYAAACOZ4wDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3debxd473H8c9XhMZwjaFkEJeUUm1oil5cSk0toloqpUK1oaVVVUonami1qtStoVq5QhHpKFU1FKnqrSEqhhhDQhJBIoJQNPzuH89zYmVn77XOSc7e5yTn+3699uus9TzPetaz1ll7/9b4LEUEZmZmZZbr6gaYmVn352BhZmaVHCzMzKySg4WZmVVysDAzs0oOFmZmVsnBYglJGi/p84s57aWSTu/sNi0JSSFp43aWPUXSr/LwQEnzJPXqpHZcJOk7eXgnSdM7o95c3w6SHu2s+jow300kTZT0iqSvtHr+ZYrru0Xz69TtpZk6e/tbWjlYNJCDwIuSVuzqtiwNIuLpiFglIt4qKyfpUEm3t6O+IyPitM5oW20AjIi/RcQmnVF3B50A3BoRq0bEeV0wf6D+/6Az13d7tHd7Wdq0d/tuwnwX7Lg1i4NFHZIGATsAAezTpY3pgZaGvc3FtAEwqasbYe+QtHxXt2GpERH+1HyA7wJ/B34CXFtRdjzwA+Au4GXgGmDNQv6vgWeBl4DbgM0LeZcCp+fhNYBrgVnAi3m4f818TsvtegW4EVi7kL898H/AXGAacGhOXxH4MfA08BxwEdCnMN3xwEzgGeBzpAC5cYNl3RD4a57/TcDPgF/lvEF52uXz+KHAk7nsFOAg4L3A68BbwDxgbmE9XAhcB7wKfLRm3ewETAe+CcwGpgIH1aybzxfGDwVuz8O35Xa9muf56bb6CuXfm+uYS/ox36fmf3Q+8Ke8LHcCG5VsD/vkOubmOt+b02/Jy/16bsd76ky7GnBJ/n/MAE4HehWW6e/AObnuJ4H/yunTgOeBETV1XUbanp4Cvk3aOSz7H5xemP4LwGRgDjAOWL+QF8CRwOO5LecDynkbk7aRl/L/6uoG62kQC28v4ynZvutMX7d9tfXWbh816/GF4jIXyvfJ6+NF4CHSd6S4vZwIPJHb+RDwicJ2VG/dfhy4l/T7MA04pWS51iZ99+fmZfsbsFzOWx/4bf6fTgG+ktP3AN4E/p3ne19TfhebUenS/skb4ZeAD+Z/wLolZceTvtjvA1bO/8xfFfI/B6xK+tE+F5hYyFvwBQXWAj4JrJTL/xr4Q818ngDekzfm8cCZOW+DvOEOB3rnuobkvHPyl2nNXO8fgR8UNrLnCm2/kvJg8Q9SAF0R+O88z0WCRa7rZWCTnLceOUhS+CGvWQ8vAduRftDexaLBYn5h3juSfvw3KaybusEijy+0TBSCRV5fk0mBaAVg57xcmxTa9gKwdV62K4AxDdbPe3K7ds31npDrXqFeO+tM/3vg53n9rUPaATmisEzzgcOAXqRA8jTph3pFYLfc7lVy+ctIOy6r5v/NY8DhFf+DtvW9M+mHfqtc9/8At9Wsz2uB1YGBpB+vPXLeVcC3Cv/H7Rss6yAWDRZ1t+860zZsX229teu9sB6/nP+fferUfybpR3pNYADwIAsHi/1JP9zLkXY+XgXWK1m3OwFb5PLvJ33n9m2wbD8g7dD1zp8dAOVp7yHtyK4A/Cdph2H3PN0pFH53mvK72MzKl8YPaQ/93+S9GuAR4NiS8gtt1MBmpCjfq07Z1fOGvFoeX/AFrVN2CPBizXy+XRj/EnB9Hj4J+H2dOpQ35I0KaR8GpuThUTVtfw8NggXpR2E+sHIh7UoaB4u5pODXp6aeel+mS4HL6qTVBovivMcC3ymsm8UNFjuQjvyWK+RfRd77y+34ZSHvY8AjDf5n3wHGFsaXI+1I7FSvnTXTrgu8wcJHfcNJ1zjalunxQt4WebnWLaS9kLebXqRtcLNC3hHA+Ir/Qdv6vgT4USFvFdJ3YlBhfW5fyB8LnJiHLwMupnBU3GB5F2wvVdt3nWkbtq+23tr1npf96Yq2PUkOfnl8JIVgUaf8RGBYo3Vbp/y5wDkN8k4lBfmNa9K3qW036Xv/v3n4FJocLHzNYlEjgBsjYnYevzKnlZlWGH6KtEewtqReks6U9ISkl0mnTyAdai5E0kqSfi7pqVz2NmD1mvP3zxaGXyN9SSDt/TxRp119SUcq90iaK2kucH1Oh7R3VNv2RtYnBa9Xq8rnMp8mnaqYKelPkjYtqZuadtRTb97rV0zTHusD0yLi7Zq6+xXGG633enUtWCe5zmk1dTWyAWm7mVn4X/2cdITR5rnC8L/yPGrTViFtX71Z+P9Tu0xlapdjHikQtWednEDaSblL0iRJn2vnPMvqXJz2lana1kq/F5IOyXe1tf2f3ked73Sh/DaSbpU0S9JLpO9Fo/JnkY5Gb5T0pKQTc/oGwPpt88zz/SZpJ6MlfHGnQFIf4ACgl6S2DXdF0o/2ByLivgaTDigMDyTt5cwGPgMMI52Dn0o6j/wi6ctU6zhgE2CbiHhW0hDSec56ZWtNI50mqTWb9AOyeUTMqJM/s07bG5kJrCFp5cKP9kDSXtwiIuIG4Ia8Tk8HfsE7Nw3UnaRk3jSY94N5+FVSUGzz7oq6ip4BBkharhAwBpJO23TUM6Q9fgAkibR+6637WtNIRxZrR8T8xZh30WzSNrgB6Zw6pGVqa0fVun4mTwuApJVJpzYrlyMiniVdT0DS9sBfJN0WEZM7sgBL0L627WMl0qlQWHR7qFr+tu9F280IC74XkjYgbcu7AP+IiLckTeSd72m9uq8kXd/bMyJel3QuDYJFRLxC+i04TtL7gFsk3U3aPqZExOAGba5apiXmI4uF7Uu6OLUZ6XB+COmi1d+AQ0qmO1jSZpJWIh1G/ibSLYGrkn4AXiBtvN8vqWNV0g/7XElrAid3oN1XAB+VdICk5SWtJWlI/vH7BXCOpHUAJPWTtHuebixwaKHtDecZEU8BE4DvSVoh/xDsXa+spHUlDctf4jdIF93afoifA/pLWqEDy9embd47AHuRrutAOg2wXz462xg4vGa650jneOu5k7QXe4Kk3pJ2yss1ZjHaNxb4uKRdJPUmfenfIN14UCoiZpIu6p4t6T8kLSdpI0k7drQRedsbC5whadX8A/c1oO3Wyqr/wVXAYZKG5FvHvw/cGRFTq+YtaX9J/fPoi6QfsbdLJlkcDdsXEbNIQePgfGT/OWCjDtY/FjhJ0hp5Wb5cyFuZtEyzACQdRjqyaFNv3a4KzMmBYmvSTmRdkvaStHHe0XiJ9Hv0Nun61SuSviGpT16290n6UGG+gyQ17TfdwWJhI0jnAJ+OiGfbPqS9goNKbrO7nHTO91nSRb22B64uIx3CziDt4d1RMu9zSRf2Zudy17e30RHxNOlc+nGkOygmAh/I2d8gHdbekU9v/YV0BENE/DnP95Zc5paKWX2GdO50DimwXNag3HKkH6dnctkdgS/mvFtIe2zPSppdf/K6niX9+DxDCo5HRsQjOe8c0jn654DROb/oFGB0Pnw/oJgREW+SgsOepHV/AXBIoe52i4hHgYNJF1xn53r3zvNoj0NIFy8fIi3rb0g3ByyOL5P2sp8Ebift3Y7KeaX/g4j4C+n6y29Je9kbAQe2c74fAu6UNI90Y8UxEfHkYi5DXe1o3xdIdzC9AGxOO4J1je+RvrdTSAH88sK8HwLOJt3s8RzpSPLvhWnrrdsvAadKeoV0gXpsybwHk76j8/I8LoiIW/MOwF6kHdgppO3rl6SzFfDOjtMLkv7ZweVtl7bb3czMzBrykYWZmVVysDAzs0oOFmZmVsnBwszMKjlYmJlZJQcLMzOr5GBhZmaVHCzMzKySg4WZmVVysDAzs0oOFmZmVsnBwszMKjlYmJlZJQcLMzOr5GBhZmaVlsnXqq699toxaNCgrm6GmdlS5Z577pkdEX3r5S2TwWLQoEFMmDChq5thZrZUkfRUozyfhjIzs0oOFmZmVsnBwszMKjlYmJlZJQcLMzOr1PRgIamXpHslXZvHN5R0p6TJkq6WtEJOXzGPT875gwp1nJTTH5W0e7PbbGZmC2vFkcUxwMOF8R8C50TExsCLwOE5/XDgxZx+Ti6HpM2AA4HNgT2ACyT1akG7zcwsa2qwkNQf+DjwyzwuYGfgN7nIaGDfPDwsj5Pzd8nlhwFjIuKNiJgCTAa2bma7zcxsYc0+sjgXOAF4O4+vBcyNiPl5fDrQLw/3A6YB5PyXcvkF6XWmMTOzFmjaE9yS9gKej4h7JO3UrPkU5jcSGAkwcODAJapr0Il/6owmdbmpZ3684xOdslrnN6SrnPJSh4pvMXqLJjWk9R4Y8UCHp3l40/c2oSVd472PPFxdqOD8I29pUkta76iLdm5Kvc08stgO2EfSVGAM6fTTT4HVJbUFqf7AjDw8AxgAkPNXA14opteZZoGIuDgihkbE0L5963ZtYmZmi6lpwSIiToqI/hExiHSB+paIOAi4FfhULjYCuCYPj8vj5PxbIiJy+oH5bqkNgcHAXc1qt5mZLaorOhL8BjBG0unAvcAlOf0S4HJJk4E5pABDREySNBZ4CJgPHBURb7W+2WZmPVdLgkVEjAfG5+EnqXM3U0S8DuzfYPozgDOa10IzMyvjJ7jNzKySg4WZmVVysDAzs0oOFmZmVsnBwszMKjlYmJlZJQcLMzOr5GBhZmaVHCzMzKySg4WZmVVysDAzs0oOFmZmVsnBwszMKjlYmJlZJQcLMzOr5GBhZmaVHCzMzKxS04KFpHdJukvSfZImSfpeTr9U0hRJE/NnSE6XpPMkTZZ0v6StCnWNkPR4/oxoNE8zM2uOZr5W9Q1g54iYJ6k3cLukP+e84yPiNzXl9wQG5882wIXANpLWBE4GhgIB3CNpXES82MS2m5lZQdOOLCKZl0d750+UTDIMuCxPdwewuqT1gN2BmyJiTg4QNwF7NKvdZma2qKZes5DUS9JE4HnSD/6dOeuMfKrpHEkr5rR+wLTC5NNzWqN0MzNrkaYGi4h4KyKGAP2BrSW9DzgJ2BT4ELAm8I3OmJekkZImSJowa9aszqjSzMyyltwNFRFzgVuBPSJiZj7V9Abwv8DWudgMYEBhsv45rVF67TwujoihETG0b9++zVgMM7Meq5l3Q/WVtHoe7gPsCjySr0MgScC+wIN5knHAIfmuqG2BlyJiJnADsJukNSStAeyW08zMrEWaeTfUesBoSb1IQWlsRFwr6RZJfQEBE4Ejc/nrgI8Bk4HXgMMAImKOpNOAu3O5UyNiThPbbWZmNZoWLCLifmDLOuk7NygfwFEN8kYBozq1gWZm1m5+gtvMzCo5WJiZWSUHCzMzq+RgYWZmlRwszMyskoOFmZlVcrAwM7NKDhZmZlbJwcLMzCo5WJiZWSUHCzMzq+RgYWZmlRwszMyskoOFmZlVcrAwM7NKDhZmZlbJwcLMzCo18x3c75J0l6T7JE2S9L2cvqGkOyVNlnS1pBVy+op5fHLOH1So66Sc/qik3ZvVZjMzq6+ZRxZvADtHxAeAIcAekrYFfgicExEbAy8Ch+fyhwMv5vRzcjkkbQYcCGwO7AFckN/rbWZmLdK0YBHJvDzaO38C2Bn4TU4fDeybh4flcXL+LpKU08dExBsRMQWYDGzdrHabmdmimnrNQlIvSROB54GbgCeAuRExPxeZDvTLw/2AaQA5/yVgrWJ6nWmK8xopaYKkCbNmzWrG4piZ9VhNDRYR8VZEDAH6k44GNm3ivC6OiKERMbRv377Nmo2ZWY/U7mAhqbekLSWt09GZRMRc4Fbgw8DqkpbPWf2BGXl4BjAgz2t5YDXghWJ6nWnMzKwFGgYLSRdJ2jwPrwbcB1wG3CtpeFXFkvpKWj0P9wF2BR4mBY1P5WIjgGvy8Lg8Ts6/JSIipx+Y75baEBgM3NWhpTQzsyWyfEneDhFxZB4+DHgsIvaV9G7gz8BVFXWvB4zOdy4tB4yNiGslPQSMkXQ6cC9wSS5/CXC5pMnAHNIdUETEJEljgYeA+cBREfFWh5fUzMwWW1mweLMwvCvwa4CIeDbdpFQuIu4HtqyT/iR17maKiNeB/RvUdQZwRuVMzcysKcquWcyVtJekLYHtgOthwfWEPq1onJmZdQ9lRxZHAOcB7wa+GhHP5vRdgD81u2FmZtZ9NAwWEfEY6Ynp2vQbgBua2SgzM+teGgYLSd8tmS4i4rQmtMfMzLqhstNQr9ZJWwn4POnJagcLM7Meouw01Nltw5JWBY4BPgeMAc5uNJ2ZmS17yo4skLQm8DXgIFInf1tFxIutaJiZmXUfZdcszgL2Ay4Gtij0IGtmZj1M2XMWxwHrA98GnpH0cv68Iunl1jTPzMy6g7JrFn7lqpmZARXXLAAkfYT0ljqAByNifFNbZGZm3U7ZNYt+wO+A14F7cvL+uQfZT0SEuwk3M+shyo4sfgZcGBGXFhMlHQJcQHrdqZmZ9QBl1yU2qw0UABFxGU18452ZmXU/ZcGibp6k5YBezWmOmZl1R2XB4lpJv5C0cltCHr4IuK7pLTMzs26jLFicALwEPCXpHkn/BKYCLwNfb0HbzMysm2gYLCLi3xHxdWAAcCjp/dgbRMTXI+LNRtO1kTRA0q2SHpI0SdIxOf0USTMkTcyfjxWmOUnSZEmPStq9kL5HTpss6cQlWF4zM1sMZbfO7lcneXDbK1Uj4ncVdc8HjouIf+aOCO+RdFPOOyciflwzv81I793enPTk+F8kvSdnn096tet04G5J4yLioYr5m5lZJym7dXbvkrwgPYPRuEDETGBmHn5F0sNAv5JJhgFjIuINYIqkybzzru7J+d3dSBqTyzpYmJm1SFmw+GM7jh7aRdIgYEvgTtL7vI/Oz2tMIB19vEgKJHcUJpvOO8FlWk36NnXmMRIYCTBw4MDOaLaZmWVlF7i/3RkzkLQK8FvSe7xfBi4ENgKGkI48OuXdGBFxcUQMjYihffv27Ywqzcwsq+wbaklI6k0KFFe0HaVExHOF/F8A1+bRGaSL6W365zRK0s3MrAXKgsWmku6vky7SO7jfX1ax0pXwS4CHI+InhfT18vUMgE8AD+bhccCVkn5CusA9GLgrz2+wpA1JQeJA4DOVS2ZmZp2mLFhMofwid5XtgM8CD0iamNO+CQyXNIR0kXwqcARAREySNJZ04Xo+cFREvAUg6WjgBtKT46MiYtIStMvMzDqoLFi8GRFPLW7FEXE76aigVsOnvyPiDOCMOunXlU1nZmbNVXaB+++1CZI2kvQdSd6zNzPrQcqe4D4aQNL6ko6VdDcwKU9zYIvaZ2Zm3UDDYCFppKRbgfHAWsDhwMyI+F5EPNCi9pmZWTdQ9fKjfwCfiYgJAJKiJa0yM7NupSxYrAfsD5wt6d3AWKB3S1plZmbdStk1ixci4qKI2BHYBZgLPCfpYUnfb1kLzcysy5XdDbVAREyPiLMjYiiwD/B6c5tlZmbdSVkX5RsAcyPipTz+EWBf4CngzNY0z8zMuoOyI4uxwMoA+YnrXwNPAx8gvV/CzMx6iLIL3H0i4pk8fDCpm42zJS0HTCyZzszMljFlRxbFrjp2Bm4GiIi3m9oiMzPrdsqOLG7NHfvNBNYAboHUayxQ+Q5uMzNbdpQFi2OAT5Oet9g+Iv6d098NfKvZDTMzs+6j6gnuqyJiTDExIu5tbpPMzKy7Kbtm8RhwlqSpkn4kactWNcrMzLqXsie4fxoRHwZ2BF4ARkl6RNLJkt7TshaamVmXq3yCOyKeiogfRsSWwHDSg3kPN71lZmbWbVQGC0nLS9pb0hXAn4FHgf3aMd0ASbdKekjSJEnH5PQ1Jd0k6fH8d42cLknnSZos6X5JWxXqGpHLPy5pxGIvrZmZLZay91nsKmkUMAP4AvAnYKOIODAirmlH3fOB4yJiM2Bb4ChJmwEnAjdHxGDSsxsn5vJ7AoPzZyRwYW7HmsDJwDbA1sDJbQHGzMxao+zI4iTS+yw2jYh9IuLKiHgVQNLKVRVHxMyI+GcefoV06qofMAwYnYuNJp3WIqdfFskdwOr5mY7dgZsiYk5EvAjcBOzR0QU1M7PFV3aBe2fgOmAjSSsASFond0/+eEdmImkQsCVwJ7BuRMzMWc8C6+bhfsC0wmTTc1qj9Np5jJQ0QdKEWbNmdaR5ZmZWoew01DGkPqD+B7hD0udJRwd9gA+2dwaSVgF+C3w1Il4u5kVEAJ3y9r2IuDgihkbE0L59+3ZGlWZmlpU9lHcEsElEzJE0kPTcxXYRcU97K5fUmxQoroiI3+Xk5yStFxEz82mm53P6DGBAYfL+OW0GsFNN+vj2tsHMzJZc2TWL1yNiDkBEPA082sFAIeAS4OGI+EkhaxzQdkfTCOCaQvoh+a6obYGX8umqG4DdJK2RL2zvltPMzKxFyo4s+ks6rzC+XnE8Ir5SUfd2wGeBByS1dWn+TdKLk8ZKOpz0IqUDct51wMeAycBrwGF5PnMknQbcncud2hbEzMysNcqCxfE14+0+qgCIiNtZuJvzol3qlA/gqAZ1jQJGdWT+ZmbWeRoGi4gY3ShPUlmQMTOzZUzZ3VC3F4Yvr8m+q2ktMjOzbqfsAnfxwbvNa/IanV4yM7NlUFmwKHv+oVOejTAzs6VD2bWH1SV9ghRQVpfU1nmggNWa3jIzM+s2yoLFX4F9CsN7F/Jua1qLzMys2ym7G+qwVjbEzMy6r7K7ofaWtEFh/LuS7pM0TtKGrWmemZl1B2UXuM8AZgFI2gs4GPgcqVuOi5rfNDMz6y5K74aKiNfy8H7AJRFxT0T8EnC3rmZmPUhZsJCkVSQtR+qe4+ZC3rua2ywzM+tOyu6GOpf0PouXST3HTgCQtCUws2Q6MzNbxpTdDTVK0g3AOsB9haxnyT3CmplZz1DVIeDywLSIeDu/Y2J74ImI+H3zm2ZmZt1Fw2Ah6buklxOFpDHAR0lvqPu4pB0j4qutaaKZmXW1siOLA4H3AisBTwPvjojXcvfkE0umMzOzZUxZsHg9It4E3pT0RNtttBExX9KbrWmemZl1B2W3zq4uaT9JnwT+Iw+3jVd2JChplKTnJT1YSDtF0gxJE/PnY4W8kyRNlvSopN0L6XvktMmSTlzM5TQzsyVQ1ZFgW+eBt9HxjgQvBX4GXFaTfk5E/LiYIGkz0mmvzYH1gb9Iek/OPh/YFZgO3C1pXEQ81I75m5lZJ2laR4IRcZukQe0sPgwYExFvAFMkTQa2znmTI+JJgHyhfRjgYGFm1kJlp6GQ9D5JoyVNyJ/RkrZYwnkeLen+fJpqjZzWD5hWKDM9pzVKr9fWkW3tnDVr1hI20czMisp6nR0G/J50Oupz+fNX4Hc5b3FcCGwEDCE9BX72YtaziIi4OCKGRsTQvn3ddZWZWWcqu2ZxKrBrREwtpN0v6RbgmvzpkIh4rm1Y0i+Aa/PoDGBAoWj/nEZJupmZtUjZaajlawIFADmt9+LMTNJ6hdFPAG13So0DDpS0Yn5XxmDgLuBuYLCkDSWtQLoIPm5x5m1mZouv7MhivqSBEfF0MTG/EGl+VcWSrgJ2AtaWNB04GdhJ0hAggKnAEQARMUnSWNKF6/nAURHxVq7naOAGoBcwKiImdWgJzcxsiZUFi5NJt7B+H7gnpw0FTgS+UVVxRAyvk3xJSfkzSC9cqk2/Driuan5mZtY8ZbfO/kHSFOA44Ms5eRJwQETc12g6MzNb9pT2OpuDwiEtaouZmXVTpc9ZmJmZgYOFmZm1g4OFmZlVqnr5USMREac1oT1mZtYNlV3gfrVO2krA54G1AAcLM7MeouzW2QX9NklaFTiG1D/UGDqxTyczM+v+Sm+dlbQm8DXgIGA0sFVEvNiKhpmZWfdRds3iLGA/4GJgi4iY17JWmZlZt1J2N9RxpLfWfRt4RtLL+fOKpJdb0zwzM+sOyq5Z+LZaMzMD/JyFmZm1g4OFmZlVcrAwM7NKDhZmZlbJwcLMzCo1LVhIGiXpeUkPFtLWlHSTpMfz3zVyuiSdJ2mypPslbVWYZkQu/7ikEc1qr5mZNdbMI4tLgT1q0k4Ebo6IwcDNeRxgT2Bw/owELoQFT5CfDGwDbA2c3BZgzMysdZoWLCLiNmBOTfIwUrch5L/7FtIvi+QOYHVJ6wG7AzdFxJzczchNLBqAzMysyVp9zWLdiJiZh58F1s3D/YBphXLTc1qj9EVIGilpgqQJs2bN6txWm5n1cF12gTsiAohOrO/iiBgaEUP79u3bWdWamRmtDxbP5dNL5L/P5/QZwIBCuf45rVG6mZm1UKuDxTig7Y6mEcA1hfRD8l1R2wIv5dNVNwC7SVojX9jeLaeZmVkLlb7PYklIugrYCVhb0nTSXU1nAmMlHQ48BRyQi18HfAyYDLwGHAYQEXMknQbcncudGhG1F83NzKzJmhYsImJ4g6xd6pQN4KgG9YwCRnVi08zMrIP8BLeZmVVysDAzs0oOFmZmVsnBwszMKjlYmJlZJQcLMzOr5GBhZmaVHCzMzKySg4WZmVVysDAzs0oOFmZmVsnBwszMKjlYmJlZJQcLMzOr5GBhZmaVHCzMzKySg4WZmVXqkmAhaaqkByRNlDQhp60p6SZJj+e/a+R0STpP0mRJ90vaqivabGbWk3XlkcVHImJIRAzN4ycCN0fEYODmPA6wJzA4f0YCF7a8pWZmPVx3Og01DBidh0cD+xbSL4vkDmB1Set1RQPNzHqqrgoWAdwo6R5JI3PauhExMw8/C6ybh/sB0wrTTs9pC5E0UtIESRNmzZrVrHabmfVIy3fRfLePiBmS1gFukvRIMTMiQlJ0pMKIuBi4GGDo0KEdmtbMzMp1yZFFRMzIf58Hfg9sDTzXdnop/30+F58BDChM3j+nmZlZi7Q8WEhaWdKqbcPAbsCDwDhgRC42ArgmD48DDsl3RW0LvFQ4XWVmZi3QFaeh1gV+L6lt/ldGxPWS7gbGSjoceAo4IJe/DvgYMBl4DTis9U02M+vZWh4sIuJJ4AN10l8AdqmTHsBRLWiamZk10J1unTUzs27KwcLMzCo5WJiZWSUHCzMzq+RgYWZmlRwszMyskoOFmZlVcrAwM7NKDhZmZlbJwdfaRaIAAAq4SURBVMLMzCo5WJiZWSUHCzMzq+RgYWZmlRwszMyskoOFmZlVcrAwM7NKDhZmZlZpqQkWkvaQ9KikyZJO7Or2mJn1JEtFsJDUCzgf2BPYDBguabOubZWZWc+xVAQLYGtgckQ8GRFvAmOAYV3cJjOzHkMR0dVtqCTpU8AeEfH5PP5ZYJuIOLpQZiQwMo9uAjza8oZ2zNrA7K5uRBfpycsOPXv5e/KyQ/df/g0iom+9jOVb3ZJmiYiLgYu7uh3tJWlCRAzt6nZ0hZ687NCzl78nLzss3cu/tJyGmgEMKIz3z2lmZtYCS0uwuBsYLGlDSSsABwLjurhNZmY9xlJxGioi5ks6GrgB6AWMiohJXdysJbXUnDJrgp687NCzl78nLzssxcu/VFzgNjOzrrW0nIYyM7Mu5GBhZmaVHCyWgKR9JYWkTfP4oDz+5UKZn0k6tDD+NUmPSHpA0n2SfiKpd86bmtPvl/RXSRtI+oKkqwvT/4ekJyT9ZwsXdRGS5tWMHyrpZzVpEyWNqUm7VNKUnPdPSR9ulC7pCklfLEy7TV43vZu5bEtC0rckTcrtnChpm5y+vKRZks6sKT8+d2Nzf94ufiZp9a5p/ULtWmQ58va5dqHMTpKuzcOH5uWbmJfj2EK5UyTNyHkPStqnTvpDkoYXprk0P1+FpL0k3Zu/Lw9JOqLO9G2fTll3+Xt8dmH865JOKZtvg+/AeElDJd2Zyz1dWE8T82/GIt/7mjr+IOmOmrRTJH29M5a1vRwslsxw4Pb8t83zwDFKd20tRNKRwG7AthGxBfChXL5PodhHIuL9wHjg28AvgQGSPprzTyVd4H+yk5elU0l6L+lmhB0krVyTfXxEDAFOBH5ekv414HhJfSUtB/wM+FJE/Lv5S9BxOfDtBWyV/4cfBabl7F2Bx4D9Jalm0oNy+fcDbwDXtKjJdVUsR5mr8/9vO+Bbkoq3u5+T8/YHRuX/ZzF9GPDz2h2BPH4xsHdEfADYkvTdWKjewmduhxe4vjeA/YrBsUaH5hsR2+Tl/C55PeXP1Fyk9nsPQA5+HwRW6+odRAeLxSRpFWB74HDSrbxtZgE3AyPqTPYt4IttG1ZEvBkRZ0bEy3XK/gPoF+kOhCOBcyUNBXYBzuq8JWma4cDlwI007prlNmDjRukR8RzwY+BHpHVwf0Tc3oS2dpb1gNkR8QZARMyOiGdy3nDgp8DTwIfrTZy7sjkBGCjpAy1obyNly1EpIl4AJud6avMeBuaTnmQupj8OvAasUTPJqqS7Nl/I5d6IiFb0zjCfFKSOrSrYyf4B9CuM7wf8kdTF0YF1p2gRB4vFNwy4PiIeA16Q9MFC3g+Bryt1gAik00fAKhExpZ317wH8ASAi7ifdNnwz8OX8o9LV+hQPw0lHPEWfJm3gV7HwkVfR3sADFekXkTqPPJ70Q9qd3Ug6CnxM0gWSdgSQ9C7S3vkfKV8fRMRbwH3Api1obyN1l6O9JA0E3gXcXydvG+Bt0k5VMX0r4PGIeL6YHhFzSM9UPSXpKkkHFY5KAI4tbIe3dqSd7XA+cJCk1erkNWu+C7732XDSNlO63bSCg8XiG076MST/XfCPzKeI7gQ+02hiSbvnDW2qpP8qZN0qaQaph92rCunnAzMiYnwntX9J/at4GE46vAYgHwHNjoinSQFuS0lrFqY9KweYkaQjs4bpEfE26ZTUn/Mea7cVEfNIpwxGkn4Mr1a6XrUXcGtE/Av4LbBvcUeijtrTVC1Vshz17rMvpn1a0v2ko4oLIuL1Qt6x+X/7Y+DT8c49+8dKmkT6vpzRoD2fJx1R3wV8HRhVyC6eDvpIBxe1VD7ivwz4Sp3sevNt9BxCe55PWOR7L2ldYDBwe94p/bek93VoITqRg8ViyD98OwO/lDSVtNd7AAt/yb8PfKMtLW948yRtmMdvyD+yDwLF6xsfATYAJgLfK6S/nT9Lg+HApnndPAH8B/DJQv7x+Uu2a0Q82I70pWbZI+KtiBgfEScDR5OWezjw0bw+7gHWIm0/i8hBZAvg4da0uL4Gy/ECC58mWpOFO8W7Op93/y/gTEnvLuS1/bjuEBF/q0nfPNd/ST4Kq9eeByLiHNK1n0/WK9Mk55J2XGqvu9VTu35g0XXUSL3v/QG5vil52xlEFx5dOFgsnk8Bl0fEBhExKCIGAFMo9F8VEY8AD5FOqbT5AXBh2x0b+ULnIl+OiJgPfBU4pGaPvNvLpwgOALbI62YQ6ZRdlx5Ct4KkTSQNLiQNIe2Z7wAMLKyPo6izPvLF3B8A0/Kpxy7RYDmeIl18/Wwu0ws4GFjkFExETCBdrzqmvfOMiHHABGqu9UlaRdJOddrSEvk02FgWPgJu5G5gu7YgmY+wV6R9NwfU+94PJ/W23bbdfJAuvG6xVHT30Q0NJ12XKPotcFJN2hnAvYXxC0l7KHdKegOYB/y9pgwAETFT0lWkH5bTOqndrbAD6XRZ8YLobcBmkha54LmMWQX4n7wzMJ90OuYaYKW2i8XZNcCPJK2Yx6/I28OKwF/o+ne11FuOkcC/STs795GOmK8HftWgjh8C/5T0/Q7M91TgSkm/KKQJOEHSz4F/Aa8Chxbyj5V0cGF838IdRp3lbNLRVVHd+Uo6Brgu7zTNA4bnU6ntUvO93wC4o5A3RdJL+boPwLclfbWQ379ji9Ux7u7DzMwq+TSUmZlVcrAwM7NKDhZmZlbJwcLMzCo5WJiZWSUHC1vmSHpLC/cIemJOH6/U66cKZf+gQg+6kjaXdItST7CPS/qOksMK9b2p1EvoRElnqqa3UUkjlXpefUTSXZK2L+SNlzShMD5U0vg6yzBI0oO16TXtrtcTaVtvqI9IurCtawwt3KvvREn/l9MX6SnVrB4/Z2HLon/lp+PrmUvqFfX2/BzBgmc/JPUh9UP0xYi4UdJKpOdnvhQR5wP/m8tNJfUSOjuPH1qoYy/gCGD7iJit1OfRHyRtHRHP5mLrSNozIv68OAund3oinSfpP2PhHojPiYgf5yBxG7Aj7zw4d3xE/GZx5mnmIwvraYq9d+4H/K6Q9xng7xFxI0BEvEZ6GOvEDtT/DdKP8uxcxz+B0aSHrNqcReqBeHG1pyfSFUi9A7y4BPMxW8DBwpZFC/WIK+nThbybgf/O3VUcCFxdyNuc1HfTAhHxBLCKUq/B7bFIHaRuLDYvjP8DeFPS4nZ8V9YTaVuHfTOBxyJiYiHvrMI6uWIx5209lIOFLYsW6hE3IooB4S3SC6sOBPo0oWuI9jqdwktu2qsdPZG2vUxoHWBlScUjj+ML6+SgJWm89TwOFtYTjQHOI3UQV/QQ6VrAAkpvJ5vX4AVV9SxSRx6fVEyIiFtIb0jctp31tmlXT6SR3iZ4PfDfHazfrC4HC+uJ/kbq3fWqmvQrgO2VX2GbL3ifR3pTX3v9CPihpLVyHUNIHd9dUKfs6XT8hU7t6ok03/G1HamLeLMl5ruhbFnUJ5+3b3N9RCy4SJ1fvPPj2oki4l+ShpF6XD2f9A7xy0nv/m6XiBgnqR/wf5ICeAU4OCJm1il7naRZi1Tyjk0kTS+M/5TqnkjbekPtTXpTXTFInSWpeOpr6/z3UEn7FtK3jYjifM3c66yZmVXzaSgzM6vkYGFmZpUcLMzMrJKDhZmZVXKwMDOzSg4WZmZWycHCzMwq/T+0eRNY1Ejo/gAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0UPLgR0k-fEJ"
      },
      "source": [
        "###Exercise 2A Balanced vs. Unbalanced Datasets"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CG57yqywq1jW"
      },
      "source": [
        "####What would be the implications of an unbalanced dataset?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KaqNfQF5Y8iM"
      },
      "source": [
        "### Data Visualization"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1BbN1EO_-VMc"
      },
      "source": [
        "In this section, we will convert the flattened pixel arrays to 2D images, so as to plot facial landmarks over the images"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jTkynlyy75cm",
        "cellView": "form"
      },
      "source": [
        "#@title Run this code to setup the extraction of Facial Landmarks\n",
        "\n",
        "# Load's dlib's pretrained face detector model\n",
        "#frontalface_detector = dlib.get_frontal_face_detector()\n",
        "\n",
        "\n",
        "#Load the 68 face Landmark file\n",
        "predictor = dlib.shape_predictor('./shape_predictor_68_face_landmarks.dat')\n",
        "\"\"\"\n",
        "Returns facial landmarks for the given input image path\n",
        "\"\"\"\n",
        "def get_landmarks(image):\n",
        "  \n",
        "  \n",
        "  #:type image : cv2 object\n",
        "  #:rtype landmarks : list of tuples where each tuple represents \n",
        "  #                  the x and y co-ordinates of facial keypoints\n",
        "  \n",
        "  #Bounding Box co-ordinates around the face(Training data is 48*48(cropped faces))\n",
        "  rects = [dlib.rectangle(left=1, top=1, right=47, bottom=47)]\n",
        "\n",
        "  #Read Image using OpenCV\n",
        "  #image = cv2.imread(image_path)\n",
        "  #Detect the Faces within the image\n",
        "  landmarks = [(p.x, p.y) for p in predictor(image, rects[0]).parts()]\n",
        "  return image,landmarks\n",
        "\n",
        "\"\"\"\n",
        "Display image with its Facial Landmarks\n",
        "\"\"\"\n",
        "def image_landmarks(image,face_landmarks):\n",
        "  \"\"\"\n",
        "  :type image_path : str\n",
        "  :type face_landmarks : list of tuples where each tuple represents \n",
        "                     the x and y co-ordinates of facial keypoints\n",
        "  :rtype : None\n",
        "  \"\"\"\n",
        "  radius = -2\n",
        "  circle_thickness = 1\n",
        "  image_copy = image.copy()\n",
        "  for (x, y) in face_landmarks:\n",
        "    cv2.circle(image_copy, (x, y), circle_thickness, (255,0,0), radius)\n",
        "    \n",
        "  plt.imshow(image_copy, interpolation='nearest', cmap='Greys_r')\n",
        "  plt.xticks([]); plt.yticks([])\n",
        "  plt.show()\n",
        "  \n",
        " \n",
        "'''\n",
        "Converts pixels values to 2D-image. \n",
        "Displays the image and returns the cv2 image\n",
        "object\n",
        "'''\n",
        "def pixels_image(img_pixels,plt_flag):\n",
        "  \"\"\"\n",
        "  :type image_pixels : str\n",
        "  :type plt_flag : boolean\n",
        "  :rtype image : cv2 object\n",
        "  \"\"\"\n",
        "  \n",
        "  width = 48\n",
        "  height = 48\n",
        "  \n",
        "  image = np.fromstring(img_pixels, dtype=np.uint8, sep=\" \").reshape((height, width))\n",
        "  \n",
        "  if plt_flag:\n",
        "      plt.imshow(image, interpolation='nearest', cmap=\"Greys_r\")\n",
        "      plt.xticks([]); plt.yticks([])\n",
        "      plt.show()\n",
        "      \n",
        "      \n",
        "  return image\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fMrrq0fxlBbN"
      },
      "source": [
        "###Lets visualize our datapoints!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E6kqtTORlAZ3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 252
        },
        "outputId": "977e4076-1fe6-4f51-c60a-6b809cf807ea"
      },
      "source": [
        "# select random index \n",
        "i_index = np.random.randint(len(df))\n",
        "\n",
        "# extract pixel values \n",
        "image_pixels = df['pixels'][i_index]        \n",
        "\n",
        "# convert pixels to 2D Images\n",
        "image = pixels_image(image_pixels, True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pPIXX0PrpBdD",
        "outputId": "9beb1134-1f27-4b59-ccc7-6487f5e5eec3"
      },
      "source": [
        "df[\"emotion\"][i_index]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jWq-f7B-BOjh",
        "cellView": "form"
      },
      "source": [
        "#@title Can you get the label for the face above? "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iEKhOBy1-_aB"
      },
      "source": [
        "####Plot Facial Landmarks on the Datapoints"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LLcpEqE_-w-T",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 252
        },
        "outputId": "35543bd7-8282-4159-8f07-cceda678b2bd"
      },
      "source": [
        "#Extract the Facial Landmarks\n",
        "image,facial_landmarks = get_landmarks(image)\n",
        "#Display the Facial Landmarks on the Image\n",
        "image_landmarks(image,facial_landmarks)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "27HUOaMqagU7"
      },
      "source": [
        "###Extract the features and save the data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uh4mN71xbyvO"
      },
      "source": [
        " We'll need to create X and Y arrays for our model:\n",
        " \n",
        "      X is a list of lists, where each element in X represents a single picture\n",
        "                            where a picture is represented by a list distances \n",
        "                            between facial landmark points\n",
        "\n",
        "      Y is a list of numbers, where each element in Y represents the emotion \n",
        "                              for the corresponding picture\n",
        "\n",
        "      X_pixels is a list of lists, where each element in X represents a single \n",
        "                           picture where a picture is represented by its pixels \n",
        "\n",
        " X and Y must be ordered in the same way so that X[0] and Y[0] refer to the \n",
        " first picture, X[1] and Y[1] refer to the second picture, and so on.\n",
        "\n",
        " "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GiBA4Uz1ZjOb"
      },
      "source": [
        "###Euclidean Distance between Facial Landmarks"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dY7dapj_H8WK"
      },
      "source": [
        "In this section we want to compute the euclidean distances between all 68 Facial Landmark points, excluding the distances of the points with themselves. \n",
        "\n",
        "We can get all the pairs of indices up to 4 using the `itertools` library. Try it out!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "To9kDuP0IXsV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dfd5d3a8-3789-4c67-cdf0-067b1a0871a3"
      },
      "source": [
        "for i, j in itertools.combinations(range(4), 2):\n",
        "  print(i, j)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1\n",
            "0 2\n",
            "0 3\n",
            "1 2\n",
            "1 3\n",
            "2 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vA6Ple1HIcwT"
      },
      "source": [
        "The 4 determines the number of indices, and the 2 says we're interested in combinations of size 2. (try changing 2 to three and see what happens if you're curious!). \n",
        "\n",
        "Notice how pairs with the same numbers are skipped (i.e. 0 0 is skipped) and that for each pair only one ordering of that pair is used (i.e. we have 0 2 but not 2 0)! "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VeVQ30QHNT94"
      },
      "source": [
        "####Exercise(Coding)\n",
        "\n",
        "Use this special for loop to help us compute the euclidean distances for each pair of Facial Landmark points. Store all the distances in the list `e_dist`\n",
        "\n",
        "Hint: Instead of having indicies that go up to 4, we want to have indices that go up to the number of facial landmarks we have!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AblhKSuIZufy"
      },
      "source": [
        "\"\"\"\n",
        "Computes euclidean distance between 68 Landmark Points for our features\n",
        "e_dist is a list of features that will go into our model.\n",
        "Each feature is a distance between two landmark points, and every pair of points\n",
        "must have a feature. \n",
        "Scipy Library has readily available fuction to compute euclidean distance. You can \n",
        "compute the distance using distance.euclidean(point1,point2)\n",
        "point1,point2 :2D points\n",
        "\"\"\"\n",
        "def landmarks_edist(face_landmarks):\n",
        "  \n",
        "    e_dist = []\n",
        "    # FILL ME IN!\n",
        "    for i, j in itertools.combinations(range(68), 2):\n",
        "      e_dist.append(distance.euclidean(face_landmarks[i],face_landmarks[j]))\n",
        "    return e_dist"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Im_3G3gtaqsK"
      },
      "source": [
        "#@title Function that preprocesses the data to extract distances between all points\n",
        "\n",
        "def preprocess_data(df):\n",
        "  \n",
        "  X = []\n",
        "  Y = []\n",
        "  X_pixels = []\n",
        "  \n",
        "  n_pixels = 2304\n",
        "  \n",
        "  for index, row in (df.iterrows()):\n",
        "\n",
        "      if index%1000 == 0:\n",
        "        print (index, \"Datapoints Processed\")\n",
        "        \n",
        "      try:\n",
        "          image = pixels_image(row['pixels'],0)\n",
        "          X_pixels.append(image.ravel()) \n",
        "          image = cv2.GaussianBlur(image,(5,5),0)\n",
        "         \n",
        "          _,face_landmarks = get_landmarks(image)\n",
        "          X.append(landmarks_edist(face_landmarks)) # Using our feature function!\n",
        "          Y.append(row['emotion'])\n",
        "\n",
        "      except Exception as e:\n",
        "          print (\"An error occured:\",e)\n",
        "\n",
        "  #Save the data \n",
        "  np.save(\"pureX\", X_pixels)\n",
        "  np.save(\"dataX\", X)\n",
        "  np.save(\"dataY\", Y)\n",
        "  \n",
        "  return np.array(X_pixels),np.array(X),np.array(Y) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5tMU3NCZcpcF"
      },
      "source": [
        "###Load the Saved Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cypubed0HIBt"
      },
      "source": [
        "# set to True if we want to preload data -- which has already been generated for us :) \n",
        "preload = True \n",
        "\n",
        "if preload: \n",
        "\n",
        "  # load outputs saved in this folder after running preprocess_data() \n",
        "  dataX = np.load('./dataX.npy')\n",
        "  dataY = np.load('./dataY.npy', allow_pickle=True)\n",
        "  \n",
        "else: \n",
        "  \n",
        "  # this takes 15-20 minutes to run, but someone has already run it and saved the ouputs in this folder\n",
        "  pureX, dataX, dataY = preprocess_data(df)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "243exuhMd38d"
      },
      "source": [
        "###Split the data\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cNWZEOrJDVpF"
      },
      "source": [
        "We split our data into different 'sets' that each will work differently with our machine learning model.\n",
        "\n",
        "Think of our AI as a machine learning 'student'.\n",
        "\n",
        "**Training Set**: Our training set is like a training manual. Our algorithm will read, or 'train', on this over and over again to try and learn its task.\n",
        "\n",
        "**Test Set**: Our test set is like a test. It is testing our model on problems that it has not seen before.\n",
        "\n",
        "We usually have a much larger training manual than our test. Let's see if this is the case with our data!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3cAC2tMjwK34"
      },
      "source": [
        "#Split Data into Train, Test (90-10)\n",
        "X_train, X_test, y_train, y_test = train_test_split(dataX, dataY, test_size=0.1, random_state=42,stratify =dataY)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tROzep-ii741",
        "outputId": "6e33a745-fd67-44f6-a276-58c3d6c31762"
      },
      "source": [
        "min(y_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jFES356Ndp6U"
      },
      "source": [
        "### Instructor-led Discussion: Standardization of Data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pbtM9MnxBozT"
      },
      "source": [
        "Standardization is the process of putting different variables on the same scale. It is a transformation that centers the data by removing the mean value of each feature and then scale it by dividing (non-constant) features by their standard deviation.\n",
        "\n",
        "After standardizing data the mean will be zero and the standard deviation one.\n",
        "\n",
        "We can use sklearn's inbuilt function which will help us to standardize our train data:\n",
        "* `StandardScaler()`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ctD2nHn1wKFA"
      },
      "source": [
        "####Standardize the data####################\n",
        "###Note: Do not use test data to fit your Standardscaler Model\n",
        "scaler = StandardScaler()\n",
        "scaler.fit(X_train)\n",
        "X_train = scaler.transform(X_train)\n",
        "X_test = scaler.transform(X_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BgzUfFcdPIkr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c5bcfcf9-d245-4b14-d506-7f41b8c356c1"
      },
      "source": [
        "X_train.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(18000, 2278)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R7GpTLtCUd9c"
      },
      "source": [
        "### Instructor-led Discussion: Dimensionality Reduction"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1ZLbw8c1VRik"
      },
      "source": [
        "Dimensionality reduction helps us find a low-dimensional representation of the data that retains as much information as possible.\n",
        "\n",
        "Principal Component Analysis (PCA) is one such technique.PCA is a technique used to emphasize variation and bring out strong patterns in a dataset. \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cVKY8f_V5_1C"
      },
      "source": [
        "#Reduces features by maintaining 95% variance of the data\n",
        "#After doing PCA on our training data, 2278 Dimensions --->reduced to 20\n",
        "#Note: PCA is trained only on training data \n",
        "pca = PCA(.95)\n",
        "pca.fit(X_train)\n",
        "\n",
        "X_train = pca.transform(X_train)\n",
        "X_test= pca.transform(X_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t3fh0Q8CPGeJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "583abd90-0cf5-45bb-ab7c-549db1fb73e4"
      },
      "source": [
        "X_train.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(18000, 20)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SV0jORxMH3w1"
      },
      "source": [
        "#Milestone 3 : Applying Machine Learning to Emotion Detection"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rx3TiV9KJSSl"
      },
      "source": [
        "##Activity 3a. Defining our machine learning problem"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mRmAsd_WJX7C"
      },
      "source": [
        "Before we build our model, we have to identify what kind of problem it will solve and what data it's going to use. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xNxpdkT_JZF3"
      },
      "source": [
        "### Instructor-led Discussion: Machine Learning for Emotion Detection?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e6PKSHcpJisw"
      },
      "source": [
        "What WILL our model look like? Remember, in machine learning, we always identify inputs and outputs. Our goal is to predict outputs from inputs with either classification or regression.\n",
        "\n",
        "In classification, our output is a category (like dogs or cats).\n",
        "\n",
        "In regression, our output is a value (like 0, 0.1, 0.3, 100, ...)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "049tc1P6JslF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "693c0df1-c17f-4675-ddec-857db904f27f"
      },
      "source": [
        "#@title How will our model operate? { display-mode: \"form\" }\n",
        "\n",
        "#@markdown What are our inputs? \n",
        "inputs = \"distances between facial landmarks\" #@param [\"images\", \"facial landmarks\", \"distances between facial landmarks\", \"Fill Me In\"]\n",
        "\n",
        "#@markdown What are our outputs? \n",
        "outputs = \"integer encoded emotions\" #@param [\"integer encoded emotions\", \"images\", \"image edges\", \"Fill Me In\"]\n",
        "\n",
        "#@markdown What kind of problem will our AI model solve? \n",
        "problem_type  = \"classification\" #@param [\"classification\", \"regression\",\"Fill Me In\"]\n",
        "\n",
        "\n",
        "if inputs == \"distances between facial landmarks\":\n",
        "  print(\"Yes, our inputs are our distance between facial landmarks!\")\n",
        "else:\n",
        "  print('Not quite our inputs.')\n",
        "\n",
        "if outputs == \"integer encoded emotions\":\n",
        "  print(\"Yes, our outputs are integer encoded emotions!\")\n",
        "else:\n",
        "  print('Not quite our outputs.')\n",
        "  \n",
        "if problem_type == \"classification\":\n",
        "  print(\"We are trying to predict labels, therefore this is classification!\")\n",
        "else:\n",
        "  print('Not quite our problem!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Yes, our inputs are our distance between facial landmarks!\n",
            "Yes, our outputs are integer encoded emotions!\n",
            "We are trying to predict labels, therefore this is classification!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3ZGgfUZNJyTF"
      },
      "source": [
        "## Activity 3b. Building and evaluating models\n",
        "\n",
        "\n",
        "We've tried a the KNN, Logistic Regression,Decision Tree model last week in sklearn. Establish best baseline acccuracy using either of the models today. Below, we list it with the sample parameters:\n",
        "* `knn = KNeighborsClassifier(n_neighbors = 1)`\n",
        "* `lr = LogisticRegression(solver='lbfgs',multi_class='multinomial')`\n",
        "* `dt = DecisionTreeClassifier(max_depth=1)`\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "Test your models with accuracy_score on the test_data, which can be accessed through the X_test variable\n",
        "\n",
        "Try to build the best model that you can! \n",
        "\n",
        "Human accuracy for the fer2013 dataset is 65% +- 5%. Lets try getting as closer as possible!\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DqavAnDpKDqE"
      },
      "source": [
        "### Exercise (Coding)     | Est Time | Within a student group\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOiec1fe4G0t"
      },
      "source": [
        "###Train the model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3pCwBkhyKAju",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "91154821-48c8-437d-aa2e-63d75c71de98"
      },
      "source": [
        "knn = KNeighborsClassifier(n_neighbors=3)\n",
        "knn.fit(X_train, y_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
              "                     metric_params=None, n_jobs=None, n_neighbors=3, p=2,\n",
              "                     weights='uniform')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OnoF1kjw3wZ1"
      },
      "source": [
        "###Evaluate the model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2f8MO1W1sYYV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8774608e-afad-45b1-e052-4a8532744c79"
      },
      "source": [
        "y_pred1 = knn.predict(X_test)\n",
        "accuracy1 = metrics.accuracy_score(y_pred1, y_test)\n",
        "print(accuracy1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.464\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yRhFI39Cx4i8",
        "outputId": "a675e1a1-d20f-48ab-fe7c-f86d0be7e663"
      },
      "source": [
        "lr = LogisticRegression(solver='lbfgs',multi_class='multinomial')\n",
        "lr.fit(X_train, y_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
              "                   intercept_scaling=1, l1_ratio=None, max_iter=100,\n",
              "                   multi_class='multinomial', n_jobs=None, penalty='l2',\n",
              "                   random_state=None, solver='lbfgs', tol=0.0001, verbose=0,\n",
              "                   warm_start=False)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c8jaSeVlx5Bh",
        "outputId": "78d64ccb-8d08-423a-fdbc-5ae2c6fbfd92"
      },
      "source": [
        "y_pred2 = lr.predict(X_test)\n",
        "accuracy2 = metrics.accuracy_score(y_pred2, y_test)\n",
        "print(accuracy2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.503\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "llk-Fnmjx5lJ",
        "outputId": "30a11c2f-7a3a-46ef-eaa2-0898c57b8dba"
      },
      "source": [
        "dt = DecisionTreeClassifier(max_depth=20)\n",
        "dt.fit(X_train, y_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "DecisionTreeClassifier(ccp_alpha=0.0, class_weight=None, criterion='gini',\n",
              "                       max_depth=20, max_features=None, max_leaf_nodes=None,\n",
              "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
              "                       min_samples_leaf=1, min_samples_split=2,\n",
              "                       min_weight_fraction_leaf=0.0, presort='deprecated',\n",
              "                       random_state=None, splitter='best')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fGwkzR6Sx59h",
        "outputId": "8c9e659d-4f44-44c9-9d27-0edbfb42d228"
      },
      "source": [
        "y_pred3 = dt.predict(X_test)\n",
        "accuracy3 = metrics.accuracy_score(y_pred3, y_test)\n",
        "print(accuracy3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.4245\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VJVpZmRSN2lY"
      },
      "source": [
        "###Exercise 3A(Discussion) | Est Time: | Within a student group\n",
        "\n",
        "Discussion over different algorithms used for Emotion Detection!\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fVr-933j4LRC"
      },
      "source": [
        "###Plot the Confusion Matrix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eN0uVF7cwbGk"
      },
      "source": [
        "'''\n",
        "Plots the confusion Matrix and saves it\n",
        "Pass the true labels and the predicted labels\n",
        "'''\n",
        "def plot_confusion_matrix(y_true,y_predicted):\n",
        "  cm = metrics.confusion_matrix(y_true, y_predicted)\n",
        "  print (\"Plotting the Confusion Matrix\")\n",
        "  labels = list(label_map.values())\n",
        "  df_cm = pd.DataFrame(cm,index = labels,columns = labels)\n",
        "  fig = plt.figure()\n",
        "  res = sns.heatmap(df_cm, annot=True,cmap='Blues', fmt='g')\n",
        "  plt.yticks([0.5,1.5,2.5,3.5,4.5], labels,va='center')\n",
        "  plt.title('Confusion Matrix - TestData')\n",
        "  plt.ylabel('True label')\n",
        "  plt.xlabel('Predicted label')\n",
        "  #plt.savefig(fig_name)\n",
        "  plt.show()\n",
        "  plt.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_7BrfLuF7Q4X",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "outputId": "6826e7fa-5823-4364-ae3d-b3381fa1d503"
      },
      "source": [
        "plot_confusion_matrix(y_test,y_pred2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Plotting the Confusion Matrix\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZUAAAEWCAYAAACufwpNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3xT5ffA8c9poKyypyBYUZGhgIiCsqfiAlFQHIAD3AiKiKKCA78oCA5QwYmAZagMcaAiS9kgMgQRFRmyym4ppU3P7497W0JtS1rSJunvvHndF8lz17lpck+ecXNFVTHGGGMCISLYARhjjMk/LKkYY4wJGEsqxhhjAsaSijHGmICxpGKMMSZgLKkYY4wJGEsqJleJSBER+VJEDovItDPYzu0i8l0gYwsGEflGRHoEOw5jcoslFQOAiNwmIitFJE5Edrknv6YB2PTNQEWgrKp2yelGVHWSqrYPQDynEJGWIqIiMj1deT23fL6f2xkiIhNPt5yqdlDV8TkMN7N9N3P/bnEiEu/GHeczVcvBNlVEzvd53lJEUny2uUNEporIZdnYpl+vkQlvllQMIvIY8DrwMk4CqAa8DXQMwObPATaranIAtpVb9gFXiEhZn7IewOZA7UAcufJ5U9VFqhqlqlFAHbe4VGqZqm4L0K7+dfdRHGgMbAIWiUibAG3f5AeqatP/4wkoCcQBXbJYphBO0vnXnV4HCrnzWgI7gMeBvcAu4C533vPACSDJ3cc9wBBgos+2owEFCrjPewJ/AUeBv4Hbfcp/8lnvSmAFcNj9/0qfefOBF4Gf3e18B5TL5NhS438XeMgt8wA7geeA+T7LvgFsB44Aq4BmbvnV6Y7zV584hrpxJADnu2X3uvPfAT732f4rwFxAzuDvmf71LAl84P5ddgIvAR533vnAAvc1jAWmuOUL3W3Eu8dzS+rrlMH+RgMrz+A1ugvY6P6d/gLuC/ZnwqYzm4IegE1BfgM4H/bk1JNQJsu8ACwFKgDlgcXAi+68lu76LwAFgWuAY0Bpd/4QTk0i6Z+nnQSBYu7J6EJ33llAHfdxT9ykApQBDgJ3uut1c5+XdefPB/4EagBF3OfDMjm2ljhJ5UpgmVt2DTAHuJdTk8odQFl3n48Du4HCGR2XTxzbcGoPBdzXZz4nk0pRnNpQT6AZzon97DP8e6a9nu7z6cBY97WtACxPPXEDMcAgnBaLwkBTn+0ocH761ymD/bUGUoBiOXyNrgXOAwRo4b53GgT7c2FTzidr/jJlgVjNunnqduAFVd2rqvtwaiB3+sxPcucnqerXON9EL8xhPCnARSJSRFV3qeqGDJa5FvhDVSeoarKqxuA0xVzvs8xHqrpZVROAqUD9rHaqqouBMiJyIdAd+CSDZSaq6n53n6/h1OBOd5wfq+oGd52kdNs7hvM6jgQmAo+o6o7TbM9vIlIRJ0H2VdV4Vd0LjAJudRdJwmmerKyqx1X1pxzs5l+chFAKsv8aqepXqvqnOhbg1Cqb5SAOEyIsqZj9QDkRKZDFMpWBf3ye/+OWpW0jXVI6BkRlNxBVjcdparkf2CUiX4lITT/iSY2pis/z3TmIZwLwMNAK5xv+KUSkv4hsdEeyHcJpWip3mm1uz2qmqi7DafYRnOSXIRHZ4NNJ7u9J9xyc2tEuETnkxjwWp8YCMMDd73J3+3f7uV1fVXBqNYfcOLP1GolIBxFZKiIH3OWvyWp5E/osqZglQCLQKYtl/sU5QaWq5pblRDxOs0+qSr4zVXWOqrbDafraBLznRzypMe3MYUypJgAPAl+7tYg07ol8ANAVp2mvFE5fhKSGnsk2s/wZcBF5COfb/L/u9jPeiGodPdnxvsifg8FJaIk4/Uml3KmEqtZxt7lbVXupamXgPuBt3xFffroRWK2q8dl9jUSkEPA5MAKo6C7/tc/yJgxZUvl/TlUP43RIjxGRTiJSVEQKut8gX3UXiwGeEZHyIlLOXT6nQ0PXAM1FpJqIlASeSp0hIhVFpKOIFMM5GcbhNIel9zVQwx0GXUBEbgFqA7NzGBMAqvo3Trv+oAxmF8fpO9oHFBCR54ASPvP3ANHZGeElIjVwOs7vwGkGGyAiWTbTZYeq7sJpTnpNREqISISInCciLdz9dxGRs93FD+Kc9FNf7z1A9UziFhGpIiKDcfqdnnZnZfc1isRJqPuAZBHpAAR82LjJW5ZUDG7b92PAMzgf8O04zUAz3EVeAlYCa4F1wGq3LCf7+h6Y4m5rFacmggg3jn+BAzgn+Acy2MZ+4DqcjuD9ON+Or1PV2JzElG7bP6lqRrWwOcC3OB3r/wDHObVpK/XCzv0isvp0+3GbGycCr6jqr6r6B87JeYL7DT5QuuOcvH/DSRyf4dQCAS4DlolIHDALeFRV/3LnDQHGu81mXd2yyu6ycTgj7i4GWqpq6kWp2XqNVPUo0Aen2e8gcJsbhwljomo36TLGGBMYVlMxxhgTMJZUjDHGBIwlFWOMMQFjScUYY0zAZHXBm8lEz5i1+W50w8sdMrrGMPxFSP675CHJm9Eo6/C380BCsEPIFY3PL3XGb8Iilzzs1zkn4ZfRQX/DW03FGGNMwFhNxRhjQl3u3DUhV1hSMcaYUBfhCXYEfrOkYowxoS6M+gYtqRhjTKiz5i9jjDEBYzUVY4wxAWM1FWOMMQFjNRVjjDEBY6O/jDHGBIw1fxljjAkYa/4yxhgTMFZTMcYYEzCWVIwxxgSMxzrqjTHGBIr1qRhjjAkYa/4yxhgTMFZTOXMi0gmYDtRS1U0iEg38DfRR1bfcZUYDK1X1Y/f5Y0BvIAlIAeYCT6pqkohsBY4CChwEugPtgbaqeou7fgngF6Cdqv6V28d4d6OzqV+5BEeOJ/PMN5vTytteUJY2NcqSovDrv0eYumY3dSpF0aVeJTwRgjdFmbJmFxv3xOd2iAHh9Xq5v+etlCtfgf+NHMPqlct4983XSEpKokbN2gwY9DyeAiH7VsyU1+uld49bKF++AsNGvc3DvbqTcMz5mxw8eIBatS9m6Ig3gxxl9tx+49UUKVoUj8eDx+Ph7Y8m89HY0SxeNI+IiAhKlS7DE8+8SLnyFYIdqt++nR7Dgu9mIiKcfc553NvvWbZsXMfkD94kOTmJ6PNrcs+jg/B4Qvg9aDWVgOgG/OT+P9gt2ws8KiJjVfWE78Iicj9OkmisqodEJBJ4DCiCk2QAWqlqrIg8DzyDk4DuEpG2qvoD8ALwYV4kFICf/jrI3M376dW4alpZzQrFuOTsEjz7zR8kpyjFCzkddEcTk3l94VYOJSRTpWQh+resTr+ZG/MizDP2+ZSJVIs+l2Px8aSkpDDs+UG8NuZ9qlaL5sOxo/n261lce0PnYIeZbZ9Nnsg50dU5Fh8HwOj3Pkmb9+yTfWnSvFWwQjsjr435gJKlSqc973pHT+6672EApk+dxMQPx9L3yWeDFV62HIjdy/dfTuF/70wmslBhRv/vaZbOn8P0Se/x5MtjqFSlGl9MGMtPP3xNi6tuCHa4mQujmkpIpj8RiQKaAvcAt/rM2odT++iRwWqDgAdU9RCAqp5Q1WGqeiSDZZcAVVRVgfuB10WkIdAGGB64I8na5n3xxJ9IPqWs9QVl+eq3fSSnOLekPproBWDbweMcSnCW3Xk4kYIeoUBE6L/R9u3ZzdKfF3Ftx5sAOHL4EAULFqRqtWgAGl5+BYt+/D6IEebM3j27WfrzQq5zj8tXfFwcq1cup1mLNkGILPCKFYtKe5yQkACh/7Y7RYrXy4kTiXi9yZxIPE6hwkXwFChIpSrVAKhzyeWsXPxjkKM8jQiPf1MICMmkAnQEvlXVzcB+EbnUZ94rQH8RSXsF3WarKFX928/tXw3MAFDVtcAcnGT1SPoaUF6rVLwQNcoX49l25zOwTXXOLVPkP8s0rFqSfw4mpCWeUDZ61Kvc93A/Itzqe8lSpfF6vfy+cQMAC378nr17dwczxBwZPeoV7n/kMSSDxL5owVwuvawRxaKiMlgztInAk4/exwM9b2H2jM/Syj989026dWzHj999Rc9eDwUxwuwpU64CHTrfzmM9O/LoHddStFgUlzdrS4rXy99/ODX9FT//yIF9e4Mc6WlIhH9TCAiNKP6rGzDZfTzZfQ6A2zS1DLgts5VF5CoRWSMiW0XkSp9Z80RkJ9ABiPEpHwPsVNX5WWyzt4isFJGVm+d+ltliZyxChKhCHl78fgtTftnFg03OOWV+5RKF6FqvEh+v2JlrMQTKkp8WUKpMGS6sVSetTER49qVXGTPqVR64qxtFixUlIkS+Yflr8aL5lCp96nH5mvvdN7Rpf00eRxUYr787nnfHT+XlkW8z6/PJrP1lJQB339+HmJnf07r9tcz8LOY0Wwkd8UePsHrpQkZ8OJ3XJ3xF4vEEFs/7lgeffIlP3xvFkH53UbhIMSIiQvVU6BLxbzrtZqSqiMwTkd9EZIOIPOqWDxGRne55c42IXOOzzlMiskVEfheRq063j5DrUxGRMkBr4GIRUcCD07k+xmexl4HPgAUAqnpEROJE5FxV/VtV5wBzRGQ2EOmzXivgEDAJeB6nzwWcTv2UrOJS1XHAOICeMWtzrYpwMCGJldsPA/D3gQRUnX6Vo4leShcpSJ9m0Yxbup19cUGtUPll/a+/sHjhPJYtXsSJxESOxcczdPBABj0/jDfHjQdgxdLFbN/2T5AjzZ71a39h8aL5accVHx/PS889yTMvvMKhQwfZtGEdL736RrDDzJFyFSoCULpMWZq0aM2m39ZT95KGafPbXHUtgx5/kB5hUlvZsGYF5StWpkRJp4/o0itbsWXjOpq07sCgV8cBsG71Unbv3BbMME8vcLWQZOBxVV0tIsWBVSKS2v48SlVHnLJbkdo4XRB1gMrADyJSQ1W9me0gFNPzzcAEVT1HVaNVtSrOqK+03mxV3QT8Blzvs97/gHdEpBSAiAhQOP3GVTUZ6At0dxNYSFm94zC1KjrNJhWLR+KJEI4meilaMIJ+LaKZ9usutsQeC3KU/un1UF+mzZ7L5BlzeO6l4VzS8HIGPT+Mgwf2A3DixAliJnzIDZ27BjnS7On9UD8+mz2XKTO/47mhw2nQ8HKeeeEVABbM/Y4rmragUKFCQY4y+xISjnEsPj7t8aplS4iufj47tp9M+osXzaPqOecGK8RsK1u+Ilt+X0/i8eOoKr/9uoLKVaM5cugAAElJJ/j6swm0vibEB4oEqPlLVXep6mr38VFgI1Ali1U6ApNVNdHtXtgCXJ7VPkKupoLT1PVKurLPgafSlQ3FGf6b6h2gGLBMRBKBOODndMsAzgsrIjHAQ8CLAYo72+6/sho1KxQjqlABRnasyYx1e1j410HuaXQ2L3WoQXKK8v6y7QC0qVGOisUL0fGiinS8yPk2OXzeX2kd+eFkysSPWfLzAjRFuaFzVxo0bBTskALmx++/4bYe9wY7jBw5eOAAQwb2BZzh0q3bd+DyK5oy5Kl+7Ni2FZEIKlY6i74DwmPkF8B5NS/isiatGfxodyI8Hs6pXoOWHTrx+Sfvsmb5z6im0PqaztSu1/D0GwsmP5uIRaQ3zqjWVOPcVpaMlo0GLsHpTmgCPCwi3YGVOLWZgzgJZ6nPajvIOgkhzgAokx252fwVLC93qBnsEHJFRBgNxfRXkjfLltqwtfNAQrBDyBWNzy91xm/CIp3G+XXOSZjR2699uSNsFwBDVfULEakIxOJ0NbwInKWqd7vXAi5V1Ynueh8A36hqph3LoVhTMcYY4yuAI7tEpCBO688kVf0CQFX3+Mx/D5jtPt2JT9cDcLZblqlQ7FMxxhjjK3CjvwT4ANioqiN9ys/yWexGYL37eBZwq4gUEpFzgQuA5Vntw2oqxhgT4iRwzbhNgDuBdSKyxi17GugmIvVxmr+2AvcBqOoGEZmKMzAqGXgoq5FfYEnFGGNCXqCSiqr+RMa/ifB1FusMxRkY5RdLKsYYE+Iy+uWGUGVJxRhjQlwAm79ynSUVY4wJcZZUjDHGBIwlFWOMMYETPjnFkooxxoQ6q6kYY4wJmJD/aX4fllSMMSbEWU3FGGNM4IRPTrGkYowxoc5qKsYYYwLGkooxxpiAsZ9pyefe7VI32CEEXOkWg4IdQq7Y/UPQbuyZawrn0ztW1D67RLBDCFlWUzHGGBMwllSMMcYEjCUVY4wxAWNJxRhjTOCET06xpGKMMaHOfqbFGGNMwFjzlzHGmMAJn5xiScUYY0Kd1VSMMcYEjCUVY4wxAWNJxRhjTMDYb38ZY4wJGKupGGOMCRhLKsYYYwImjHKKJRVjjAl1VlMxxhgTMBHWUW+MMSZQwqiiEtpJRUTiVDXK53lPoKGqPuxTtgbYpKq3+pR9DLQADgMpwEOquiSjcuBh4CdVfcddtxHwHnCpqibl6gH62L1rF4OeGsCB/ftBhJu7dOX2O3sA8OmkCUyJmUREhIfmzVvQr/+AvAor286uUJL3n72ZCqWjUJQPZ65gzLQlADxwc2Pu69wYb0oK3y7+nUFvz6FgAQ+jB3SkQc0qpKQo/d/4ikW//B3ko8haYmIi9919JyeSTuBNTqZN26vo/eAjPP/sU6xetYKoqOIADH7hZWrUrBXkaP2XmJjI/Xd3Tzuu1m3b0/vBR1BV3h39BnO/n4PH46Fzl1u45bY7gx2uXxITE+l9150kJZ0gOTmZNu2u4r4HH0mbP2LYUGbN+IKFS1cFMcrTs5pKHhGRWoAHaCYixVQ13mf2E6r6mYi0B8YCdTMpbwcsEZHPgP3AaODBvEwoAJ4CHvoPGEit2nWIj4/j1i430fiKJuzfH8v8H+cy7YtZREZGsn///rwMK9uSvSkMfOsb1mz+l6iikSz+4CHmrthChTJRXNe0Fpf3eIsTSV7KlyoGwN03NATgsu5vUb5UMWa81oOm976DqgbzMLIUGRnJ2+99RNGixUhOSqLXXXdwRdNmAPTp9wRt2l0V5AhzJjIykjHvfZh2XL3vuoMrmjZn619/smfPbqbO+IqIiAgOHAjt96CvyMhI3nn/5N/q3p53cGXTZlxctz6/bVjPkSOHgx2iX8KpphI+v6ecsW7ABOA7oGMmyywEzs+sXFX3ACOAV4H7gbWq+lMuxJql8uUrUKt2HQCKFYuievXq7N27h2lTYrj73t5ERkYCULZs2bwOLVt27z/Kms3/AhB37ASb/tlH5fIl6N2pESMmLuREkheAfYec/F8zugLzV/2VVnY47jiX1qwSnOD9JCIULeokxeTkZJKTk8KqIzUz/z2uZETgi2lTuKf3A2k/v16mTGi/B31l+LdC8Hq9vDlyOH369Q9yhP4REb+mUBDqSaWIiKxJnYAX0s2/BZgMxOAkmIxcD6w7Tfm7QG3gCSDobUs7d+5g08aNXFy3Hv9s3crqVSu5/dYu3N3jDtavWxvs8PxWrVIp6l9wFis27OD8auVoUi+ahePu57vR96YljnVbdnNd05p4PBGcc1ZpLrmwMmdXLBnkyE/P6/Vye9cbuap1Uy5vfCUXXVwPgHdGv85tXToycvj/OHHiRJCjzD6v18sdXW/kap/j2rFjGz/M+YYet3Wh70O92fbP1mCHmS1er5fbut5I+1ZNadT4Si6qW4+pkyfRvGUrypWvEOzw/CLi3xQKQj2pJKhq/dQJeC51hog0BGJVdRswF7hERMr4rDvcTUS9gXuyKlfVFJymsG9UNah1+2Px8Tzetw9PDHyaqKgokr1eDh8+zMSYqfR7fABPPN43pJuGUhUrEknM0Nt44s2vOHoskQKeCMqUKELz3u/y9Jhvmfii0wU2/qtV7Nx3hJ8/eJDhj17L0vXb8HpTghz96Xk8HiZNnc7sOfP4bf06/tyymYf69GPajK/5eNI0jhw+zCcfvRfsMLPN4/Ewcep0vpwzjw3r1/Hnlj9IOnGCyEKFGP/pNDp27sJLQ54JdpjZ4vF4+HTqdL76zjmm1atWMPe7OXTtdkewQ/NbRESEX9PpiEhVEZknIr+JyAYRedQtLyMi34vIH+7/pd1yEZE3RWSLiKwVkQanjfWMjzZ4ugE1RWQr8CdQArjJZ/4TbjJqp6rr/ShPcacMiUhvEVkpIis/eG9cAA/jpKSkJB7r24drrr2etu3aA1CxYkXatG2HiHBx3bpERERw8ODBXNl/oBTwRBAz9DamfPcrMxf8BsDOvYeZsWADACs37iBFlXKliuL1pjDgza9p3HM0XQdOpFRUYf7YHhvM8LOleIkSXHrZ5Sz5+SfKla+AiBAZGcn1HTuzYX1GFeTwcPK4FlGhYiVatWkHQMvWbdnyx+YgR5czqce0asVytm/fRufrr+KGDm04fjyBG68L7X6wANZUkoHHVbU20Bh4SERqAwOBuap6Ac6X9IHu8h2AC9ypN/DO6XYQlklFRCKArsDFqhqtqtE4fSqZNYGdMVUdp6oNVbXhPb1658b2GfLcIKpXr073nnellbdq05YVy5cBsHXr3yQlJVG6dOmA7z+Q3n2qM7//s5c3p/ycVvbloo20aFAdgPOrliWygIfYQ8coUqggRQsXBKD1ZeeR7E1h09Z9QYnbXwcPHODokSMAHD9+nGVLl3DOuecSu28v4PwtF8z7gfPOvyCYYWZb+uNavnQx0edWp0WrNqxc4bwHV69cQbVq0UGMMnv+e0xLqFmrNnN+XMSsb+Yy65u5FC5chOmz5wQ50qwFqk9FVXep6mr38VFgI1AF5/w53l1sPNDJfdwR+EQdS4FSInJWVvsI19FfzYCdqvqvT9lCoPbpDjhU/bJ6FbNnzeSCGjXo2tkZc/BI38e48cabeO7Zp+nc8ToKFizIi0OHhUyHXEaurHsOt3e4hHVbdrP0Y2fk9+Cx3zF+9irGPt2ZlRP6cCLJy70vfQ5A+dLF+HJUT1JSlH/3HeGeFz4LZvh+iY3dx/PPPkVKipeUlBTatr+aZs1b8UCvnhw6eABVpcaFtRj4zOBgh5otsbH7eOHZp0hJSSElJYU27a+mafOW1KvfgOeeHsDkiZ9QpGhRnh6cvmszdMXG7mPIM+n+Vi1aBTusbPP3Iy8ivXFqFKnGqWqGTSsiEg1cAiwDKqrqLnfWbqCi+7gKsN1ntR1u2S4yIeHQPh9qjieT71600i0GBTuEXLH7hxeDHULAaf57+wEQEcJfls5EicJnfpHJpS/O8+uPvurZVn7tS0SigAXAUFX9QkQOqWopn/kHVbW0iMwGhqWOiBWRucCTqroys22HZfOXMcb8fxLI0V8iUhD4HJikql+4xXtSW3nc//e65TuBqj6rn+2WZcqSijHGhLiICPFrOh1x2s4/ADaq6kifWbOAHu7jHsBMn/Lu7iiwxsBhn2ayDIVrn4oxxvy/EcB+1CbAncA699IKgKeBYcBUEbkH+AdnIBTA18A1wBbgGHAXp2FJxRhjQlygcorbN5LZ1tpksLzi/Eai3yypGGNMiAvlEZ/pWVIxxpgQF0Y5xZKKMcaEOvvpe2OMMQFjzV/GGGMCxpKKMcaYgAmjnGJJxRhjQp3VVIwxxgRMGOUUSyrGGBPqbPSXMcaYgAmnX3C2pGKMMSEujHKKJRVjjAl11lFvjDEmYMKoSyXzpCIib0Hmt5hT1T65ElEY2LwrLtghBNzvXz4X7BByxfT1O4IdQsBdVaNSsEPIFb/sOBTsEHLFNXUqnPE28ktHfaa3izTGGJN3JNNfqw89mSYVVR3v+1xEiqrqsdwPyRhjjK8wqqic/nbCInKFiPwGbHKf1xORt3M9MmOMMYDTUe/PFAr8uUf968BVwH4AVf0VaJ6bQRljjDlJxL8pFPg1+ktVt6fLgt7cCccYY0x6+e3ix+0iciWgIlIQeBTYmLthGWOMSRVOo7/8af66H+fG91WAf4H67nNjjDF5IF81f6lqLHB7HsRijDEmA+HU/OXP6K/qIvKliOwTkb0iMlNEqudFcMYYY0D8nEKBP81fnwJTgbOAysA0ICY3gzLGGHNSfhtSXFRVJ6hqsjtNBArndmDGGGMcEeLfFAqy+u2vMu7Db0RkIDAZ57fAbgG+zoPYjDHGEF6jv7LqqF+Fk0RSj+Y+n3kKPJVbQRljjDkpVJq2/JHVb3+dm5eBGGOMyVgYVVT8u6JeRC4CauPTl6Kqn+RWUMYYY07KFzWVVCIyGGiJk1S+BjoAPwGWVIwxJg+ET0rxb/TXzUAbYLeq3gXUA0rmalTGGGPSeCLErykU+NP8laCqKSKSLCIlgL1A1VyOK0dEZBBwG84PXqYA96nqMhEpAOwCPlDVgT7Lz8e5/iYRiAR+AJ5R1Ty/Bd3O7VsZ9dLJsQ97d+3klh73Ex93lB++nk6JUqUBuO3uh2jQqGleh3dG7rjxaooULUqEx4PH4+HtjyanzZv26XjGvfUan32zgJLuMYair8aNYMuaZRQtUYpew94D4MdPx/HHL0vxFChA6QqVubZ3fwoXiwJg8awYfp3/LREREbTr/iDV614WzPCzxev1cl+PWylXvgLDRo1h1fKlvPvWSFJSUihStCgDn3uJs6tWC3aYWYoZ/T9+W7mYqJKlefINp1El/ugRPnltMAf27aZM+Ur06P8CRaOKs275Ir6JeR+RCCI8Hm68uw/Va9UN8hGcKl81fwErRaQU8B7OiLA4YEmuRpUDInIFcB3QQFUTRaQcTqIAaAdsBrqIyFOq6nub5NtVdaWIRAL/A2YCLfIydoAqVaMZMda5ptTr9XLfrR24vGkr5n07i+tuuo0bunbP65ACasSYD/6TNPbu2c2q5UuoUOmsIEXlv4ubt+fSdh35cuyraWXRFzeg5S33EOHxMG/yeyz5MoZWt/Yiduc/bFw6n16vvEfcwf3EDHuS+0Z8RESEJ4hH4L/PJ0/knOhziY+PB2DUKy8xdMSbnHNudWZ8NpkJH47lqcFDgxxl1i5v1YGmHTrz6Zsn45w7fSIX1L2Utp3v4IcvJjL3i4lc3/0Balx8KRdd1hQR4d+tWxj/2mCeemtSEKP/rzDKKadv/lLVB1X1kKq+i3Ny7uE2g4Was4BYVU0E5zfLVPVfd1434A1gG3BFRiur6glgAFBNROrlQbyZWv/LcipVPpvyFUP/ZHsm3n3jVXo91C8sbpVarWZdCkcVP6Ws+sUNifA4iaLyeTvSPYYAACAASURBVLU4ciAWgM2rFlOrcUsKFIykVIWzKF2xMv/++Xuex5wTe/fsZunPi7i2401pZSJCfHwcAPFxcZQrf+b3XM9t59WpT7HiJU4pW7/8Jy5reTUAl7W8mnXLFwFQqEjRtJrAicTjhGIPRoSIX1MoyOrixwZZzVPV1bkTUo59BzwnIptxmrGmqOoCESkMtMW5zqYUToJZnNEGVNUrIr8CNYFf8ybs//p53nc0aXVV2vNvZ05lwfdfcV6N2nS/vx9R6T4soU4EBj56HyLCtZ26cG2nm1m8cB5ly1fgvAsuDHZ4AbF24RxqNXIquEcPxlLlvFpp84qXKU/cwdhghZYto0e9yn2P9OPYsZN3Dn9i0BAG9n2QyMKFKFYsirc/CK1v8f46euggJcuUA6BE6bIcPXQwbd7apQv5atJY4g4fpNegVzPbRNAEMl+IyIc4rTp7VfUit2wI0AvY5y72tKp+7c57CrgHp1uhj6rOyWr7WdVUXstiGpHD48k1qhoHXAr0xnlhpohIT5wXb56qJgCfA51EJKt2iAz/fCLSW0RWisjKzyZ9GNjgfSQlJbFyyQKuaNEWgPY33Mxbn8xk+NgYSpUtxyfvjsq1feeWUe+O553xUxk68m1mfT6Ztb+sJGb8e/TslT/uoPDzzElERHio06RNsEM5I4sXLaB06TJcWKvOKeXTYiYw7PW3+Wz2XDpc14kxrw8PUoSB4/xW1snndRs356m3JnH3ky/zdcz7wQssEwH+7a+PgaszKB+lqvXdKTWh1AZuBeq467x9mvNnlhc/tvI3wlChql5gPjBfRNYBPYATQFMR2eouVhZoDXyffn33xbqYDG5CpqrjgHEAa7fHafr5gbJm+c+ce0FNSpUuC5D2P0Dba25k2DN9c2vXuaZchYoAlC5TliYtWrP2l1Xs3rWT++7sAsC+fXt4oOctjP7gU8qULRfMULNt7cI5bPllGbc99Wrah7p46XIcObAvbZmjB/YRVTr0j2v92l/4edE8li5exInERI7FxzOw34Ns2/o3tS9yOq5btbuaAY/eH+RIc6Z4qdIcPhBLyTLlOHwglqiS/x0Ycl6d+uwf/S9xRw4RVaJUEKLMmCeAVRVVXSgi0X4u3hGY7HYr/C0iW4DLyaJf3Z8hxWFBRC4UkQt8iurj1FiaAdVUNVpVo3FuMNYtg/UL4nTUb1fVtXkQcoZ+mjeHpq1Ofok4uP/kyWn5T/OoGn1eMMLKsYSEYxxzO3wTEo6xatkSLqxVh2lfL2Di9G+ZOP1bypevyDsfTwm7hPLnrytYOnsqXR57gYKFTv7G6gUNrmDj0vkkJ53g0N5dHNy9k8rnhX4zX++H+vLZ7LlMmTmH54YO55KGl/PS8DeJi4tj+z9bAVi5bAnnRIfnnS8uuqwJK+Z/C8CK+d9y0eXOKMp9u3aQOnZn+5+/401Koljx0Lpqwt8flPRtUXGn3tnYzcMislZEPhSR1IxbBdjus8wOtyxTfl1RHyaigLfckWrJwBackVxFUzvvXTOBV0WkkPt8kogkAoVw+mI65mHMpziekMDaVcvo3ffptLIJ773J1i2/IyKUr1SZ+3zmhYNDBw4wZKBTu/J6vbRq34HLrgivIdEAM0YPZdvGtSTEHWb0I91odlN3Fs+ajDc5iZhhTwJQ5fxaXH13X8qfHU3NRs1578l7iYjw0L7nI2Ez8iu9AgUK8MTTQ3huYD8iJIKoEiV48tkXgh3WaX0ycghb1v9C/NHDDLm3M1ffejdtOt/B+BHPsWzuV5QuX5EejzvHsXbJAlYs+BaPpwAFIwvR/fHnQ24Ir7+XoPi2qGTTO8CLOL/r+CJON8fdOdgOcuroWuOP3Gz+CpZSxQoGO4Rc8eOfe4IdQsBdVaNSsEPIFb/syPPLw/LENXUqnHGGevzL3/0657x2/YV+7ctt/pqd2lGf2Ty3kx5V/Z87bw4wRFVz3vwljjtE5Dn3eTURudyfwI0xxpy53L6fioj4Xr9wI7DefTwLuFVEConIucAFwPKstuVP89fbOFentwZeAI7ijKIKn0uEjTEmjAV4SHEMzu85lhORHcBgoKWI1Mdp/tqKe6sTVd0gIlOB33C6FR5yB0Rlyp+k0khVG4jIL+5ODrpXnxtjjMkDBQI7+us/A5WAD7JYfijg908o+JNUktyhtgogIuVxai7GGGPyQIiNG8iSP0nlTWA6UEFEhuL8avEzuRqVMcaYNKHyEyz+OG1SUdVJIrIK5+fvBeikqv+5ONAYY0zuCKOc4tdNuqoBx4AvfctUdVtuBmaMMcYRIrdK8Ys/zV9f4fSnCM7thM8Ffsf5LRhjjDG5LFRuwOUPf5q/LvZ97v568YO5FpExxphThFFOyf7PtKjqahFplBvBGGOM+a9wuOdQKn/6VB7zeRoBNAD+zWRxY4wxAZbfaiq+t7tLxulj+Tx3wjHGGJNevkkq7kWPxVW1fx7FY4wxJp1Q+9XkrGR1O+ECqposIk3yMiBjjDGn8oTRna+yqqksx+k/WSMis4BpQHzqTFX9IpdjM8YYQz67oh7n2pT9OL9SnHq9igKWVIwxJg/klz6VCu7Ir/WcTCap8t1NqrKjxllRwQ4h4JK9+fNP2qVe1WCHEHDlGj0S7BByxZ4lbwY7hJAVRhWVLJOKB+cWvRkdTv48AxljTAiKyCfXqexS1dC/GbUxxuRz+aWmEkaHYYwx+VeBMOpUySqptMmzKIwxxmQqX9RUVPVAXgZijDEmY/ltSLExxpggCqOcYknFGGNCXRhdUG9JxRhjQp01fxljjAkYSyrGGGMCJnxSiiUVY4wJeWFUUbGkYowxoS5f3E/FGGNMaLDRX8YYYwLGOuqNMcYEjDV/GWOMCRhr/jLGGBMwVlNxicgg4DbAC6QA9wFTgIaqGusu0xLor6rXiUhPYDiwE+c2xmNVdZS73BCgF7DPjftpVZ2VrjwSeFFVY9x1PgZmq+pnInId8CJO0i8IvKGqY9Otn6qlqh7KhZckU7t37WLQUwM4sH8/iHBzl67cfmcPAD6dNIEpMZOIiPDQvHkL+vUfkJehnZHExER63XUHJ06cwOv10qZte+5/qA9TYiby6cRP2LF9Gz8sWELp0qWDHarfEhMTubenzzG1a88DD/Vh544dPDXgMQ4dOkSt2nV46X+vULBgZLDDzdLZFUvx/ovdqVC2OKrw4ec/MyZmPhOG3cUF0RUBKFW8CIeOJtD41mEULOBh9DPdaFC7GimaQv9XP2fRqj+CfBSZS0xMpPddd5KUdILk5GTatLuK+x48eefMEcOGMmvGFyxcuiqIUZ5e+KSUXEwqInIFcB3QQFUTRaQczkn/dKao6sMiUhb4XUQ+U9Xt7rxRqjpCRGoBi0SkQrryC4BV7jpJPrEUBMYBl6vqDhEpBET77HOUqo44syM+M54CHvoPGEit2nWIj4/j1i430fiKJuzfH8v8H+cy7YtZREZGsn///mCGmW2RkZG8+/7HFC1ajKSkJO7pcTtNmjanXv0GNGvekt73dA92iNkWGRnJ2A/+e0yTPvmY2+/swVUdrmXoC4OZ8cXndLmlW7DDzVKyN4WBI79gzaYdRBUtxOJPn2Tusk3cOfCjtGWGPXYjh+MSALi7cxMALuv6MuVLRzFj9IM0vWM4qqF5M9jIyEjeef8jihYtRnJSEvf2vIMrmzbj4rr1+W3Deo4cORzsEP3iCaOaSm421Z0FxKpqIoCqxqrqv/6urKr7gS3udtLP2wgkA+XSlf8BHAPSf+0tjpNA97vLJarq7/4fSu4rX74CtWrXAaBYsSiqV6/O3r17mDYlhrvv7U1kpJOPy5YtG8wws01EKFq0GADJyckkJyeDCDVr1aZylbODHF3OZHRMIsKK5Utp0+4qAK67oRPzfvwhmGH6ZXfsEdZs2gFA3LFENv29m8rlS52yzE3tGjD1W+ebfM3qlZi/wvno7DsYx+GjCVxau1reBp0N//1bJSEIXq+XN0cOp0+//kGO0D8i/k2hIDeTyndAVRHZLCJvi0iL7KwsItVwmsDWZjCvEU5z2r505Q2AP1R1r2+5e2+YWcA/IhIjIreLiO+x9xORNe40Lztx5oadO3ewaeNGLq5bj3+2bmX1qpXcfmsX7u5xB+vX/eflCHler5duXTrRrmUTGl9xJRfXrRfskM6Y1+vl1ps70bZFExo1vpKzq1YjqngJChRwKv8VK1Vi3969p9lKaKl2VhnqX3g2K9ZvTStr0uA89hw4yp/bnI/aus07ua7FxXg8EZxTuSyX1K7K2ZVCu+nS6/VyW9cbad+qKY0aX8lFdesxdfIkmrdsRbnyFU6/gRAgfv7za1siH4rIXhFZ71NWRkS+F5E/3P9Lu+UiIm+KyBYRWeueY7OUa0lFVeOAS4HeOCf/KW6fSUb1ZN+yW0RkLU4t5W1VPe4zr5+IrAFGALfoyTp3PxHZACwDhmYSz704d7NcDvQHPvSZPUpV67tTq2weakAdi4/n8b59eGLg00RFRZHs9XL48GEmxkyl3+MDeOLxviHb1JAZj8dDzLQZfPP9fNavX8uWPzYHO6Qz5vF4mPzZDL79YT4b1q9l699/BTukM1KsSCQxI+7liRGfczT+5Eeu69UNmfbtyrTn42cuYeeeQ/w8aQDDn7iJpb/+jdebEoyQ/ebxePh06nS++m4eG9avY/WqFcz9bg5du90R7ND8FuCaysfA1enKBgJzVfUCYK77HKADcIE79QbeOd3Gc3Wkmqp6VXW+qg4GHgZuwmmC8v1qUwaI9Xk+RVXrAlcCw0Skks+81JN/M1VdlK68jrv9D0SkcCbxrHM7/tu5y/pNRHqLyEoRWfnBe+Oys6rfkpKSeKxvH6659nratmsPQMWKFWnTth0iwsV16xIREcHBgwdzZf+5rXiJEjS8rBGLf150+oXDROoxrf11DXFHjzjNe8Ce3bspXyE8vgUXKBBBzIheTPlmJTN//DWt3OOJoGPrenw2Z3VamdebwoDXvqDxrcPo2m8cpYoX4Y9t4VEjK16iBJdedjmrVixn+/ZtdL7+Km7o0IbjxxO48bqrgh1eliIQvyZ/qOpCIP2dfTsC493H44FOPuWfqGMpUEpE/tMlcWqsuURELnQ7zlPVB/4B5gN3ust4gDuA/zQ5qepKYALwqL/7VNVZwEqgR7pYotxRZulj8ZuqjlPVhqra8J5evbOzqr/bZ8hzg6hevTrde96VVt6qTVtWLF8GwNatf5OUlBRWI6UOHjjA0SNHADh+/DjLliwm+tzqQY7qzKQ/pqVLF3Nu9eo0vKwRc7+fA8DsWTNo2apNMMP027uDb+f3v3fz5sQfTylv3ehCNm/dw869JwdCFilckKKFI935NUn2prDpr915Gm92pP9bLV+6hJq1ajPnx0XM+mYus76ZS+HCRZg+e06QI82avzUV3y+/7uTvyaqiqu5yH+8GKrqPqwDbfZbb4ZZlKjeHFEcBb4lIKZxO9S041ack4B0R+RVnpNy3wMRMtvEKsFpEXs7Gfl8APhWR93zKBBggImOBBCAe6Okzv5+I+NaFO6nq1mzs84z9snoVs2fN5IIaNejauSMAj/R9jBtvvInnnn2azh2vo2DBgrw4dFhYjVmPjd3H4GcG4vV60RSl7VVX07xFK2ImfcInH33A/v2x3HrzDTRp2oLnnn8p2OH6Zd8+n2NSpV1755iqVz+fpwY8xpi33qBmzVp06nxzsEM9rSvrV+f26xqxbvNOlk52WjwGj57FnJ9+o8tVl6Z10KcqX7o4X779ECkpyr/7DnHPM+Mz2mzIiI3dx5BnniIlxUtKSgpt219NsxZBbeHOEX9/pkVVx+GMdM0xVVURyXEbu4Rb+3woOJ6cYb9QWEv25rtDAkJnREwglWv0yOkXCkN7lrwZ7BByRYnCEWf8Lpy7KdavD2ibmuX82peIRONcw3eR+/x3nOvzdrnNW/NV9UL3i/h8n2v/0pbLbNvhdPW/Mcb8vxTI0V+ZmMXJboMewEyf8u7uKLDGwOGsEgrYz7QYY0zIC2SNW0RigJZAORHZAQwGhgFTReQenP7mru7iXwPX4HRfHAPu+s8G07GkYowxIe4MayGnUNXMfubhPyNL3Ms2HsrO9i2pGGNMiDvzXpm8Y0nFGGNCnN2kyxhjTMCET0qxpGKMMSHPairGGGMCJnxSiiUVY4wJfWGUVSypGGNMiLPmL2OMMQETPinFkooxxoS+MMoqllSMMSbEBfKK+txmScUYY0JcGHWpWFIxxphQF0Y5xZKKMcaEunC6MZ8lFWOMCXFhlFPszo858Xfs8Xz3ohUvnD+/X+w7khjsEAKuSCFPsEPIFX0+XxfsEHLFrN6XnXFK+HXbUb/OOfWqFQ96+smfZxJjjMlPgp4q/GdJxRhjQpwNKTbGGBMw4dSnYknFGGNCnCUVY4wxAWPNX8YYYwLGairGGGMCJoxyiiUVY4wJeWGUVSypGGNMiLObdBljjAmY8EkpllSMMSb0hVFWsaRijDEhzoYUG2OMCZgw6lKxpGKMMaEujHKKJRVjjAl1dpMuY4wxARNGOcWSijHGhLowyil5k1RERIGRqvq4+7w/EKWqQ0RkCNAL2OezSkugE9BQVR/22c58oD8wBigElAGKADvdRToB84GjgAIHge6q+o/PNmYAlVS1sU/ZECBOVUcE6phzovtNHShatCgRER48Hg9vfRjDn5s38dbwlzhx4gQej4eH+z/NhbUvDmaY2eb1ernnzq6UL1+R4W+8zWdTJjH10wns3LGdr374iVKlSwc7xGyLizvKmOEvsO3vPxGBhwcMplChIrw7aigJCQlUqHQWjw0aStFiUcEONVu6d+5AkaJFifA478HRH8YAMHPap8z6fAoRnggaXdmcex/qF+RIs9anRTQNq5XicEISj3y2AYAn2pxHlZKFAShWyEN8ope+XzjzossU4cFm0RQt6CEF5fHpv5HkDaEbvIZRVsmrmkoi0FlE/qeqsRnMH5X+hJ5VG6KqNnKX6cl/Ew9AK1WNFZHngWdwkhYiUgq4FIgTkeqq+tcZHVUueOWt9ylZ6uRJ9oO3R3H73fdz2RVNWb54Ee+//TrDR38QxAizb1rMBKKjqxMfHw9A3XoNaNKsJQ/37hncwM7AB28Np8HlV/Lk88NJSkoiMfE4Q/o/QM/7+3FR/Uv54esZTJ/yCbff/WCwQ822V0ef+h5cs2o5ixfN551PphEZGcmhA/uDGJ1/5v4ey+z1e+nX6ty0suFz/0x7fHfjqsSf8AIQIfBYq+qMnPcXWw8kULyQB29KCCUUwmtIcUQe7ScZGAfk9debJUAVn+edgS+BycCteRxLzohwLD4OgPj4OMqWKx/kgLJn757dLP5pIdd3uimtrEbNWpxVuUoWa4W2+LijbFi7mrbXdAKgYMGCREUV598d26hTrwEA9Ro2ZsnCucEMM2BmT5/GLXfeTWRkJAClypQNckSnt2F3HHGJyZnOb1K9DAu3OMnxkrNLsvVAAlsPJABwNNFLiOUURPyb/NuWbBWRdSKyRkRWumVlROR7EfnD/T/HzQd52acyBlgrIq9mMK+fiNzhPj6oqq0CtM+rgRk+z7sBLwB7gM+BlwO0n4AQgaf73Y+IcE3Hm7mm483c/+gABj32AO+NGYmmpDBy7CfBDjNb3nhtGA8++jjH3FpKfrBn97+ULFWaN18ZwtY/N3NejVrc+/ATVI2uzrKf59O4aSsWz/+B2L17gh1q9gk83fd+EOHajjdzTaeb2bn9H9b/upqPx75FZGQhej38GBfWvijYkeZYnUpRHEpIYteRRACqlCyMogzpUIOSRQqw6M8DfPHr7iBHeaqIwFdUWqVrNRoIzFXVYSIy0H3+ZE42nFc1FVT1CPAJ0CeD2aNUtb47pSaUzL4r+PMdYp6I7AQ6ADEAIlIRuAD4SVU3A0ki4vcnQ0R6i8hKEVkZ80nuND+99s7HjPloCi+9NoYvv5jCujWrmD19Kvc98gQTp3/HfX2eYNT/huTKvnPDzwvnU7p0GWrWqhPsUAIqxevlz82b6HDDzYx6L4bChYvwecxHPDJgMN/MnMZjvW8jISGeggULBjvUbBv57seM+XgKQ18bw6wvprDul1V4k5M5euQwb7w3kXsf7sfQZ59ANcS+ymdD8/PLsmjLySa8iAihdsXivPbjXzw5cxONo0tTt3LxIEaYEfFzyrGOwHj38Xic/ukcybOk4noduAco5sey+4H0VbAyQEZ9Mum1As4B1gDPu2Vd3e39LSJbgWicmotfVHWcqjZU1Ybdut/j72rZUq58RQBKlS7Llc1b8/tv6/nhmy9p0rINAM1at2fzb+tzZd+5Ye2vv/DTwvncdF07Bj/dn1UrlvH8Mzn68hNSypavQNnyFajhDpi4okUb/tq8ibOrncvzw99m5LhPadb6aipVPjvIkWZf2nuwTFmaNG/Npo3rKVehIk1atEFEqFn7YiIkgsOHDgY50pyJELgiujSL/jqQVrY//gQbdh/laGIyJ7wprNp2iPPK+XOKyjv+Nn/5fvl1p94ZbE6B70Rklc/8iqq6y328G6iY01jzNKmo6gFgKk5iOZ0VQBMRqQQgIg1xRnxt93NfyUBfoLuIlMFJIFerarSqRuN02IdMv8rxhGNpTUTHE46xevkSoqufT9ly5Vn7y0rA6TCtXLVaMMPMlgce6ceMb37k89nf8/zLI7j0skYMfumVYId1xkqXKUe5ChXZuW0rAGtXL6dq9LkcOuicqFJSUpg24X2uuv6mLLYSetK/B1e578Erm7fi19UrANixbStJyUmndOSHk/pVSrDjUAL745PSylZvP8w5ZYoQ6YkgQqDOWcXZfjAhiFH+l7/1FN8vv+40LoPNNVXVBjgtOQ+JSHPfmepUQ3NcFQ3GdSqvAQ+nK/PtUwHopKpbReRR4GsRiQDigG6qmuLvjlR1l4jEAA/h1FyW+sz7W0QOi0gjt+gZEenrMz9Pv2YePHCAF552xjF4k5Np1f4aGjZuQuEiRXj3jVfxer1ERkby6IDn8jKsXDEtZiKTPvmQA/tj6X7rjVzRpDlPPfdCsMPKll59nmTk0EEkJydR8ayz6fPkEObNmc03M6cC0LhZa9p06BjkKLPn4IEDPP+U+x70JtOq3TVc1rgJSUlJjBz6HL1v70zBggV54pkXQ/4K7/6tq3NR5eKUKFyAD2+rR8yqnXz/eyzNzivLwj8PnLJs/AkvM9fuYeSNtVGUVdsPs3L74SBFnrFAvtyqutP9f6+ITAcuB/aIyFnuOfMsYG9Oty/h3DYaLH/HHs93L1rxwvnzOth9bmdsflKkkCfYIeSKPp+vC3YIuWJW78vOOCXsPpLk1zmnUomCWe5LRIoBEap61H38Pc7gpTbAfp+O+jKqOiAnsebPM4kxxuQjAayoVASmuzXNAsCnqvqtiKwAporIPcA/OH3QOWJJxRhjQlygmr/cC77rZVC+H6e2csYsqRhjTIgLpyvqLakYY0yoC5+cYknFGGNCXRjlFEsqxhgT6iJCfAi3L0sqxhgT4sIop+T5z7QYY4zJx6ymYowxIS6caiqWVIwxJsTZkGJjjDEBYzUVY4wxAWNJxRhjTMBY85cxxpiAsZqKMcaYgAmjnGJJxRhjQl4YZRVLKsYYE+LC6Wda7M6PIU5Eemdyn+mwlR+PCfLnceXHY4L8e1yhwH6mJfT1DnYAuSA/HhPkz+PKj8cE+fe4gs6SijHGmICxpGKMMSZgLKmEvvzY7psfjwny53Hlx2OC/HtcQWcd9cYYYwLGairGGGMCxpKKMcaYgLGkkgdEpJOIqIjUdJ9Hu88f8VlmtIj09Hn+mIhsEpF1IvKriIwUkYLuvK1u+VoRWSAi54hILxGZ4rN+CRH5U0Sq59IxxaV73lNERqcrWyMik9OVfSwif7vzVovIFZmVi8gkEXnAZ91G7jEXzI1jyoqIDBKRDe7+14hII7e8gIjsE5Fh6ZafLyK/u8tvcv++pfIyPvd9Us5nmZYiMtt93NONe40bXz+f5YaIyE533noRuSGD8t9EpJvPOh+LyM3u4+tE5Bf3ffubiNyXwfqpU5avifs5ec3neX8RGZLV9jJ5L84XkYYissxdbpvP8a9xP5P/+Vyl28YMEVmarmyIiPT388/0/4IllbzRDfjJ/T/VXuBREYlMv7CI3A+0Bxqr6sXAZe7yRXwWa6WqdYH5wDPA+0BVEWnrzn8B+FBV/wrwsfhFRGoBHqCZiBRLN/sJVa0PDATGZlH+GPCEiJQXkQhgNPCgqibl/hGc5Ca+64AG7mveFtjuzm4HbAa6iPznsufb3eXrAonAzCDEl5Up7uvdBBgkIlV95o1y53UBPnRff9/yjsDY9AnefT4OuF5V6wGX4LxHT9muz3ToNDEmAp19k2M62dqeqjZy438u9fjdaau7SPrPVepxlQIuBUrm1he1/MKSSi4TkSigKXAPcKvPrH3AXKBHBqsNAh5I/YCo6glVHaaqRzJYdglQRZ0RF/cDr4tIQ6ANMDxwR5Jt3YAJwHc4J6CMLATOz6xcVfcAI4BXcY5trar+lAuxns5ZQKyqJgKoaqyq/uvO6wa8AWwDrshoZVU9AQwAqolIvTyO77RUdT+wxd1O+nkbgWSgXLryP4BjwP+1d/4xdhVVHP98KUkp1jaWICYKrVGk1mIU8FdJayFVW5UIom3WojFKNhr5tQloTIwEDL8Eg4mhYCj8gUhBUpQ2arcB27QlAi1oS1uExixg0EQtiC5WpO3xj3Pu7uzb93Yv9L3dbD2fpGnvzNy5M71v5sw5c+ecNzXc8kbc/dPeKPeKmT1VvyvD2I8LqZ7RCraZ3wJvLa4/C6wF7mboOE4aSKHSeT4DrDOzp4G9kk4t8q4DLpU0qUqQNA2YamZ9NetfDPwCwMx2AL24sLowJrNOMaU0O+CaUckyfACuYqiGVnIW8MQo6bcAc4DL8Il5WsGZSAAABodJREFUPFiPa4FPS1oh6aMAko7CtYK1jNxPzOwAsB2YPVbtq4ukE4CjgB1N8j4EHMQXQWX6KcAeM/trmW5mLwBrgGclrZK0vNByAHqK382Gmk28CVguaXqTvNdTXx0GxlXQhb/jEd9zkkJlLOjCJ1fi74EfZJimHgG+0OpmSZ+IAfOMpHlF1gZJzwNL8B96xU3A82a2sU3tb8W+0uyAmxOqNp+Gr5yfwwXc+yXNKO69PgRRN67BtUw3s4O4KezXsaIec8ysHzd9dOOT6z3y/a9PAxvMbB+wGji7XCA0oSNeAUdoX7PzAmXaMkk7cC1lhZn9p8jriXdxA7DMBs8e9Ejahf9ur2rRnvNxTflR4FLg9iK7NFedUbN//wTuAC5qkt2svlbnJOqcnxg2riQdB5wIbInF4auS5tZp+/8jKVQ6SEykZwIrJT2Dr7aXMnRyuRr4VpUWA6hf0tvjujcm7Z1Auf9yBjAT+D1wRZF+MP6MJ13A7OjzH4FpwLlF/mUxCXzMzHbWSB/3PpnZATPbaGaXAxfg/ekCFkU/HwOOwd/3MELYnAw8OYbt28tQ89QM4O/F9T2xfzAPuFbSW4q8arKeb2abG9LfE/XfFtpas/Y8YWY34ntO5zYr8xr5Ib7QaNyfa0Zjv2F431vRbFwtjfr64l3PIrWVlqRQ6SyfA35iZjPNbJaZHQ/0AQMbomb2B2A3bvKpuAa4ufoyJjaAhw1eM9sPXAJ8qUETGDfC1LEUODn6PAs3AU7YQSjpJEknFknvwzWC+cAJRT+/QZN+xub1NcCfwkQ5Fu17Ft9s/mKUmQScBwwzEZnZNnz/6+K6zzSzNcA2GvYEJU2VtLBJWw6JMKv9jKGabSu2AqdXQjI058nU+3ih2bjqAhYX7/lUcl+lJRlPpbN04fsmJauBbzekXQX8rri+GV+RPSLpFaAfeKihDABm9hdJq/AJ7XttavehMB83v5UbxZuAOZKGbQRPEKYCPwohvx83F90PHF1tjgf3A9+XNDmufxrvbzLwAK0/WOhE+7qBV/HFyXZcE14H3NmijuuAxyVd/RqeeyVwl6RbizQB35T0Y2Af8DLw5SK/R9J5xfXZxZdXo/EDXAsraVqfpIuBX8Uipx/oClNqLRrG1Uzg4SKvT9JLsd8E8B1JlxT5b6v7nMORdNOSJEmStI00fyVJkiRtI4VKkiRJ0jZSqCRJkiRtI4VKkiRJ0jZSqCRJkiRtI4VKMmGRdECDnnTvlXT0IdRVetldKWnOCGUXNng3qPuMIV6DR0tvKNM/Un6T8uk9NxkXUqgkE5nKVcxc4L+408kBJL2uc1hmdr6Z7R6hyEL8FHqSJA2kUEkOFzYD7wwtYrOkNcBuSZMkXS9pqzxORhXbQ/IYJ09JegB4c1WRIvZG/HuxPL7LdkkPSpqFC6/KkeF8uWv+1fGMrZJOj3uPkbReHudkJTV8f8ljdjwW93Q35N0Y6Q9KOjbS3iFpXdyzWRGzJ0nGizxRn0x4QiNZgp8YBzgFmBsnn7uBl8zsA3HS/SFJ6/E4HyfhHpCPw13l3N5Q77HArcCCqGuGmb0g6Rag38xuiHJ34T6xtsg9/vYC7wYux50QXinpU9RzMfKVeMYUYKuk1eFI8w3ANjPrkfTdqPsC3C3818xsT5zwXkEL/2NJMhakUEkmMlPCky64pnIbbpZ6tAgd8HHgvdV+CTAd9zi7AFgVLun/LOk3Ter/MLCpqiv8TzVjEe6GprqeJo+jswCPw4GZ/VLSizX6dJGkc+Lfx0db9+IONavInncC98Uz5gH3Fs+eTJKMIylUkonMvvDgPEBMri+XSXhsmd6Gcp9sYzuOwKN0lq7j0bBAkCMTjhgXAR8xs39L2kgTR6KBxXP/0fh/kCTjSe6pJIc7vcDXw1Mwkt4lD2+8CY8nMikcXTaL7fEwsEARhkCDnqD/hUc4rFgPXFhdSKom+U1ErBxJSxjujr2R6cCLIVBm45pSxRG412uizi0RJqFP0ufjGVJnIksmSW1SqCSHOyvx/ZLHJe3EA34dCfwc2BN5d+DhY4dgZn/Dvf3eF55+K/PTWuCcaqMeDx51WnwIsJvBr9CuwIXSLtwM9twobV0HHCnpSeBaCs+4uPb1wejDmQxG2lwOfDXat4vOeUJOklqkl+IkSZKkbaSmkiRJkrSNFCpJkiRJ20ihkiRJkrSNFCpJkiRJ20ihkiRJkrSNFCpJkiRJ20ihkiRJkrSN/wEq8GxoDDxSFwAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7iyM_SREPTbE"
      },
      "source": [
        "####Exercise (Discussion) | Est Time: | Within a student group"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cVsJs_arPTnR",
        "cellView": "form"
      },
      "source": [
        "#@title Take a look at your confusion Matrix and answer the following questions\n",
        "\n",
        "#@markdown Name most correctly classified emotion? \n",
        "correct_emotion = \"Surprise\"#@param [\"Anger\",\"Happy\",\"Sad\",\"Surprise\",\"Fill Me In\"] \n",
        "\n",
        "#@markdown Name most incorrectly classified emotion? \n",
        "incorrect_emotion = \"Sad\"#@param [\"Anger\",\"Happy\",\"Sad\",\"Surprise\",\"Fill Me In\"] \n",
        "\n",
        "#@markdown Sad Emotion is highly misclassified as?\n",
        "sad_misclassify =\"Neutral\"#@param [\"Anger\",\"Happy\",\"Sad\",\"Surprise\", \"Neutral\", \"Fill Me In\"]\n",
        "\n",
        "#@markdown Neutral Emotion is highly misclassified as?\n",
        "neutral_misclassify =\"Sad\"#@param [\"Anger\",\"Happy\",\"Sad\",\"Surprise\", \"Neutral\", \"Fill Me In\"] \n",
        "\n",
        "\n",
        "#@markdown Angry Emotion is highly misclassified as?\n",
        "angry_misclassify =\"Neutral\"#@param [\"Anger\",\"Happy\",\"Sad\",\"Surprise\", \"Neutral\", \"Fill Me In\"]\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g0dNBYIPI2-c"
      },
      "source": [
        "#Milestone 4: Coding Exercise\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GolaaB1-tvBC"
      },
      "source": [
        "We performed feature generation and extraction process in the previous sections. Now train your best model from Section 3 again with actual pixels of the images with standardization.\n",
        "\n",
        "####Report and Comment over the result!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zqMKoYD0Ib9L"
      },
      "source": [
        "#Load the true pixel data and corresponding labels\n",
        "X = np.load('pureX.npy')\n",
        "Y = np.load('dataY.npy')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WatuJy48Qe__",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 374
        },
        "outputId": "fa9bb621-c932-4e71-c7a8-c1e7556fbe3d"
      },
      "source": [
        "###YOUR CODE HERE\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.1, random_state=42,stratify =dataY)\n",
        "\n",
        "scaler = StandardScaler()\n",
        "scaler.fit(X_train)\n",
        "X_train = scaler.transform(X_train)\n",
        "X_test = scaler.transform(X_test)\n",
        "\n",
        "pca = PCA(.95)\n",
        "pca.fit(X_train)\n",
        "\n",
        "\n",
        "\n",
        "lr = LogisticRegression(solver='lbfgs',multi_class='multinomial')\n",
        "lr.fit(X_train, y_train)\n",
        "y_pred2 = lr.predict(X_test)\n",
        "accuracy2 = metrics.accuracy_score(y_pred2, y_test)\n",
        "print(accuracy2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-38-fc85d6d90aae>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0mlr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLogisticRegression\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msolver\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'lbfgs'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmulti_class\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'multinomial'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mlr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m \u001b[0my_pred2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0maccuracy2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmetrics\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maccuracy_score\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_pred2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, sample_weight)\u001b[0m\n\u001b[1;32m   1599\u001b[0m                       \u001b[0mpenalty\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpenalty\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_squared_sum\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmax_squared_sum\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1600\u001b[0m                       sample_weight=sample_weight)\n\u001b[0;32m-> 1601\u001b[0;31m             for class_, warm_start_coef_ in zip(classes_, warm_start_coef))\n\u001b[0m\u001b[1;32m   1602\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1603\u001b[0m         \u001b[0mfold_coefs_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_iter_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mfold_coefs_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m   1039\u001b[0m             \u001b[0;31m# remaining jobs.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1040\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_iterating\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1041\u001b[0;31m             \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdispatch_one_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1042\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_iterating\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_original_iterator\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1043\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36mdispatch_one_batch\u001b[0;34m(self, iterator)\u001b[0m\n\u001b[1;32m    857\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    858\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 859\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dispatch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtasks\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    860\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    861\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m_dispatch\u001b[0;34m(self, batch)\u001b[0m\n\u001b[1;32m    775\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    776\u001b[0m             \u001b[0mjob_idx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_jobs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 777\u001b[0;31m             \u001b[0mjob\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    778\u001b[0m             \u001b[0;31m# A job can complete so quickly than its callback is\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    779\u001b[0m             \u001b[0;31m# called before we get here, causing self._jobs to\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/joblib/_parallel_backends.py\u001b[0m in \u001b[0;36mapply_async\u001b[0;34m(self, func, callback)\u001b[0m\n\u001b[1;32m    206\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mapply_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    207\u001b[0m         \u001b[0;34m\"\"\"Schedule a func to be run\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 208\u001b[0;31m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mImmediateResult\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    209\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mcallback\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    210\u001b[0m             \u001b[0mcallback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/joblib/_parallel_backends.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, batch)\u001b[0m\n\u001b[1;32m    570\u001b[0m         \u001b[0;31m# Don't delay the application, to avoid keeping the input\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    571\u001b[0m         \u001b[0;31m# arguments in memory\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 572\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    573\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    574\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    261\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mparallel_backend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_n_jobs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    262\u001b[0m             return [func(*args, **kwargs)\n\u001b[0;32m--> 263\u001b[0;31m                     for func, args, kwargs in self.items]\n\u001b[0m\u001b[1;32m    264\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    265\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__reduce__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m    261\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mparallel_backend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_n_jobs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    262\u001b[0m             return [func(*args, **kwargs)\n\u001b[0;32m--> 263\u001b[0;31m                     for func, args, kwargs in self.items]\n\u001b[0m\u001b[1;32m    264\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    265\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__reduce__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py\u001b[0m in \u001b[0;36m_logistic_regression_path\u001b[0;34m(X, y, pos_class, Cs, fit_intercept, max_iter, tol, verbose, solver, coef, class_weight, dual, penalty, intercept_scaling, multi_class, random_state, check_input, max_squared_sum, sample_weight, l1_ratio)\u001b[0m\n\u001b[1;32m    934\u001b[0m                 \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"L-BFGS-B\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjac\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    935\u001b[0m                 \u001b[0margs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mC\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 936\u001b[0;31m                 \u001b[0moptions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m\"iprint\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0miprint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"gtol\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtol\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"maxiter\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mmax_iter\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    937\u001b[0m             )\n\u001b[1;32m    938\u001b[0m             n_iter_i = _check_optimize_result(\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_minimize.py\u001b[0m in \u001b[0;36mminimize\u001b[0;34m(fun, x0, args, method, jac, hess, hessp, bounds, constraints, tol, callback, options)\u001b[0m\n\u001b[1;32m    608\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mmeth\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'l-bfgs-b'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    609\u001b[0m         return _minimize_lbfgsb(fun, x0, args, jac, bounds,\n\u001b[0;32m--> 610\u001b[0;31m                                 callback=callback, **options)\n\u001b[0m\u001b[1;32m    611\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mmeth\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'tnc'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    612\u001b[0m         return _minimize_tnc(fun, x0, args, jac, bounds, callback=callback,\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/lbfgsb.py\u001b[0m in \u001b[0;36m_minimize_lbfgsb\u001b[0;34m(fun, x0, args, jac, bounds, disp, maxcor, ftol, gtol, eps, maxfun, maxiter, iprint, callback, maxls, **unknown_options)\u001b[0m\n\u001b[1;32m    343\u001b[0m             \u001b[0;31m# until the completion of the current minimization iteration.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    344\u001b[0m             \u001b[0;31m# Overwrite f and g:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 345\u001b[0;31m             \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc_and_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    346\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mtask_str\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mb'NEW_X'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    347\u001b[0m             \u001b[0;31m# new iteration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/lbfgsb.py\u001b[0m in \u001b[0;36mfunc_and_grad\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m    293\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    294\u001b[0m         \u001b[0;32mdef\u001b[0m \u001b[0mfunc_and_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 295\u001b[0;31m             \u001b[0mf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    296\u001b[0m             \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjac\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    297\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/optimize.py\u001b[0m in \u001b[0;36mfunction_wrapper\u001b[0;34m(*wrapper_args)\u001b[0m\n\u001b[1;32m    325\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mfunction_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mwrapper_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    326\u001b[0m         \u001b[0mncalls\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 327\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mfunction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapper_args\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    328\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    329\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mncalls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunction_wrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/optimize.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, x, *args)\u001b[0m\n\u001b[1;32m     63\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     64\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 65\u001b[0;31m         \u001b[0mfg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     66\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjac\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfg\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     67\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mfg\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(x, *args)\u001b[0m\n\u001b[1;32m    909\u001b[0m         \u001b[0mtarget\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mY_multi\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    910\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0msolver\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'lbfgs'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 911\u001b[0;31m             \u001b[0mfunc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0m_multinomial_loss_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    912\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0msolver\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'newton-cg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    913\u001b[0m             \u001b[0mfunc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0m_multinomial_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py\u001b[0m in \u001b[0;36m_multinomial_loss_grad\u001b[0;34m(w, X, Y, alpha, sample_weight)\u001b[0m\n\u001b[1;32m    347\u001b[0m     grad = np.zeros((n_classes, n_features + bool(fit_intercept)),\n\u001b[1;32m    348\u001b[0m                     dtype=X.dtype)\n\u001b[0;32m--> 349\u001b[0;31m     \u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_multinomial_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    350\u001b[0m     \u001b[0msample_weight\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnewaxis\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    351\u001b[0m     \u001b[0mdiff\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msample_weight\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mp\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py\u001b[0m in \u001b[0;36m_multinomial_loss\u001b[0;34m(w, X, Y, alpha, sample_weight)\u001b[0m\n\u001b[1;32m    295\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    296\u001b[0m         \u001b[0mintercept\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 297\u001b[0;31m     \u001b[0mp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msafe_sparse_dot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    298\u001b[0m     \u001b[0mp\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mintercept\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    299\u001b[0m     \u001b[0mp\u001b[0m \u001b[0;34m-=\u001b[0m \u001b[0mlogsumexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnewaxis\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/sklearn/utils/extmath.py\u001b[0m in \u001b[0;36msafe_sparse_dot\u001b[0;34m(a, b, dense_output)\u001b[0m\n\u001b[1;32m    149\u001b[0m             \u001b[0mret\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    150\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 151\u001b[0;31m         \u001b[0mret\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    152\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    153\u001b[0m     if (sparse.issparse(a) and sparse.issparse(b)\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jTI1-quUzf96"
      },
      "source": [
        "#Finish!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YlBmqx-agQiw"
      },
      "source": [
        "### Example"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lfM0GGKm1FMQ"
      },
      "source": [
        "# extract images as vectors, convert from strings to ints -- this is called a \"list comprihension\" \n",
        "x_image = np.array( [np.fromstring(df['pixels'][i], dtype=np.uint8, sep=\" \") for i in range(len(df))] ) \n",
        "\n",
        "# extract labels in the same way--through a list comprehension\n",
        "y_image = np.array( [df['emotion'][i] for i in range(len(df)) ])\n",
        "\n",
        "# generate train-test (90/10) splits\n",
        "X_train, X_test, y_train, y_test = train_test_split(x_image, y_image, test_size=0.1,random_state=42)\n",
        "\n",
        "# define the model\n",
        "knn = KNeighborsClassifier(n_neighbors=10)\n",
        "\n",
        "# train \n",
        "print (\"training knn model ...\")\n",
        "knn.fit(X_train, y_train)\n",
        "\n",
        "# test\n",
        "print (\"Predict for KNN Model\")\n",
        "y_pred_knn = knn.predict(X_test)\n",
        "\n",
        "# display results\n",
        "print (\"KNN Test Accuracy on raw image inputs:\", metrics.accuracy_score(y_test, y_pred_knn))"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}