diff --git a/your-code/main.ipynb b/your-code/main.ipynb
index a5caf8b..654f63e 100755
--- a/your-code/main.ipynb
+++ b/your-code/main.ipynb
@@ -12,16 +12,87 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Import your libraries:\n",
+    "# 📚 Basic Libraries\n",
+    "import numpy as np # operaciones matemáticas (numerical python)\n",
+    "import pandas as pd # manipulación de datos\n",
+    "import warnings # nobody likes warnings\n",
+    "\n",
+    "# 📊 Visualizations\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "# 🤖 Machine Learning\n",
+    "from sklearn.svm import LinearSVC\n",
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "import plotly.graph_objs as go\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.linear_model import LogisticRegression #esta es nueva\n",
+    "from sklearn.metrics import roc_curve, confusion_matrix, ConfusionMatrixDisplay #esta es nueva, me da el mapita de calor de roc curve\n",
+    "from sklearn.metrics import classification_report #esta es nueva, esta me va a decir todo el reporte\n",
     "\n",
     "%matplotlib inline\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ⚙️ Settings\n",
+    "pd.set_option('display.max_columns', None) # display all columns\n",
+    "warnings.filterwarnings('ignore') # ignore warnings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 🔧 Basic functions\n",
+    "def snake_columns(data): \n",
+    "    \"\"\"\n",
+    "    returns the columns in snake case\n",
+    "    \"\"\"\n",
+    "    data.columns = [column.lower().replace(' ', '_') for column in data.columns]\n",
+    "    \n",
+    "def open_data(data): # returns shape, data types & shows a small sample\n",
+    "    print(f\"Data shape is {data.shape}.\")\n",
+    "    print()\n",
+    "    print(data.dtypes)\n",
+    "    print()\n",
+    "    print(\"Data row sample and full columns:\")\n",
+    "    return data.sample(5)\n",
     "\n",
