LogisticRegression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import ListedColormap\n",
    "from sklearn import datasets\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "class LogisticRegressionGD(object):\n",
    "    \"\"\"Logistic Regression Classifier using gradient descent.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    eta : float\n",
    "      Learning rate (between 0.0 and 1.0)\n",
    "    n_iter : int\n",
    "      Passes over the training dataset.\n",
    "    random_state : int\n",
    "      Random number generator seed for random weight initialization.\n",
    "      \n",
    "    Attributes\n",
    "    ----------\n",
    "    w_ : 1d-array\n",
    "      Weights after fitting.\n",
    "    cost_ : list\n",
    "      Sum-of-squares cost function value in each epoch.\n",
    "      \n",
    "    \"\"\"\n",
    "    def __init__(self, eta=0.01, n_iter=50, random_state=1):\n",
    "        self.eta = eta\n",
    "        self.n_iter = n_iter\n",
    "        self.random_state = random_state\n",
    "        \n",
    "    def fit(self, X, y):\n",
    "        \"\"\"Fit training data.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        X : {array-like}, shape = [n_samples, n_features]\n",
    "          Training vectors, where n_samples is the number of samples and n_features is the number of feautures.\n",
    "        y : array-like, shape = [n_samples]\n",
    "          Target values.\n",
    "          \n",
    "        Returns\n",
    "        -------\n",
    "        self : object\n",
    "        \n",
    "        \"\"\"\n",
    "        rgen = np.random.RandomState(self.random_state)\n",
    "        self.w_ = rgen.normal(loc=0.0, scale=0.01, size=1 + X.shape[1])\n",
    "        self.cost_ = []\n",
    "        \n",
    "        for i in range(self.n_iter):\n",
    "            net_input = self.net_input(X)\n",
    "            output = self.activation(net_input)\n",
    "            errors = (y - output)\n",
    "            self.w_[1:] += self.eta * X.T.dot(errors)\n",
    "            self.w_[0] += self.eta * errors.sum()\n",
    "            \n",
    "            # note that we compute the logistic cost now\n",
    "            cost = (-y.dot(np.log(output)) - ((1 - y).dot(np.log(1 - output))))\n",
    "            self.cost_.append(cost)\n",
    "        return self\n",
    "    \n",
    "    def net_input(self, X):\n",
    "        \"\"\"Calculate net input\"\"\"\n",
    "        return np.dot(X, self.w_[1:]) + self.w_[0]\n",
    "    \n",
    "    def activation(self, z):\n",
    "        \"\"\"Compute logistic sigmoid activation\"\"\"\n",
    "        return 1.0 / (1.0 + np.exp(-np.clip(z, -250, 250)))\n",
    "\n",
    "    def predict(self, X):\n",
    "        \"\"\"Return class label after unit step\"\"\"\n",
    "        return np.where(self.net_input(X) >= 0.0, 1, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_decision_regions(X, y, classifier, test_idx=None, resolution=0.02):\n",
    "    # setup marker generator and color map\n",
    "    markers = ('s', 'x', 'o', '^', 'v')\n",
    "    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')\n",
    "    cmap = ListedColormap(colors[:len(np.unique(y))])\n",
    "    \n",
    "    # plot the decision surface\n",
    "    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() +1\n",
    "    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() +1\n",
    "    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), \n",
    "                           np.arange(x2_min, x2_max, resolution))\n",
    "    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)\n",
    "    Z = Z.reshape(xx1.shape)\n",
    "    plt.contourf(xx1, xx2, Z, alpha=0.3, cmap=cmap)\n",
    "    plt.xlim(xx1.min(), xx1.max())\n",
    "    plt.ylim(xx2.min(),xx2.max())\n",
    "    \n",
    "    # plot class samples\n",
    "    for idx, cl in enumerate(np.unique(y)):\n",
    "        plt.scatter(x=X[y == cl, 0],\n",
    "                   y=X[y == cl, 1],\n",
    "                   alpha=0.8,\n",
    "                   c=colors[idx],\n",
    "                   marker=markers[idx],\n",
    "                   label=cl,\n",
    "                   edgecolor='black')\n",
    "        \n",
    "    # highlight test samples\n",
    "    if test_idx:\n",
    "        # plot all samples\n",
    "        X_test, y_test = X[test_idx, :], y[test_idx]\n",
    "        \n",
    "        plt.scatter(X_test[:, 0], X_test[:, 1], \n",
    "                    c='', edgecolor='black', alpha=1.0,\n",
    "                   linewidth=1, marker='o', s=100, label='test set')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class labels: [0 1 2]\n"
     ]
    }
   ],
   "source": [
    "iris = datasets.load_iris()\n",
    "X = iris.data[:, [2,3]]\n",
    "y = iris.target\n",
    "print('Class labels:', np.unique(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Label counts in y: [50 50 50]\n",
      "Label counts in y_train: [35 35 35]\n",
      "Label counts in y_test: [15 15 15]\n"
     ]
    }
   ],
   "source": [
    "# train_test_split already shuffles the training sets internally before splitting\n",
    "# stratify returns training and test subsets that have the same proportions of class labels as the input dataset\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1, stratify=y)\n",
    "print('Label counts in y:', np.bincount(y))\n",
    "print('Label counts in y_train:', np.bincount(y_train))\n",
    "print('Label counts in y_test:', np.bincount(y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_01_subset = X_train[(y_train == 0) | (y_train == 1)]\n",
    "y_train_01_subset = y_train[(y_train == 0) | (y_train == 1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lgrd = LogisticRegressionGD(eta=0.05, n_iter=1000, random_state=1)\n",
    "lgrd.fit(X_train_01_subset, y_train_01_subset)\n",
    "plot_decision_regions(X=X_train_01_subset, y=y_train_01_subset, classifier=lgrd)\n",
    "plt.title('Logistic Regression - Gradient Descent')\n",
    "plt.xlabel('petal length [standardized]')\n",
    "plt.ylabel('petal width [standardized]')\n",
    "plt.legend(loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}