Part_04_classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "begIKlTyB2sV"
   },
   "source": [
    "# Задачи классификации\n",
    "\n",
    "Задача классифификации (classification) - метод обучения с учителем (supervised)\n",
    "\n",
    "Классификация - задача для алгоритмов машинного обучения восстановить на объектах обучающей выборки **метки классов**. Классы - конечный (дискретный) набор целевых переменных. Например, в задаче фильтрации спама два класса: спам (метка $1$) и не спам (метка $0$)\n",
    "\n",
    "Классификация бывает бинарная (когда классов всего два: $0$ и $1$) и мультиклассовая, когда классов несколько. Если научились классифицировать на два класса, то и на несколько получиться: метод One vs All."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ByIHKBSaD6RM"
   },
   "source": [
    "Подключаемся к гугл драйв"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T06:52:54.184979Z",
     "start_time": "2023-06-18T06:52:53.136232Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KnDYDutsBwXS",
    "outputId": "4db22e14-1082-44a0-e759-5cb7b128f4c4"
   },
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'google.colab'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "Input \u001b[0;32mIn [1]\u001b[0m, in \u001b[0;36m<cell line: 6>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mshutil\u001b[39;00m \n\u001b[1;32m      5\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgoogle\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcolab\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m drive\n\u001b[1;32m      8\u001b[0m RANDOM_SEED \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m42\u001b[39m\n\u001b[1;32m      9\u001b[0m np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mseed(RANDOM_SEED)  \u001b[38;5;66;03m# гарантируем воспроизводимость\u001b[39;00m\n",
      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'google.colab'"
     ]
    }
   ],
   "source": [
    "import logging\n",
    "import os\n",
    "import shutil \n",
    "\n",
    "import numpy as np\n",
    "# from google.colab import drive\n",
    "\n",
    "RANDOM_SEED = 42\n",
    "np.random.seed(RANDOM_SEED)  # гарантируем воспроизводимость\n",
    "\n",
    "logging.getLogger().setLevel(logging.INFO)\n",
    "logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)\n",
    "logger = logging.getLogger(__name__)\n",
    "logger.info('Инициализировали логгер')\n",
    "\n",
    "ROOT_DIR = '/content/drive' \n",
    "drive.mount(ROOT_DIR)\n",
    "logger.info('Подключили диск')\n",
    "\n",
    "root_data_dir = os.path.join(ROOT_DIR, 'MyDrive', 'ml-compling-2022-hse', 'data')\n",
    "if not os.path.exists(root_data_dir):\n",
    "  raise RuntimeError('Отсутствует директория с данными')\n",
    "else:\n",
    "  logger.info('Содержимое директории %s: %s', root_data_dir, os.listdir(root_data_dir))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ls5L2Xb-EG7P"
   },
   "source": [
    "Загружаем данные - у нас будет новый датасет с задачей классификации"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T07:22:17.542036Z",
     "start_time": "2023-06-18T07:22:16.256146Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 206
    },
    "id": "rkNpxXLwB23h",
    "outputId": "e83ec8f1-9d88-47f0-9e43-c782804fc9cc"
   },
   "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>call_diff</th>\n",
       "      <th>sms_diff</th>\n",
       "      <th>traffic_diff</th>\n",
       "      <th>customes_class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-0.666421</td>\n",
       "      <td>0.444911</td>\n",
       "      <td>-0.273538</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.889273</td>\n",
       "      <td>-0.537896</td>\n",
       "      <td>-1.959469</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.841503</td>\n",
       "      <td>0.846665</td>\n",
       "      <td>0.727606</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.389749</td>\n",
       "      <td>0.390911</td>\n",
       "      <td>1.789246</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-1.228211</td>\n",
       "      <td>-1.375899</td>\n",
       "      <td>-1.434209</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   call_diff  sms_diff  traffic_diff  customes_class\n",
       "0  -0.666421  0.444911     -0.273538               0\n",
       "1  -0.889273 -0.537896     -1.959469               2\n",
       "2  -0.841503  0.846665      0.727606               0\n",
       "3   1.389749  0.390911      1.789246               1\n",
       "4  -1.228211 -1.375899     -1.434209               2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "raw_data_file = '/Users/alexandradolidze/Downloads/client_segmentation.csv'\n",
    "\n",
    "# задаём типизацию колонок чтобы память экономить\n",
    "df_source = pd.read_csv(\n",
    "    raw_data_file, sep=',',\n",
    "    dtype={\n",
    "        'call_diff': np.float32,\n",
    "        'call_diff': np.float32,\n",
    "        'traffic_diff': np.float32,\n",
    "        'customes_class': np.uint16\n",
    "    }\n",
    ")\n",
    "\n",
    "df_source.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8yHuOacoGh32"
   },
   "source": [
    "В файле `client_segmentation.csv` содержатся данные по оттоку: информация по клиентам оператора связи о том, как изменилось потребление услуг оператора за два месяца:\n",
    "* call_diff доля звонков\n",
    "* sms_diff доля смс\n",
    "* доля интернет-трафика traffic_diff\n",
    "\n",
    "Значение отрицательное - показатель снизился. Значение превосходит по модулю единицу - потребление кратно выросло. \n",
    "\n",
    "Все показатели вычисляются по формуле\n",
    "\n",
    "$$\n",
    "\\frac{\\text{new_value}-\\text{old_value}}{\\text{old_value}}\n",
    "$$\n",
    "\n",
    "Посмотрим на распределение какой-нибудь фичи, например `sms_diff`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T07:22:22.521857Z",
     "start_time": "2023-06-18T07:22:21.268559Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 283
    },
    "id": "-fv4JPUEMQvM",
    "outputId": "10a7e931-04ca-4153-eba3-7952608e63bd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot: >"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_source.sms_diff.hist(bins=8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bRVSDIg-MI0A"
   },
   "source": [
    "В последней колонке `customes_class` содержится метка по оттоку:\n",
    "* $0$ - активный пользователь\n",
    "* $1$ - \"спящий\" пользователь (редко пользуется услугами)\n",
    "* $2$ - пользователь, который ушел в отток\n",
    "\n",
    "Это наша целевая переменная, хотим её предсказывать"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T07:25:23.270818Z",
     "start_time": "2023-06-18T07:25:23.247316Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "0s9CvHRQFTRt",
    "outputId": "35f35e54-2607-4520-a963-6e9ba4e14b6b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num train samples 100\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0    0.34\n",
       "2    0.33\n",
       "1    0.33\n",
       "Name: customes_class, dtype: float64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('num train samples', df_source.shape[0])\n",
    "df_source.customes_class.value_counts(normalize=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WfH-kDYzOxOg"
   },
   "source": [
    "Видим, что у нас примерно одинакоково представлены все классы. Ситуация, когда один класс представлен слишком сильно и ли наоборот слишком слабо в выборке называется \"дисбаланс классов\". \n",
    "\n",
    "Есть два основных приёма решения проблемы дисбаланса\n",
    "* undersampling доминирующего класса\n",
    "* oversampling класса с меньшим числом элементов"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TBjQdIrE-eCP"
   },
   "source": [
    "Важный момент: дальше мы будем решать задачу классификации на 2 класса\n",
    "\n",
    "Для этого искусственно разделим класс `2` между классами `0` и `1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T07:25:29.474837Z",
     "start_time": "2023-06-18T07:25:29.400476Z"
    },
    "id": "OYG0dhnb-ePE"
   },
   "outputs": [],
   "source": [
    "df_source[(df_source.customes_class==2) & (df_source.call_diff>1.1)] = 0\n",
    "df_source[(df_source.customes_class==2) & (df_source.call_diff<=1.1)] = 1\n",
    "\n",
    "X = df_source[['call_diff','sms_diff','traffic_diff']].values\n",
    "y = df_source.customes_class.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "24t9UyIHWYq0"
   },
   "source": [
    "# Naive Bayes\n",
    "\n",
    "Попробуем для решения задачи использовать классификатор \"из коробки\": воспользуемся  [наивным Байесовским классификатором](https://scikit-learn.org/stable/modules/naive_bayes.html). Кстати, реализация содержит функцию `.partial_fit()` с которой мы уже встречались! Вспомните где именно.\n",
    "\n",
    "Этот классификатор основан на частотах встречаемости фичей. У нас фичи непрерывные, так что вместо частот будем использовать вероятности.\n",
    "\n",
    "Классификатор очень быстро обучается, т.к. по сути нам нужно просто посчитать разные статистики по выборке - никакого градиентного спуска тут нет."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sdTe9oROb29N"
   },
   "source": [
    "Пусть $c$ - класс объекта (у нас три класса) тогда мы берём объект и предсказываем вероятности по формуле Байеса для всех трёх классов, а класс объекту присваиваем тот, у которого максимальная вероятность - это называется Maximum a posteriori (MAP) estimation, метод максимальной апостериорной вероятност (потому что формула Байеса для вычисляет апостериорную вероятност гипотезы) \n",
    "\n",
    "$$\n",
    "c_{MAP} = \\arg \\max_{\\substack{c \\in C}}P(c \\mid X) = \\arg \\max_{\\substack{c \\in C}}\\frac{P(c)P(X\\mid c)}{P(X)}\n",
    "$$\n",
    "\n",
    "В формуле\n",
    "* P(c) - вероятность класса, его встречаемость\n",
    "* P(X|c) - вероятность встретить объект с конкретными фичами в конкретном классе, то есть насколько объект объект ожидаем встретить в классе $c$\n",
    "* P(X) - распределение данных. Т.к. мы ищем максимум по всем $c$, а знаменатель от C не зависит, то его вообще можно не учитывать\n",
    "\n",
    "Для начала вычислим априорные вероятности классов $P(c)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T07:25:32.307418Z",
     "start_time": "2023-06-18T07:25:32.289698Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "A93ouFqxkqiI",
    "outputId": "89dd2208-507f-4fd1-adbe-d0a128054384"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({1: 66, 0: 34})\n",
      "{0: 0.34, 1: 0.66}\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "num_samples = df_source.shape[0]  # число объектов\n",
    "prior_class_counts = Counter(y)  # группируем по классу и считаем колияество объектов каждого класса\n",
    "prior_class_probs = dict() # тут будем хранить  априорные вероятности классов\n",
    "print(prior_class_counts)\n",
    "\n",
    "for class_label in prior_class_counts:\n",
    "  prior_class_probs[class_label] = prior_class_counts[class_label] / num_samples\n",
    "print(prior_class_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TF79r5QQmB6u"
   },
   "source": [
    "Как посчитать $P(X\\mid c)$? Каждый объект $x \\in X$ состоит из фичей, это вектор $x = [x_1, \\ldots, n_n ]$, в нашем случае это из три элементов (у нас три фичи). Классификатор называется *наивным*, потому что мы делаем предположение о независимости фичей - в этом случае совместное распределение можно расписать через произведение маргинальных распределений\n",
    "\n",
    "$$\n",
    "P(X\\mid c) = P(x_1\\ldots x_n\\mid c) = P(x_1 \\mid c)\\cdot \\ldots \\cdot P(x_n\\mid c) = \\prod_{i=1}^nP(x_i\\mid c)\n",
    "$$\n",
    "\n",
    "Небольшое преобразование: т.к. ищем максимум то можем применить логарифм чтобы перейти от произведения к сумме (т.к. логарифм фозрастающая функция и на точку максимума не вилияет\n",
    "\n",
    "$$\n",
    "\\ln P(X\\mid c) = \\ln\\prod_{i=1}^nP(x_i\\mid c) = \\sum_{i=1}^n\\log P(x_i\\mid c)\n",
    "$$\n",
    "\n",
    "Как для конкретной фичи $x_i$ найти $P(x_i\\mid c)$? Для непрерывной фичи придётся ввести предположение о том, что фича имеет гауссовское распределение, то есть \n",
    "\n",
    "$$\n",
    "P(x_i\\mid c) = \\frac{1}{\\sqrt{2\\pi \\sigma^2_{x|c}}}\\exp\\left(-\\frac{(x - \\mu_{x|c})^2}{2\\sigma^2_{x|c}}\\right)\n",
    "$$\n",
    "\n",
    "Где $\\sigma_{x|c}$ - СКО фичи $x$ для класса $c$, $\\mu_{x|c}$ - МО фичи $x$ для класса $c$. Это параметры гауссовского распределения - их мы оценим по выборке.\n",
    "\n",
    "Алгоритм оценки параметров следующий:\n",
    "* берём класс $c$\n",
    "* оставляем в датасете только примеры этого класса $c$\n",
    "* вычисляем $\\sigma_{x|c}$ и $\\mu_{x|c}$\n",
    "\n",
    "В результате получим словарь, где ключ - имя фичи, а значение - вложенный словарь, где ключ - метка класса, а значение - параметры гауссовского распределения фичи этом классе, то есть получаем структуру вида \n",
    "```python\n",
    "{\n",
    "  class_1: {mu: some_value, sigma: some_value},\n",
    "  class_2: {mu: some_value, sigma: some_value},\n",
    "  class_3: {mu: some_value, sigma: some_value}\n",
    "}\n",
    "```\n",
    "\n",
    "Работать будем с `pandas.DataFrame` чтобы упростить фильтрацию и подсчёт статистик"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T07:25:38.031409Z",
     "start_time": "2023-06-18T07:25:38.009851Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "A-ppCrOZDeix",
    "outputId": "21b09004-8390-47db-a4df-4ff1787ab7d7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "call_diff\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{0: {'mu': -1.0015249, 'sigma': 0.74156827},\n",
       " 1: {'mu': 1.1297727, 'sigma': 0.44200704}}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "target_col = 'customes_class'\n",
    "feature_names = ['call_diff','sms_diff','traffic_diff']\n",
    "\n",
    "feature_proba_param = defaultdict(dict)\n",
    "for col in feature_names:  # цикл по фичам\n",
    "  for class_id in prior_class_probs:  # цикл по классам\n",
    "    feature_values = df_source[df_source[target_col]==class_id][col]  # отфильтруем фичу по классу\n",
    "    feature_proba_param[col][class_id] = {\n",
    "        'mu': feature_values.mean(), \n",
    "        'sigma': feature_values.std()\n",
    "    }\n",
    "# посмотрим распределение статистике по конкретной фиче\n",
    "feature_example = 'call_diff'\n",
    "print(feature_example)\n",
    "feature_proba_param[feature_example]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_Olp_nmJWc4w"
   },
   "source": [
    "По сути мы нашли  параметры распределения - можем посчитать вероятности классов\n",
    "\n",
    "Теперь можем построить алгоритм предсказания с помощью MAP\n",
    "* для объекта $x$ считаем $P(c_1 | X), P(c_2 | X), P(c_3 | X)$\n",
    "* выбираем максимальную вероятность - это и будет наше предсказание\n",
    "\n",
    "время познакомится с библиотекой [scipy](https://docs.scipy.org/) - оттуда возьмём реализацию $P(X | c)$ для [распределения гаусса](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.norm.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T07:26:55.731141Z",
     "start_time": "2023-06-18T07:26:55.564910Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "zkIb6pW5cdWe",
    "outputId": "d73b2b33-309d-44d2-d5f4-d5568969c22a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Предсказания построены, accuracy = 0.96\n"
     ]
    }
   ],
   "source": [
    "from scipy.stats import norm\n",
    "\n",
    "\n",
    "def eval_bayes(row):\n",
    "  log_classes_probas = defaultdict(float)  # т.к. нужно собирать сумму из разных фичей\n",
    "  for feature in feature_names:\n",
    "    feature_params = feature_proba_param[feature]  # извлекаем параметры распределения фичи (там три класса)\n",
    "    for class_id in feature_params:  # считаем априорную вероятность получить такое значение фичи в каждом классе\n",
    "      feature_class_params = feature_params[class_id]  # достаём параметры распределения (mu, sigma), которые посчитали на предыдущем шаге\n",
    "      feature_class_proba = norm.pdf(\n",
    "          row[feature],\n",
    "          loc=feature_class_params['mu'], scale=feature_class_params['sigma']\n",
    "      )\n",
    "      # вероятность в интервале [0, 1] - там отрицательные значения логарифма\n",
    "      log_classes_probas[class_id] += np.log(feature_class_proba)\n",
    "  sorted_log_classes_probas = sorted(log_classes_probas.items(), key = lambda x: x[1], reverse=True)\n",
    "  predicted_class, predicted_class_proba = sorted_log_classes_probas[0]\n",
    "  return predicted_class, predicted_class_proba\n",
    "\n",
    "def predict(input_df):\n",
    "  res = []\n",
    "  for _, row in input_df.iterrows():\n",
    "    class_label, _ = eval_bayes(row)\n",
    "    res.append(class_label)\n",
    "  return res\n",
    "\n",
    "def predict_proba(input_df):\n",
    "  res = []\n",
    "  for _, row in input_df.iterrows():\n",
    "    _, class_proba = eval_bayes(row)\n",
    "    res.append(class_proba)\n",
    "  return res\n",
    "\n",
    "# predict_proba(df_source[feature_names].head(1))\n",
    "predicted_classes = predict(df_source[feature_names])\n",
    "accuracy = (predicted_classes == y).sum() / len(y)\n",
    "\n",
    "print(f'Предсказания построены, accuracy = {accuracy:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VKEYoSZTJ3Nn"
   },
   "source": [
    "Проверим точность классификатора в реализации sklearn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T07:27:07.038453Z",
     "start_time": "2023-06-18T07:27:06.850878Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UkfYulXpJ4xR",
    "outputId": "2d62132d-18df-4ad9-b263-9a23a62d0f8d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Предсказания построены, accuracy = 0.97\n"
     ]
    }
   ],
   "source": [
    "from sklearn.naive_bayes import GaussianNB\n",
    "\n",
    "naive_bayes = GaussianNB() # создаём экземпляр класса\n",
    "naive_bayes.fit(X, y) # обучение модели\n",
    "predicted_classes = naive_bayes.predict(X) # предсказание (эксплуатация модели)\n",
    "\n",
    "accuracy = (predicted_classes == y).sum() / len(y)\n",
    "\n",
    "print(f'Предсказания построены, accuracy = {accuracy:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9wL9jMuT8uWM"
   },
   "source": [
    "Визуализируем confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T07:27:25.355330Z",
     "start_time": "2023-06-18T07:27:24.824482Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 318
    },
    "id": "rc5zz3ft8uk7",
    "outputId": "8bb75005-192f-4c74-e730-80676a4f28fe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Кoличество объектов в тестовой выборке: 33\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.model_selection import train_test_split\n",
    "import itertools\n",
    "\n",
    "# сводим задачу к бинарной классификации\n",
    "# df_source = pd.read_csv(\n",
    "#     'data/client_segmentation.csv', \n",
    "#     dtype={'call_diff': np.float32, 'call_diff': np.float32, 'traffic_diff': np.float32, 'customes_class': np.uint16}\n",
    "# )\n",
    "\n",
    "X = df_source[['call_diff','sms_diff','traffic_diff']].values\n",
    "y = df_source.customes_class.values\n",
    "\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, cm[i, j],\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)\n",
    "naive_bayes.fit(X_train, y_train)\n",
    "y_pred = naive_bayes.predict(X_test)\n",
    "\n",
    "conf_matrix = confusion_matrix(y_test, y_pred)\n",
    "plot_confusion_matrix(\n",
    "    conf_matrix,\n",
    "    classes=['active', 'churn'],\n",
    "    title='Confusion matrix, without normalization'\n",
    ")\n",
    "print(f'Кoличество объектов в тестовой выборке: {len(y_pred)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AslEGRA8KnkP"
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "01QfKZ0vHcSQ"
   },
   "source": [
    "Самостоятельное задание: постройте бейзлайн в виде рандомного предсказания классов. Выбор класса должен делаться случайным образом, но вероятность класса $1$ возьмите такую же, как в исходном датасете. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T08:05:01.594067Z",
     "start_time": "2023-06-18T08:05:01.585027Z"
    },
    "id": "7lFdOwB8HPLx"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Предсказания построены, accuracy = 0.42\n"
     ]
    }
   ],
   "source": [
    "# --------- ВАШ КОД ТУТ --------\n",
    "import random\n",
    "\n",
    "RANDOM_SEED = 100\n",
    "random.seed(RANDOM_SEED)\n",
    "\n",
    "classes = df_source.customes_class.unique()\n",
    "weights = df_source.customes_class.value_counts(normalize=True)\n",
    "size = len(df_source[feature_names])\n",
    "\n",
    "y_pred_random = random.choices(classes, weights = weights, k = size)\n",
    "\n",
    "accuracy = (y_pred_random == y).sum() / len(y)\n",
    "\n",
    "print(f'Предсказания построены, accuracy = {accuracy:.2f}')\n",
    "# --------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T08:05:08.619589Z",
     "start_time": "2023-06-18T08:05:08.400015Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 283
    },
    "id": "qgyDt1zPy1xx",
    "outputId": "04e02ae9-8ebd-4e18-cfba-d6c8ab5924b6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fc29fedf7f0>]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "x_space = np.linspace(0.00001, 1, num=100)\n",
    "plt.plot(x_space, np.log(x_space))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oKFo_vOjS9mo"
   },
   "source": [
    "# Logistic regression\n",
    "\n",
    "Другой интересный классификатор, для обучения которого уже применим градиентнй спуск - это логистическая регрессия\n",
    "\n",
    "Для понимания логистической регресси представим что у нас есть задача бинарной классификации, где два класса: класс $1$ (успех) и класс $0$ (неуспех), вероятность успеха обозначим $p$\n",
    "\n",
    "Шансы на успех (odds) - это отношение числа успехов  к числу неуспехов\n",
    "\n",
    "$$\n",
    "odds = \\frac{p}{1-p}\n",
    "$$\n",
    "\n",
    "В отличие от вероятности эта величина может быть как меньше единицы (если вероятность успеха меньше $0.5$) так и больше единицы (если вероятность успеха больше $0.5$). Термин шировко применяется в ставкав: допустим, мы выиграли в 15 играх из 100: в этом случае шансы на успех всего $\\frac{15}{85}=\\frac{3}{17}=0.17$ c другой стороны, если выиграть 60 игр из 100 то шансы на успех уже $\\frac{60}{40}=\\frac{3}{2}=1.5$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "04S9DExCbv2B"
   },
   "source": [
    "\n",
    "Теперь проведем небольшьшой трюк и логарифмируем наши шансы на успех\n",
    "\n",
    "$$\n",
    "\\log odds = \\log \\frac{p}{1-p}\n",
    "$$\n",
    "\n",
    "График логарифма мы строили ранее в этом семинаре: для значений от $0$ до $1$ получим отрицательные значения, выше - положительные\n",
    "\n",
    "Мы знаем, что линейная регрессия $\\hat{y} = w_0x_0 + \\ldots w_nx_n$ \"умеет\" предсказывать величины от $-\\infty$ до $\\infty$. Получается, мы по данным $X$ хотим предсказывать шансы на успех (как в ставках на спорт), например для конкретного объекта x у которого $n$ фичей:\n",
    "\n",
    "$$\n",
    "w_0x_0 + \\ldots w_nx_n = \\overline{w}x = \\log \\frac{p}{1-p}\n",
    "$$\n",
    "\n",
    "Превращаем логарифм в экспоненту\n",
    "$$\n",
    "\\exp(\\overline{w}x) = \\frac{p}{1-p}\n",
    "$$\n",
    "\n",
    "И окончательно выражаем вероятность успеха $p$ для конкретного объекта $x_i$:\n",
    "$$\n",
    "p_i = \\frac{1}{1+e^{-\\overline{w}x_i}}\n",
    "$$\n",
    "\n",
    "Функция $\\sigma (z) = \\frac{1}{1+e^{-z}}$ называеся *сигмоидой* - в курсе по нейросетям с сигмоидой вы встретитесь ещё не раз. Она обладает рядом интересных свойств, например $\\sigma (-z) = 1 - \\sigma (z)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ckxq2YSQMVCV"
   },
   "source": [
    "Дальше нужно подобрать оптимальные веса $w$. В задаче линейной регресси эмирический риск $Q_{\\text{emp}}$ мы считали как сумму квадратов отклонений предикта от таргета. Тут мы аналогично алгоритму наивного байеса воспользуемся достижениями из тервера и выпишем *правдоподобие данных* для выборки из распределения Бернулли (т.к. $y_i=0$ либо $y_i=1$ ) размера $N$:\n",
    "$$\n",
    "P(y | X, w) = \\prod_{i}^N p^{y_i}(1-p)^{1-y_i}\n",
    "$$\n",
    "Чтобы избавиться от произведения переходим к логарифмам (т.к. нам нужно найти точку максимума и логарифмирование на эту точку всё равно не повлияет)\n",
    "$$\n",
    "\\log P(y | X, w) = \\sum_{i}^{N} y_i \\log p_i + (1-y_i)\\log(1-p_i)\n",
    "$$\n",
    "\n",
    "Т.к. $p=\\sigma (z)$ и $\\sigma (-z) = 1 - \\sigma (z)$ то окончательно получаем\n",
    "$$\n",
    "\\log P(y | X, w) = \\sum_{i}^{N} y_i \\log \\sigma (z) + (1-y_i)\\log(\\sigma (-z))\n",
    "$$\n",
    "\n",
    "Правдоподобие нужно *максимизировать*, тогда функционал эмпирического риска, который мы минимизируем:\n",
    "$$\n",
    "L(y, X, w) = - \\sum_{i}^{N} y_i \\log \\sigma (z) + (1-y_i)\\log(\\sigma (-z))\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pZR5YBFVY9pX"
   },
   "source": [
    "Кстати, такая функция потерь называется \"бинарная кросс-энтропия\" или *BCE (binary crossemtropy loss)*. Аналитическое решение тут уже нельзя найти, зато отлично будет работать градиентный спуск, нужно только найти градиент функции потерь $L(Y, X, w)$\n",
    "\n",
    "$$\n",
    "\\nabla L = \\frac{1}{N}\\left(Y - \\hat{Y}\\right)\\cdot X\n",
    "$$\n",
    "\n",
    "Здесь $X$ - матрица объекты-признаки, а $\\hat{Y} = \\sigma(\\overline{w}x)$.одробнее про вывод этой формулы можно почитать в разделе про [логиcтическую регрессию](https://ml-handbook.ru/chapters/linear_models/intro) - только там не совсем правильно, т.к. нет усреднения ошибки.\n",
    "\n",
    "Можем реализовать на python (вот [тут](https://towardsdatascience.com/logistic-regression-from-scratch-in-python-ec66603592e2) подробнее и с картинками). Для начала сигмоиду"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T08:05:18.693504Z",
     "start_time": "2023-06-18T08:05:18.684376Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Ldg_woQYiN8H",
    "outputId": "9fd9990e-ad87-420c-ce29-7f578bd95a13"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.73105858, 0.88079708, 0.95257413, 0.99330715])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sigmoid(z):\n",
    "  return 1 / ( 1. + np.exp(-z))\n",
    "\n",
    "x = np.array([1, 2, 3, 5])\n",
    "sigmoid(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mk7b8zAeiOJX"
   },
   "source": [
    "Далее собственно градиентный спуск"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T08:06:08.048196Z",
     "start_time": "2023-06-18T08:06:07.962953Z"
    },
    "id": "9EG8gKaOM359"
   },
   "outputs": [],
   "source": [
    "from scipy.spatial import distance\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "def gradient(X, y, w, alpha=0) -> np.array:\n",
    "    \"\"\"Вычисляем градиент в точке\"\"\"\n",
    "    # количество обучающих примеров в выборке\n",
    "    n = X.shape[0]\n",
    "    # считаем прогноз\n",
    "    y_hat = sigmoid(X.dot(w.T))\n",
    "    # вычисляем ошибку прогноза\n",
    "    error = (y - y_hat).reshape(1, -1)\n",
    "    # дальше pointwise перемножение - умножаем каждую из координат на ошибку\n",
    "    grad = (-1.) * error.dot(X) / n\n",
    "    return grad, error\n",
    "\n",
    "def eval_w_next(X, y, eta, w_current):\n",
    "    \"\"\"Делаем шаг градиентного спуска\"\"\"\n",
    "    # вычисляем градиент\n",
    "    grad, error = gradient(X, y, w_current)\n",
    "    # делаем шаг градиентного спуска\n",
    "    w_next = w_current - eta*grad\n",
    "    # проверяем условие сходимости\n",
    "    weight_evolution = distance.euclidean(w_current, w_next)\n",
    "    return (w_next, weight_evolution, grad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1Q6wsAJEvh2P"
   },
   "source": [
    "Повторяем шаги до сходимости"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T08:06:11.573418Z",
     "start_time": "2023-06-18T08:06:11.508403Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "sOqZ7iXMvhV8",
    "outputId": "bdfcc529-56ba-48f4-fa69-efb5bee4532e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 100 |w-w_next|=0.00335, grad=[[ 0.14471559 -0.29080525  0.13451325  0.22725221]]\n",
      "step 200 |w-w_next|=0.00261, grad=[[ 0.09692591 -0.24838453  0.07914115  0.1710438 ]]\n",
      "step 300 |w-w_next|=0.00206, grad=[[ 0.06242417 -0.21254249  0.03865657  0.12547547]]\n",
      "step 400 |w-w_next|=0.00169, grad=[[ 0.04064907 -0.18472803  0.0130487   0.09426067]]\n",
      "step 500 |w-w_next|=0.00145, grad=[[ 0.02759291 -0.16307762 -0.00227086  0.07409879]]\n",
      "step 600 |w-w_next|=0.00128, grad=[[ 0.01983082 -0.14582509 -0.01132707  0.06103861]]\n",
      "step 700 |w-w_next|=0.00115, grad=[[ 0.01517733 -0.1317668  -0.01669817  0.05231134]]\n",
      "step 800 |w-w_next|=0.00105, grad=[[ 0.01235231 -0.12010273 -0.01989456  0.0462283 ]]\n"
     ]
    }
   ],
   "source": [
    "def gradient_descent(X: np.array, y: np.array, eta=0.01, epsilon=0.001) -> np.array:\n",
    "    m = X.shape[1] # количество фичей\n",
    "    # инициализируем рандомом веса\n",
    "    w = np.random.random(m).reshape(1, -1)\n",
    "    w_next, weight_evolution, grad = eval_w_next(X, y, eta, w)\n",
    "    step = 0\n",
    "    # повторяем до сходимости вектора весов\n",
    "    while weight_evolution > epsilon:\n",
    "        w = w_next\n",
    "        w_next, weight_evolution, grad = eval_w_next(X, y, eta, w)\n",
    "        step += 1\n",
    "        if step % 100 == 0:\n",
    "            print(\"step %s |w-w_next|=%.5f, grad=%s\" % (step, weight_evolution, grad))\n",
    "    return w\n",
    "\n",
    "# добавляем тривиальный признак w_0, столбец из единиц. См. прошлый урок, почему так\n",
    "X_extended = np.hstack([\n",
    "    np.ones(X.shape[0]).reshape(-1,1),\n",
    "    X\n",
    "])\n",
    "w = gradient_descent(\n",
    "    X_extended,\n",
    "    y.reshape(-1, 1),\n",
    "    eta=0.008\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T08:06:14.153312Z",
     "start_time": "2023-06-18T08:06:14.142132Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jzQfGJIJQc2R",
    "outputId": "3c760e0e-a46e-4ce5-a0e0-1f4e91a72c2c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 4)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_extended.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T10:09:01.409872Z",
     "start_time": "2023-06-18T10:09:01.392813Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hhsL462DKBUa",
    "outputId": "eabb8eb3-85c0-4e94-af00-87f845fcecf9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Предсказания построены, accuracy = 0.9500\n"
     ]
    }
   ],
   "source": [
    "def predict(X, w):\n",
    "  y_probas = sigmoid(X.dot(w.T))\n",
    "  y_hat = np.zeros_like(y_probas)\n",
    "  y_hat[np.where(y_probas >= 0.5)] = 1\n",
    "  y_hat[np.where(y_probas < 0.5)] = 0\n",
    "  y_hat = y_hat.flatten().astype(np.uint16)\n",
    "\n",
    "  return y_hat\n",
    "\n",
    "predicted_classes = predict(X_extended, w)\n",
    "accuracy = (predicted_classes == y).sum() / len(y)\n",
    "print(f'Предсказания построены, accuracy = {accuracy:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T08:43:49.653733Z",
     "start_time": "2023-06-18T08:43:49.631111Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w2aXqIpKE_0n"
   },
   "source": [
    "Сраваним с \"коробочной\" реализацией"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T10:08:59.378301Z",
     "start_time": "2023-06-18T10:08:59.179060Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XCcNQAp0xrwU",
    "outputId": "65185b00-64ae-4138-d120-5e6530b49f66"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Предсказания построены, accuracy = 0.9500\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "log_reg = LogisticRegression().fit(X, y)\n",
    "\n",
    "predicted_classes_sklearn = log_reg.predict(X)\n",
    "accuracy = (predicted_classes == y).sum() / len(y)\n",
    "print(f'Предсказания построены, accuracy = {accuracy:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "S45AjHgCafg3"
   },
   "source": [
    "Самостоятельное задание: посчитать используя библиотеку sklearn и визуализировать ROC-AUC для двух логистических регрессий выше."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T09:54:25.161605Z",
     "start_time": "2023-06-18T09:54:24.644412Z"
    },
    "id": "Rc3CmRjEzZIz"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Наш ROC-AUC score = 0.9955436720142602\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Коробочный ROC-AUC score = 1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# --------- ВАШ КОД ТУТ --------\n",
    "from sklearn.metrics import roc_curve, roc_auc_score\n",
    "\n",
    "def count_and_draw_roc_curve(y_true, y_score, explanation):\n",
    "    \n",
    "    auc_score = roc_auc_score(y_true, y_score)\n",
    "    print(f'{explanation} ROC-AUC score = {auc_score}')\n",
    "    \n",
    "    fpr, tpr, thresholds = roc_curve(y_true, y_score)\n",
    "    plt.plot(fpr, tpr)\n",
    "    plt.plot([0,1], [0,1], linestyle='dashed', color='black')\n",
    "    plt.ylabel('True Positive Rate')\n",
    "    plt.xlabel('False Positive Rate')\n",
    "    plt.show()\n",
    "    return\n",
    "\n",
    "\n",
    "y_probas = sigmoid(X_extended.dot(w.T))\n",
    "y_probas_sklearn = log_reg.predict_proba(X)[:,1]\n",
    "# print(y_probas)\n",
    "# print(y_probas_sklearn[:,1])\n",
    "\n",
    "count_and_draw_roc_curve(y, y_probas, 'Наш')\n",
    "count_and_draw_roc_curve(y, y_probas_sklearn, 'Коробочный')\n",
    "# --------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итог: Обе модели идеально (наша - почти идеально) различают классы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ScEVSffCcQHq"
   },
   "source": [
    "Бонус уровень (+2 балла к этому заданию, если есть понижение): самостоятельно реализовать функцию roc_auc_score и сравнить ее с результатами выше."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T10:30:50.654708Z",
     "start_time": "2023-06-18T10:30:50.647305Z"
    },
    "id": "QabCl6M4czcU"
   },
   "outputs": [],
   "source": [
    "# --------- ВАШ КОД ТУТ --------\n",
    "\n",
    "# примерный план:\n",
    "# построить точки ROC по thershold -- ROC кусочно-заданная от точки до точки \n",
    "# точки соответствуют соотношению Sensitivity и Specificity\n",
    "# надо посчитать TPR и FPR\n",
    "# посчитать площадь под ROC\n",
    "\n",
    "# https://www.youtube.com/watch?v=4jRBRDbJemM\n",
    "\n",
    "def count_roc_auc_score(y_true, y_score, explanation):\n",
    "    \n",
    "    _, _, thresholds = roc_curve(y_true, y_score)\n",
    "    \n",
    "    \n",
    "\n",
    "count_roc_auc_score(y, y_probas, 'Наш')\n",
    "count_roc_auc_score(y, y_probas_sklearn, 'Коробочный')\n",
    "# --------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WG3isoK8cztt"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}