02-regression/homework_02_till_meineke.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Homework 02 Till Meineke"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this homework, we will use the Laptops price dataset from [Kaggle](https://www.kaggle.com/datasets/juanmerinobermejo/laptops-price-dataset).\n",
    "\n",
    "Here's a wget-able [link](https://raw.githubusercontent.com/alexeygrigorev/datasets/master/laptops.csv):\n",
    "\n",
    "```bash\n",
    "wget https://raw.githubusercontent.com/alexeygrigorev/datasets/master/laptops.csv\n",
    "```\n",
    "\n",
    "The goal of this homework is to create a regression model for predicting the prices (column `'Final Price'`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# %matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EDA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Load the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2024-09-30 17:55:50--  https://raw.githubusercontent.com/alexeygrigorev/datasets/master/laptops.csv\n",
      "Auflösen des Hostnamens raw.githubusercontent.com (raw.githubusercontent.com)… 2606:50c0:8003::154, 2606:50c0:8000::154, 2606:50c0:8001::154, ...\n",
      "Verbindungsaufbau zu raw.githubusercontent.com (raw.githubusercontent.com)|2606:50c0:8003::154|:443 … verbunden.\n",
      "HTTP-Anforderung gesendet, auf Antwort wird gewartet … 200 OK\n",
      "Länge: 298573 (292K) [text/plain]\n",
      "Wird in »./data/laptops.csv« gespeichert.\n",
      "\n",
      "./data/laptops.csv  100%[===================>] 291,58K  --.-KB/s    in 0,06s   \n",
      "\n",
      "2024-09-30 17:55:51 (4,85 MB/s) - »./data/laptops.csv« gespeichert [298573/298573]\n",
      "\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>Laptop</th>\n",
       "      <th>Status</th>\n",
       "      <th>Brand</th>\n",
       "      <th>Model</th>\n",
       "      <th>CPU</th>\n",
       "      <th>RAM</th>\n",
       "      <th>Storage</th>\n",
       "      <th>Storage type</th>\n",
       "      <th>GPU</th>\n",
       "      <th>Screen</th>\n",
       "      <th>Touch</th>\n",
       "      <th>Final Price</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ASUS ExpertBook B1 B1502CBA-EJ0436X Intel Core...</td>\n",
       "      <td>New</td>\n",
       "      <td>Asus</td>\n",
       "      <td>ExpertBook</td>\n",
       "      <td>Intel Core i5</td>\n",
       "      <td>8</td>\n",
       "      <td>512</td>\n",
       "      <td>SSD</td>\n",
       "      <td>NaN</td>\n",
       "      <td>15.6</td>\n",
       "      <td>No</td>\n",
       "      <td>1009.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Alurin Go Start Intel Celeron N4020/8GB/256GB ...</td>\n",
       "      <td>New</td>\n",
       "      <td>Alurin</td>\n",
       "      <td>Go</td>\n",
       "      <td>Intel Celeron</td>\n",
       "      <td>8</td>\n",
       "      <td>256</td>\n",
       "      <td>SSD</td>\n",
       "      <td>NaN</td>\n",
       "      <td>15.6</td>\n",
       "      <td>No</td>\n",
       "      <td>299.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                              Laptop Status   Brand  \\\n",
       "0  ASUS ExpertBook B1 B1502CBA-EJ0436X Intel Core...    New    Asus   \n",
       "1  Alurin Go Start Intel Celeron N4020/8GB/256GB ...    New  Alurin   \n",
       "\n",
       "        Model            CPU  RAM  Storage Storage type  GPU  Screen Touch  \\\n",
       "0  ExpertBook  Intel Core i5    8      512          SSD  NaN    15.6    No   \n",
       "1          Go  Intel Celeron    8      256          SSD  NaN    15.6    No   \n",
       "\n",
       "   Final Price  \n",
       "0       1009.0  \n",
       "1        299.0  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "URL = \"https://raw.githubusercontent.com/alexeygrigorev/datasets/master/laptops.csv\"\n",
    "\n",
    "!wget $URL -O ./data/laptops.csv\n",
    "\n",
    "df = pd.read_csv(\"./data/laptops.csv\")\n",
    "df.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we'll normalize the names of the columns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.columns = df.columns.str.lower().str.replace(\" \", \"_\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, instead of `'Final Price'`, we have `'final_price'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['laptop', 'status', 'brand', 'model', 'cpu', 'ram', 'storage',\n",
       "       'storage_type', 'gpu', 'screen', 'touch', 'final_price'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, use only the following columns:\n",
    "\n",
    "* `'ram'`,\n",
    "* `'storage'`,\n",
    "* `'screen'`,\n",
    "* `'final_price'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['ram', 'storage', 'screen', 'final_price'], dtype='object')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_small = df[[\"ram\", \"storage\", \"screen\", \"final_price\"]]\n",
    "df_small.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EDA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Look at the `final_price` variable. Does it have a long tail?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7150.47"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_small.final_price.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "final_price\n",
       "999.00     27\n",
       "1999.00    25\n",
       "699.00     23\n",
       "799.00     23\n",
       "1599.00    21\n",
       "           ..\n",
       "1073.34     1\n",
       "998.69      1\n",
       "644.39      1\n",
       "676.79      1\n",
       "1699.99     1\n",
       "Name: count, Length: 1440, dtype: int64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_small.final_price.value_counts().sort_values(ascending=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.histplot(df_small.final_price, bins=30);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes, the `final_price` variable has a long tail."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's one feature with missing values. What is it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 2160 entries, 0 to 2159\n",
      "Data columns (total 4 columns):\n",
      " #   Column       Non-Null Count  Dtype  \n",
      "---  ------       --------------  -----  \n",
      " 0   ram          2160 non-null   int64  \n",
      " 1   storage      2160 non-null   int64  \n",
      " 2   screen       2156 non-null   float64\n",
      " 3   final_price  2160 non-null   float64\n",
      "dtypes: float64(2), int64(2)\n",
      "memory usage: 67.6 KB\n"
     ]
    }
   ],
   "source": [
    "df_small.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ram            0\n",
       "storage        0\n",
       "screen         4\n",
       "final_price    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_small.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Screen missing values:  4\n"
     ]
    }
   ],
   "source": [
    "print(\"Screen missing values: \", df_small.screen.isnull().sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Columns with missing values:  screen\n"
     ]
    }
   ],
   "source": [
    "# Which column has missing values?\n",
    "print(\n",
    "    \"Columns with missing values: \",\n",
    "    df_small.columns[df_small.isnull().any()].tolist()[0],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`screen` is the column with missing values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What's the median (50% percentile) for variable `'ram'`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The median (50% percentile) for variable 'ram' is:  16.0\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    \"The median (50% percentile) for variable 'ram' is: \",\n",
    "    df_small[\"ram\"].median(),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The median (50% percentile) for variable `ram` is:  16.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare and split the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Shuffle the dataset (the filtered one you created above), use seed `42`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from sklearn.utils import shuffle\n",
    "\n",
    "# seed = 42\n",
    "\n",
    "# # shuffle dataset\n",
    "# df_small = shuffle(df_small, random_state=seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = len(df_small)\n",
    "\n",
    "n_val = int(n * 0.2)\n",
    "n_test = int(n * 0.2)\n",
    "n_train = n - n_val - n_test\n",
    "\n",
    "idx = np.arange(n)\n",
    "np.random.seed(42)\n",
    "np.random.shuffle(idx)\n",
    "\n",
    "df_shuffled = df_small.iloc[idx]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Split your data in train/val/test sets, with 60%/20%/20% distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = df_shuffled.iloc[:n_train].copy()\n",
    "df_val = df_shuffled.iloc[n_train : n_train + n_val].copy()\n",
    "df_test = df_shuffled.iloc[n_train + n_val :].copy()\n",
    "\n",
    "df_train = df_train.reset_index(drop=True)\n",
    "df_val = df_val.reset_index(drop=True)\n",
    "df_test = df_test.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = df_train.final_price.values\n",
    "y_val = df_val.final_price.values\n",
    "y_test = df_test.final_price.values\n",
    "\n",
    "del df_train[\"final_price\"]\n",
    "del df_val[\"final_price\"]\n",
    "del df_test[\"final_price\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* We need to deal with missing values for the column from Q1.\n",
    "* We have two options: fill it with 0 or with the mean of this variable.\n",
    "* Try both options. For each, train a linear regression model without regularization using the code from the lessons.\n",
    "* For computing the mean, use the training only!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.163534416086618"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_screen = df_train.screen.mean()\n",
    "mean_screen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fill missing values in `total_bedrooms` with the median value\n",
    "X_train_mean = df_train.fillna(mean_screen).values\n",
    "X_val_mean = df_val.fillna(mean_screen).values\n",
    "X_test_mean = df_test.fillna(mean_screen).values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fill missing values in `total_bedrooms` with 0\n",
    "X_train_zero = df_train.fillna(0).values\n",
    "X_val_zero = df_val.fillna(0).values\n",
    "X_test_zero = df_test.fillna(0).values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHFCAYAAAAUpjivAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABJy0lEQVR4nO3dfVxUZf7/8ffIrSiigjKwoZKhqWB505q6haVirlZmrZVatlprZrakfjVzVTIXzVZ0V9NuviaWufb7VrptWYmmlpGlZOsda2koWCBiCCgIBNfvj5bZRm4UBAeOr+fjcR4x53zOda5rDjRvz1xnxmaMMQIAALCoRq7uAAAAQF0i7AAAAEsj7AAAAEsj7AAAAEsj7AAAAEsj7AAAAEsj7AAAAEsj7AAAAEsj7AAAAEsj7AANzBdffKG77rpLbdq0kZeXlwIDA9W7d29NmTLF1V1zCZvNppiYGMfj+Ph42Ww2HT16tFrtxMbGasOGDdXap6Jj9evXT+Hh4dVq50I2btzoNMZfateunR566KFaPR5gNYQdoAF5//331adPH+Xm5mrhwoXatGmT/vrXv6pv37568803Xd29emHIkCH6/PPPFRQUVK39ahJ2anqs6tq4caOeeeaZCretX79es2bNqtPjAw2du6s7AODiLVy4UKGhofroo4/k7v7fP9/77rtPCxcurJVj5Ofny8fHp1bacoVWrVqpVatWdXqMgoICeXt7X5ZjXUi3bt1cenygIeDKDtCAnDp1SgEBAU5Bp0yjRuX/nNeuXavevXuradOmatq0qa6//nqtXLnSsb3sLZdPPvlEffr0kY+Pj8aOHStJys3N1dSpUxUaGipPT0/96le/UnR0tM6ePet0DGOMli9fruuvv16NGzdWixYtdM899+i7775zqis71q5du3TTTTfJx8dHV199tRYsWKDS0tILjj03N1ePPPKI/P391bRpU91222365ptvytVV9NbSnj17NHToULVu3VpeXl4KDg7WkCFDdPz4cUk/vxV29uxZrV69WjabTTabTf369XNqb9OmTRo7dqxatWolHx8fFRYWVvmW2aeffqobb7xRjRs31q9+9SvNmjVLJSUlju3btm2TzWbTtm3bnPY7evSobDab4uPjJUkPPfSQXnjhBUc/y5ayY1b0NlZqaqpGjx7tGG+nTp20aNEip+e57Dh/+ctfFBcXp9DQUDVt2lS9e/fWzp07L3g+gIaEKztAA9K7d2/97//+r5544gmNGjVK3bt3l4eHR4W1s2fP1rPPPqvhw4drypQp8vPz0/79+3Xs2DGnuvT0dI0ePVrTpk1TbGysGjVqpPz8fEVGRur48eN6+umn1bVrVx04cECzZ8/Wvn37tHnzZtlsNknS+PHjFR8fryeeeELPPfecfvzxR82dO1d9+vTRv/71LwUGBjqOlZGRoVGjRmnKlCmaM2eO1q9frxkzZig4OFgPPvhgpeM2xmjYsGFKTEzU7NmzdcMNN+izzz7T4MGDL/icnT17VgMHDlRoaKheeOEFBQYGKiMjQ1u3blVeXp4k6fPPP9ett96qW265xfGWULNmzZzaGTt2rIYMGaLXX39dZ8+erfR5Lxvnfffdp6eeekpz587V+++/r3nz5ik7O1vLli27YJ9/adasWTp79qzeeustff755471lb11dvLkSfXp00dFRUV69tln1a5dO7333nuaOnWqjhw5ouXLlzvVv/DCC7r22mu1ZMkSx/F++9vfKiUlRX5+ftXqK1BvGQANRlZWlvnNb35jJBlJxsPDw/Tp08fMnz/f5OXlOeq+++474+bmZkaNGlVle5GRkUaS2bJli9P6+fPnm0aNGpldu3Y5rX/rrbeMJLNx40ZjjDGff/65kWQWLVrkVJeWlmYaN25spk2bVu5YX3zxhVNt586dzaBBg6rs5wcffGAkmb/+9a9O6//85z8bSWbOnDmOdatWrTKSTEpKijHGmN27dxtJZsOGDVUeo0mTJmbMmDHl1pe19+CDD1a6rexYvxznP/7xD6faRx55xDRq1MgcO3bMGGPM1q1bjSSzdetWp7qUlBQjyaxatcqxbuLEiaay/123bdvWqd9PPfVUhc/zhAkTjM1mM4cOHXI6TkREhPnpp58cdV9++aWRZP7+979XeDygIeJtLKAB8ff316effqpdu3ZpwYIFuvPOO/XNN99oxowZioiIUFZWliQpISFBJSUlmjhx4gXbbNGihW699Vande+9957Cw8N1/fXX66effnIsgwYNcnrr5b333pPNZtPo0aOd6ux2u6677rpyb9HY7Xb9+te/dlrXtWvXclebzrd161ZJ0qhRo5zWjxw58oLju+aaa9SiRQtNnz5dL774og4ePHjBfSpy9913X3Str6+v7rjjDqd1I0eOVGlpqT755JMaHf9iffzxx+rcuXO55/mhhx6SMUYff/yx0/ohQ4bIzc3N8bhr166SdMFzAjQkhB2gAerZs6emT5+u//u//9MPP/ygJ598UkePHnVMUj558qQk6aqrrrpgWxW9HXLixAnt3btXHh4eTouvr6+MMY5QdeLECRljFBgYWK52586djroy/v7+5Y7l5eWlgoKCKvt46tQpubu7l9vfbrdfcHx+fn7avn27rr/+ej399NPq0qWLgoODNWfOHBUXF19w/zLVuePql2/dnd/XU6dOXXQ7NXHq1KkK+xocHFzh8c9/Tr28vCTpgucEaEiYswM0cB4eHpozZ44WL16s/fv3S5LjDqHjx48rJCSkyv3L5t78UkBAgBo3bqxXX321wn0CAgIc/7XZbPr0008dL5K/VNG6mvD399dPP/2kU6dOOb04Z2RkXNT+ERERWrdunYwx2rt3r+Lj4zV37lw1btxYTz311EW1UdHzVJkTJ06UW1fW17L+e3t7S5IKCwud6s4PiNXl7++v9PT0cut/+OEHSf89d8CVhCs7QANS0YuYJCUnJ0v677/eo6Ki5ObmphUrVtToOEOHDtWRI0fk7++vnj17llvatWvnqDPG6Pvvv6+wLiIiokbHP98tt9wiSXrjjTec1q9du7Za7dhsNl133XVavHixmjdvrq+++sqx7WKuMF2svLw8vfvuu+X62qhRI918882S5HgO9+7d61R3/n5lfZMu7mpL//79dfDgQaexSdJrr70mm83meC6BKwlXdoAGZNCgQbrqqqt0++2369prr1Vpaam+/vprLVq0SE2bNtUf//hHST+/kD799NN69tlnVVBQoPvvv19+fn46ePCgsrKyKv2AujLR0dF6++23dfPNN+vJJ59U165dVVpaqtTUVG3atElTpkxRr1691LdvX/3hD3/Q73//e+3evVs333yzmjRpovT0dO3YsUMRERGaMGHCJY87KipKN998s6ZNm6azZ8+qZ8+e+uyzz/T6669fcN/33ntPy5cv17Bhw3T11VfLGKN33nlHp0+f1sCBAx11ERER2rZtm/75z38qKChIvr6+6tixY4366+/vrwkTJig1NVUdOnTQxo0b9corr2jChAlq06aNpJ/f1howYIDmz5+vFi1aqG3bttqyZYveeeedcu2VhcbnnntOgwcPlpubm7p27SpPT89ytU8++aRee+01DRkyRHPnzlXbtm31/vvva/ny5ZowYYI6dOhQozEBDZorZ0cDqJ4333zTjBw50oSFhZmmTZsaDw8P06ZNG/PAAw+YgwcPlqt/7bXXzA033GC8vb1N06ZNTbdu3Zzu8omMjDRdunSp8Fhnzpwxf/rTn0zHjh2Np6en8fPzMxEREebJJ580GRkZTrWvvvqq6dWrl2nSpIlp3Lixad++vXnwwQfN7t27L3isMWPGmLZt215w7KdPnzZjx441zZs3Nz4+PmbgwIHm3//+9wXvxvr3v/9t7r//ftO+fXvTuHFj4+fnZ37961+b+Ph4p/a//vpr07dvX+Pj42MkmcjISKf2zr8zraJj/XKc27ZtMz179jReXl4mKCjIPP3006a4uNhp//T0dHPPPfeYli1bGj8/PzN69GjH3WO/PE+FhYXm4YcfNq1atTI2m83pmOffjWWMMceOHTMjR440/v7+xsPDw3Ts2NE8//zzpqSkxFFTdjfW888/X25c5z+nQENnM8YYlyUtAACAOsacHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGl8qKCk0tJS/fDDD/L19a3WR8IDAADXMcYoLy9PwcHBatSo8us3hB39/J0xF/r+IAAAUD+lpaVV+cXHhB1Jvr6+kn5+spo1a+bi3gAAgIuRm5urkJAQx+t4ZQg7+u+3GTdr1oywAwBAA3OhKShMUAYAAJZG2AEAAJZG2AEAAJbGnJ1qKCkpUXFxsau7YSkeHh5yc3NzdTcAABZG2LkIxhhlZGTo9OnTru6KJTVv3lx2u53POAIA1AnCzkUoCzqtW7eWj48PL8q1xBij/Px8ZWZmSpKCgoJc3CMAgBURdi6gpKTEEXT8/f1d3R3Lady4sSQpMzNTrVu35i0tAECtY4LyBZTN0fHx8XFxT6yr7LllPhQAoC4Qdi4Sb13VHZ5bAEBdIuwAAABLY85ODaWmpiorK+uyHS8gIEBt2rS5bMcDAMAqCDs1kJqaqk6dOik/P/+yHdPHx0fJyckEHgAAqomwUwNZWVnKz8/X5MlrFBLSqc6Pl5aWrLi40crKyiLsAABQTYSdSxAS0knt23d3dTcq1a9fP0VERMjNzU2rV6+Wp6ennn32WY0aNUqPP/643nrrLbVu3VrLli3T4MGDJUkHDx7U1KlT9cknn6hJkyaKiorS4sWLFRAQIEn68MMPNW/ePO3fv19ubm7q3bu3/vrXv6p9+/aSpKNHjyo0NFRvv/22li5dqi+++EJhYWF68cUX1bt3b5c9FwCAKxdhx+JWr16tadOm6csvv9Sbb76pCRMmaMOGDbrrrrv09NNPa/HixXrggQeUmpqqnJwcRUZG6pFHHlFcXJwKCgo0ffp0jRgxQh9//LEk6ezZs5o8ebIiIiJ09uxZzZ49W3fddZe+/vprNWr03/nuM2fO1F/+8heFhYVp5syZuv/++3X48GG5u/MrB+DKUFdzO5nDWX288ljcddddpz/96U+SpBkzZmjBggUKCAjQI488IkmaPXu2VqxYob1792rjxo3q3r27YmNjHfu/+uqrCgkJ0TfffKMOHTro7rvvdmp/5cqVat26tQ4ePKjw8HDH+qlTp2rIkCGSpGeeeUZdunTR4cOHde2119b1kAHA5epybidzOKuPsGNxXbt2dfzs5uYmf39/RUREONYFBgZK+vkTjJOSkrR161Y1bdq0XDtHjhxRhw4ddOTIEc2aNUs7d+5UVlaWSktLJf38h/3LsPPL45Z9DURmZiZhB8AVoWxu55rJk9UpJKTW2k1OS9PouDjmcFYTYcfiPDw8nB7bbDandWUf6FdaWqrS0lLdfvvteu6558q1UxZYbr/9doWEhOiVV15RcHCwSktLFR4erqKiokqP+8tjAMCVpFNIiLr/Z04jXIewA4fu3bvr7bffVrt27SqcW3Pq1CklJyfrpZde0k033SRJ2rFjx+XuJgAA1cInKMNh4sSJ+vHHH3X//ffryy+/1HfffadNmzZp7NixKikpUYsWLeTv76+XX35Zhw8f1scff6zJkye7utsAAFSJKzuXIC0t2VLHCQ4O1meffabp06dr0KBBKiwsVNu2bXXbbbepUaNGstlsWrdunZ544gmFh4erY8eO+tvf/qZ+/fpdlv4BAFAThJ0aCAgIkI+Pj+LiRl+2Y/r4+Dg+6+Zibdu2rdy6o0ePlltnjHH8HBYWpnfeeafSNgcMGKCDBw9Wun+7du2cHktS8+bNy60DAOByIezUQJs2bZScnMx3YwEA0AAQdmqoTZs2hA8AABoAJigDAABLI+wAAABLI+wAAABLI+wAAABLI+wAAABLc2nYadeunWw2W7ll4sSJkn7+/JaYmBgFBwercePG6tevnw4cOODURmFhoSZNmqSAgAA1adJEd9xxh44fP+6K4QAAgHrIpWFn165dSk9PdywJCQmSpN/97neSpIULFyouLk7Lli3Trl27ZLfbNXDgQOXl5TnaiI6O1vr167Vu3Trt2LFDZ86c0dChQ1VSUuKSMQEAgPrFpZ+z06pVK6fHCxYsUPv27RUZGSljjJYsWaKZM2dq+PDhkqTVq1crMDBQa9eu1fjx45WTk6OVK1fq9ddf14ABAyRJa9asUUhIiDZv3qxBgwbVWd9TU1P5UEEAABqAevOhgkVFRVqzZo0mT54sm82m7777ThkZGYqKinLUeHl5KTIyUomJiRo/frySkpJUXFzsVBMcHKzw8HAlJibWWdhJTU1Vp06dlJ+fXyftV8THx0fJyckEHgAAqqnehJ0NGzbo9OnTeuihhyRJGRkZkqTAwECnusDAQB07dsxR4+npqRYtWpSrKdu/IoWFhSosLHQ8zs3NrVZfs7KylJ+frzWTJ6tTSEi19q2J5LQ0jY6LU1ZWlsvCTlFRkTw9PV1ybAAALkW9CTsrV67U4MGDFRwc7LTeZrM5PTbGlFt3vgvVzJ8/X88880zNO/sfnUJC1L19+0tupy4cPXpUoaGh5dZHRkZq27ZtSkxM1FNPPaVdu3YpICBAd911l+bPn68mTZpI+nny+MMPP6zDhw9r/fr1GjZsmFavXq23335bs2fP1uHDhxUUFKRJkyZpypQpl3t4AABctHpx6/mxY8e0efNmPfzww451drtdkspdocnMzHRc7bHb7SoqKlJ2dnalNRWZMWOGcnJyHEtaWlptDaXeCAkJcZr8vWfPHvn7++vmm2/Wvn37NGjQIA0fPlx79+7Vm2++qR07dujxxx93auP5559XeHi4kpKSNGvWLCUlJWnEiBG67777tG/fPsXExGjWrFmKj493zSABALgI9eLKzqpVq9S6dWsNGTLEsS40NFR2u10JCQnq1q2bpJ/fStm+fbuee+45SVKPHj3k4eGhhIQEjRgxQpKUnp6u/fv3a+HChZUez8vLS15eXnU4Itdzc3NzBMZz585p2LBh6t27t2JiYvTQQw9p5MiRio6OliSFhYXpb3/7myIjI7VixQp5e3tLkm699VZNnTrV0eaoUaPUv39/zZo1S5LUoUMHHTx4UM8//7zj7UcAAOobl4ed0tJSrVq1SmPGjJG7+3+7Y7PZFB0drdjYWIWFhSksLEyxsbHy8fHRyJEjJUl+fn4aN26cpkyZIn9/f7Vs2VJTp05VRESE4+4sSOPGjVNeXp4SEhLUqFEjJSUl6fDhw3rjjTccNcYYlZaWKiUlRZ06dZIk9ezZ06md5ORk3XnnnU7r+vbtqyVLlqikpERubm51PxgAAKrJ5WFn8+bNSk1N1dixY8ttmzZtmgoKCvTYY48pOztbvXr10qZNm+Tr6+uoWbx4sdzd3TVixAgVFBSof//+io+P54X3P+bNm6cPP/xQX375peN5Ky0t1fjx4/XEE0+Uq//lBOiy+TtlKpoLZYypg14DAFB7XB52oqKiKn3BtNlsiomJUUxMTKX7e3t7a+nSpVq6dGkd9bDhevvttzV37lx98MEHav+LidTdu3fXgQMHdM0111Srvc6dO2vHjh1O6xITE9WhQwfCJQCg3qoXE5RR+/bv368HH3xQ06dPV5cuXZSRkaGMjAz9+OOPmj59uj7//HNNnDhRX3/9tb799lu9++67mjRpUpVtTpkyRVu2bNGzzz6rb775RqtXr9ayZcuc5vUAAFDfuPzKTkOWfJnu4qrJcXbv3q38/HzNmzdP8+bNc6wvu/V8+/btmjlzpm666SYZY9S+fXvde++9VbbZvXt3/b//9/80e/ZsPfvsswoKCtLcuXOZnAwAqNcIOzUQEBAgHx8fjY6Lu2zH9PHxUUBAwEXXP/TQQ1WGkBtuuEGbNm2qdPvRo0crXH/33Xfr7rvvvuh+AADgaoSdGmjTpo2Sk5P5biwAABoAwk4NtWnThvABAEADwARlAABgaYQdAABgaYSdi8SH59UdnlsAQF0i7FyAh4eHJCk/P9/FPbGusue27LkGAKA2MUH5Atzc3NS8eXNlZmZK+vkW8PO/MgE1Y4xRfn6+MjMz1bx5cz6FGQBQJwg7F6Hs28PLAg9qV/PmzR3PMQAAtY2wcxFsNpuCgoLUunVrFRcXu7o7luLh4cEVHQBAnSLsVIObmxsvzAAANDBMUAYAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJbm7uoOAABgJampqUpOTpYkpaWlya+SumbNmqlVq1aXr2NXMJeHne+//17Tp0/XBx98oIKCAnXo0EErV65Ujx49JEnGGD3zzDN6+eWXlZ2drV69eumFF15Qly5dHG0UFhZq6tSp+vvf/66CggL1799fy5cv11VXXeWqYQEArkCpqanq1KmT8vPzJUmL4uIqDTtenp5asWIFgecycGnYyc7OVt++fXXLLbfogw8+UOvWrXXkyBE1b97cUbNw4ULFxcUpPj5eHTp00Lx58zRw4EAdOnRIvr6+kqTo6Gj985//1Lp16+Tv768pU6Zo6NChSkpKkpubm4tGBwC40mRlZSk/P1+jRj2rN96YpWF3Tlb7gJAK6tK04R9xys3NJexcBi4NO88995xCQkK0atUqx7p27do5fjbGaMmSJZo5c6aGDx8uSVq9erUCAwO1du1ajR8/Xjk5OVq5cqVef/11DRgwQJK0Zs0ahYSEaPPmzRo0aNBlHRMAAIGBoZKkgIAQBQW1d3Fv4NIJyu+++6569uyp3/3ud2rdurW6deumV155xbE9JSVFGRkZioqKcqzz8vJSZGSkEhMTJUlJSUkqLi52qgkODlZ4eLij5nyFhYXKzc11WgAAgDW5NOx89913WrFihcLCwvTRRx/p0Ucf1RNPPKHXXntNkpSRkSFJCgwMdNovMDDQsS0jI0Oenp5q0aJFpTXnmz9/vvz8/BxLSEj5S4wAAMAaXBp2SktL1b17d8XGxqpbt24aP368HnnkEa1YscKpzmazOT02xpRbd76qambMmKGcnBzHkpaWdmkDAQAA9ZZLw05QUJA6d+7stK5Tp05KTU2VJNntdkkqd4UmMzPTcbXHbrerqKhI2dnZldacz8vLS82aNXNaAACANbk07PTt21eHDh1yWvfNN9+obdu2kqTQ0FDZ7XYlJCQ4thcVFWn79u3q06ePJKlHjx7y8PBwqklPT9f+/fsdNQAA4Mrl0ruxnnzySfXp00exsbEaMWKEvvzyS7388st6+eWXJf389lV0dLRiY2MVFhamsLAwxcbGysfHRyNHjpQk+fn5ady4cZoyZYr8/f3VsmVLTZ06VREREY67swAAwJXLpWHnhhtu0Pr16zVjxgzNnTtXoaGhWrJkiUaNGuWomTZtmgoKCvTYY485PlRw06ZNjs/YkaTFixfL3d1dI0aMcHyoYHx8PJ+xAwAAXP8JykOHDtXQoUMr3W6z2RQTE6OYmJhKa7y9vbV06VItXbq0DnoIAAAaMr4IFAAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWBphBwAAWJpLw05MTIxsNpvTYrfbHduNMYqJiVFwcLAaN26sfv366cCBA05tFBYWatKkSQoICFCTJk10xx136Pjx45d7KAAAoJ5y+ZWdLl26KD093bHs27fPsW3hwoWKi4vTsmXLtGvXLtntdg0cOFB5eXmOmujoaK1fv17r1q3Tjh07dObMGQ0dOlQlJSWuGA4AAKhn3F3eAXd3p6s5ZYwxWrJkiWbOnKnhw4dLklavXq3AwECtXbtW48ePV05OjlauXKnXX39dAwYMkCStWbNGISEh2rx5swYNGnRZxwIAAOofl1/Z+fbbbxUcHKzQ0FDdd999+u677yRJKSkpysjIUFRUlKPWy8tLkZGRSkxMlCQlJSWpuLjYqSY4OFjh4eGOmooUFhYqNzfXaQEAANbk0rDTq1cvvfbaa/roo4/0yiuvKCMjQ3369NGpU6eUkZEhSQoMDHTaJzAw0LEtIyNDnp6eatGiRaU1FZk/f778/PwcS0hISC2PDAAA1BcuDTuDBw/W3XffrYiICA0YMEDvv/++pJ/fripjs9mc9jHGlFt3vgvVzJgxQzk5OY4lLS3tEkYBAADqM5e/jfVLTZo0UUREhL799lvHPJ7zr9BkZmY6rvbY7XYVFRUpOzu70pqKeHl5qVmzZk4LAACwpnoVdgoLC5WcnKygoCCFhobKbrcrISHBsb2oqEjbt29Xnz59JEk9evSQh4eHU016err279/vqAEAAFc2l96NNXXqVN1+++1q06aNMjMzNW/ePOXm5mrMmDGy2WyKjo5WbGyswsLCFBYWptjYWPn4+GjkyJGSJD8/P40bN05TpkyRv7+/WrZsqalTpzreFgMAAHBp2Dl+/Ljuv/9+ZWVlqVWrVrrxxhu1c+dOtW3bVpI0bdo0FRQU6LHHHlN2drZ69eqlTZs2ydfX19HG4sWL5e7urhEjRqigoED9+/dXfHy83NzcXDUsAABQj7g07Kxbt67K7TabTTExMYqJiam0xtvbW0uXLtXSpUtruXcAAMAK6tWcHQAAgNpG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZWo7Bz9dVX69SpU+XWnz59WldfffUldwoAAKC21CjsHD16VCUlJeXWFxYW6vvvv7/kTgEAANQW9+oUv/vuu46fP/roI/n5+Tkel5SUaMuWLWrXrl2tdQ4AAOBSVSvsDBs2TJJks9k0ZswYp20eHh5q166dFi1aVGudAwAAuFTVCjulpaWSpNDQUO3atUsBAQF10ikAAIDaUq2wUyYlJaW2+wEAAFAnahR2JGnLli3asmWLMjMzHVd8yrz66quX3DEAAIDaUKOw88wzz2ju3Lnq2bOngoKCZLPZartfAAAAtaJGt56/+OKLio+P1xdffKENGzZo/fr1TktNzJ8/XzabTdHR0Y51xhjFxMQoODhYjRs3Vr9+/XTgwAGn/QoLCzVp0iQFBASoSZMmuuOOO3T8+PEa9QEAAFhPjcJOUVGR+vTpU2ud2LVrl15++WV17drVaf3ChQsVFxenZcuWadeuXbLb7Ro4cKDy8vIcNdHR0Vq/fr3WrVunHTt26MyZMxo6dGiFnwMEAACuPDUKOw8//LDWrl1bKx04c+aMRo0apVdeeUUtWrRwrDfGaMmSJZo5c6aGDx+u8PBwrV69Wvn5+Y5j5+TkaOXKlVq0aJEGDBigbt26ac2aNdq3b582b95cK/0DAAANW43m7Jw7d04vv/yyNm/erK5du8rDw8Npe1xc3EW3NXHiRA0ZMkQDBgzQvHnzHOtTUlKUkZGhqKgoxzovLy9FRkYqMTFR48ePV1JSkoqLi51qgoODFR4ersTERA0aNKjCYxYWFqqwsNDxODc396L7CwAAGpYahZ29e/fq+uuvlyTt37/faVt1JiuvW7dOX331lXbt2lVuW0ZGhiQpMDDQaX1gYKCOHTvmqPH09HS6IlRWU7Z/RebPn69nnnnmovsJAAAarhqFna1bt17ygdPS0vTHP/5RmzZtkre3d6V154cnY8wFA9WFambMmKHJkyc7Hufm5iokJOQiew4AABqSGs3ZqQ1JSUnKzMxUjx495O7uLnd3d23fvl1/+9vf5O7u7riic/4VmszMTMc2u92uoqIiZWdnV1pTES8vLzVr1sxpAQAA1lSjKzu33HJLlVdOPv744wu20b9/f+3bt89p3e9//3tde+21mj59uq6++mrZ7XYlJCSoW7dukn6+C2z79u167rnnJEk9evSQh4eHEhISNGLECElSenq69u/fr4ULF9ZkaAAAwGJqFHbK5uuUKS4u1tdff639+/eX+4LQyvj6+io8PNxpXZMmTeTv7+9YHx0drdjYWIWFhSksLEyxsbHy8fHRyJEjJUl+fn4aN26cpkyZIn9/f7Vs2VJTp05VRESEBgwYUJOhAQAAi6lR2Fm8eHGF62NiYnTmzJlL6tAvTZs2TQUFBXrssceUnZ2tXr16adOmTfL19XXqi7u7u0aMGKGCggL1799f8fHxcnNzq7V+AACAhqvG341VkdGjR+vXv/61/vKXv9Ro/23btjk9ttlsiomJUUxMTKX7eHt7a+nSpVq6dGmNjgkAAKytVicof/7551XeWQUAAHC51ejKzvDhw50eG2OUnp6u3bt3a9asWbXSMQAAgNpQo7Dj5+fn9LhRo0bq2LGj5s6d6/RpxgAAAK5Wo7CzatWq2u4HAABAnbikCcpJSUlKTk6WzWZT586dHZ+HAwAAUF/UKOxkZmbqvvvu07Zt29S8eXMZY5STk6NbbrlF69atU6tWrWq7nwAAADVSo7uxJk2apNzcXB04cEA//vijsrOztX//fuXm5uqJJ56o7T4CAADUWI2u7Hz44YfavHmzOnXq5FjXuXNnvfDCC0xQBgAA9UqNruyUlpbKw8Oj3HoPDw+VlpZecqcAAABqS43Czq233qo//vGP+uGHHxzrvv/+ez355JPq379/rXUOAADgUtUo7Cxbtkx5eXlq166d2rdvr2uuuUahoaHKy8vjaxsAAEC9UqM5OyEhIfrqq6+UkJCgf//73zLGqHPnznzTOAAAqHeqdWXn448/VufOnZWbmytJGjhwoCZNmqQnnnhCN9xwg7p06aJPP/20TjoKAABQE9UKO0uWLNEjjzyiZs2aldvm5+en8ePHKy4urtY6BwAAcKmqFXb+9a9/6bbbbqt0e1RUlJKSki65UwAAALWlWmHnxIkTFd5yXsbd3V0nT5685E4BAADUlmqFnV/96lfat29fpdv37t2roKCgS+4UAABAbalW2Pntb3+r2bNn69y5c+W2FRQUaM6cORo6dGitdQ4AAOBSVevW8z/96U9655131KFDBz3++OPq2LGjbDabkpOT9cILL6ikpEQzZ86sq74CAABUW7XCTmBgoBITEzVhwgTNmDFDxhhJks1m06BBg7R8+XIFBgbWSUcBAABqotofKti2bVtt3LhR2dnZOnz4sIwxCgsLU4sWLeqifwAAAJekRp+gLEktWrTQDTfcUJt9AQAAqHU1+m4sAACAhoKwAwAALI2wAwAALI2wAwAALI2wAwAALI2wAwAALI2wAwAALI2wAwAALI2wAwAALI2wAwAALI2wAwAALI2wAwAALI2wAwAALI2wAwAALI2wAwAALM2lYWfFihXq2rWrmjVrpmbNmql379764IMPHNuNMYqJiVFwcLAaN26sfv366cCBA05tFBYWatKkSQoICFCTJk10xx136Pjx45d7KAAAoJ5yadi56qqrtGDBAu3evVu7d+/WrbfeqjvvvNMRaBYuXKi4uDgtW7ZMu3btkt1u18CBA5WXl+doIzo6WuvXr9e6deu0Y8cOnTlzRkOHDlVJSYmrhgUAAOoRl4ad22+/Xb/97W/VoUMHdejQQX/+85/VtGlT7dy5U8YYLVmyRDNnztTw4cMVHh6u1atXKz8/X2vXrpUk5eTkaOXKlVq0aJEGDBigbt26ac2aNdq3b582b97syqEBAIB6ot7M2SkpKdG6det09uxZ9e7dWykpKcrIyFBUVJSjxsvLS5GRkUpMTJQkJSUlqbi42KkmODhY4eHhjpqKFBYWKjc312kBAADW5PKws2/fPjVt2lReXl569NFHtX79enXu3FkZGRmSpMDAQKf6wMBAx7aMjAx5enqqRYsWldZUZP78+fLz83MsISEhtTwqAABQX7g87HTs2FFff/21du7cqQkTJmjMmDE6ePCgY7vNZnOqN8aUW3e+C9XMmDFDOTk5jiUtLe3SBgEAAOotl4cdT09PXXPNNerZs6fmz5+v6667Tn/9619lt9slqdwVmszMTMfVHrvdrqKiImVnZ1daUxEvLy/HHWBlCwAAsCaXh53zGWNUWFio0NBQ2e12JSQkOLYVFRVp+/bt6tOnjySpR48e8vDwcKpJT0/X/v37HTUAAODK5u7Kgz/99NMaPHiwQkJClJeXp3Xr1mnbtm368MMPZbPZFB0drdjYWIWFhSksLEyxsbHy8fHRyJEjJUl+fn4aN26cpkyZIn9/f7Vs2VJTp05VRESEBgwY4MqhAQCAesKlYefEiRN64IEHlJ6eLj8/P3Xt2lUffvihBg4cKEmaNm2aCgoK9Nhjjyk7O1u9evXSpk2b5Ovr62hj8eLFcnd314gRI1RQUKD+/fsrPj5ebm5urhoWAACoR1wadlauXFnldpvNppiYGMXExFRa4+3traVLl2rp0qW13DsAAGAF9W7ODgAAQG0i7AAAAEsj7AAAAEsj7AAAAEsj7AAAAEsj7AAAAEtz6a3nAABcjNTUVGVlZdV6uwEBAWrTpk2tt4v6hbADAKjXUlNT1alTJ+Xn59d62z4+PkpOTibwWBxhBwBQr2VlZSk/P19rJk9Wp5CQWms3OS1No+PilJWVRdixOMIOAKBB6BQSou7t27u6G2iAmKAMAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAszd3VHQAAoLpOnjyp3NzcKmuaNWumVq1aXaYeoT4j7AAAGpSTJ09qwoQJKiwqqrLOy9NTK1asIPCAsAMAaFhyc3NVWFSkYXdOVkBASIU1WVlp2vCPOOXm5hJ2QNgBADRMAQEhCgpq7+puoAFggjIAALA0wg4AALA0wg4AALA0wg4AALA0wg4AALA0wg4AALA0wg4AALA0wg4AALA0l4ad+fPn64YbbpCvr69at26tYcOG6dChQ041xhjFxMQoODhYjRs3Vr9+/XTgwAGnmsLCQk2aNEkBAQFq0qSJ7rjjDh0/fvxyDgUAANRTLg0727dv18SJE7Vz504lJCTop59+UlRUlM6ePeuoWbhwoeLi4rRs2TLt2rVLdrtdAwcOVF5enqMmOjpa69ev17p167Rjxw6dOXNGQ4cOVUlJiSuGBQAA6hGXfl3Ehx9+6PR41apVat26tZKSknTzzTfLGKMlS5Zo5syZGj58uCRp9erVCgwM1Nq1azV+/Hjl5ORo5cqVev311zVgwABJ0po1axQSEqLNmzdr0KBBl31cAACg/qhXc3ZycnIkSS1btpQkpaSkKCMjQ1FRUY4aLy8vRUZGKjExUZKUlJSk4uJip5rg4GCFh4c7agAAwJWr3nwRqDFGkydP1m9+8xuFh4dLkjIyMiRJgYGBTrWBgYE6duyYo8bT01MtWrQoV1O2//kKCwtVWFjoeJybm1tr4wAAAPVLvbmy8/jjj2vv3r36+9//Xm6bzWZzemyMKbfufFXVzJ8/X35+fo4lJCSk5h0HAAD1Wr0IO5MmTdK7776rrVu36qqrrnKst9vtklTuCk1mZqbjao/dbldRUZGys7MrrTnfjBkzlJOT41jS0tJqczgAAKAecWnYMcbo8ccf1zvvvKOPP/5YoaGhTttDQ0Nlt9uVkJDgWFdUVKTt27erT58+kqQePXrIw8PDqSY9PV379+931JzPy8tLzZo1c1oAAIA1uXTOzsSJE7V27Vr94x//kK+vr+MKjp+fnxo3biybzabo6GjFxsYqLCxMYWFhio2NlY+Pj0aOHOmoHTdunKZMmSJ/f3+1bNlSU6dOVUREhOPuLAAAcOVyadhZsWKFJKlfv35O61etWqWHHnpIkjRt2jQVFBToscceU3Z2tnr16qVNmzbJ19fXUb948WK5u7trxIgRKigoUP/+/RUfHy83N7fLNRQAAFBPuTTsGGMuWGOz2RQTE6OYmJhKa7y9vbV06VItXbq0FnsHAACsoF5MUAYAAKgrhB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBpLg07n3zyiW6//XYFBwfLZrNpw4YNTtuNMYqJiVFwcLAaN26sfv366cCBA041hYWFmjRpkgICAtSkSRPdcccdOn78+GUcBQAAqM9cGnbOnj2r6667TsuWLatw+8KFCxUXF6dly5Zp165dstvtGjhwoPLy8hw10dHRWr9+vdatW6cdO3bozJkzGjp0qEpKSi7XMAAAqJG0tDQdOXKkyuXkyZOu7maD5+7Kgw8ePFiDBw+ucJsxRkuWLNHMmTM1fPhwSdLq1asVGBiotWvXavz48crJydHKlSv1+uuva8CAAZKkNWvWKCQkRJs3b9agQYMu21gAALhYZ878KElaFBd3wVovT0+tWLFCrVq1qutuWZZLw05VUlJSlJGRoaioKMc6Ly8vRUZGKjExUePHj1dSUpKKi4udaoKDgxUeHq7ExMRKw05hYaEKCwsdj3Nzc+tuIAAAnOfcubOSpFv6jVX79hGV1mVlpWnDP+KUm5tL2LkE9TbsZGRkSJICAwOd1gcGBurYsWOOGk9PT7Vo0aJcTdn+FZk/f76eeeaZWu4xAADV4+dnV1BQe1d3w/LqbdgpY7PZnB4bY8qtO9+FambMmKHJkyc7Hufm5iokJOTSOgoAV7jU1FRlZWVdUhvp6ek6ffq007qUlBRJP89v8fvPf1E3auMcViQgIEBt2rSp9XYvVr0NO3a7XdLPV2+CgoIc6zMzMx1Xe+x2u4qKipSdne10dSczM1N9+vSptG0vLy95eXnVUc8B4MqTmpqqTp06KT8/v86OsSguTn6/eHzmzJk6O9aVqC7PoY+Pj5KTk10WeOpt2AkNDZXdbldCQoK6desmSSoqKtL27dv13HPPSZJ69OghDw8PJSQkaMSIEZJ+/lfB/v37tXDhQpf1HQCuNFlZWcrPz9eayZPVqYZXytPS0rQoLk79IkepefP/TmFISkvW2q8+UL/IUepxTU8dPrxb27a/oXPnCmqr+5DzObQ3barY2FgV//RTlft4uLvr6aefLjed5JeS09I0Oi5OWVlZV2bYOXPmjA4fPux4nJKSoq+//lotW7ZUmzZtFB0drdjYWIWFhSksLEyxsbHy8fHRyJEjJUl+fn4aN26cpkyZIn9/f7Vs2VJTp05VRESE4+4sAMDl0ykkRN3b12wOit9/lh7X9HSax3JGkr76QM2bByooqL2ysngbqy51CgmRnySfn37SsDsnKyCg4vBaNnm6XYsWal/Dc365uDTs7N69W7fccovjcdk8mjFjxig+Pl7Tpk1TQUGBHnvsMWVnZ6tXr17atGmTfH19HfssXrxY7u7uGjFihAoKCtS/f3/Fx8fLzc3tso8HAAArCQgIscQEapeGnX79+skYU+l2m82mmJgYxcTEVFrj7e2tpUuXaunSpXXQQwAA0NDx3VgAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDS3F3dAQAAUD3JyckNos36grADAEA9l5aWJkn66sABSdLo0aPr7FjZ2dnya9Giztp3BcIOAAD11JkzP0qSFsXFSZK+/8/66yX5nlfr4e6up59+Wi0uEFSys7N15syZcuu3Jydr8Qcf6MiRI3ILDLy0jtczhB0AAOqpc+fOSpJu6TdW7dtHaPvh3dqz/Q3dHjlKPa7p6ajLykrThn/EqV2LFmrfvn2l7Z08eVKx06ersKio3LayILXmjTfk95+fKwpFDRFhBwBgWWVv/1S1LT09/XJ1p8b8/OwKCmqv5lk/97l580AFBVUeaiqTm5urwqIiDbtzsgICQpy2lQWpfpGj5Cdp2/Y3dO5cQW103+UIOwAAyzn/7Z+K5Pznv/fcc48OHTqkNm3aXIae1Q8BASHlwtIvg5RfRTs1YIQdAIDlnP/2T0WOZKXp03/E6dy5c/r000/VqVOnSz5u2R1NJ06kXHJbqD2EHQBAnTt58qRyc3OrrKnqLaeaKnv7pyLfncl2/Fzbdze98cYsSdKZXxwDrkPYAYArTGpqqrKysmq1zao+o+XkyZOaMGFChZNiK3K5JsXmnfv5ONdLipk8WSEhIVXWX4y0tDQtiotTSPfBWvvVBzp3zhoTfBs6wg4AXEFSU1PVqVMn5efn10n72dnlr2RUNSn2lw4f3u2SSbG+ksJDQqq8i0m6uKtTuZL8JAX6tqy1/uHSEXYAoB6q7tWX9PR0nT59+oJ1WVlZys/P15rJk9WpiisZlX0Wy/maNm2qFi1aaOPu3Zr1xhtV7lPRpFjnvtX+21i1pbpXp86dK6zjHqE6CDsAUM/U9dUXSbI3barulVzJqOqzWM7n5empFStWKNRiH0J3vupenSouvrhQhMvDMmFn+fLlev7555Wenq4uXbpoyZIluummm1zdLQAWdilzX6q6EpOSkqL8/HwtGj1a11199QU/Ebdsnki/yFFq3rzy0HH69Am9uf0NfaOq58Vc7At72QfZXeitHStpyFenrmSWCDtvvvmmoqOjtXz5cvXt21cvvfSSBg8erIMHD15Rn5sA4PK5HFdfNqxZo8T/XDlp1apVpXV+/1l6XNOzyhfi9PQjem/7Gxd9/Au9sAMNhSXCTlxcnMaNG6eHH35YkrRkyRJ99NFHWrFihebPn+/SvtXFXQ9lAgICCHOAi1zs3JeKXOhKTFJastZ+9YF6dB+sw199oNzc3CrDDi7dhW57r4vb4nH5NPiwU1RUpKSkJD311FNO66OiopSYmOiiXv2srv/l5+Pjo+TkZAIP4EKdQkKc5r5U546dyq7EnJGkrz6Q73/u6KmLF+ITJ07oyJEjtdJeWlqaTpw4UWm7DSEoVPVJy79kle+Kqk0NISg2+LCTlZWlkpISBZ43OS4wMFAZGRkV7lNYWKjCwv/OlM/J+flDw2v7feejR48qPz9f/3PXXQqp5X+VpZ08qefXr9dHH32kjh071mrbktSoUSOVlpY2mHbrsm36fHnabmh9PnTokCQp6fBhnTl3TpJ0+vRpLfrLX1RcUnJRbWz911a1Tj9cbv3+739ue2/qAZ2S9PRFvhBX1l6ZEyeOquz/csveeEPxb1T9ltbFtFfWv8yLaPdC7R3//pBOSfrq2B6dKM5xrC97Pv51dK/OFRdWWncxbf1SWbunJYW276VWrYIr7dvJk6n69kiSEg8l6lhexa8tvzzuuaxjTn2uSf8qqjv/uSiTk3NSpyS99/nnan248uc48+TPdYn//lx+552LX7bdRLpg/355/qtSFg+PHDmia665psra6ip73TbGVF1oGrjvv//eSDKJiYlO6+fNm2c6duxY4T5z5swxklhYWFhYWFgssKSlpVWZFRr8lZ2AgAC5ubmVu4qTmZlZ7mpPmRkzZmjy5MmOx6Wlpfrxxx/l7+8vm81Wa33Lzc1VSEiI0tLS1KxZs1prtyFg7Ffe2K/UcUuM/Uoc+5U6bql+jd0Yo7y8PAUHV35VTrLA21ienp7q0aOHEhISdNdddznWJyQk6M4776xwHy8vL3l5eTmta968eZ31sVmzZi7/hXAVxn7ljf1KHbfE2K/EsV+p45bqz9j9/PwuWNPgw44kTZ48WQ888IB69uyp3r176+WXX1ZqaqoeffRRV3cNAAC4mCXCzr333qtTp05p7ty5Sk9PV3h4uDZu3Ki2bdu6umsAAMDFLBF2JOmxxx7TY4895upuOPHy8tKcOXPKvWV2JWDsV97Yr9RxS4z9Shz7lTpuqWGO3WbMhe7XAgAAaLgauboDAAAAdYmwAwAALI2wAwAALI2wAwAALI2wc4mWL1+u0NBQeXt7q0ePHvr000+rrN++fbt69Oghb29vXX311XrxxRcvU09rz/z583XDDTfI19dXrVu31rBhwxzfE1SZbdu2yWazlVv+/e9/X6Ze146YmJhyY7Db7VXuY4Vz3q5duwrP38SJEyusb8jn+5NPPtHtt9+u4OBg2Ww2bdiwwWm7MUYxMTEKDg5W48aN1a9fPx04cOCC7b799tvq3LmzvLy81LlzZ61fv76ORlBzVY29uLhY06dPV0REhJo0aaLg4GA9+OCD+uGHH6psMz4+vsLfhXP/+T6x+uBC5/yhhx4q1/8bb7zxgu029HMuqcJzZ7PZ9Pzzz1faZn0854SdS/Dmm28qOjpaM2fO1J49e3TTTTdp8ODBSk1NrbA+JSVFv/3tb3XTTTdpz549evrpp/XEE0/o7bffvsw9vzTbt2/XxIkTtXPnTiUkJOinn35SVFSUzp49e8F9Dx06pPT0dMcSFhZ2GXpcu7p06eI0hn379lVaa5VzvmvXLqcxJyQkSJJ+97vfVblfQzzfZ8+e1XXXXadly5ZVuH3hwoWKi4vTsmXLtGvXLtntdg0cOFB5eXmVtvn555/r3nvv1QMPPKB//etfeuCBBzRixAh98cUXdTWMGqlq7Pn5+frqq680a9YsffXVV3rnnXf0zTff6I477rhgu82aNXP6PUhPT5e3t3ddDKFGLnTOJem2225z6v/GjRurbNMK51xSufP26quvymaz6e67766y3Xp3zmvl2zivUL/+9a/No48+6rTu2muvNU899VSF9dOmTTPXXnut07rx48ebG2+8sc76eDlkZmYaSWb79u2V1mzdutVIMtnZ2ZevY3Vgzpw55rrrrrvoeque8z/+8Y+mffv2prS0tMLtVjnfksz69esdj0tLS43dbjcLFixwrDt37pzx8/MzL774YqXtjBgxwtx2221O6wYNGmTuu+++Wu9zbTl/7BX58ssvjSRz7NixSmtWrVpl/Pz8ardzdaiicY8ZM8bceeed1WrHquf8zjvvNLfeemuVNfXxnHNlp4aKioqUlJSkqKgop/VRUVFKTEyscJ/PP/+8XP2gQYO0e/duFRcX11lf61pOTo4kqWXLlhes7datm4KCgtS/f39t3bq1rrtWJ7799lsFBwcrNDRU9913n7777rtKa614zouKirRmzRqNHTv2gl+ca4Xz/UspKSnKyMhwOqdeXl6KjIys9O9eqvz3oKp9GoKcnBzZbLYLfrfgmTNn1LZtW1111VUaOnSo9uzZc3k6WIu2bdum1q1bq0OHDnrkkUeUmZlZZb0Vz/mJEyf0/vvva9y4cResrW/nnLBTQ1lZWSopKSn3zeqBgYHlvoG9TEZGRoX1P/30k7Kysuqsr3XJGKPJkyfrN7/5jcLDwyutCwoK0ssvv6y3335b77zzjjp27Kj+/fvrk08+uYy9vXS9evXSa6+9po8++kivvPKKMjIy1KdPH506darCeiue8w0bNuj06dN66KGHKq2xyvk+X9nfdnX+7sv2q+4+9d25c+f01FNPaeTIkVV+GeS1116r+Ph4vfvuu/r73/8ub29v9e3bV99+++1l7O2lGTx4sN544w19/PHHWrRokXbt2qVbb71VhYWFle5jxXO+evVq+fr6avjw4VXW1cdzbpmvi3CV8/9la4yp8l+7FdVXtL6hePzxx7V3717t2LGjyrqOHTuqY8eOjse9e/dWWlqa/vKXv+jmm2+u627WmsGDBzt+joiIUO/evdW+fXutXr1akydPrnAfq53zlStXavDgwQoODq60xirnuzLV/buv6T71VXFxse677z6VlpZq+fLlVdbeeOONTpN5+/btq+7du2vp0qX629/+VtddrRX33nuv4+fw8HD17NlTbdu21fvvv1/lC7+Vzrkkvfrqqxo1atQF597Ux3POlZ0aCggIkJubW7mUnpmZWS7Nl7Hb7RXWu7u7y9/fv876WlcmTZqkd999V1u3btVVV11V7f1vvPHGBvWvu4o0adJEERERlY7Dauf82LFj2rx5sx5++OFq72uF81125111/u7L9qvuPvVVcXGxRowYoZSUFCUkJFR5VacijRo10g033NCgfxeCgoLUtm3bKsdgpXMuSZ9++qkOHTpUo7/9+nDOCTs15OnpqR49ejjuSimTkJCgPn36VLhP7969y9Vv2rRJPXv2lIeHR531tbYZY/T444/rnXfe0ccff6zQ0NAatbNnzx4FBQXVcu8ur8LCQiUnJ1c6Dquc8zKrVq1S69atNWTIkGrva4XzHRoaKrvd7nROi4qKtH379kr/7qXKfw+q2qc+Kgs63377rTZv3lyjwG6M0ddff92gfxdOnTqltLS0KsdglXNeZuXKlerRo4euu+66au9bL865q2ZGW8G6deuMh4eHWblypTl48KCJjo42TZo0MUePHjXGGPPUU0+ZBx54wFH/3XffGR8fH/Pkk0+agwcPmpUrVxoPDw/z1ltvuWoINTJhwgTj5+dntm3bZtLT0x1Lfn6+o+b8sS9evNisX7/efPPNN2b//v3mqaeeMpLM22+/7Yoh1NiUKVPMtm3bzHfffWd27txphg4danx9fS1/zo0xpqSkxLRp08ZMnz693DYrne+8vDyzZ88es2fPHiPJxMXFmT179jjuOFqwYIHx8/Mz77zzjtm3b5+5//77TVBQkMnNzXW08cADDzjdlfnZZ58ZNzc3s2DBApOcnGwWLFhg3N3dzc6dOy/7+KpS1diLi4vNHXfcYa666irz9ddfO/3tFxYWOto4f+wxMTHmww8/NEeOHDF79uwxv//97427u7v54osvXDHEClU17ry8PDNlyhSTmJhoUlJSzNatW03v3r3Nr371K8uf8zI5OTnGx8fHrFixosI2GsI5J+xcohdeeMG0bdvWeHp6mu7duzvdfj1mzBgTGRnpVL9t2zbTrVs34+npadq1a1fpL099JqnCZdWqVY6a88f+3HPPmfbt2xtvb2/TokUL85vf/Ma8//77l7/zl+jee+81QUFBxsPDwwQHB5vhw4ebAwcOOLZb9ZwbY8xHH31kJJlDhw6V22al81122/z5y5gxY4wxP99+PmfOHGO3242Xl5e5+eabzb59+5zaiIyMdNSX+b//+z/TsWNH4+HhYa699tp6GfyqGntKSkqlf/tbt251tHH+2KOjo02bNm2Mp6enadWqlYmKijKJiYmXf3BVqGrc+fn5JioqyrRq1cp4eHiYNm3amDFjxpjU1FSnNqx4zsu89NJLpnHjxub06dMVttEQzrnNmP/MlgQAALAg5uwAAABLI+wAAABLI+wAAABLI+wAAABLI+wAAABLI+wAAABLI+wAAABLI+wAAABLI+wAAABLI+wAsKTi4mJXdwFAPUHYAVCvvPXWW4qIiFDjxo3l7++vAQMG6OzZs5KkV199VV26dJGXl5eCgoL0+OOPO/az2Wx68cUXdeedd6pJkyaaN2+eJOmf//ynevToIW9vb1199dV65pln9NNPPzn2y8nJ0R/+8Ae1bt1azZo106233qp//etfju0xMTG6/vrr9frrr6tdu3by8/PTfffdp7y8vMv0jAC4VIQdAPVGenq67r//fo0dO1bJycnatm2bhg8fLmOMVqxYoYkTJ+oPf/iD9u3bp3fffVfXXHON0/5z5szRnXfeqX379mns2LH66KOPNHr0aD3xxBM6ePCgXnrpJcXHx+vPf/6zJMkYoyFDhigjI0MbN25UUlKSunfvrv79++vHH390tHvkyBFt2LBB7733nt577z1t375dCxYsuKzPDYBL4NKvIQWAX0hKSjKSzNGjR8ttCw4ONjNnzqx0X0kmOjraad1NN91kYmNjnda9/vrrJigoyBhjzJYtW0yzZs3MuXPnnGrat29vXnrpJWOMMXPmzDE+Pj4mNzfXsf1//ud/TK9evao3OAAu4+7qsAUAZa677jr1799fERERGjRokKKionTPPfeouLhYP/zwg/r371/l/j179nR6nJSUpF27djmu5EhSSUmJzp07p/z8fCUlJenMmTPy9/d32q+goEBHjhxxPG7Xrp18fX0dj4OCgpSZmXkpQwVwGRF2ANQbbm5uSkhIUGJiojZt2qSlS5dq5syZ2rJly0Xt36RJE6fHpaWleuaZZzR8+PBytd7e3iotLVVQUJC2bdtWbnvz5s0dP3t4eDhts9lsKi0tvag+AXA9wg6AesVms6lv377q27evZs+erbZt2yohIUHt2rXTli1bdMstt1x0W927d9ehQ4fKze355faMjAy5u7urXbt2tTQCAPUNYQdAvfHFF19oy5YtioqKUuvWrfXFF1/o5MmT6tSpk2JiYvToo4+qdevWGjx4sPLy8vTZZ59p0qRJlbY3e/ZsDR06VCEhIfrd736nRo0aae/evdq3b5/mzZunAQMGqHfv3ho2bJiee+45dezYUT/88IM2btyoYcOGlXtbDEDDRNgBUG80a9ZMn3zyiZYsWaLc3Fy1bdtWixYt0uDBgyVJ586d0+LFizV16lQFBATonnvuqbK9QYMG6b333tPcuXO1cOFCeXh46Nprr9XDDz8s6eerSBs3btTMmTM1duxYnTx5Una7XTfffLMCAwPrfLwALg+bMca4uhMAAAB1hc/ZAQAAlkbYAQAAlkbYAQAAlkbYAQAAlkbYAQAAlkbYAQAAlkbYAQAAlkbYAQAAlkbYAQAAlkbYAQAAlkbYAQAAlkbYAQAAlvb/AZuSZnF9vXV1AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "sns.histplot(\n",
    "    df_train.screen.fillna(mean_screen), bins=20, color=\"blue\", alpha=0.3, label=\"mean\"\n",
    ")\n",
    "sns.histplot(df_train.screen.fillna(0), bins=20, color=\"red\", alpha=0.3, label=\"zero\")\n",
    "plt.legend()\n",
    "plt.title(\"Screen distribution\")\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_linear_regression(X, y):\n",
    "    ones = np.ones(X.shape[0])\n",
    "    X = np.column_stack([ones, X])\n",
    "\n",
    "    XTX = X.T.dot(X)\n",
    "    XTX_inv = np.linalg.inv(XTX)\n",
    "    w = XTX_inv.dot(X.T).dot(y)\n",
    "\n",
    "    return w[0], w[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Evaluate models\n",
    "def rmse(y, y_pred):\n",
    "    error = y - y_pred\n",
    "    mse = (error**2).mean()\n",
    "    return np.sqrt(mse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "w0_median, w_median = train_linear_regression(X_train_mean, y_train)\n",
    "y_pred_median = w0_median + X_val_mean.dot(w_median)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "w0_zero, w_zero = train_linear_regression(X_train_zero, y_train)\n",
    "y_pred_zero = w0_zero + X_val_zero.dot(w_zero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Use the validation dataset to evaluate the models and compare the RMSE of each option.\n",
    "* Round the RMSE scores to 2 decimal digits using `round(score, 2)`\n",
    "* Which option gives better RMSE?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE for model with median filled values:\t  600.27\n",
      "RMSE for model with 0 filled values:\t\t  597.36\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    \"RMSE for model with median filled values:\\t \", rmse(y_val, y_pred_median).round(2)\n",
    ")\n",
    "print(\"RMSE for model with 0 filled values:\\t\\t \", rmse(y_val, y_pred_zero).round(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Option with 0 filled values gives better RMSE."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Now let's train a regularized linear regression.\n",
    "* For this question, fill the NAs with 0.\n",
    "* Try different values of `r` from this list:`[0, 0.01, 0.1, 1, 5, 10, 100]`.\n",
    "* Use RMSE to evaluate the model on the validation dataset.\n",
    "* Round the RMSE scores to 2 decimal digits.\n",
    "* Which `r` gives the best RMSE?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_X(df):\n",
    "    df = df.copy()\n",
    "    df = df.fillna(0)\n",
    "\n",
    "    X = df.values\n",
    "    return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_linear_regression_reg(X, y, r=0.001):\n",
    "    ones = np.ones(X.shape[0])\n",
    "    X = np.column_stack([ones, X])\n",
    "\n",
    "    XTX = X.T.dot(X)\n",
    "    XTX = XTX + r * np.eye(XTX.shape[0])\n",
    "\n",
    "    XTX_inv = np.linalg.inv(XTX)\n",
    "    w = XTX_inv.dot(X.T).dot(y)\n",
    "\n",
    "    return w[0], w[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r:      0 - rmse: 597.36\n",
      "r:   0.01 - rmse: 597.36\n",
      "r:    0.1 - rmse: 597.35\n",
      "r:      1 - rmse: 597.21\n",
      "r:      5 - rmse: 597.01\n",
      "r:     10 - rmse: 597.06\n",
      "r:    100 - rmse: 597.90\n"
     ]
    }
   ],
   "source": [
    "X_train = prepare_X(df_train)\n",
    "X_val = prepare_X(df_val)\n",
    "for r in [0, 0.01, 0.1, 1, 5, 10, 100]:\n",
    "    w0, w = train_linear_regression_reg(X_train, y_train, r=r)\n",
    "\n",
    "    y_pred = w0 + X_val.dot(w)\n",
    "    score = rmse(y_val, y_pred)\n",
    "\n",
    "    print(\"r: %06s - rmse: %0.2f\" % (r, score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "r = 5 gives the best RMSE. But it is not in the list of possible options. So, the best option from the list is r = 10."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* We used seed 42 for splitting the data. Let's find out how selecting the seed influences our score.\n",
    "* Try different seed values: `[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]`.\n",
    "* For each seed, do the train/validation/test split with 60%/20%/20% distribution.\n",
    "* Fill the missing values with 0 and train a model without regularization.\n",
    "* For each seed, evaluate the model on the validation dataset and collect the RMSE scores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_X(df, fillna_value):\n",
    "    df = df.fillna(fillna_value)\n",
    "    X = df.values\n",
    "    return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seed\t RMSE\n",
      "----\t ----\n",
      "0\t 565.45\n",
      "1\t 636.80\n",
      "2\t 588.96\n",
      "3\t 597.81\n",
      "4\t 571.96\n",
      "5\t 573.24\n",
      "6\t 647.34\n",
      "7\t 550.44\n",
      "8\t 587.33\n",
      "9\t 576.10\n"
     ]
    }
   ],
   "source": [
    "rmses = []\n",
    "\n",
    "for s in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:\n",
    "    n = len(df_small)\n",
    "\n",
    "    n_val = int(0.2 * n)\n",
    "    n_test = int(0.2 * n)\n",
    "    n_train = n - (n_val + n_test)\n",
    "\n",
    "    idx = np.arange(n)\n",
    "    np.random.seed(s)\n",
    "    np.random.shuffle(idx)\n",
    "\n",
    "    df_shuffled = df_small.iloc[idx]\n",
    "\n",
    "    df_train = df_shuffled.iloc[:n_train].copy()\n",
    "    df_val = df_shuffled.iloc[n_train : n_train + n_val].copy()\n",
    "    df_test = df_shuffled.iloc[n_train + n_val :].copy()\n",
    "\n",
    "    df_train = df_train.reset_index(drop=True)\n",
    "    df_val = df_val.reset_index(drop=True)\n",
    "    df_test = df_test.reset_index(drop=True)\n",
    "\n",
    "    y_train = df_train.final_price.values\n",
    "    y_val = df_val.final_price.values\n",
    "    y_test = df_test.final_price.values\n",
    "\n",
    "\n",
    "    del df_train[\"final_price\"]\n",
    "    del df_val[\"final_price\"]\n",
    "    del df_test[\"final_price\"]\n",
    "\n",
    "    X_train = prepare_X(df_train, fillna_value=0)\n",
    "    w_0, w = train_linear_regression(X_train, y_train)\n",
    "\n",
    "    X_val = prepare_X(df_val, fillna_value=0)\n",
    "    y_pred = w_0 + X_val.dot(w)\n",
    "\n",
    "    result = rmse(y_val, y_pred)\n",
    "\n",
    "    rmses.append(result)\n",
    "\n",
    "# Print results\n",
    "print(\"Seed\\t RMSE\")\n",
    "print(\"----\\t ----\")\n",
    "for s, r in enumerate(rmses):\n",
    "    print(f\"{s}\\t {r:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* What's the standard deviation of all the scores? To compute the standard deviation, use `np.std`.\n",
    "* Round the result to 3 decimal digits (`round(std, 3)`)\n",
    "\n",
    "What's the value of std?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of std is:  29.176\n"
     ]
    }
   ],
   "source": [
    "print(\"The value of std is: \", np.std(rmses).round(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Split the dataset like previously, use seed 9."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = len(df_small)\n",
    "\n",
    "n_val = int(0.2 * n)\n",
    "n_test = int(0.2 * n)\n",
    "n_train = n - (n_val + n_test)\n",
    "\n",
    "idx = np.arange(n)\n",
    "np.random.seed(9)\n",
    "np.random.shuffle(idx)\n",
    "\n",
    "df_shuffled = df_small.iloc[idx]\n",
    "\n",
    "df_train = df_shuffled.iloc[:n_train].copy()\n",
    "df_val = df_shuffled.iloc[n_train : n_train + n_val].copy()\n",
    "df_test = df_shuffled.iloc[n_train + n_val :].copy()\n",
    "\n",
    "df_train = df_train.reset_index(drop=True)\n",
    "df_val = df_val.reset_index(drop=True)\n",
    "df_test = df_test.reset_index(drop=True)\n",
    "\n",
    "y_train = df_train.final_price.values\n",
    "y_val = df_val.final_price.values\n",
    "y_test = df_test.final_price.values\n",
    "\n",
    "\n",
    "del df_train[\"final_price\"]\n",
    "del df_val[\"final_price\"]\n",
    "del df_test[\"final_price\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Combine train and validation datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_full_train = pd.concat([df_train, df_val])\n",
    "df_full_train = df_full_train.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Fill the missing values with 0 and train a model with `r=0.001`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_full_train = prepare_X(df_full_train, fillna_value=0)\n",
    "y_full_train = np.concatenate([y_train, y_val])\n",
    "\n",
    "w_0, w = train_linear_regression_reg(X_full_train, y_full_train, r=0.001)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* What's the RMSE on the test dataset?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The RMSE for the model is:  608.61\n"
     ]
    }
   ],
   "source": [
    "X_test = prepare_X(df_test, fillna_value=0)\n",
    "y_pred = w_0 + X_test.dot(w)\n",
    "\n",
    "result = rmse(y_test, y_pred)\n",
    "\n",
    "print(f\"The RMSE for the model is: \", result.round(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework URL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Homework 02](https://github.com/TillMeineke/ML_Zoomcamp2024_hw/blob/main/02-regression/homework_02_till_meineke.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning in public links (optional) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [x] Learn in public 1: weekly learning [LinkedIn](https://www.linkedin.com/pulse/learning-ml-zoomcamp-week-1-introduction-till-meineke-k05mc) on 30 September 2024\n",
    "- [x] Learn in public 2 & 3: [California housing dataset](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.fetch_california_housing.html) - EDA & predict the price of a house\n",
    "  - [x] [Slack](https://datatalks-club.slack.com/archives/C0288NJ5XSA/p1728512104462489) on 10 October 2024\n",
    "  - [x] [linkedin](https://www.linkedin.com/pulse/eda-california-housing-dataset-till-meineke-pr3mf) on 9 October 2024\n",
    "- [x] Learn in public 4 & 5: Setup iTerm2 for ML Zoomcamp\n",
    "  - [x] [medium.com](https://medium.com/@till.meineke/costumize-your-terminal-for-ml-zoomcamp-2024-b1530b6a6bf0) on 9 October 2024\n",
    "  - [x] [linkedIn](https://www.linkedin.com/posts/tillmeineke_costumize-your-terminal-for-ml-zoomcamp-2024-activity-7249898785428963328-1rcC?utm_source=share&utm_medium=member_desktop) on 9 October 2024\n",
    "- [x] Learn in public 6: Importance of cell order execution [Slack](https://datatalks-club.slack.com/archives/C0288NJ5XSA/p1728406911333039?thread_ts=1728406320.928139&cid=C0288NJ5XSA) on 8 October 2024\n",
    "- [x] Learn in public 7: Nobel price for AI in Physiks and Chemistry [Slack](https://datatalks-club.slack.com/archives/C0288NJ5XSA/p1728473909631359?thread_ts=1728421282.172389&channel=C0288NJ5XSA&message_ts=1728473909.631359) on 9 October 2024\n",
    "- [ ] Learn in public 8: [Student Performance Data Set](https://archive.ics.uci.edu/dataset/320/student+performance)\n",
    "- [ ] Learn in public 9: [UCI ML datasets](https://archive.ics.uci.edu/datasets)\n",
    "- [ ] Learn in public 10: [Default prediction](https://archive.ics.uci.edu/dataset/350/default+of+credit+card+clients)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Time spent on lectures (hours) (optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Time spent on homework (hours) (optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FAQ contribution (FAQ document, optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Added Link for 2024 Leaderboard"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ML_Zoomcamp2024",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}