_6_Обучение с учителем в Scikit-learn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Обучение с учителем в Scikit-learn\n",
    "\n",
    "На предыдущих уроках мы изучили инструменты, которые позволяют работать с данными: загружать, просматривать, фильтровать, преобразовывать, визуализировать. Всё это делалось с помощью библиотек `numpy`, `pandas` и `matplotlib`. Такая работа позволяет получить представление об информации, содержащейся в данных, и сделать какие-то выводы.\n",
    "\n",
    "Когда данных имеется достаточное количество, можно доверить получение выводов по этим данным в руки специальным алгоритмам, умеющим в зависимости от поставленной задачи прогнозировать интересующую нас величину, классифицировать объекты или разбивать их на группы.\n",
    "\n",
    "Совокупность таких алгоритмов образует дисциплину под названием _Машинное обучение_. Эту дисциплину можно разделить на две основные части: обучение с учителем и обучение без учителя. \n",
    "\n",
    "На этом уроке мы рассмотрим обучение с учителем. Основная особенность этого вида обучения состоит в том, что помимо набора данных, по которым мы хотим предсказать ту или иную величину, у нас имеется для этих данных набор правильных ответов. Наша задача в этом случае - построить модель, которая будет способна наиболее точно _обобщать_ эти данные, то есть предсказывать этот правильный ответ по данным, в которых этого правильного ответа у нас нет.\n",
    "\n",
    "## Линейная регрессия\n",
    "\n",
    "Первый алгоритм, который мы рассмотрим - _Линейная регрессия_ - предназначен для предсказания непрерывной величины. Например, это может быть цена на какой-то товар, какой-то физический показатель или иная характеристика, представляющая собой, например, вещественное число. _Задачи регрессии_ - это как раз тип задач, в которых предсказываются такого рода величины.\n",
    "\n",
    "Для решения задач машинного обучения можно использовать библиотеку `scikit-learn` (сокращённо `sklearn`). В этой библиотеке помимо готовых реализаций алгоритмов и моделей машинного обучения есть также средства для предобработки данных и многое другое.\n",
    "\n",
    "Также в библиотеке `sklearn` имеется набор датасетов, которые удобно использовать для знакомства с библиотекой, и на которых можно пробовать различные алгоритмы машинного обучения. Для изучения алгоритма линейной регрессии мы возьмём датасет, содержащий цены на недвижимость в Бостоне различные характеристики этой недвижимости. Для начала загрузим этот датасет:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from sklearn.datasets import load_boston"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функция `load_boston` загружает датасет. Загрузим его в переменную `boston`. Этот датасет представлен в виде словаря. Посмотрим, какие у этого словаря есть ключи:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['data', 'target', 'feature_names', 'DESCR', 'filename'])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "boston = load_boston()\n",
    "\n",
    "boston.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Данные о недвижимости хранятся в массиве по ключу `\"data\"`. Посмотрим поближе на эти данные."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(506, 13)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = boston[\"data\"]\n",
    "\n",
    "data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы видим, что это массив из 506 строк и 13 столбцов. Здесь каждая строка отвечает какому-то объекту (в нашем случае - объекту недвижимости), а столбцы - каким-то его характеристикам. Названия этих признаков хранятся в массиве по ключу `\"feature_names\"`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD',\n",
       "       'TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='<U7')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "feature_names = boston[\"feature_names\"]\n",
    "\n",
    "feature_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Не совсем ясно, что представляют из себя эти признаки. Описание всего датасета можно получить по ключу `\"DESCR\"`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".. _boston_dataset:\n",
      "\n",
      "Boston house prices dataset\n",
      "---------------------------\n",
      "\n",
      "**Data Set Characteristics:**  \n",
      "\n",
      "    :Number of Instances: 506 \n",
      "\n",
      "    :Number of Attributes: 13 numeric/categorical predictive. Median Value (attribute 14) is usually the target.\n",
      "\n",
      "    :Attribute Information (in order):\n",
      "        - CRIM     per capita crime rate by town\n",
      "        - ZN       proportion of residential land zoned for lots over 25,000 sq.ft.\n",
      "        - INDUS    proportion of non-retail business acres per town\n",
      "        - CHAS     Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)\n",
      "        - NOX      nitric oxides concentration (parts per 10 million)\n",
      "        - RM       average number of rooms per dwelling\n",
      "        - AGE      proportion of owner-occupied units built prior to 1940\n",
      "        - DIS      weighted distances to five Boston employment centres\n",
      "        - RAD      index of accessibility to radial highways\n",
      "        - TAX      full-value property-tax rate per $10,000\n",
      "        - PTRATIO  pupil-teacher ratio by town\n",
      "        - B        1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town\n",
      "        - LSTAT    % lower status of the population\n",
      "        - MEDV     Median value of owner-occupied homes in $1000's\n",
      "\n",
      "    :Missing Attribute Values: None\n",
      "\n",
      "    :Creator: Harrison, D. and Rubinfeld, D.L.\n",
      "\n",
      "This is a copy of UCI ML housing dataset.\n",
      "https://archive.ics.uci.edu/ml/machine-learning-databases/housing/\n",
      "\n",
      "\n",
      "This dataset was taken from the StatLib library which is maintained at Carnegie Mellon University.\n",
      "\n",
      "The Boston house-price data of Harrison, D. and Rubinfeld, D.L. 'Hedonic\n",
      "prices and the demand for clean air', J. Environ. Economics & Management,\n",
      "vol.5, 81-102, 1978.   Used in Belsley, Kuh & Welsch, 'Regression diagnostics\n",
      "...', Wiley, 1980.   N.B. Various transformations are used in the table on\n",
      "pages 244-261 of the latter.\n",
      "\n",
      "The Boston house-price data has been used in many machine learning papers that address regression\n",
      "problems.   \n",
      "     \n",
      ".. topic:: References\n",
      "\n",
      "   - Belsley, Kuh & Welsch, 'Regression diagnostics: Identifying Influential Data and Sources of Collinearity', Wiley, 1980. 244-261.\n",
      "   - Quinlan,R. (1993). Combining Instance-Based and Model-Based Learning. In Proceedings on the Tenth International Conference of Machine Learning, 236-243, University of Massachusetts, Amherst. Morgan Kaufmann.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(boston[\"DESCR\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Данный текст содержит более подробную информацию о датасете, признаках, а также об авторах.\n",
    "\n",
    "Наконец, массив с целевыми значениями (в нашем случае - ценами на недвижимость) можно получить по ключу `\"target\"`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([24. , 21.6, 34.7, 33.4, 36.2, 28.7, 22.9, 27.1, 16.5, 18.9])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target = boston[\"target\"]\n",
    "\n",
    "target[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Создадим несколько таблиц `DataFrame` для более удобного хранения данных. В таблице `X` будут храниться признаки. В качестве названий для столбцов возьмём массив `feature_names`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>CRIM</th>\n",
       "      <th>ZN</th>\n",
       "      <th>INDUS</th>\n",
       "      <th>CHAS</th>\n",
       "      <th>NOX</th>\n",
       "      <th>RM</th>\n",
       "      <th>AGE</th>\n",
       "      <th>DIS</th>\n",
       "      <th>RAD</th>\n",
       "      <th>TAX</th>\n",
       "      <th>PTRATIO</th>\n",
       "      <th>B</th>\n",
       "      <th>LSTAT</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.00632</td>\n",
       "      <td>18.0</td>\n",
       "      <td>2.31</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.538</td>\n",
       "      <td>6.575</td>\n",
       "      <td>65.2</td>\n",
       "      <td>4.0900</td>\n",
       "      <td>1.0</td>\n",
       "      <td>296.0</td>\n",
       "      <td>15.3</td>\n",
       "      <td>396.90</td>\n",
       "      <td>4.98</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.02731</td>\n",
       "      <td>0.0</td>\n",
       "      <td>7.07</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.469</td>\n",
       "      <td>6.421</td>\n",
       "      <td>78.9</td>\n",
       "      <td>4.9671</td>\n",
       "      <td>2.0</td>\n",
       "      <td>242.0</td>\n",
       "      <td>17.8</td>\n",
       "      <td>396.90</td>\n",
       "      <td>9.14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.02729</td>\n",
       "      <td>0.0</td>\n",
       "      <td>7.07</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.469</td>\n",
       "      <td>7.185</td>\n",
       "      <td>61.1</td>\n",
       "      <td>4.9671</td>\n",
       "      <td>2.0</td>\n",
       "      <td>242.0</td>\n",
       "      <td>17.8</td>\n",
       "      <td>392.83</td>\n",
       "      <td>4.03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.03237</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.18</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.458</td>\n",
       "      <td>6.998</td>\n",
       "      <td>45.8</td>\n",
       "      <td>6.0622</td>\n",
       "      <td>3.0</td>\n",
       "      <td>222.0</td>\n",
       "      <td>18.7</td>\n",
       "      <td>394.63</td>\n",
       "      <td>2.94</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.06905</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.18</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.458</td>\n",
       "      <td>7.147</td>\n",
       "      <td>54.2</td>\n",
       "      <td>6.0622</td>\n",
       "      <td>3.0</td>\n",
       "      <td>222.0</td>\n",
       "      <td>18.7</td>\n",
       "      <td>396.90</td>\n",
       "      <td>5.33</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      CRIM    ZN  INDUS  CHAS    NOX     RM   AGE     DIS  RAD    TAX  \\\n",
       "0  0.00632  18.0   2.31   0.0  0.538  6.575  65.2  4.0900  1.0  296.0   \n",
       "1  0.02731   0.0   7.07   0.0  0.469  6.421  78.9  4.9671  2.0  242.0   \n",
       "2  0.02729   0.0   7.07   0.0  0.469  7.185  61.1  4.9671  2.0  242.0   \n",
       "3  0.03237   0.0   2.18   0.0  0.458  6.998  45.8  6.0622  3.0  222.0   \n",
       "4  0.06905   0.0   2.18   0.0  0.458  7.147  54.2  6.0622  3.0  222.0   \n",
       "\n",
       "   PTRATIO       B  LSTAT  \n",
       "0     15.3  396.90   4.98  \n",
       "1     17.8  396.90   9.14  \n",
       "2     17.8  392.83   4.03  \n",
       "3     18.7  394.63   2.94  \n",
       "4     18.7  396.90   5.33  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = pd.DataFrame(data, columns=feature_names)\n",
    "\n",
    "X.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Выведем информацию об этой таблице:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 506 entries, 0 to 505\n",
      "Data columns (total 13 columns):\n",
      "CRIM       506 non-null float64\n",
      "ZN         506 non-null float64\n",
      "INDUS      506 non-null float64\n",
      "CHAS       506 non-null float64\n",
      "NOX        506 non-null float64\n",
      "RM         506 non-null float64\n",
      "AGE        506 non-null float64\n",
      "DIS        506 non-null float64\n",
      "RAD        506 non-null float64\n",
      "TAX        506 non-null float64\n",
      "PTRATIO    506 non-null float64\n",
      "B          506 non-null float64\n",
      "LSTAT      506 non-null float64\n",
      "dtypes: float64(13)\n",
      "memory usage: 51.5 KB\n"
     ]
    }
   ],
   "source": [
    "X.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видно из этой информации, данная таблица не содержит пропущенных значений.\n",
    "\n",
    "Теперь создадим таблицу `y`, в которую запишем целевые значения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 506 entries, 0 to 505\n",
      "Data columns (total 1 columns):\n",
      "price    506 non-null float64\n",
      "dtypes: float64(1)\n",
      "memory usage: 4.1 KB\n"
     ]
    }
   ],
   "source": [
    "y = pd.DataFrame(target, columns=[\"price\"])\n",
    "\n",
    "y.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В этой таблице также нет пропущенных значений.\n",
    "\n",
    "### Разбиение выборки на тренировочную и тестовую\n",
    "\n",
    "Обычно при обучении моделей машинного обучения используют две выборки: тренировочную и тестовую. Первая нужна для того, чтобы обучить модель. Вторая - для проверки качества обученной модели: мы можем сравнить предсказанную на этих данных цену с реальной, поскольку она у нас тоже имеется.\n",
    "\n",
    "Разбиение данных на тренировочную и тестовую выборку можно выполнить с помощью функции `train_test_split` из модуля `sklearn.model_selection`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощью параметра `test_size` можно указать, какую часть данных мы хотим выделить под тест. Если подать сюда число из отрезка $[0, 1)$, то оно будет интерпретироваться как доля тестовых объектов. Если же подать число большее или равное 1, это будет число объектов в тестовой выборке.\n",
    "\n",
    "### Построение модели\n",
    "\n",
    "Итак, загрузим модель линейной регрессии:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = LinearRegression()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Модель линейной регрессии по объекту $x = (x_1, \\dots, x_n)$ предсказывает значение целевой переменной, используя линейную функцию \n",
    "\n",
    "$$f(x) = w_0 + w_1 \\cdot x_1 + \\dots + w_n \\cdot x_n.$$ \n",
    "\n",
    "Задача такой модели - в процессе обучения подобрать эти коэффициенты $w_i$ так, чтобы значение этой функции было как можно более близко к реальному целевому значению $y$ объекта $x$.\n",
    "\n",
    "Итак, чтобы обучить модель, мы используем метод `.fit`, в который передаём нашу тренировочную выборку:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь, когда модель обучена, мы можем получить предсказанные значения на объектах `X_test` с помощью метода `.predict`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[18.3310232 ],\n",
       "       [15.09645264],\n",
       "       [27.7988149 ],\n",
       "       [20.24547942],\n",
       "       [19.16871096],\n",
       "       [19.35141987],\n",
       "       [24.51557024],\n",
       "       [29.09527107],\n",
       "       [44.24629945],\n",
       "       [19.11404054],\n",
       "       [29.29264161],\n",
       "       [26.08133931],\n",
       "       [22.81099208],\n",
       "       [17.96354604],\n",
       "       [31.53605319],\n",
       "       [15.12111598],\n",
       "       [30.87799719],\n",
       "       [ 4.15893915],\n",
       "       [31.03219126],\n",
       "       [30.70088269],\n",
       "       [36.61664083],\n",
       "       [21.04273974],\n",
       "       [21.71661015],\n",
       "       [25.28109992],\n",
       "       [24.57104893],\n",
       "       [20.93543979],\n",
       "       [23.27877882],\n",
       "       [30.63488172],\n",
       "       [34.6731918 ],\n",
       "       [38.31527181],\n",
       "       [25.69159423],\n",
       "       [18.54111931],\n",
       "       [18.4411295 ],\n",
       "       [19.22630269],\n",
       "       [ 8.50357536],\n",
       "       [11.83847753],\n",
       "       [28.98009924],\n",
       "       [ 7.42212876],\n",
       "       [23.78084163],\n",
       "       [29.40142592],\n",
       "       [16.33407997],\n",
       "       [27.58846734],\n",
       "       [37.2198274 ],\n",
       "       [27.41698502],\n",
       "       [21.83249281],\n",
       "       [19.4936236 ],\n",
       "       [17.30823074],\n",
       "       [19.8399778 ],\n",
       "       [20.20280258],\n",
       "       [33.01086298],\n",
       "       [18.76854605],\n",
       "       [31.18771532],\n",
       "       [33.19350027],\n",
       "       [13.23585728],\n",
       "       [22.10571545],\n",
       "       [27.95477481],\n",
       "       [36.17534376],\n",
       "       [29.90698194],\n",
       "       [21.79811821],\n",
       "       [22.49807164],\n",
       "       [15.53936262],\n",
       "       [20.97647172],\n",
       "       [33.13128026],\n",
       "       [17.52524193],\n",
       "       [23.70125611],\n",
       "       [18.23036668],\n",
       "       [30.54826673],\n",
       "       [32.13456122],\n",
       "       [22.26076165],\n",
       "       [25.50744175],\n",
       "       [18.73537176],\n",
       "       [17.50013815],\n",
       "       [30.82869668],\n",
       "       [27.68953496],\n",
       "       [16.81826861],\n",
       "       [35.13684524],\n",
       "       [27.46954638],\n",
       "       [16.18246141],\n",
       "       [28.87261225],\n",
       "       [22.97478598],\n",
       "       [19.83709446],\n",
       "       [17.11275203],\n",
       "       [ 8.33230438],\n",
       "       [17.77723487],\n",
       "       [25.97144767],\n",
       "       [18.5859382 ],\n",
       "       [22.7807687 ],\n",
       "       [16.53929652],\n",
       "       [24.7278483 ],\n",
       "       [22.67625896],\n",
       "       [24.413461  ],\n",
       "       [ 1.02337384],\n",
       "       [17.3493383 ],\n",
       "       [23.64111729],\n",
       "       [25.35129516],\n",
       "       [22.06010941],\n",
       "       [20.15394024],\n",
       "       [24.43795935],\n",
       "       [33.7736401 ],\n",
       "       [39.50013839],\n",
       "       [21.03543605],\n",
       "       [37.18562689],\n",
       "       [32.67875348],\n",
       "       [19.50257734],\n",
       "       [33.97101137],\n",
       "       [11.36933901],\n",
       "       [20.63300564],\n",
       "       [25.14832478],\n",
       "       [12.88719436],\n",
       "       [19.88090631],\n",
       "       [30.95949104],\n",
       "       [26.37918202],\n",
       "       [19.30541602],\n",
       "       [13.78662494],\n",
       "       [15.26659858],\n",
       "       [28.51762394],\n",
       "       [31.15346088],\n",
       "       [19.26079973],\n",
       "       [10.60055924],\n",
       "       [21.65501382],\n",
       "       [17.33330491],\n",
       "       [28.37986977],\n",
       "       [ 5.88850617],\n",
       "       [22.2435618 ],\n",
       "       [19.21371603],\n",
       "       [30.63603433],\n",
       "       [18.42698343]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred = lr.predict(X_test)\n",
    "\n",
    "y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Создадим таблицу `DataFrame` чтобы сопоставить реальные значения с предсказанными. Поскольку массив `y_pred` является двумерным, переведём его в одномерный, используя метод `.flatten`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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>y_test</th>\n",
       "      <th>y_pred</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>356</td>\n",
       "      <td>17.8</td>\n",
       "      <td>18.331023</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>436</td>\n",
       "      <td>9.6</td>\n",
       "      <td>15.096453</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>240</td>\n",
       "      <td>22.0</td>\n",
       "      <td>27.798815</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>122</td>\n",
       "      <td>20.5</td>\n",
       "      <td>20.245479</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>460</td>\n",
       "      <td>16.4</td>\n",
       "      <td>19.168711</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>497</td>\n",
       "      <td>18.3</td>\n",
       "      <td>19.351420</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>242</td>\n",
       "      <td>22.2</td>\n",
       "      <td>24.515570</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>93</td>\n",
       "      <td>25.0</td>\n",
       "      <td>29.095271</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>257</td>\n",
       "      <td>50.0</td>\n",
       "      <td>44.246299</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>431</td>\n",
       "      <td>14.1</td>\n",
       "      <td>19.114041</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     y_test     y_pred\n",
       "356    17.8  18.331023\n",
       "436     9.6  15.096453\n",
       "240    22.0  27.798815\n",
       "122    20.5  20.245479\n",
       "460    16.4  19.168711\n",
       "497    18.3  19.351420\n",
       "242    22.2  24.515570\n",
       "93     25.0  29.095271\n",
       "257    50.0  44.246299\n",
       "431    14.1  19.114041"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_test = pd.DataFrame({\n",
    "    \"y_test\": y_test[\"price\"],\n",
    "    \"y_pred\": y_pred.flatten(),\n",
    "})\n",
    "\n",
    "check_test.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Метрики оценки качества моделей регрессии\n",
    "\n",
    "Чтобы оценить то, насколько отличаются реальные значения от предсказанных, создадим отдельный столбец с их разностями:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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>y_test</th>\n",
       "      <th>y_pred</th>\n",
       "      <th>error</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>356</td>\n",
       "      <td>17.8</td>\n",
       "      <td>18.331023</td>\n",
       "      <td>0.531023</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>436</td>\n",
       "      <td>9.6</td>\n",
       "      <td>15.096453</td>\n",
       "      <td>5.496453</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>240</td>\n",
       "      <td>22.0</td>\n",
       "      <td>27.798815</td>\n",
       "      <td>5.798815</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>122</td>\n",
       "      <td>20.5</td>\n",
       "      <td>20.245479</td>\n",
       "      <td>-0.254521</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>460</td>\n",
       "      <td>16.4</td>\n",
       "      <td>19.168711</td>\n",
       "      <td>2.768711</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     y_test     y_pred     error\n",
       "356    17.8  18.331023  0.531023\n",
       "436     9.6  15.096453  5.496453\n",
       "240    22.0  27.798815  5.798815\n",
       "122    20.5  20.245479 -0.254521\n",
       "460    16.4  19.168711  2.768711"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_test[\"error\"] = check_test[\"y_pred\"] - check_test[\"y_test\"]\n",
    "\n",
    "check_test.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Одной из основных метрик для оценки качества моделей регрессии является _средняя квадратическая ошибка_ или _mean squared error_, сокращённо _mse_. Она вычисляется как среднее от квадратов ошибок на каждом из объектов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23.337563554599406"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mse1 = (check_test[\"error\"] ** 2).mean()\n",
    "\n",
    "mse1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Эта метрика есть в готовом виде в библиотеке `sklearn`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23.33756355459941"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "mean_squared_error(check_test[\"y_pred\"], check_test[\"y_test\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также применяется _средняя абсолютная ошибка_. Она представляет из себя среднее не от квадратов ошибок, а от их модулей:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.4834356454200117"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(np.abs(check_test[\"error\"])).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Данная метрика также доступна в готовом виде:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.483435645420011"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import mean_absolute_error\n",
    "\n",
    "mean_absolute_error(check_test[\"y_pred\"], check_test[\"y_test\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Эта метрика отличается от mse тем, что не так сильно реагирует на выбросы в данных, например, на те ситуации, в которых у некоторых объектов недвижимости сильно завышена или сильно занижена цена.\n",
    "\n",
    "### Коэффициенты линейной регрессии\n",
    "\n",
    "Посмотрим, какие коэффициенты подобрала наша модель на этапе обучения. Свободный коэффициент $w_0$ хранится в атрибуте `.intercept_`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([35.9395996])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr.intercept_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Остальные коэффициенты $w_1$, $\\dots$, $w_n$ хранятся в атрибуте `.coef_`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.05080528e-01,  5.38292026e-02, -1.82428666e-02,\n",
       "         1.45213607e+00, -1.65084447e+01,  4.02138897e+00,\n",
       "        -4.82005275e-03, -1.51353994e+00,  2.69153562e-01,\n",
       "        -1.12699682e-02, -9.77321548e-01,  7.68426128e-03,\n",
       "        -4.82330004e-01]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr.coef_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Давайте визуализируем то, какой вклад вносит каждый из этих коэффициентов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "plt.rcParams['figure.figsize'] = 6, 4\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.barh(feature_names, lr.coef_.flatten())\n",
    "\n",
    "plt.xlabel(\"Вес признака\")\n",
    "plt.ylabel(\"Признак\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Стандартизация признаков\n",
    "\n",
    "Не стоит торопиться с выводами о том, какой признак имеет наибольший вклад в итоговую цену. Если мы посмотрим на таблицу `X_train.describe()`, содержащую статистические данные по таблице `X_train`, мы убедимся, что значения по каждому признаку _не отмасштабированы_, т.е. имеют разный масштаб разброса значений (см. строки `mean` и `std`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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>CRIM</th>\n",
       "      <th>ZN</th>\n",
       "      <th>INDUS</th>\n",
       "      <th>CHAS</th>\n",
       "      <th>NOX</th>\n",
       "      <th>RM</th>\n",
       "      <th>AGE</th>\n",
       "      <th>DIS</th>\n",
       "      <th>RAD</th>\n",
       "      <th>TAX</th>\n",
       "      <th>PTRATIO</th>\n",
       "      <th>B</th>\n",
       "      <th>LSTAT</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>count</td>\n",
       "      <td>379.000000</td>\n",
       "      <td>379.000000</td>\n",
       "      <td>379.000000</td>\n",
       "      <td>379.000000</td>\n",
       "      <td>379.000000</td>\n",
       "      <td>379.000000</td>\n",
       "      <td>379.000000</td>\n",
       "      <td>379.000000</td>\n",
       "      <td>379.000000</td>\n",
       "      <td>379.000000</td>\n",
       "      <td>379.000000</td>\n",
       "      <td>379.000000</td>\n",
       "      <td>379.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>mean</td>\n",
       "      <td>3.631606</td>\n",
       "      <td>10.726913</td>\n",
       "      <td>11.261029</td>\n",
       "      <td>0.065963</td>\n",
       "      <td>0.555540</td>\n",
       "      <td>6.268778</td>\n",
       "      <td>68.491293</td>\n",
       "      <td>3.791144</td>\n",
       "      <td>9.612137</td>\n",
       "      <td>405.635884</td>\n",
       "      <td>18.440633</td>\n",
       "      <td>356.585383</td>\n",
       "      <td>12.885910</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>std</td>\n",
       "      <td>8.589430</td>\n",
       "      <td>22.982998</td>\n",
       "      <td>6.680567</td>\n",
       "      <td>0.248546</td>\n",
       "      <td>0.116679</td>\n",
       "      <td>0.706223</td>\n",
       "      <td>28.452532</td>\n",
       "      <td>2.084688</td>\n",
       "      <td>8.617379</td>\n",
       "      <td>167.277324</td>\n",
       "      <td>2.161113</td>\n",
       "      <td>91.164382</td>\n",
       "      <td>7.211847</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>min</td>\n",
       "      <td>0.009060</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.460000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.385000</td>\n",
       "      <td>3.863000</td>\n",
       "      <td>2.900000</td>\n",
       "      <td>1.129600</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>187.000000</td>\n",
       "      <td>12.600000</td>\n",
       "      <td>2.520000</td>\n",
       "      <td>1.920000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>25%</td>\n",
       "      <td>0.088495</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>5.640000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.449000</td>\n",
       "      <td>5.876500</td>\n",
       "      <td>44.050000</td>\n",
       "      <td>2.102150</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>279.500000</td>\n",
       "      <td>17.000000</td>\n",
       "      <td>374.960000</td>\n",
       "      <td>7.240000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>50%</td>\n",
       "      <td>0.289600</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>9.690000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.538000</td>\n",
       "      <td>6.167000</td>\n",
       "      <td>77.700000</td>\n",
       "      <td>3.215700</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>330.000000</td>\n",
       "      <td>19.000000</td>\n",
       "      <td>391.340000</td>\n",
       "      <td>11.740000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>75%</td>\n",
       "      <td>3.504645</td>\n",
       "      <td>12.500000</td>\n",
       "      <td>18.100000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.624000</td>\n",
       "      <td>6.591500</td>\n",
       "      <td>94.100000</td>\n",
       "      <td>5.116700</td>\n",
       "      <td>24.000000</td>\n",
       "      <td>666.000000</td>\n",
       "      <td>20.200000</td>\n",
       "      <td>396.270000</td>\n",
       "      <td>17.155000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>max</td>\n",
       "      <td>88.976200</td>\n",
       "      <td>100.000000</td>\n",
       "      <td>27.740000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.871000</td>\n",
       "      <td>8.780000</td>\n",
       "      <td>100.000000</td>\n",
       "      <td>12.126500</td>\n",
       "      <td>24.000000</td>\n",
       "      <td>711.000000</td>\n",
       "      <td>22.000000</td>\n",
       "      <td>396.900000</td>\n",
       "      <td>36.980000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             CRIM          ZN       INDUS        CHAS         NOX          RM  \\\n",
       "count  379.000000  379.000000  379.000000  379.000000  379.000000  379.000000   \n",
       "mean     3.631606   10.726913   11.261029    0.065963    0.555540    6.268778   \n",
       "std      8.589430   22.982998    6.680567    0.248546    0.116679    0.706223   \n",
       "min      0.009060    0.000000    0.460000    0.000000    0.385000    3.863000   \n",
       "25%      0.088495    0.000000    5.640000    0.000000    0.449000    5.876500   \n",
       "50%      0.289600    0.000000    9.690000    0.000000    0.538000    6.167000   \n",
       "75%      3.504645   12.500000   18.100000    0.000000    0.624000    6.591500   \n",
       "max     88.976200  100.000000   27.740000    1.000000    0.871000    8.780000   \n",
       "\n",
       "              AGE         DIS         RAD         TAX     PTRATIO           B  \\\n",
       "count  379.000000  379.000000  379.000000  379.000000  379.000000  379.000000   \n",
       "mean    68.491293    3.791144    9.612137  405.635884   18.440633  356.585383   \n",
       "std     28.452532    2.084688    8.617379  167.277324    2.161113   91.164382   \n",
       "min      2.900000    1.129600    1.000000  187.000000   12.600000    2.520000   \n",
       "25%     44.050000    2.102150    4.000000  279.500000   17.000000  374.960000   \n",
       "50%     77.700000    3.215700    5.000000  330.000000   19.000000  391.340000   \n",
       "75%     94.100000    5.116700   24.000000  666.000000   20.200000  396.270000   \n",
       "max    100.000000   12.126500   24.000000  711.000000   22.000000  396.900000   \n",
       "\n",
       "            LSTAT  \n",
       "count  379.000000  \n",
       "mean    12.885910  \n",
       "std      7.211847  \n",
       "min      1.920000  \n",
       "25%      7.240000  \n",
       "50%     11.740000  \n",
       "75%     17.155000  \n",
       "max     36.980000  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для решения этой проблемы можно применить _стандартизацию_ признаков. Для этого нужно от значений каждого признака отнять среднее значение этого признака, а затем поделить на среднее квадратическое отклонение этого признака:\n",
    "\n",
    "$$x_{scaled} = \\dfrac{x - x_{mean}}{\\sigma_x}$$\n",
    "\n",
    "После стандартизации каждый признак имеет среднее значение 0 и среднее квадратическое отклонение 1.\n",
    "\n",
    "Изучем инструменты из библиотеки `sklearn`, с помощью которых можно провести стандартизацию данных:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "scaler = StandardScaler()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Обучим\" объект `scaler` на наших данных, а затем сразу же получим стандартизированные значения. Это можно сделать с помощью одного общего метода `.fit_transform`. (На самом деле этот метод включает в себя два метода: `.fit` и `.transform`.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_scaled = scaler.fit_transform(X_train)\n",
    "X_train_scaled = pd.DataFrame(X_train_scaled, columns=feature_names)\n",
    "\n",
    "X_test_scaled = scaler.fit_transform(X_test)\n",
    "X_test_scaled = pd.DataFrame(X_test_scaled, columns=feature_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итак, попробуем обучить нашу модель заново, но уже на стандартизированных данных, и выведем аналогичную диаграмму, но уже для новой модели:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "lr.fit(X_train_scaled, y_train)\n",
    "\n",
    "plt.barh(feature_names, lr.coef_.flatten())\n",
    "\n",
    "plt.xlabel(\"Вес признака\")\n",
    "plt.ylabel(\"Признак\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы видим, что теперь веса признаков имеют совершенно иные значения друг относительно друга.\n",
    "\n",
    "Важно отметить, что стандартизация важна не только для отбора признаков. Стандартизация является важным этапом предобработки данных, без которого многие алгоритмы будут работать некорректно.\n",
    "\n",
    "Попробуем обучить модель, используя лишь признаки, вес которых достаточно отличается от 0, и посмотрим, как это отразится на качестве модели:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['CRIM', 'ZN', 'NOX', 'RM', 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT']\n"
     ]
    }
   ],
   "source": [
    "important_features = [\n",
    "    feature\n",
    "    for feature, weight in zip(feature_names, lr.coef_.flatten())\n",
    "    if np.abs(weight) > 0.5\n",
    "]\n",
    "\n",
    "print(important_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mse до: 23.337563554599406\n",
      "mse после: 24.188573863136337\n"
     ]
    }
   ],
   "source": [
    "lr.fit(\n",
    "    X_train_scaled.loc[:, important_features],\n",
    "    y_train\n",
    ")\n",
    "\n",
    "y_pred = lr.predict(X_test_scaled.loc[:, important_features])\n",
    "\n",
    "mse2 = mean_squared_error(y_test, y_pred)\n",
    "\n",
    "print(\"mse до: {}\".format(mse1))\n",
    "print(\"mse после: {}\".format(mse2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Стандартизация и отбор признаков иногда позволяют немного уменьшить ошибку, хотя и не всегда.\n",
    "\n",
    "### Модели линейной регрессии с регуляризацией\n",
    "\n",
    "В машинном обучении важной проблемой является _переобучение_, и нужно уметь бороться с переобучением обучаемой модели. Переобучение - это когда модель очень хорошо подстраивается под имеющиеся у неё тренировочные данные, однако, на тестовых данных показывает очень плохой результат.\n",
    "\n",
    "Одним из симптомов переобучения линейных моделей являются очень большие по модулю веса. Бороться с этим можно с помощью _регуляризации_. В библиотеке `sklearn` доступны уже готовые реализации моделей линейной регрессии с L1- и L2-регуляризацией. Это, соответственно, модели `Lasso` и `Ridge` из модуля `sklearn.linear_model`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import Lasso, Ridge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При этом, коэффициент регуляризации можно задавать с помощью параметра `alpha` при инициализации этих моделей."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24.359512832418453"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Lasso(alpha=0.03)\n",
    "\n",
    "model.fit(X_train_scaled.loc[:, important_features], y_train)\n",
    "\n",
    "y_pred = model.predict(X_test_scaled.loc[:, important_features])\n",
    "\n",
    "mean_squared_error(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "На графике ниже изображено изменение весов признаков при увеличении коэффициента регуляризации `alpha` от $10^{-3}$ до $10$ для модели `Lasso` (L1-регуляризация). Чем больше значение `alpha`, тем сильнее регуляризация и тем сильнее модель \"штрафует\" за большую абсолютную величину признаков. \n",
    "\n",
    "Такой метод часто используется для отбора признаков: у менее ценных признаков гораздо раньше обнуляются веса."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x257a9659248>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 50\n",
    "\n",
    "coeffs = np.zeros((n, len(important_features)))\n",
    "alpha_list = np.logspace(-3, 1, n)\n",
    "\n",
    "for i, val in enumerate(alpha_list):\n",
    "    lasso = Lasso(alpha=val)\n",
    "    lasso.fit(X_train_scaled.loc[:, important_features], y_train)\n",
    "    \n",
    "    coeffs[i, :] = lasso.coef_.flatten()\n",
    "\n",
    "for i in range(len(important_features)):\n",
    "    plt.plot(alpha_list, coeffs[:, i])\n",
    "\n",
    "plt.title('Убывание абсолютных значений весов признаков\\n при увеличении коэффициента регуляризации alpha (Lasso)')\n",
    "\n",
    "plt.xlabel('alpha')\n",
    "plt.ylabel('Вес признака')\n",
    "\n",
    "plt.legend(important_features)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При использовании модели `Ridge` (L2-регуляризация) наблюдается аналогичный эффект, однако, абсолютные значения весов убывают более плавно и примерно одновременно друг с другом."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x257b07cb408>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 50\n",
    "\n",
    "coeffs = np.zeros((n, len(important_features)))\n",
    "alpha_list = np.logspace(-3, 3.5, n)\n",
    "\n",
    "for i, val in enumerate(alpha_list):\n",
    "    ridge = Ridge(alpha=val)\n",
    "    ridge.fit(X_train_scaled.loc[:, important_features], y_train)\n",
    "    \n",
    "    coeffs[i, :] = ridge.coef_.flatten()\n",
    "\n",
    "for i in range(len(important_features)):\n",
    "    plt.plot(alpha_list, coeffs[:, i])\n",
    "\n",
    "plt.title('Убывание абсолютных значений весов признаков\\n при увеличении коэффициента регуляризации alpha (Ridge)')\n",
    "\n",
    "plt.xlabel('alpha')\n",
    "plt.ylabel('Вес признака')\n",
    "\n",
    "plt.legend(important_features)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Логистическая регрессия\n",
    "\n",
    "_Логистическая регрессия_ - это один из самых простых алгоритмов, используемых в _задачах классификации_: имеется набор данных, и у каждого объекта есть метка принадлежности к какому-то классу. Наша задача - предсказать эту метку для объекта. Идея логистической регрессии в том, чтобы предсказывать не метку класса, а вероятность принадлежности данного объекта к каждому из классов. \n",
    "\n",
    "Рассмотрим алгоритм логистической регрессии для _бинарной классификации_, т.е. случая, когда различных классов всего 2. В этом случае задача алгоритма логистической регрессии очень похожа на задачу алгоритма линейной регрессии, рассмотренного ранее: модель должна подобрать коэффициенты $w_0, w_1, \\dots, w_n$. Как используются эти коэффициенты?\n",
    "\n",
    "В начале мы делаем то же самое, что и в линейной регрессии. Мы вычисляем значение\n",
    "\n",
    "$$z = w_0 + w_1 \\cdot x_1 + \\dots + w_n \\cdot x_n.$$\n",
    "\n",
    "Затем величина $z$ помещается в _сигмоидную функцию_:\n",
    "$$f(z) = \\dfrac{1}{1 + e^{- z}}.$$\n",
    "\n",
    "Сигмоидная функция используется для того, чтобы преобразовать число $z$ из промежутка $(- \\infty, \\infty)$ в число $f(z)$ из промежутка $(0, 1)$. Причём, делается это так, что число $f(z)$ можно теперь интерпретировать как вероятность. В нашем случае это будет вероятность принадлежности объекта $x$ классу 1. Соответственно, вероятность принадлежности объекта классу 0 будет равна $1 - f(z)$.\n",
    "\n",
    "Алгоритм логистической регрессии минимизирует функцию потерь $logloss$:\n",
    "\n",
    "$$logloss(x) = - y \\cdot \\operatorname{ln} (p) - (1 - y) \\cdot \\operatorname{ln} (1 - p).$$\n",
    "\n",
    "Здесь $y$ - правильный ответ на объекте $x$ (0 или 1), а $p$ - вычисленная алгоритмом вероятность принадлежности объекта $x$ классу 1.\n",
    "\n",
    "Для того, чтобы разобраться с деталями модели логистической регрессии, мы будем использовать датасет, содержащий информацию о пассажирах Титаника. Этот датасет можно скачать [здесь](https://www.kaggle.com/c/titanic/data)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] File b'titanic_train.csv' does not exist: b'titanic_train.csv'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-37-e88c716f15e1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread_csv\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"titanic_train.csv\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindex_col\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"PassengerId\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mhead\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\pandas\\io\\parsers.py\u001b[0m in \u001b[0;36mparser_f\u001b[1;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, squeeze, prefix, mangle_dupe_cols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, dialect, error_bad_lines, warn_bad_lines, delim_whitespace, low_memory, memory_map, float_precision)\u001b[0m\n\u001b[0;32m    683\u001b[0m         )\n\u001b[0;32m    684\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 685\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0m_read\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfilepath_or_buffer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    686\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    687\u001b[0m     \u001b[0mparser_f\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__name__\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\pandas\\io\\parsers.py\u001b[0m in \u001b[0;36m_read\u001b[1;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[0;32m    455\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    456\u001b[0m     \u001b[1;31m# Create the parser.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 457\u001b[1;33m     \u001b[0mparser\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mTextFileReader\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfp_or_buf\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    458\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    459\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mchunksize\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0miterator\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\pandas\\io\\parsers.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[0;32m    893\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"has_index_names\"\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mkwds\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"has_index_names\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    894\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 895\u001b[1;33m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_make_engine\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mengine\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    896\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    897\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mclose\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\pandas\\io\\parsers.py\u001b[0m in \u001b[0;36m_make_engine\u001b[1;34m(self, engine)\u001b[0m\n\u001b[0;32m   1133\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m_make_engine\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mengine\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"c\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1134\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mengine\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m\"c\"\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1135\u001b[1;33m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_engine\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mCParserWrapper\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1136\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1137\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mengine\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m\"python\"\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\pandas\\io\\parsers.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, src, **kwds)\u001b[0m\n\u001b[0;32m   1915\u001b[0m         \u001b[0mkwds\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"usecols\"\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0musecols\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1916\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1917\u001b[1;33m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_reader\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mparsers\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mTextReader\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msrc\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1918\u001b[0m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0munnamed_cols\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_reader\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0munnamed_cols\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1919\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mpandas\\_libs\\parsers.pyx\u001b[0m in \u001b[0;36mpandas._libs.parsers.TextReader.__cinit__\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas\\_libs\\parsers.pyx\u001b[0m in \u001b[0;36mpandas._libs.parsers.TextReader._setup_parser_source\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] File b'titanic_train.csv' does not exist: b'titanic_train.csv'"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv(\"titanic_train.csv\", index_col=\"PassengerId\")\n",
    "\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Целевым значением для нас будет значение `\"Survived\"` - то, выжил пассажир или нет. Вынесем этот столбец в отдельную переменную `y`, а в переменную `X` запишем все столбцы из таблицы `data` кроме столбца `target`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target = \"Survived\"\n",
    "\n",
    "y = data[target]\n",
    "X = data.drop(target, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Изучим содержимое таблицы `X` более подробно:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Прежде чем приступить к обучении модели, данные необходимо почистить. Мы видим, что всего у нас есть данные о 891 пассажире, однако, многие данные пропущены. Например, в столбце `\"Cabin\"` всего 204 непустых значения. Этот столбец мы удалим. Также удалим столбцы `\"Name\"` и `\"Ticket\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X.drop([\"Cabin\", \"Name\", \"Ticket\"], axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В поле `\"Age\"` также немало пропущенных значений. Подставим в них среднее значение по имеющимся данным:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age_mean = X[\"Age\"].mean()\n",
    "\n",
    "print(age_mean)\n",
    "\n",
    "X[\"Age\"].fillna(age_mean, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Отметим, что существует и иной подход к заполнению пропущенных значений, который является более предпочтительным при достаточном количестве данных. Через некоторое время нам предстоит разбить наши данные на тренировочную и валидационную выборку. Мы могли бы сначала сделать это, а затем уже заполнить пропущенные значения средними именно по тренировочной и валидационной выборке, соответственно. Это более предпочтительный подход, поскольку средние значения получатся немного разными, что может предотвратить переобучение.\n",
    "\n",
    "Здесь, однако, мы этого делать не будем, поскольку данных не слишком много.\n",
    "\n",
    "Теперь рассмотрим поле `\"Embarked\"`. Оно текстовое, и здесь всего два пропущенных значения. Посмотрим, как часто встречаются возможные значения этого поля в датасете:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X[\"Embarked\"].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы видим, что чаще всего встречается значение `\"S\"`. Заполним им пропущенные значения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X[\"Embarked\"].fillna(\"S\", inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иногда пропущенные значения не заполняют, а используют факт их пропуска в качестве ещё одного признака. Но в этом уроке мы так делать не будем.\n",
    "\n",
    "Обычно непрерывные значения заполняют средним или медианой, а категориальные - модой.\n",
    "\n",
    "Чтобы использовать категориальные признаки в нашей модели, нужно перевести их в числовые. Для поля `\"Sex\"` это сделать легко, поскольку здесь всего два разных значения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X[\"Sex\"].unique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Заменим их на числовые значения 0 и 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sex_map = {\n",
    "    \"female\": 1,\n",
    "    \"male\": 0,\n",
    "}\n",
    "\n",
    "X[\"Sex\"] = X[\"Sex\"].map(sex_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Признак `\"Embarked\"` также является категориальным, но содержит более двух категорий, поэтому переводить их в числовые значения нельзя. Вместо этого используют так называемые _dummy-переменные_. Вместо одной переменной `\"Embarked\"` заведём три переменные `\"Embarked_C\"`, `\"Embarked_Q\"` и `\"Embarked_S\"`. В каждом из этих столбцов теперь будет стоять 1, если у соответствующего объекта переменная `\"Embarked\"` равна этому значению, и 0, если нет.\n",
    "\n",
    "Мы могли бы сделать это вручную, однако, в библиотеке `pandas` уже есть готовая функция для этого:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = pd.get_dummies(X)\n",
    "\n",
    "X.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Несмотря на то, что столбец `\"Pclass\"` является числовым, его тоже хорошо бы рассматривать как категориальный, поскольку класс пассажира - это именно категория, а не непрерывное значение. Для этого зададим для этого столбца тип `\"category\"`, чтобы функция `pd.get_dummies` \"поняла\", что этот столбец тоже нужно обработать."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X[\"Pclass\"] = X[\"Pclass\"].astype(\"category\")\n",
    "\n",
    "X = pd.get_dummies(X)\n",
    "\n",
    "X.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Тренировочный, валидационный и тестовый датасеты\n",
    "\n",
    "Ранее мы упомянули _валидационную_ выборку. Давайте разберёмся, что это такое и зачем она нам нужна. Многие модели машинного обучения имеют параметры, которые влияют на то, каким образом обучается модель. В таких случаях мы используем тренировочную выборку чтобы обучить модель, валидационную чтобы проверить её качество и, если нужно, подправить параметры каким-то образом. Наконец, тестовую выборку мы используем лишь для окончательной проверки качества модели.\n",
    "\n",
    "Тестовый датасет с данными о пассажирах Титаника можно найти по вышеуказанной ссылке в файле `test.csv`. Мы же здесь работать с этими данными не будем.\n",
    "\n",
    "Итак, разобьём наши данные на тренировочную и валидационную выборки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.25, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "и приступим к построению моделей.\n",
    "\n",
    "В начале работы над любой задачей рекомендуется сперва построить простую модель, не затрачивая на неё слишком много времени. Затем можно будет уже строить более сложные модели и сравнивать их качество с качеством базовой модели.\n",
    "\n",
    "Ранее мы перевели все наши признаки в числовые. Попробуем просто построить модель, используя все признаки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "lr = LogisticRegression(solver=\"liblinear\")\n",
    "\n",
    "lr.fit(X_train, y_train)\n",
    "\n",
    "y_pred = lr.predict(X_valid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для подсчёта правильных ответов будем использовать метрику _accuracy_ (_точность_). Она равна отношению числа объектов, на которых целевой класс был угадан верно, к общему числу объектов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "accuracy_score(y_valid, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также сделаем предсказание на тренировочном датасете и посчитаем точность на нём:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_train = lr.predict(X_train)\n",
    "\n",
    "accuracy_score(y_train, y_pred_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как мы видим, точность на тренировочной и обучающей выборках примерно одинаковая. Если точность на обучающей выборке оказывается сильно выше - это означает, что модель переобучилась.\n",
    "\n",
    "Мы уже говорили о том, что алгоритм логистической регрессии позволяет получить не только предсказанную метку класса, но и вероятность принадлежности этому классу. Эти вероятности можно получить с помощью метода `.predict_proba`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_proba = lr.predict_proba(X_valid)\n",
    "\n",
    "y_pred_proba[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В первом столбце полученного массива стоит вероятность каждого объекта принадлежать классу 0, а во втором - вероятность принадлежать классу 1. Можно заметить, что сумма значений каждой строки равна 1.\n",
    "\n",
    "## Support Vector Machine\n",
    "\n",
    "_Support Vector Machine_ или _Метод опорных векторов_ является одним из самых известных методов машинного обучения. Он включает в себя несколько алгоритмов, с помощью которых можно решать задачи как классификации, так и регрессии. \n",
    "\n",
    "В задаче классификации метод SVM стремится построить между объектами разных классов \"линию\" (в пространствах больших размерностей это называется _гиперплоскость_) так, чтобы максимизировать расстояние от этой \"линии\" до объектов разных классов. Во многих случаях такой метод работает лучше, чем логистическая регрессия.\n",
    "\n",
    "Алгоритмы метода опорных векторов расположены в модуле `svm` библиотеки `sklearn`. Импортируем из этого модуля модель `SVC` (Support Vector Classifier):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.svm import SVC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Алгоритмы метода SVM чувствительны к ненормализованным и нестандартизованным данным. Поэтому прежде чем строить модель, нам следует масштабировать признаки. Ранее мы уже познакомились со _стандартизацией_: тогда мы вычитали из признаков их среднее значение, а затем делили на среднее квадратическое отклонение. Здесь мы попробуем применить _нормализацию_, т.е. расположить признаки так, чтобы минимальное значение каждого признака оказалось равным 0, а максимальное - 1. Это можно сделать с помощью инструмента `MinMaxScaler` из модуля `sklearn.preprocessing`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "scaler = MinMaxScaler()\n",
    "\n",
    "X_train = pd.DataFrame(scaler.fit_transform(X_train), columns=X_train.columns)\n",
    "\n",
    "X_valid = pd.DataFrame(scaler.transform(X_valid), columns=X_valid.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Заметим, что для нормализации данных `X_valid` мы использовали не метод `.fit_transform`, а метод `.transform`. Это мотивировано тем, что мы хотели бы, чтобы значения признаков из массивов `X_train` и `X_valid` были согласованы, т.е. чтобы те значения, которые совпадали до нормализации, остались равными и после неё. Поэтому обучать модель заново на значениях из `X_valid` мы не хотим.\n",
    "\n",
    "Итак, создадим модель и обучим её на наших тренировочных данных, а затем проверим её качество на валидационной выборке:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = SVC(gamma=\"auto\")\n",
    "\n",
    "clf.fit(X_train, y_train)\n",
    "\n",
    "y_pred = clf.predict(X_valid)\n",
    "y_pred_train = clf.predict(X_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Оценим точность предсказания:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracy_score(y_valid, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracy_score(y_train, y_pred_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как мы видим, здесь мы получили более плохую точность, чем ранее, когда использовали модель логистической регрессии. Попробуем получше настроить модель.\n",
    "\n",
    "### Тюнинг модели SVC\n",
    "\n",
    "У модели SVC есть параметр `C`, который штрафует за ошибку классификации. По умолчанию этот параметр равен 1. Зададим несколько возможных значений для этого параметра и посмотрим, какие значения являются наиболее выгодными:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'SVC' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-41-1bf5939473c2>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mc_values\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m     \u001b[0mclf\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mSVC\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mC\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mvalue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgamma\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"auto\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m     \u001b[0mclf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'SVC' is not defined"
     ]
    }
   ],
   "source": [
    "c_values = np.logspace(-2, 5, 36)\n",
    "\n",
    "accuracy_on_valid = []\n",
    "accuracy_on_train = []\n",
    "\n",
    "for i, value in enumerate(c_values):\n",
    "    clf = SVC(C=value, gamma=\"auto\")\n",
    "    \n",
    "    clf.fit(X_train, y_train)\n",
    "    \n",
    "    y_pred = clf.predict(X_valid)\n",
    "    y_pred_train = clf.predict(X_train)\n",
    "        \n",
    "    acc_valid = accuracy_score(y_valid, y_pred)\n",
    "    acc_train = accuracy_score(y_train, y_pred_train)\n",
    "    \n",
    "    if i % 5 == 0:\n",
    "        print('C = {}'.format(value))\n",
    "        print('\\tacc_valid = {}'.format(acc_valid))\n",
    "        print('\\tacc_train = {}\\n'.format(acc_train))\n",
    "    \n",
    "    accuracy_on_valid.append(acc_valid)\n",
    "    accuracy_on_train.append(acc_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(c_values, accuracy_on_valid, label=\"valid\")\n",
    "plt.plot(c_values, accuracy_on_train, label=\"train\")\n",
    "\n",
    "plt.xlabel('Значение параметра C')\n",
    "plt.ylabel('Accuracy')\n",
    "\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как мы видим, точность на валидационных данных до определённого момента растёт, но затем начинает падать. Пик точности попадает приблизительно на значение $C = 10000$. Дальше мы видим спад точности на валидационных данных, однако, точность на тренировочных данных продолжает расти. Это означает, что модель начинает переобучаться.\n",
    "\n",
    "Можно заметить, что точность на валидационных данных при $C = 10000$ уже выше, чем при использовании логистической регрессии, а также выше, чем при использовании SVM без настройки параметров.\n",
    "\n",
    "## KNN\n",
    "\n",
    "KNN расшифровывается как _K Nearest Neighbours_ или _K ближайших соседей_. Это один из самых простых в понимании методов машинного обучения. Представим каждый объект из рассматриваемых данных в виде точки в пространстве признаков. Метод KNN основан на предположении, что объекты одного класса расположены в пространстве близко друг к другу. Раз так, то можно классифицировать новый объект исходя из того, какие объекты находятся в пространстве рядом с ним.\n",
    "\n",
    "### Масштабирование признаков с использованием RobustScaler\n",
    "\n",
    "В первую очередь, раз мы работаем с расстояниями между объектами, нам необходимо отмасштабировать признаки так, чтобы они вносили в это расстояние соизмеримый вклад. Делать это мы будем с помощью `RobustScaler`. При таком подходе масштабирования признаков минимизируется влияние выбросов в данных. Это достигается за счёт того, что при масштабировании используется медиана и интерквартильный размах."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import RobustScaler\n",
    "from sklearn.neighbors import KNeighborsClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.25, random_state=42)\n",
    "\n",
    "scaler = RobustScaler()\n",
    "cols_for_scaling = ['Age', 'SibSp', 'Parch', 'Fare']\n",
    "\n",
    "X_train[cols_for_scaling] = scaler.fit_transform(X_train[cols_for_scaling])\n",
    "X_valid[cols_for_scaling] = scaler.transform(X_valid[cols_for_scaling])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train[cols_for_scaling].describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как мы видим, после масштабирования мода каждого из масштабируемых признаков стала равной 0.\n",
    "\n",
    "### Классификация с помощью KNN\n",
    "\n",
    "Итак, построим нашу модель. Идея метода заключается в том, что, классифицируя некоторый объект, мы смотрим на `K` его ближайших соседей и смотрим, представителей какого класса среди этих соседей больше всего. К такому классу мы и относим классифицируемый объект.\n",
    "\n",
    "Построим модель для различных `K` чтобы подобрать наиболее удачное значение."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k_values = np.arange(1, 11)\n",
    "\n",
    "accuracy_on_valid = []\n",
    "accuracy_on_train = []\n",
    "\n",
    "for i, value in enumerate(k_values):\n",
    "    clf = KNeighborsClassifier(n_neighbors=value)\n",
    "    \n",
    "    clf.fit(X_train, y_train)\n",
    "    \n",
    "    y_pred = clf.predict(X_valid)\n",
    "    y_pred_train = clf.predict(X_train)\n",
    "        \n",
    "    acc_valid = accuracy_score(y_valid, y_pred)\n",
    "    acc_train = accuracy_score(y_train, y_pred_train)\n",
    "    \n",
    "    if i % 2 == 0:\n",
    "        print('K = {}'.format(value))\n",
    "        print('\\tacc_valid = {}'.format(acc_valid))\n",
    "        print('\\tacc_train = {}\\n'.format(acc_train))\n",
    "    \n",
    "    accuracy_on_valid.append(acc_valid)\n",
    "    accuracy_on_train.append(acc_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(k_values, accuracy_on_valid, label=\"valid\")\n",
    "plt.plot(k_values, accuracy_on_train, label=\"train\")\n",
    "\n",
    "plt.xlabel('Значение параметра K')\n",
    "plt.ylabel('Accuracy')\n",
    "\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы видим, что при малых значениях `K` модель склонна к переобучению. Оптимальном выбором является число $K = 6$. Построим модель ещё раз, используя эти знания."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = KNeighborsClassifier(n_neighbors=6)\n",
    "\n",
    "clf.fit(X_train, y_train)\n",
    "\n",
    "y_pred = clf.predict(X_valid)\n",
    "\n",
    "accuracy_score(y_valid, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Полученная точность также выше, чем при использовании логистической регрессии.\n",
    "\n",
    "## Метрики качества классификационных моделей\n",
    "\n",
    "Ранее мы для задач классификации использовали только метрику _accuracy_, которая равна доле правильных ответов классификатора к общему количеству объектов в выборке. Такая метрика очень плохо работает в случае несбалансированной выборки (т.е. случая, когда объектов одного класса сильно больше, чем объектов другого). Представим ситуацию: мы классифицируем объекты, среди которых 950 объектов класса 1 и 50 объектов класса 0. На таких данных даже классификатор, который относит все объекты к классу 1 без разбора, даст точность 0.95. Для таких случаев рекомендуется использовать другие метрики качества.\n",
    "\n",
    "Разберёмся подробнее в результатах, которые мы только что получили с помощью классификатора KNN. Для этого будем использовать _confusion matrix_, т.е. _матрицу ошибок_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "cm = confusion_matrix(y_valid, y_pred)\n",
    "\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Данная матрица содержит в себе 4 значения:\n",
    "\n",
    "* True Negative (TN) - случаи, когда мы правильно классифицировали объект как объект класса 0 (левое верхнее значение)\n",
    "* False Positive (FP) - случаи, когда мы классифицировали объект как объект класса 1, хотя, он на самом деле имеет класс 0 (правое верхнее)\n",
    "* False Negative (FN) - классифицировали объект как объект класса 0, а на самом деле он имеет класс 1 (левое нижнее)\n",
    "* True Positive (TP) - правильно классифицировали объект как объект класса 1 (правое нижнее)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TP = ((y_pred == 1) & (y_valid) == 1).sum()\n",
    "TP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TN = cm[0, 0]\n",
    "FP = cm[0, 1]\n",
    "FN = cm[1, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Точность и полнота\n",
    "\n",
    "Метрика _precision_ (точность) является долей объектов класса 1, верно классифицированных моделью, к общему числу объектов, которые модель классифицировала как объекты класса 1. Т.е.\n",
    "\n",
    "$$precision = \\dfrac{TP}{TP + FP}.$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "precision = TP / (TP + FP)\n",
    "precision"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Данную метрику можно также сразу посчитать по предсказанным данным с помощью функции `precision_score` из модуля `sklearn.metrics`.\n",
    "\n",
    "Метрика _recall_ (_полнота_) является долей найденных моделью объектов класса 1:\n",
    "\n",
    "$$recall = \\dfrac{TP}{TP + FN}.$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import recall_score\n",
    "\n",
    "recall_score(y_valid, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### F-мера\n",
    "\n",
    "Хорошим способом комбинировать эти две метрики является мера $F_1$:\n",
    "\n",
    "$$F_1 = 2 \\cdot \\dfrac{precision \\cdot recall}{precision + recall}.$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "\n",
    "f1_score(y_valid, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### AUC\n",
    "\n",
    "Следующей часто используемой метрикой является метрика _AUC_ или _Area Under Curve_ (площадь под кривой). Часто в качестве кривой используется кривая _ROC_. Разберёмся, что это за кривая. Для этого нам нужно получить не просто метки класса для каждого классифицируемого объекта, а вероятности принадлежности к классу 1. Это можно сделать с помощью метода `.predict_proba`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_proba = clf.predict_proba(X_valid)\n",
    "\n",
    "print(y_pred_proba[:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Данный метод возвращает для каждого классифицируемого объекта список из двух значений. Первой идёт вероятность принадлежности классу 0, а второй - вероятность принадлежности классу 1. Как мы видим, сумма двух значений всегда равна 1. \n",
    "\n",
    "Нам понадобится лишь вероятность принадлежности классу 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_proba = y_pred_proba[:, 1]\n",
    "\n",
    "print(y_pred_proba[:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим, как распределяются эти вероятности. Для этого построим две гистограммы. В первом случае будем смотреть на распределение вероятностей на объектах, принадлежащих классу 1, а во втором - на объектах класса 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(y_pred_proba[y_valid == 1], bins=7, density=True, label='class 1', alpha=0.5)\n",
    "plt.hist(y_pred_proba[y_valid == 0], bins=7, density=True, label='class 0', alpha=0.5)\n",
    "\n",
    "plt.xlabel(\"Probability\")\n",
    "plt.ylabel(\"Density\")\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы видим, что наша модель неплохо разделила объекты классов 0 и 1.\n",
    "\n",
    "Теперь построим ROC-кривую. Для этого нам понадобятся следующие значения:\n",
    "\n",
    "* $FPR = \\dfrac{FP}{FP + TN}$ - False Positive Rate, т.е. доля False Positive\n",
    "\n",
    "* $TPR = \\dfrac{TP}{TP + FN}$ - True Positive Rate, т.е. доля True Positive (совпадает с recall)\n",
    "\n",
    "На основании этих метрик строится ROC-кривая. Посчитаем эти значения с помощью функции `roc_curve` из модуля `sklearn.metrics`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve\n",
    "\n",
    "fpr, tpr, thresholds = roc_curve(y_valid, y_pred_proba, pos_label=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь параметр `pos_label` - метка того класса, который мы считаем позитивным. В нашем случае это класс 1.\n",
    "\n",
    "Идея ROC-кривой состоит в следующем. Если у нас есть массив с вероятностями принадлежности объектов классу 1, то порог, по которому принимается решение, мы можем выбирать сами. Например, если мы возьмём в качестве порога 1, то модель будет классифицировать объекты как объекты класса 1 только если классификатор на них абсолютно уверен (т.е. вероятность равна 1). Мы также можем взять этот порог и меньше: $0.9$, $0.7$, $0.5$ и т.д. Каждому такому выбору порога соответствуют свои значения FPR и TPR.\n",
    "\n",
    "Итак, будем постепенно уменьшать порог, начиная с 1, и смотреть, в какие моменты значения FPR и TPR меняются. Как только какое-нибудь из этих значений изменилось, мы будем сохранять текущее значение FPR, TPR, а также значение порога, на котором произошло изменение. Именно эти значения и возвращает функция `roc_curve`.\n",
    "\n",
    "Например, рассмотрим четвёртый элемент в массиве `thresholds`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "th = thresholds[3]\n",
    "th"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь посмотрим, какие значения FPR и TPR соответствуют этому порогу:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(fpr[3])\n",
    "print(tpr[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Эти же значения можно посчитать и руками:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fpr_ = ((y_valid==0) & (y_pred==1) & (y_pred_proba>=th)).sum() / (y_valid==0).sum()\n",
    "tpr_ = ((y_valid==1) & (y_pred==1) & (y_pred_proba>=th)).sum() / (y_valid==1).sum()\n",
    "\n",
    "print(fpr_)\n",
    "print(tpr_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь ROC-кривая просто строится по точкам, которые получаются, если FPR откладывать по оси x, а TPR - по оси y:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rcParams['figure.figsize'] = 5, 5\n",
    "\n",
    "plt.plot(fpr, tpr)\n",
    "plt.plot([0, 1], [0, 1], color='grey', linestyle='dashed')\n",
    "\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('ROC curve')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Соответственно, метрика ROC AUC - это площадь под кривой ROC. Для константного классификатора эта метрика равна $0.5$, поэтому для хороших классификаторов она должна быть между $0.5$ и $1$.\n",
    "\n",
    "Посчитать эту метрику можно и сразу, воспользовавшись соответствующей функцией из библиотеки `sklearn`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "roc_auc_score(y_valid, y_pred_proba)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Деревья решений и случайный лес\n",
    "\n",
    "_Дерево решений_ - один из самых легко интерпретируемых методов машинного обучения. При использовании этого метода по тренировочным данным строится бинарное дерево, в каждом узле которого происходит разбиение данных по значению какого-то признака. На конце каждой ветки дерева (т.е. в каждом её _листе_) располагается метка класса, к которому следует отнести те объекты, которые дошли до соответствующего листа."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.25, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Разберёмся с тем, какие параметры есть у модели `DecisionTreeClassifier`, и как их настраивать. Первый интересующий нас параметр - максимальная глубина дерева или `max_depth`. Деревья большой глубины склонны к переобучению: модель просто слишком детально подстраивается под тренировочные данные."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Unknown label type: 'continuous'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-42-9c38895515f1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      7\u001b[0m     \u001b[0mclf\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mDecisionTreeClassifier\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmax_depth\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m     \u001b[0mclf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     10\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m     \u001b[0my_pred\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mclf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_valid\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\sklearn\\tree\\tree.py\u001b[0m in \u001b[0;36mfit\u001b[1;34m(self, X, y, sample_weight, check_input, X_idx_sorted)\u001b[0m\n\u001b[0;32m    814\u001b[0m             \u001b[0msample_weight\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0msample_weight\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    815\u001b[0m             \u001b[0mcheck_input\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mcheck_input\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 816\u001b[1;33m             X_idx_sorted=X_idx_sorted)\n\u001b[0m\u001b[0;32m    817\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    818\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\sklearn\\tree\\tree.py\u001b[0m in \u001b[0;36mfit\u001b[1;34m(self, X, y, sample_weight, check_input, X_idx_sorted)\u001b[0m\n\u001b[0;32m    152\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    153\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mis_classification\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 154\u001b[1;33m             \u001b[0mcheck_classification_targets\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    155\u001b[0m             \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    156\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\multiclass.py\u001b[0m in \u001b[0;36mcheck_classification_targets\u001b[1;34m(y)\u001b[0m\n\u001b[0;32m    167\u001b[0m     if y_type not in ['binary', 'multiclass', 'multiclass-multioutput',\n\u001b[0;32m    168\u001b[0m                       'multilabel-indicator', 'multilabel-sequences']:\n\u001b[1;32m--> 169\u001b[1;33m         \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Unknown label type: %r\"\u001b[0m \u001b[1;33m%\u001b[0m \u001b[0my_type\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    170\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    171\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: Unknown label type: 'continuous'"
     ]
    }
   ],
   "source": [
    "max_depth_values = np.arange(2, 20)\n",
    "\n",
    "accuracy_on_valid = []\n",
    "accuracy_on_train = []\n",
    "\n",
    "for i, value in enumerate(max_depth_values):\n",
    "    clf = DecisionTreeClassifier(max_depth=value)\n",
    "    \n",
    "    clf.fit(X_train, y_train)\n",
    "    \n",
    "    y_pred = clf.predict(X_valid)\n",
    "    y_pred_train = clf.predict(X_train)\n",
    "        \n",
    "    acc_valid = accuracy_score(y_valid, y_pred)\n",
    "    acc_train = accuracy_score(y_train, y_pred_train)\n",
    "    \n",
    "    if i % 4 == 2:\n",
    "        print('K = {}'.format(value))\n",
    "        print('\\tacc_valid = {}'.format(acc_valid))\n",
    "        print('\\tacc_train = {}\\n'.format(acc_train))\n",
    "    \n",
    "    accuracy_on_valid.append(acc_valid)\n",
    "    accuracy_on_train.append(acc_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "x and y must have same first dimension, but have shapes (18,) and (0,)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-43-17cf8ac1495e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrcParams\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'figure.figsize'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m6\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmax_depth_values\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maccuracy_on_valid\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"valid\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmax_depth_values\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maccuracy_on_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"train\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\matplotlib\\pyplot.py\u001b[0m in \u001b[0;36mplot\u001b[1;34m(scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m   2793\u001b[0m     return gca().plot(\n\u001b[0;32m   2794\u001b[0m         *args, scalex=scalex, scaley=scaley, **({\"data\": data} if data\n\u001b[1;32m-> 2795\u001b[1;33m         is not None else {}), **kwargs)\n\u001b[0m\u001b[0;32m   2796\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2797\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\matplotlib\\axes\\_axes.py\u001b[0m in \u001b[0;36mplot\u001b[1;34m(self, scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1664\u001b[0m         \"\"\"\n\u001b[0;32m   1665\u001b[0m         \u001b[0mkwargs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcbook\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnormalize_kwargs\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmlines\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mLine2D\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_alias_map\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1666\u001b[1;33m         \u001b[0mlines\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_get_lines\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1667\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0mline\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mlines\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1668\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd_line\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mline\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\matplotlib\\axes\\_base.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m    223\u001b[0m                 \u001b[0mthis\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    224\u001b[0m                 \u001b[0margs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 225\u001b[1;33m             \u001b[1;32myield\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_plot_args\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mthis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    226\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    227\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mget_next_color\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\matplotlib\\axes\\_base.py\u001b[0m in \u001b[0;36m_plot_args\u001b[1;34m(self, tup, kwargs)\u001b[0m\n\u001b[0;32m    389\u001b[0m             \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mindex_of\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtup\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    390\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 391\u001b[1;33m         \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_xy_from_xy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    392\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    393\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcommand\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m'plot'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\matplotlib\\axes\\_base.py\u001b[0m in \u001b[0;36m_xy_from_xy\u001b[1;34m(self, x, y)\u001b[0m\n\u001b[0;32m    268\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    269\u001b[0m             raise ValueError(\"x and y must have same first dimension, but \"\n\u001b[1;32m--> 270\u001b[1;33m                              \"have shapes {} and {}\".format(x.shape, y.shape))\n\u001b[0m\u001b[0;32m    271\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    272\u001b[0m             raise ValueError(\"x and y can be no greater than 2-D, but have \"\n",
      "\u001b[1;31mValueError\u001b[0m: x and y must have same first dimension, but have shapes (18,) and (0,)"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['figure.figsize'] = 6, 4\n",
    "\n",
    "plt.plot(max_depth_values, accuracy_on_valid, label=\"valid\")\n",
    "plt.plot(max_depth_values, accuracy_on_train, label=\"train\")\n",
    "\n",
    "plt.xlabel('Значение параметра max_depth')\n",
    "plt.ylabel('Accuracy')\n",
    "\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Это мы и наблюдаем: при достаточно больших значениях параметра `max_depth` точность на тренировочных данных почти достигает 1. На валидационных же данных точность достигает своего пика приблизительно на значении `max_depth = 7`, а затем начинает падать."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = DecisionTreeClassifier(max_depth=7)\n",
    "\n",
    "clf.fit(X_train, y_train)\n",
    "\n",
    "y_pred = clf.predict(X_valid)\n",
    "\n",
    "accuracy_score(y_valid, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Даже в лучшем случае мы получаем точность, которая уступает точности других рассмотренных нами моделей. \n",
    "\n",
    "Рассмотрим теперь алгоритм, основанный на деревьях решений, но являющийся более сложным, а именно со _Случайным лесом_ или _Random forest_.\n",
    "\n",
    "### Random Forest\n",
    "\n",
    "В этом алгоритме используется _ансамбль_ деревьев решений. Для каждого обучаемого дерева решений создаётся подвыборка из исходной тренировочной выборки, кроме того, при обучении каждого дерева используется лишь часть признаков. \n",
    "\n",
    "На этапе предсказания мы учитываем ответы, полученные каждым из деревьев, и выбираем тот ответ, за который \"проголосовало\" наибольшее количество деревьев. Это позволяет, в частности, уменьшить влияние переобучения каждого из деревьев."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Рассмотрим несколько параметров данной модели:\n",
    "\n",
    "* `n_estimators` - число деревьев в ансамбле\n",
    "* `max_features` - максимальное число признаков, которое может быть использовано при построении каждого дерева\n",
    "* `max_depth` - максимальная глубина дерева\n",
    "\n",
    "Для того, чтобы выбрать подходящий набор параметров, можно использовать _Grid search_ или поиск по сетке. Этот метод используется для того, чтобы перебрать все возможные комбинации параметров и выбрать ту комбинацию, которая максимизирует выбранную нами метрику. Можно воспользоваться готовой реализацией из библиотеки `sklearn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Зададим сетку параметров, по которой мы хотели бы провести поиск:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parameters = {\n",
    "    'n_estimators': [150, 200, 250],\n",
    "    'max_features': np.arange(5, 9),\n",
    "    'max_depth': np.arange(5, 10),\n",
    "}\n",
    "\n",
    "clf = GridSearchCV(\n",
    "    estimator=RandomForestClassifier(),\n",
    "    param_grid=parameters,\n",
    "    scoring='accuracy',\n",
    "    cv=5,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`GridSearchCV` - это классификатор, который строится на основе модели `estimator`, пробегая все комбинации значений из `param_grid`. Для каждой комбинации параметров по кросс-валидации на указанном количестве _фолдов_ считается метрика, указанная в `scoring`. Наконец, выбирается та комбинация параметров, при которой выбранная метрика оказалась максимальной, и дальше для предсказания используется именно этот набор параметров.\n",
    "\n",
    "### Кросс-валидация\n",
    "\n",
    "При оценке каждой построенной в процессе модели используется _кросс-валидация_. Это метод, при котором вся обучающая выборка разбивается на заданное число _фолдов_ (частей), и по очереди каждый из этих фолдов выкидывается из тренировочной выборки и используется для валидации. Другими словами, если `cv=5`, то мы строим 5 моделей, для каждой из них выкидывая один из фолдов из обучающей выборки. Затем значения выбранной метрики усредняются на этих 5 моделях."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для ознакомления с результатами Grid search можно использовать атрибут `.cv_results_`. Удобнее всего визуализировать эти результаты в виде `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv_results = pd.DataFrame(clf.cv_results_)\n",
    "\n",
    "cv_results.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим, как выбранные нами параметры влияют на точность модели:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "param_columns = [\n",
    "    column\n",
    "    for column in cv_results.columns\n",
    "    if column.startswith('param_')\n",
    "]\n",
    "\n",
    "score_columns = ['mean_test_score', 'mean_train_score']\n",
    "\n",
    "cv_results = (cv_results[param_columns + score_columns]\n",
    "              .sort_values(by=score_columns, ascending=False))\n",
    "\n",
    "cv_results.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы видим, что наилучшей точности модель достигает, если взять 150 деревьев глубины не более 6, и на каждом из них выбирать не более 6 признаков. При этом модель всё ещё даёт ощутимо более хороший результат на обучающей выборке, но уже не так сильно переобучается.\n",
    "\n",
    "Наилучшие параметры можно также посмотреть, используя атрибут `.best_params_`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Полученная в результате модель аналогична такой модели:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = RandomForestClassifier(max_depth=6, max_features=6, n_estimators=150)\n",
    "\n",
    "clf.fit(X_train, y_train)\n",
    "\n",
    "y_pred = clf.predict(X_valid)\n",
    "\n",
    "accuracy_score(y_valid, y_pred)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}