hw7-trees-rf.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Домашнее задание №7: деревья, случайный лес (14.5 баллов)\n",
    "<!-- ![](meme.jpg) -->\n",
    "<img src=\"meme.jpg\" alt=\"Drawing\" style=\"width: 700px;\"/>\n",
    "\n",
    "## Часть 1: основы построения решающие дерева\n",
    "\n",
    "начнём с простого..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 1.1 (1 балл)\n",
    "Пусть известно, что в вершину решающего дерева попали 10 объектов, 8 из которых имеют метку класса $k_1$, а 2 - $k_2$. Посчитайте энтропию (с натуральным логарифмом). Ответ округлите до двух знаков после запятой."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Энтропия равна: 0.5\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print('Энтропия равна:', round((-1*(0.2*math.log(0.2)+0.8*math.log(0.8))), 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (*・‿・)ノ⌒*:･ﾟ✧"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 1.2 (1 балл)\n",
    "Пусть дополнительно известно, что вершина из предыдущего задания не является листовой и возможно такое разбиение, что в левое поддерево попадут все объекты класса $k_1$, а в правое - класса $k_2$. Посчитайте критерий информативности (в формулировке разности impurity пришедшей выборки и полученного разбиения) такой вершины с применением индекса Джини. Ответ округлите до двух знаков после запятой."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Критерий информативности равен:  0.32\n"
     ]
    }
   ],
   "source": [
    "print('Критерий информативности равен: ', round(((0.2*0.8+0.8*0.2)-(1*0)-(1*0)), 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (￣▽￣)/♫•*¨*•.¸¸♪"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 1.3 (0.5 балла)\n",
    "Пусть при построении дерева образовалась листовая вершина с 10 объектами, значения целевой переменной для которых следующие: [1, 10, 5, 18, 100, 30, 50, 61, 84, 47] (решается задача регрессии). Чему будут равны предсказания модели для этих объектов?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Прогноз будет равен: 40.6\n"
     ]
    }
   ],
   "source": [
    "print('Прогноз будет равен:', (1+10+5+18+100+30+50+61+84+47)/10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ༼ つ ◕_◕ ༽つ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 2: решающие деревья\n",
    "\n",
    "### Задание 2.1 (2 балла)\n",
    "Первым делом реализуйте функцию `find_best_split`, которая должна находить оптимальное разбиение подмножества обучающей выборки. При решении задачи регрессии испольуйте дисперсию подвыборки, при решении задачи классификации используйте критерий Джини. Эту функцию можно протестировать на датасете `Boston` из `sklearn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "from typing import Dict, List, Tuple, Union\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.datasets import load_boston"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "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": [
    "boston = load_boston()\n",
    "X = pd.DataFrame(data=boston[\"data\"], columns=boston[\"feature_names\"])\n",
    "y = boston[\"target\"]\n",
    "X.head()\n",
    "\n",
    "print(boston[\"DESCR\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При решении задания имейте в виду, что под критерием Джини подразумевается такая функция:\n",
    "\n",
    "$$Q(R) = -\\frac {|R_{\\ell}|}{|R|}H(R_\\ell) -\\frac {|R_r|}{|R|}H(R_r) ,$$\n",
    "\n",
    "где $R$ — множество объектов, попавших в вершину, $R_{\\ell}$ и $R_r$ — объекты, попавшие в левое и правое поддеревья,\n",
    "$H(R) = 1 - p_1^2 - p_0^2$, $p_1$, $p_0$ — доли объектов класса 1 и 0 соответственно.\n",
    "\n",
    "Для категориальных признаков применяется наивный алгоритм разбиения: мы пытаемся найти одно значение, разбиение по которому сильнее всего увеличит критерий информативности. Иными словами, объекты с конкретным значением признака отправляем в левое поддерево, остальные - в правое. Обратите внимание, что это далеко не оптимальные способ учёта категориальных признаков. Например, можно было бы на каждое значение категориального признака создавать отдельное поддерево или использовать более сложные подходы. Подробнее об этом можно прочитать в конспектах [лекций](https://github.com/esokolov/ml-course-hse/blob/master/2019-fall/lecture-notes/lecture07-trees.pdf) по машинному обучению на ПМИ (раздел «Учёт категориальных признаков»).\n",
    "\n",
    "В качестве подсказок реализации можете пользоваться кодом из бонусной части семинара по решающим деревьям (скачайте решённую версию ноутбука)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/andreydyadyunov/Downloads/anaconda3/lib/python3.8/site-packages/numpy/core/_methods.py:233: RuntimeWarning: Degrees of freedom <= 0 for slice\n",
      "  ret = _var(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/andreydyadyunov/Downloads/anaconda3/lib/python3.8/site-packages/numpy/core/_methods.py:194: RuntimeWarning: invalid value encountered in true_divide\n",
      "  arrmean = um.true_divide(\n",
      "/Users/andreydyadyunov/Downloads/anaconda3/lib/python3.8/site-packages/numpy/core/_methods.py:226: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n"
     ]
    }
   ],
   "source": [
    "def find_best_split(\n",
    "    feature_vector: Union[np.ndarray, pd.DataFrame], \n",
    "    target_vector: Union[np.ndarray, pd.Series],\n",
    "    task: str = \"classification\",\n",
    "    feature_type: str = \"real\"\n",
    ") -> Tuple[np.ndarray, np.ndarray, float, float]:\n",
    "    \"\"\"\n",
    "    Указания:\n",
    "    * Пороги, приводящие к попаданию в одно из поддеревьев пустого множества объектов, не рассматриваются.\n",
    "    * В качестве порогов, нужно брать среднее двух сосдених (при сортировке) значений признака\n",
    "    * Поведение функции в случае константного признака может быть любым.\n",
    "    * При одинаковых приростах Джини или дисперсии нужно выбирать минимальный сплит.\n",
    "    * За наличие в функции циклов балл будет снижен. Векторизуйте! :)\n",
    "\n",
    "    :param feature_vector: вещественнозначный вектор значений признака\n",
    "    :param target_vector: вектор классов объектов,  len(feature_vector) == len(target_vector)\n",
    "    :param task: либо `classification`, либо `regression`\n",
    "    :param feature_type: либо `real`, либо `categorical`\n",
    "    \n",
    "    :return thresholds: отсортированный по возрастанию вектор со всеми возможными порогами, по которым объекты можно\n",
    "     разделить на две различные подвыборки, или поддерева\n",
    "    :return ginis: вектор со значениями критерия Джини для каждого из порогов в thresholds len(ginis) == len(thresholds)\n",
    "    :return threshold_best: оптимальный порог (число)\n",
    "    :return gini_best: оптимальное значение критерия Джини (число)\n",
    "    \"\"\"\n",
    "    # ᕕ(╭ರ╭ ͟ʖ╮•́)⊃¤=(————-\n",
    "    thresholds = []\n",
    "    ginis = []\n",
    "    if task == 'classification':\n",
    "        if feature_type=='real':\n",
    "            gini_best = float(-10**27)\n",
    "            for i in np.unique(feature_vector):\n",
    "                left = target_vector[feature_vector >= i]\n",
    "                right = target_vector[feature_vector <i]\n",
    "                if left.size==0:\n",
    "                    HR_left = 1\n",
    "                    HR_right = 1-(len(np.where(right==1)[0])/right.size)**2 - (len(np.where(right==0)[0])/right.size)**2\n",
    "                elif right.size==0:\n",
    "                    HR_right=1\n",
    "                    HR_left = 1-(len(np.where(left==1)[0])/left.size)**2 - (len(np.where(left==0)[0])/left.size)**2\n",
    "                else:\n",
    "                    HR_right = 1-(len(np.where(right==1)[0])/right.size)**2 - (len(np.where(right==0)[0])/right.size)**2\n",
    "                    HR_left = 1-(len(np.where(left==1)[0])/left.size)**2 - (len(np.where(left==0)[0])/left.size)**2\n",
    "                QR = -(right.size/feature_vector.size)*HR_right-(left.size/feature_vector.size)*HR_left\n",
    "                ginis.append(QR)\n",
    "                thresholds.append(i)\n",
    "                if QR > gini_best:\n",
    "                    gini_best = QR\n",
    "                    threshold_best = i\n",
    "            return tuple([np.array(thresholds), np.array(ginis), threshold_best, gini_best])\n",
    "        elif feature_type=='categorical':\n",
    "            gini_best = float(-10**27)\n",
    "            for i in np.unique(feature_vector):\n",
    "                left = target_vector[feature_vector == i]\n",
    "                right = target_vector[feature_vector != i]\n",
    "                if left.size==0:\n",
    "                    HR_left = 1\n",
    "                    HR_right = 1-(len(np.where(right==1)[0])/right.size)**2 - (len(np.where(right==0)[0])/right.size)**2\n",
    "                elif right.size==0:\n",
    "                    HR_right=1\n",
    "                    HR_left = 1-(len(np.where(left==1)[0])/(left.size))**2 - len(np.where(left==0)[0])/left.size**2\n",
    "                else:\n",
    "                    HR_right = 1-(len(np.where(right==1)[0])/right.size)**2 - (len(np.where(right==0)[0])/right.size)**2\n",
    "                    HR_left = 1-(len(np.where(left==1)[0])/left.size)**2 - (len(np.where(left==0)[0])/left.size)**2\n",
    "                QR = -(right.size/feature_vector.size)*HR_right-(left.size/feature_vector.size)*HR_left\n",
    "                ginis.append(QR)\n",
    "                thresholds.append(i)\n",
    "                if QR > gini_best:\n",
    "                    gini_best = QR\n",
    "                    threshold_best = i\n",
    "            return tuple([np.array(thresholds), np.array(ginis), threshold_best, gini_best])\n",
    "    if task=='regression':\n",
    "        gini_best = float(-10**27)\n",
    "        if feature_type=='real':\n",
    "            for i in np.unique(feature_vector):\n",
    "                left = target_vector[feature_vector >= i]\n",
    "                right = target_vector[feature_vector <i]\n",
    "                HR_right = right.std()\n",
    "                HR_left = left.std()\n",
    "                QR = -(right.size/target_vector.size)*HR_right-(left.size/target_vector.size)*HR_left\n",
    "                ginis.append(QR)\n",
    "                thresholds.append(i)\n",
    "                if QR > gini_best:\n",
    "                    gini_best = QR\n",
    "                    threshold_best = i\n",
    "            return tuple([np.array(thresholds), np.array(ginis), threshold_best, gini_best])\n",
    "        elif feature_type=='categorical':\n",
    "            gini_best = float(-10**27)\n",
    "            for i in np.unique(feature_vector):\n",
    "                left = target_vector[feature_vector == i]\n",
    "                right = target_vector[feature_vector != i]\n",
    "                HR_right = right.std()\n",
    "                HR_left = left.std()\n",
    "                QR = -(right.size/feature_vector.size)*HR_right-(left.size/feature_vector.size)*HR_left\n",
    "                ginis.append(QR)\n",
    "                thresholds.append(i)\n",
    "                if QR > gini_best:\n",
    "                    gini_best = QR\n",
    "                    threshold_best = i\n",
    "            return tuple([np.array(thresholds), np.array(ginis), threshold_best, gini_best])\n",
    "    pass\n",
    "\n",
    "thresholds, variances, threshold_best, variance_best = find_best_split(\n",
    "    X[\"CRIM\"].to_numpy(), \n",
    "    y, \n",
    "    task=\"regression\",\n",
    "    feature_type=\"real\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Выведите график зависимости значения критерия ошибки от порогового значения при разбиении вершины по признаку `CRIM`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "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.plot(thresholds,variances)\n",
    "plt.xlabel('порог')\n",
    "plt.ylabel('ошибка')\n",
    "plt.axvline(x=threshold_best, color='g')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 2.2 (3 балла)\n",
    "Разберитесь с написанным кодом решающего дерева, заполните пропуски в коде и реализуйте недостающий метод _predict_node.\n",
    "\n",
    "Построение дерева осуществляется согласно базовому жадному алгоритму, предложенному в лекции в разделе «Построение дерева».\n",
    "- Выбор лучшего разбиения необходимо производить по критерию Джини\n",
    "- Критерий останова: все объекты в листе относятся к одному классу или ни по одному признаку нельзя разбить выборку\n",
    "- Ответ в листе: наиболее часто встречающийся класс в листе"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DecisionTree:\n",
    "    def __init__(\n",
    "        self, \n",
    "        feature_types: Union[List[str], np.ndarray], \n",
    "        max_depth: int = None, \n",
    "        min_samples_split: int = None, \n",
    "        min_samples_leaf: int = None,\n",
    "        task: str = \"classification\"\n",
    "    ) -> None:\n",
    "        \n",
    "        if np.any(list(map(lambda x: x != \"real\" and x != \"categorical\", feature_types))):\n",
    "            raise ValueError(\"There is unknown feature type\")\n",
    "\n",
    "        # В этой переменной будем хранить узлы решающего дерева. Каждая вершина хранит в себе идентификатор того,\n",
    "        # является ли она листовой. Листовые вершины хранят значение класса для предсказания, нелистовые - правого и\n",
    "        # левого детей (поддеревья для продолжения процедуры предсказания)\n",
    "        self._tree = {}\n",
    "        \n",
    "        # типы признаков (категориальные или числовые)\n",
    "        self._feature_types = feature_types\n",
    "        \n",
    "        # гиперпараметры дерева\n",
    "        self._max_depth = max_depth\n",
    "        self._min_samples_split = min_samples_split\n",
    "        self._min_samples_leaf = min_samples_leaf\n",
    "        self.task = task\n",
    "\n",
    "    def _fit_node(\n",
    "        self, \n",
    "        sub_X: np.ndarray, \n",
    "        sub_y: np.ndarray, \n",
    "        node: dict\n",
    "    ) -> None:\n",
    "        \n",
    "        # критерий останова\n",
    "        if np.all(sub_y == sub_y[0]):\n",
    "            node[\"type\"] = \"terminal\"\n",
    "            node[\"class\"] = sub_y[0]\n",
    "            return\n",
    "\n",
    "        feature_best, threshold_best, gini_best, split = None, None, None, None\n",
    "        for feature in range(1, sub_X.shape[1]):\n",
    "            feature_type = self._feature_types[feature]\n",
    "            categories_map = {}\n",
    "\n",
    "            # подготавливаем признак для поиска оптимального порога\n",
    "            if feature_type == \"real\":\n",
    "                feature_vector = sub_X[:, feature]\n",
    "            elif feature_type == \"categorical\":\n",
    "                # здесь могла быть реализация более сложного подхода к обработке категориального признака\n",
    "                feature_vector = sub_X[:, feature]\n",
    "\n",
    "            # ищем оптимальный порог\n",
    "            _, _, threshold, gini = find_best_split(feature_vector, sub_y, self.task, feature_type)\n",
    "            \n",
    "            if gini_best is None or gini > gini_best:\n",
    "                feature_best = feature\n",
    "                gini_best = gini\n",
    "\n",
    "                # split - маска на объекты, которые должны попасть в левое поддерево\n",
    "                if feature_type == \"real\":\n",
    "                    threshold_best = threshold\n",
    "                    split = feature_vector < threshold_best\n",
    "                elif feature_type == \"categorical\":\n",
    "                    # в данной реализации это просто значение категории\n",
    "                    threshold_best = threshold\n",
    "                    split = feature_vector != threshold_best\n",
    "                else:\n",
    "                    raise ValueError\n",
    "\n",
    "        # записываем полученные сплиты в атрибуты класса\n",
    "        if feature_best is None:\n",
    "            node[\"type\"] = \"terminal\"\n",
    "            node[\"class\"] = Counter(sub_y).most_common(1)[0][0]\n",
    "            return\n",
    "\n",
    "        node[\"type\"] = \"nonterminal\"\n",
    "\n",
    "        node[\"feature_split\"] = feature_best\n",
    "        if self._feature_types[feature_best] == \"real\":\n",
    "            node[\"threshold\"] = threshold_best\n",
    "        elif self._feature_types[feature_best] == \"categorical\":\n",
    "            node[\"category_split\"] = threshold_best\n",
    "        else:\n",
    "            raise ValueError\n",
    "            \n",
    "        node[\"left_child\"], node[\"right_child\"] = {}, {}\n",
    "        self._fit_node(sub_X[split], sub_y[split], node[\"left_child\"])\n",
    "        self._fit_node(sub_X[np.logical_not(split)], sub_y[np.logical_not(split)], node[\"right_child\"])\n",
    "\n",
    "    def _predict_node(self, x: np.ndarray, node: dict) -> int:\n",
    "        \"\"\"\n",
    "        Предсказание начинается с корневой вершины дерева и рекурсивно идёт в левое или правое поддерево в зависимости от значения\n",
    "        предиката на объекте. Листовая вершина возвращает предсказание.\n",
    "        :param x: np.array, элемент выборки\n",
    "        :param node: dict, вершина дерева\n",
    "        \"\"\"\n",
    "        # ᕕ(╭ರ╭ ͟ʖ╮•́)⊃¤=(————-\n",
    "        \n",
    "        if node['type']== 'nonterminal': \n",
    "            if self._feature_types[node['feature_split']] == 'categorical':\n",
    "                if x[node['feature_split']] != node['category_split']:\n",
    "                    return self._predict_node(x, node['left_child'])\n",
    "                else:\n",
    "                    return self._predict_node(x, node['right_child'])\n",
    "            elif self._feature_types[node['feature_split']] == 'real':\n",
    "                if x[node['feature_split']] < node['threshold']:\n",
    "                    return self._predict_node(x, node['left_child'])\n",
    "                else:\n",
    "                    return self._predict_node(x, node['right_child'])\n",
    "        elif 'terminal' == node['type']: \n",
    "            return node['class']\n",
    "\n",
    "    def fit(self, X: np.ndarray, y: np.ndarray) -> None:\n",
    "        self._fit_node(X, y, self._tree)\n",
    "\n",
    "    def predict(self, X: np.ndarray) -> np.ndarray:\n",
    "        predicted = []\n",
    "        for x in X:\n",
    "            predicted.append(self._predict_node(x, self._tree))\n",
    "            \n",
    "        return np.array(predicted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 2.3 (1 балл)\n",
    "Загрузите таблицу [students.csv](https://drive.google.com/file/d/0B2zoFVYw1rN3a0d0Zm43TzQ4aUU/view?usp=sharing) (это немного преобразованный датасет [User Knowledge](https://archive.ics.uci.edu/ml/datasets/User+Knowledge+Modeling)). В ней признаки объекта записаны в первых пяти столбцах, а в последнем записана целевая переменная (класс: 0 или 1). Постройте на одном изображении пять кривых \"порог — значение критерия Джини\" для всех пяти признаков. Отдельно визуализируйте scatter-графики \"значение признака — класс\" для всех пяти признаков."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['STG', 'SCG', 'STR', 'LPR', 'PEG']"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('students.csv')\n",
    "col = list(df.columns)\n",
    "col = col[:-1]\n",
    "col\n",
    "# col.remove('UNS')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      0\n",
       "1      1\n",
       "2      0\n",
       "3      1\n",
       "4      0\n",
       "      ..\n",
       "253    1\n",
       "254    1\n",
       "255    1\n",
       "256    1\n",
       "257    1\n",
       "Name:  UNS, Length: 258, dtype: int64"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "uns = df.iloc[:,-1]\n",
    "uns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (10,8))\n",
    "for i in col:\n",
    "    thresholds, variances, threshold_best, variance_best = find_best_split(\n",
    "    df[i].to_numpy(), \n",
    "    uns, \n",
    "    task=\"classification\",\n",
    "    feature_type=\"real\")\n",
    "    plt.plot(thresholds,variances, label = i)\n",
    "    plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "x and y must be the same size",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-180-0cc67eb5651e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_numpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0muns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_numpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxlabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Значение\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mylabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Класс\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Downloads/anaconda3/lib/python3.8/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mscatter\u001b[0;34m(x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, verts, edgecolors, plotnonfinite, data, **kwargs)\u001b[0m\n\u001b[1;32m   2888\u001b[0m         \u001b[0mverts\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdeprecation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_deprecated_parameter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2889\u001b[0m         edgecolors=None, *, plotnonfinite=False, data=None, **kwargs):\n\u001b[0;32m-> 2890\u001b[0;31m     __ret = gca().scatter(\n\u001b[0m\u001b[1;32m   2891\u001b[0m         \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmarker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmarker\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2892\u001b[0m         \u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmax\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlinewidths\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlinewidths\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Downloads/anaconda3/lib/python3.8/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1436\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0minner\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1437\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1438\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msanitize_sequence\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1439\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1440\u001b[0m         \u001b[0mbound\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_sig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Downloads/anaconda3/lib/python3.8/site-packages/matplotlib/cbook/deprecation.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*inner_args, **inner_kwargs)\u001b[0m\n\u001b[1;32m    409\u001b[0m                          \u001b[0;32melse\u001b[0m \u001b[0mdeprecation_addendum\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    410\u001b[0m                 **kwargs)\n\u001b[0;32m--> 411\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0minner_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    412\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    413\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Downloads/anaconda3/lib/python3.8/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mscatter\u001b[0;34m(self, x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, verts, edgecolors, plotnonfinite, **kwargs)\u001b[0m\n\u001b[1;32m   4439\u001b[0m         \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mravel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   4440\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 4441\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"x and y must be the same size\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   4442\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   4443\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0ms\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: x and y must be the same size"
     ]
    },
    {
     "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": [
    "for i in list(df.columns):\n",
    "    plt.scatter(df[i].to_numpy(),uns.to_numpy().reshape(1,-1))\n",
    "    plt.xlabel(\"Значение\")\n",
    "    plt.ylabel(\"Класс\")\n",
    "    plt.title(column)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 2.4 (1 балл)\n",
    "\n",
    "Исходя из кривых значений критерия Джини, по какому признаку нужно производить деление выборки на два поддерева? Согласуется ли этот результат с визуальной оценкой scatter-графиков? Как бы охарактеризовали вид кривой для \"хороших\" признаков, по которым выборка делится почти идеально? Чем отличаются кривые для признаков, по которым деление практически невозможно?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Исходя из кривых значений критерия Джини, производить деление выборки на два поддерева следует по признаку PEG.  Данный результат согласуется с визуальной оценкой графика. Для хороших признаков кривая будет стремиться к параболическому виду. Следовательно почти невозможно деление по признакам, которые близки к одному уровню на протяжении всех значений"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 2.5 (1 балл)\n",
    "\n",
    "Протестируйте свое решающее дерево на датасете [mushrooms](https://archive.ics.uci.edu/ml/datasets/Mushroom). Вам нужно скачать таблицу agaricus-lepiota.data (из [Data Folder](https://archive.ics.uci.edu/ml/machine-learning-databases/mushroom/)), прочитать ее с помощью pandas, применить к каждому столбцу LabelEncoder (из sklearn), чтобы преобразовать строковые имена категорий в натуральные числа. Первый столбец — это целевая переменная (e — edible, p — poisonous) Мы будем измерять качество с помощью accuracy, так что нам не очень важно, что будет классом 1, а что — классом 0. Обучите решающее дерево на половине случайно выбранных объектов (признаки в датасете категориальные) и сделайте предсказания для оставшейся половины. Вычислите accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-129-2c24d8fb1794>:8: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  X[i] = LE.fit_transform(X[i])\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn import preprocessing\n",
    "df = pd.read_csv('agaricus-lepiota.data')\n",
    "X = df.iloc[:,1:]\n",
    "for i in X.columns:\n",
    "    LE = preprocessing.LabelEncoder()\n",
    "    X[i] = LE.fit_transform(X[i])\n",
    "y = df.iloc[:,0]\n",
    "LE = preprocessing.LabelEncoder()\n",
    "y = LE.fit_transform(y)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "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>x</th>\n",
       "      <th>s</th>\n",
       "      <th>n</th>\n",
       "      <th>t</th>\n",
       "      <th>p.1</th>\n",
       "      <th>f</th>\n",
       "      <th>c</th>\n",
       "      <th>n.1</th>\n",
       "      <th>k</th>\n",
       "      <th>e</th>\n",
       "      <th>...</th>\n",
       "      <th>s.2</th>\n",
       "      <th>w</th>\n",
       "      <th>w.1</th>\n",
       "      <th>p.2</th>\n",
       "      <th>w.2</th>\n",
       "      <th>o</th>\n",
       "      <th>p.3</th>\n",
       "      <th>k.1</th>\n",
       "      <th>s.3</th>\n",
       "      <th>u</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>853</th>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6227</th>\n",
       "      <td>5</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>...</td>\n",
       "      <td>1</td>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6454</th>\n",
       "      <td>5</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>...</td>\n",
       "      <td>1</td>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6629</th>\n",
       "      <td>5</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>...</td>\n",
       "      <td>2</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7181</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6017</th>\n",
       "      <td>5</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>...</td>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>709</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>9</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>3</td>\n",
       "      <td>7</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2487</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>1</td>\n",
       "      <td>...</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>174</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1146</th>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>...</td>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>4061 rows × 22 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      x  s  n  t  p.1  f  c  n.1   k  e  ...  s.2  w  w.1  p.2  w.2  o  p.3  \\\n",
       "853   4  0  4  0    5  1  0    1   5  0  ...    2  7    7    0    2  1    4   \n",
       "6227  5  3  2  0    7  1  0    1   0  1  ...    1  6    6    0    2  1    0   \n",
       "6454  5  2  4  0    2  1  0    1   0  1  ...    1  6    6    0    2  1    0   \n",
       "6629  5  2  4  0    7  1  0    1   0  1  ...    2  6    7    0    2  1    0   \n",
       "7181  2  2  4  0    5  0  0    0   5  0  ...    2  5    5    0    0  1    4   \n",
       "...  .. .. .. ..  ... .. ..  ...  .. ..  ...  ... ..  ...  ...  ... ..  ...   \n",
       "6017  5  3  2  0    7  1  0    1   0  1  ...    2  7    6    0    2  1    0   \n",
       "709   2  3  9  1    0  1  0    0  10  0  ...    3  7    7    0    2  1    4   \n",
       "2487  2  0  3  1    5  1  0    0   7  1  ...    2  3    6    0    2  1    4   \n",
       "174   0  3  8  1    3  1  0    0  10  0  ...    2  7    7    0    2  1    4   \n",
       "1146  5  0  3  0    5  1  1    0   5  1  ...    2  7    7    0    2  1    0   \n",
       "\n",
       "      k.1  s.3  u  \n",
       "853     2    4  5  \n",
       "6227    7    4  0  \n",
       "6454    7    4  4  \n",
       "6629    7    4  2  \n",
       "7181    3    1  2  \n",
       "...   ...  ... ..  \n",
       "6017    7    4  0  \n",
       "709     2    3  4  \n",
       "2487    3    4  0  \n",
       "174     2    2  3  \n",
       "1146    3    0  1  \n",
       "\n",
       "[4061 rows x 22 columns]"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(['categorical' for i in range(len(list(X.columns)))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "tree = DecisionTree(feature_types = ['categorical' for i in range(len(list(X.columns)))])\n",
    "tree.fit(X_train.values,y_train)\n",
    "y_test_pred = tree.predict(X_test.values)\n",
    "print(accuracy_score(y_test_pred,y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ЧЕТКО! ВНАТУРЕ ЧЕТКО!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 3: бэггинг, случайный лес"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В данной части будем работать [с задачей предсказания диабета у пациента](https://www.kaggle.com/uciml/pima-indians-diabetes-database/data). Посмотрим на работу бэггинга над решающими деревьями и случайного леса, сравним их работу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import BaggingClassifier, RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, roc_auc_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.tree import DecisionTreeClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset shape: (768, 9)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Pregnancies</th>\n",
       "      <th>Glucose</th>\n",
       "      <th>BloodPressure</th>\n",
       "      <th>SkinThickness</th>\n",
       "      <th>Insulin</th>\n",
       "      <th>BMI</th>\n",
       "      <th>DiabetesPedigreeFunction</th>\n",
       "      <th>Age</th>\n",
       "      <th>Outcome</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6</td>\n",
       "      <td>148</td>\n",
       "      <td>72</td>\n",
       "      <td>35</td>\n",
       "      <td>0</td>\n",
       "      <td>33.6</td>\n",
       "      <td>0.627</td>\n",
       "      <td>50</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>85</td>\n",
       "      <td>66</td>\n",
       "      <td>29</td>\n",
       "      <td>0</td>\n",
       "      <td>26.6</td>\n",
       "      <td>0.351</td>\n",
       "      <td>31</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8</td>\n",
       "      <td>183</td>\n",
       "      <td>64</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>23.3</td>\n",
       "      <td>0.672</td>\n",
       "      <td>32</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>89</td>\n",
       "      <td>66</td>\n",
       "      <td>23</td>\n",
       "      <td>94</td>\n",
       "      <td>28.1</td>\n",
       "      <td>0.167</td>\n",
       "      <td>21</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>137</td>\n",
       "      <td>40</td>\n",
       "      <td>35</td>\n",
       "      <td>168</td>\n",
       "      <td>43.1</td>\n",
       "      <td>2.288</td>\n",
       "      <td>33</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>5</td>\n",
       "      <td>116</td>\n",
       "      <td>74</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>25.6</td>\n",
       "      <td>0.201</td>\n",
       "      <td>30</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>3</td>\n",
       "      <td>78</td>\n",
       "      <td>50</td>\n",
       "      <td>32</td>\n",
       "      <td>88</td>\n",
       "      <td>31.0</td>\n",
       "      <td>0.248</td>\n",
       "      <td>26</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>10</td>\n",
       "      <td>115</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>35.3</td>\n",
       "      <td>0.134</td>\n",
       "      <td>29</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>2</td>\n",
       "      <td>197</td>\n",
       "      <td>70</td>\n",
       "      <td>45</td>\n",
       "      <td>543</td>\n",
       "      <td>30.5</td>\n",
       "      <td>0.158</td>\n",
       "      <td>53</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>8</td>\n",
       "      <td>125</td>\n",
       "      <td>96</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.232</td>\n",
       "      <td>54</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Pregnancies  Glucose  BloodPressure  SkinThickness  Insulin   BMI  \\\n",
       "0            6      148             72             35        0  33.6   \n",
       "1            1       85             66             29        0  26.6   \n",
       "2            8      183             64              0        0  23.3   \n",
       "3            1       89             66             23       94  28.1   \n",
       "4            0      137             40             35      168  43.1   \n",
       "5            5      116             74              0        0  25.6   \n",
       "6            3       78             50             32       88  31.0   \n",
       "7           10      115              0              0        0  35.3   \n",
       "8            2      197             70             45      543  30.5   \n",
       "9            8      125             96              0        0   0.0   \n",
       "\n",
       "   DiabetesPedigreeFunction  Age  Outcome  \n",
       "0                     0.627   50        1  \n",
       "1                     0.351   31        0  \n",
       "2                     0.672   32        1  \n",
       "3                     0.167   21        0  \n",
       "4                     2.288   33        1  \n",
       "5                     0.201   30        0  \n",
       "6                     0.248   26        1  \n",
       "7                     0.134   29        0  \n",
       "8                     0.158   53        1  \n",
       "9                     0.232   54        1  "
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.read_csv('diabetes.csv')\n",
    "print(f\"Dataset shape: {data.shape}\")\n",
    "data.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим на распределение целевой переменной"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQk0lEQVR4nO3df6zd9V3H8edr7cYmnVBku2kKs9VUXRkyxxWJU3MrRjpcLCYj6cStW0gaI5qZzGRlf7gY08j+wBhBMpuxUAPupmGbrZvMNJ1XNBtjVBmlMKQO7DpIm/FrXiSYsrd/3C/mrr2Xe3rvOedyP/f5SJrz/X6+n+/5vN9t87pfvj3nS6oKSVJbXrfYBUiS+s9wl6QGGe6S1CDDXZIaZLhLUoNWLnYBAOeff36tW7du3ue/8MILnH322f0r6DVuufUL9rxc2POZOXjw4Peq6i0zHXtNhPu6deu4//77533+xMQEY2Nj/SvoNW659Qv2vFzY85lJ8l+zHfO2jCQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWpQT+Ge5Ikkh5I8kOT+buy8JPuTPNa9rp42/4YkR5I8muTKQRUvSZrZmVy5b6qqd1bVaLe/AzhQVRuAA90+STYCW4GLgM3ArUlW9LFmSdIcFnJbZguwu9veDVw9bXy8ql6qqseBI8BlC1hHknSG0sv/rCPJ48CzQAF/XVW7kjxXVedOm/NsVa1Ocgtwb1Xd0Y3fBtxdVXed8p7bge0AIyMjl46Pj8+7iRPPPM/xF+d9+rxdvPac4S8KTE5OsmrVqkVZe7HY8/Jgz2dm06ZNB6fdTfkhvT5+4N1V9WSStwL7k3zrVeZmhrHTfoJU1S5gF8Do6Ggt5CvHN9+5l5sODf9JCk9cOzb0NcGvaC8X9rw8DKrnnm7LVNWT3esJ4AtM3WY5nmQNQPd6opt+DLhw2ukXAE/2q2BJ0tzmDPckZyd58yvbwK8DDwH7gG3dtG3A3m57H7A1yVlJ1gMbgPv6XbgkaXa93MsYAb6Q5JX5f1tVX07yDWBPkuuAo8A1AFV1OMke4GHgJHB9Vb08kOolSTOaM9yr6tvAJTOMPw1cMcs5O4GdC65OkjQvfkNVkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1KCewz3JiiT/nuSL3f55SfYneax7XT1t7g1JjiR5NMmVgyhckjS7M7ly/wjwyLT9HcCBqtoAHOj2SbIR2ApcBGwGbk2yoj/lSpJ60VO4J7kA+A3g09OGtwC7u+3dwNXTxser6qWqehw4AlzWl2olST1JVc09KbkL+DPgzcAfVdV7kzxXVedOm/NsVa1Ocgtwb1Xd0Y3fBtxdVXed8p7bge0AIyMjl46Pj8+7iRPPPM/xF+d9+rxdvPac4S8KTE5OsmrVqkVZe7HY8/Jgz2dm06ZNB6tqdKZjK+c6Ocl7gRNVdTDJWA/rZYax036CVNUuYBfA6OhojY318tYzu/nOvdx0aM5W+u6Ja8eGvibAxMQEC/n9WorseXmw5/7pJRHfDfxmkquANwI/muQO4HiSNVX1VJI1wIlu/jHgwmnnXwA82c+iJUmvbs577lV1Q1VdUFXrmPqH0q9U1e8A+4Bt3bRtwN5uex+wNclZSdYDG4D7+l65JGlWC7mXcSOwJ8l1wFHgGoCqOpxkD/AwcBK4vqpeXnClkqSenVG4V9UEMNFtPw1cMcu8ncDOBdYmSZonv6EqSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJatCc4Z7kjUnuS/LNJIeT/Ek3fl6S/Uke615XTzvnhiRHkjya5MpBNiBJOl0vV+4vAb9aVZcA7wQ2J7kc2AEcqKoNwIFunyQbga3ARcBm4NYkKwZQuyRpFnOGe02Z7HZf3/0qYAuwuxvfDVzdbW8Bxqvqpap6HDgCXNbPoiVJr66ne+5JViR5ADgB7K+qrwMjVfUUQPf61m76WuA7004/1o1JkoZkZS+Tqupl4J1JzgW+kOQdrzI9M73FaZOS7cB2gJGRESYmJnopZUYjb4KPXnxy3ufP10JqXojJyclFW3ux2PPyYM/901O4v6KqnksywdS99ONJ1lTVU0nWMHVVD1NX6hdOO+0C4MkZ3msXsAtgdHS0xsbGzrz6zs137uWmQ2fUSl88ce3Y0NeEqR8qC/n9WorseXmw5/7p5dMyb+mu2EnyJuDXgG8B+4Bt3bRtwN5uex+wNclZSdYDG4D7+ly3JOlV9HK5uwbY3X3i5XXAnqr6YpKvAXuSXAccBa4BqKrDSfYADwMngeu72zqSpCGZM9yr6kHg52YYfxq4YpZzdgI7F1ydJGle/IaqJDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUHDfyCLJL3GrNvxpUVb+/bNZw/kfb1yl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNWjOcE9yYZJ/SvJIksNJPtKNn5dkf5LHutfV0865IcmRJI8muXKQDUiSTtfLlftJ4KNV9XbgcuD6JBuBHcCBqtoAHOj26Y5tBS4CNgO3JlkxiOIlSTObM9yr6qmq+rdu+7+BR4C1wBZgdzdtN3B1t70FGK+ql6rqceAIcFmf65YkvYpUVe+Tk3XAPcA7gKNVde60Y89W1eoktwD3VtUd3fhtwN1Vddcp77Ud2A4wMjJy6fj4+LybOPHM8xx/cd6nz9vFa88Z/qLA5OQkq1atWpS1F4s9Lw+L1fOh7z4/9DVfsf6cFfPuedOmTQeranSmYyt7fZMkq4DPAX9YVd9PMuvUGcZO+wlSVbuAXQCjo6M1NjbWaymnufnOvdx0qOdW+uaJa8eGvibAxMQEC/n9WorseXlYrJ4/tONLQ1/zFbdvPnsgPff0aZkkr2cq2O+sqs93w8eTrOmOrwFOdOPHgAunnX4B8GR/ypUk9aKXT8sEuA14pKr+fNqhfcC2bnsbsHfa+NYkZyVZD2wA7utfyZKkufRyL+PdwAeAQ0ke6MY+DtwI7ElyHXAUuAagqg4n2QM8zNQnba6vqpf7XbgkaXZzhntV/Ssz30cHuGKWc3YCOxdQlyRpAfyGqiQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBc4Z7ks8kOZHkoWlj5yXZn+Sx7nX1tGM3JDmS5NEkVw6qcEnS7Hq5cr8d2HzK2A7gQFVtAA50+yTZCGwFLurOuTXJir5VK0nqyZzhXlX3AM+cMrwF2N1t7waunjY+XlUvVdXjwBHgsv6UKknqVapq7knJOuCLVfWObv+5qjp32vFnq2p1kluAe6vqjm78NuDuqrprhvfcDmwHGBkZuXR8fHzeTZx45nmOvzjv0+ft4rXnDH9RYHJyklWrVi3K2ovFnpeHxer50HefH/qar1h/zop597xp06aDVTU607GVC6rqdJlhbMafHlW1C9gFMDo6WmNjY/Ne9OY793LToX63Mrcnrh0b+poAExMTLOT3aymy5+VhsXr+0I4vDX3NV9y++eyB9DzfT8scT7IGoHs90Y0fAy6cNu8C4Mn5lydJmo/5hvs+YFu3vQ3YO218a5KzkqwHNgD3LaxESdKZmvNeRpLPAmPA+UmOAZ8AbgT2JLkOOApcA1BVh5PsAR4GTgLXV9XLA6pdkjSLOcO9qt4/y6ErZpm/E9i5kKIkSQvjN1QlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBAwv3JJuTPJrkSJIdg1pHknS6gYR7khXAXwHvATYC70+ycRBrSZJON6gr98uAI1X17ar6X2Ac2DKgtSRJp1g5oPddC3xn2v4x4BemT0iyHdje7U4meXQB650PfG8B589LPjnsFf/fovS7yOx5eVh2PW/65IJ6/vHZDgwq3DPDWP3QTtUuYFdfFkvur6rRfrzXUrDc+gV7Xi7suX8GdVvmGHDhtP0LgCcHtJYk6RSDCvdvABuSrE/yBmArsG9Aa0mSTjGQ2zJVdTLJ7wP/CKwAPlNVhwexVqcvt3eWkOXWL9jzcmHPfZKqmnuWJGlJ8RuqktQgw12SGrRkwn2uxxlkyl92xx9M8q7FqLOfeuj52q7XB5N8Nckli1FnP/X62IokP5/k5STvG2Z9g9BLz0nGkjyQ5HCSfx52jf3Ww9/tc5L8fZJvdj1/eDHq7Jckn0lyIslDsxzvf35V1Wv+F1P/KPufwE8AbwC+CWw8Zc5VwN1Mfcb+cuDri133EHr+RWB1t/2e5dDztHlfAf4BeN9i1z2EP+dzgYeBt3X7b13suofQ88eBT3bbbwGeAd6w2LUvoOdfAd4FPDTL8b7n11K5cu/lcQZbgL+pKfcC5yZZM+xC+2jOnqvqq1X1bLd7L1PfJ1jKen1sxR8AnwNODLO4Aeml598GPl9VRwGqaqn33UvPBbw5SYBVTIX7yeGW2T9VdQ9TPcym7/m1VMJ9pscZrJ3HnKXkTPu5jqmf/EvZnD0nWQv8FvCpIdY1SL38Of8UsDrJRJKDST44tOoGo5eebwHeztSXHw8BH6mqHwynvEXR9/wa1OMH+m3Oxxn0OGcp6bmfJJuYCvdfGmhFg9dLz38BfKyqXp66qFvyeul5JXApcAXwJuBrSe6tqv8YdHED0kvPVwIPAL8K/CSwP8m/VNX3B1zbYul7fi2VcO/lcQatPfKgp36S/CzwaeA9VfX0kGoblF56HgXGu2A/H7gqycmq+ruhVNh/vf7d/l5VvQC8kOQe4BJgqYZ7Lz1/GLixpm5IH0nyOPAzwH3DKXHo+p5fS+W2TC+PM9gHfLD7V+fLgeer6qlhF9pHc/ac5G3A54EPLOGruOnm7Lmq1lfVuqpaB9wF/N4SDnbo7e/2XuCXk6xM8iNMPWH1kSHX2U+99HyUqf9SIckI8NPAt4da5XD1Pb+WxJV7zfI4gyS/2x3/FFOfnLgKOAL8D1M/+ZesHnv+Y+DHgFu7K9mTtYSfqNdjz03ppeeqeiTJl4EHgR8An66qGT9StxT0+Of8p8DtSQ4xdcviY1W1ZB8FnOSzwBhwfpJjwCeA18Pg8svHD0hSg5bKbRlJ0hkw3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KD/g/dqvHa9wuV2QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data['Outcome'].hist()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Разделите данные на признаки и целевую переменную. Разбейте датасет на тренировочную и тестовую части в отношении 70:30."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "Y = data['Outcome']\n",
    "X = data.drop('Outcome', axis=1)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.3, random_state=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "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>Pregnancies</th>\n",
       "      <th>Glucose</th>\n",
       "      <th>BloodPressure</th>\n",
       "      <th>SkinThickness</th>\n",
       "      <th>Insulin</th>\n",
       "      <th>BMI</th>\n",
       "      <th>DiabetesPedigreeFunction</th>\n",
       "      <th>Age</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>262</th>\n",
       "      <td>4</td>\n",
       "      <td>95</td>\n",
       "      <td>70</td>\n",
       "      <td>32</td>\n",
       "      <td>0</td>\n",
       "      <td>32.1</td>\n",
       "      <td>0.612</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>619</th>\n",
       "      <td>0</td>\n",
       "      <td>119</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>32.4</td>\n",
       "      <td>0.141</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>275</th>\n",
       "      <td>2</td>\n",
       "      <td>100</td>\n",
       "      <td>70</td>\n",
       "      <td>52</td>\n",
       "      <td>57</td>\n",
       "      <td>40.5</td>\n",
       "      <td>0.677</td>\n",
       "      <td>25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>338</th>\n",
       "      <td>9</td>\n",
       "      <td>152</td>\n",
       "      <td>78</td>\n",
       "      <td>34</td>\n",
       "      <td>171</td>\n",
       "      <td>34.2</td>\n",
       "      <td>0.893</td>\n",
       "      <td>33</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>177</th>\n",
       "      <td>0</td>\n",
       "      <td>129</td>\n",
       "      <td>110</td>\n",
       "      <td>46</td>\n",
       "      <td>130</td>\n",
       "      <td>67.1</td>\n",
       "      <td>0.319</td>\n",
       "      <td>26</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Pregnancies  Glucose  BloodPressure  SkinThickness  Insulin   BMI  \\\n",
       "262            4       95             70             32        0  32.1   \n",
       "619            0      119              0              0        0  32.4   \n",
       "275            2      100             70             52       57  40.5   \n",
       "338            9      152             78             34      171  34.2   \n",
       "177            0      129            110             46      130  67.1   \n",
       "\n",
       "     DiabetesPedigreeFunction  Age  \n",
       "262                     0.612   24  \n",
       "619                     0.141   24  \n",
       "275                     0.677   25  \n",
       "338                     0.893   33  \n",
       "177                     0.319   26  "
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 3.1 (1 балл)\n",
    "\n",
    "Обучите [`BaggingClassifier`](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.BaggingClassifier.html) на 50 деревьях. Оцените качество классификации на тестовой выборке по метрикам `accuracy`, `precision` и `recall`, `auc_roc`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy score for test is: 0.7532467532467533\n",
      "Precision score for test is: 0.6708860759493671\n",
      "Recall score for test is: 0.6309523809523809\n",
      "AUC-ROC score for test is: 0.7270408163265306\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import recall_score\n",
    "from sklearn.metrics import roc_auc_score\n",
    "classifier = BaggingClassifier(n_estimators=50)\n",
    "classifier.fit(X_train, y_train)\n",
    "x_test_pred = classifier.predict(X_test)\n",
    "print('Accuracy score for test is:', accuracy_score(x_test_pred, y_test))\n",
    "print('Precision score for test is:', precision_score(x_test_pred, y_test))\n",
    "print('Recall score for test is:', recall_score(x_test_pred, y_test))\n",
    "print('AUC-ROC score for test is:', roc_auc_score(x_test_pred, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 3.2 (1 балл)\n",
    "\n",
    "Теперь обучите Random Forest с таким же количеством деревьев. Оцените качество классификации по тем же метрикам. Какая из двух построенных моделей показала себя лучше?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy score for test is: 0.7792207792207793\n",
      "Precision score for test is: 0.7088607594936709\n",
      "Recall score for test is: 0.6666666666666666\n",
      "AUC-ROC score for test is: 0.7551020408163265\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "forest_classifier = RandomForestClassifier(n_estimators=50)\n",
    "forest_classifier.fit(X_train, y_train)\n",
    "x_test_pred = forest_classifier.predict(X_test)\n",
    "print('Accuracy score for test is:', accuracy_score(x_test_pred, y_test))\n",
    "print('Precision score for test is:', precision_score(x_test_pred, y_test))\n",
    "print('Recall score for test is:', recall_score(x_test_pred, y_test))\n",
    "print('AUC-ROC score for test is:', roc_auc_score(x_test_pred, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ОБЕ МОДЕЛИ ПОКАЗАЛИ ПРИМЕРНО ОДИНАКОВЫЕ РЕЗУЛЬТАТЫ БЕЗ КРИТИЧЕСКИХ ОТКЛОНЕНИЙ (но это дело житейское :3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 3.3 (1 балл)\n",
    "\n",
    "Для случайного леса проанализируйте значение AUC-ROC на этих же данных в зависимости от изменения параметров (можете сделать обычный перебор с обучением/тестированием в цикле):\n",
    "* `'n_estimators'` (можно перебрать около 10 значений из отрезка от 10 до 1500)\n",
    "* `'min_samples_leaf'` (сетку значений можете выбрать на ваше усмотрение)\n",
    "\n",
    "Постройте соответствующие графики зависимости AUC-ROC от этих параметров. Используйте heat map для визуализации. Какие выводы вы можете сделать?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "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>n_estimators</th>\n",
       "      <th>min_samples_leaf</th>\n",
       "      <th>AUC-ROC</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>20</td>\n",
       "      <td>1</td>\n",
       "      <td>0.766116</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>20</td>\n",
       "      <td>2</td>\n",
       "      <td>0.764282</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>20</td>\n",
       "      <td>3</td>\n",
       "      <td>0.736395</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>20</td>\n",
       "      <td>4</td>\n",
       "      <td>0.722037</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>20</td>\n",
       "      <td>5</td>\n",
       "      <td>0.725742</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  n_estimators min_samples_leaf   AUC-ROC\n",
       "0           20                1  0.766116\n",
       "0           20                2  0.764282\n",
       "0           20                3  0.736395\n",
       "0           20                4  0.722037\n",
       "0           20                5  0.725742"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "df = pd.DataFrame(columns = ['n_estimators', 'min_samples_leaf', 'AUC-ROC'])\n",
    "n_estimators = [20,50,100,300,500,700,800,1000,1200,1500]\n",
    "min_samples_leaf = [1, 2, 3, 4, 5]\n",
    "for i in n_estimators:\n",
    "    for j in min_samples_leaf:\n",
    "        forest_classifier = RandomForestClassifier(n_estimators=i, min_samples_leaf=j)\n",
    "        forest_classifier.fit(X_train, y_train)\n",
    "        x_test_pred = forest_classifier.predict(X_test)\n",
    "        l = pd.DataFrame([[i, j, roc_auc_score(x_test_pred, y_test)]],columns = ['n_estimators', 'min_samples_leaf', 'AUC-ROC'] )\n",
    "        df = df.append(l)\n",
    "df.head(5)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='min_samples_leaf', ylabel='n_estimators'>"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = df.pivot('n_estimators', 'min_samples_leaf', 'AUC-ROC')\n",
    "sns.heatmap(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Лучший набор параметров: n_estimators=100, min_samples_leaf=3\n"
     ]
    }
   ],
   "source": [
    "print('Лучший набор параметров: n_estimators=100, min_samples_leaf=3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 3.4 (1 балл)\n",
    "\n",
    "Для лучшей модели случайного леса посчитайте важность признаков и постройте bar plot. Какой признак оказался самым важным для определения диабета?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "forest_classifier = RandomForestClassifier(n_estimators=100, min_samples_leaf=3)\n",
    "forest_classifier.fit(X_train, y_train)\n",
    "importance = forest_classifier.feature_importances_\n",
    "col = list(X_train.columns)\n",
    "data = pd.DataFrame(importance, columns=['importance'])\n",
    "data['col'] = col\n",
    "fig = plt.figure(figsize=(14,8))\n",
    "fig = sns.barplot(data=data, x='col', y='importance')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cамый важный признак  это уровень глюкозы"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}