Logistic_regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Логистическая регрессия"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Особенность: возможность оценивания вероятностей классов"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Реализация градиентного спуска"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import pandas\n",
    "import math\n",
    "from sklearn.metrics import roc_auc_score\n",
    "import sympy\n",
    "from IPython.display import Image\n",
    "from IPython.core.display import HTML \n",
    "\n",
    "#Загрузите данные из файла data-logistic.csv.\n",
    "#Это двумерная выборка, целевая переменная на которой принимает знчения -1 и 1.\n",
    "\n",
    "data = pandas.read_csv('data-logistic.csv', header = None)\n",
    "y = data[0]\n",
    "X = data.iloc[:, 1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-1</td>\n",
       "      <td>-0.663827</td>\n",
       "      <td>-0.138526</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1.994596</td>\n",
       "      <td>2.468025</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-1</td>\n",
       "      <td>-1.247395</td>\n",
       "      <td>0.749425</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>2.309374</td>\n",
       "      <td>1.899836</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>0.849143</td>\n",
       "      <td>2.407750</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0         1         2\n",
       "0 -1 -0.663827 -0.138526\n",
       "1  1  1.994596  2.468025\n",
       "2 -1 -1.247395  0.749425\n",
       "3  1  2.309374  1.899836\n",
       "4  1  0.849143  2.407750"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"imgs/compute-ws.png\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(url= \"imgs/compute-ws.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_w1(X, y, w1, w2, k, C):\n",
    "    l = len(y)\n",
    "    S = 0\n",
    "    for i in range(0, l):\n",
    "        S += y[i] * X[1][i] * (1.0 - 1.0 / (1.0 + math.exp(-y[i] * (w1*X[1][i] + w2*X[2][i]))))\n",
    "    return w1 + (k * (1.0 / l) * S) - k * C * w1\n",
    "\n",
    "\n",
    "def compute_w2(X, y, w1, w2, k, C):\n",
    "    l = len(y)\n",
    "    S = 0\n",
    "    for i in range(0, l):\n",
    "        S += y[i] * X[2][i] * (1.0 - 1.0 / (1.0 + math.exp(-y[i] * (w1*X[1][i] + w2*X[2][i]))))\n",
    "    return w2 + (k * (1.0 / l) * S) - k * C * w2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.9268571428571428, 0.9362857142857142)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def run_grad_descent(X, y, C, w1=0, w2=0, k=0.1, perm_err=1e-5):   # perm_err = допустимая ошибка\n",
    "    i = 0\n",
    "    i_max = 10000\n",
    "    new_w1 = 0 # начальные значения весов\n",
    "    new_w2 = 0\n",
    "\n",
    "    while True:\n",
    "        i += 1\n",
    "        new_w1 = compute_w1(X, y, w1, w2, k, C)\n",
    "        new_w2 = compute_w2(X, y, w1, w2, k, C)\n",
    "        error = math.sqrt((new_w1 - w1)**2 + (new_w2 - w2)**2)\n",
    "        \n",
    "        if i >= i_max or error <= perm_err:\n",
    "            break\n",
    "        else:\n",
    "            w1 = new_w1\n",
    "            w2 = new_w2\n",
    "            \n",
    "    return [new_w1, new_w2]\n",
    "\n",
    "w1, w2 = run_grad_descent(X, y, 0)\n",
    "regul_w1, regul_w2 = run_grad_descent(X, y, 10)\n",
    "\n",
    "#Какое значение принимает AUC-ROC на обучении без регуляризации и при ее использовании? Эти величины будут ответом на задание.\n",
    "#В качестве ответа приведите два числа через пробел. \n",
    "#Обратите внимание, что на вход функции roc_auc_score нужно подавать оценки вероятностей, подсчитанные обученным алгоритмом.\n",
    "#Для этого воспользуйтесь сигмоидной функцией: a(x) = 1/(1 + exp(−w1x1 − w2x2)).\n",
    "\n",
    "def a(X, w1, w2):\n",
    "    return 1 / (1 + math.exp(-w1*X[1] - w2*X[2]))\n",
    "\n",
    "y_score = X.apply(lambda x: a(x, w1, w2), axis=1)\n",
    "ry_score = X.apply(lambda x: a(x, regw1, regw2), axis=1)\n",
    "\n",
    "auc = roc_auc_score(y, y_score)\n",
    "r_auc = roc_auc_score(y, ry_score)\n",
    "auc, r_auc # нужны для оценки качества бинарной классификации\n",
    "\n",
    "\"\"\"\n",
    "отображает соотношение между долей объектов от общего количества носителей признака, верно классифицированных как \n",
    "несущих признак. \n",
    "\n",
    "Количественную интерпретацию ROC даёт показатель AUC (англ. area under ROC curve, площадь под ROC-кривой) — площадь,\n",
    "ограниченная ROC-кривой и осью доли ложных положительных классификаций. Чем выше показатель AUC, тем качественнее\n",
    "классификатор, при этом значение 0,5 демонстрирует непригодность выбранного метода классификации \n",
    "(соответствует случайному гаданию). Значение менее 0,5 говорит, что классификатор действует с точностью до наоборот:\n",
    "если положительные назвать отрицательными и наоборот, классификатор будет работать лучше. \n",
    "\"\"\""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}