06. Optimization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class Overview\n",
    "<img src=\"PDF_slides/class_overview.png\"  width=\"500\">\n",
    "\n",
    "\n",
    "___\n",
    "# Agenda\n",
    " - Numerical Optimization Techniques\n",
    "  - Types of Optimization\n",
    "  - Programming the Optimization\n",
    " - **Whirlwind Lecture Alert**\n",
    "  - Entire classes cover these concepts in expanded form\n",
    "  - But we can cover them in one lecture to get a good intuition!\n",
    "  - And then you can look over this even more for better understanding.\n",
    "  - If you feel confused after this lecture, that's okay. These are not easy the first time you see them. Keep going, you got this.\n",
    "  \n",
    "<img src=\"PDF_slides/dont-be-nervous-you-got-this-meme.jpg\"  width=\"300\">\n",
    "\n",
    "\n",
    "    \n",
    "___\n",
    "\n",
    "# Last Time\n",
    "\n",
    "|Description| Equations, Derivations, Hessian Calculations, and Miscellaneous|\n",
    "|-----------|--------|\n",
    "| Sigmoid Definition | $$ p(y^{(i)}=1\\text{ | }\\mathbf{x}^{(i)},\\mathbf{w})=\\frac{1}{1+\\exp{(-\\mathbf{w}^T \\mathbf{x}^{(i)}})}$$ |\n",
    "| Log Likelihood | $$ l(\\mathbf{w}) = \\sum_i \\left( y^{(i)} \\ln [g(\\mathbf{w}^T \\mathbf{x}^{(i)})] + (1-y^{(i)}) (\\ln [1 - g(\\mathbf{w}^T \\mathbf{x}^{(i)})])  \\right)  $$ |\n",
    "| Vectorized Gradient | $$gradient = \\nabla l(\\mathbf{w}) =\\frac{1}{M}\\sum_{i=1}^M (y^{(i)}-g(\\mathbf{w}^T\\mathbf{x}^{(i)}))\\mathbf{x}^{(i)}$$ |\n",
    "| Regularization | $$ \\mathbf{w} \\leftarrow \\mathbf{w} + \\eta \\left[\\underbrace{\\nabla l(\\mathbf{w})_{old}}_{\\text{old gradient}} - C \\cdot 2\\mathbf{w} \\right]$$|\n",
    "\n",
    "___"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "import numpy as np\n",
    "from sklearn.metrics import accuracy_score\n",
    "from scipy.special import expit\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "ds = load_iris()\n",
    "X = ds.data\n",
    "y = (ds.target>1).astype(int) # make problem binary\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y, train_size = 0.8, test_size=0.2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Binary Logistic Regression Object with coefficients:\n",
      "[[-0.20089197]\n",
      " [-0.4670883 ]\n",
      " [-0.51457683]\n",
      " [ 0.7630656 ]\n",
      " [ 0.5081168 ]]\n",
      "Accuracy of:  1.0\n",
      "CPU times: user 5.03 ms, sys: 2.84 ms, total: 7.87 ms\n",
      "Wall time: 7.99 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# from last time, our logistic regression algorithm is given by (including everything we previously had):\n",
    "class BinaryLogisticRegression:\n",
    "    def __init__(self, eta, iterations=20, C=0.001):\n",
    "        self.eta = eta\n",
    "        self.iters = iterations\n",
    "        self.C = C\n",
    "        # internally we will store the weights as self.w_ to keep with sklearn conventions\n",
    "        \n",
    "    def __str__(self):\n",
    "        if(hasattr(self,'w_')):\n",
    "            return 'Binary Logistic Regression Object with coefficients:\\n'+ str(self.w_) # is we have trained the object\n",
    "        else:\n",
    "            return 'Untrained Binary Logistic Regression Object'\n",
    "        \n",
    "    # convenience, private:\n",
    "    @staticmethod\n",
    "    def _add_bias(X):\n",
    "        return np.hstack((np.ones((X.shape[0],1)),X)) # add bias term\n",
    "    \n",
    "    @staticmethod\n",
    "    def _sigmoid(theta):\n",
    "        # increase stability, redefine sigmoid operation\n",
    "        return expit(theta) #1/(1+np.exp(-theta))\n",
    "    \n",
    "    # vectorized gradient calculation with regularization using L2 Norm\n",
    "    def _get_gradient(self,X,y):\n",
    "        ydiff = y-self.predict_proba(X,add_bias=False).ravel() # get y difference\n",
    "        gradient = np.mean(X * ydiff[:,np.newaxis], axis=0) # make ydiff a column vector and multiply through\n",
    "        \n",
    "        gradient = gradient.reshape(self.w_.shape)\n",
    "        gradient[1:] += -2 * self.w_[1:] * self.C\n",
    "        \n",
    "        return gradient\n",
    "    \n",
    "    # public:\n",
    "    def predict_proba(self,X,add_bias=True):\n",
    "        # add bias term if requested\n",
    "        Xb = self._add_bias(X) if add_bias else X\n",
    "        return self._sigmoid(Xb @ self.w_) # return the probability y=1\n",
    "    \n",
    "    def predict(self,X):\n",
    "        return (self.predict_proba(X)>0.5) #return the actual prediction\n",
    "    \n",
    "    \n",
    "    def fit(self, X, y):\n",
    "        Xb = self._add_bias(X) # add bias term\n",
    "        num_samples, num_features = Xb.shape\n",
    "        \n",
    "        self.w_ = np.zeros((num_features,1)) # init weight vector to zeros\n",
    "        \n",
    "        # for as many as the max iterations\n",
    "        for _ in range(self.iters):\n",
    "            gradient = self._get_gradient(Xb,y)\n",
    "            self.w_ += gradient*self.eta # multiply by learning rate \n",
    "            # add bacause maximizing \n",
    "\n",
    "blr = BinaryLogisticRegression(eta=0.1,iterations=50,C=0.001)\n",
    "\n",
    "blr.fit(X_train,y_train)\n",
    "print(blr)\n",
    "\n",
    "yhat = blr.predict(X_test)\n",
    "print('Accuracy of: ',accuracy_score(y_test,yhat))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<img src=\"PDF_slides/BtJXjJcCAAE7QOB.jpg\"  width=\"300\">\n",
    "\n",
    "# More Advanced  Optimization for Machine Learning\n",
    "\n",
    "## Problem One: finding the right eta\n",
    "From previous notebooks, we know that the logistic regression update equation is given by:\n",
    "\n",
    "$$ \\underbrace{w_j}_{\\text{new value}} \\leftarrow \\underbrace{w_j}_{\\text{old value}} + \\eta \\underbrace{\\left[\\left(\\sum_{i=1}^M (y^{(i)}-g(\\mathbf{w}^T\\mathbf{x}^{(i)}))x^{(i)}_j\\right) - C \\cdot 2w_j \\right]}_{\\nabla l(w)}$$\n",
    "\n",
    "Which can be made into more generic notation by denoting the objective function as $l(\\mathbf{w})$ and the gradient calculation as $\\nabla$:\n",
    "$$ \\mathbf{w} \\leftarrow \\mathbf{w} + \\eta \\nabla l(\\mathbf{w})$$\n",
    "\n",
    "One problem is that we still need to set the value of $\\eta$, which can drastically change the performance of the optimization algorithm. If $\\eta$ is too large, the algorithm might be unstable. If $\\eta$ is too small, it might take a long time (i.e., many iterations) to converge.\n",
    "\n",
    "\n",
    "<img src=\"PDF_slides/batch.gif\"  width=\"400\">\n",
    "\n",
    "## Optimizing Logistic Regression via Line Search\n",
    "We can solve this issue by performing a line search for the best value of $\\eta$ along the direction of the gradient.\n",
    "\n",
    "$$ \\mathbf{w} \\leftarrow \\mathbf{w} + \\underbrace{\\eta}_{\\text{best step?}} \\nabla l(\\mathbf{w}) $$\n",
    "\n",
    "$$ \\eta \\leftarrow \\arg\\max_\\eta l(\\mathbf{w}+\\eta\\cdot\\nabla l(\\mathbf{w})) $$\n",
    "\n",
    "<img src=\"PDF_slides/line_search copy.gif\"  width=\"400\">\n",
    "\n",
    "\n",
    "We can also use the golden section search to find the best value of the line we are interested in searching along, such that objective function calculations are minimized:\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/6/68/Diagram_of_a_golden_section_search.jpg\" width=\"400\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Binary Logistic Regression Object with coefficients:\n",
      "[[-1.00164139]\n",
      " [-2.35775886]\n",
      " [-3.12998561]\n",
      " [ 4.18857275]\n",
      " [ 2.4959703 ]]\n",
      "Accuracy of:  1.0\n",
      "CPU times: user 11 ms, sys: 3.74 ms, total: 14.8 ms\n",
      "Wall time: 13 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# and we can update this to use a line search along the gradient like this:\n",
    "from scipy.optimize import minimize_scalar\n",
    "import copy\n",
    "from numpy import ma # (masked array) this has most numpy functions that work with NaN data.\n",
    "class LineSearchLogisticRegression(BinaryLogisticRegression):\n",
    "    \n",
    "    # define custom line search for problem\n",
    "    def __init__(self, line_iters=0.0, **kwds):        \n",
    "        self.line_iters = line_iters\n",
    "        # but keep other keywords\n",
    "        super().__init__(**kwds) # call parent initializer\n",
    "    \n",
    "    # this defines the function with the first input to be optimized\n",
    "    # therefore eta will be optimized, with all inputs constant\n",
    "    @staticmethod\n",
    "    def objective_function(eta,X,y,w,grad,C):\n",
    "        wnew = w - grad*eta\n",
    "        g = expit(X @ wnew)\n",
    "        # the line search is looking for minimization, so take the negative of l(w)\n",
    "        return -np.sum(ma.log(g[y==1]))-ma.sum(ma.log(1-g[y==0])) + C*sum(wnew[1:]**2)\n",
    "    \n",
    "        \n",
    "    def fit(self, X, y):\n",
    "        Xb = self._add_bias(X) # add bias term\n",
    "        num_samples, num_features = Xb.shape\n",
    "        \n",
    "        self.w_ = np.zeros((num_features,1)) # init weight vector to zeros\n",
    "        \n",
    "        # for as many as the max iterations\n",
    "        for _ in range(self.iters):\n",
    "            gradient = -self._get_gradient(Xb,y)\n",
    "            # minimization is in opposite direction\n",
    "            \n",
    "            # do line search in gradient direction, using scipy function\n",
    "            opts = {'maxiter':self.line_iters} # unclear exactly what this should be\n",
    "            res = minimize_scalar(self.objective_function, # objective function to optimize\n",
    "                                  bounds=(0,self.eta*10), #bounds to optimize\n",
    "                                  args=(Xb,y,self.w_,gradient,self.C), # additional argument for objective function\n",
    "                                  method='bounded', # bounded optimization for speed\n",
    "                                  options=opts) # set max iterations\n",
    "            \n",
    "            eta = res.x # get optimal learning rate\n",
    "            self.w_ -= gradient*eta # set new function values\n",
    "            # subtract to minimize\n",
    "                \n",
    "            \n",
    "\n",
    "lslr = LineSearchLogisticRegression(eta=1.0,\n",
    "                                    iterations=6, \n",
    "                                    line_iters=8, \n",
    "                                    C=0.001)\n",
    "\n",
    "lslr.fit(X_train,y_train)\n",
    "\n",
    "yhat = lslr.predict(X_test)\n",
    "print(lslr)\n",
    "print('Accuracy of: ',accuracy_score(y_test,yhat))         "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This performs well, but was not too much faster than previously (this is because $\\eta$ was chosen well in the initial example). \n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Self Test\n",
    "How much computation (i.e., how many multiplies) are required for calculating the gradient of:\n",
    "$$ \\left( \\frac{1}{M}\\left[\\sum_{i=1}^M (y^{(i)}-g(\\mathbf{w}^T\\cdot\\mathbf{x}^{(i)}))\\cdot \\mathbf{x}^{(i)}\\right] - 2C\\cdot \\mathbf{w}\\right) $$\n",
    "\n",
    "Where $M$ is the number of instance and $N$ is the number of elements in $\\mathbf{w}$.\n",
    "\n",
    "- A: $ M\\cdot N+1$\n",
    "- B: $ 2\\cdot M \\cdot N+ N$\n",
    "- C: $ 2N $ \n",
    "- D: $ 2N-M$ \n",
    "_____\n",
    "\n",
    "# Stochastic Gradient Descent (Mini-batching)\n",
    "Sometimes the gradient calculation is too computational:\n",
    "$$ \\mathbf{w} \\leftarrow \\mathbf{w} + \\eta\\left( \\frac{1}{M}\\left[\\sum_{i=1}^M (y^{(i)}-g(\\mathbf{w}^T\\mathbf{x}^{(i)}))\\mathbf{x}^{(i)}\\right] - 2C\\cdot \\mathbf{w}\\right) $$\n",
    "\n",
    "Instead, we can approximate the gradient using a smaller number of instances (perhaps even just one instance), this is called stochastic gradient descent (SGD) because the steps can appear somewhat random.\n",
    "\n",
    "For a single instance, this becomes: \n",
    "\n",
    "$$ \\mathbf{w} \\leftarrow \\mathbf{w} + \\eta \\underbrace{\\left((y^{(i)}-g(\\mathbf{w}^T\\mathbf{x}^{(i)}))\\mathbf{x}^{(i)}-2C\\cdot \\mathbf{w}\\right)}_{\\text{approx. gradient}} \\text{,   where   } i\\in M$$\n",
    "\n",
    "<img src=\"PDF_slides/SGD.gif\"  width=\"400\">\n",
    "\n",
    "For a small batch (mini-batch) of samples, this becomes:\n",
    "$$ \\mathbf{w} \\leftarrow \\mathbf{w} + \\eta\\left( \\frac{1}{M_{sub}}\\left[\\sum_{i\\in M_{sub}} (y^{(i)}-g(\\mathbf{w}^T\\mathbf{x}^{(i)}))\\mathbf{x}^{(i)}\\right] - 2C\\cdot \\mathbf{w}\\right) $$\n",
    "\n",
    "Let's code up the SGD example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Binary Logistic Regression Object with coefficients:\n",
      "[[-0.06384544]\n",
      " [-0.16011584]\n",
      " [-0.19443504]\n",
      " [ 0.24273753]\n",
      " [ 0.14941267]]\n",
      "Accuracy of:  0.7666666666666667\n",
      "CPU times: user 4.66 ms, sys: 1.75 ms, total: 6.41 ms\n",
      "Wall time: 5.38 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "class StochasticLogisticRegression(BinaryLogisticRegression):\n",
    "    # stochastic gradient calculation \n",
    "    def _get_gradient(self,X,y):\n",
    "        \n",
    "        # grab a subset of samples in a mini-batch\n",
    "        # and calculate the gradient according to the small batch only\n",
    "        mini_batch_size = 16\n",
    "        idxs = np.random.choice(len(y), mini_batch_size)\n",
    "        \n",
    "        ydiff = y[idxs]-self.predict_proba(X[idxs],add_bias=False).ravel() # get y difference (now scalar)\n",
    "        gradient = np.mean(X[idxs] * ydiff[:,np.newaxis], axis=0) # make ydiff a column vector and multiply through\n",
    "        \n",
    "        gradient = gradient.reshape(self.w_.shape)\n",
    "        gradient[1:] += -2 * self.w_[1:] * self.C\n",
    "        \n",
    "        return gradient\n",
    "    \n",
    "    \n",
    "slr = StochasticLogisticRegression(eta=0.01, iterations=100, C=0.001) # take a lot more steps!!\n",
    "\n",
    "slr.fit(X_train,y_train)\n",
    "\n",
    "yhat = slr.predict(X_test)\n",
    "print(slr)\n",
    "print('Accuracy of: ',accuracy_score(y_test,yhat))      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "\n",
    "\n",
    "\n",
    "<img src=\"PDF_slides/hessian_second.jpg\"  width=\"300\">\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Optimizing with Second Order Derivatives\n",
    "First, let's look at the one dimensional case when we have a function $l(w)$ where w is a scalar. The optimal value of w is given by:\n",
    "\n",
    "$$ w_{optimal} \\leftarrow w_{start} - \\underbrace{[\\frac{\\partial^2}{\\partial w}l(w_{start})]^{-1}}_{\\text{inverse 2nd deriv}}\\underbrace{\\frac{\\partial}{\\partial w}l(w_{start})}_{\\text{derivative}}  $$\n",
    "\n",
    "Note that if $l(w)$ is a quadratic function, this solution converges in a single step!\n",
    "\n",
    "\n",
    "**Aside: an example with the second derivative:**\n",
    "- Say $l(w)=2w^2+4w+5$, and we want to minimize the function. We have that:\n",
    "- $\\frac{\\partial}{\\partial w}l(w)=4w+4$\n",
    "- $\\frac{\\partial^2}{\\partial w}l(w)=4$\n",
    "- Therefore, if we choose $w_{start}=0$, we have:\n",
    "- $\\frac{\\partial}{\\partial w}l(0)=4$\n",
    "- $\\frac{\\partial^2}{\\partial w}l(0)=4$ \n",
    "- So the update becomes\n",
    "- $w \\leftarrow w_{start} - \\frac{1}{4}4 = -1$\n",
    "- The solution is found in one step. This works for any initial value of $w_{start}$. Let's verify that the solution worked graphically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(-1, 2.5, '$\\\\leftarrow$found minimum')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.style.use('ggplot')\n",
    "\n",
    "w = np.linspace(-7,5,100)\n",
    "l = 2*w**2+4*w+5\n",
    "plt.plot(w,l)\n",
    "plt.text(-1,2.5,'$\\leftarrow$found minimum',fontsize=14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "\n",
    "\n",
    "# Newton's Update Method\n",
    "<img src=\"PDF_slides/newton.png\"  width=\"600\">\n",
    "\n",
    "But how do we translate this over to objective funtions with more than one variable? We need a second derivative of a multivariate equation... enter, the hessian. Our new update is defined by Newton's method:\n",
    "\n",
    "$$ w \\leftarrow w - \\underbrace{[\\frac{\\partial^2}{\\partial w}l(w)]^{-1}}_{\\text{inverse 2nd deriv}}\\underbrace{\\frac{\\partial}{\\partial w}l(w)}_{\\text{derivative}}  $$\n",
    "\n",
    "such that, in multiple dimensions we can approximate the update as:\n",
    "\n",
    "$$ \\mathbf{w} \\leftarrow \\mathbf{w} + \\eta \\cdot \\underbrace{\\mathbf{H}(\\mathbf{w})^{-1}}_{\\text{inverse Hessian}}\\cdot\\underbrace{\\nabla l(\\mathbf{w})}_{\\text{gradient}}$$\n",
    "\n",
    "where the Hessian is defined as follows for any multivariate equation $l(\\mathbf{w})$:\n",
    "$$ \\nabla^2 l(\\mathbf{w}) = \\mathbf{H}(\\mathbf{w})   $$\n",
    "\n",
    "$$  \\mathbf{H}(\\mathbf{w}) =  \\begin{bmatrix}\n",
    "        \\frac{\\partial^2}{\\partial w_1}l(\\mathbf{w}), &  \\frac{\\partial}{\\partial w_1}\\frac{\\partial}{\\partial w_2}l(\\mathbf{w}), & \\ldots     & \\frac{\\partial}{\\partial w_1}\\frac{\\partial}{\\partial w_N}l(\\mathbf{w})  \\\\\n",
    "        \\frac{\\partial}{\\partial w_2}\\frac{\\partial}{\\partial w_1}l(\\mathbf{w}),  & \\frac{\\partial^2}{\\partial w_2}l(\\mathbf{w}), &  \\ldots     & \\frac{\\partial}{\\partial w_2}\\frac{\\partial}{\\partial w_N}l(\\mathbf{w})  \\\\\n",
    "        &  \\vdots &\\\\\n",
    "        \\frac{\\partial}{\\partial w_N}\\frac{\\partial}{\\partial w_1}l(\\mathbf{w}),  & \\frac{\\partial}{\\partial w_N}\\frac{\\partial}{\\partial w_2}l(\\mathbf{w}), &  \\ldots     & \\frac{\\partial^2}{\\partial w_N}l(\\mathbf{w}) \\\\\n",
    "     \\end{bmatrix}\n",
    "$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____\n",
    "For logistic regression, we can calculate the formula for the $j^{th}$ and $k^{th}$ element of the Hessian as follows:\n",
    "\n",
    "$$ \\mathbf{H}_{j,k}(\\mathbf{w}) = \\frac{\\partial}{\\partial w_k} \\underbrace{\\frac{\\partial}{\\partial w_j}l(\\mathbf{w})}_{\\text{first derivative}} $$\n",
    "\n",
    "Since this second partial derivative is identical regardless of the ordering of derivatives taken, the Hessian is also symmetric about the diagonal:\n",
    "\n",
    "<img src=\"PDF_slides/spider_hessian.png\"  width=\"400\">\n",
    "\n",
    "\n",
    "But we already know the result of the $j^{th}$ partial derivative from our calculation of $\\nabla l(\\mathbf{w})$: \n",
    "\n",
    "$$ \\frac{\\partial}{\\partial w_j}l(\\mathbf{w}) = \\sum_i \\left(y^{(i)}-g(\\mathbf{w}^T\\cdot\\mathbf{x}^{(i)})\\right)x_j^{(i)} $$\n",
    "\n",
    "So we can plug this back into the equation to get:\n",
    "\n",
    "$$ \n",
    "\\begin{split}\n",
    "\\mathbf{H}_{j,k}(\\mathbf{w}) & = \\frac{\\partial}{\\partial w_k}\\sum_i \\left(y^{(i)}-g(\\mathbf{w}^T\\cdot\\mathbf{x}^{(i)})\\right)x_j^{(i)} \\\\\n",
    " & = \\underbrace{\\sum_i \\frac{\\partial}{\\partial w_k} y^{(i)}x_j^{(i)}}_{\\text{no dependence on }k\\text{, zero}} -\\sum_i \\frac{\\partial}{\\partial w_k}g(\\mathbf{w}^T\\cdot\\mathbf{x}^{(i)})x_j^{(i)} \\\\\n",
    " & = -\\sum_i x_j^{(i)}\\underbrace{\\frac{\\partial}{\\partial w_k}g(\\mathbf{w}^T\\cdot\\mathbf{x}^{(i)})}_{\\text{already know this as }g(1-g)x_k} \\\\\n",
    " & =  -\\sum_{i=1}^M \\left[g(\\mathbf{w}^T\\mathbf{x}^{(i)})[1-g(\\mathbf{w}^T\\mathbf{x}^{(i)})]\\right]\\cdot{x_k}^{(i)}{x_j}^{(i)} \\\\\n",
    "\\end{split}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "Therefore the Hessian for logistic regression becomes (adding in the regularization term also):\n",
    "$$ \\mathbf{H}_{j,k}(\\mathbf{w}) =\\left( -\\sum_{i=1}^M \\underbrace{\\left[g(\\mathbf{w}^T\\mathbf{x}^{(i)})[1-g(\\mathbf{w}^T\\mathbf{x}^{(i)})]\\right]}_{\\text{scalar value for each instance}}\\cdot\\underbrace{{x_k}^{(i)}{x_j}^{(i)}}_{i^{th}\\text{ instance elements}} \\right) + \\underbrace{2\\cdot C}_{\\text{regularization}}  $$\n",
    "\n",
    "\n",
    "This equation can be calcuated in a for loop, for each $j,k$ element in the Hessian and for each instance in the dataset, but this would be **slow** in python. To vectorize this operation, we need to have each operation be linear algebra, so that it can be run efficiently with numpy. \n",
    "____\n",
    "## Calculating the Hessian for Logistic Regression using Linear Algebra\n",
    "First notice that the sum of each terms ${x_k}^{(i)}{x_j}^{(i)}$ that forms a matrix can be calculated as follows:\n",
    "\n",
    "$$    \n",
    "\\begin{bmatrix}\n",
    "        \\sum_{i=1}^M {x_1}^{(i)}{x_1}^{(i)}, & \\sum_{i=1}^M {x_1}^{(i)}{x_2}^{(i)}, & \\ldots     &  \\sum_{i=1}^M {x_1}^{(i)}{x_N}^{(i)}, \\\\\n",
    "        \\sum_{i=1}^M {x_2}^{(i)}{x_1}^{(i)}, & \\sum_{i=1}^M {x_2}^{(i)}{x_2}^{(i)}, & \\ldots     &  \\sum_{i=1}^M {x_2}^{(i)}{x_N}^{(i)}, \\\\\n",
    "        &  \\vdots & \\\\\n",
    "        \\sum_{i=1}^M {x_N}^{(i)}{x_1}^{(i)}, & \\sum_{i=1}^M {x_N}^{(i)}{x_2}^{(i)}, & \\ldots     &  \\sum_{i=1}^M {x_N}^{(i)}{x_N}^{(i)} \\\\ \\\\\n",
    "\\end{bmatrix}   \n",
    "%\n",
    "= \\mathbf{X}^T \\cdot\\mathbf{X} = \\mathbf{X}^T \\cdot\\mathbf{I} \\cdot\\mathbf{X}\n",
    "$$\n",
    "\n",
    "where $\\mathbf{I}$ is the identity matrix of size $M\\text{x}M$. This can be seen in the following exploded view of the matrix operations: \n",
    "\n",
    "$$ \\mathbf{X}^T \\cdot\\mathbf{I} \\cdot\\mathbf{X}=\n",
    "\\begin{bmatrix}\n",
    "        \\uparrow &    \\uparrow    &    & \\uparrow  \\\\\n",
    "        \\mathbf{x}^{(1)} &  \\mathbf{x}^{(2)} & \\ldots   & \\mathbf{x}^{(M)}  \\\\\n",
    "        \\downarrow &    \\downarrow    &   & \\downarrow  \\\\\n",
    "\\end{bmatrix}_{(N\\times M)}\n",
    "%\n",
    "\\begin{bmatrix}\n",
    "        1 &  0 & \\ldots & 0 \\\\\n",
    "        0 &  1 & \\ldots & 0 \\\\\n",
    "          &  \\vdots  & &    \\\\\n",
    "        0 &  0 & \\ldots & 1 \\\\\n",
    "\\end{bmatrix}_{(M\\times M)}\n",
    "%\n",
    "\\begin{bmatrix}\n",
    "        \\leftarrow &  \\mathbf{x}^{(1)}      & \\rightarrow  \\\\\n",
    "        \\leftarrow &  \\mathbf{x}^{(2)}      & \\rightarrow  \\\\\n",
    "        &  \\vdots &\\\\\n",
    "        \\leftarrow &  \\mathbf{x}^{(M)}      & \\rightarrow  \\\\\n",
    "\\end{bmatrix}_{(M\\times N)}\n",
    "%\n",
    "$$\n",
    "\n",
    "With this equation in mind, we can revisit the calcualtion of the Hessian and use matrix operations to define the needed multiplication in an exploded view of the operations:\n",
    "$$ \\mathbf{H}[\\mathbf{w}]= $$\n",
    "$$ \n",
    "\\begin{bmatrix}\n",
    "        \\uparrow &    \\uparrow    &    & \\uparrow  \\\\\n",
    "        \\mathbf{x}^{(1)} &  \\mathbf{x}^{(2)} & \\ldots   & \\mathbf{x}^{(M)}  \\\\\n",
    "        \\downarrow &    \\downarrow    &   & \\downarrow  \\\\\n",
    "\\end{bmatrix}\n",
    "%\n",
    "\\begin{bmatrix}\n",
    "        g(\\mathbf{w}^T\\mathbf{x}^{(1)})[1-g(\\mathbf{w}^T\\mathbf{x}^{(1)})] & \\ldots & 0 \\\\\n",
    "          &  \\vdots   &    \\\\\n",
    "        0  & \\ldots & g(\\mathbf{w}^T\\mathbf{x}^{(M)})[1-g(\\mathbf{w}^T\\mathbf{x}^{(M)})] \\\\\n",
    "\\end{bmatrix}\n",
    "%\n",
    "\\begin{bmatrix}\n",
    "        \\leftarrow &  \\mathbf{x}^{(1)}      & \\rightarrow  \\\\\n",
    "        \\leftarrow &  \\mathbf{x}^{(2)}      & \\rightarrow  \\\\\n",
    "        &  \\vdots &\\\\\n",
    "        \\leftarrow &  \\mathbf{x}^{(M)}      & \\rightarrow  \\\\\n",
    "\\end{bmatrix}\n",
    "%\n",
    "$$\n",
    "\n",
    "___\n",
    "Or, more succinctly as follows (adding in the regularization term as well):\n",
    "\n",
    "$$ \\mathbf{H}[\\mathbf{w}] =  \\mathbf{X}^T \\cdot \\text{diag}\\left[g(\\mathbf{X}\\cdot\\mathbf{w})\\odot(1-g(\\mathbf{X}\\cdot\\mathbf{w}))\\right]\\cdot \\mathbf{X} -2C$$\n",
    "\n",
    "___\n",
    "\n",
    "Now we can place the Hessian derivation into the Newton Update Equation, like this:\n",
    "\n",
    "$$ \\mathbf{w} \\leftarrow \\mathbf{w} + \\eta \\cdot \\underbrace{\\mathbf{H}[\\mathbf{w}]^{-1}}_{\\text{inverse Hessian}}\\cdot\\underbrace{\\nabla l(\\mathbf{w})}_{\\text{gradient}}$$\n",
    "\n",
    "Adding in the exact equations for the Hessian and gradient, we can finally get:\n",
    "\n",
    "$$ \\mathbf{w} \\leftarrow \\mathbf{w} + \\eta \\cdot \\underbrace{\\left[\\mathbf{X}^T \\cdot \\text{diag}\\left[g(\\mathbf{X}\\cdot\\mathbf{w})\\odot(1-g(\\mathbf{X}\\cdot\\mathbf{w}))\\right] \\cdot \\mathbf{X} -2C \\right]^{-1} }_{\\text{inverse Hessian}} \\cdot \\underbrace{\\mathbf{X}\\odot y_{diff}}_{\\text{gradient}}$$\n",
    "\n",
    "\n",
    "You can see the full derivation of the Hessian in my hand written notes here also:\n",
    "- https://raw.githubusercontent.com/eclarson/MachineLearningNotebooks/master/PDF_Slides/HessianCalculation.pdf\n",
    "\n",
    "\n",
    "\n",
    "So let's code this up using numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Binary Logistic Regression Object with coefficients:\n",
      "[[-10.49245761]\n",
      " [ -1.13444874]\n",
      " [ -1.09525527]\n",
      " [  2.47576674]\n",
      " [  5.15314995]]\n",
      "Accuracy of:  1.0\n",
      "CPU times: user 2.02 ms, sys: 3.8 ms, total: 5.82 ms\n",
      "Wall time: 4.88 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# note to future (2024) Eric: call this get_dirtection, instead of gradient\n",
    "\n",
    "from numpy.linalg import pinv\n",
    "class HessianBinaryLogisticRegression(BinaryLogisticRegression):\n",
    "    # just overwrite gradient function\n",
    "    def _get_gradient(self,X,y):\n",
    "        g = self.predict_proba(X,add_bias=False).ravel() # get sigmoid value for all classes\n",
    "        hessian = X.T @ np.diag(g*(1-g)) @ X - 2 * self.C # calculate the hessian\n",
    "\n",
    "        ydiff = y-g # get y difference\n",
    "        gradient = np.sum(X * ydiff[:,np.newaxis], axis=0) # make ydiff a column vector and multiply through\n",
    "        gradient = gradient.reshape(self.w_.shape)\n",
    "        gradient[1:] += -2 * self.w_[1:] * self.C\n",
    "        \n",
    "        return pinv(hessian) @ gradient\n",
    "       \n",
    "hlr = HessianBinaryLogisticRegression(eta=1.0,\n",
    "                                      iterations=4,\n",
    "                                      C=0.001) # note that we need only a few iterations here\n",
    "\n",
    "hlr.fit(X_train,y_train)\n",
    "yhat = hlr.predict(X_test)\n",
    "print(hlr)\n",
    "print('Accuracy of: ',accuracy_score(y_test,yhat))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "### Can we still do better? Problems With the Hessian:\n",
    "Quadratic isn’t always a great assumption:\n",
    " - highly dependent on starting point\n",
    "  - jumps can get really random!\n",
    " - near saddle points, inverse hessian is unstable\n",
    " - hessian not always invertible… or invertible with enough numerical precision\n",
    " \n",
    "The Hessian can sometimes be ill formed for these problems and can also be highly computational. Thus, we prefer to approximate the Hessian, and approximate its inverse to better control the steps we make and directions we use.  \n",
    "\n",
    "<img src=\"PDF_slides/gru_hessian.jpg\"  width=\"400\">\n",
    "\n",
    "____\n",
    "\n",
    "# Quasi-Newton Methods\n",
    "In general:\n",
    " - Approximate the Hessian with something numerically sound and efficiently invertible \n",
    " - Back off to gradient descent when the approximate hessian is not stable\n",
    " - Try to create an approximation with as many properties of the Hessian as possible, like being symmetric and positive semi-definite\n",
    " - A popular approach: Rank One Hessian Approximation\n",
    " - An even more popular appraoch: Rank Two, with Broyden-Fletcher-Goldfarb-Shanno (BFGS)\n",
    "\n",
    "\n",
    "### Rank One Hessian Approximation \n",
    "Let's work our way up to using BFGS by first looking at one quasi-newton method, the rank one Hessian approximation. **Note, I only want you to get an intuition for this process. There is no requirenemtn to understand the derivation completely.**\n",
    "Essentially, we want to update the Hessian with an approximation that is easily invertible and based on stable gradient calculations. We can define the approximate Hessian for each iteration of the optimization, $\\mathbf{H}_k$. That is, we will be optimizing $\\mathbf{w}$ over a number of iterations, $k$. We refer to the evolving vector as $\\mathbf{w}_{k}$. Each time we update this quantity, we can also update our Hessian approximation, $\\mathbf{H}_k$.\n",
    "\n",
    "**To start as simple as possible, we will assume the Hessian can be approximated with one vector, often called the rank one approximation.** Let's start off with a few other assumptions. We wil develop some equations that characterize a family of solutions. Within this rank one family, we will only give one popular solution. After this, we will then motivate an example in the rank two family of solutions. \n",
    "\n",
    "___\n",
    "#### Step One: Use the secant equation\n",
    "One property of the hessian is called the Secant equation, which relates the change in input to the change in the derivative. The Secant Equation (exact for quadratic functions) is:\n",
    "$$ \\underbrace{\\mathbf{H}_{k+1}}_{\\text{approx. Hessian}} \\cdot\\underbrace{(\\mathbf{w}_{k+1} - \\mathbf{w}_k)}_{\\text{Change in }w} = \\underbrace{\\nabla l(\\mathbf{w}_{k+1}) - \\nabla l(\\mathbf{w}_k)}_{\\text{Change in gradient}}$$\n",
    "\n",
    "or, using intermediate variables for the differences: \n",
    "$$ \\mathbf{H}_{k+1} \\mathbf{s}_k =  \\mathbf{v}_k $$\n",
    "\n",
    "where $ \\mathbf{s} = (\\mathbf{w}_{k+1} - \\mathbf{w}_k) $ and $ \\mathbf{v} = (\\nabla l(\\mathbf{w}_{k+1}) - \\nabla l(\\mathbf{w}_k)) $, the difference in the gradient. If we enforce this relationship, we can solve for the hessian by calculating $\\mathbf{s}$ and $\\mathbf{v}$. We can also add some extra constraints since we want the Hessian to be symmetric and the next guess to be not \"too far away\" from our current guess (for stable optimization). Practically, this means that the new Hessian guess will be an average between the old value and our new guess, which is called momentum when performing optimization.\n",
    "\n",
    "___\n",
    "\n",
    "#### Step Two: Use the rank one update assumption\n",
    "For optimizing, we would like to be able to update the Hessian at $\\mathbf{w}_{k+1}$ from our previous guess, $\\mathbf{H}_k$ at $\\mathbf{w}_{k}$, and have the update be easy to calculate. Therefore, we can choose the update of the Hessian to be approximated by the rank one update (one vector). Since the Hessian is the second partial derivative, a starting approximation might be the gradient difference we already defined such that  $\\mathbf{H} \\approx \\mathbf{v}\\cdot\\mathbf{v}^T$ which would form a matrix of the differences of each partial deriviative in the gradient. In practice, we need a vector that is slightly less constrained, such that    \n",
    "$$ \\mathbf{H}_{k+1}=\\mathbf{H}_k+\\alpha_k\\mathbf{u}\\cdot\\mathbf{u}^T $$\n",
    "Where $\\mathbf{u}$ and $\\alpha_k$ can be anything we want. This gives us a general form for the approximation, but has too many solutions to be of practical use. So, let's combine this form with our secant equation from the previous step. \n",
    "\n",
    "Substituting back into the secant formula:\n",
    "$$ \\mathbf{H}_{k+1} \\mathbf{s}_k =  \\mathbf{v}_k \\qquad\\rightarrow\\qquad (\\mathbf{H}_k +\\alpha_k\\mathbf{u}_k\\cdot\\mathbf{u}_k^T)\\mathbf{s}_{k} = \\mathbf{v}_{k} $$\n",
    "\n",
    "\n",
    "Many solutions exist for this and they are referred to as a family of rank one Hessian approximations. One solution of this equation is to use the difference in our secant approximation. The intuition here is that we want to update the Hessian approximation more when the error from the secant equation is large. That is, if the Hessian approximation exactly matched the secant equation, its a good update and $\\alpha_k$ should be large. If the secant equation was poor, then we should not update our Hessian approximation too much, and $\\alpha_k$ should be smaller.   For example we can choose the following:\n",
    "$$ \\mathbf{u}_k=\\mathbf{v}_{k}-\\mathbf{H}_k \\mathbf{s}_{k} \\qquad\\text{   and   } \\qquad\\alpha_k=\\frac{1}{(\\mathbf{v}_{k}-\\mathbf{H}_k \\mathbf{s}_{k})\\mathbf{s}_{k}}=\\frac{1}{\\mathbf{u}_{k}^T\\mathbf{s}_{k}}$$\n",
    "\n",
    "___\n",
    "#### Step Three: Combine secant equation with rank one update for iterative solution\n",
    "and combining this with our initial $\\mathbf{H}_{k+1}$ formula:\n",
    "$$ \\mathbf{H}_{k+1}=\\mathbf{H}_k- \\frac{\\mathbf{u}_k\\mathbf{u}_k^T}{\\mathbf{u}_k^T\\mathbf{s}_{k}} $$\n",
    "\n",
    "This gives an update for the Hessian, which we can use in our optimization formula. Recall that we need to define the vectors using the secant equation assumptions, such that $ \\mathbf{v}_k $ and $ \\mathbf{s}_k $ are the difference in gradients and difference in weights (respectively) as previously defined.\n",
    "\n",
    "#### Step Four: Use Sherman-Morris to also iterative track the inverse of our rank one approximation\n",
    "**This final step illustrates the power of this method.** We can now assume that the inverse of the Hessian can be optimized and formulate similar equations for its update, based upon the previous inverse. Therefore, we need the inverse of $(\\mathbf{H}_k+\\mathbf{v}_k\\cdot\\mathbf{v}_k^T)^{-1}$, which *\"luckily\"* has a closed form solution according to the Sherman-Morrison formula:\n",
    "\n",
    "$$ (\\mathbf{A}+\\mathbf{a}\\cdot\\mathbf{a}^T)^{-1} = \\mathbf{A}^{-1} - \\frac{\\mathbf{A}^{-1} \\mathbf{a} \\cdot\\mathbf{a}^T\\mathbf{A}^{-1}}{1+\\mathbf{a}^T \\mathbf{A}^{-1} \\mathbf{a}}  $$\n",
    "\n",
    "We can now substitute $\\mathbf{H}_k$ and $\\mathbf{v}_k$ to get our inverse Hessian. This equation is the entire reason we first decided to approximate the Hessian using the rank one update equation! It means we can always calculate a stable inverse Hessian. Moreover, since we will always start our initial guess of the Hessian with the identity matrix, we never actually need to perform the inverse operation. Ever. \n",
    "\n",
    "___\n",
    "\n",
    "\n",
    "#### Summary of Rank One Approximation\n",
    "Now the optimization can be described as a rank one approximation of the Hessian. Placing it all together, we can get the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "|Description| Equations, Derivations, Hessian Calculations, and Miscellaneous |\n",
    "|-----------|--------|\n",
    "| **Definitions with Rank 1 Approximation** |  |\n",
    "|$$ \\mathbf{w} \\leftarrow \\mathbf{w} + \\eta \\cdot \\underbrace{\\mathbf{H}[l(\\mathbf{w})]^{-1}}_{\\text{inverse Hessian}}\\cdot\\underbrace{\\nabla l(\\mathbf{w})}_{\\text{gradient}}$$ |  |\n",
    "|1. Initial Approx. Hessian for $k=0$ is identity matrix| $$\\mathbf{H}_0=\\mathbf{I}$$, $$\\mathbf{H}_0^{-1}=\\mathbf{I}$$|\n",
    "|2. Find update direction, $\\mathbf{p}_k$ | $$ \\mathbf{p}_k = -\\mathbf{H}_k^{-1} \\nabla l(\\mathbf{w}_k) $$| \n",
    "|3. Update $\\mathbf{w}$|$$\\mathbf{w}_{k+1}\\leftarrow \\mathbf{w}_k + \\eta \\cdot \\mathbf{p}_k $$|\n",
    "|4. Save scaled direction ($\\mathbf{w}_{k+1}-\\mathbf{w}_k$)| $$\\mathbf{s}_k = \\mathbf{w}_{k+1}-\\mathbf{w}_k = \\eta \\cdot \\mathbf{p}_k $$ |\n",
    "|5a. Approximate change in derivative | $$\\mathbf{v}_k = \\nabla l(\\mathbf{w}_{k+1}) - \\nabla l(\\mathbf{w}_k) $$|\n",
    "| 5b. Define $\\mathbf{u}$ from above: | $$\\mathbf{u}_k=\\mathbf{v}_k-\\mathbf{H}_k\\mathbf{s}_k$$| \n",
    "|6. Redefine approx Hessian update| $$\\mathbf{H}_{k+1}=\\mathbf{H}_k+\\underbrace{\\frac{\\mathbf{u}_k \\mathbf{u}_k^T}{\\mathbf{u}_k^T \\mathbf{s}_k}}_{\\text{approx. Hessian}} $$ |\n",
    "|7. Approx. Inverse $\\mathbf{H}_{k+1}^{-1}$ via Sherman Morris| $$ \\mathbf{H}_{k+1}^{-1} = \\mathbf{H}_{k}^{-1} - \\frac{\\mathbf{H}_k^{-1} \\mathbf{u}_k \\mathbf{u}_k^T\\mathbf{H}_k^{-1}}{1+\\mathbf{u}_k^T \\mathbf{H}_k^{-1} \\mathbf{u}_k} $$ |\n",
    "| 8. Repeat starting at step 2| $$ k = k+1 $$| \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "### Rank Two Hessian Approximation: BFGS\n",
    "\n",
    "\n",
    "Although the rank one approximation is a good performer, it can be improved by adding some additional criteria to the Hessian approximation. In this case, we assume that the $\\mathbf{H}_k$ needs to also be positive semi-definite, which helps with numerical stability. One of the most popular quasi-Newton methods that does this is known as Broyden-Fletcher-Goldfarb-Shanno (BFGS). \n",
    "- https://en.wikipedia.org/wiki/Broyden–Fletcher–Goldfarb–Shanno_algorithm \n",
    "\n",
    "<img src=\"PDF_slides/bfgs_meme.png\"  width=\"300\">\n",
    "\n",
    "#### Replace Step two with a higher rank approximation of the Hessian\n",
    "In this formulation we add an additional vector matrix addition to the update equation that ensure the resulting matrix is positive semidefinite:\n",
    "$$ \\mathbf{H}_{k+1}=\\mathbf{H}_k+\\alpha_k\\mathbf{u}_k\\cdot\\mathbf{u}_k^T - \\beta_k\\mathbf{z}_k\\cdot\\mathbf{z}_k^T$$\n",
    "\n",
    "The derivation is intuitively similar to the previous rank one approximation. Again, there are many potential solutions, referred to as a family of rank two solutions. However, it becomes easier to obtain simple solutions for $\\mathbf{u}$ and $\\mathbf{z}$. Intuitively, we simply choose the difference in gradient for $\\mathbf{u}$ and we choose the secant equation for $\\mathbf{z}$. The BFGS solution takes the following form:\n",
    "$$ \\mathbf{u}_k = \\mathbf{v}_k  \\qquad \\text{    and    }\\qquad \\mathbf{z}_k=\\mathbf{H}_k \\mathbf{s}_k  $$\n",
    "\n",
    "We can again choose $\\alpha_k=\\frac{1}{\\mathbf{u}_{k}^T\\mathbf{s}_{k}}$ and choose $\\beta_k = \\frac{1}{\\mathbf{z}_{k}^T\\mathbf{s}_{k}}$. \n",
    "\n",
    "After substituiting in $\\alpha_k$ and $\\beta_k$ coefficients, we get the update equation as:\n",
    "$$  \\mathbf{H}_{k+1}=\\mathbf{H}_k+\\underbrace{\\frac{\\mathbf{v}_k \\mathbf{v}_k^T}{\\mathbf{v}_k^T \\mathbf{s}_k}}_{\\text{previous}} -\\underbrace{\\frac{\\mathbf{H}_k \\mathbf{s}_k \\mathbf{s}_k^T \\mathbf{H}_k}{\\mathbf{s}_k^T \\mathbf{H}_k \\mathbf{s}_k}}_{\\text{new}}  $$\n",
    "\n",
    "Intuitively, this equation updates the Hessian more when the secant equation is approximated well, meaning it is a safer update. That is, when the current Hessian is a good approximation, the difference in $\\mathbf{u}_{k}$ and $\\mathbf{z}_{k}$ will also be small. When inverted, $\\alpha_k$ and $\\beta_k$ become large such that Hessian update is mostly from the new calculations. Conversely, if these are not good approximations of the secant equation, we use smaller $\\alpha_k$ and $\\beta_k$ values. \n",
    "\n",
    "The complete formulation can replace steps from the previous rank update as follows:\n",
    "\n",
    "|Description| Equations, Derivations, Hessian Calculations, and Miscellaneous |\n",
    "|-----------|--------|\n",
    "| **Alternative Definitions with Rank 2 (BFGS)** |  |\n",
    "| 6. Redefine approx Hessian:| $$\\mathbf{H}_{k+1}=\\mathbf{H}_k+\\frac{\\mathbf{v}_k \\mathbf{v}_k^T}{\\mathbf{v}_k^T \\mathbf{s}_k} -\\frac{\\mathbf{H}_k \\mathbf{s}_k \\mathbf{s}_k^T \\mathbf{H}_k}{\\mathbf{s}_k^T \\mathbf{H}_k \\mathbf{s}_k} $$ |\n",
    "|7. Approximate Inverse $\\mathbf{H}_{k+1}^{-1}$ via Sherman Morris:| $$ \\mathbf{H}_{k+1}^{-1} = \\mathbf{H}_{k}^{-1} + \\frac{(\\mathbf{s}_k^T \\mathbf{v}_k+\\mathbf{H}_{k}^{-1})(\\mathbf{s}_k \\mathbf{s}_k^T)}{(\\mathbf{s}_k^T \\mathbf{v}_k)^2}-\\frac{\\mathbf{H}_{k}^{-1} \\mathbf{v}_k \\mathbf{s}_k^T+\\mathbf{s}_k \\mathbf{v}_k^T\\mathbf{H}_{k}^{-1}}{\\mathbf{s}_k^T \\mathbf{v}_k} $$|\n",
    "\n",
    "___\n",
    "We won't explicitly program the BFGS algorithm--instead we can take advantage of scipy's calculations to do it for us. For using this algorithm, we need to define the objective function and the gradient explicitly for another program to calculate. \n",
    "\n",
    "Recall that Logistic regression uses the following objective and gradient functions:\n",
    "\n",
    "$$ \\text{Objective} = l(\\mathbf{w}) = \\left(\\sum_i y^{(i)} \\ln g(\\mathbf{x}^{(i)}) + (1-y^{(i)})\\ln[1-g(\\mathbf{x}^{(i)})]\\right)  - C \\cdot \\sum_j w_j^2 $$\n",
    "\n",
    "and \n",
    "\n",
    "$$ \\text{Gradient} =\\nabla l(\\mathbf{w}) =\\text{mean}\\left( \\mathbf{X}\\odot \\mathbf{y}_{diff} \\right)_{columns} - 2\\cdot C \\cdot \\mathbf{w}$$\n",
    "\n",
    "we can use these calcualtion directly in the already implemented BFGS algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Binary Logistic Regression Object with coefficients:\n",
      "[[-0.1936976 ]\n",
      " [-0.44984547]\n",
      " [-0.58284252]\n",
      " [ 0.83413532]\n",
      " [ 0.50464717]]\n",
      "Accuracy of:  0.9666666666666667\n",
      "CPU times: user 4.44 ms, sys: 5.63 ms, total: 10.1 ms\n",
      "Wall time: 8 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# for this, we won't perform our own BFGS implementation \n",
    "# (it takes a fair amount of code and understanding, which we haven't setup yet)\n",
    "# luckily for us, scipy has its own BFGS implementation:\n",
    "from scipy.optimize import fmin_bfgs # maybe the most common bfgs algorithm in the world\n",
    "from numpy import ma\n",
    "class BFGSBinaryLogisticRegression(BinaryLogisticRegression):\n",
    "    \n",
    "    @staticmethod\n",
    "    def objective_function(w,X,y,C):\n",
    "        g = expit(X @ w)\n",
    "        # invert this because scipy minimizes, but we derived all formulas for maximzing\n",
    "        return -ma.sum(ma.log(g[y==1]))-ma.sum(ma.log(1-g[y==0])) + C*sum(w**2) \n",
    "        #-np.sum(y*np.log(g)+(1-y)*np.log(1-g))\n",
    "\n",
    "    @staticmethod\n",
    "    def objective_gradient(w,X,y,C):\n",
    "        g = expit(X @ w)\n",
    "        ydiff = y-g # get y difference\n",
    "        gradient = np.mean(X * ydiff[:,np.newaxis], axis=0)\n",
    "        gradient = gradient.reshape(w.shape)\n",
    "        gradient[1:] += -2 * w[1:] * C\n",
    "        return -gradient\n",
    "    \n",
    "    # just overwrite fit function\n",
    "    def fit(self, X, y):\n",
    "        Xb = self._add_bias(X) # add bias term\n",
    "        num_samples, num_features = Xb.shape\n",
    "        \n",
    "        self.w_ = fmin_bfgs(self.objective_function, # what to optimize\n",
    "                            np.zeros((num_features,1)), # starting point\n",
    "                            fprime=self.objective_gradient, # gradient function\n",
    "                            args=(Xb,y,self.C), # extra args for gradient and objective function\n",
    "                            gtol=1e-03, # stopping criteria for gradient, |v_k|\n",
    "                            maxiter=self.iters, # stopping criteria iterations\n",
    "                            disp=False)\n",
    "        \n",
    "        self.w_ = self.w_.reshape((num_features,1))\n",
    "            \n",
    "bfgslr = BFGSBinaryLogisticRegression(_,iterations=3,C=0.001) # note that we need only a few iterations here\n",
    "\n",
    "bfgslr.fit(X_train,y_train)\n",
    "yhat = bfgslr.predict(X_test)\n",
    "print(bfgslr)\n",
    "print('Accuracy of: ',accuracy_score(y_test,yhat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#str(bfgslr.eta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### BFGS and Newton's Method for Multiclass Logistic Regression\n",
    "Now let's add BFGS and the actual Hessian to non-binary classification. As before, we will use one-versus-all."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# allow for the user to specify the algorithm they want to solver the binary case\n",
    "class MultiClassLogisticRegression:\n",
    "    def __init__(self, eta, iterations=20, \n",
    "                 C=0.0001, \n",
    "                 solver=BFGSBinaryLogisticRegression):\n",
    "        self.eta = eta\n",
    "        self.iters = iterations\n",
    "        self.C = C\n",
    "        self.solver = solver\n",
    "        self.classifiers_ = []\n",
    "        # internally we will store the weights as self.w_ to keep with sklearn conventions\n",
    "    \n",
    "    def __str__(self):\n",
    "        if(hasattr(self,'w_')):\n",
    "            return 'MultiClass Logistic Regression Object with coefficients:\\n'+ str(self.w_) # is we have trained the object\n",
    "        else:\n",
    "            return 'Untrained MultiClass Logistic Regression Object'\n",
    "        \n",
    "    def fit(self,X,y):\n",
    "        num_samples, num_features = X.shape\n",
    "        self.unique_ = np.sort(np.unique(y)) # get each unique class value\n",
    "        num_unique_classes = len(self.unique_)\n",
    "        self.classifiers_ = []\n",
    "        for i,yval in enumerate(self.unique_): # for each unique value\n",
    "            y_binary = np.array(y==yval).astype(int) # create a binary problem\n",
    "            # train the binary classifier for this class\n",
    "            \n",
    "            hblr = self.solver(eta=self.eta,iterations=self.iters,C=self.C)\n",
    "            hblr.fit(X,y_binary)\n",
    "\n",
    "            # add the trained classifier to the list\n",
    "            self.classifiers_.append(hblr)\n",
    "            \n",
    "        # save all the weights into one matrix, separate column for each class\n",
    "        self.w_ = np.hstack([x.w_ for x in self.classifiers_]).T\n",
    "        \n",
    "    def predict_proba(self,X):\n",
    "        probs = []\n",
    "        for hblr in self.classifiers_:\n",
    "            probs.append(hblr.predict_proba(X).reshape((len(X),1))) # get probability for each classifier\n",
    "        \n",
    "        return np.hstack(probs) # make into single matrix\n",
    "    \n",
    "    def predict(self,X):\n",
    "        return self.unique_[np.argmax(self.predict_proba(X),axis=1)] # take argmax along row\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "\n",
    "ds = load_iris()\n",
    "X = ds.data\n",
    "\n",
    "#X = StandardScaler().fit(X).transform(X)\n",
    "y_not_binary = ds.target # note problem is NOT binary anymore, there are three classes!\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y_not_binary, train_size = 0.8, test_size=0.2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MultiClass Logistic Regression Object with coefficients:\n",
      "[[ 0.16316113  0.27437972  0.85986402 -1.32028647 -0.59101194]\n",
      " [-0.02377682 -0.09532089 -0.45496747  0.34436342  0.04052904]\n",
      " [-0.26635603 -0.60779384 -0.74390001  1.07238755  0.65805821]]\n",
      "Accuracy of:  0.9\n",
      "CPU times: user 7.04 ms, sys: 8.65 ms, total: 15.7 ms\n",
      "Wall time: 23.6 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "lr = MultiClassLogisticRegression(eta=1.0,\n",
    "                                  iterations=4,\n",
    "                                  C=0.01,\n",
    "                                  solver=BFGSBinaryLogisticRegression\n",
    "                                 )\n",
    "lr.fit(X_train,y_train)\n",
    "print(lr)\n",
    "\n",
    "yhat = lr.predict(X_test)\n",
    "print('Accuracy of: ',accuracy_score(y_test,yhat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MultiClass Logistic Regression Object with coefficients:\n",
      "[[ -9.99227088   1.03625383   5.02754055  -2.93868949  -3.31870145]\n",
      " [  9.4370063   -0.18274543  -3.44636186   1.33652335  -3.0697015 ]\n",
      " [-19.9052326   -2.31816951  -2.71099544   5.82862655   8.12728329]]\n",
      "Accuracy of:  0.8666666666666667\n",
      "CPU times: user 5.14 ms, sys: 7.02 ms, total: 12.2 ms\n",
      "Wall time: 9.03 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "lr = MultiClassLogisticRegression(eta=1.0,\n",
    "                                  iterations=6,\n",
    "                                  C=0.001,\n",
    "                                  solver=HessianBinaryLogisticRegression\n",
    "                                 )\n",
    "lr.fit(X_train,y_train)\n",
    "print(lr)\n",
    "\n",
    "yhat = lr.predict(X_test)\n",
    "print('Accuracy of: ',accuracy_score(y_test,yhat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0.98231986   3.96798279  -6.00518511  -2.66956243]\n",
      " [ -0.18290211  -3.44787709   1.33804985  -3.07388763]\n",
      " [ -6.77733256 -10.70656041  26.5191283   24.03374704]]\n",
      "Accuracy of:  0.9666666666666667\n",
      "CPU times: user 6.35 ms, sys: 5.84 ms, total: 12.2 ms\n",
      "Wall time: 10.9 ms\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/eclarson/miniconda3/envs/mlenv3_11/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1256: FutureWarning: 'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegression(..)) instead. Leave it to its default value to avoid this warning.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# how do we compare now to sklearn?\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "lr_sk = LogisticRegression(solver='lbfgs',n_jobs=1,\n",
    "                           multi_class='ovr', C = 1/0.001, \n",
    "                           penalty='l2',\n",
    "                          max_iter=50) # all params default\n",
    "# note that sklearn is optimized for using the liblinear library with logistic regression\n",
    "# ...and its faster than our implementation here\n",
    "\n",
    "lr_sk.fit(X_train, y_train) # no need to add bias term, sklearn does it internally!!\n",
    "print(lr_sk.coef_)\n",
    "yhat = lr_sk.predict(X_test)\n",
    "print('Accuracy of: ',accuracy_score(y_test,yhat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.97552955  4.21132851 -6.23813453 -2.9657076 ]\n",
      " [-0.17518032 -3.43276103  1.33669541 -3.07417841]\n",
      " [-8.96981805 -9.70635712 16.9505171  15.59705915]]\n",
      "Accuracy of:  0.9666666666666667\n",
      "CPU times: user 4.3 ms, sys: 921 μs, total: 5.22 ms\n",
      "Wall time: 5.16 ms\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/eclarson/miniconda3/envs/mlenv3_11/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1256: FutureWarning: 'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegression(..)) instead. Leave it to its default value to avoid this warning.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# actually, we aren't quite as good as the lib linear implementation\n",
    "# how do we compare now to sklearn?\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "lr_sk = LogisticRegression(solver='liblinear',n_jobs=1, \n",
    "                           multi_class='ovr', C = 1/0.001, \n",
    "                           penalty='l2',max_iter=100) \n",
    "\n",
    "lr_sk.fit(X_train,y_train) # no need to add bias term, sklearn does it internally!!\n",
    "print(lr_sk.coef_)\n",
    "yhat = lr_sk.predict(X_test)\n",
    "print('Accuracy of: ',accuracy_score(y_test,yhat))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Liblinear is a great toolkit for linear modeling (from National Taiwan University, NTU) and the paper can be found here:\n",
    "- https://www.csie.ntu.edu.tw/~cjlin/papers/liblinear.pdf\n",
    "\n",
    "Actually, this solves a slightly different problem (known as the 'dual' formulation because its a linear SVM) to make it extremely fast. So this is actually not a fair comparison to ours."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parallelization across Classes [if time]\n",
    "Is the formulation of multi-class logistic regression parallelizable? Is the optimization? Or the one versus all classification?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %%time\n",
    "# # its still faster! Can we fix it with parallelization?\n",
    "# from joblib import Parallel, delayed\n",
    "\n",
    "# class ParallelMultiClassLogisticRegression(MultiClassLogisticRegression):\n",
    "#     @staticmethod\n",
    "#     def par_logistic(yval,eta,iters,C,X,y,solver):\n",
    "#         y_binary = y==yval # create a binary problem\n",
    "#         # train the binary classifier for this class\n",
    "#         hblr = solver(eta=eta,iterations=iters,C=C)\n",
    "#         hblr.fit(X,y_binary)\n",
    "#         return hblr\n",
    "    \n",
    "#     def fit(self,X,y):\n",
    "#         num_samples, num_features = X.shape\n",
    "#         self.unique_ = np.sort(np.unique(y)) # get each unique class value\n",
    "#         num_unique_classes = len(self.unique_)\n",
    "#         backend = 'threading' # can also try 'multiprocessing'\n",
    "        \n",
    "#         self.classifiers_ = Parallel(n_jobs=-1,backend=backend)(\n",
    "#             delayed(self.par_logistic)(yval,self.eta,self.iters,self.C,X,y,self.solver) for yval in self.unique_)\n",
    "            \n",
    "#         # save all the weights into one matrix, separate column for each class\n",
    "#         self.w_ = np.hstack([x.w_ for x in self.classifiers_]).T\n",
    "        \n",
    "# plr = ParallelMultiClassLogisticRegression(eta=1,iterations=10,C=0.001,solver=HessianBinaryLogisticRegression)\n",
    "# plr.fit(X_train,y_train)\n",
    "# print(plr)\n",
    "\n",
    "# yhat = plr.predict(X_test)\n",
    "# print('Accuracy of: ',accuracy_score(y_test,yhat))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "Please note that the overhead of parallelization is not worth it for this problem!!\n",
    "\n",
    "**When would it make sense???**\n",
    "___\n",
    "\n",
    "\n",
    "<img src=\"PDF_slides/mark_scooter.png\"  width=\"300\">\n",
    "\n",
    "\n",
    "# Extended Logistic Regression Example\n",
    "\n",
    "In this example we will explore methods of using logistic regression in scikit-learn. A basic understanding of scikit-learn is required to complete this notebook, but we start very basic. Note also that there are more efficient methods of separating testing and training data, but we will leave that for a later lecture.\n",
    "\n",
    "First let's load a dataset and prepare it for analysis. We will use pandas to load in data, and then prepare it for classification. We will be using the titanic dataset (a very modest sized data set of about 1000 instances). The imputation methods used here are discussed in a previous notebook.\n",
    "\n",
    "Steps:\n",
    "- Load data, impute\n",
    "- One hot encode and normalize data\n",
    "- Separate into training and testing sets\n",
    "- Explore best hyper parameter, C\n",
    "\n",
    "\n",
    "## Load Titanic Data and Pre-process\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 882 entries, 0 to 890\n",
      "Data columns (total 8 columns):\n",
      " #   Column    Non-Null Count  Dtype  \n",
      "---  ------    --------------  -----  \n",
      " 0   Survived  882 non-null    int64  \n",
      " 1   Age       882 non-null    float64\n",
      " 2   Sex       882 non-null    object \n",
      " 3   Parch     882 non-null    int64  \n",
      " 4   SibSp     882 non-null    int64  \n",
      " 5   Pclass    882 non-null    int64  \n",
      " 6   Fare      882 non-null    float64\n",
      " 7   Embarked  882 non-null    object \n",
      "dtypes: float64(2), int64(4), object(2)\n",
      "memory usage: 62.0+ KB\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "df = pd.read_csv('data/titanic.csv') # read in the csv file\n",
    "\n",
    "# 1. Remove attributes that just arent useful for us\n",
    "del df['PassengerId']\n",
    "del df['Name']\n",
    "del df['Cabin']\n",
    "del df['Ticket']\n",
    "\n",
    "# 2. Impute some missing values, grouped by their Pclass and SibSp numbers\n",
    "df_grouped = df.groupby(by=['Pclass','SibSp'])\n",
    "\n",
    "# # now use this grouping to fill the data set in each group, then transform back\n",
    "# fill in the numeric values\n",
    "numeric_columns = ['Survived','Age','Parch','SibSp','Pclass','Fare'] # only transform numeric columns\n",
    "df_imputed = df_grouped[numeric_columns].transform(lambda grp: grp.fillna(grp.median()))\n",
    "# Extra step: fill any object columns that could not be transformed\n",
    "col_deleted = list( set(df.columns) - set(df_imputed.columns)) # in case the median operation deleted columns\n",
    "df_imputed[col_deleted] = df[col_deleted]\n",
    "\n",
    "\n",
    "# fillin the grouped variables from original data frame\n",
    "df_imputed[['Pclass','SibSp']] = df[['Pclass','SibSp']]\n",
    "\n",
    "# 4. drop rows that still had missing values after grouped imputation\n",
    "df_imputed.dropna(inplace=True)\n",
    "\n",
    "# 5. Rearrange the columns\n",
    "df_imputed = df_imputed[['Survived','Age','Sex','Parch','SibSp','Pclass','Fare','Embarked']]\n",
    "\n",
    "df_imputed.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 882 entries, 0 to 890\n",
      "Data columns (total 12 columns):\n",
      " #   Column      Non-Null Count  Dtype  \n",
      "---  ------      --------------  -----  \n",
      " 0   Survived    882 non-null    int64  \n",
      " 1   Age         882 non-null    float64\n",
      " 2   Parch       882 non-null    int64  \n",
      " 3   SibSp       882 non-null    int64  \n",
      " 4   Pclass      882 non-null    int64  \n",
      " 5   Fare        882 non-null    float64\n",
      " 6   Embarked_C  882 non-null    bool   \n",
      " 7   Embarked_Q  882 non-null    bool   \n",
      " 8   Embarked_S  882 non-null    bool   \n",
      " 9   Sex_female  882 non-null    bool   \n",
      " 10  Sex_male    882 non-null    bool   \n",
      " 11  FamilySize  882 non-null    int64  \n",
      "dtypes: bool(5), float64(2), int64(5)\n",
      "memory usage: 59.4 KB\n"
     ]
    }
   ],
   "source": [
    "# perform one-hot encoding of the categorical data \"embarked\"\n",
    "tmp_df = pd.get_dummies(df_imputed.Embarked,prefix='Embarked')\n",
    "df_imputed = pd.concat((df_imputed,tmp_df),axis=1) # add back into the dataframe\n",
    "\n",
    "tmp_df = pd.get_dummies(df_imputed.Sex,prefix='Sex')\n",
    "df_imputed = pd.concat((df_imputed,tmp_df),axis=1) # add back into the dataframe\n",
    "\n",
    "# Now let's clean up the dataset\n",
    "if 'Sex' in df_imputed:\n",
    "    del df_imputed['Sex'] # if 'Sex' column still exists, delete it (as we created an ismale column)\n",
    "    \n",
    "if 'Embarked' in df_imputed:    \n",
    "    del df_imputed['Embarked'] # get reid of the original category as it is now one-hot encoded\n",
    "    \n",
    "# Finally, let's create a new variable based on the number of family members\n",
    "# traveling with the passenger\n",
    "\n",
    "# notice that this new column did not exist before this line of code--we use the pandas \n",
    "#    syntax to add it in \n",
    "df_imputed['FamilySize'] = df_imputed.Parch + df_imputed.SibSp\n",
    "df_imputed.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training and Testing Split\n",
    "For training and testing purposes, let's gather the data we have and grab 80% of the instances for training and the remaining 20% for testing. Moreover, let's repeat this process of separating the testing and training data three times. We will use the hold out cross validation method built into scikit-learn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ShuffleSplit(n_splits=3, random_state=None, test_size=0.2, train_size=None)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import ShuffleSplit\n",
    "\n",
    "# we want to predict the X and y data as follows:\n",
    "if 'Survived' in df_imputed:\n",
    "    y = df_imputed['Survived'].to_numpy() # get the labels we want\n",
    "    del df_imputed['Survived'] # get rid of the class label\n",
    "    \n",
    "    norm_features = ['Age','Fare' ]\n",
    "    df_imputed[norm_features] = (df_imputed[norm_features]-df_imputed[norm_features].mean()) / df_imputed[norm_features].std()\n",
    "    X = df_imputed.to_numpy() # use everything else to predict!\n",
    "    \n",
    "    ## X and y are now numpy matrices, by calling 'values' on the pandas data frames we\n",
    "    #    have converted them into simple matrices to use with scikit learn\n",
    "    \n",
    "X = X.astype(float)  \n",
    "# to use the cross validation object in scikit learn, we need to grab an instance\n",
    "#    of the object and set it up. This object will be able to split our data into \n",
    "#    training and testing splits\n",
    "num_cv_iterations = 3\n",
    "num_instances = len(y)\n",
    "cv_object = ShuffleSplit(\n",
    "                         n_splits=num_cv_iterations,\n",
    "                         test_size  = 0.2)\n",
    "                         \n",
    "print(cv_object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "====Iteration 0  ====\n",
      "accuracy 0.7796610169491526\n",
      "confusion matrix\n",
      " [[103  17]\n",
      " [ 22  35]]\n",
      "====Iteration 1  ====\n",
      "accuracy 0.8361581920903954\n",
      "confusion matrix\n",
      " [[100  13]\n",
      " [ 16  48]]\n",
      "====Iteration 2  ====\n",
      "accuracy 0.7570621468926554\n",
      "confusion matrix\n",
      " [[94 18]\n",
      " [25 40]]\n"
     ]
    }
   ],
   "source": [
    "# run logistic regression and vary some parameters\n",
    "from sklearn import metrics as mt\n",
    "\n",
    "# first we create a reusable logisitic regression object\n",
    "#   here we can setup the object with different learning parameters and constants\n",
    "lr_clf = HessianBinaryLogisticRegression(eta=0.1, iterations=10) # get object\n",
    "\n",
    "# now we can use the cv_object that we setup before to iterate through the \n",
    "#    different training and testing sets. Each time we will reuse the logisitic regression \n",
    "#    object, but it gets trained on different data each time we use it.\n",
    "\n",
    "iter_num=0\n",
    "# the indices are the rows used for training and testing in each iteration\n",
    "for train_indices, test_indices in cv_object.split(X,y): \n",
    "    # I will create new variables here so that it is more obvious what \n",
    "    # the code is doing (you can compact this syntax and avoid duplicating memory,\n",
    "    # but it makes this code less readable)\n",
    "    X_train = X[train_indices]\n",
    "    y_train = y[train_indices]\n",
    "    \n",
    "    X_test = X[test_indices]\n",
    "    y_test = y[test_indices]\n",
    "    \n",
    "    # train the reusable logisitc regression model on the training data\n",
    "    lr_clf.fit(X_train,y_train)  # train object\n",
    "    y_hat = lr_clf.predict(X_test) # get test set precitions\n",
    "\n",
    "    # now let's get the accuracy and confusion matrix for this iterations of training/testing\n",
    "    acc = mt.accuracy_score(y_test,y_hat)\n",
    "    conf = mt.confusion_matrix(y_test,y_hat)\n",
    "    print(\"====Iteration\",iter_num,\" ====\")\n",
    "    print(\"accuracy\", acc )\n",
    "    print(\"confusion matrix\\n\",conf)\n",
    "    iter_num += 1\n",
    "    \n",
    "# Also note that every time you run the above code\n",
    "#   it randomly creates a new training and testing set, \n",
    "#   so accuracy will be different each time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "====Iteration 0  ====\n",
      "accuracy 0.8248587570621468\n",
      "confusion matrix\n",
      " [[101  18]\n",
      " [ 13  45]]\n",
      "====Iteration 1  ====\n",
      "accuracy 0.7853107344632768\n",
      "confusion matrix\n",
      " [[86 14]\n",
      " [24 53]]\n",
      "====Iteration 2  ====\n",
      "accuracy 0.768361581920904\n",
      "confusion matrix\n",
      " [[82 18]\n",
      " [23 54]]\n"
     ]
    }
   ],
   "source": [
    "# this does the exact same thing as the above block of code, but with shorter syntax\n",
    "\n",
    "for iter_num, (train_indices, test_indices) in enumerate(cv_object.split(X,y)):\n",
    "    lr_clf.fit(X[train_indices],y[train_indices])  # train object\n",
    "    y_hat = lr_clf.predict(X[test_indices]) # get test set precitions\n",
    "\n",
    "    # print the accuracy and confusion matrix \n",
    "    print(\"====Iteration\",iter_num,\" ====\")\n",
    "    print(\"accuracy\", mt.accuracy_score(y[test_indices],y_hat)) \n",
    "    print(\"confusion matrix\\n\",mt.confusion_matrix(y[test_indices],y_hat))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interactive Example, adjusting C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7936d72a2dc34d5e972672658a19d55b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='cost', options=(0.0001, 0.00022758459260747887, 0.0005179474679231…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.lr_explor(cost)>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from ipywidgets import widgets as wd\n",
    "\n",
    "num_cv_iterations = 10\n",
    "num_instances = len(y)\n",
    "cv_object = ShuffleSplit(n_splits=num_cv_iterations,\n",
    "                         test_size  = 0.5)\n",
    "\n",
    "def lr_explor(cost):\n",
    "    print('Running')\n",
    "    lr_clf = HessianBinaryLogisticRegression(eta=0.1,iterations=10,\n",
    "                                            C=float(cost)) # get object\n",
    "    acc = []\n",
    "    for iter_num, (train_indices, test_indices) in enumerate(cv_object.split(X,y)):\n",
    "        lr_clf.fit(X[train_indices],y[train_indices])  # train object\n",
    "        y_hat = lr_clf.predict(X[test_indices]) # get test set predictions\n",
    "        acc.append(mt.accuracy_score(y[test_indices],y_hat))\n",
    "        \n",
    "    acc = np.array(acc)\n",
    "    print(acc.mean(),'+-',2.7*acc.std())\n",
    "        \n",
    "wd.interact(lr_explor,cost=list(np.logspace(-4,1,15)),__manual=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exhaustive Search for C, then Visualize with Boxplots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 932 ms, sys: 431 ms, total: 1.36 s\n",
      "Wall time: 1.38 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# alternatively, we can also graph out the values using boxplots\n",
    "num_cv_iterations = 20\n",
    "num_instances = len(y)\n",
    "cv_object = ShuffleSplit(n_splits=num_cv_iterations,\n",
    "                         test_size  = 0.5)\n",
    "\n",
    "def lr_explor(cost):\n",
    "    lr_clf = BFGSBinaryLogisticRegression(eta=0.1,iterations=10,\n",
    "                                            C=float(cost)) # get object\n",
    "    acc = []\n",
    "    for iter_num, (train_indices, test_indices) in enumerate(cv_object.split(X,y)):\n",
    "        lr_clf.fit(X[train_indices],y[train_indices])  # train object\n",
    "        y_hat = lr_clf.predict(X[test_indices]) # get test set predictions\n",
    "        acc.append(mt.accuracy_score(y[test_indices],y_hat))\n",
    "        \n",
    "    acc = np.array(acc)\n",
    "    return acc\n",
    "\n",
    "costs = np.logspace(-5,1,20)\n",
    "accs = []\n",
    "for c in costs:\n",
    "    accs.append(lr_explor(c))\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# now show a boxplot of the data across c\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.boxplot(accs)\n",
    "plt.xticks(range(1,len(costs)+1),['%.4f'%(c) for c in costs],rotation='vertical')\n",
    "plt.xlabel('C')\n",
    "plt.ylabel('validation accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "___\n",
    "# Next Time: Neural Networks\n",
    "___\n",
    "\n",
    "In this notebook you learned:\n",
    "- Formulation of Logistic regression with different optimization strategies\n",
    " - Line Search\n",
    " - Mini-batch and Stochastic Gradient\n",
    "- Newton's Approach using Hessian \n",
    "- Quasi Newton Method, BFGS\n",
    "- Use Exhaustive Searches for Finding \"C\" \n",
    "- And Training/Testing Splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}