base_algos/python/2. Logistic regression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy as sp\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "sns.set(style = \"whitegrid\")\n",
    "import sklearn\n",
    "from sklearn import metrics\n",
    "from mlxtend.plotting import plot_confusion_matrix\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Binary Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>oxygen</th>\n",
       "      <th>survive</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>75</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>14</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>8</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   oxygen  survive\n",
       "0      10        0\n",
       "1       5        0\n",
       "2      75        1\n",
       "3      14        0\n",
       "4       8        0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.read_csv(\"../../datasets/log_reg_bin.csv\")\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Splitting dataset into training and testing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11 11 4 4\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(data.iloc[:,0], data.iloc[:,1], test_size = 0.25, random_state = 42)\n",
    "print(len(X_train), len(y_train), len(X_test), len(y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing the training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.FacetGrid at 0x2e8d9051a58>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2e8d9051518>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train = pd.DataFrame([X_train.reset_index(drop=True), y_train.reset_index(drop=True)]).T.reindex(columns = [\"oxygen\", \"survive\"])\n",
    "sns.lmplot(\"oxygen\", \"survive\", data = train, hue='survive', fit_reg=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building logistic regression model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
       "          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,\n",
       "          penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\n",
       "          verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "model = LogisticRegression()\n",
    "model.fit(train.iloc[:,0].values.reshape(-1,1), train.iloc[:,1].values.reshape(-1,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.41956612])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.04616302]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.coef_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estimated values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy:  90.9090909090909\n",
      "Testing Accuracy:  75.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(<matplotlib.figure.Figure at 0x2e8d91ec0f0>,\n",
       " <matplotlib.axes._subplots.AxesSubplot at 0x2e8d91ec908>)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2e8d9153ef0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2e8d91ec0f0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "est = model.predict(train.iloc[:,0].values.reshape(-1,1))\n",
    "est\n",
    "\n",
    "# Training\n",
    "print('Training Accuracy: ', model.score(train.iloc[:,0].values.reshape(-1,1), train.iloc[:,1].values.reshape(-1,1)) * 100)\n",
    "est = model.predict(train.iloc[:,0].values.reshape(-1,1))\n",
    "actual = train.iloc[:,1].values.reshape(-1,1)\n",
    "cm = metrics.confusion_matrix(actual, est, labels=pd.unique(train.iloc[:,1]))\n",
    "plot_confusion_matrix(cm)\n",
    "\n",
    "# Testing\n",
    "print('Testing Accuracy: ', model.score(X_test.values.reshape(-1,1), y_test.values.reshape(-1,1)) * 100)\n",
    "est = model.predict(X_test.values.reshape(-1,1))\n",
    "actual = y_test.values.reshape(-1,1)\n",
    "cm = metrics.confusion_matrix(actual, est, labels=pd.unique(y_test))\n",
    "plot_confusion_matrix(cm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logistic regression model graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x2e8d2768828>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2e8d2768898>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def model_curve(x):\n",
    "    return 1 / (1 + np.exp(-x))\n",
    "loss = model_curve(X_train.values.reshape(-1,1) * model.coef_ + model.intercept_).ravel()\n",
    "\n",
    "sns.lmplot(\"oxygen\", \"survive\", data = train, hue='survive', fit_reg=False)\n",
    "plt.plot(np.sort(X_train),np.sort(loss), color = \"red\")\n",
    "plt.axhline(.5, color='.5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multinomial Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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>budget</th>\n",
       "      <th>cars</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>100000</td>\n",
       "      <td>Toyota</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>250000</td>\n",
       "      <td>Toyota</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>500000</td>\n",
       "      <td>Toyota</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>750000</td>\n",
       "      <td>Toyota</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1000000</td>\n",
       "      <td>Toyota</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    budget    cars\n",
       "0   100000  Toyota\n",
       "1   250000  Toyota\n",
       "2   500000  Toyota\n",
       "3   750000  Toyota\n",
       "4  1000000  Toyota"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.read_csv(\"datasets/ML/log_reg_mul.csv\")\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Toyota', 'Ferrari', 'Bugatti'], dtype=object)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.unique(data.iloc[:,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Splitting dataset into training and testing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11 11 4 4\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(data.iloc[:,0], data.iloc[:,1], test_size = 0.25, random_state = 42)\n",
    "print(len(X_train), len(y_train), len(X_test), len(y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building multinomial logistic regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
       "          intercept_scaling=1, max_iter=100, multi_class='multinomial',\n",
       "          n_jobs=1, penalty='l2', random_state=None, solver='newton-cg',\n",
       "          tol=0.0001, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "model = LogisticRegression(multi_class=\"multinomial\", solver = \"newton-cg\")\n",
    "model.fit(X_train.values.reshape(-1,1), y_train.values.reshape(-1,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-9.86086392,  0.14315378,  9.71771013])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.00057775],\n",
       "       [-0.00057926],\n",
       "       [-0.00058583]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.coef_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estimated values and accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy:  100.0\n",
      "Testing Accuracy:  100.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(<matplotlib.figure.Figure at 0x2e8d92c1668>,\n",
       " <matplotlib.axes._subplots.AxesSubplot at 0x2e8d92c1e80>)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2e8d9250e80>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2e8d92c1668>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Training\n",
    "print('Training Accuracy: ', model.score(X_train.values.reshape(-1,1), y_train.values.reshape(-1,1)) * 100)\n",
    "est = model.predict(X_train.values.reshape(-1,1))\n",
    "actual = y_train.values.reshape(-1,1)\n",
    "cm = metrics.confusion_matrix(actual, est, labels=pd.unique(y_train))\n",
    "plot_confusion_matrix(cm)\n",
    "\n",
    "# Testing\n",
    "print('Testing Accuracy: ', model.score(X_test.values.reshape(-1,1), y_test.values.reshape(-1,1)) * 100)\n",
    "est = model.predict(X_test.values.reshape(-1,1))\n",
    "actual = y_test.values.reshape(-1,1)\n",
    "cm = metrics.confusion_matrix(actual, est, labels=pd.unique(y_test))\n",
    "plot_confusion_matrix(cm)"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}