LogisticRegression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sl</th>\n",
       "      <th>sw</th>\n",
       "      <th>pl</th>\n",
       "      <th>pw</th>\n",
       "      <th>c</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>6.7</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>63</th>\n",
       "      <td>6.1</td>\n",
       "      <td>2.9</td>\n",
       "      <td>4.7</td>\n",
       "      <td>1.4</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>147</th>\n",
       "      <td>6.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>141</th>\n",
       "      <td>6.9</td>\n",
       "      <td>3.1</td>\n",
       "      <td>5.1</td>\n",
       "      <td>2.3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>47</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      sl   sw   pl   pw  c\n",
       "145  6.7  3.0  5.2  2.3  3\n",
       "63   6.1  2.9  4.7  1.4  2\n",
       "147  6.5  3.0  5.2  2.0  3\n",
       "2    4.7  3.2  1.3  0.2  1\n",
       "141  6.9  3.1  5.1  2.3  3\n",
       "47   4.6  3.2  1.4  0.2  1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from matplotlib import pylab as plt\n",
    "%matplotlib inline\n",
    "df = pd.read_csv(\"data/iris.txt\", delimiter=\" \")\n",
    "df.sample(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    return 1 / (1 + np.exp(-x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class LogisticRegression(object):\n",
    "    def __init__(self, X, Y, order=1):\n",
    "        super(LogisticRegression, self).__init__()\n",
    "        self.order = order\n",
    "        self.X = X\n",
    "        self.Y = Y\n",
    "        self.train()\n",
    "        \n",
    "    @staticmethod\n",
    "    def prepareOrderedX(X, order):\n",
    "        return X\n",
    "    \n",
    "    def train(self):\n",
    "        N = self.X.shape[0]\n",
    "        D = self.X.shape[1]\n",
    "        \n",
    "        theta = np.ones((D, 1))\n",
    "        eta = 0.001\n",
    "        maxIteration = 500000\n",
    "        prev_error = np.infty\n",
    "        \n",
    "        errors = []\n",
    "        for i in range(maxIteration):\n",
    "            pr = sigmoid(self.X * theta)\n",
    "            theta = theta + eta * self.X.T * (self.Y - pr)\n",
    "            \n",
    "            error = np.power(self.Y - pr, 2).sum() / N\n",
    "            errors.append(error)\n",
    "            if (prev_error * 0.99999) < error:\n",
    "                break\n",
    "            prev_error = error\n",
    "\n",
    "        self.error_history = errors\n",
    "        self.theta = theta\n",
    "    \n",
    "    def predict(self, X):\n",
    "        X = LogisticRegression.prepareOrderedX(X, self.order)\n",
    "        return sigmoid(X * self.theta)\n",
    "\n",
    "    def plotErrors(self):\n",
    "        plt.plot(self.error_history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def calcAccuracy(X, Y, model):\n",
    "    y_est = model.predict(X)\n",
    "    y_est2 = model.predict(X)\n",
    "    y_est[y_est >= 0.5] = 1\n",
    "    y_est[y_est < 0.5] = 0\n",
    "    #print np.hstack([Y, y_est])\n",
    "    ROC = {\n",
    "        \"truePositive\": 0,\n",
    "        \"falsePositive\": 0,\n",
    "        \"trueNegative\": 0,\n",
    "        \"falseNegative\": 0,\n",
    "    }\n",
    "    \n",
    "    for i_est, i in zip(y_est, Y):\n",
    "        if i == 1 and i_est == i:\n",
    "            ROC[\"truePositive\"] += 1 \n",
    "        elif i_est == 1:\n",
    "            ROC[\"falsePositive\"] += 1\n",
    "        elif i_est == 0 and i != 1:\n",
    "            ROC[\"trueNegative\"] += 1\n",
    "        elif i_est == 0 and i == 1:\n",
    "            ROC[\"falseNegative\"] += 1\n",
    "        \n",
    "    print ROC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = np.matrix(df.iloc[:, [0, 1, 2, 3]])\n",
    "y = np.matrix(df.iloc[:, 4]).T\n",
    "y1, y2, y3 = np.copy(y), np.copy(y), np.copy(y)\n",
    "\n",
    "y1[ y1!= 1] = 0\n",
    "\n",
    "y2[ y2 != 2] = 0\n",
    "y2[ y2 == 2] = 1\n",
    "\n",
    "y3[ y3 != 3] = 0\n",
    "y3[ y3 == 3] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 328,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'falseNegative': 0, 'falsePositive': 0, 'truePositive': 50, 'trueNegative': 100}\n"
     ]
    }
   ],
   "source": [
    "m = LogisticRegression(x, y1, order=2)\n",
    "calcAccuracy(x, y1, m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'falseNegative': 50, 'falsePositive': 0, 'truePositive': 0, 'trueNegative': 100}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "matrix([[-0.49591048],\n",
       "        [ 0.10889452],\n",
       "        [ 0.12148996],\n",
       "        [ 0.68384537]])"
      ]
     },
     "execution_count": 329,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = LogisticRegression(x, y2, order=2)\n",
    "calcAccuracy(x, y2, m)\n",
    "m.theta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'falseNegative': 0, 'falsePositive': 48, 'truePositive': 50, 'trueNegative': 52}\n"
     ]
    }
   ],
   "source": [
    "m = LogisticRegression(x, y3, order=2)\n",
    "calcAccuracy(x, y3, m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}