w2LogisticRegression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\FridayLab\\Miniconda2\\lib\\site-packages\\sklearn\\utils\\fixes.py:313: FutureWarning: numpy not_equal will not check object identity in the future. The comparison did not return the same result as suggested by the identity (`is`)) and will change.\n",
      "  _nan_object_mask = _nan_object_array != _nan_object_array\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression, LogisticRegression\n",
    "import matplotlib.pyplot as plt \n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xd1f15f8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x=[10, 20, 30, 40, 50, 60, 70]\n",
    "y=[0, 0, 0, 1, 1, 1, 1]\n",
    "\n",
    "#Uncomment following two line to show the difference\n",
    "# x=[10, 20, 30, 40, 50, 60, 70, 190]\n",
    "# y=[0, 0, 0, 1, 1, 1, 1, 1]\n",
    "\n",
    "# x=[10, 20, 30, 40, 50, 60, 70]\n",
    "# y=[0, 0, 0, 1, 1, 0, 1]\n",
    "\n",
    "plt.scatter(x, y, color = 'red') \n",
    "plt.title('x vs y')\n",
    "plt.xlabel('x data')\n",
    "plt.ylabel('y data')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10], [20], [30], [40], [50], [60], [70]]\n"
     ]
    }
   ],
   "source": [
    "xx=[ [ix] for ix in x]\n",
    "print xx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.07142857  0.14285714  0.35714286  0.57142857  0.78571429  1.\n",
      "  1.21428571]\n",
      "m= [ 0.02142857] c= -0.285714285714\n",
      "[ 2.92857143]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "model = LinearRegression()\n",
    "model.fit(xx, y)\n",
    "\n",
    "pred=model.predict(xx)\n",
    "print pred\n",
    "print 'm=', model.coef_ ,'c=',model.intercept_\n",
    "\n",
    "print model.predict([[150]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xd395a90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x, y, color = 'red')\n",
    "plt.plot(x, pred, color = 'blue')\n",
    "plt.title('x vs y')\n",
    "plt.xlabel('x data')\n",
    "plt.ylabel('y data')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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='warn',\n",
       "          n_jobs=None, penalty='l2', random_state=None, solver='warn',\n",
       "          tol=0.0001, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X=[ [ix] for ix in x]\n",
    "model = LogisticRegression()\n",
    "model.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.predict(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  9.99999950e-01,   5.00049282e-08],\n",
       "       [  9.99958372e-01,   4.16283835e-05],\n",
       "       [  9.66503021e-01,   3.34969788e-02],\n",
       "       [  3.34970055e-02,   9.66502995e-01],\n",
       "       [  4.16284178e-05,   9.99958372e-01],\n",
       "       [  5.00049694e-08,   9.99999950e-01],\n",
       "       [  6.00645725e-11,   1.00000000e+00]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.predict_proba(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.score(X, y)  #mean accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now get to business.\n",
    "\n",
    "1. Predict Class <br>\n",
    "  i. Linear Regression model predict a value. <br>\n",
    "  ii. Map the value between 0 and 1 using sigmoid. <br>\n",
    "2. Cross Entropy Cost Function (or log loss)\n",
    "3. Use gradient descent to optimize loss.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Terms\n",
    "1. Odds, Odds ratio\n",
    "2. Probability\n",
    "3. Maximum Likliehood\n",
    "4. Logit Function (aka Sigmoid Function)\n",
    "5. Binary Cross Entropy Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Best Fit Model\n",
    "\n",
    "we need something, that maps every x in between 0 and 1 where the linear regression model do some extra ie. lower zero\n",
    "and upper then 1. So we need a best fit model. The S shape logistic function (another name is sigmoid function )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "odd ratio=probability of win / probability of not win<br>\n",
    "odds=p/1-p <br>\n",
    "\n",
    "Maximum Likliehood Estimation (MLE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cost Function\n",
    "\n",
    "cross entropy or log loss\n",
    "\n",
    "<img src='ng_cost_function_logistic.png'>\n",
    "\n",
    "Prediction vs Loss\n",
    "<img src='y1andy2_logistic_function.png' caption='prediction vs loss'>\n",
    "\n",
    "The key thing to note is the cost function penalizes confident and wrong predictions more than it rewards confident and right predictions! \n",
    "\n",
    "\n",
    "To Put it in one line (for 0 another will cancel out and same for 1)\n",
    "\\begin{equation*}\n",
    "p=h \\theta (X)  [mind] \\\\\n",
    "{ - y\\log(p) - (1 - y)\\log(1 - p)} \n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, the loss function for the data becomes, \n",
    "<img src='logistic_cost_function_joined.png'>\n",
    "Multiplying by y and (1−y) in the above equation is a sneaky trick that let’s us use the same equation to solve for both y=1 and y=0 cases. If y=0, the first side cancels out. If y=1, the second side cancels out. In both cases we only perform the operation we need to perform.\n",
    "\n",
    "\n",
    "for i^Th data of X\n",
    "\\begin{equation*}\n",
    "\\theta x^i:=\\theta_0+\\theta_1 x^i_1+\\dots+\\theta_p x^i_p.\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Or,\n",
    "def CrossEntropy(yHat, y):\n",
    "    if y == 1:\n",
    "      return -log(yHat)\n",
    "    else:\n",
    "      return -log(1 - yHat)\n",
    "\n",
    "def CrossEntropy2(yHat, y):\n",
    "    return ( -y*log(yHat) - (1-y)*log(1 - yHat) ).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Minimizing J(theta)\n",
    "\n",
    "<img src='ng_cost_min.png' width=540>\n",
    "\n",
    "What we got is the following\n",
    "<img src='ng_partial_der.png' width=540>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    # Activation function used to map any real value between 0 and 1\n",
    "    return 1 / (1 + np.exp(-x))\n",
    "\n",
    "def net_input(theta, x):\n",
    "    # Computes the weighted sum of inputs\n",
    "    return np.dot(x, theta)\n",
    "\n",
    "def probability(theta, x):\n",
    "    # Returns the probability after passing through sigmoid\n",
    "    return sigmoid(net_input(theta, x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cost_function(self, theta, x, y):\n",
    "    # Computes the cost function for all the training samples\n",
    "    m = x.shape[0]\n",
    "    total_cost = -(1 / m) * np.sum(\n",
    "        y * np.log(probability(theta, x)) + (1 - y) * np.log(\n",
    "            1 - probability(theta, x)))\n",
    "    return total_cost\n",
    "\n",
    "def gradient(self, theta, x, y):\n",
    "    # Computes the gradient of the cost function at the point theta\n",
    "    m = x.shape[0]\n",
    "    return (1 / m) * np.dot(x.T, sigmoid(net_input(theta,   x)) - y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(features, weights):\n",
    "  z = np.dot(features, weights)\n",
    "  return sigmoid(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decision_boundary(prob):\n",
    "  return 1 if prob >= .5 else 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classify(predictions):\n",
    "#   decision_boundary = np.vectorize(decision_boundary)\n",
    "  return decision_boundary(predictions).flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=[10, 20, 30, 40, 50, 60, 70]\n",
    "yy=[0, 0, 0, 1, 1, 1, 1]\n",
    "xx=[ [1.0, float(ix) ] for ix in x]\n",
    "xxx=np.array(xx)\n",
    "yyy=np.array(yy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1.  10.]\n",
      " [  1.  20.]\n",
      " [  1.  30.]\n",
      " [  1.  40.]\n",
      " [  1.  50.]\n",
      " [  1.  60.]\n",
      " [  1.  70.]]\n",
      "[0 0 0 1 1 1 1]\n"
     ]
    }
   ],
   "source": [
    "X=xxx\n",
    "y=yyy\n",
    "\n",
    "print X\n",
    "print y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some problem with python2 not in 3 why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References\n",
    "\n",
    "1. [pat obi] https://www.youtube.com/watch?v=ODKnSvELXbg\n",
    "2. [odds, statequest] https://www.youtube.com/watch?v=ARfXDSkQf1Y\n",
    "3. [statequest] https://www.youtube.com/watch?v=yIYKR4sgzI8\n",
    "4. [Andrew NG] https://www.youtube.com/watch?v=-la3q9d7AKQ\n",
    "5. https://medium.com/@anishsingh20/logistic-regression-in-python-423c8d32838b\n",
    "6. [scikit-learn example on digit recog.] https://towardsdatascience.com/logistic-regression-using-python-sklearn-numpy-mnist-handwriting-recognition-matplotlib-a6b31e2b166a\n",
    "7. [good understanding on logit function, LHS=RHS ] https://towardsdatascience.com/logit-of-logistic-regression-understanding-the-fundamentals-f384152a33d1\n",
    "8. [code, good, no explan on los] https://medium.com/@martinpella/logistic-regression-from-scratch-in-python-124c5636b8ac\n",
    "9. [very very good] https://ml-cheatsheet.readthedocs.io/en/latest/logistic_regression.html\n",
    "10. [How does it work? the way desribed here?] https://becominghuman.ai/logistic-regression-in-python-from-scratch-954c0196d258\n",
    "11. [loss function, very good] https://ml-cheatsheet.readthedocs.io/en/latest/loss_functions.html#loss-cross-entropy\n",
    "12. [great, derivative of sigmoid] https://math.stackexchange.com/questions/78575/derivative-of-sigmoid-function-sigma-x-frac11e-x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}