-    "import numpy as np\n",
-    "import pandas as pd"
+    "# 🎯 Specific functions\n",
+    "def explore_data(data): # sum & returns duplicates, NaN & empty spaces\n",
+    "    duplicate_rows = data.duplicated().sum()\n",
+    "    nan_values = data.isna().sum()\n",
+    "    empty_spaces = data.eq(' ').sum()\n",
+    "    import pandas as pd\n",
+    "    exploration = pd.DataFrame({\"NaN\": nan_values, \"EmptySpaces\": empty_spaces}) # New dataframe with the results\n",
+    "    print(f\"There are {data.duplicated().sum()} duplicate rows. Also;\")\n",
+    "    return exploration\n",
+    "\n",
+    "#el threshold es el que le pongo como parametro apra que quite los outliers de 1.5 o menos podemos hacerlo con menos mejor, pero si no ponemos nada\n",
+    "#pondra por defecto 1.5.\n",
+    "def outlier_slayer(data, threshold = 1.5): # automatically removes outliers based on Q1, Q3 #CUIDADO MEJOR VER EN BOX PLOTS Y VER QUE QUITAMOS#\n",
+    "    for column in data.select_dtypes(include=[np.number]):\n",
+    "        Q1 = data[column].quantile(0.25)\n",
+    "        Q3 = data[column].quantile(0.75)\n",
+    "        IQR = Q3 - Q1\n",
+    "        lower_bound = Q1 - threshold * IQR\n",
+    "        upper_bound = Q3 + threshold * IQR\n",
+    "        data = data[(data[column] >= lower_bound) & (data[column] <= upper_bound)]\n",
+    "    return data"
    ]
   },
   {
@@ -37,7 +108,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -65,20 +136,461 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "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>URL</th>\n",
+       "      <th>URL_LENGTH</th>\n",
+       "      <th>NUMBER_SPECIAL_CHARACTERS</th>\n",
+       "      <th>CHARSET</th>\n",
+       "      <th>SERVER</th>\n",
+       "      <th>CONTENT_LENGTH</th>\n",
+       "      <th>WHOIS_COUNTRY</th>\n",
+       "      <th>WHOIS_STATEPRO</th>\n",
+       "      <th>WHOIS_REGDATE</th>\n",
+       "      <th>WHOIS_UPDATED_DATE</th>\n",
+       "      <th>TCP_CONVERSATION_EXCHANGE</th>\n",
+       "      <th>DIST_REMOTE_TCP_PORT</th>\n",
+       "      <th>REMOTE_IPS</th>\n",
+       "      <th>APP_BYTES</th>\n",
+       "      <th>SOURCE_APP_PACKETS</th>\n",
+       "      <th>REMOTE_APP_PACKETS</th>\n",
+       "      <th>SOURCE_APP_BYTES</th>\n",
+       "      <th>REMOTE_APP_BYTES</th>\n",
+       "      <th>APP_PACKETS</th>\n",
+       "      <th>DNS_QUERY_TIMES</th>\n",
+       "      <th>Type</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>M0_109</td>\n",
+       "      <td>16</td>\n",
+       "      <td>7</td>\n",
+       "      <td>iso-8859-1</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>263.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>10/10/2015 18:21</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>7</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>700</td>\n",
+       "      <td>9</td>\n",
+       "      <td>10</td>\n",
+       "      <td>1153</td>\n",
+       "      <td>832</td>\n",
+       "      <td>9</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>B0_2314</td>\n",
+       "      <td>16</td>\n",
+       "      <td>6</td>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>Apache/2.4.10</td>\n",
+       "      <td>15087.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>17</td>\n",
+       "      <td>7</td>\n",
+       "      <td>4</td>\n",
+       "      <td>1230</td>\n",
+       "      <td>17</td>\n",
+       "      <td>19</td>\n",
+       "      <td>1265</td>\n",
+       "      <td>1230</td>\n",
+       "      <td>17</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>B0_911</td>\n",
+       "      <td>16</td>\n",
+       "      <td>6</td>\n",
+       "      <td>us-ascii</td>\n",
+       "      <td>Microsoft-HTTPAPI/2.0</td>\n",
+       "      <td>324.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>B0_113</td>\n",
+       "      <td>17</td>\n",
+       "      <td>6</td>\n",
+       "      <td>ISO-8859-1</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>162.0</td>\n",
+       "      <td>US</td>\n",
+       "      <td>AK</td>\n",
+       "      <td>7/10/1997 4:00</td>\n",
+       "      <td>12/09/2013 0:45</td>\n",
+       "      <td>31</td>\n",
+       "      <td>22</td>\n",
+       "      <td>3</td>\n",
+       "      <td>3812</td>\n",
+       "      <td>39</td>\n",
+       "      <td>37</td>\n",
+       "      <td>18784</td>\n",
+       "      <td>4380</td>\n",
+       "      <td>39</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>B0_403</td>\n",
+       "      <td>17</td>\n",
+       "      <td>6</td>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>124140.0</td>\n",
+       "      <td>US</td>\n",
+       "      <td>TX</td>\n",
+       "      <td>12/05/1996 0:00</td>\n",
+       "      <td>11/04/2017 0:00</td>\n",
+       "      <td>57</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
+       "      <td>4278</td>\n",
+       "      <td>61</td>\n",
+       "      <td>62</td>\n",
+       "      <td>129889</td>\n",
+       "      <td>4586</td>\n",
+       "      <td>61</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       URL  URL_LENGTH  NUMBER_SPECIAL_CHARACTERS     CHARSET  \\\n",
+       "0   M0_109          16                          7  iso-8859-1   \n",
+       "1  B0_2314          16                          6       UTF-8   \n",
+       "2   B0_911          16                          6    us-ascii   \n",
+       "3   B0_113          17                          6  ISO-8859-1   \n",
+       "4   B0_403          17                          6       UTF-8   \n",
+       "\n",
+       "                  SERVER  CONTENT_LENGTH WHOIS_COUNTRY WHOIS_STATEPRO  \\\n",
+       "0                  nginx           263.0           NaN            NaN   \n",
+       "1          Apache/2.4.10         15087.0           NaN            NaN   \n",
+       "2  Microsoft-HTTPAPI/2.0           324.0           NaN            NaN   \n",
+       "3                  nginx           162.0            US             AK   \n",
+       "4                    NaN        124140.0            US             TX   \n",
+       "\n",
+       "      WHOIS_REGDATE WHOIS_UPDATED_DATE  TCP_CONVERSATION_EXCHANGE  \\\n",
+       "0  10/10/2015 18:21                NaN                          7   \n",
+       "1               NaN                NaN                         17   \n",
+       "2               NaN                NaN                          0   \n",
+       "3    7/10/1997 4:00    12/09/2013 0:45                         31   \n",
+       "4   12/05/1996 0:00    11/04/2017 0:00                         57   \n",
+       "\n",
+       "   DIST_REMOTE_TCP_PORT  REMOTE_IPS  APP_BYTES  SOURCE_APP_PACKETS  \\\n",
+       "0                     0           2        700                   9   \n",
+       "1                     7           4       1230                  17   \n",
+       "2                     0           0          0                   0   \n",
+       "3                    22           3       3812                  39   \n",
+       "4                     2           5       4278                  61   \n",
+       "\n",
+       "   REMOTE_APP_PACKETS  SOURCE_APP_BYTES  REMOTE_APP_BYTES  APP_PACKETS  \\\n",
+       "0                  10              1153               832            9   \n",
+       "1                  19              1265              1230           17   \n",
+       "2                   0                 0                 0            0   \n",
+       "3                  37             18784              4380           39   \n",
+       "4                  62            129889              4586           61   \n",
+       "\n",
+       "   DNS_QUERY_TIMES  Type  \n",
+       "0              2.0     1  \n",
+       "1              0.0     0  \n",
+       "2              0.0     0  \n",
+       "3              8.0     0  \n",
+       "4              4.0     0  "
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Your code here: What the dataset looks like?\n",
+    "websites.head()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "URL                           object\n",
+       "URL_LENGTH                     int64\n",
+       "NUMBER_SPECIAL_CHARACTERS      int64\n",
+       "CHARSET                       object\n",
+       "SERVER                        object\n",
+       "CONTENT_LENGTH               float64\n",
+       "WHOIS_COUNTRY                 object\n",
+       "WHOIS_STATEPRO                object\n",
+       "WHOIS_REGDATE                 object\n",
+       "WHOIS_UPDATED_DATE            object\n",
+       "TCP_CONVERSATION_EXCHANGE      int64\n",
+       "DIST_REMOTE_TCP_PORT           int64\n",
+       "REMOTE_IPS                     int64\n",
+       "APP_BYTES                      int64\n",
+       "SOURCE_APP_PACKETS             int64\n",
+       "REMOTE_APP_PACKETS             int64\n",
+       "SOURCE_APP_BYTES               int64\n",
+       "REMOTE_APP_BYTES               int64\n",
+       "APP_PACKETS                    int64\n",
+       "DNS_QUERY_TIMES              float64\n",
+       "Type                           int64\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Your code here:  What are the data types?\n",
+    "websites.dtypes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Index(['URL', 'URL_LENGTH', 'NUMBER_SPECIAL_CHARACTERS', 'CHARSET', 'SERVER',\n",
+       "       'CONTENT_LENGTH', 'WHOIS_COUNTRY', 'WHOIS_STATEPRO', 'WHOIS_REGDATE',\n",
+       "       'WHOIS_UPDATED_DATE', 'TCP_CONVERSATION_EXCHANGE',\n",
+       "       'DIST_REMOTE_TCP_PORT', 'REMOTE_IPS', 'APP_BYTES', 'SOURCE_APP_PACKETS',\n",
+       "       'REMOTE_APP_PACKETS', 'SOURCE_APP_BYTES', 'REMOTE_APP_BYTES',\n",
+       "       'APP_PACKETS', 'DNS_QUERY_TIMES', 'Type'],\n",
+       "      dtype='object')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Your code here: columns\n",
+    "websites.columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "# Your code here: Which columns contain the features of the websites?\n",
+    "#URL', 'URL_LENGTH', 'NUMBER_SPECIAL_CHARACTERS', 'CHARSET', 'SERVER',\n",
+    "        #'CONTENT_LENGTH', 'WHOIS_COUNTRY', 'WHOIS_STATEPRO', 'WHOIS_REGDATE',\n",
+    "       #'WHOIS_UPDATED_DATE', 'TCP_CONVERSATION_EXCHANGE',\n",
+    "       #'DIST_REMOTE_TCP_PORT', 'REMOTE_IPS', 'APP_BYTES', 'SOURCE_APP_PACKETS',\n",
+    "       #'REMOTE_APP_PACKETS', 'SOURCE_APP_BYTES', 'REMOTE_APP_BYTES',\n",
+    "       #'APP_PACKETS', 'DNS_QUERY_TIMES'"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Type\n",
+       "0    1565\n",
+       "1     216\n",
+       "Name: count, dtype: int64"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "websites.Type.value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Which column contains the feature we will predict? \n",
+    "#The target is Type. \n",
+    "\n",
+    "#What is the code standing for benign vs malicious websites?\n",
+    "#De acuerdo con el value counts consideramos que el 0 es para paginas benignas y el 1 es para paginas malignas."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your comment here"
+    "#Do we need to transform any of the columns from categorical to ordinal values? \n",
+    "#No, \n",
+    "\n",
+    "#If so what are these columns?\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1781"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(websites)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "URL                          1781\n",
+       "URL_LENGTH                    142\n",
+       "NUMBER_SPECIAL_CHARACTERS      31\n",
+       "CHARSET                         8\n",
+       "SERVER                        238\n",
+       "CONTENT_LENGTH                637\n",
+       "WHOIS_COUNTRY                  48\n",
+       "WHOIS_STATEPRO                181\n",
+       "WHOIS_REGDATE                 890\n",
+       "WHOIS_UPDATED_DATE            593\n",
+       "TCP_CONVERSATION_EXCHANGE     103\n",
+       "DIST_REMOTE_TCP_PORT           66\n",
+       "REMOTE_IPS                     18\n",
+       "APP_BYTES                     825\n",
+       "SOURCE_APP_PACKETS            113\n",
+       "REMOTE_APP_PACKETS            116\n",
+       "SOURCE_APP_BYTES              885\n",
+       "REMOTE_APP_BYTES              822\n",
+       "APP_PACKETS                   113\n",
+       "DNS_QUERY_TIMES                10\n",
+       "Type                            2\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "websites.nunique()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array(['iso-8859-1', 'UTF-8', 'us-ascii', 'ISO-8859-1', 'utf-8', nan,\n",
+       "       'windows-1251', 'ISO-8859', 'windows-1252'], dtype=object)"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "websites.CHARSET.unique()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<h2 style=\"color: #FF6347;\">Copy as best practices</h2>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = websites.copy()"
    ]
   },
   {
@@ -102,20 +614,56 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "# Your comment here\n",
+    "cat = df.select_dtypes(exclude=\"number\")\n",
+    "num = df.select_dtypes(include=\"number\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2500x1500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#You will create a correlation matrix using the numeric columns in the dataset. \n",
+    "#Create a heatmap using seaborn to visualize which columns have high collinearity.\n",
+    "num_corr = round(num.corr(), 2)\n",
+    "\n",
+    "mask = np.zeros_like(num_corr)\n",
+    "mask[np.triu_indices_from(mask)] = True # optional, to hide repeat half of the matrix\n",
+    "\n",
+    "f, ax = plt.subplots(figsize=(25, 15))\n",
+    "sns.set(font_scale=1.5) # increase font size\n",
+    "\n",
+    "ax = sns.heatmap(num_corr, mask=mask, annot=True, annot_kws={\"size\": 12}, linewidths=.5, cmap=\"coolwarm\", fmt=\".2f\", ax=ax) # round to 2 decimal places\n",
+    "ax.set_title(\"Dealing with Multicollinearity\", fontsize=20) # add title\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your comment here"
+    "#Comment on which columns you might need to remove due to high collinearity.\n",
+    "#We need to erase the colums: SOURCE_APP_PACKETS, REMOTE_APP_PACKETS, APP_PACKETS, REMOTE_APP_BYTES, SOURCE_APP_PACKETS\n",
+    "\n"
    ]
   },
   {
@@ -133,29 +681,381 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "# Your code here\n",
+    "df_clean = num.drop(columns = [\"SOURCE_APP_PACKETS\", \"TCP_CONVERSATION_EXCHANGE\",\"REMOTE_APP_PACKETS\",\"APP_BYTES\"])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "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>URL_LENGTH</th>\n",
+       "      <th>NUMBER_SPECIAL_CHARACTERS</th>\n",
+       "      <th>CONTENT_LENGTH</th>\n",
+       "      <th>DIST_REMOTE_TCP_PORT</th>\n",
+       "      <th>REMOTE_IPS</th>\n",
+       "      <th>SOURCE_APP_BYTES</th>\n",
+       "      <th>REMOTE_APP_BYTES</th>\n",
+       "      <th>APP_PACKETS</th>\n",
+       "      <th>DNS_QUERY_TIMES</th>\n",
+       "      <th>Type</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>16</td>\n",
+       "      <td>7</td>\n",
+       "      <td>263.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1153</td>\n",
+       "      <td>832</td>\n",
+       "      <td>9</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>16</td>\n",
+       "      <td>6</td>\n",
+       "      <td>15087.0</td>\n",
+       "      <td>7</td>\n",
+       "      <td>4</td>\n",
+       "      <td>1265</td>\n",
+       "      <td>1230</td>\n",
+       "      <td>17</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>16</td>\n",
+       "      <td>6</td>\n",
+       "      <td>324.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>17</td>\n",
+       "      <td>6</td>\n",
+       "      <td>162.0</td>\n",
+       "      <td>22</td>\n",
+       "      <td>3</td>\n",
+       "      <td>18784</td>\n",
+       "      <td>4380</td>\n",
+       "      <td>39</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>17</td>\n",
+       "      <td>6</td>\n",
+       "      <td>124140.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
+       "      <td>129889</td>\n",
+       "      <td>4586</td>\n",
+       "      <td>61</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   URL_LENGTH  NUMBER_SPECIAL_CHARACTERS  CONTENT_LENGTH  \\\n",
+       "0          16                          7           263.0   \n",
+       "1          16                          6         15087.0   \n",
+       "2          16                          6           324.0   \n",
+       "3          17                          6           162.0   \n",
+       "4          17                          6        124140.0   \n",
+       "\n",
+       "   DIST_REMOTE_TCP_PORT  REMOTE_IPS  SOURCE_APP_BYTES  REMOTE_APP_BYTES  \\\n",
+       "0                     0           2              1153               832   \n",
+       "1                     7           4              1265              1230   \n",
+       "2                     0           0                 0                 0   \n",
+       "3                    22           3             18784              4380   \n",
+       "4                     2           5            129889              4586   \n",
+       "\n",
+       "   APP_PACKETS  DNS_QUERY_TIMES  Type  \n",
+       "0            9              2.0     1  \n",
+       "1           17              0.0     0  \n",
+       "2            0              0.0     0  \n",
+       "3           39              8.0     0  \n",
+       "4           61              4.0     0  "
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Your comment here\n",
+    "df_clean.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1781"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(num)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1781"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(df_clean)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "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>URL_LENGTH</th>\n",
+       "      <th>NUMBER_SPECIAL_CHARACTERS</th>\n",
+       "      <th>CONTENT_LENGTH</th>\n",
+       "      <th>DIST_REMOTE_TCP_PORT</th>\n",
+       "      <th>REMOTE_IPS</th>\n",
+       "      <th>SOURCE_APP_BYTES</th>\n",
+       "      <th>REMOTE_APP_BYTES</th>\n",
+       "      <th>APP_PACKETS</th>\n",
+       "      <th>DNS_QUERY_TIMES</th>\n",
+       "      <th>Type</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>16</td>\n",
+       "      <td>7</td>\n",
+       "      <td>263.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1153</td>\n",
+       "      <td>832</td>\n",
+       "      <td>9</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>16</td>\n",
+       "      <td>6</td>\n",
+       "      <td>15087.0</td>\n",
+       "      <td>7</td>\n",
+       "      <td>4</td>\n",
+       "      <td>1265</td>\n",
+       "      <td>1230</td>\n",
+       "      <td>17</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>16</td>\n",
+       "      <td>6</td>\n",
+       "      <td>324.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>17</td>\n",
+       "      <td>6</td>\n",
+       "      <td>162.0</td>\n",
+       "      <td>22</td>\n",
+       "      <td>3</td>\n",
+       "      <td>18784</td>\n",
+       "      <td>4380</td>\n",
+       "      <td>39</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>17</td>\n",
+       "      <td>6</td>\n",
+       "      <td>124140.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
+       "      <td>129889</td>\n",
+       "      <td>4586</td>\n",
+       "      <td>61</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   URL_LENGTH  NUMBER_SPECIAL_CHARACTERS  CONTENT_LENGTH  \\\n",
+       "0          16                          7           263.0   \n",
+       "1          16                          6         15087.0   \n",
+       "2          16                          6           324.0   \n",
+       "3          17                          6           162.0   \n",
+       "4          17                          6        124140.0   \n",
+       "\n",
+       "   DIST_REMOTE_TCP_PORT  REMOTE_IPS  SOURCE_APP_BYTES  REMOTE_APP_BYTES  \\\n",
+       "0                     0           2              1153               832   \n",
+       "1                     7           4              1265              1230   \n",
+       "2                     0           0                 0                 0   \n",
+       "3                    22           3             18784              4380   \n",
+       "4                     2           5            129889              4586   \n",
+       "\n",
+       "   APP_PACKETS  DNS_QUERY_TIMES  Type  \n",
+       "0            9              2.0     1  \n",
+       "1           17              0.0     0  \n",
+       "2            0              0.0     0  \n",
+       "3           39              8.0     0  \n",
+       "4           61              4.0     0  "
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_clean.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your comment here"
+    "num_corr_clean = round(df_clean.corr(), 2)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2500x1500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Print heatmap again\n",
+    "mask = np.zeros_like(num_corr_clean)\n",
+    "mask[np.triu_indices_from(mask)] = True # optional, to hide repeat half of the matrix\n",
+    "\n",
+    "f, ax = plt.subplots(figsize=(25, 15))\n",
+    "sns.set(font_scale=1.5) # increase font size\n",
+    "\n",
+    "ax = sns.heatmap(num_corr_clean, mask=mask, annot=True, annot_kws={\"size\": 12}, linewidths=.5, cmap=\"coolwarm\", fmt=\".2f\", ax=ax) # round to 2 decimal places\n",
+    "ax.set_title(\"Dealing with Multicollinearity\", fontsize=20) # add title\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Print heatmap again\n"
+    "#if we really want all the corralation below 90 we should eliminate the column url_length.\n",
+    "#This column is really correlate with my target therefore i would leave this column."
    ]
   },
   {
@@ -169,11 +1069,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 34,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "URL_LENGTH                     0\n",
+       "NUMBER_SPECIAL_CHARACTERS      0\n",
+       "CONTENT_LENGTH               812\n",
+       "DIST_REMOTE_TCP_PORT           0\n",
+       "REMOTE_IPS                     0\n",
+       "SOURCE_APP_BYTES               0\n",
+       "REMOTE_APP_BYTES               0\n",
+       "APP_PACKETS                    0\n",
+       "DNS_QUERY_TIMES                1\n",
+       "Type                           0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# Your code here\n"
+    "# Your code here\n",
+    "df_clean.isna().sum()\n"
    ]
   },
   {
@@ -187,20 +1109,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
+   "execution_count": 36,
+   "metadata": {
+    "scrolled": true
+   },
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "# Your code here, we can put df_clean = df_clean.drop... or we can do it like: df_clean.drop(columns=[\"CONTENT_LENGTH\"], inplace=True)\n",
+    "df_clean = df_clean.drop(columns = [\"CONTENT_LENGTH\"])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 37,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your comment here"
+    "# Your comment here\n",
+    "#I decide to erase the column CONTENT_LENGTH because is the one with must na values, we cant use the mean to fill the na because this would move a lot\n",
+    "#our statistics. "
    ]
   },
   {
@@ -214,11 +1141,71 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "URL_LENGTH                   0\n",
+       "NUMBER_SPECIAL_CHARACTERS    0\n",
+       "DIST_REMOTE_TCP_PORT         0\n",
+       "REMOTE_IPS                   0\n",
+       "SOURCE_APP_BYTES             0\n",
+       "REMOTE_APP_BYTES             0\n",
+       "APP_PACKETS                  0\n",
+       "DNS_QUERY_TIMES              1\n",
+       "Type                         0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Examine missing values in each column\n",
+    "df_clean.isna().sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Examine missing values in each column\n"
+    "df_clean['DNS_QUERY_TIMES'].fillna(method='ffill', inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "URL_LENGTH                   0\n",
+       "NUMBER_SPECIAL_CHARACTERS    0\n",
+       "DIST_REMOTE_TCP_PORT         0\n",
+       "REMOTE_IPS                   0\n",
+       "SOURCE_APP_BYTES             0\n",
+       "REMOTE_APP_BYTES             0\n",
+       "APP_PACKETS                  0\n",
+       "DNS_QUERY_TIMES              0\n",
+       "Type                         0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Examine missing values in each column\n",
+    "df_clean.isna().sum()"
    ]
   },
   {
@@ -256,11 +1243,272 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "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>URL</th>\n",
+       "      <th>CHARSET</th>\n",
+       "      <th>SERVER</th>\n",
+       "      <th>WHOIS_COUNTRY</th>\n",
+       "      <th>WHOIS_STATEPRO</th>\n",
+       "      <th>WHOIS_REGDATE</th>\n",
+       "      <th>WHOIS_UPDATED_DATE</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>M0_109</td>\n",
+       "      <td>iso-8859-1</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>10/10/2015 18:21</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>B0_2314</td>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>Apache/2.4.10</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>B0_911</td>\n",
+       "      <td>us-ascii</td>\n",
+       "      <td>Microsoft-HTTPAPI/2.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>B0_113</td>\n",
+       "      <td>ISO-8859-1</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>US</td>\n",
+       "      <td>AK</td>\n",
+       "      <td>7/10/1997 4:00</td>\n",
+       "      <td>12/09/2013 0:45</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>B0_403</td>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>US</td>\n",
+       "      <td>TX</td>\n",
+       "      <td>12/05/1996 0:00</td>\n",
+       "      <td>11/04/2017 0:00</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       URL     CHARSET                 SERVER WHOIS_COUNTRY WHOIS_STATEPRO  \\\n",
+       "0   M0_109  iso-8859-1                  nginx           NaN            NaN   \n",
+       "1  B0_2314       UTF-8          Apache/2.4.10           NaN            NaN   \n",
+       "2   B0_911    us-ascii  Microsoft-HTTPAPI/2.0           NaN            NaN   \n",
+       "3   B0_113  ISO-8859-1                  nginx            US             AK   \n",
+       "4   B0_403       UTF-8                    NaN            US             TX   \n",
+       "\n",
+       "      WHOIS_REGDATE WHOIS_UPDATED_DATE  \n",
+       "0  10/10/2015 18:21                NaN  \n",
+       "1               NaN                NaN  \n",
+       "2               NaN                NaN  \n",
+       "3    7/10/1997 4:00    12/09/2013 0:45  \n",
+       "4   12/05/1996 0:00    11/04/2017 0:00  "
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cat.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "48"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Your code here\n",
+    "cat.WHOIS_COUNTRY.nunique()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([nan, 'US', 'SC', 'GB', 'UK', 'RU', 'AU', 'CA', 'PA', 'se', 'IN',\n",
+       "       'LU', 'TH', \"[u'GB'; u'UK']\", 'FR', 'NL', 'UG', 'JP', 'CN', 'SE',\n",
+       "       'SI', 'IL', 'ru', 'KY', 'AT', 'CZ', 'PH', 'BE', 'NO', 'TR', 'LV',\n",
+       "       'DE', 'ES', 'BR', 'us', 'KR', 'HK', 'UA', 'CH', 'United Kingdom',\n",
+       "       'BS', 'PK', 'IT', 'Cyprus', 'BY', 'AE', 'IE', 'UY', 'KG'],\n",
+       "      dtype=object)"
+      ]
+     },
+     "execution_count": 46,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cat.WHOIS_COUNTRY.unique()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "#tengo esto cambialo por esto, key= a lo que tengo y value es lo que quiero\n",
+    "country_mapping = {\n",
+    "    'nan': None,\n",
+    "    'US': 'US',\n",
+    "    'us': 'US',\n",
+    "    'GB': 'GB',\n",
+    "    'UK': 'GB',\n",
+    "    'United Kingdom': 'GB',\n",
+    "    \"[u'GB'; u'UK']\": 'GB',\n",
+    "    'RU': 'RU',\n",
+    "    'ru': 'RU',\n",
+    "    'AU': 'AU',\n",
+    "    'CA': 'CA',\n",
+    "    'PA': 'PA',\n",
+    "    'se': 'SE',\n",
+    "    'SE': 'SE',\n",
+    "    'IN': 'IN',\n",
+    "    'LU': 'LU',\n",
+    "    'TH': 'TH',\n",
+    "    'FR': 'FR',\n",
+    "    'NL': 'NL',\n",
+    "    'UG': 'UG',\n",
+    "    'JP': 'JP',\n",
+    "    'CN': 'CN',\n",
+    "    'SI': 'SI',\n",
+    "    'IL': 'IL',\n",
+    "    'KY': 'KY',\n",
+    "    'AT': 'AT',\n",
+    "    'CZ': 'CZ',\n",
+    "    'PH': 'PH',\n",
+    "    'BE': 'BE',\n",
+    "    'NO': 'NO',\n",
+    "    'TR': 'TR',\n",
+    "    'LV': 'LV',\n",
+    "    'DE': 'DE',\n",
+    "    'ES': 'ES',\n",
+    "    'BR': 'BR',\n",
+    "    'KR': 'KR',\n",
+    "    'HK': 'HK',\n",
+    "    'UA': 'UA',\n",
+    "    'CH': 'CH',\n",
+    "    'BS': 'BS',\n",
+    "    'PK': 'PK',\n",
+    "    'IT': 'IT',\n",
+    "    'CY': 'CY',\n",
+    "    'Cyprus': 'CY',\n",
+    "    'BY': 'BY',\n",
+    "    'AE': 'AE',\n",
+    "    'IE': 'IE',\n",
+    "    'UY': 'UY',\n",
+    "    'KG': 'KG'\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "49"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(country_mapping)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cat['WHOIS_COUNTRY'].replace(country_mapping, inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "42"
+      ]
+     },
+     "execution_count": 50,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cat.WHOIS_COUNTRY.nunique()"
    ]
   },
   {
@@ -278,11 +1526,66 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 52,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "WHOIS_COUNTRY\n",
+       "US    1106\n",
+       "CA      84\n",
+       "ES      63\n",
+       "GB      35\n",
+       "AU      35\n",
+       "PA      21\n",
+       "JP      11\n",
+       "CN      10\n",
+       "IN      10\n",
+       "FR       9\n",
+       "CZ       9\n",
+       "CH       6\n",
+       "NL       6\n",
+       "RU       6\n",
+       "KR       5\n",
+       "AT       4\n",
+       "BS       4\n",
+       "PH       4\n",
+       "SE       4\n",
+       "KY       3\n",
+       "TR       3\n",
+       "DE       3\n",
+       "HK       3\n",
+       "SC       3\n",
+       "BE       3\n",
+       "NO       2\n",
+       "UA       2\n",
+       "UY       2\n",
+       "CY       2\n",
+       "SI       2\n",
+       "KG       2\n",
+       "IL       2\n",
+       "BR       2\n",
+       "TH       1\n",
+       "PK       1\n",
+       "IT       1\n",
+       "UG       1\n",
+       "BY       1\n",
+       "AE       1\n",
+       "IE       1\n",
+       "LV       1\n",
+       "LU       1\n",
+       "Name: count, dtype: int64"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# Your code here\n"
+    "# Your code here\n",
+    "cat.WHOIS_COUNTRY.value_counts()\n"
    ]
   },
   {
@@ -294,13 +1597,52 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 54,
    "metadata": {
     "scrolled": true
    },
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "# Your code here\n",
+    "# Step 1: Get the top 10 values \n",
+    "\n",
+    "top_10_values = cat[\"WHOIS_COUNTRY\"].value_counts().head(10).index \n",
+    "\n",
+    "#Step 2: Create a new column with values ‘OTHER’ for values not in top 10 \n",
+    "\n",
+    "cat[\"WHOIS_COUNTRY\"] = cat[\"WHOIS_COUNTRY\"].apply(lambda x: x if x in top_10_values else \"OTHER\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "WHOIS_COUNTRY\n",
+       "US       1106\n",
+       "OTHER     397\n",
+       "CA         84\n",
+       "ES         63\n",
+       "GB         35\n",
+       "AU         35\n",
+       "PA         21\n",
+       "JP         11\n",
+       "IN         10\n",
+       "CN         10\n",
+       "FR          9\n",
+       "Name: count, dtype: int64"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cat.WHOIS_COUNTRY.value_counts()"
    ]
   },
   {
@@ -316,11 +1658,102 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 57,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "# Your code here\n",
+    "cat = cat.drop(columns = [\"WHOIS_STATEPRO\",\"WHOIS_REGDATE\",\"WHOIS_UPDATED_DATE\"])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "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>URL</th>\n",
+       "      <th>CHARSET</th>\n",
+       "      <th>SERVER</th>\n",
+       "      <th>WHOIS_COUNTRY</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>M0_109</td>\n",
+       "      <td>iso-8859-1</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>OTHER</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>B0_2314</td>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>Apache/2.4.10</td>\n",
+       "      <td>OTHER</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>B0_911</td>\n",
+       "      <td>us-ascii</td>\n",
+       "      <td>Microsoft-HTTPAPI/2.0</td>\n",
+       "      <td>OTHER</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>B0_113</td>\n",
+       "      <td>ISO-8859-1</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>US</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>B0_403</td>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>US</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       URL     CHARSET                 SERVER WHOIS_COUNTRY\n",
+       "0   M0_109  iso-8859-1                  nginx         OTHER\n",
+       "1  B0_2314       UTF-8          Apache/2.4.10         OTHER\n",
+       "2   B0_911    us-ascii  Microsoft-HTTPAPI/2.0         OTHER\n",
+       "3   B0_113  ISO-8859-1                  nginx            US\n",
+       "4   B0_403       UTF-8                    NaN            US"
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cat.head()"
    ]
   },
   {
@@ -334,11 +1767,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 60,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "URL              object\n",
+       "CHARSET          object\n",
+       "SERVER           object\n",
+       "WHOIS_COUNTRY    object\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 60,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# Your code here\n"
+    "# Your code here\n",
+    "cat.dtypes"
    ]
   },
   {
@@ -350,11 +1799,96 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 62,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "# Your code here\n",
+    "cat = cat.drop(columns = [\"URL\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "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>CHARSET</th>\n",
+       "      <th>SERVER</th>\n",
+       "      <th>WHOIS_COUNTRY</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>iso-8859-1</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>OTHER</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>Apache/2.4.10</td>\n",
+       "      <td>OTHER</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>us-ascii</td>\n",
+       "      <td>Microsoft-HTTPAPI/2.0</td>\n",
+       "      <td>OTHER</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>ISO-8859-1</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>US</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>US</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      CHARSET                 SERVER WHOIS_COUNTRY\n",
+       "0  iso-8859-1                  nginx         OTHER\n",
+       "1       UTF-8          Apache/2.4.10         OTHER\n",
+       "2    us-ascii  Microsoft-HTTPAPI/2.0         OTHER\n",
+       "3  ISO-8859-1                  nginx            US\n",
+       "4       UTF-8                    NaN            US"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cat.head()"
    ]
   },
   {
@@ -366,11 +1900,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 65,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array(['iso-8859-1', 'UTF-8', 'us-ascii', 'ISO-8859-1', 'utf-8', nan,\n",
+       "       'windows-1251', 'ISO-8859', 'windows-1252'], dtype=object)"
+      ]
+     },
+     "execution_count": 65,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# Your code here"
+    "# Your code here\n",
+    "cat.CHARSET.unique()"
    ]
   },
   {
@@ -384,11 +1931,152 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 67,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array(['nginx', 'Apache/2.4.10', 'Microsoft-HTTPAPI/2.0', nan, 'Apache/2',\n",
+       "       'nginx/1.10.1', 'Apache', 'Apache/2.2.15 (Red Hat)',\n",
+       "       'Apache/2.4.23 (Unix) OpenSSL/1.0.1e-fips mod_bwlimited/1.4',\n",
+       "       'openresty/1.11.2.1', 'Apache/2.2.22', 'Apache/2.4.7 (Ubuntu)',\n",
+       "       'nginx/1.12.0',\n",
+       "       'Apache/2.4.12 (Unix) OpenSSL/1.0.1e-fips mod_bwlimited/1.4',\n",
+       "       'Oracle-iPlanet-Web-Server/7.0', 'cloudflare-nginx', 'nginx/1.6.2',\n",
+       "       'openresty', 'Heptu web server', 'Pepyaka/1.11.3', 'nginx/1.8.0',\n",
+       "       'nginx/1.10.1 + Phusion Passenger 5.0.30',\n",
+       "       'Apache/2.2.29 (Amazon)', 'Microsoft-IIS/7.5', 'LiteSpeed',\n",
+       "       'Apache/2.4.25 (cPanel) OpenSSL/1.0.1e-fips mod_bwlimited/1.4',\n",
+       "       'tsa_c', 'Apache/2.2.0 (Fedora)', 'Apache/2.2.22 (Debian)',\n",
+       "       'Apache/2.2.15 (CentOS)', 'Apache/2.4.25',\n",
+       "       'Apache/2.4.25 (Amazon) PHP/7.0.14', 'GSE',\n",
+       "       'Apache/2.4.23 (Unix) OpenSSL/0.9.8e-fips-rhel5 mod_bwlimited/1.4',\n",
+       "       'Apache/2.4.25 (Amazon) OpenSSL/1.0.1k-fips',\n",
+       "       'Apache/2.2.22 (Ubuntu)', 'Tengine',\n",
+       "       'Apache/2.4.18 (Unix) OpenSSL/0.9.8e-fips-rhel5 mod_bwlimited/1.4',\n",
+       "       'Apache/2.4.10 (Debian)', 'Apache/2.4.6 (CentOS) PHP/5.6.8',\n",
+       "       'Sun-ONE-Web-Server/6.1',\n",
+       "       'Apache/2.4.18 (Unix) OpenSSL/1.0.2e Communique/4.1.10',\n",
+       "       'AmazonS3',\n",
+       "       'Apache/1.3.37 (Unix) mod_perl/1.29 mod_ssl/2.8.28 OpenSSL/0.9.7e-p1',\n",
+       "       'ATS', 'Apache/2.2.27 (CentOS)',\n",
+       "       'Apache/2.2.29 (Unix) mod_ssl/2.2.29 OpenSSL/1.0.1e-fips DAV/2 mod_bwlimited/1.4',\n",
+       "       'CherryPy/3.6.0', 'Server', 'KHL',\n",
+       "       'Apache/2.4.6 (CentOS) OpenSSL/1.0.1e-fips mod_fcgid/2.3.9 PHP/5.4.16 mod_jk/1.2.40',\n",
+       "       'Apache/2.2.3 (CentOS)', 'Apache/2.4',\n",
+       "       'Apache/1.3.27 (Unix)  (Red-Hat/Linux) mod_perl/1.26 PHP/4.3.3 FrontPage/5.0.2 mod_ssl/2.8.12 OpenSSL/0.9.6b',\n",
+       "       'mw2114.codfw.wmnet',\n",
+       "       'Apache/2.2.31 (Unix) mod_ssl/2.2.31 OpenSSL/1.0.1e-fips mod_bwlimited/1.4 mod_perl/2.0.8 Perl/v5.10.1',\n",
+       "       'Apache/1.3.34 (Unix) PHP/4.4.4', 'Apache/2.2.31 (Amazon)',\n",
+       "       'Jetty(9.0.z-SNAPSHOT)', 'Apache/2.2.31 (CentOS)',\n",
+       "       'Apache/2.4.12 (Ubuntu)', 'HTTPDaemon',\n",
+       "       'Apache/2.2.29 (Unix) mod_ssl/2.2.29 OpenSSL/1.0.1e-fips mod_bwlimited/1.4',\n",
+       "       'MediaFire', 'DOSarrest', 'mw2232.codfw.wmnet',\n",
+       "       'Sucuri/Cloudproxy', 'Apache/2.4.23 (Unix)', 'nginx/0.7.65',\n",
+       "       'mw2260.codfw.wmnet', 'Apache/2.2.32', 'mw2239.codfw.wmnet',\n",
+       "       'DPS/1.1.8', 'Apache/2.0.52 (Red Hat)',\n",
+       "       'Apache/2.2.25 (Unix) mod_ssl/2.2.25 OpenSSL/0.9.8e-fips-rhel5 mod_bwlimited/1.4',\n",
+       "       'Apache/1.3.31 (Unix) PHP/4.3.9 mod_perl/1.29 rus/PL30.20',\n",
+       "       'Apache/2.2.13 (Unix) mod_ssl/2.2.13 OpenSSL/0.9.8e-fips-rhel5 mod_auth_passthrough/2.1 mod_bwlimited/1.4 PHP/5.2.10',\n",
+       "       'nginx/1.1.19', 'ATS/5.3.0', 'Apache/2.2.3 (Red Hat)',\n",
+       "       'nginx/1.4.3',\n",
+       "       'Apache/2.2.29 (Unix) mod_ssl/2.2.29 OpenSSL/1.0.1e-fips mod_bwlimited/1.4 PHP/5.4.35',\n",
+       "       'Apache/2.2.14 (FreeBSD) mod_ssl/2.2.14 OpenSSL/0.9.8y DAV/2 PHP/5.2.12 with Suhosin-Patch',\n",
+       "       'Apache/2.2.14 (Unix) mod_ssl/2.2.14 OpenSSL/0.9.8e-fips-rhel5',\n",
+       "       'Apache/1.3.39 (Unix) PHP/5.2.5 mod_auth_passthrough/1.8 mod_bwlimited/1.4 mod_log_bytes/1.2 mod_gzip/1.3.26.1a FrontPage/5.0.2.2635 DAV/1.0.3 mod_ssl/2.8.30 OpenSSL/0.9.7a',\n",
+       "       'SSWS', 'Microsoft-IIS/8.0', 'Apache/2.4.18 (Ubuntu)',\n",
+       "       'Apache/2.4.6 (CentOS) OpenSSL/1.0.1e-fips PHP/5.4.16 mod_apreq2-20090110/2.8.0 mod_perl/2.0.10 Perl/v5.24.1',\n",
+       "       'Apache/2.2.20 (Unix)', 'YouTubeFrontEnd', 'nginx/1.11.3',\n",
+       "       'nginx/1.11.2', 'nginx/1.10.0 (Ubuntu)', 'nginx/1.8.1',\n",
+       "       'nginx/1.11.10', 'Squeegit/1.2.5 (3_sir)',\n",
+       "       'Virtuoso/07.20.3217 (Linux) i686-generic-linux-glibc212-64  VDB',\n",
+       "       'Apache-Coyote/1.1', 'Yippee-Ki-Yay', 'mw2165.codfw.wmnet',\n",
+       "       'mw2192.codfw.wmnet', 'Apache/2.2.23 (Amazon)',\n",
+       "       'nginx/1.4.6 (Ubuntu)', 'nginx + Phusion Passenger',\n",
+       "       'Proxy Pandeiro UOL', 'mw2231.codfw.wmnet', 'openresty/1.11.2.2',\n",
+       "       'mw2109.codfw.wmnet', 'nginx/0.8.54', 'Apache/2.4.6',\n",
+       "       'mw2225.codfw.wmnet', 'Apache/1.3.27 (Unix) PHP/4.4.1',\n",
+       "       'mw2236.codfw.wmnet', 'mw2101.codfw.wmnet', 'Varnish',\n",
+       "       'Resin/3.1.8', 'mw2164.codfw.wmnet', 'Microsoft-IIS/8.5',\n",
+       "       'mw2242.codfw.wmnet',\n",
+       "       'Apache/2.4.6 (CentOS) OpenSSL/1.0.1e-fips PHP/5.5.38',\n",
+       "       'mw2175.codfw.wmnet', 'mw2107.codfw.wmnet', 'mw2190.codfw.wmnet',\n",
+       "       'Apache/2.4.6 (CentOS)', 'nginx/1.13.0', 'barista/5.1.3',\n",
+       "       'mw2103.codfw.wmnet', 'Apache/2.4.25 (Debian)', 'ECD (fll/0790)',\n",
+       "       'Pagely Gateway/1.5.1', 'nginx/1.10.3',\n",
+       "       'Apache/2.4.25 (FreeBSD) OpenSSL/1.0.1s-freebsd PHP/5.6.30',\n",
+       "       'mw2097.codfw.wmnet', 'mw2233.codfw.wmnet', 'fbs',\n",
+       "       'mw2199.codfw.wmnet', 'mw2255.codfw.wmnet', 'mw2228.codfw.wmnet',\n",
+       "       'Apache/2.2.31 (Unix) mod_ssl/2.2.31 OpenSSL/1.0.1e-fips mod_bwlimited/1.4 mod_fcgid/2.3.9',\n",
+       "       'gunicorn/19.7.1',\n",
+       "       'Apache/2.2.31 (Unix) mod_ssl/2.2.31 OpenSSL/0.9.8e-fips-rhel5 mod_bwlimited/1.4',\n",
+       "       'Apache/2.4.6 (CentOS) OpenSSL/1.0.1e-fips PHP/5.4.16',\n",
+       "       'mw2241.codfw.wmnet',\n",
+       "       'Apache/1.3.33 (Unix) mod_ssl/2.8.24 OpenSSL/0.9.7e-p1 PHP/4.4.8',\n",
+       "       'lighttpd', 'mw2230.codfw.wmnet',\n",
+       "       'Apache/2.4.6 (CentOS) OpenSSL/1.0.1e-fips', 'AkamaiGHost',\n",
+       "       'mw2240.codfw.wmnet', 'nginx/1.10.2', 'PWS/8.2.0.7', 'nginx/1.2.1',\n",
+       "       'nxfps',\n",
+       "       'Apache/2.2.16 (Unix) mod_ssl/2.2.16 OpenSSL/0.9.8e-fips-rhel5 mod_auth_passthrough/2.1 mod_bwlimited/1.4',\n",
+       "       'Play', 'mw2185.codfw.wmnet',\n",
+       "       'Apache/2.4.10 (Unix) OpenSSL/1.0.1k',\n",
+       "       'Apache/Not telling (Unix) AuthTDS/1.1',\n",
+       "       'Apache/2.2.11 (Unix) PHP/5.2.6', 'Scratch Web Server',\n",
+       "       'marrakesh 1.12.2', 'nginx/0.8.35', 'mw2182.codfw.wmnet',\n",
+       "       'squid/3.3.8', 'nginx/1.10.0', 'Nginx (OpenBSD)',\n",
+       "       'Zope/(2.13.16; python 2.6.8; linux2) ZServer/1.1',\n",
+       "       'Apache/2.2.26 (Unix) mod_ssl/2.2.26 OpenSSL/0.9.8e-fips-rhel5 mod_bwlimited/1.4 PHP/5.4.26',\n",
+       "       'Apache/2.2.21 (Unix) mod_ssl/2.2.21 OpenSSL/0.9.8e-fips-rhel5 PHP/5.3.10',\n",
+       "       'Apache/2.2.27 (Unix) OpenAM Web Agent/4.0.1-1 mod_ssl/2.2.27 OpenSSL/1.0.1p PHP/5.3.28',\n",
+       "       'mw2104.codfw.wmnet', '.V01 Apache', 'mw2110.codfw.wmnet',\n",
+       "       'Apache/2.4.6 (Unix) mod_jk/1.2.37 PHP/5.5.1 OpenSSL/1.0.1g mod_fcgid/2.3.9',\n",
+       "       'mw2176.codfw.wmnet', 'mw2187.codfw.wmnet', 'mw2106.codfw.wmnet',\n",
+       "       'Microsoft-IIS/7.0',\n",
+       "       'Apache/1.3.42 Ben-SSL/1.60 (Unix) mod_gzip/1.3.26.1a mod_fastcgi/2.4.6 mod_throttle/3.1.2 Chili!Soft-ASP/3.6.2 FrontPage/5.0.2.2635 mod_perl/1.31 PHP/4.4.9',\n",
+       "       'Aeria Games & Entertainment', 'nginx/1.6.3 + Phusion Passenger',\n",
+       "       'Apache/2.4.10 (Debian) PHP/5.6.30-0+deb8u1 mod_perl/2.0.9dev Perl/v5.20.2',\n",
+       "       'mw2173.codfw.wmnet',\n",
+       "       'Apache/2.4.6 (Red Hat Enterprise Linux) OpenSSL/1.0.1e-fips mod_fcgid/2.3.9 Communique/4.2.0',\n",
+       "       'Apache/2.2.15 (CentOS) DAV/2 mod_ssl/2.2.15 OpenSSL/1.0.1e-fips PHP/5.3.3',\n",
+       "       'Apache/2.4.6 (CentOS) OpenSSL/1.0.1e-fips PHP/7.0.14',\n",
+       "       'mw2198.codfw.wmnet', 'mw2172.codfw.wmnet', 'nginx/1.2.6',\n",
+       "       'Apache/2.4.6 (Unix) mod_jk/1.2.37',\n",
+       "       'Apache/2.4.25 (Unix) OpenSSL/1.0.1e-fips mod_bwlimited/1.4',\n",
+       "       'nginx/1.4.4', 'Cowboy', 'mw2113.codfw.wmnet',\n",
+       "       'Apache/2.2.14 (Unix) mod_ssl/2.2.14 OpenSSL/0.9.8a',\n",
+       "       'Apache/2.4.10 (Ubuntu)', 'mw2224.codfw.wmnet',\n",
+       "       'mw2171.codfw.wmnet', 'mw2257.codfw.wmnet', 'mw2226.codfw.wmnet',\n",
+       "       'DMS/1.0.42', 'nginx/1.6.3', 'Application-Server',\n",
+       "       'Apache/2.4.6 (CentOS) mod_fcgid/2.3.9 PHP/5.6.30',\n",
+       "       'mw2177.codfw.wmnet', 'lighttpd/1.4.28', 'mw2197.codfw.wmnet',\n",
+       "       'Apache/2.2.31 (FreeBSD) PHP/5.4.15 mod_ssl/2.2.31 OpenSSL/1.0.2d DAV/2',\n",
+       "       'Apache/2.2.26 (Unix) mod_ssl/2.2.26 OpenSSL/1.0.1e-fips DAV/2 mod_bwlimited/1.4',\n",
+       "       'Apache/2.2.24 (Unix) DAV/2 PHP/5.3.26 mod_ssl/2.2.24 OpenSSL/0.9.8y',\n",
+       "       'mw2178.codfw.wmnet', '294', 'Microsoft-IIS/6.0', 'nginx/1.7.4',\n",
+       "       'Apache/2.2.22 (Debian) mod_python/3.3.1 Python/2.7.3 mod_ssl/2.2.22 OpenSSL/1.0.1t',\n",
+       "       'Apache/2.4.16 (Ubuntu)', 'www.lexisnexis.com  9999',\n",
+       "       'nginx/0.8.38', 'mw2238.codfw.wmnet', 'Pizza/pepperoni',\n",
+       "       'XXXXXXXXXXXXXXXXXXXXXX', 'MI', 'Roxen/5.4.98-r2',\n",
+       "       'Apache/2.2.31 (Unix) mod_ssl/2.2.31 OpenSSL/1.0.1e-fips mod_bwlimited/1.4',\n",
+       "       'nginx/1.9.13', 'mw2180.codfw.wmnet', 'Apache/2.2.14 (Ubuntu)',\n",
+       "       'ebay server', 'nginx/0.8.55', 'Apache/2.2.10 (Linux/SUSE)',\n",
+       "       'nginx/1.7.12',\n",
+       "       'Apache/2.0.63 (Unix) mod_ssl/2.0.63 OpenSSL/0.9.8e-fips-rhel5 mod_auth_passthrough/2.1 mod_bwlimited/1.4 PHP/5.3.6',\n",
+       "       'Boston.com Frontend', 'My Arse', 'IdeaWebServer/v0.80',\n",
+       "       'Apache/2.4.17 (Unix) OpenSSL/1.0.1e-fips PHP/5.6.19',\n",
+       "       'Microsoft-IIS/7.5; litigation_essentials.lexisnexis.com  9999',\n",
+       "       'Apache/2.2.16 (Debian)'], dtype=object)"
+      ]
+     },
+     "execution_count": 67,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# Your code here\n"
+    "# Your code here\n",
+    "cat.SERVER.unique()"
    ]
   },
   {
@@ -400,11 +2088,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 69,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your comment here\n"
+    "# Your comment here\n",
+    "#I think that i would use a regex to indicate that i want everything before the /."
    ]
   },
   {
@@ -418,22 +2107,87 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 71,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "# Your code here\n",
+    "import re\n",
+    "regex = r\"^[^/]+\"\n",
+    "cat['SERVER'] = cat['SERVER'].apply(lambda x: re.match(regex, str(x)).group(0) if isinstance(x, str) and re.match(regex, str(x)) else x)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 72,
    "metadata": {
-    "scrolled": false
+    "scrolled": true
    },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "SERVER\n",
+       "Apache                622\n",
+       "nginx                 337\n",
+       "Microsoft-HTTPAPI     113\n",
+       "cloudflare-nginx       94\n",
+       "Microsoft-IIS          85\n",
+       "                     ... \n",
+       "mw2103.codfw.wmnet      1\n",
+       "barista                 1\n",
+       "mw2190.codfw.wmnet      1\n",
+       "mw2107.codfw.wmnet      1\n",
+       "IdeaWebServer           1\n",
+       "Name: count, Length: 110, dtype: int64"
+      ]
+     },
+     "execution_count": 72,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Count `SERVER` value counts here\n",
+    "cat.SERVER.value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "# Count `SERVER` value counts here\n"
+    "top_3_server = cat[\"SERVER\"].value_counts().head(3).index \n",
+    "\n",
+    "#Step 2: Create a new column with values ‘OTHER’ for values not in top 10 \n",
+    "\n",
+    "cat[\"SERVER\"] = cat[\"SERVER\"].apply(lambda x: x if x in top_3_server else \"OTHER\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "SERVER\n",
+       "OTHER                709\n",
+       "Apache               622\n",
+       "nginx                337\n",
+       "Microsoft-HTTPAPI    113\n",
+       "Name: count, dtype: int64"
+      ]
+     },
+     "execution_count": 74,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cat.SERVER.value_counts()"
    ]
   },
   {
@@ -445,11 +2199,341 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [
+    {
+     "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>CHARSET</th>\n",
+       "      <th>SERVER</th>\n",
+       "      <th>WHOIS_COUNTRY</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>iso-8859-1</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>OTHER</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>Apache</td>\n",
+       "      <td>OTHER</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>us-ascii</td>\n",
+       "      <td>Microsoft-HTTPAPI</td>\n",
+       "      <td>OTHER</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>ISO-8859-1</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>US</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>OTHER</td>\n",
+       "      <td>US</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      CHARSET             SERVER WHOIS_COUNTRY\n",
+       "0  iso-8859-1              nginx         OTHER\n",
+       "1       UTF-8             Apache         OTHER\n",
+       "2    us-ascii  Microsoft-HTTPAPI         OTHER\n",
+       "3  ISO-8859-1              nginx            US\n",
+       "4       UTF-8              OTHER            US"
+      ]
+     },
+     "execution_count": 76,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cat.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "website_dummy =pd.get_dummies(cat, prefix=['CHARSET', 'SERVER','WHOIS_COUNTRY'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "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>CHARSET_ISO-8859</th>\n",
+       "      <th>CHARSET_ISO-8859-1</th>\n",
+       "      <th>CHARSET_UTF-8</th>\n",
+       "      <th>CHARSET_iso-8859-1</th>\n",
+       "      <th>CHARSET_us-ascii</th>\n",
+       "      <th>CHARSET_utf-8</th>\n",
+       "      <th>CHARSET_windows-1251</th>\n",
+       "      <th>CHARSET_windows-1252</th>\n",
+       "      <th>SERVER_Apache</th>\n",
+       "      <th>SERVER_Microsoft-HTTPAPI</th>\n",
+       "      <th>SERVER_OTHER</th>\n",
+       "      <th>SERVER_nginx</th>\n",
+       "      <th>WHOIS_COUNTRY_AU</th>\n",
+       "      <th>WHOIS_COUNTRY_CA</th>\n",
+       "      <th>WHOIS_COUNTRY_CN</th>\n",
+       "      <th>WHOIS_COUNTRY_ES</th>\n",
+       "      <th>WHOIS_COUNTRY_FR</th>\n",
+       "      <th>WHOIS_COUNTRY_GB</th>\n",
+       "      <th>WHOIS_COUNTRY_IN</th>\n",
+       "      <th>WHOIS_COUNTRY_JP</th>\n",
+       "      <th>WHOIS_COUNTRY_OTHER</th>\n",
+       "      <th>WHOIS_COUNTRY_PA</th>\n",
+       "      <th>WHOIS_COUNTRY_US</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   CHARSET_ISO-8859  CHARSET_ISO-8859-1  CHARSET_UTF-8  CHARSET_iso-8859-1  \\\n",
+       "0             False               False          False                True   \n",
+       "1             False               False           True               False   \n",
+       "2             False               False          False               False   \n",
+       "3             False                True          False               False   \n",
+       "4             False               False           True               False   \n",
+       "\n",
+       "   CHARSET_us-ascii  CHARSET_utf-8  CHARSET_windows-1251  \\\n",
+       "0             False          False                 False   \n",
+       "1             False          False                 False   \n",
+       "2              True          False                 False   \n",
+       "3             False          False                 False   \n",
+       "4             False          False                 False   \n",
+       "\n",
+       "   CHARSET_windows-1252  SERVER_Apache  SERVER_Microsoft-HTTPAPI  \\\n",
+       "0                 False          False                     False   \n",
+       "1                 False           True                     False   \n",
+       "2                 False          False                      True   \n",
+       "3                 False          False                     False   \n",
+       "4                 False          False                     False   \n",
+       "\n",
+       "   SERVER_OTHER  SERVER_nginx  WHOIS_COUNTRY_AU  WHOIS_COUNTRY_CA  \\\n",
+       "0         False          True             False             False   \n",
+       "1         False         False             False             False   \n",
+       "2         False         False             False             False   \n",
+       "3         False          True             False             False   \n",
+       "4          True         False             False             False   \n",
+       "\n",
+       "   WHOIS_COUNTRY_CN  WHOIS_COUNTRY_ES  WHOIS_COUNTRY_FR  WHOIS_COUNTRY_GB  \\\n",
+       "0             False             False             False             False   \n",
+       "1             False             False             False             False   \n",
+       "2             False             False             False             False   \n",
+       "3             False             False             False             False   \n",
+       "4             False             False             False             False   \n",
+       "\n",
+       "   WHOIS_COUNTRY_IN  WHOIS_COUNTRY_JP  WHOIS_COUNTRY_OTHER  WHOIS_COUNTRY_PA  \\\n",
+       "0             False             False                 True             False   \n",
+       "1             False             False                 True             False   \n",
+       "2             False             False                 True             False   \n",
+       "3             False             False                False             False   \n",
+       "4             False             False                False             False   \n",
+       "\n",
+       "   WHOIS_COUNTRY_US  \n",
+       "0             False  \n",
+       "1             False  \n",
+       "2             False  \n",
+       "3              True  \n",
+       "4              True  "
+      ]
+     },
+     "execution_count": 78,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "website_dummy.head()"
    ]
   },
   {
@@ -461,11 +2545,1248 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "CHARSET_ISO-8859            bool\n",
+       "CHARSET_ISO-8859-1          bool\n",
+       "CHARSET_UTF-8               bool\n",
+       "CHARSET_iso-8859-1          bool\n",
+       "CHARSET_us-ascii            bool\n",
+       "CHARSET_utf-8               bool\n",
+       "CHARSET_windows-1251        bool\n",
+       "CHARSET_windows-1252        bool\n",
+       "SERVER_Apache               bool\n",
+       "SERVER_Microsoft-HTTPAPI    bool\n",
+       "SERVER_OTHER                bool\n",
+       "SERVER_nginx                bool\n",
+       "WHOIS_COUNTRY_AU            bool\n",
+       "WHOIS_COUNTRY_CA            bool\n",
+       "WHOIS_COUNTRY_CN            bool\n",
+       "WHOIS_COUNTRY_ES            bool\n",
+       "WHOIS_COUNTRY_FR            bool\n",
+       "WHOIS_COUNTRY_GB            bool\n",
+       "WHOIS_COUNTRY_IN            bool\n",
+       "WHOIS_COUNTRY_JP            bool\n",
+       "WHOIS_COUNTRY_OTHER         bool\n",
+       "WHOIS_COUNTRY_PA            bool\n",
+       "WHOIS_COUNTRY_US            bool\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 80,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Your code here\n",
+    "website_dummy.dtypes\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 81,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1781"
+      ]
+     },
+     "execution_count": 81,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(num.Type)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1781"
+      ]
+     },
+     "execution_count": 82,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(cat)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "website_dummy[\"Type\"] = num.Type"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 84,
+   "metadata": {},
+   "outputs": [
+    {
+     "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>CHARSET_ISO-8859</th>\n",
+       "      <th>CHARSET_ISO-8859-1</th>\n",
+       "      <th>CHARSET_UTF-8</th>\n",
+       "      <th>CHARSET_iso-8859-1</th>\n",
+       "      <th>CHARSET_us-ascii</th>\n",
+       "      <th>CHARSET_utf-8</th>\n",
+       "      <th>CHARSET_windows-1251</th>\n",
+       "      <th>CHARSET_windows-1252</th>\n",
+       "      <th>SERVER_Apache</th>\n",
+       "      <th>SERVER_Microsoft-HTTPAPI</th>\n",
+       "      <th>SERVER_OTHER</th>\n",
+       "      <th>SERVER_nginx</th>\n",
+       "      <th>WHOIS_COUNTRY_AU</th>\n",
+       "      <th>WHOIS_COUNTRY_CA</th>\n",
+       "      <th>WHOIS_COUNTRY_CN</th>\n",
+       "      <th>WHOIS_COUNTRY_ES</th>\n",
+       "      <th>WHOIS_COUNTRY_FR</th>\n",
+       "      <th>WHOIS_COUNTRY_GB</th>\n",
+       "      <th>WHOIS_COUNTRY_IN</th>\n",
+       "      <th>WHOIS_COUNTRY_JP</th>\n",
+       "      <th>WHOIS_COUNTRY_OTHER</th>\n",
+       "      <th>WHOIS_COUNTRY_PA</th>\n",
+       "      <th>WHOIS_COUNTRY_US</th>\n",
+       "      <th>Type</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   CHARSET_ISO-8859  CHARSET_ISO-8859-1  CHARSET_UTF-8  CHARSET_iso-8859-1  \\\n",
+       "0             False               False          False                True   \n",
+       "1             False               False           True               False   \n",
+       "2             False               False          False               False   \n",
+       "3             False                True          False               False   \n",
+       "4             False               False           True               False   \n",
+       "\n",
+       "   CHARSET_us-ascii  CHARSET_utf-8  CHARSET_windows-1251  \\\n",
+       "0             False          False                 False   \n",
+       "1             False          False                 False   \n",
+       "2              True          False                 False   \n",
+       "3             False          False                 False   \n",
+       "4             False          False                 False   \n",
+       "\n",
+       "   CHARSET_windows-1252  SERVER_Apache  SERVER_Microsoft-HTTPAPI  \\\n",
+       "0                 False          False                     False   \n",
+       "1                 False           True                     False   \n",
+       "2                 False          False                      True   \n",
+       "3                 False          False                     False   \n",
+       "4                 False          False                     False   \n",
+       "\n",
+       "   SERVER_OTHER  SERVER_nginx  WHOIS_COUNTRY_AU  WHOIS_COUNTRY_CA  \\\n",
+       "0         False          True             False             False   \n",
+       "1         False         False             False             False   \n",
+       "2         False         False             False             False   \n",
+       "3         False          True             False             False   \n",
+       "4          True         False             False             False   \n",
+       "\n",
+       "   WHOIS_COUNTRY_CN  WHOIS_COUNTRY_ES  WHOIS_COUNTRY_FR  WHOIS_COUNTRY_GB  \\\n",
+       "0             False             False             False             False   \n",
+       "1             False             False             False             False   \n",
+       "2             False             False             False             False   \n",
+       "3             False             False             False             False   \n",
+       "4             False             False             False             False   \n",
+       "\n",
+       "   WHOIS_COUNTRY_IN  WHOIS_COUNTRY_JP  WHOIS_COUNTRY_OTHER  WHOIS_COUNTRY_PA  \\\n",
+       "0             False             False                 True             False   \n",
+       "1             False             False                 True             False   \n",
+       "2             False             False                 True             False   \n",
+       "3             False             False                False             False   \n",
+       "4             False             False                False             False   \n",
+       "\n",
+       "   WHOIS_COUNTRY_US  Type  \n",
+       "0             False     1  \n",
+       "1             False     0  \n",
+       "2             False     0  \n",
+       "3              True     0  \n",
+       "4              True     0  "
+      ]
+     },
+     "execution_count": 84,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "website_dummy.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 85,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Index(['CHARSET_ISO-8859', 'CHARSET_ISO-8859-1', 'CHARSET_UTF-8',\n",
+       "       'CHARSET_iso-8859-1', 'CHARSET_us-ascii', 'CHARSET_utf-8',\n",
+       "       'CHARSET_windows-1251', 'CHARSET_windows-1252', 'SERVER_Apache',\n",
+       "       'SERVER_Microsoft-HTTPAPI', 'SERVER_OTHER', 'SERVER_nginx',\n",
+       "       'WHOIS_COUNTRY_AU', 'WHOIS_COUNTRY_CA', 'WHOIS_COUNTRY_CN',\n",
+       "       'WHOIS_COUNTRY_ES', 'WHOIS_COUNTRY_FR', 'WHOIS_COUNTRY_GB',\n",
+       "       'WHOIS_COUNTRY_IN', 'WHOIS_COUNTRY_JP', 'WHOIS_COUNTRY_OTHER',\n",
+       "       'WHOIS_COUNTRY_PA', 'WHOIS_COUNTRY_US', 'Type'],\n",
+       "      dtype='object')"
+      ]
+     },
+     "execution_count": 85,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "website_dummy.columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 86,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "website_dummy = website_dummy.astype(int)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 87,
+   "metadata": {},
+   "outputs": [
+    {
+     "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>CHARSET_ISO-8859</th>\n",
+       "      <th>CHARSET_ISO-8859-1</th>\n",
+       "      <th>CHARSET_UTF-8</th>\n",
+       "      <th>CHARSET_iso-8859-1</th>\n",
+       "      <th>CHARSET_us-ascii</th>\n",
+       "      <th>CHARSET_utf-8</th>\n",
+       "      <th>CHARSET_windows-1251</th>\n",
+       "      <th>CHARSET_windows-1252</th>\n",
+       "      <th>SERVER_Apache</th>\n",
+       "      <th>SERVER_Microsoft-HTTPAPI</th>\n",
+       "      <th>SERVER_OTHER</th>\n",
+       "      <th>SERVER_nginx</th>\n",
+       "      <th>WHOIS_COUNTRY_AU</th>\n",
+       "      <th>WHOIS_COUNTRY_CA</th>\n",
+       "      <th>WHOIS_COUNTRY_CN</th>\n",
+       "      <th>WHOIS_COUNTRY_ES</th>\n",
+       "      <th>WHOIS_COUNTRY_FR</th>\n",
+       "      <th>WHOIS_COUNTRY_GB</th>\n",
+       "      <th>WHOIS_COUNTRY_IN</th>\n",
+       "      <th>WHOIS_COUNTRY_JP</th>\n",
+       "      <th>WHOIS_COUNTRY_OTHER</th>\n",
+       "      <th>WHOIS_COUNTRY_PA</th>\n",
+       "      <th>WHOIS_COUNTRY_US</th>\n",
+       "      <th>Type</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   CHARSET_ISO-8859  CHARSET_ISO-8859-1  CHARSET_UTF-8  CHARSET_iso-8859-1  \\\n",
+       "0                 0                   0              0                   1   \n",
+       "1                 0                   0              1                   0   \n",
+       "2                 0                   0              0                   0   \n",
+       "3                 0                   1              0                   0   \n",
+       "4                 0                   0              1                   0   \n",
+       "\n",
+       "   CHARSET_us-ascii  CHARSET_utf-8  CHARSET_windows-1251  \\\n",
+       "0                 0              0                     0   \n",
+       "1                 0              0                     0   \n",
+       "2                 1              0                     0   \n",
+       "3                 0              0                     0   \n",
+       "4                 0              0                     0   \n",
+       "\n",
+       "   CHARSET_windows-1252  SERVER_Apache  SERVER_Microsoft-HTTPAPI  \\\n",
+       "0                     0              0                         0   \n",
+       "1                     0              1                         0   \n",
+       "2                     0              0                         1   \n",
+       "3                     0              0                         0   \n",
+       "4                     0              0                         0   \n",
+       "\n",
+       "   SERVER_OTHER  SERVER_nginx  WHOIS_COUNTRY_AU  WHOIS_COUNTRY_CA  \\\n",
+       "0             0             1                 0                 0   \n",
+       "1             0             0                 0                 0   \n",
+       "2             0             0                 0                 0   \n",
+       "3             0             1                 0                 0   \n",
+       "4             1             0                 0                 0   \n",
+       "\n",
+       "   WHOIS_COUNTRY_CN  WHOIS_COUNTRY_ES  WHOIS_COUNTRY_FR  WHOIS_COUNTRY_GB  \\\n",
+       "0                 0                 0                 0                 0   \n",
+       "1                 0                 0                 0                 0   \n",
+       "2                 0                 0                 0                 0   \n",
+       "3                 0                 0                 0                 0   \n",
+       "4                 0                 0                 0                 0   \n",
+       "\n",
+       "   WHOIS_COUNTRY_IN  WHOIS_COUNTRY_JP  WHOIS_COUNTRY_OTHER  WHOIS_COUNTRY_PA  \\\n",
+       "0                 0                 0                    1                 0   \n",
+       "1                 0                 0                    1                 0   \n",
+       "2                 0                 0                    1                 0   \n",
+       "3                 0                 0                    0                 0   \n",
+       "4                 0                 0                    0                 0   \n",
+       "\n",
+       "   WHOIS_COUNTRY_US  Type  \n",
+       "0                 0     1  \n",
+       "1                 0     0  \n",
+       "2                 0     0  \n",
+       "3                 1     0  \n",
+       "4                 1     0  "
+      ]
+     },
+     "execution_count": 87,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "website_dummy.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 88,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_clean.drop(columns = \"Type\", inplace =True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "metadata": {},
+   "outputs": [
+    {
+     "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>URL_LENGTH</th>\n",
+       "      <th>NUMBER_SPECIAL_CHARACTERS</th>\n",
+       "      <th>DIST_REMOTE_TCP_PORT</th>\n",
+       "      <th>REMOTE_IPS</th>\n",
+       "      <th>SOURCE_APP_BYTES</th>\n",
+       "      <th>REMOTE_APP_BYTES</th>\n",
+       "      <th>APP_PACKETS</th>\n",
+       "      <th>DNS_QUERY_TIMES</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>16</td>\n",
+       "      <td>7</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1153</td>\n",
+       "      <td>832</td>\n",
+       "      <td>9</td>\n",
+       "      <td>2.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>16</td>\n",
+       "      <td>6</td>\n",
+       "      <td>7</td>\n",
+       "      <td>4</td>\n",
+       "      <td>1265</td>\n",
+       "      <td>1230</td>\n",
+       "      <td>17</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>16</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>17</td>\n",
+       "      <td>6</td>\n",
+       "      <td>22</td>\n",
+       "      <td>3</td>\n",
+       "      <td>18784</td>\n",
+       "      <td>4380</td>\n",
+       "      <td>39</td>\n",
+       "      <td>8.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>17</td>\n",
+       "      <td>6</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
+       "      <td>129889</td>\n",
+       "      <td>4586</td>\n",
+       "      <td>61</td>\n",
+       "      <td>4.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   URL_LENGTH  NUMBER_SPECIAL_CHARACTERS  DIST_REMOTE_TCP_PORT  REMOTE_IPS  \\\n",
+       "0          16                          7                     0           2   \n",
+       "1          16                          6                     7           4   \n",
+       "2          16                          6                     0           0   \n",
+       "3          17                          6                    22           3   \n",
+       "4          17                          6                     2           5   \n",
+       "\n",
+       "   SOURCE_APP_BYTES  REMOTE_APP_BYTES  APP_PACKETS  DNS_QUERY_TIMES  \n",
+       "0              1153               832            9              2.0  \n",
+       "1              1265              1230           17              0.0  \n",
+       "2                 0                 0            0              0.0  \n",
+       "3             18784              4380           39              8.0  \n",
+       "4            129889              4586           61              4.0  "
+      ]
+     },
+     "execution_count": 89,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_clean.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 90,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_clean.reset_index(inplace=True)\n",
+    "website_dummy.reset_index(inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "metadata": {},
+   "outputs": [
+    {
+     "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>index</th>\n",
+       "      <th>URL_LENGTH</th>\n",
+       "      <th>NUMBER_SPECIAL_CHARACTERS</th>\n",
+       "      <th>DIST_REMOTE_TCP_PORT</th>\n",
+       "      <th>REMOTE_IPS</th>\n",
+       "      <th>SOURCE_APP_BYTES</th>\n",
+       "      <th>REMOTE_APP_BYTES</th>\n",
+       "      <th>APP_PACKETS</th>\n",
+       "      <th>DNS_QUERY_TIMES</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>16</td>\n",
+       "      <td>7</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1153</td>\n",
+       "      <td>832</td>\n",
+       "      <td>9</td>\n",
+       "      <td>2.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1</td>\n",
+       "      <td>16</td>\n",
+       "      <td>6</td>\n",
+       "      <td>7</td>\n",
+       "      <td>4</td>\n",
+       "      <td>1265</td>\n",
+       "      <td>1230</td>\n",
+       "      <td>17</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>16</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3</td>\n",
+       "      <td>17</td>\n",
+       "      <td>6</td>\n",
+       "      <td>22</td>\n",
+       "      <td>3</td>\n",
+       "      <td>18784</td>\n",
+       "      <td>4380</td>\n",
+       "      <td>39</td>\n",
+       "      <td>8.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>4</td>\n",
+       "      <td>17</td>\n",
+       "      <td>6</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
+       "      <td>129889</td>\n",
+       "      <td>4586</td>\n",
+       "      <td>61</td>\n",
+       "      <td>4.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   index  URL_LENGTH  NUMBER_SPECIAL_CHARACTERS  DIST_REMOTE_TCP_PORT  \\\n",
+       "0      0          16                          7                     0   \n",
+       "1      1          16                          6                     7   \n",
+       "2      2          16                          6                     0   \n",
+       "3      3          17                          6                    22   \n",
+       "4      4          17                          6                     2   \n",
+       "\n",
+       "   REMOTE_IPS  SOURCE_APP_BYTES  REMOTE_APP_BYTES  APP_PACKETS  \\\n",
+       "0           2              1153               832            9   \n",
+       "1           4              1265              1230           17   \n",
+       "2           0                 0                 0            0   \n",
+       "3           3             18784              4380           39   \n",
+       "4           5            129889              4586           61   \n",
+       "\n",
+       "   DNS_QUERY_TIMES  \n",
+       "0              2.0  \n",
+       "1              0.0  \n",
+       "2              0.0  \n",
+       "3              8.0  \n",
+       "4              4.0  "
+      ]
+     },
+     "execution_count": 91,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_clean.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 92,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_final = df_clean.merge(website_dummy, on = [\"index\"],how=\"inner\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 93,
+   "metadata": {},
+   "outputs": [
+    {
+     "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>index</th>\n",
+       "      <th>URL_LENGTH</th>\n",
+       "      <th>NUMBER_SPECIAL_CHARACTERS</th>\n",
+       "      <th>DIST_REMOTE_TCP_PORT</th>\n",
+       "      <th>REMOTE_IPS</th>\n",
+       "      <th>SOURCE_APP_BYTES</th>\n",
+       "      <th>REMOTE_APP_BYTES</th>\n",
+       "      <th>APP_PACKETS</th>\n",
+       "      <th>DNS_QUERY_TIMES</th>\n",
+       "      <th>CHARSET_ISO-8859</th>\n",
+       "      <th>CHARSET_ISO-8859-1</th>\n",
+       "      <th>CHARSET_UTF-8</th>\n",
+       "      <th>CHARSET_iso-8859-1</th>\n",
+       "      <th>CHARSET_us-ascii</th>\n",
+       "      <th>CHARSET_utf-8</th>\n",
+       "      <th>CHARSET_windows-1251</th>\n",
+       "      <th>CHARSET_windows-1252</th>\n",
+       "      <th>SERVER_Apache</th>\n",
+       "      <th>SERVER_Microsoft-HTTPAPI</th>\n",
+       "      <th>SERVER_OTHER</th>\n",
+       "      <th>SERVER_nginx</th>\n",
+       "      <th>WHOIS_COUNTRY_AU</th>\n",
+       "      <th>WHOIS_COUNTRY_CA</th>\n",
+       "      <th>WHOIS_COUNTRY_CN</th>\n",
+       "      <th>WHOIS_COUNTRY_ES</th>\n",
+       "      <th>WHOIS_COUNTRY_FR</th>\n",
+       "      <th>WHOIS_COUNTRY_GB</th>\n",
+       "      <th>WHOIS_COUNTRY_IN</th>\n",
+       "      <th>WHOIS_COUNTRY_JP</th>\n",
+       "      <th>WHOIS_COUNTRY_OTHER</th>\n",
+       "      <th>WHOIS_COUNTRY_PA</th>\n",
+       "      <th>WHOIS_COUNTRY_US</th>\n",
+       "      <th>Type</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>16</td>\n",
+       "      <td>7</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1153</td>\n",
+       "      <td>832</td>\n",
+       "      <td>9</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1</td>\n",
+       "      <td>16</td>\n",
+       "      <td>6</td>\n",
+       "      <td>7</td>\n",
+       "      <td>4</td>\n",
+       "      <td>1265</td>\n",
+       "      <td>1230</td>\n",
+       "      <td>17</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>16</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3</td>\n",
+       "      <td>17</td>\n",
+       "      <td>6</td>\n",
+       "      <td>22</td>\n",
+       "      <td>3</td>\n",
+       "      <td>18784</td>\n",
+       "      <td>4380</td>\n",
+       "      <td>39</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>4</td>\n",
+       "      <td>17</td>\n",
+       "      <td>6</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
+       "      <td>129889</td>\n",
+       "      <td>4586</td>\n",
+       "      <td>61</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   index  URL_LENGTH  NUMBER_SPECIAL_CHARACTERS  DIST_REMOTE_TCP_PORT  \\\n",
+       "0      0          16                          7                     0   \n",
+       "1      1          16                          6                     7   \n",
+       "2      2          16                          6                     0   \n",
+       "3      3          17                          6                    22   \n",
+       "4      4          17                          6                     2   \n",
+       "\n",
+       "   REMOTE_IPS  SOURCE_APP_BYTES  REMOTE_APP_BYTES  APP_PACKETS  \\\n",
+       "0           2              1153               832            9   \n",
+       "1           4              1265              1230           17   \n",
+       "2           0                 0                 0            0   \n",
+       "3           3             18784              4380           39   \n",
+       "4           5            129889              4586           61   \n",
+       "\n",
+       "   DNS_QUERY_TIMES  CHARSET_ISO-8859  CHARSET_ISO-8859-1  CHARSET_UTF-8  \\\n",
+       "0              2.0                 0                   0              0   \n",
+       "1              0.0                 0                   0              1   \n",
+       "2              0.0                 0                   0              0   \n",
+       "3              8.0                 0                   1              0   \n",
+       "4              4.0                 0                   0              1   \n",
+       "\n",
+       "   CHARSET_iso-8859-1  CHARSET_us-ascii  CHARSET_utf-8  CHARSET_windows-1251  \\\n",
+       "0                   1                 0              0                     0   \n",
+       "1                   0                 0              0                     0   \n",
+       "2                   0                 1              0                     0   \n",
+       "3                   0                 0              0                     0   \n",
+       "4                   0                 0              0                     0   \n",
+       "\n",
+       "   CHARSET_windows-1252  SERVER_Apache  SERVER_Microsoft-HTTPAPI  \\\n",
+       "0                     0              0                         0   \n",
+       "1                     0              1                         0   \n",
+       "2                     0              0                         1   \n",
+       "3                     0              0                         0   \n",
+       "4                     0              0                         0   \n",
+       "\n",
+       "   SERVER_OTHER  SERVER_nginx  WHOIS_COUNTRY_AU  WHOIS_COUNTRY_CA  \\\n",
+       "0             0             1                 0                 0   \n",
+       "1             0             0                 0                 0   \n",
+       "2             0             0                 0                 0   \n",
+       "3             0             1                 0                 0   \n",
+       "4             1             0                 0                 0   \n",
+       "\n",
+       "   WHOIS_COUNTRY_CN  WHOIS_COUNTRY_ES  WHOIS_COUNTRY_FR  WHOIS_COUNTRY_GB  \\\n",
+       "0                 0                 0                 0                 0   \n",
+       "1                 0                 0                 0                 0   \n",
+       "2                 0                 0                 0                 0   \n",
+       "3                 0                 0                 0                 0   \n",
+       "4                 0                 0                 0                 0   \n",
+       "\n",
+       "   WHOIS_COUNTRY_IN  WHOIS_COUNTRY_JP  WHOIS_COUNTRY_OTHER  WHOIS_COUNTRY_PA  \\\n",
+       "0                 0                 0                    1                 0   \n",
+       "1                 0                 0                    1                 0   \n",
+       "2                 0                 0                    1                 0   \n",
+       "3                 0                 0                    0                 0   \n",
+       "4                 0                 0                    0                 0   \n",
+       "\n",
+       "   WHOIS_COUNTRY_US  Type  \n",
+       "0                 0     1  \n",
+       "1                 0     0  \n",
+       "2                 0     0  \n",
+       "3                 1     0  \n",
+       "4                 1     0  "
+      ]
+     },
+     "execution_count": 93,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_final.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_final.drop(columns = \"index\", inplace =True)"
    ]
   },
   {
@@ -479,13 +3800,45 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 96,
    "metadata": {},
    "outputs": [],
    "source": [
     "from sklearn.model_selection import train_test_split\n",
     "\n",
-    "# Your code here:\n"
+    "# Your code here:\n",
+    "y = df_final[\"Type\"]\n",
+    "X = df_final.drop(columns = [\"Type\"]) #pongo corchetes por si quiero mas de una columna \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 98,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100% of our data: 1781.\n",
+      "80% for training data: 1424.\n",
+      "20% for test data: 357.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f'100% of our data: {len(df)}.')\n",
+    "print(f'80% for training data: {len(X_train)}.')\n",
+    "print(f'20% for test data: {len(X_test)}.')"
    ]
   },
   {
@@ -499,12 +3852,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 100,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Your code here:\n",
-    "\n"
+    "model = LogisticRegression()\n"
    ]
   },
   {
@@ -516,12 +3869,66 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 102,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "20% for test prediction data: 357.\n"
+     ]
+    }
+   ],
    "source": [
     "# Your code here:\n",
-    "\n"
+    "model.fit(X_train, y_train)\n",
+    "predictions = model.predict(X_test)\n",
+    "print(f'20% for test prediction data: {len(predictions)}.')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.89      0.98      0.93       306\n",
+      "           1       0.74      0.27      0.40        51\n",
+      "\n",
+      "    accuracy                           0.88       357\n",
+      "   macro avg       0.81      0.63      0.67       357\n",
+      "weighted avg       0.87      0.88      0.86       357\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(classification_report(y_test, predictions))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 225,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test data accuracy:  0.927170868347339\n",
+      "Train data accuracy:  0.9487359550561798\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Test data accuracy: \",model.score(X_test,y_test))\n",
+    "print(\"Train data accuracy: \", model.score(X_train, y_train))"
    ]
   },
   {
@@ -533,12 +3940,45 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 105,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Your code here:\n",
-    "\n"
+    "cm = confusion_matrix(y_test, predictions)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 203,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 800x600 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "disp = ConfusionMatrixDisplay(confusion_matrix=cm)\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "disp.plot(cmap='Oranges')  \n",
+    "plt.grid(True)\n",
+    "plt.show()"
    ]
   },
   {
@@ -550,12 +3990,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 107,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Your conclusions here:\n",
-    "\n"
+    "#we can conclude that the model has an accurency of .88 but the precision for the type 1 is unprecise because we have a .74.\n"
    ]
   },
   {
@@ -569,14 +4009,45 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 205,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Your code here:\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "\n",
+    "model = KNeighborsClassifier(n_neighbors=3)\n",
+    "model = model.fit(X_train, y_train)\n",
+    "predictions = model.predict(X_test)\n",
     "\n"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 217,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.94      0.98      0.96       306\n",
+      "           1       0.84      0.61      0.70        51\n",
+      "\n",
+      "    accuracy                           0.93       357\n",
+      "   macro avg       0.89      0.79      0.83       357\n",
+      "weighted avg       0.92      0.93      0.92       357\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "print(classification_report(y_test, predictions))"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -586,11 +4057,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 219,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 800x600 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Your code here:\n",
+    "\n",
+    "cm = confusion_matrix(y_test, predictions)\n",
+    "disp = ConfusionMatrixDisplay(confusion_matrix=cm)\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "disp.plot(cmap='Oranges')  \n",
+    "plt.grid(True)\n",
+    "plt.show()\n",
     "\n"
    ]
   },
