diff --git a/your-code/main.ipynb b/your-code/main.ipynb
index a5caf8b..72b6889 100755
--- a/your-code/main.ipynb
+++ b/your-code/main.ipynb
@@ -20,8 +20,240 @@
     "\n",
     "%matplotlib inline\n",
     "\n",
+    "# 📚 Basic Libraries\n",
+    "import pandas as pd\n",
     "import numpy as np\n",
-    "import pandas as pd"
+    "import datetime as datetime\n",
+    "\n",
+    "# 📊 Visualizations\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "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",
+    "# 🎯 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",
+    "    nan_pct = round((data.isna().sum()/len(data)*100),2)\n",
+    "    import pandas as pd\n",
+    "    exploration = pd.DataFrame({\"NaN\": nan_values, \"NaN %\": nan_pct, \"EmptySpaces\": empty_spaces}) # New dataframe with the results\n",
+    "    print(f\"There are {duplicate_rows} duplicate rows. Also;\")\n",
+    "    return exploration\n",
+    "\n",
+    "def outliers(data, threshold = 1.5, result = \"outliers\"): \n",
+    "    \"\"\"\n",
+    "    Identifies the outliers in each column and returns a dataframe with only the outliers.\n",
+    "\n",
+    "    If the parameter result = \"slayed\" it returns the dataframe passed in without outliers\n",
+    "    \"\"\"\n",
+    "    import numpy as np\n",
+    "    import pandas as pd\n",
+    "    outliers=[]\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",
+    "        if result == \"slayed\":\n",
+    "            data = data[(data[column] >= lower_bound) & (data[column] <= upper_bound)]\n",
+    "        else:\n",
+    "            outliers.append(data[(data[column] < lower_bound) | (data[column] > upper_bound)])\n",
+    "    if result == \"slayed\":\n",
+    "        return data\n",
+    "    else:\n",
+    "        outliers_df = pd.concat(outliers).drop_duplicates()\n",
+    "        return outliers_df\n",
+    "\n",
+    "\n",
+    "def evaluate_regresion_model(df, target, size=0.3, random=42, shuff=True, round_digits=4):\n",
+    "    \"\"\"\n",
+    "    Function to automatically evaluate ML regresion models and returns a df with the comparison\n",
+    "    \"\"\"\n",
+    "    from sklearn.model_selection import train_test_split\n",
+    "    from sklearn.linear_model import LinearRegression, Ridge, Lasso\n",
+    "    import xgboost as xgb\n",
+    "    from sklearn.neighbors import KNeighborsRegressor\n",
+    "    from sklearn.tree import DecisionTreeRegressor\n",
+    "    from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error, root_mean_squared_error\n",
+    "    import pandas as pd\n",
+    "\n",
+    "    # Definition of the models\n",
+    "    models = {\n",
+    "        'Linear Regression': LinearRegression(),\n",
+    "        'Ridge': Ridge(),\n",
+    "        'Lasso': Lasso(),\n",
+    "        'Decision Tree': DecisionTreeRegressor(),\n",
+    "        'KNN': KNeighborsRegressor(),\n",
+    "        'XGBoost': xgb.XGBRegressor()\n",
+    "        }\n",
+    "\n",
+    "    metrics = {\n",
+    "        'Model': [],\n",
+    "        'R²': [],\n",
+    "        'RMSE': [],\n",
+    "        'MSE': [],\n",
+    "        'MAE': []\n",
+    "        }\n",
+    "    \n",
+    "    # Separate features and target\n",
+    "    X = df.drop(columns=[target])\n",
+    "    y = df[target]\n",
+    "\n",
+    "    # Separate data into train and test:\n",
+    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = size, random_state = random, shuffle = shuff)\n",
+    "\n",
+    "    #Run all the models and store the results\n",
+    "    for key, model in models.items():\n",
+    "        model.fit(X_train, y_train)\n",
+    "        predictions = model.predict(X_test)\n",
+    "        metrics['Model'].append(key)\n",
+    "        metrics['R²'].append(r2_score(y_test, predictions))\n",
+    "        metrics['RMSE'].append(root_mean_squared_error(y_test, predictions))\n",
+    "        metrics['MSE'].append(mean_squared_error(y_test, predictions))\n",
+    "        metrics['MAE'].append(mean_absolute_error(y_test, predictions))\n",
+    "\n",
+    "    df_metrics = round(pd.DataFrame(metrics),round_digits)\n",
+    "    return df_metrics.set_index(\"Model\").T\n",
+    "\n",
+    "def range_verifier(value):\n",
+    "    return isinstance(value, range)\n",
+    "\n",
+    "def evaluate_clasification_model(df, target, size=0.3, random=42, shuff=True, neighbors=3, trees=3):\n",
+    "    \"\"\"\n",
+    "    Function to automatically evaluate ML clasification models and shows results.\n",
+    "    Parameters neighbors and tree can be:\n",
+    "     - integers to define the number of neighbors and depth of tree levels\n",
+    "     - ranges (ex. range(5, 30)) to tune the parameter\n",
+    "    \"\"\"\n",
+    "    from sklearn.model_selection import train_test_split\n",
+    "    from sklearn.linear_model import LogisticRegression \n",
+    "    import xgboost as xgb\n",
+    "    from sklearn.neighbors import KNeighborsClassifier\n",
+    "    from sklearn.tree import DecisionTreeClassifier\n",
+    "    from sklearn.svm import LinearSVC\n",
+    "    from sklearn.metrics import roc_curve, confusion_matrix, ConfusionMatrixDisplay, classification_report\n",
+    "    import matplotlib.pyplot as plt\n",
+    "\n",
+    "    # Separate features and target\n",
+    "    X = df.drop(columns=[target])\n",
+    "    y = df[target]\n",
+    "\n",
+    "    # Separate data into train and test:\n",
+    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = size, random_state = random, shuffle = shuff)\n",
+    "\n",
+    "    # Determine the optimal number of neighbors if `neighbors` is a range\n",
+    "    if range_verifier(neighbors) == False:\n",
+    "        num_neighbors = neighbors\n",
+    "    else:\n",
+    "        n_test = {}\n",
+    "        for neighbor in neighbors:\n",
+    "            model = KNeighborsClassifier(n_neighbors=neighbor)\n",
+    "            model.fit(X_train, y_train)\n",
+    "            n_test[neighbor] = model.score(X_test,y_test)\n",
+    "        num_neighbors = max(n_test, key=n_test.get)\n",
+    "\n",
+    "    # Determine the optimal tree depth if `trees` is a range\n",
+    "    if range_verifier(trees) == False:\n",
+    "        num_trees = trees\n",
+    "    else:\n",
+    "        t_test = {}\n",
+    "        for tree in trees:\n",
+    "            model = DecisionTreeClassifier(max_depth=tree)\n",
+    "            model.fit(X_train, y_train)\n",
+    "            t_test[tree] = model.score(X_test,y_test)\n",
+    "        num_trees = max(t_test, key=t_test.get)\n",
+    "\n",
+    "    # Definition of the models\n",
+    "    models = {\n",
+    "        'Logistic Regression': LogisticRegression(),\n",
+    "        'KNN': KNeighborsClassifier(n_neighbors=num_neighbors),\n",
+    "        'Decision Tree': DecisionTreeClassifier(max_depth=num_trees),\n",
+    "        'SVM': LinearSVC(),\n",
+    "        'XGBoost': xgb.XGBClassifier()\n",
+    "        }\n",
+    "    \n",
+    "    #Run all the models and store the results\n",
+    "    for key, model in models.items():\n",
+    "        model.fit(X_train, y_train)\n",
+    "        predictions = model.predict(X_test)\n",
+    "        print(\"\\n---------------------------------------------------\\n\")\n",
+    "        print(key) # Print the model name\n",
+    "        if key == \"KNN\":\n",
+    "            print(f\"with {num_neighbors} neighbors\")\n",
+    "        elif key == \"Decision Tree\":\n",
+    "            print(f\"with {num_trees} maximum depth\")\n",
+    "        \n",
+    "        print(classification_report(y_test, predictions)) # Print the model clasification report\n",
+    "        \n",
+    "        # Print the acurracy of test and train\n",
+    "        print(\"Test data accuracy: \",model.score(X_test,y_test))\n",
+    "        print(\"Train data accuracy: \", model.score(X_train, y_train))\n",
+    "        \n",
+    "        # Calculate and displays the confusion matrix\n",
+    "        cm = confusion_matrix(y_test, predictions)\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",
+    "        if key == \"KNN\":\n",
+    "            plt.title(f'{key} Confusion Matrix with {num_neighbors} neighbors')\n",
+    "        elif key == \"Decision Tree\":\n",
+    "            plt.title(f'{key} Confusion Matrix with {num_trees} maximum depth')\n",
+    "        else:\n",
+    "            plt.title(f'{key} Confusion Matrix')\n",
+    "        plt.grid(False)\n",
+    "        plt.show()\n",
+    "\n",
+    "        # Calculate and displays the ROC curve\n",
+    "        fpr, tpr, thresholds = roc_curve(y_test, predictions, pos_label=1)\n",
+    "        plt.figure(figsize=(8, 6))\n",
+    "        plt.plot(fpr, tpr, color='orange', lw=2, label='ROC curve')\n",
+    "        plt.xlabel('False Positive Rate')\n",
+    "        plt.ylabel('True Positive Rate')\n",
+    "        plt.title(f'{key} Receiver Operating Characteristic (ROC) Curve')\n",
+    "        plt.legend(loc=\"lower right\")\n",
+    "        plt.grid(False)\n",
+    "        plt.show()\n",
+    "\n",
+    "def correlation_matrix(df):\n",
+    "    import numpy as np\n",
+    "    import matplotlib.pyplot as plt\n",
+    "    import seaborn as sns\n",
+    "    data = df.select_dtypes(include=[np.number])\n",
+    "    num_corr = round(data.corr(), 2)\n",
+    "    # Correlation Matrix-Heatmap Plot\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()"
    ]
   },
   {
@@ -37,7 +269,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -65,20 +297,307 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code here\n"
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data shape is (1781, 21).\n",
+      "\n",
+      "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\n",
+      "\n",
+      "Data row sample and full columns:\n"
+     ]
+    },
+    {
+     "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>...</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>822</th>\n",
+       "      <td>M0_146</td>\n",
+       "      <td>48</td>\n",
+       "      <td>11</td>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>640.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1</td>\n",
+       "      <td>4</td>\n",
+       "      <td>2912</td>\n",
+       "      <td>31</td>\n",
+       "      <td>25</td>\n",
+       "      <td>3753</td>\n",
+       "      <td>3494</td>\n",
+       "      <td>31</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>728</th>\n",
+       "      <td>B0_730</td>\n",
+       "      <td>45</td>\n",
+       "      <td>9</td>\n",
+       "      <td>iso-8859-1</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>US</td>\n",
+       "      <td>WA</td>\n",
+       "      <td>20/07/1998 4:00</td>\n",
+       "      <td>21/02/2017 3:57</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>805</td>\n",
+       "      <td>12</td>\n",
+       "      <td>11</td>\n",
+       "      <td>1087</td>\n",
+       "      <td>1099</td>\n",
+       "      <td>12</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1509</th>\n",
+       "      <td>M4_72</td>\n",
+       "      <td>82</td>\n",
+       "      <td>17</td>\n",
+       "      <td>utf-8</td>\n",
+       "      <td>Microsoft-IIS/6.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>US</td>\n",
+       "      <td>California</td>\n",
+       "      <td>18/06/2003 0:00</td>\n",
+       "      <td>14/06/2016 0:00</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>186</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>287</th>\n",
+       "      <td>B0_144</td>\n",
+       "      <td>35</td>\n",
+       "      <td>6</td>\n",
+       "      <td>us-ascii</td>\n",
+       "      <td>Microsoft-IIS/7.5</td>\n",
+       "      <td>324.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>21/03/2014 0:00</td>\n",
+       "      <td>22/03/2017 0:00</td>\n",
+       "      <td>...</td>\n",
+       "      <td>15</td>\n",
+       "      <td>8</td>\n",
+       "      <td>1527</td>\n",
+       "      <td>24</td>\n",
+       "      <td>25</td>\n",
+       "      <td>1928</td>\n",
+       "      <td>1699</td>\n",
+       "      <td>24</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1386</th>\n",
+       "      <td>B0_1371</td>\n",
+       "      <td>71</td>\n",
+       "      <td>13</td>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>Server</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>US</td>\n",
+       "      <td>NV</td>\n",
+       "      <td>1/11/1994 0:00</td>\n",
+       "      <td>30/04/2014 0:00</td>\n",
+       "      <td>...</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",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 21 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "          url  url_length  number_special_characters     charset  \\\n",
+       "822    M0_146          48                         11       UTF-8   \n",
+       "728    B0_730          45                          9  iso-8859-1   \n",
+       "1509    M4_72          82                         17       utf-8   \n",
+       "287    B0_144          35                          6    us-ascii   \n",
+       "1386  B0_1371          71                         13       UTF-8   \n",
+       "\n",
+       "                 server  content_length whois_country whois_statepro  \\\n",
+       "822               nginx           640.0           NaN            NaN   \n",
+       "728               nginx             NaN            US             WA   \n",
+       "1509  Microsoft-IIS/6.0             NaN            US     California   \n",
+       "287   Microsoft-IIS/7.5           324.0           NaN            NaN   \n",
+       "1386             Server             NaN            US             NV   \n",
+       "\n",
+       "        whois_regdate whois_updated_date  ...  dist_remote_tcp_port  \\\n",
+       "822               NaN                NaN  ...                     1   \n",
+       "728   20/07/1998 4:00    21/02/2017 3:57  ...                     0   \n",
+       "1509  18/06/2003 0:00    14/06/2016 0:00  ...                     0   \n",
+       "287   21/03/2014 0:00    22/03/2017 0:00  ...                    15   \n",
+       "1386   1/11/1994 0:00    30/04/2014 0:00  ...                     0   \n",
+       "\n",
+       "      remote_ips  app_bytes  source_app_packets  remote_app_packets  \\\n",
+       "822            4       2912                  31                  25   \n",
+       "728            2        805                  12                  11   \n",
+       "1509           0          0                   0                   3   \n",
+       "287            8       1527                  24                  25   \n",
+       "1386           0          0                   0                   0   \n",
+       "\n",
+       "      source_app_bytes  remote_app_bytes  app_packets  dns_query_times  type  \n",
+       "822               3753              3494           31              8.0     1  \n",
+       "728               1087              1099           12              4.0     0  \n",
+       "1509               186                 0            0              0.0     1  \n",
+       "287               1928              1699           24              2.0     0  \n",
+       "1386                 0                 0            0              0.0     0  \n",
+       "\n",
+       "[5 rows x 21 columns]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "snake_columns(websites)\n",
+    "open_data(websites)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "type\n",
+       "0    1565\n",
+       "1     216\n",
+       "Name: count, dtype: int64"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# Your comment here"
+    "websites.type.value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nThe target column is type, the rest are features\\nIn column type (target):\\n    - 0 means beningn\\n    - 1 means malign\\nWe have to transform whois_regdate & whois_updated_date to ordinal\\n'"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "The target column is type, the rest are features\n",
+    "In column type (target):\n",
+    "    - 0 means beningn\n",
+    "    - 1 means malign\n",
+    "We have to transform whois_regdate & whois_updated_date to ordinal\n",
+    "\"\"\""
    ]
   },
   {
@@ -102,20 +621,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2500x1500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# Your code here\n"
+    "correlation_matrix(websites)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your comment here"
+    "# We have to drop: url_length, source_app_packets, remote_app_packets, app_packets, remote_app_bytes"
    ]
   },
   {
@@ -133,29 +663,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "df2 = websites.drop(columns=[\"url_length\", \"source_app_packets\", \"remote_app_packets\", \"app_packets\", \"remote_app_bytes\"])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your comment here"
+    "#from the column pairs that have colinearity (over 0.9) we remove the ones that have less correlation with the target "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 11,
    "metadata": {},
-   "outputs": [],
+   "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"
+    "correlation_matrix(df2)"
    ]
   },
   {
@@ -169,11 +710,170 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code here\n"
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "There are 0 duplicate rows. Also;\n"
+     ]
+    },
+    {
+     "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>NaN</th>\n",
+       "      <th>NaN %</th>\n",
+       "      <th>EmptySpaces</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>url</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>number_special_characters</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>charset</th>\n",
+       "      <td>7</td>\n",
+       "      <td>0.39</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>server</th>\n",
+       "      <td>176</td>\n",
+       "      <td>9.88</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>content_length</th>\n",
+       "      <td>812</td>\n",
+       "      <td>45.59</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>whois_country</th>\n",
+       "      <td>306</td>\n",
+       "      <td>17.18</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>whois_statepro</th>\n",
+       "      <td>362</td>\n",
+       "      <td>20.33</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>whois_regdate</th>\n",
+       "      <td>127</td>\n",
+       "      <td>7.13</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>whois_updated_date</th>\n",
+       "      <td>139</td>\n",
+       "      <td>7.80</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>tcp_conversation_exchange</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>dist_remote_tcp_port</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>remote_ips</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>app_bytes</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>source_app_bytes</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>dns_query_times</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.06</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>type</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                           NaN  NaN %  EmptySpaces\n",
+       "url                          0   0.00            0\n",
+       "number_special_characters    0   0.00            0\n",
+       "charset                      7   0.39            0\n",
+       "server                     176   9.88            0\n",
+       "content_length             812  45.59            0\n",
+       "whois_country              306  17.18            0\n",
+       "whois_statepro             362  20.33            0\n",
+       "whois_regdate              127   7.13            0\n",
+       "whois_updated_date         139   7.80            0\n",
+       "tcp_conversation_exchange    0   0.00            0\n",
+       "dist_remote_tcp_port         0   0.00            0\n",
+       "remote_ips                   0   0.00            0\n",
+       "app_bytes                    0   0.00            0\n",
+       "source_app_bytes             0   0.00            0\n",
+       "dns_query_times              1   0.06            0\n",
+       "type                         0   0.00            0"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "explore_data(df2)"
    ]
   },
   {
@@ -187,20 +887,54 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "df2.drop(columns=[\"content_length\"], inplace=True)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\FernandoSanz-Extreme\\AppData\\Local\\Temp\\ipykernel_45072\\2509464592.py:1: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
+      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
+      "\n",
+      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
+      "\n",
+      "\n",
+      "  df2[\"dns_query_times\"].interpolate(inplace=True)\n"
+     ]
+    }
+   ],
+   "source": [
+    "df2[\"dns_query_times\"].interpolate(inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for column in df2.select_dtypes(exclude=[np.number]):\n",
+    "    df2[column] = df2[column].fillna(\"unkown\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your comment here"
+    "# We have dropped the column with almost half of missing values, we have interpolated the missing value of dns_query_times.\n",
+    "# We have filled the NaNs of the categorical columns with \"Unknown\""
    ]
   },
   {
@@ -214,11 +948,164 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 17,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Examine missing values in each column\n"
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "There are 0 duplicate rows. Also;\n"
+     ]
+    },
+    {
+     "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>NaN</th>\n",
+       "      <th>NaN %</th>\n",
+       "      <th>EmptySpaces</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>url</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>number_special_characters</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>charset</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>server</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>whois_country</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>whois_statepro</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>whois_regdate</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>whois_updated_date</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>tcp_conversation_exchange</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>dist_remote_tcp_port</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>remote_ips</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>app_bytes</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>source_app_bytes</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>dns_query_times</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>type</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                           NaN  NaN %  EmptySpaces\n",
+       "url                          0    0.0            0\n",
+       "number_special_characters    0    0.0            0\n",
+       "charset                      0    0.0            0\n",
+       "server                       0    0.0            0\n",
+       "whois_country                0    0.0            0\n",
+       "whois_statepro               0    0.0            0\n",
+       "whois_regdate                0    0.0            0\n",
+       "whois_updated_date           0    0.0            0\n",
+       "tcp_conversation_exchange    0    0.0            0\n",
+       "dist_remote_tcp_port         0    0.0            0\n",
+       "remote_ips                   0    0.0            0\n",
+       "app_bytes                    0    0.0            0\n",
+       "source_app_bytes             0    0.0            0\n",
+       "dns_query_times              0    0.0            0\n",
+       "type                         0    0.0            0"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Examine missing values in each column\n",
+    "explore_data(df2)"
    ]
   },
   {
@@ -256,11 +1143,82 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 18,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code here\n"
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\FernandoSanz-Extreme\\AppData\\Local\\Temp\\ipykernel_45072\\4226028702.py:1: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
+      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
+      "\n",
+      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
+      "\n",
+      "\n",
+      "  df2[\"whois_country\"].replace([\"[u'GB'; u'UK']\", \"United Kingdom\", \"GB\"], \"UK\", inplace=True)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "whois_country\n",
+       "US        1106\n",
+       "UNKOWN     306\n",
+       "CA          84\n",
+       "ES          63\n",
+       "UK          35\n",
+       "AU          35\n",
+       "PA          21\n",
+       "JP          11\n",
+       "CN          10\n",
+       "IN          10\n",
+       "FR           9\n",
+       "CZ           9\n",
+       "NL           6\n",
+       "CH           6\n",
+       "RU           6\n",
+       "KR           5\n",
+       "AT           4\n",
+       "SE           4\n",
+       "BS           4\n",
+       "PH           4\n",
+       "BE           3\n",
+       "HK           3\n",
+       "TR           3\n",
+       "DE           3\n",
+       "KY           3\n",
+       "SC           3\n",
+       "UA           2\n",
+       "CYPRUS       2\n",
+       "UY           2\n",
+       "KG           2\n",
+       "BR           2\n",
+       "NO           2\n",
+       "IL           2\n",
+       "SI           2\n",
+       "LV           1\n",
+       "PK           1\n",
+       "IT           1\n",
+       "LU           1\n",
+       "BY           1\n",
+       "AE           1\n",
+       "IE           1\n",
+       "UG           1\n",
+       "TH           1\n",
+       "Name: count, dtype: int64"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df2[\"whois_country\"].replace([\"[u'GB'; u'UK']\", \"United Kingdom\", \"GB\"], \"UK\", inplace=True)\n",
+    "df2[\"whois_country\"].replace(\"CYPRUS\", \"CY\", inplace=True)\n",
+    "df2[\"whois_country\"] = df2[\"whois_country\"].str.upper()\n",
+    "df2[\"whois_country\"].value_counts()"
    ]
   },
   {
@@ -278,11 +1236,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 19,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# Your code here\n"
+    "sns.barplot(data=df2[\"whois_country\"].value_counts().head(10), errorbar=None)\n",
+    "plt.xticks(rotation = 90)\n",
+    "plt.show;"
    ]
   },
   {
@@ -294,13 +1265,37 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 20,
    "metadata": {
     "scrolled": true
    },
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "countries = list(df2[\"whois_country\"].value_counts().head(11).index)\n",
+    "countries.remove(\"UNKOWN\")\n",
+    "df2[\"whois_country\"] = df2[\"whois_country\"].apply(lambda x: \"OTHER\" if x not in countries else x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.barplot(data=df2[\"whois_country\"].value_counts(), errorbar=None)\n",
+    "plt.xticks(rotation = 90)\n",
+    "plt.show;"
    ]
   },
   {
@@ -316,11 +1311,155 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code here\n"
+   "execution_count": 22,
+   "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>number_special_characters</th>\n",
+       "      <th>charset</th>\n",
+       "      <th>server</th>\n",
+       "      <th>whois_country</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_bytes</th>\n",
+       "      <th>dns_query_times</th>\n",
+       "      <th>type</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1011</th>\n",
+       "      <td>B0_1188</td>\n",
+       "      <td>9</td>\n",
+       "      <td>us-ascii</td>\n",
+       "      <td>Microsoft-HTTPAPI/2.0</td>\n",
+       "      <td>US</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>283</th>\n",
+       "      <td>M0_165</td>\n",
+       "      <td>8</td>\n",
+       "      <td>ISO-8859-1</td>\n",
+       "      <td>cloudflare-nginx</td>\n",
+       "      <td>OTHER</td>\n",
+       "      <td>15</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1850</td>\n",
+       "      <td>2970</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1704</th>\n",
+       "      <td>B0_411</td>\n",
+       "      <td>19</td>\n",
+       "      <td>ISO-8859-1</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>US</td>\n",
+       "      <td>47</td>\n",
+       "      <td>10</td>\n",
+       "      <td>10</td>\n",
+       "      <td>4284</td>\n",
+       "      <td>28130</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>425</th>\n",
+       "      <td>B0_1061</td>\n",
+       "      <td>8</td>\n",
+       "      <td>utf-8</td>\n",
+       "      <td>YouTubeFrontEnd</td>\n",
+       "      <td>US</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>1090</th>\n",
+       "      <td>B0_853</td>\n",
+       "      <td>9</td>\n",
+       "      <td>ISO-8859-1</td>\n",
+       "      <td>Apache</td>\n",
+       "      <td>OTHER</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",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "          url  number_special_characters     charset                 server  \\\n",
+       "1011  B0_1188                          9    us-ascii  Microsoft-HTTPAPI/2.0   \n",
+       "283    M0_165                          8  ISO-8859-1       cloudflare-nginx   \n",
+       "1704   B0_411                         19  ISO-8859-1                  nginx   \n",
+       "425   B0_1061                          8       utf-8        YouTubeFrontEnd   \n",
+       "1090   B0_853                          9  ISO-8859-1                 Apache   \n",
+       "\n",
+       "     whois_country  tcp_conversation_exchange  dist_remote_tcp_port  \\\n",
+       "1011            US                          0                     0   \n",
+       "283          OTHER                         15                     1   \n",
+       "1704            US                         47                    10   \n",
+       "425             US                          0                     0   \n",
+       "1090         OTHER                          0                     0   \n",
+       "\n",
+       "      remote_ips  app_bytes  source_app_bytes  dns_query_times  type  \n",
+       "1011           0          0                 0              0.0     0  \n",
+       "283            2       1850              2970              6.0     1  \n",
+       "1704          10       4284             28130              6.0     0  \n",
+       "425            0          0                 0              0.0     0  \n",
+       "1090           0          0                 0              0.0     0  "
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df2.drop(columns=[\"whois_statepro\", \"whois_regdate\", \"whois_updated_date\"], inplace=True)\n",
+    "df2.sample(5)"
    ]
   },
   {
@@ -334,11 +1473,34 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code here\n"
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "url                           object\n",
+       "number_special_characters      int64\n",
+       "charset                       object\n",
+       "server                        object\n",
+       "whois_country                 object\n",
+       "tcp_conversation_exchange      int64\n",
+       "dist_remote_tcp_port           int64\n",
+       "remote_ips                     int64\n",
+       "app_bytes                      int64\n",
+       "source_app_bytes               int64\n",
+       "dns_query_times              float64\n",
+       "type                           int64\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df2.dtypes\n"
    ]
   },
   {
@@ -350,11 +1512,156 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 24,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code here\n"
+   "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>number_special_characters</th>\n",
+       "      <th>charset</th>\n",
+       "      <th>server</th>\n",
+       "      <th>whois_country</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_bytes</th>\n",
+       "      <th>dns_query_times</th>\n",
+       "      <th>type</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1751</th>\n",
+       "      <td>22</td>\n",
+       "      <td>ISO-8859-1</td>\n",
+       "      <td>Apache/2.2.15 (CentOS) DAV/2 mod_ssl/2.2.15 Op...</td>\n",
+       "      <td>US</td>\n",
+       "      <td>70</td>\n",
+       "      <td>2</td>\n",
+       "      <td>6</td>\n",
+       "      <td>5398</td>\n",
+       "      <td>137144</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1419</th>\n",
+       "      <td>13</td>\n",
+       "      <td>iso-8859-1</td>\n",
+       "      <td>Apache/2.2.15 (CentOS)</td>\n",
+       "      <td>US</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>1414</th>\n",
+       "      <td>14</td>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>nginx</td>\n",
+       "      <td>PA</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>679</th>\n",
+       "      <td>9</td>\n",
+       "      <td>iso-8859-1</td>\n",
+       "      <td>Apache</td>\n",
+       "      <td>OTHER</td>\n",
+       "      <td>9</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>870</td>\n",
+       "      <td>5876</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>495</th>\n",
+       "      <td>9</td>\n",
+       "      <td>UTF-8</td>\n",
+       "      <td>Apache</td>\n",
+       "      <td>PA</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",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      number_special_characters     charset  \\\n",
+       "1751                         22  ISO-8859-1   \n",
+       "1419                         13  iso-8859-1   \n",
+       "1414                         14       UTF-8   \n",
+       "679                           9  iso-8859-1   \n",
+       "495                           9       UTF-8   \n",
+       "\n",
+       "                                                 server whois_country  \\\n",
+       "1751  Apache/2.2.15 (CentOS) DAV/2 mod_ssl/2.2.15 Op...            US   \n",
+       "1419                             Apache/2.2.15 (CentOS)            US   \n",
+       "1414                                              nginx            PA   \n",
+       "679                                              Apache         OTHER   \n",
+       "495                                              Apache            PA   \n",
+       "\n",
+       "      tcp_conversation_exchange  dist_remote_tcp_port  remote_ips  app_bytes  \\\n",
+       "1751                         70                     2           6       5398   \n",
+       "1419                          0                     0           0          0   \n",
+       "1414                          0                     0           0          0   \n",
+       "679                           9                     0           2        870   \n",
+       "495                           0                     0           0          0   \n",
+       "\n",
+       "      source_app_bytes  dns_query_times  type  \n",
+       "1751            137144              4.0     0  \n",
+       "1419                 0              0.0     0  \n",
+       "1414                 0              0.0     0  \n",
+       "679               5876              2.0     0  \n",
+       "495                  0              0.0     0  "
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df2.drop(columns=[\"url\"], inplace=True)\n",
+    "df2.sample(5)"
    ]
   },
   {
@@ -366,11 +1673,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 25,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array(['iso-8859-1', 'UTF-8', 'us-ascii', 'ISO-8859-1', 'utf-8', 'unkown',\n",
+       "       'windows-1251', 'ISO-8859', 'windows-1252'], dtype=object)"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# Your code here"
+    "df2.charset.unique()"
    ]
   },
   {
@@ -384,11 +1703,183 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 26,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code here\n"
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "server\n",
+       "Apache                                                                             386\n",
+       "nginx                                                                              211\n",
+       "unkown                                                                             176\n",
+       "Microsoft-HTTPAPI/2.0                                                              113\n",
+       "cloudflare-nginx                                                                    94\n",
+       "                                                                                  ... \n",
+       "Apache/2.2.29 (Unix) mod_ssl/2.2.29 OpenSSL/1.0.1e-fips DAV/2 mod_bwlimited/1.4      1\n",
+       "gunicorn/19.7.1                                                                      1\n",
+       "Apache/2.2.31 (Unix) mod_ssl/2.2.31 OpenSSL/0.9.8e-fips-rhel5 mod_bwlimited/1.4      1\n",
+       "Apache/1.3.37 (Unix) mod_perl/1.29 mod_ssl/2.8.28 OpenSSL/0.9.7e-p1                  1\n",
+       "Apache/2.2.16 (Debian)                                                               1\n",
+       "Name: count, Length: 239, dtype: int64"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df2.server.value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array(['nginx', 'Apache/2.4.10', 'Microsoft-HTTPAPI/2.0', 'unkown',\n",
+       "       'Apache/2', '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": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df2.server.unique()\n"
    ]
   },
   {
@@ -400,11 +1891,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your comment here\n"
+    "# We could use regex to do some binning, and reduce to just a few values like Apache, Microsoft, nginx, unkown ..."
    ]
   },
   {
@@ -418,22 +1909,42 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here\n"
+    "df2[\"server\"] = df2[\"server\"].str.replace(\".*Apache.*\", \"Apache\", regex = True)\n",
+    "df2[\"server\"] = df2[\"server\"].str.replace(\".*nginx.*\", \"nginx\", regex = True)\n",
+    "df2[\"server\"] = df2[\"server\"].str.replace(\".*Microsoft.*\", \"Microsoft\", regex = True)\n",
+    "df2[\"server\"] = df2[\"server\"].apply(lambda x: \"Other\" if x not in [\"Apache\", \"Microsoft\", \"nginx\"] else x)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 30,
    "metadata": {
     "scrolled": false
    },
-   "outputs": [],
-   "source": [
-    "# Count `SERVER` value counts here\n"
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "server\n",
+       "Apache       643\n",
+       "Other        505\n",
+       "nginx        435\n",
+       "Microsoft    198\n",
+       "Name: count, dtype: int64"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Count `SERVER` value counts here\n",
+    "df2.server.value_counts()"
    ]
   },
   {
@@ -445,11 +1956,414 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 31,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code here\n"
+   "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>number_special_characters</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_bytes</th>\n",
+       "      <th>dns_query_times</th>\n",
+       "      <th>type</th>\n",
+       "      <th>charset_ISO-8859</th>\n",
+       "      <th>charset_ISO-8859-1</th>\n",
+       "      <th>...</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_IN</th>\n",
+       "      <th>whois_country_JP</th>\n",
+       "      <th>whois_country_OTHER</th>\n",
+       "      <th>whois_country_PA</th>\n",
+       "      <th>whois_country_UK</th>\n",
+       "      <th>whois_country_US</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>7</td>\n",
+       "      <td>7</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>700</td>\n",
+       "      <td>1153</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>...</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",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>6</td>\n",
+       "      <td>17</td>\n",
+       "      <td>7</td>\n",
+       "      <td>4</td>\n",
+       "      <td>1230</td>\n",
+       "      <td>1265</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>...</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",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\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>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>...</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",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>6</td>\n",
+       "      <td>31</td>\n",
+       "      <td>22</td>\n",
+       "      <td>3</td>\n",
+       "      <td>3812</td>\n",
+       "      <td>18784</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>...</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>6</td>\n",
+       "      <td>57</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
+       "      <td>4278</td>\n",
+       "      <td>129889</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>...</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>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1776</th>\n",
+       "      <td>16</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>186</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>...</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",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1777</th>\n",
+       "      <td>17</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>124</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>...</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",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1778</th>\n",
+       "      <td>34</td>\n",
+       "      <td>83</td>\n",
+       "      <td>2</td>\n",
+       "      <td>6</td>\n",
+       "      <td>6631</td>\n",
+       "      <td>132181</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>...</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>1779</th>\n",
+       "      <td>34</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>False</td>\n",
+       "      <td>True</td>\n",
+       "      <td>...</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>1780</th>\n",
+       "      <td>40</td>\n",
+       "      <td>19</td>\n",
+       "      <td>6</td>\n",
+       "      <td>11</td>\n",
+       "      <td>2314</td>\n",
+       "      <td>3039</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>...</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",
+       "<p>1781 rows × 32 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      number_special_characters  tcp_conversation_exchange  \\\n",
+       "0                             7                          7   \n",
+       "1                             6                         17   \n",
+       "2                             6                          0   \n",
+       "3                             6                         31   \n",
+       "4                             6                         57   \n",
+       "...                         ...                        ...   \n",
+       "1776                         16                          0   \n",
+       "1777                         17                          0   \n",
+       "1778                         34                         83   \n",
+       "1779                         34                          0   \n",
+       "1780                         40                         19   \n",
+       "\n",
+       "      dist_remote_tcp_port  remote_ips  app_bytes  source_app_bytes  \\\n",
+       "0                        0           2        700              1153   \n",
+       "1                        7           4       1230              1265   \n",
+       "2                        0           0          0                 0   \n",
+       "3                       22           3       3812             18784   \n",
+       "4                        2           5       4278            129889   \n",
+       "...                    ...         ...        ...               ...   \n",
+       "1776                     0           0          0               186   \n",
+       "1777                     0           0          0               124   \n",
+       "1778                     2           6       6631            132181   \n",
+       "1779                     0           0          0                 0   \n",
+       "1780                     6          11       2314              3039   \n",
+       "\n",
+       "      dns_query_times  type  charset_ISO-8859  charset_ISO-8859-1  ...  \\\n",
+       "0                 2.0     1             False               False  ...   \n",
+       "1                 0.0     0             False               False  ...   \n",
+       "2                 0.0     0             False               False  ...   \n",
+       "3                 8.0     0             False                True  ...   \n",
+       "4                 4.0     0             False               False  ...   \n",
+       "...               ...   ...               ...                 ...  ...   \n",
+       "1776              0.0     1             False               False  ...   \n",
+       "1777              0.0     1             False               False  ...   \n",
+       "1778              4.0     0             False               False  ...   \n",
+       "1779              0.0     0             False                True  ...   \n",
+       "1780              6.0     0             False               False  ...   \n",
+       "\n",
+       "      whois_country_CA  whois_country_CN  whois_country_ES  whois_country_FR  \\\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",
+       "1776             False             False              True             False   \n",
+       "1777             False             False              True             False   \n",
+       "1778             False             False             False             False   \n",
+       "1779             False             False             False             False   \n",
+       "1780             False             False             False             False   \n",
+       "\n",
+       "      whois_country_IN  whois_country_JP  whois_country_OTHER  \\\n",
+       "0                False             False                 True   \n",
+       "1                False             False                 True   \n",
+       "2                False             False                 True   \n",
+       "3                False             False                False   \n",
+       "4                False             False                False   \n",
+       "...                ...               ...                  ...   \n",
+       "1776             False             False                False   \n",
+       "1777             False             False                False   \n",
+       "1778             False             False                False   \n",
+       "1779             False             False                False   \n",
+       "1780             False             False                False   \n",
+       "\n",
+       "      whois_country_PA  whois_country_UK  whois_country_US  \n",
+       "0                False             False             False  \n",
+       "1                False             False             False  \n",
+       "2                False             False             False  \n",
+       "3                False             False              True  \n",
+       "4                False             False              True  \n",
+       "...                ...               ...               ...  \n",
+       "1776             False             False             False  \n",
+       "1777             False             False             False  \n",
+       "1778             False             False              True  \n",
+       "1779             False             False              True  \n",
+       "1780             False             False              True  \n",
+       "\n",
+       "[1781 rows x 32 columns]"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Your code here\n",
+    "website_dummy = pd.get_dummies(df2)\n",
+    "website_dummy"
    ]
   },
   {
@@ -461,11 +2375,55 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 32,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code here\n"
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "number_special_characters      int64\n",
+       "tcp_conversation_exchange      int64\n",
+       "dist_remote_tcp_port           int64\n",
+       "remote_ips                     int64\n",
+       "app_bytes                      int64\n",
+       "source_app_bytes               int64\n",
+       "dns_query_times              float64\n",
+       "type                           int64\n",
+       "charset_ISO-8859                bool\n",
+       "charset_ISO-8859-1              bool\n",
+       "charset_UTF-8                   bool\n",
+       "charset_iso-8859-1              bool\n",
+       "charset_unkown                  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                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_IN                bool\n",
+       "whois_country_JP                bool\n",
+       "whois_country_OTHER             bool\n",
+       "whois_country_PA                bool\n",
+       "whois_country_UK                bool\n",
+       "whois_country_US                bool\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Your code here\n",
+    "website_dummy.dtypes"
    ]
   },
   {
@@ -479,13 +2437,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [],
    "source": [
     "from sklearn.model_selection import train_test_split\n",
     "\n",
-    "# Your code here:\n"
+    "# Separate features and target\n",
+    "X = website_dummy.drop(columns=[\"type\"])\n",
+    "y = website_dummy[\"type\"]\n",
+    "\n",
+    "# Separate data into train and test:\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42, shuffle = True)"
    ]
   },
   {
@@ -499,12 +2462,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here:\n",
-    "\n"
+    "from sklearn.linear_model import LogisticRegression\n",
+    "\n",
+    "model = LogisticRegression()"
    ]
   },
   {
@@ -516,12 +2480,443 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code here:\n",
-    "\n"
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\FernandoSanz-Extreme\\anaconda3\\Lib\\site-packages\\sklearn\\linear_model\\_logistic.py:469: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
+      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
+      "\n",
+      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
+      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
+      "Please also refer to the documentation for alternative solver options:\n",
+      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
+      "  n_iter_i = _check_optimize_result(\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-1 {\n",
+       "  /* Definition of color scheme common for light and dark mode */\n",
+       "  --sklearn-color-text: black;\n",
+       "  --sklearn-color-line: gray;\n",
+       "  /* Definition of color scheme for unfitted estimators */\n",
+       "  --sklearn-color-unfitted-level-0: #fff5e6;\n",
+       "  --sklearn-color-unfitted-level-1: #f6e4d2;\n",
+       "  --sklearn-color-unfitted-level-2: #ffe0b3;\n",
+       "  --sklearn-color-unfitted-level-3: chocolate;\n",
+       "  /* Definition of color scheme for fitted estimators */\n",
+       "  --sklearn-color-fitted-level-0: #f0f8ff;\n",
+       "  --sklearn-color-fitted-level-1: #d4ebff;\n",
+       "  --sklearn-color-fitted-level-2: #b3dbfd;\n",
+       "  --sklearn-color-fitted-level-3: cornflowerblue;\n",
+       "\n",
+       "  /* Specific color for light theme */\n",
+       "  --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
+       "  --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, white)));\n",
+       "  --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
+       "  --sklearn-color-icon: #696969;\n",
+       "\n",
+       "  @media (prefers-color-scheme: dark) {\n",
+       "    /* Redefinition of color scheme for dark theme */\n",
+       "    --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
+       "    --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, #111)));\n",
+       "    --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
+       "    --sklearn-color-icon: #878787;\n",
+       "  }\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 pre {\n",
+       "  padding: 0;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 input.sk-hidden--visually {\n",
+       "  border: 0;\n",
+       "  clip: rect(1px 1px 1px 1px);\n",
+       "  clip: rect(1px, 1px, 1px, 1px);\n",
+       "  height: 1px;\n",
+       "  margin: -1px;\n",
+       "  overflow: hidden;\n",
+       "  padding: 0;\n",
+       "  position: absolute;\n",
+       "  width: 1px;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-dashed-wrapped {\n",
+       "  border: 1px dashed var(--sklearn-color-line);\n",
+       "  margin: 0 0.4em 0.5em 0.4em;\n",
+       "  box-sizing: border-box;\n",
+       "  padding-bottom: 0.4em;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-container {\n",
+       "  /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n",
+       "     but bootstrap.min.css set `[hidden] { display: none !important; }`\n",
+       "     so we also need the `!important` here to be able to override the\n",
+       "     default hidden behavior on the sphinx rendered scikit-learn.org.\n",
+       "     See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n",
+       "  display: inline-block !important;\n",
+       "  position: relative;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-text-repr-fallback {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       "div.sk-parallel-item,\n",
+       "div.sk-serial,\n",
+       "div.sk-item {\n",
+       "  /* draw centered vertical line to link estimators */\n",
+       "  background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n",
+       "  background-size: 2px 100%;\n",
+       "  background-repeat: no-repeat;\n",
+       "  background-position: center center;\n",
+       "}\n",
+       "\n",
+       "/* Parallel-specific style estimator block */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item::after {\n",
+       "  content: \"\";\n",
+       "  width: 100%;\n",
+       "  border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n",
+       "  flex-grow: 1;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel {\n",
+       "  display: flex;\n",
+       "  align-items: stretch;\n",
+       "  justify-content: center;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  position: relative;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item {\n",
+       "  display: flex;\n",
+       "  flex-direction: column;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item:first-child::after {\n",
+       "  align-self: flex-end;\n",
+       "  width: 50%;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item:last-child::after {\n",
+       "  align-self: flex-start;\n",
+       "  width: 50%;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item:only-child::after {\n",
+       "  width: 0;\n",
+       "}\n",
+       "\n",
+       "/* Serial-specific style estimator block */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-serial {\n",
+       "  display: flex;\n",
+       "  flex-direction: column;\n",
+       "  align-items: center;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  padding-right: 1em;\n",
+       "  padding-left: 1em;\n",
+       "}\n",
+       "\n",
+       "\n",
+       "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n",
+       "clickable and can be expanded/collapsed.\n",
+       "- Pipeline and ColumnTransformer use this feature and define the default style\n",
+       "- Estimators will overwrite some part of the style using the `sk-estimator` class\n",
+       "*/\n",
+       "\n",
+       "/* Pipeline and ColumnTransformer style (default) */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable {\n",
+       "  /* Default theme specific background. It is overwritten whether we have a\n",
+       "  specific estimator or a Pipeline/ColumnTransformer */\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "}\n",
+       "\n",
+       "/* Toggleable label */\n",
+       "#sk-container-id-1 label.sk-toggleable__label {\n",
+       "  cursor: pointer;\n",
+       "  display: block;\n",
+       "  width: 100%;\n",
+       "  margin-bottom: 0;\n",
+       "  padding: 0.5em;\n",
+       "  box-sizing: border-box;\n",
+       "  text-align: center;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 label.sk-toggleable__label-arrow:before {\n",
+       "  /* Arrow on the left of the label */\n",
+       "  content: \"▸\";\n",
+       "  float: left;\n",
+       "  margin-right: 0.25em;\n",
+       "  color: var(--sklearn-color-icon);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "}\n",
+       "\n",
+       "/* Toggleable content - dropdown */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content {\n",
+       "  max-height: 0;\n",
+       "  max-width: 0;\n",
+       "  overflow: hidden;\n",
+       "  text-align: left;\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content pre {\n",
+       "  margin: 0.2em;\n",
+       "  border-radius: 0.25em;\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content.fitted pre {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n",
+       "  /* Expand drop-down */\n",
+       "  max-height: 200px;\n",
+       "  max-width: 100%;\n",
+       "  overflow: auto;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n",
+       "  content: \"▾\";\n",
+       "}\n",
+       "\n",
+       "/* Pipeline/ColumnTransformer-specific style */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Estimator-specific style */\n",
+       "\n",
+       "/* Colorize estimator box */\n",
+       "#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label label.sk-toggleable__label,\n",
+       "#sk-container-id-1 div.sk-label label {\n",
+       "  /* The background is the default theme color */\n",
+       "  color: var(--sklearn-color-text-on-default-background);\n",
+       "}\n",
+       "\n",
+       "/* On hover, darken the color of the background */\n",
+       "#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Label box, darken color on hover, fitted */\n",
+       "#sk-container-id-1 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Estimator label */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label label {\n",
+       "  font-family: monospace;\n",
+       "  font-weight: bold;\n",
+       "  display: inline-block;\n",
+       "  line-height: 1.2em;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label-container {\n",
+       "  text-align: center;\n",
+       "}\n",
+       "\n",
+       "/* Estimator-specific */\n",
+       "#sk-container-id-1 div.sk-estimator {\n",
+       "  font-family: monospace;\n",
+       "  border: 1px dotted var(--sklearn-color-border-box);\n",
+       "  border-radius: 0.25em;\n",
+       "  box-sizing: border-box;\n",
+       "  margin-bottom: 0.5em;\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-estimator.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "/* on hover */\n",
+       "#sk-container-id-1 div.sk-estimator:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-estimator.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n",
+       "\n",
+       "/* Common style for \"i\" and \"?\" */\n",
+       "\n",
+       ".sk-estimator-doc-link,\n",
+       "a:link.sk-estimator-doc-link,\n",
+       "a:visited.sk-estimator-doc-link {\n",
+       "  float: right;\n",
+       "  font-size: smaller;\n",
+       "  line-height: 1em;\n",
+       "  font-family: monospace;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  border-radius: 1em;\n",
+       "  height: 1em;\n",
+       "  width: 1em;\n",
+       "  text-decoration: none !important;\n",
+       "  margin-left: 1ex;\n",
+       "  /* unfitted */\n",
+       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
+       "  color: var(--sklearn-color-unfitted-level-1);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link.fitted,\n",
+       "a:link.sk-estimator-doc-link.fitted,\n",
+       "a:visited.sk-estimator-doc-link.fitted {\n",
+       "  /* fitted */\n",
+       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
+       "  color: var(--sklearn-color-fitted-level-1);\n",
+       "}\n",
+       "\n",
+       "/* On hover */\n",
+       "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n",
+       ".sk-estimator-doc-link:hover,\n",
+       "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n",
+       ".sk-estimator-doc-link:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
+       "  color: var(--sklearn-color-background);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n",
+       ".sk-estimator-doc-link.fitted:hover,\n",
+       "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n",
+       ".sk-estimator-doc-link.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-3);\n",
+       "  color: var(--sklearn-color-background);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "/* Span, style for the box shown on hovering the info icon */\n",
+       ".sk-estimator-doc-link span {\n",
+       "  display: none;\n",
+       "  z-index: 9999;\n",
+       "  position: relative;\n",
+       "  font-weight: normal;\n",
+       "  right: .2ex;\n",
+       "  padding: .5ex;\n",
+       "  margin: .5ex;\n",
+       "  width: min-content;\n",
+       "  min-width: 20ex;\n",
+       "  max-width: 50ex;\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  box-shadow: 2pt 2pt 4pt #999;\n",
+       "  /* unfitted */\n",
+       "  background: var(--sklearn-color-unfitted-level-0);\n",
+       "  border: .5pt solid var(--sklearn-color-unfitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link.fitted span {\n",
+       "  /* fitted */\n",
+       "  background: var(--sklearn-color-fitted-level-0);\n",
+       "  border: var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link:hover span {\n",
+       "  display: block;\n",
+       "}\n",
+       "\n",
+       "/* \"?\"-specific style due to the `<a>` HTML tag */\n",
+       "\n",
+       "#sk-container-id-1 a.estimator_doc_link {\n",
+       "  float: right;\n",
+       "  font-size: 1rem;\n",
+       "  line-height: 1em;\n",
+       "  font-family: monospace;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  border-radius: 1rem;\n",
+       "  height: 1rem;\n",
+       "  width: 1rem;\n",
+       "  text-decoration: none;\n",
+       "  /* unfitted */\n",
+       "  color: var(--sklearn-color-unfitted-level-1);\n",
+       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 a.estimator_doc_link.fitted {\n",
+       "  /* fitted */\n",
+       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
+       "  color: var(--sklearn-color-fitted-level-1);\n",
+       "}\n",
+       "\n",
+       "/* On hover */\n",
+       "#sk-container-id-1 a.estimator_doc_link:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
+       "  color: var(--sklearn-color-background);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 a.estimator_doc_link.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LogisticRegression()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow fitted\">&nbsp;&nbsp;LogisticRegression<a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.4/modules/generated/sklearn.linear_model.LogisticRegression.html\">?<span>Documentation for LogisticRegression</span></a><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></label><div class=\"sk-toggleable__content fitted\"><pre>LogisticRegression()</pre></div> </div></div></div></div>"
+      ],
+      "text/plain": [
+       "LogisticRegression()"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.fit(X_train, y_train)"
    ]
   },
   {
@@ -533,12 +2928,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code here:\n",
-    "\n"
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.8543417366946778\n",
+      "[[295  11]\n",
+      " [ 41  10]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.metrics import accuracy_score, confusion_matrix\n",
+    "\n",
+    "y_pred = model.predict(X_test)\n",
+    "print(accuracy_score(y_test, y_pred))\n",
+    "print(confusion_matrix(y_test, y_pred))"
    ]
   },
   {
@@ -550,12 +2958,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your conclusions here:\n",
-    "\n"
+    "# The model has a 85% of accuracy to predict the not malicious websites, but it has a low accuracy to predict the malicious ones"
    ]
   },
   {
@@ -569,12 +2976,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here:\n",
-    "\n"
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "\n",
+    "knn3_model = KNeighborsClassifier(n_neighbors=3)\n",
+    "knn3_model = knn3_model.fit(X_train, y_train)"
    ]
   },
   {
@@ -586,12 +2995,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 47,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.9327731092436975\n",
+      "[[302   4]\n",
+      " [ 20  31]]\n"
+     ]
+    }
+   ],
    "source": [
-    "# Your code here:\n",
-    "\n"
+    "predictions3 = knn3_model.predict(X_test)\n",
+    "print(accuracy_score(y_test, predictions3))\n",
+    "print(confusion_matrix(y_test, predictions3))"
    ]
   },
   {
@@ -605,12 +3025,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 48,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.9243697478991597\n",
+      "[[300   6]\n",
+      " [ 21  30]]\n"
+     ]
+    }
+   ],
    "source": [
-    "# Your code here:\n",
-    "\n"
+    "knn5_model = KNeighborsClassifier(n_neighbors=5)\n",
+    "knn5_model = knn5_model.fit(X_train, y_train)\n",
+    "predictions5 = knn5_model.predict(X_test)\n",
+    "print(accuracy_score(y_test, predictions5))\n",
+    "print(confusion_matrix(y_test, predictions5))"
    ]
   },
   {
@@ -622,12 +3055,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your conclusions here:\n",
-    "\n"
+    "# The KNN method yields a better accuracy than the LogisticRegression, but it does worst with 5 neighbors than with 3 neighbors"
    ]
   },
   {
@@ -645,7 +3077,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -655,9 +3087,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "ironhack-3.7",
+   "display_name": "base",
    "language": "python",
-   "name": "ironhack-3.7"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -669,7 +3101,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.3"
+   "version": "3.12.4"
   }
  },
  "nbformat": 4,