@@ -605,12 +4103,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 221,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.94      0.98      0.96       306\n",
+      "           1       0.84      0.61      0.70        51\n",
+      "\n",
+      "    accuracy                           0.93       357\n",
+      "   macro avg       0.89      0.79      0.83       357\n",
+      "weighted avg       0.92      0.93      0.92       357\n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "# Your code here:\n",
-    "\n"
+    "\n",
+    "model = KNeighborsClassifier(n_neighbors=5)\n",
+    "model = model.fit(X_train, y_train)\n",
+    "predictions = model.predict(X_test)\n",
+    "\n",
+    "print(classification_report(y_test, predictions))"
    ]
   },
   {
@@ -622,42 +4143,58 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 223,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 800x600 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhoAAAHLCAYAAACOMzExAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABWdklEQVR4nO3df3zP9f7/8dtr29t+mjHMxoxhflQKHcs6J1IolRNRfhShKP2gX3wrSRxR59NvKdJJVkmZFCqVSH5ERH6bYX4NM7GN/X7v9f1j7X3a2Wbvvd97773Z/Xq5vC/q9Xq+Xq/H661zdt/z+Xw9X4ZpmiYiIiIiLuDh7gJERETk0qWgISIiIi6joCEiIiIuo6AhIiIiLqOgISIiIi6joCEiIiIuo6AhIiIiLqOgISIiIi6joCEiIiIu4+XuAkRERMR+33zzDR9//DG7du3CNE3Cw8Pp3bs3w4cPx8fHp1j79evX895777F3716ysrKIjIxk4MCB9O/fH8MwirXPy8sjLi6OhQsXkpiYiJeXF1dccQWjRo0iOjq63PUaWoJcRESkenjrrbeYOXMmnp6edOrUiYCAALZv305KSgqtWrXi448/pk6dOrb2CxYsYPLkyVgsFqKjo7FYLPzyyy9kZmbSr18/pk+fXuT8pmny5JNPsmzZMurUqUPnzp05d+4cW7ZswTRNpk2bxh133FGumhU0REREqoHNmzczZMgQAgMDiY2NpU2bNgBkZGTw6KOP8vPPPzN48GCef/55AA4dOsQtt9yCr68vsbGxtGvXDoCkpCSGDRvGkSNHeOONN7jpppts11i0aBHPPvssbdu2Zd68eQQFBQGwYcMGRo8eDcCKFSsIDQ21u27N0RAREakGvvjiCwDuv/9+W8gA8PPz49FHHwVg9erVtu1z587FarUycuRIW8gACAsLY9KkSbY2fzV79mwAJk6caAsZAF26dGHYsGFkZ2cTGxtbrroVNERERKqBF154ga+//pqBAwcW22e1WgHw9PS0bVu1ahUAPXv2LNY+JiaG2rVrs2PHDk6dOgVAQkICR44cITg4mE6dOhU7plevXgCsXLmyXHUraIiIiFQDXl5etGjRgsDAwCLbT5w4wUsvvQRAv379AEhJSeHMmTNYLBYiIyOLncvT09O2fd++fQDEx8cD0KpVqxIniRZuP3LkCJmZmfbXbXdLERERqTJmzJjB77//zu+//45hGIwYMYIHHngAgOTkZADq16+Ph0fJfQoNGzYs0rbwz5CQkBLbe3t7ExgYSGpqKikpKYSHh9tVp4KGiIhIJfn99995/PHHS91fnmGJuLg40tLSAKhVqxanT58mJSWFhg0bkpGRAVDi466FvL29AWxtL1y4YPcxhW3toaABWPNySTtx1N1l1AgeXhYCGzUh7eQx8vNy3V1OjVG3cYS7S6hZDA8w891dRc1g/Pnbegld/RUpPy+P1BNHnDpHndCmNGjQoIIqgq+++oq6desSHx/PK6+8wtKlS9m6dStLly619WKUNATyvwofPi2c32HPMeWhoAGknTjKGz1au7uMGiG0XQdGL97Epw/dwYndW91dTo0x+bcT7i6h5jA8wbcuZKWBaXV3NZc+n7oFfxqeF2/npNQTR3jTyZ8Tj36/j7DwyHJPpixN4SOm7du357333uOOO+4gPj6ezz77jC5dugCQlZVV6vHZ2dlAwVMrAP7+/nYf4+vra3edmgwqIiJSzdWqVYubb74ZgN27d9vmWaSkpFDaclmFczIK52oUHnP69OkS22dnZ5OWloZhGOXqmVHQEBERsYNhOPdx1ptvvsm4ceM4efJkiftr1aoFFCwhHhQUREhICDk5ORw+fLhYW6vVysGDBwFo3bp1kT/3799f4vn3799vW/K8sBfEHgoaIiIidvBw8uOsdevW8c0337B8+fIS9//0008AXHHFFQB07doVgO+++67Ec6Wnp9OmTRsaNWoEQEREBM2aNSM5OZlt27YVO+bbb78FoFu3buWqW0FDRETEDu7u0RgyZAgAM2fOZPv27bbtubm5/N///R+bNm0iODjY9i6SIUOG4OnpyezZs4sEh6SkJKZOnQpgW1a80NChQwF47rnnSElJsW3fsGED8+fPx2KxMGLEiHLVrcmgIiIi1UCfPn3YvHkzCxcu5K677qJDhw4EBgayZ88eTp48SVBQEO+8845tQa82bdowbtw4XnnlFQYPHkznzp3x8fFh48aNZGRkMGDAAHr37l3kGoMGDWLNmjWsXr2aXr16ER0dTXp6Ops3b8Y0TWbMmFGu95yAgoaIiIhdXPsArX2mTJnCNddcw4IFC9i1axc5OTmEhYUxbNgwRo4cWWyxrVGjRtGiRQvmzZvH9u3bMQyDFi1aMGjQIPr27Vvs/B4eHsycOZOPPvqIxYsXs3btWgICAoiJiWH06NF07ty53DUraIiIiNjBxUt12K13797FeiIu5oYbbuCGG26wu73FYmH48OEMHz7ckfKK0RwNERERcRn1aIiIiJTBwPnfzKtIh0ilU9AQERGxQ1UZOqluNHQiIiIiLqMeDRERETuoQ8MxChoiIiJlqYhFt2poUtHQiYiIiLiMejRERETsUEM7JJymoCEiIlIGA/BwMmnU1KCioCEiImKHmhoUnKU5GiIiIuIy6tEQERGxgxbscoyChoiIiB2UMxyjoRMRERFxGfVoiIiI2MHDMN1dQrWkoCEiImIHDZ04RkMnIiIi4jLq0RAREbGDejQco6AhIiJSBgPnH2+tqUFFQyciIiLiMurREBERsUNN7ZFwloKGiIiIHZx9qVpNpaAhIiJiB+UMx2iOhoiIiLiMejRERETsoJeqOUZBQ0RExA7KGY7R0ImIiIi4jHo0REREymDg/FMnNbVHREFDRETEDjU1KDhLQyciIiLiMurREBERKYtRAU+d1NAuEQUNERERO9TQnOA0DZ2IiIiIy6hHQ0RExA5asMsxChoiIiJ20BCAYxQ0REREymDgfI9GTe0QUUATERERl1GPhoiIiB1qao+EsxQ0RERE7ODsEuQ1lYZORERExGXUoyEiImIHdWg4RkFDRETEDho6cYyGTkRERMRl1KMhIiJSBgPnfzOvqR0iChoiIiJ20BLkjtHQiYiIiLiMejRERETsUFV+M//yyy9ZtGgRe/fuJTMzk+DgYK655hpGjRpFixYtirRduHAhkyZNKvVcrVq1YtmyZUW25eXlERcXx8KFC0lMTMTLy4srrriCUaNGER0dXe56FTRERETs4O6hE9M0efLJJ1m2bJnth3+9evXYu3cvS5Ys4dtvv+Xtt9/m73//u+2YXbt2ARAdHU3Dhg2LnTM0NLTYNSZMmMCyZcuoU6cOMTExnDt3jvXr17Nu3TqmTZvGHXfcUa66FTRERETKYoCHYTp9Dmd89dVXLFu2jAYNGjB37lzatGkDgNVq5c033+Tdd99l/PjxfP/99/j7+wP/DRovvPACzZs3L/MacXFxLFu2jLZt2zJv3jyCgoIA2LBhA6NHj+aFF14gJiamWEC5mKrSEyQiIiIXsWjRIgCeeOIJW8gA8PT0ZNy4cbRq1YozZ86wbt06AHJzc4mPj6d27do0a9bMrmvMnj0bgIkTJ9pCBkCXLl0YNmwY2dnZxMbGlqtuBQ0REZEyFD7e6szH2ZGXwMBAWrRowdVXX128PsOw9VicOnUKgISEBHJycrj88ssx7Bj3SUhI4MiRIwQHB9OpU6di+3v16gXAypUry1W3hk5ERETs4O45Gm+//Xap+6xWq22YpHBYo/DfQ0JCeOmll1i1ahVJSUnUrVuXbt26MWbMGEJCQmzniI+PBwomiJYUTAq3HzlyhMzMTHx9fe2qWz0aIiIi1dwnn3zC8ePHCQoKokuXLsB/g8aSJUv47LPPiIiIoFOnTmRmZvLpp5/St29f9u3bZztHcnIyQJHw8Vfe3t4EBgaSn59PSkqK3bWpR0NERMQOFfGbeVJSEvfcc0+p+8s7LAEFEzVffvllAJ588knbRNDdu3cDBUMeL774IgEBAQCkp6fz7LPPsmLFCh599FGWL1+Ol5cXFy5cAMDHx6fUa3l7ewPY2tpDQUNERMQO7h46KcmqVasYN24cOTk5DBo0iAEDBtj2ffjhhxw9epSIiAhq1apl2167dm2mT5/O1q1bSUxMZM2aNXTv3h1PT08Au+ZzlIeChoiISCUJCwtzqNeiJLGxsUyfPh2r1cqQIUN47rnniuz38fGhVatWJR7r7+/PNddcw1dffcWOHTvo3r27rSckKyur1GtmZ2cD2D0/AxQ0RERE7FJVJjXm5eUxZcoUFi5ciGEYPPbYYzzwwAPlPk/hpNHMzEzgv3MzTp8+XWL77Oxs0tLSMAyDBg0a2H0dBQ0REZEyGICHkyMKFTEgkZWVxUMPPcTatWvx9fVlxowZ3HTTTcXanTp1itdff50LFy7w2muv2YZF/urEiRMANGrUCIDWrVsDsH///hKvvX//fkzTpGnTpvj5+dldc1UJaCIiInIRVqvVFjKCg4OZP39+iSEDCuZhLF++nBUrVrBp06Zi+8+dO8eqVaswDIPrrrsOgIiICJo1a0ZycjLbtm0rdsy3334LQLdu3cpVt4KGiIiIHQzDuY+z3nnnHdauXYufnx8ffvgh7du3L7Wtn58ft99+OwCTJ0/m+PHjtn2pqamMHTuW9PR0+vTpQ2RkpG3f0KFDAXjuueeKPMK6YcMG5s+fj8ViYcSIEeWqW0MnIiIidnDnb+apqam8//77ADRs2NC2VHhJbrvtNrp27cr48ePZs2cP27dvp3fv3nTs2BEfHx9+/fVX0tPT6dSpE88//3yRYwcNGsSaNWtYvXo1vXr1Ijo6mvT0dDZv3oxpmsyYMaNc7zkBBQ0RERG7uPPx1k2bNpGRkQFAYmIiiYmJpbZt27YtXbt2JSAggI8//pgPP/yQZcuWsWXLFjw9PWnevDl9+vRhyJAhWCyWIsd6eHgwc+ZMPvroIxYvXszatWsJCAggJiaG0aNH07lz53LXrqAhIiJSxfXo0aPIKp72qlWrFvfffz/333+/3cdYLBaGDx/O8OHDy329kihoiIiIlKHwpWrOnqMmUtAQERGxg7OPt9ZUeupEREREXEY9GiIiInZQh4ZjFDRERETsoKETx2joRERERFxGPRoiIiJ2UIeGYxQ0REREymAYFfBStRqaVDR0IiIiIi6jHg2xW73w5vx9+MO0iO5KQP0GZKae49iO39j02Qcc3LimxGN869TluvvG0aZrLwJDQsnOuADZaTRs0ZoTu7eWeq06jRrT9f7HaBlzPf716nPh7BkObVrLzx+8Rcqhkl9hLOJOBzetZdPC/3BsxxYyUs/iV6cezf92LdeNHEuDyCh3lycVwMMw3V1CtaQeDbFLiy7dePDTlXS8fTC+QXU5fTCe/Hwrba6/iaHvLKTHuOeKHeNfrz73z19OlyGj8A9uwKn9e8A0wZrDPyf9Hx3+ObDEawVHtGD0x9/Rse8Qavn5czJ+N161vLny1gGM/ngFLbp0c/HdipTP929OY/4DA9i76hvAoEFkGzLTzrHjm8XMHtKLA7/85O4SpQIYTn5qKgUNKZNfUD36vzgLi68vO779gld6XcW7g3rw6k0diXtmDPl5eVw7dAxtu99S5LgBM2ZTL7w5Bzb8xKs3dWTO3TcR+8g9YPHDw9OTW595ifrNWxU5xsPTk8FvzMevbj1+X76I/+t5Fe/dczOv9LyKjZ++j8XHl/7T38G3Tt3K/ApESvXbkgWsmzcTDy8L/5z8Ok98t50Hv/yNJ77bTqu/30hedhaLJz5MTmaGu0sVJ3kYzn1qqmoTNA4dOsSTTz7J9ddfT/v27enZsyevvfaa7W124jodbx+Mb526nD1+hCXPjyP7fLpt345vv2DLFx8DcHX/e2zbm3XqQrOrY8i+cJ64Z8eQlZ5asMM0weLH/nU/4mmpxXUjxxa5VvvedxDcNJJzJ47x1QuPk5edBYA1L5dvXp7I4a0b8Q0MosuQUS6+a5Gy5WZn8f0bUwG4+ampdOhzF8afM/786tTljmlvU8s/gAt/pLDvpxXuLFXEbapF0Ni+fTv9+vVj6dKl1K9fn27dupGRkcG7777LwIEDOX/+vLtLvKSdSzrKjm8W8+vn87Dm5hTbf2r/bgCCQpvYtl11210A7PtpBRnn/ih2zK4fvgagTbeb8PL2KXbc9uWLsOblFjtu86L5AFze63YH70ak4sSv+Z7M1LPUaxpJp353F9vvUzuQ3uOn0fPx5wmOaOGGCqUiaejEMVV+MmheXh6PP/44GRkZTJs2jf79+wOQlZXFY489xo8//sirr77KpEmT3FzppWvnd1+y87svS90f1u5KAM4cOWTb1qR9JwCObN1U4jGnD+7DmptLLT9/wtpdyZGtGzEMg8aXdSg4blvJxx39c3u98GYEhoSRdiqp/DckUkEK51606doLD0/PEttcddudlVmSuIhBBTzeWiGVVD9Vvkdj+fLlHD16lC5duthCBoCPjw8vvvgifn5+fPbZZ6SmprqxyprJJyCQrqMep0OfgVhzc1n34dsAGIZB3cYRAPxxLLHEY/OtVtJPnwQguGkkALUbhmLx9S047mjJx6WeSiI/L6/guIjIiroVEYec2r8HgAYtWmOaJrtXLueLSY/w4fBefDb+Pn5b8gnW3OI9cyI1SZXv0fjxxx8B6NGjR7F9devWJTo6mlWrVvHzzz9z6623VnZ5NVLb7rdw/QNPUi+8GV7ePqSeOM6y6RM4/NsvAPgEBuFpsQCQcfZMqefJSD1LUFg4fkH1gIKnVGz7SjnOzM8n63wafkH1bMeJuEvqyWMAeHp58cF9fTmydWOR/bu//4pfPpnLkDdjqdOosTtKlApU5X8zr6Kq/PcWHx8PQOvWrUvc37JlSwD27t1baTXVdI0vv4qGLdvY5lb4BNah9XU9qeXnD4DFx9fWNi8nu9Tz5GUVTPQs7MWw+7g/J4j+tb2IO2RfKJgf9u0rz5O0+3duenIKT63czTNbUxn0xkcEhYWTnLCHT8YOJa+E+U1SvRiGc5+aqsoHjeTkZABCQkJK3N+wYcMi7cT1Nn36H6bFRPJ/Pa/ki0mPkpedxdX9hzJs9iI8PD0xrVZbW9O8yAI3f/4Pz8zPL/jT7uOMIseJuEth6M04e4Y7XpzFNYPvx79efWr5+tH6up7cPfMTPLwsnNq/m9+XfubmakXco8oPnRQ+vurj41Pi/sLtzjzm6uFlIbRdB4ePr4n86zcCIPlgAkunP03/aTNpfNlV/OO+xzm0eZ2tXaO2V1LLP9D27/UjW9v+LFwLw7dOMKHtOhAYGm5r16T930pdd6CWb0HPSUCDUP292csoeaKiOMfi40tOxgVCoi6jbfc/h24Lv2vDk/rNW3PFTX35fdln7P3pOzrdMcx9xYrTavJaGM6o8kHD09OT/Px827Pppbnob8BlCGzUhNGLS37KQeyUnQ7WbK4f8zTX1wqAzII5FgNeiQXPWsWa3/F/sZD5B5j5XDPsUa4ZOR7yrZB1FoDhsSvBo4QfjqZpO3ePJ6eXeG6RyuITWJecjAs0atcRfOv+704AGrbtCMs+42zSseJtpGLkW8tuUwGUMxxT5YOGv78/586dIzMzs8T9WX+O8/v6Oj5en3byGJ8+dIfDx1/qvP0DqN2gEedTksk6n1Zim853DqNDn7s4unUdX788if7TZhIcEcnqmVPY99N3tnb1I1tzx//Fsnj8MP458SU8vbxY8uxo2+z9e2d/hrd/AMuef4Dju34vdp3aDUIY/NoHAMTe36fENTqkuNEfa7EoV6jfrAVpJ49hzTwPmQUhGcOzIGRkpYFpxSO/YG6Gl5fnf9tIxfEOLLtNBTCgzF947TlHTVTlg0bDhg05d+4cp0+fJjw8vNj+wrkZhXM1HJGfl3vRF3zVdI9+uYF64c347vUprJ//ToltPL3uA+D0wXhO7N5K4pb1BEdEEli/QYnfrYdh4OnlRW5WJju/XWwb6z62fQstunTFLzCoxOPq39wPKFhE7MD6lRV1i5c+s3J+46tpmlzRkYO//MTxXb8V/45NK5hWUg4VTGiv2yRCfw9SI1X5yaCFT5skJCSUuL9we2lPpYjzChcl6tR3CB5exbNpUGgT2l5/M1CwUiLAru++AqDdjbfiGxhU7JjLbuxta1cYMgB2fV9w3FV97sLTy1LsuKv7DwVg29KFjt6OSIW54qa+AJw9dpg9P35dbP/5P1LYsWIJUPC/BanGnHzixKjBy4NW+aDRtWtXAFasKN71e/bsWTZu3IjFYuHaa6+t7NJqjPXzZ5GbmUlwRAvumDaryPoVjVpfzt1vL8Di60vilg3sXf0tAAc3/czhrRvxqV2Hga9+8N81MgwDcjNodW13rLk5rP1zka9C27+O44+jh6gX3ow7Xpxle2TW08vCzU9NJaJDNFnpqWz89D+Vc/MiF9GgeSs69h0MwJLJjxUZJkxPOcWi/zeanAvnCWnVjrbde7urTKkoer7VIYbpzCzKSpCVlcXNN99MUlISkyZNYsiQIbbtjz/+OCtXrmTQoEFMnjzZ4WucPXqQN3qoR+Riov5xI/1nzKaWrx952VmkHD6AVy1v6jcrWMfk6PbNLBg3rMicibqNmzJ87hcEhoSRl51F8oF91AkLxz+oHmZ+Poufe4Qd3ywudq2wdlcy9J2F+NSuQ/aF86QkJlC3cVP8guqRl5PNRw8PJnHz+kq790vB5N9OuLuES1ZuViafjR/F/rU/ABDYqDH+9RqSvH8X1twc6oQ24e6Zn9Dgf95ULBXE588JtiVNHq9AuScPcvi+KKfOETE3HkujmreicZUPGgAbN25k1KhRZGVlcdlll9GkSRO2bt1KcnIy7dq1IzY2loCAAIfPr6Bhn3rhzYgZOoYW13QlsGEjcrMyOZWwl+1fx7H1ywW2pcH/yi+oHv8YOZbW1/UkMCQUa24O3rXrsXTqE2yJ+7DUa9UJbULX+8bRoks3AoIbkHU+ncNbNrBm7uucjN/lytu8JClouJZpmuz4ZjG/LVnAyX07ycvNKRhS7N6bLkNGaRVbV6rEoHHkfueCRtP3FDSqtPj4eGbOnMmmTZvIyMigSZMm9OrVi5EjRzoVMkBBozKFtuvA6MWbmN2vsybgViIFjUpkeBY8xpp5VpM/K0MlBo2jo5z7ORE+Z1+NDBpV/qmTQlFRUbz55pvuLkNERETKodoEDREREXdydh2NmkpBQ0RExB5V/jnNqklfm4iIiLiMejRERETKZFTA0EnNHHpR0BARESlLRay5VTNzhoKGiIhIWfRSNcdpjoaIiIi4jHo0RERE7FFTuyScpKAhIiJiB62j4RgNnYiIiIjLqEdDRETEDurQcIyChoiIiB00dOIYDZ2IiIiIy6hHQ0RExB7q0XCIgoaIiEhZtDKowzR0IiIiIi6jHg0RERE7aDKoYxQ0RERE7FBVcsaXX37JokWL2Lt3L5mZmQQHB3PNNdcwatQoWrRoUaz9+vXree+999i7dy9ZWVlERkYycOBA+vfvX2J4ysvLIy4ujoULF5KYmIiXlxdXXHEFo0aNIjo6utz1auhERETEHobh3MdJpmnyxBNPMH78eH777TdatGjBddddh6enJ0uWLKFfv36sXbu2yDELFixg+PDh/Prrr7Rr147o6GgOHDjAxIkTeeaZZ0q8xoQJE5g0aRLHjh0jJiaGqKgo1q9fz7Bhw4iLiyt33erREBERqQa++uorli1bRoMGDZg7dy5t2rQBwGq18uabb/Luu+8yfvx4vv/+e/z9/Tl06BBTp04lICCA2NhY2rVrB0BSUhLDhg1j8eLFdO3alZtuusl2jbi4OJYtW0bbtm2ZN28eQUFBAGzYsIHRo0fzwgsvEBMTQ2hoqN11q0dDRETEDm7u0GDRokUAPPHEE7aQAeDp6cm4ceNo1aoVZ86cYd26dQDMnTsXq9XKyJEjbSEDICwsjEmTJtna/NXs2bMBmDhxoi1kAHTp0oVhw4aRnZ1NbGxsuepW0BARESmDQcFkUKc+TtYQGBhIixYtuPrqq4vXZxg0b94cgFOnTgGwatUqAHr27FmsfUxMDLVr12bHjh229gkJCRw5coTg4GA6depU7JhevXoBsHLlynLVraETERGRauDtt98udZ/VamXXrl0AhIaGkpKSwpkzZ7BYLERGRhZr7+npSWRkJL///jv79u0jJCSE+Ph4AFq1alXiJNHC7UeOHCEzMxNfX1+76lbQEBERKZNRAY+3GiQlJXHPPfeU2qK8vQWFPvnkE44fP05QUBBdunTh8OHDANSvXx8Pj5IHLxo2bAhAcnJykT9DQkJKbO/t7U1gYCCpqamkpKQQHh5uV20KGiIiInaoKo+3/q8NGzbw8ssvA/Dkk0/i7+9PRkYGAD4+PqUe5+3tDWBre+HCBbuPKWxrDwUNERGRShIWFuZwr0VJVq1axbhx48jJyWHQoEEMGDAAwNaLYU8vjGmaQMFwir3HlIeChoiISFkKZoM6f44KFBsby/Tp07FarQwZMoTnnnvOts/f3x+ArKysUo/Pzs4GwM/Pr9zH2Ds/AxQ0RERE7FJVhk7y8vKYMmUKCxcuxDAMHnvsMR544IEibQrnWaSkpGCaZom9FIVzMgrnahQec/r06RKvm52dTVpaGoZh0KBBA7vr1eOtIiIi1URWVhajR49m4cKF+Pr68vrrrxcLGQBBQUGEhISQk5Njmxj6V1arlYMHDwLQunXrIn/u37+/xGvv378f0zQJDw+39YLYQ0FDRETEDs6uo+Esq9XKQw89xNq1awkODmb+/PlFVvX8X127dgXgu+++K7Zv3bp1pKen06ZNGxo1agRAREQEzZo1Izk5mW3bthU75ttvvwWgW7du5apbQUNERMQO7l4Z9J133mHt2rX4+fnx4Ycf0r59+4u2HzJkCJ6ensyePbtIcEhKSmLq1KkAjB49usgxQ4cOBeC5554jJSXFtn3Dhg3Mnz8fi8XCiBEjylW3XXM0xo8fX66TlsQwDF566SWnzyMiIuIWbpykkZqayvvvvw8UzKkoXCq8JLfddhtdu3alTZs2jBs3jldeeYXBgwfTuXNnfHx82LhxIxkZGQwYMIDevXsXOXbQoEGsWbOG1atX06tXL6Kjo0lPT2fz5s2YpsmMGTPK9Z4TsDNofPXVVxiGYXsEpjwKj1PQEBERccymTZts610kJiaSmJhYatu2bdvahk0KXx0/b948tm/fjmEYtGjRgkGDBtG3b99ix3p4eDBz5kw++ugjFi9ezNq1awkICCAmJobRo0fTuXPnctduV9C4/fbbK/y5WhERkerEnT8He/Towb59+xw69oYbbuCGG26wu73FYmH48OEMHz7coev9L7uCxowZMyrkYiIiItVRFVxGo9rQZFARERFxmQpZsOvAgQOsXr2agwcPkp6ezptvvklGRgYrVqzg1ltvxWKxVMRlRERE3MOogKGTGtql4VTQyMzMZPLkySxduhTTNIusPnbs2DGefvpp3n77bf7zn//QtGnTCilYRETELWpoUHCWw0Mn+fn5jBkzxvZESrt27ahbt65tf3Z2Nl5eXhw7dowhQ4bwxx9/VEjBIiIiUn04HDTi4uLYsGEDERERLFmyhLi4OJo3b27bf8UVV/DNN9/QvHlzUlJSmDdvXkXUKyIi4gYGhoeHU5+a2iXicNBYsmQJhmHw+uuv06pVqxLbhIeH88YbbwAFr7IVERGptty9NGg15XDQiI+Pp2nTprRp0+ai7aKiooiIiODo0aOOXkpERESqKYcng2ZnZ9v99jZ/f3+HVhUVERGpMmpwr4QzHA4ajRo1IjExkZycHGrVqlVqu4yMDA4cOGB7z72IiEh1ZBhaesoRDn9rMTExZGVlXfTFLgBvvvkm2dnZdOnSxdFLiYiIuJ/maDjE4R6NkSNHsmTJEt555x3Onz/PbbfdRk5ODgBZWVnEx8cTGxvLsmXL8PLyYtiwYRVWtIiIiFQPDgeN8PBw/v3vf/PEE08wf/585s+fb9vXoUMHAEzTxNPTkylTphAZGel8tSIiIu6gl504zKkBpx49evDZZ5/RvXt3LBaLbXVQ0zTx8PCgS5cuxMbGlvgqWhERkerEMAynPjWV0+86adOmDW+//TY5OTkcPnyY9PR0/Pz8CA8Px9/fvyJqFBERkWqqQl6qBlCrVq1SF+4SERGp3gxw+qmTmtmr4XTQyM3N5dtvv7W9vTUzM5M6deoQFRVF9+7duf766yuiThEREbcyPGpmUHCWU0Fj7969jB07liNHjhRbkOv3339n0aJFXHXVVbz++utaR0NERKQGcjhoJCcnM2zYMFJTUwkMDOTGG2+kdevW+Pv7c/78eXbt2sUPP/zA1q1bGTlyJJ9//jm+vr4VWbuIiEjlqcETOp3hcNCYM2cOqampXH311bz11ltFXhFf6OTJkzzwwAPs27eP999/n4cfftipYkVERNxGK4M6xOFvbfXq1VgsFl577bUSQwYULFP+1ltv4eHhwddff+1wkSIiIlI9OTV0EhUVRYMGDS7aLjw8nKioKA4ePOjopURERNyuJq+F4QyHg0ZwcDDnzp2zq21GRga1a9d29FIiIiLuVRHvK6mhQcXhoZOePXuSlJTEDz/8cNF2mzZt4vDhw3Tv3t3RS4mIiLifXqrmEIeDxiOPPELLli156qmnWLRoEXl5ecXarFy5krFjxxIeHs64ceOcqVNERESqIbuGTrp161bi9qysLDIzM3nuueeYMWMGLVu2xN/fn4yMDBITE21DK40bN+b//b//x5w5cyqqbhERkUpl6KkTh9gVNE6ePHnR/aZpcv78ebZt21bi/p07d2oSjYiIVG/6OeYQu4LG9OnTXV2HiIiIXILsChp6zbuIiNRkBs6/66Sm9odU2NtbRURELmmao+EQp4NGeno6hw4dIjMzk/z8/CL7rFYrWVlZnDx5klWrVvH+++87ezkRERGpRpwKGq+//jrvv/9+iY+2ioiIXDK0YJfDHA4aK1as4N1337WrbUREBLfeequjlxIREXE7PT3pGIcHnOLi4gDo3bs3q1evZsOGDXh4eHDnnXeyc+dOfvjhB0aPHo2HhwemaXLfffdVWNEiIiJSPTgcNHbt2oW3tzeTJ0+mUaNG1K1bl8jISDZs2ICXlxdNmjThscce48EHH+To0aN8/PHHFVm3iIhI5dIS5A5xOGikpqbSpEkTAgMDbduioqI4duwY6enptm3Dhw+nVq1afPfdd85VKiIi4k6Gh3OfGsrhO/f29sbb27vItvDwcAAOHDhg2xYQEEBERASJiYmOXkpERMTtDMNw6lNTORw0QkJCOH78OFar1batadOmAOzfv79Y+4yMDEcvJSIiItWUw0GjU6dOpKWlFVkbo1WrVpimWeTV8adOneLQoUM0bNjQuUpFRETcycNw7lNDORw0hgwZgmEYvPbaawwYMICcnBzat29PREQEa9as4emnn+ajjz7ivvvuIy8vj8suu6wi6xYREalEBobh4dSnpi5C7nDQaNOmDRMnTsTT05OEhARq1aoFwJgxYzBNkyVLljBt2jT279+Ph4cHY8aMqbCiRUREpHpwamXQwYMHc+2117J27Vrbtn/+85/k5+czZ84cjh07RmRkJI899hht27Z1ulgRERG3MKiAlUErpJJqx+l3nURERBAREVFkW9++ffXGVxERubTU4CdHnFFzH+wVERERl7OrR2PRokUVcrH+/ftXyHlEREQqW01eC8MZdgWNiRMnVsgXrKAhIiLVVg1e3dMZdgWNsLAwV9chIiIi5ZSYmMjtt99Ov379mDRpUrH9CxcuLHF7oVatWrFs2bIi2/Ly8oiLi2PhwoUkJibi5eXFFVdcwahRo4iOji53jXYFjR9//LHcJxYREbmkVLGhk5SUFMaMGUNmZmapbXbt2gVAdHR0iQtnhoaGFvl30zSZMGECy5Yto06dOsTExHDu3DnWr1/PunXrmDZtGnfccUe56nT6qRMREZFLX0W8r6TigsqePXsYO3Yshw8fvmi7wqDxwgsv0Lx58zLPGxcXx7Jly2jbti3z5s0jKCgIgA0bNjB69GheeOEFYmJiigWUi1HQAILCwnn+lwR3l1EzeBYs7Dbqwy/BmuPmYmoOMyPF3SXUHJ7eGL51MbPOgTXb3dVc+rwL3iBu4Ona6xiAh5NzNCogZ6SmpjJnzhzmz59PTk4OTZo04dixYyW2zc3NJT4+ntq1a9OsWTO7zj979mygYG5mYcgA6NKlC8OGDWPOnDnExsYyfvx4u2vWzBYREZFqYv78+cydO5d69erxzjvvcPvtt5faNiEhgZycHC6//HK7emMSEhI4cuQIwcHBdOrUqdj+Xr16AbBy5cpy1aweDREREXtUgTkajRo1YsKECQwePBgfHx/b0EhJCveFhITw0ksvsWrVKpKSkqhbty7dunVjzJgxhISE2NrHx8cDBRNESwomhduPHDlCZmYmvr6+dtWsoCEiImKPCni8NSkpiXvuuafU/WX1FgwYMMDuaxUGjSVLlhAQEMDVV19NaGgou3bt4tNPP+X777/ngw8+oHXr1gAkJycDFAkff+Xt7U1gYCCpqamkpKQQHh5uVx0KGiIiIpeg3bt3AwVDHi+++CIBAQEApKen8+yzz7JixQoeffRRli9fjpeXFxcuXADAx8en1HN6e3sD2NraQ0FDRETEHhUwdBIWFlbuOQ6O+vDDDzl69CgRERG2N6wD1K5dm+nTp7N161YSExNZs2YN3bt3x9OzYEJtRa+AqsmgIiIiZTIKhk6c+VTy61t9fHxo1apVkZBRyN/fn2uuuQaAHTt22LYBZGVllXrO7OyCJ6nsnZ8BFdSjkZ+fz65duzh48CDp6encfffd5ObmcvLkSbvHcERERKTyFK6FUbjgV+HcjNOnT5fYPjs7m7S0NAzDoEGDBnZfx+mgERcXx1tvvcWpU6ds2+6++26SkpLo3bs3N998M//6178uOuYjIiJS5VWBp07sderUKV5//XUuXLjAa6+9ZhsW+asTJ04ABU+yALZJofv37y/xnPv378c0TZo2bYqfn5/dtTg1dPLKK68wceJETp48iWEYRW7k5MmTWK1Wli9fzn333UdeXp4zlxIREXEvp4dOKk/t2rVZvnw5K1asYNOmTcX2nzt3jlWrVmEYBtdddx0AERERNGvWjOTkZLZt21bsmG+//RaAbt26lasWh+/8l19+4b333sPHx4fJkyezadMm2rdvb9sfHR3Nyy+/jK+vL1u2bGHhwoWOXkpERETKwc/Pz7aY1+TJkzl+/LhtX2pqKmPHjiU9PZ0+ffoQGRlp2zd06FAAnnvuOVJS/rui8IYNG5g/fz4Wi4URI0aUqxaHh05iY2MxDIMXX3yRm2++ucQ2ffr0wc/Pj4cffpilS5cyZMgQRy8nIiLiXtVo6ARg/Pjx7Nmzh+3bt9O7d286duyIj48Pv/76K+np6XTq1Innn3++yDGDBg1izZo1rF69ml69ehEdHU16ejqbN2/GNE1mzJhRrvecgBNBY9u2bdSvX7/UkFHoxhtvpGHDhiQk6F0iIiJSTRk4P/xRyTklICCAjz/+mA8//JBly5axZcsWPD09ad68OX369GHIkCFYLJYix3h4eDBz5kw++ugjFi9ezNq1awkICCAmJobRo0fTuXPnctfhcNBITU2lTZs2drUNCQlhz549jl5KRETEzYwK6NGo+KTxyCOP8Mgjj5S6v1atWtx///3cf//9dp/TYrEwfPhwhg8fXhElOj5HIygoiKNHj5bZzjRNjh07Rt26dR29lIiIiFRTDgeNjh07kpaWxvLlyy/a7osvvuDs2bN06NDB0UuJiIi4n2E496mhHA4a99xzD6ZpMmXKlBKXU83Pz+fzzz9nypQpGIbBwIEDnSpURETErarR461VicNzNP72t79x3333MXfuXB5++GH8/f3Jzc0FoH///iQmJnLhwgVM0+TOO+8kJiamwooWERGR6sGplUGffPJJmjRpwltvvcWZM2ds23fu3AkULBgyatSock1CERERqZJq8PCHM5xegnzgwIHccccdbN26lf3795Oeno6vry/Nmzfnb3/7W7levCIiIlJl1eDhD2dUyEvVLBYLnTt3duj5WhEREbl0VUjQEBERueRp6MQhDgeNG264oVztDcPghx9+cPRyIiIi7mMYFbAyaM0MKg4Hjb++oOViDMPANE2MGvoFi4iI1GQOB43p06eXui8jI4Pk5GR+/PFHEhISePTRR7n11lsdvZSIiIj76RdmhzgcNPr27Vtmm7Fjx/L0008za9Ys/vGPfzh6KREREffTUycOcem35uHhwbPPPouXlxfvvvuuKy8lIiLiWlqC3CEuj2eBgYFERkayZcsWV19KREREqphKebz17NmzZGZmVsalREREXKACnjpxwWviqwOXB43Y2FhOnDhBq1atXH0pERER16nBwx/OcDhojB8/vtR9pmmSk5PDwYMHSUhIwDAMPXUiIiJSAzkcNL766ivbGhllufrqqxk+fLijlxIREXE/PXXiEIeDxu23337RRbg8PT2pW7cunTp1omvXrlqwS0REqjf9HHOIw0HjxRdfxMND6U5ERERK53BSGDFiBE899RRpaWkVWY+IiEjVY1AwdOLUx9034R4O92js3LkTX19fAgMDK7IeERGRqklDJw5xuEfDarUSHBxckbWIiIjIJcbhoHHDDTcQHx+vFT9FRKQGMJwfOqmhYycOD508/fTTJCUlMWLECG6++WY6depEgwYN8Pb2LvWYLl26OHo5ERER99LQiUMcDhp///vfbf/85Zdf8uWXX160vWEY7N6929HLiYiIuJfW0XCIw0HDnoW6nGkvIiIi1Z/DQWPv3r0VWYeIiEjV5qGhE0fY1Q80dOhQpk2b5upaREREqiaDgjkaTn3cfRPuYVePxqZNm7Bara6uRURERC4xLn9NvIiISPVnVMBk0JrZpaGgISIiYg893uoQPasjIiIiLqMeDREREXtoHQ2H2B00du7cyQ033ODwhQzD4IcffnD4eBEREbdS0HCI3UEjJyeH48ePO3whQ2NbIiIiNY7dQSM0NJR+/fq5shYREZEqSk+dOKpcQePhhx92ZS0iIiJVl3rmHaLJoCIiIvbQHA2H6FsTERERl1GPhoiISFkMnO/RqKEjLwoaIiIi9tAcDYfYFTSmT59OcHCwq2sRERGRS4xdQaNv376urkNERKQK0+OtjtLQiYiIiD301IlD9K2JiIhUU4mJiVx11VVMmTKl1Dbr169n+PDhdOnShQ4dOnDHHXfw+eefY5pmie3z8vJYuHAh/fr1o2PHjnTu3JmRI0eyceNGh2pU0BAREbGH4eHcp4KlpKQwZswYMjMzS22zYMEChg8fzq+//kq7du2Ijo7mwIEDTJw4kWeeeaZYe9M0mTBhApMmTeLYsWPExMQQFRXF+vXrGTZsGHFxceWuU0MnIiIi9qhCT53s2bOHsWPHcvjw4VLbHDp0iKlTpxIQEEBsbCzt2rUDICkpiWHDhrF48WK6du3KTTfdZDsmLi6OZcuW0bZtW+bNm0dQUBAAGzZsYPTo0bzwwgvExMQQGhpqd63q0RAREakmUlNT+fe//82dd97J4cOHadKkSalt586di9VqZeTIkbaQARAWFsakSZNsbf5q9uzZAEycONEWMgC6dOnCsGHDyM7OJjY2tlw1K2iIiIiUyaiAoRPne0Tmz5/P3LlzqVevHu+88w633357qW1XrVoFQM+ePYvti4mJoXbt2uzYsYNTp04BkJCQwJEjRwgODqZTp07FjunVqxcAK1euLFfNChoiIiL2qAJzNBo1asSECRNYsWIF3bt3L7VdSkoKZ86cwWKxEBkZWWy/p6enbfu+ffsAiI+PB6BVq1YYJQwTFW4/cuTIReeF/C/N0RARESmLAXi4fwnyAQMG2NUuOTkZgPr16+NRSt0NGzYs0rbwz5CQkBLbe3t7ExgYSGpqKikpKYSHh9tVi4KGiIhIJUlKSuKee+4pdX95hyVKk5GRAYCPj0+pbby9vYu0vXDhgt3HFLa1h4KGiIiIParQUydlKezFKGkI5H8Vrqfh6elp9zHloaAhIiJijwqYZxEWFlZhvRYX4+/vD0BWVlapbbKzswHw8/Mr9zG+vr5216LJoCIiIpeYwnkWKSkppa4AWjgno3CuRuExp0+fLrF9dnY2aWlpGIZBgwYN7K5FQUNERKRMVePxVnsFBQUREhJCTk5OiYt6Wa1WDh48CEDr1q2L/Ll///4Sz7l//35M0yQ8PNzWC2IPBQ0RERF7GIZzn0rWtWtXAL777rti+9atW0d6ejpt2rShUaNGAERERNCsWTOSk5PZtm1bsWO+/fZbALp161auOhQ0RERELkFDhgzB09OT2bNnFwkOSUlJTJ06FYDRo0cXOWbo0KEAPPfcc6SkpNi2b9iwgfnz52OxWBgxYkS56tBkUBEREXtUs9fEt2nThnHjxvHKK68wePBgOnfujI+PDxs3biQjI4MBAwbQu3fvIscMGjSINWvWsHr1anr16kV0dDTp6els3rwZ0zSZMWNGud5zAgoaIiIiZTNwPmi44enYUaNG0aJFC+bNm8f27dsxDIMWLVowaNAg+vbtW6y9h4cHM2fO5KOPPmLx4sWsXbuWgIAAYmJiGD16NJ07dy53DYZZ2nTUGsS05kJ6krvLqBk8a2HUDsVMPwHWHHdXU3Pk2b9csDjJ0xujbnPMs4fAmu3uai59dQuW0TY8a7n0MmbWOczN/3HqHMbVIzB8giqmoGpEPRoiIiJlMipg6KT6LPhVkRQ0RERE7FGNVgatShQ0RERE7FHNJoNWFfrWRERExGXUoyEiImIP9Wg4REFDRETEHpqj4RAFDakwacknWP/J+xzY8DPnTh4HoG5YE1pd252YwSPxrxdc7JiM1LOs+eBt9q1ZSVrySXxrBxLevhPX3nM/TS7vUNm3IFKqM0cPs/aj9zn46wbO/5GCb2AdmlzWnr/1G0iLv8XYdY4f3n2ddR+9zz2vzSHyb11cXLFI1aCgIRXi8LZf+fSp0WSlp2F4elKvSQSm1UrKkUOcPjSH7d98wd2vf0BIm/a2Y86fSeE/o+/k7LEjWHx8CWnZmrTkk+z96Tv2rV3Jbf/vX3S4bYAb70qkQMLGdSx8Zhx52VlYfHxp0KwFGefOsu/nVez7eRVdBt1Lz4eeuOg54tf9xIYFH1ZSxVLx9HiroxQ0xGlZ6Wl89vRDZKWn0fKa6+gzcQa16xe8dvjs8SN88cJTHN2+hU8nPMhDn63EUrvguEUTH+XssSNEdr6W/v96E9/AOpj5+az76D1Wzvo3y16aRJPLO9CgeUs33p3UdBnnzhI3eTx52VlcfsPN3PLUc/gEFPxHvOO75Xwx7Vk2LJhHk8va065bjxLPsWvlt3wx7VnyrXmVWbpUNM3RcEi1/NYSExO56qqrmDJlirtLEWDb8jgyzv5B7QYh9J/2pi1kANRt3JS7XpqFT2AdziUdZffKrwFI3LKBw1s3UcvPnzumvIZvYB0ADA8P/j50NFf06kN+Xi4/z5vllnsSKfTb0jiy0tMICm3MP5/9ly1kAFzR8xY63nYHAFuWfFbs2Kz0NJa/8i8WPf8U1hythCs1U7ULGikpKYwZM4bMTC2pXFUkbvkFgFbXXo+3f0Cx/f51gwm/oiMAx3f/DsC2pZ8D0PofN+AXVK/YMVf3GwLA3jU/kJuV5ZK6RewRFNqYy2+8mav73oVXreLLXIe0iALg3MkTRbYf3bGVNwfewuYvFuLl7UOfp/WLUbVW+K4Tpz7uvgn3qFZDJ3v27GHs2LEcPnzY3aXIX/xj+EO07X4TweHNS2/05yt1zPx8AI7t+A2ApldeXWLzxpe1x8PTi9zMDJL27iDiqr9VbNEidrr8xpu5/MabS92ftHcXAMHhTYtsP3PkEJmp52h5zd+5edzT1GvSlK+mT3JpreJiHjU0KTipWgSN1NRU5syZw/z588nJyaFJkyYcO3bM3WXJnxq3a0/jdu1L3Z9x7g8Sf9sIQIPIKPLz8zl7/AhQMLRSEk8vC7UbhJB68jhnjhxS0JAqJys9jV8+/5htXy/Bw9OLa4eMKLK/YWQrhs+aT9P2enpKarZqETTmz5/P3LlzadSoEc8//zy7du1i5syZ7i5L7PTtq/8iNysTi48v7brfTFbqWdukOP+6xYdNCvnVCSL15HEyzp2trFJFyrR79fesfn8Wfxw/gjUnh8CGjbjlyeeIuKpo71xY2yv09tZLip46cVS1mKPRqFEjJkyYwIoVK+jevbu7y5FyWPOft9nx3VcAXDfiYfzr1Sc3K8O236uWd6nHenn7AJCbrfk4UnUc372D04cSbJM7s9LTiF+3muyMC26uTFzO2TkaNVS16NEYMEBrKVRHq+e+yU9z3wQKJn1ee88oAAwPz/82uthKe3/O6zBq8P9ApeqJ7j+YrsMfIPvCBQ78up7v336VLV9+zol9uxn57kd4eJYenqWa0/8XOaRaBA2XMwzwLD6bXByTn5fH1/9+ji2LPwagxTVd6T/9HQwvb/Dwopb/f/+POC8vv9TvPi+34DdGi6+//n6cZea7u4JLRmBoBAC1Aupy1a130uSKq5k99J8k7d3F9h9WcFWfgQUNL/bfrIcFFEgqiAGY7i5CLkJBA8DwxKgd6u4qLglZ59P47Im7OLj+BwAu630nfWd8UOSxwFr5+XjW8saak01mrkep331GWhoA/qEt9PcjVVaDus1p27MvO5Z9SuLOXXS4uzEARmDj0g+qHYpR9yJPaUm5mNZKWqNE7zpxiIIGgGnFPH/a3VVUe2mnTvDx2KEkH9gHQMw9o7nxkWcwss9gFs6J8/DCw78B9SNacGr/bs4mbMO8rE2xc1nzckk/lQRAcMN6mOknirWRcsjTWiSOykw9x9kTxwhqFFbimi8AdeoVLDh3/kQiZtpxjMDGmGnHobQfgOknMM8eclXJNUtgk0q8mIKGIxQ0oGAuQGUl4ktUekoy8x4YyNljRzA8Pen9xPNc3W8w5OeW2L7xZVdyav9ujv3+Kx1v7Vds//HtW8i35uHl7U2jllH6+3GWnn5w2Hsj+nE26Rg3jnmcawcPL7FN6omjANSuX/+//61ac0r/3vNz9XdSYTRsUtVpZos4zZqbw4InR3H22BE8LRYGTHurIGRcxGU33grA7lXfkpl6rtj+zX/O77jshluw+PhUeM0i9orsXPBm1t++isOaVzw4nztxnD1rfgSg9bVdK7U2qUSGUQErg9bMHhEFDXHa2tg5nNi7E4DeT06mbbeeZR7TvPPfaXrl1WSfT+fTCQ9y/kwKULBy6LrYOexY8RUeXhbbkyoi7nLtoHvx8vbhj2OHWTx5QpF1XU7E7+Gjxx8gLzuLiKs60fofevz+kmYYzn1qKA2diFOsuTn88ukHAHh4erFt+WK2LV9cavtWf7+B6x6dhmEY3D7pZT54YBBHtv3K632vo2FkFOmnT3H+zGkwDP45cYbe3CpuV7dxOAOm/B+Lnn+K3au/Z9/6n6gf3oy8nBzOHE0EoMll7bnzX69h1OAfJiKlUdAQp5w6EE9WWioA+dY8jm7fctH29f7yPpS6jZvyQOxS1sybRfzPK0k+sA+Ljy8tr7mOmHvup3mnLi6tXcReUdd25YF5i1j3yQcc/HUDpw8fxOLjS9P2Hbmi5y10uLUvnl4Wd5cpLqdBAEcoaIhTwtpczvO/JNh/wP+sLeAXVI+bxk3kpnETK7gykYpVr0lTbhv/vFPneH7tjgqqRtxCPVYOMUzTrPFTdk1rLqQnubuMmsGzFkbt0ILHVfUkSeXJ0zLulcbTG6Nu84LHV/VkievVjQTAcPGifmbOecz93zh1DqPVzRi1AiqooupDPRoiIiL2UI+GQxQ0REREymTg/ByNmhlUFDRERETsoR4Nh2gKrYiIiLiMejRERETsoR4NhyhoiIiI2EWDAI7QtyYiIiIuox4NERERe2joxCEKGiIiImX68+2tzp6jBtLQiYiIiLiMejRERETsUjN7JJyloCEiIlIWA+fnaNTQnKKhExEREXEZ9WiIiIjYw+nJoDWTgoaIiIgdDD3e6hAFDREREbuoR8MR+tZERETEZdSjISIiUiajAlYGrZlDLwoaIiIi9tAcDYdo6ERERERcRj0aIiIidnH/7+aHDh3ipptuumibDRs2UK9ePdu/r1+/nvfee4+9e/eSlZVFZGQkAwcOpH///pXyJI2ChoiIiD2qwNDJ7t27AWjZsiVt27YtsY23t7ftnxcsWMDkyZOxWCxER0djsVj45ZdfmDhxIr/99hvTp093ec0KGiIiItXEzp07ARg6dCh33XXXRdseOnSIqVOnEhAQQGxsLO3atQMgKSmJYcOGsXjxYrp27VpmD4mz3N8PJCIiUh0YhnOfClDYo3HFFVeU2Xbu3LlYrVZGjhxpCxkAYWFhTJo0ydbG1RQ0REREymRQ8CPTmY/zYWP37t14e3vTqlWrMtuuWrUKgJ49exbbFxMTQ+3atdmxYwenTp1yuq6LUdAQERGpBo4ePUpaWhrNmjVjwYIF9OvXjw4dOhAdHc2YMWPYvn27rW1KSgpnzpzBYrEQGRlZ7Fyenp627fv27XNp3QoaIiIiZSl8TbxTH+dKKJyfsW/fPl566SX8/f255ppr8PPzY+XKlQwaNIivvvoKgOTkZADq16+Ph0fJP+obNmxYpK2raDKoiIiIPSrg7a1JSUncc889pe5fuXJlqfv++sTJrFmziIiIACA/P5/33nuPV199lWeffZYrr7ySjIwMAHx8fEo9X+HTKYVtXUU9GiIiInYxnPw4Z+zYsXz//ffExsbaQgaAh4cHo0eP5vrrrycnJ4cFCxbYejHsWSfDNE2na7sY9WiIiIhUkrCwsIv2WlyMl5cXTZs2LXX/DTfcwKpVq9ixYwd9+/YFICsrq9T22dnZAPj5+TlUj70UNEREROxRBRbsupjQ0FAAMjMzCQkJAQomhZqmWWLPRuHcjMK5Gq6ioRMRERF7GB7OfZw0bdo0Hn74Yfbv31/i/hMnTgDQqFEjgoKCCAkJIScnh8OHDxdra7VaOXjwIACtW7d2uraLUdAQERGpBnbt2sX333/P119/XeL+L7/8EoBu3boB0LVrVwC+++67Ym3XrVtHeno6bdq0oVGjRq4p+E8KGiIiImVy9tFW5yeEDhkyBChYzfOXX36xbbdarbz88sv8+uuvNGvWjH/+85+29p6ensyePZtt27bZ2iclJTF16lQARo8e7VRN9jBMV083rQZMay6kJ7m7jJrBsxZG7VDM9BNgzXF3NTVHXqa7K6g5PL0x6jbHPHsIrNnurubSV7dg0SnDs5ZLL2PmZUPyTudO0vByDC/vsttdxPPPP8+nn36KYRhceeWVhISEsHPnTo4fP06DBg348MMPadGiha39nDlzeOWVV/D09KRz5874+PiwceNGMjIyGDBgAP/617+cuyc7KGigoFGpFDTcQ0Gj8ihoVK4aFjQAvvnmGz755BN2795NTk4OoaGhdO/enVGjRhV5PXyhlStXMm/ePHbt2oVhGDRv3pxBgwbRt2/fUhfzqkgKGihoVCoFDfdQ0Kg8ChqVqzKDxundzp2kQbsKCRrVjR5vFRERsUvVfry1qlLQEBERsUcVX0ejqtJTJyIiIuIy6tEQERGxi3o0HKGgISIiUiajAoZOamZQ0dCJiIiIuIyChoiIiLiMhk5ERETKYuD80EnNHDlRj4aIiIi4jno0RERE7FJDuyScpKAhIiJiDy3Y5RANnYiIiIjLqEdDRETELurRcISChoiIiD00dOIQBQ0RERG7KGg4QnM0RERExGXUoyEiImIPDZ04REFDRESkTAbOD53UzKCioRMRERFxGfVoiIiI2ENDJw5R0BAREbGLgoYjNHQiIiIiLqOgISIiIi6joRMREZEyGKA5Gg5Sj4aIiIi4jHo0RERE7KIeDUcoaIiIiNhDQycOUdAQERGxi4KGIzRHQ0RERFxGPRoiIiJlMQznh05q6NCLgoaIiIhdamZQcJaGTkRERMRl1KMhIiJijxo69OEsBQ0RERG7KGg4QkMnIiIi4jLq0RAREbGHhk4coqAhIiJiFwUNR2joRERERFxGPRoiIiL2UIeGQxQ0RERE7KKk4QgFDREREXtoMqhDNEdDREREXEY9GiIiImUycH7opGb2iChoiIiI2ENDJw7R0ImIiIi4jGGapunuItzNNE3Iz3N3GTWDYWB4eGHm54H+06tE+q4rj4HhacG05qLvvRJ4WAATw3Dx782mCWa+c+cwPGpkr4iChoiIiLiMhk5ERETEZRQ0RERExGUUNERERMRlFDRERETEZRQ0RERExGUUNERERMRlFDRERETEZRQ0RERExGUUNERERMRlFDRERETEZRQ0RERExGUUNERERMRlFDRERETEZRQ0pFIcOnSIJ598kuuvv5727dvTs2dPXnvtNTIyMtxdmkiFS0xM5KqrrmLKlCnuLkXE7RQ0xOW2b99Ov379WLp0KfXr16dbt25kZGTw7rvvMnDgQM6fP+/uEkUqTEpKCmPGjCEzM9PdpYhUCQoa4lJ5eXk8/vjjZGRkMG3aND7//HPefPNNfvjhB7p3786+fft49dVX3V2mSIXYs2cPgwcP5sCBA+4uRaTKUNAQl1q+fDlHjx6lS5cu9O/f37bdx8eHF198ET8/Pz777DNSU1PdWKWIc1JTU/n3v//NnXfeyeHDh2nSpIm7SxKpMhQ0xKV+/PFHAHr06FFsX926dYmOjiY3N5eff/65sksTqTDz589n7ty51KtXj3feeYfbb7/d3SWJVBkKGuJS8fHxALRu3brE/S1btgRg7969lVaTSEVr1KgREyZMYMWKFXTv3t3d5YhUKV7uLkAubcnJyQCEhISUuL9hw4ZF2olURwMGDHB3CSJVlno0xKUKH1/18fEpcX/hdj3mKiJyaVLQEJfy9PQEwDCMi7YzTbMyyhERkUqmoCEu5e/vD1DqmgJZWVkA+Pr6VlpNIiJSeRQ0xKUK52CcPn26xP2FczMK24mIyKVFQUNcqvBpk4SEhBL3F24v7akUERGp3hQ0xKW6du0KwIoVK4rtO3v2LBs3bsRisXDttddWdmkiIlIJFDTEpXr06EFYWBhr167l448/tm3Pysri2WefJSMjg/79+1O/fn03VikiIq6idTTEpXx8fJgxYwajRo1iypQpxMXF0aRJE7Zu3UpycjLt2rXjySefdHeZIiLiIurREJeLjo7m888/p1evXiQlJbF69Wpq167NmDFjiI2NJSAgwN0lioiIiximFjAQERERF1GPhoiIiLiMgoaIiIi4jIKGiIiIuIyChoiIiLiMgoaIiIi4jIKGiIiIuIyChoiIiLiMgoaIiIi4jIKGVFnHjh2jdevWpX4uv/xyrrnmGgYOHMi7777L+fPn3V2yzcaNG2115uXl2ba/9dZbtG7dmkGDBlXIdTIzMzl27FiFnKsspd3TxVT0/RZef/369RVyvotx5H5FpDgFDakWoqKi6NixY5FPmzZt8PPzY+vWrbz22mvcdtttHD582N2lVpqlS5fSq1cvNmzY4O5SRERKpZeqSbUwceJEoqOjS9y3ceNGxowZQ1JSEhMmTODTTz+t5OrsN2TIEHr37o2vr6/T53rttdc4depUBVQlIuI66tGQai86OprHH38cgK1bt7Jz5043V1S6evXq0aJFC8LCwtxdiohIpVDQkEtCjx49bP/8+++/u7ESERH5Kw2dyCWhdu3atn++cOGC7Z/vueceNm3axJw5c9i5cycff/wxFy5cIDw8nDfeeIMWLVoAkJKSwn/+8x9Wr17N8ePH8fDwIDIykltuuYUhQ4bg7e1d4nU3btzIBx98wM6dO0lPT6dVq1bce++9NGjQoMT2b731FjNnzqRjx44sWLCg2P4ff/yRzz//nF27dvHHH38QFBTE1VdfzX333cfll19e5ByFJk6cyMSJE3n44Yd55JFHbNsr654clZaWxqeffspPP/1EQkIC58+fx9fXl6ZNm3L99dczdOhQ6tSpU+rxX331FR9++CEJCQn4+Phw1VVXMXToUK699toS2+fk5LBgwQK+/vprEhISyM3NJTQ0lG7dujFy5EgaNmxYofcnIgUUNOSS8NdJoI0aNSq2/9133+W3336jadOm1K5dm/Pnz9OsWTMAtmzZwpgxYzh37hwWi4VmzZphmia7du1i586dfPnll8ydO7fYD9o5c+bw6quvYpomwcHBtGzZksTERJ544gk6d+5crvqtVitPP/00X375JQANGjQgKiqKo0eP8s033/D9998za9YsunbtSmhoKB07dmTnzp3k5OQQERFBcHAwoaGhtvNVhXu6mMTERO69915OnDiBl5cXTZs2pXHjxhw/fpxdu3axa9culi9fTlxcHP7+/sWOnzVrFr/++iv+/v60bNmSpKQkVq9ezerVq3nkkUd4+OGHi7RPTk5m1KhR7NmzB8MwCAsLIygoiISEBObNm8eSJUuYNWsWnTp1qrB7FJE/mSJV1NGjR82oqCgzKirK/OWXXy7advz48WZUVJR52WWXmadPn7Ztv/vuu23nmDNnjm37mTNnTNM0zZMnT5qdO3c2o6KizIkTJ5qpqam2NocPHzYHDBhgRkVFmYMHDy5yvc2bN5tRUVFm69atzffff9+0Wq2maZpmVlaWOXXqVNs1o6KizNzcXNtxb775phkVFWUOHDiwyPlmz55tRkVFmVdeeaW5bNkyMz8/33a+559/3oyKijKvuuoq89y5c7Zjrr/+ejMqKsr87LPPipyrsu/pYkq738K/lzvvvNM8deqUbXt+fr75xRdfmG3atDGjoqLMjz76qMhxf63hmWeeMS9cuGCapmnm5eWZs2bNsu1bv359kXPeddddZlRUlDlo0CDzwIEDtn1paWnm008/bUZFRZnR0dFmcnKybd8vv/xS7vsVkeI0R0OqraysLHbv3s3zzz/PkiVLALj33nupX79+sbaNGzfmvvvus/17vXr1AHj//fc5d+4c3bt3Z+rUqQQGBtraNG3alFmzZhEQEMDmzZv56aefbPveeecdAPr27cuIESPw8Cj4n5K3tzcTJ07kmmuusfs+cnJymDNnDgDjx4/nlltuwTAM2/kmTZpE8+bNycjI4JtvvinzfFXhni7mzJkz7N+/H4CpU6cWGbIwDIPbb7/d1nuyb9++Es/RsWNH/vWvf+Hn5weAp6cnDz74IH369AFg9uzZtrYrV65k69atNGzYkLlz5xIZGWnbV7t2baZNm8aVV17J2bNnmTdvXoXco4j8l4KGVAtDhw4ttmDXlVdeSd++fW2Psw4YMICxY8eWeHyHDh1sP7z/6ocffgCw/YD6X/Xr17eN+a9atQooWCRr48aNQMEP5ZIMHDjQ7nvbvHkz6enpWCwW+vXrV2y/h4cHc+bMYfXq1dx1111lnq8q3NPFBAcH88svv/D7778TFRVVbL/VaiUgIAAoCJMlGTJkSIl/n3feeScAv/76KxkZGcB/v48bb7zRFkz+yjAM23dV+H2ISMXRHA2pFqKiomw/fKDgh4O3tzdBQUG0bt2aG2+8kZYtW5Z6fEkTGS9cuMDx48eBgjH/+fPnl3hsYZuDBw8CkJSURE5ODgCtWrUq8Zi2bdvacVcFCueXNG/eHB8fnxLbNG3a1K5zVZV7soePjw8nTpzg999/58iRIxw9epQDBw6wZ88eW0jIz88v8dh27dqVuL1169YA5OXlcfjwYdq2bUt8fDxQECL27t1b4nFpaWlAwdwR0zRLDDEi4hgFDakWLrZglz1KesLir0uWF/4wupj09HQAUlNTbdtKmqgIFBmuKMu5c+cASvxtu7yqyj2V5eDBg7z88sv89NNPRcJEQEAAV199NcnJyaWGgovV+NftmZmZwH+/kxMnTnDixImL1mW1Wrlw4UKRUCsizlHQkBrrr6tzLl26tMRu/JIEBQXZ/vn8+fO2+R5/lZ2dXe46/vpYrqOqyj1dzJkzZ7j77rs5c+YMYWFh3HnnnbRr147IyEiaNGmCYRg88cQTFw0ahT0e/6swOAG2R2MLv5PnnnuOu+++u0LuQUTspzkaUmMFBgbaJo4mJCSU2m7fvn3s2bPH9lt/WFiYbYhj9+7dJR5TONnRHs2bNwcKhlBK+2G+YMEC7r33Xt5///2Lnquq3NPFxMXFcebMGYKCgoiLi+PBBx+ka9euhIeH24YsylpavXDI538V1u7t7W0bbir8fi9W/4kTJ9i2bRvJycnlvh8RuTgFDanRunXrBsBHH31U4nyA9PR0hg0bxu23386HH34IFMwtuO666wBKXHQL4PPPP7e7hk6dOuHn50dOTg5Lly4ttj8/P59FixaxYcOGIr/JF/5QNk2zyt3TxRS+bTYsLKzEnpOEhAS2bdsGFAxllCQuLq7E7bGxsQBcd911WCwWAK6//noAvv76a86cOVPicc888wx33XWXbSl7Eak4ChpSo40aNQo/Pz+2bNnCU089xR9//GHbd/z4cUaNGsXZs2epXbs2Q4YMse175JFHsFgs/PDDD/z73/+2TaTMzc3ljTfe4LvvvrO7hoCAAO69914Apk+fzo8//mjbl5WVxbRp09i5cycBAQFFnjopnNNROLGzKt3TxRQ+Xrp3715WrFhh226aJmvWrOG+++4jNzcX+O88i/+1cuVKXn31VVuNOTk5vPTSS/z4449YLBYeeughW9vevXsTFRVFWloaI0eOLNKzcf78eSZPnsz69esxDINRo0ZVyD2KyH9pjobUaBEREbz++us89thjLFu2jBUrVtCyZUtyc3NJTEwkLy8PPz8/5syZQ3BwsO24qKgoXnzxRZ555hnmzp3L559/TtOmTTl69Cjnzp2jR48efP/993bX8dBDD3Ho0CG++eYbHnzwQUJDQ6lXrx6JiYlcuHABHx8fXn311SJrTrRr1474+Hjmzp3LmjVr6NGjB2PGjKky91Sa/v3788knn3D48GEeffRRGjduTN26dTlx4gRnzpzBYrHQuXNnNm3aVOoQSq9evZg9ezYLFy6kSZMmHD16lNTUVCwWC9OnTy/yhIzFYmHWrFncd9997Nmzh1tvvZXmzZvj6+tLYmKirZfo6aeftvXqiEjFUdCQGq9r164sX76cefPm8fPPP3Po0CGsViuNGzfm2muvZcSIEYSHhxc7rk+fPrRq1Yq5c+fy66+/sm/fPiIiInjkkUe44YYbyvVD2cvLi9dee42ePXuyaNEidu3axb59+wgODqZXr16MGjXKNteg0IQJE8jMzGT9+vUcPHiQAwcOVKl7Kk1AQACLFi3ivffeY9WqVRw7doyUlBQaNWpEt27dGDZsGH5+ftx4443s3buXpKSkYm+7LXwKacGCBcTHxxMQEEDv3r0ZPXo0bdq0KXbN8PBwvvjiCxYsWMCKFSs4cOAAWVlZ1K1bl3/84x/cc889/O1vf3P63kSkOMP83wFeERERkQqiORoiIiLiMgoaIiIi4jIKGiIiIuIyChoiIiLiMgoaIiIi4jIKGiIiIuIyChoiIiLiMgoaIiIi4jIKGiIiIuIyChoiIiLiMgoaIiIi4jIKGiIiIuIyChoiIiLiMgoaIiIi4jL/H6GpRbjNxUH3AAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Your conclusions here:\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Bonus Challenge - Feature Scaling\n",
-    "\n",
-    "Problem-solving in machine learning is iterative. You can improve your model prediction with various techniques (there is a sweetspot for the time you spend and the improvement you receive though). Now you've completed only one iteration of ML analysis. There are more iterations you can conduct to make improvements. In order to be able to do that, you will need deeper knowledge in statistics and master more data analysis techniques. In this bootcamp, we don't have time to achieve that advanced goal. But you will make constant efforts after the bootcamp to eventually get there.\n",
     "\n",
-    "However, now we do want you to learn one of the advanced techniques which is called *feature scaling*. The idea of feature scaling is to standardize/normalize the range of independent variables or features of the data. This can make the outliers more apparent so that you can remove them. This step needs to happen during Challenge 6 after you split the training and test data because you don't want to split the data again which makes it impossible to compare your results with and without feature scaling. For general concepts about feature scaling, click [here](https://en.wikipedia.org/wiki/Feature_scaling). To read deeper, click [here](https://medium.com/greyatom/why-how-and-when-to-scale-your-features-4b30ab09db5e).\n",
     "\n",
-    "In the next cell, attempt to improve your model prediction accuracy by means of feature scaling. A library you can utilize is `sklearn.preprocessing.RobustScaler` ([documentation](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.RobustScaler.html)). You'll use the `RobustScaler` to fit and transform your `X_train`, then transform `X_test`. You will use logistic regression to fit and predict your transformed data and obtain the accuracy score in the same way. Compare the accuracy score with your normalized data with the previous accuracy data. Is there an improvement?"
+    "cm = confusion_matrix(y_test, predictions)\n",
+    "disp = ConfusionMatrixDisplay(confusion_matrix=cm)\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "disp.plot(cmap='Oranges')  \n",
+    "plt.grid(True)\n",
+    "plt.show()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here"
+    "#We can conclude that the model improves with the k = 5 therefore we decide to keep this one."
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "ironhack-3.7",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
-   "name": "ironhack-3.7"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -669,9 +4206,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.3"
+   "version": "3.12.4"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }