08a. Practical_NeuralNets with Bias.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# see the actual derivation of these equations \n",
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo(\"WRr2e7mKCUY\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Practical Implementation of Neural Networks\n",
    "\n",
    "We define a new objective function as:\n",
    "\n",
    "$$ J(\\mathbf{W})=-[\\mathbf{y}^{(i)}\\ln[\\mathbf{a}^{(L+1)}]^{(i)}+(1-\\mathbf{y}^{(i)})\\ln(1-[\\mathbf{a}^{(L+1)}]^{(i)}) ]$$\n",
    "\n",
    "Notice that this is highly similar to the log-likelihood we derived for logistic regression.\n",
    "\n",
    "Such that the new update for the final layer becomes:\n",
    "\n",
    "$$ \\left[\\frac{\\partial J(\\mathbf{W})}{\\mathbf{z}^{(L)}}\\right]^{(i)} = ([\\mathbf{a}^{(L+1)}]^{(i)}- \\mathbf{y}^{(i)}) $$\n",
    "\n",
    "$$ \\left[\\frac{\\partial J(\\mathbf{W})}{\\mathbf{z}^{(2)}}\\right]^{(i)} = ([\\mathbf{a}^{(3)}]^{(i)}- \\mathbf{y}^{(i)})$$\n",
    "\n",
    "And this is straight forward to convert to vectorized math for the sensitivity:\n",
    "\n",
    "$$ \\mathbf{V}^{(2)} = \\mathbf{A}^{(3)}-\\mathbf{Y} $$\n",
    "\n",
    "Which can be derived as follows\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "J(\\mathbf{W})&=-\\left[\\mathbf{y}^{(i)}\\ln\\phi([\\mathbf{z}^{(L)}]^{(i)})+(1-\\mathbf{y}^{(i)})\\ln(1-[\\phi(\\mathbf{z}^{(L)}]^{(i)})) \\right] \\\\\n",
    "\\frac{\\partial J}{\\partial \\mathbf{z}^{(L)}} &=  -\\left[\\frac{\\mathbf{y}^{(i)}}{\\phi([\\mathbf{z}^{(L)})]^{(i)}}\\left( \\frac{\\partial}{\\partial \\mathbf{z}^{(L)}}\\phi([\\mathbf{z}^{(L)}]^{(i)}) \\right)\n",
    "+\\frac{(1-\\mathbf{y}^{(i)})}{(1-[\\phi(\\mathbf{z}^{(L)})]^{(i)})}\\left( \\frac{\\partial}{\\partial \\mathbf{z}^{(L)}}(1-[\\phi(\\mathbf{z}^{(L)}]^{(i)}))\\right) \\right] \\\\\n",
    " &=  -\\left[\\frac{\\mathbf{y}^{(i)}}{\\phi([\\mathbf{z}^{(L)}]^{(i)})} \\phi([\\mathbf{z}^{(L)}]^{(i)})\\left(1-\\phi([\\mathbf{z}^{(L)}]^{(i)}) \\right)\n",
    "+\\left(\\frac{1-\\mathbf{y}^{(i)}}{1-[\\phi(\\mathbf{z}^{(L)}]^{(i)})}\\right)  \\left(-\\phi([\\mathbf{z}^{(L)}]^{(i)})\\left(1-\\phi([\\mathbf{z}^{(L)}]^{(i)}) \\right)\\right) \\right] \\\\\n",
    " &=  -\\left[\\mathbf{y}^{(i)}\\left(1-\\phi([\\mathbf{z}^{(L)}]^{(i)}) \\right)\n",
    "+\\left(1-\\mathbf{y}^{(i)}\\right)  \\left(-\\phi([\\mathbf{z}^{(L)}]^{(i)})\\right) \\right] \\\\\n",
    "&=  -\\left[\\mathbf{y}^{(i)}-\\mathbf{y}^{(i)}\\phi([\\mathbf{z}^{(L)}]^{(i)}) \n",
    "-\\phi([\\mathbf{z}^{(L)}]^{(i)})+\\phi([\\mathbf{z}^{(L)}]^{(i)})\\mathbf{y}^{(i)}   \\right] \\\\\n",
    "&=  -\\left[\\mathbf{y}^{(i)}-\\phi([\\mathbf{z}^{(L)}]^{(i)})   \\right] \\\\\n",
    "&=  \\phi([\\mathbf{z}^{(L)}]^{(i)}) - \\mathbf{y}^{(i)} \\\\\n",
    "&=  [\\mathbf{a}^{(L+1)}]^{(i)} - \\mathbf{y}^{(i)} \\\\\n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another option is to choose the softmax, which is defined as:\n",
    "\n",
    "$$  a_j^{(L+1)} = \\frac{\\exp(z_j^{(L)})}{\\sum_i \\exp(z_i^{(L)})}  $$\n",
    "\n",
    "However, it has an identical update equation as the sigmoid final layer using cross entropy. We will stick with cross entropy in order to keep the consistency to previous feedforward code. However, please note that that sigmoid activation functions are more susceptible to gradient instability. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example adapted from https://github.com/rasbt/python-machine-learning-book/blob/master/code/ch12/ch12.ipynb\n",
    "# Original Author: Sebastian Raschka\n",
    "\n",
    "# This is the optional book we use in the course, excellent intuitions and straightforward programming examples\n",
    "# please note, however, that this code has been manipulated to reflect our assumptions and notation.\n",
    "import numpy as np\n",
    "from scipy.special import expit\n",
    "import pandas as pd\n",
    "import sys\n",
    "\n",
    "# start with a simple base classifier, which can't be fit or predicted\n",
    "# it only has internal classes to be used by classes that will subclass it\n",
    "class TwoLayerPerceptronBase(object):\n",
    "    def __init__(self, n_hidden=30,\n",
    "                 C=0.0, epochs=500, eta=0.001, random_state=None):\n",
    "        np.random.seed(random_state)\n",
    "        self.n_hidden = n_hidden\n",
    "        self.l2_C = C\n",
    "        self.epochs = epochs\n",
    "        self.eta = eta\n",
    "        \n",
    "    @staticmethod\n",
    "    def _encode_labels(y):\n",
    "        \"\"\"Encode labels into one-hot representation\"\"\"\n",
    "        onehot = pd.get_dummies(y).values.T\n",
    "            \n",
    "        return onehot\n",
    "\n",
    "    def _initialize_weights(self):\n",
    "        \"\"\"Initialize weights with small random numbers.\"\"\"\n",
    "        W1_num_elems = (self.n_features_)*self.n_hidden\n",
    "        W1 = np.random.uniform(-1.0, 1.0, size=W1_num_elems)\n",
    "        W1 = W1.reshape(self.n_hidden, self.n_features_) # reshape to be W\n",
    "        b1 = np.zeros((self.n_hidden, 1))\n",
    "        \n",
    "        W2_num_elems = (self.n_hidden)*self.n_output_\n",
    "        W2 = np.random.uniform(-1.0, 1.0, size=W2_num_elems)\n",
    "        W2 = W2.reshape(self.n_output_, self.n_hidden)\n",
    "        b2 = np.zeros((self.n_output_, 1))\n",
    "        \n",
    "        return W1, W2, b1, b2\n",
    "    \n",
    "    @staticmethod\n",
    "    def _sigmoid(z):\n",
    "        \"\"\"Use scipy.special.expit to avoid overflow\"\"\"\n",
    "        # 1.0 / (1.0 + np.exp(-z))\n",
    "        return expit(z)\n",
    "    \n",
    "    \n",
    "    @staticmethod\n",
    "    def _L2_reg(lambda_, W1, W2):\n",
    "        \"\"\"Compute L2-regularization cost\"\"\"\n",
    "        # only compute for non-bias terms\n",
    "        return (lambda_/2.0) * np.sqrt(np.mean(W1[:, 1:] ** 2) + np.mean(W2[:, 1:] ** 2))\n",
    "    \n",
    "    def _cost(self,A3,Y_enc,W1,W2):\n",
    "        '''Get the objective function value'''\n",
    "        cost = np.mean((Y_enc-A3)**2)\n",
    "        L2_term = self._L2_reg(self.l2_C, W1, W2)\n",
    "        return cost + L2_term\n",
    "    \n",
    "    def _feedforward(self, X, W1, W2, b1, b2):\n",
    "        \"\"\"Compute feedforward step\n",
    "        -----------\n",
    "        X : Input layer with original features.\n",
    "        W1: Weight matrix for input layer -> hidden layer.\n",
    "        W2: Weight matrix for hidden layer -> output layer.\n",
    "        ----------\n",
    "        a1-a3 : activations into layer (or output layer)\n",
    "        z1-z2 : layer inputs \n",
    "\n",
    "        \"\"\"\n",
    "        A1 = X.T\n",
    "        Z1 = W1 @ A1 + b1\n",
    "        A2 = self._sigmoid(Z1)\n",
    "        Z2 = W2 @ A2 + b2\n",
    "        A3 = self._sigmoid(Z2)\n",
    "        return A1, Z1, A2, Z2, A3\n",
    "    \n",
    "    def _get_gradient(self, A1, A2, A3, Z1, Z2, Y_enc, W1, W2):\n",
    "        \"\"\" Compute gradient step using backpropagation.\n",
    "        \"\"\"\n",
    "        # vectorized backpropagation\n",
    "        V2 = -2*(Y_enc-A3)*A3*(1-A3)\n",
    "        V1 = A2*(1-A2)*(W2.T @ V2)\n",
    "        \n",
    "        gradW2 = V2 @ A2.T\n",
    "        gradW1 = V1 @ A1.T\n",
    "        \n",
    "        gradb2 = np.sum(V2, axis=1).reshape((-1,1))\n",
    "        gradb1 = np.sum(V1, axis=1).reshape((-1,1))\n",
    "        \n",
    "        \n",
    "        # regularize weights that are not bias terms\n",
    "        gradW1 += W1 * self.l2_C\n",
    "        gradW2 += W2 * self.l2_C\n",
    "\n",
    "        return gradW1, gradW2, gradb1, gradb2\n",
    "    \n",
    "    def predict(self, X):\n",
    "        \"\"\"Predict class labels\"\"\"\n",
    "        _, _, _, _, A3 = self._feedforward(X, self.W1, self.W2, self.b1, self.b2)\n",
    "        y_pred = np.argmax(A3, axis=0)\n",
    "        return y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Momentum, Mini-batch and Cooling\n",
    "Like in the previous notebook, we will add in momentum, cooling and min-batching to the implementation to get a better optimizer. \n",
    "\n",
    "As a bonus, let's add support for keeping track of the validation in the training loop. That is, we will add in a calculation to test the validation loss and accuracy at the end of each epoch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "# just start with the vectorized version and minibatch\n",
    "class TLPMiniBatch(TwoLayerPerceptronBase):\n",
    "    def __init__(self, alpha=0.0, decrease_const=0.1, \n",
    "                 decrease_iter = 10, shuffle=True, \n",
    "                 minibatches=1, **kwds):        \n",
    "        # need to add to the original initializer \n",
    "        self.alpha = alpha\n",
    "        self.decrease_const = decrease_const\n",
    "        self.decrease_iter = decrease_iter\n",
    "        self.shuffle = shuffle\n",
    "        self.minibatches = minibatches\n",
    "        # but keep other keywords\n",
    "        super().__init__(**kwds)\n",
    "        \n",
    "    \n",
    "    def fit(self, X, y, print_progress=False, XY_test=None):\n",
    "        \"\"\" Learn weights from training data. With mini-batch\"\"\"\n",
    "        X_data, y_data = X.copy(), y.copy()\n",
    "        Y_enc = self._encode_labels(y)\n",
    "        \n",
    "        # init weights and setup matrices\n",
    "        self.n_features_ = X_data.shape[1]\n",
    "        self.n_output_ = Y_enc.shape[0]\n",
    "        self.W1, self.W2, self.b1, self.b2 = self._initialize_weights()\n",
    "\n",
    "        # start momentum at zero for previous updates\n",
    "        rho_W1_prev = np.zeros(self.W1.shape) # for momentum\n",
    "        rho_W2_prev = np.zeros(self.W2.shape) # for momentum\n",
    "\n",
    "        self.cost_ = []\n",
    "        self.score_ = []\n",
    "        # get starting acc\n",
    "        self.score_.append(accuracy_score(y_data,self.predict(X_data)))\n",
    "        # keep track of validation, if given\n",
    "        if XY_test is not None:\n",
    "            X_test = XY_test[0].copy()\n",
    "            y_test = XY_test[1].copy()\n",
    "            self.val_score_ = []\n",
    "            self.val_score_.append(accuracy_score(y_test,self.predict(X_test)))\n",
    "            self.val_cost_ = []\n",
    "            \n",
    "        for i in range(self.epochs):\n",
    "\n",
    "            # adaptive learning rate\n",
    "            # decrease at certain epochs\n",
    "            eta = self.eta * self.decrease_const**(np.floor(i/self.decrease_iter))\n",
    "\n",
    "            if print_progress>0 and (i+1)%print_progress==0:\n",
    "                sys.stderr.write('\\rEpoch: %d/%d' % (i+1, self.epochs))\n",
    "                sys.stderr.flush()\n",
    "\n",
    "            if self.shuffle:\n",
    "                idx_shuffle = np.random.permutation(y_data.shape[0])\n",
    "                X_data, Y_enc, y_data = X_data[idx_shuffle], Y_enc[:, idx_shuffle], y_data[idx_shuffle]\n",
    "\n",
    "            mini = np.array_split(range(y_data.shape[0]), self.minibatches)\n",
    "            mini_cost = []\n",
    "            for idx in mini:\n",
    "\n",
    "                # feedforward\n",
    "                A1, Z1, A2, Z2, A3 = self._feedforward(X_data[idx],\n",
    "                                                       self.W1,\n",
    "                                                       self.W2,\n",
    "                                                       self.b1,\n",
    "                                                       self.b2\n",
    "                                                      )\n",
    "                \n",
    "                cost = self._cost(A3,Y_enc[:, idx],self.W1,self.W2)\n",
    "                mini_cost.append(cost) # this appends cost of mini-batch only\n",
    "\n",
    "                # compute gradient via backpropagation\n",
    "                gradW1, gradW2, gradb1, gradb2 = self._get_gradient(A1=A1, A2=A2, A3=A3, Z1=Z1, Z2=Z2, \n",
    "                                                  Y_enc=Y_enc[:, idx],\n",
    "                                                  W1=self.W1,W2=self.W2)\n",
    "\n",
    "                \n",
    "                \n",
    "                # simple momentum calculations\n",
    "                \n",
    "                rho_W1, rho_W2 = eta * gradW1, eta * gradW2\n",
    "                self.W1 -= (rho_W1 + (self.alpha * rho_W1_prev)) # update with momentum\n",
    "                self.W2 -= (rho_W2 + (self.alpha * rho_W2_prev)) # update with momentum\n",
    "                \n",
    "                # no need for momentum in bias \n",
    "                # these values need to change abruptly and \n",
    "                # do not influence sensitivity backward\n",
    "                self.b1 -= eta * gradb1\n",
    "                self.b2 -= eta * gradb2\n",
    "                \n",
    "                # update previous parameters \n",
    "                rho_W1_prev, rho_W2_prev = rho_W1, rho_W2\n",
    "                \n",
    "                \n",
    "\n",
    "            self.cost_.append(np.mean(mini_cost))\n",
    "            self.score_.append(accuracy_score(y_data,self.predict(X_data)))\n",
    "            \n",
    "            # update if a validation set was provided\n",
    "            if XY_test is not None:\n",
    "                yhat = self.predict(X_test)\n",
    "                self.val_score_.append(accuracy_score(y_test,yhat))\n",
    "            \n",
    "        return self\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [End review]\n",
    "___\n",
    "\n",
    "## Start of new material\n",
    "\n",
    "Let's start our architecture updates by changing to cross entropy. THis is a realtively easy change to make. Let's do this and then load the fashion MNIST dataset for testing. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to implement the new style of objective function, \n",
    "# we just need to update the final layer calculation of the gradient\n",
    "class TLPMiniBatchCrossEntropy(TLPMiniBatch):\n",
    "    def _cost(self,A3,Y_enc,W1,W2):\n",
    "        '''Get the objective function value'''\n",
    "        cost = -np.mean(np.nan_to_num((Y_enc*np.log(A3+1e-7)+(1-Y_enc)*np.log(1-A3+1e-7))))\n",
    "        L2_term = self._L2_reg(self.l2_C, W1, W2)\n",
    "        return cost + L2_term\n",
    "    \n",
    "    def _get_gradient(self, A1, A2, A3, Z1, Z2, Y_enc, W1, W2):\n",
    "        \"\"\" Compute gradient step using backpropagation.\n",
    "        \"\"\"\n",
    "        # vectorized backpropagation\n",
    "        V2 = (A3-Y_enc) # <- this is only line that changed\n",
    "        V1 = A2*(1-A2)*(W2.T @ V2)\n",
    "        \n",
    "        gradW2 = V2 @ A2.T\n",
    "        gradW1 = V1 @ A1.T\n",
    "        \n",
    "        gradb2 = np.sum(V2, axis=1).reshape((-1,1))\n",
    "        gradb1 = np.sum(V1, axis=1).reshape((-1,1))\n",
    "        \n",
    "        # regularize weights that are not bias terms\n",
    "        gradW1 += W1 * self.l2_C\n",
    "        gradW2 += W2 * self.l2_C\n",
    "\n",
    "        return gradW1, gradW2, gradb1, gradb2\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rows: 60000, columns: 784\n",
      "Rows: 10000, columns: 784\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# more diverse fashion MNIST data\n",
    "# Let's use Raschka's implementation for using the mnist dataset:\n",
    "# https://github.com/rasbt/python-machine-learning-book/blob/master/code/ch12/ch12.ipynb\n",
    "import os\n",
    "import struct\n",
    "import numpy as np\n",
    "# from sklearn.preprocessing import RobustScaler\n",
    " \n",
    "def load_mnist(path, kind='fashion_train'):\n",
    "    \"\"\"Load MNIST data from `path`\"\"\"\n",
    "    labels_path = os.path.join(path, '%s-labels-idx1-ubyte' % kind)\n",
    "    images_path = os.path.join(path, '%s-images-idx3-ubyte' % kind)\n",
    "        \n",
    "    with open(labels_path, 'rb') as lbpath:\n",
    "        magic, n = struct.unpack('>II', lbpath.read(8))\n",
    "        labels = np.fromfile(lbpath, dtype=np.uint8)\n",
    "\n",
    "    with open(images_path, 'rb') as imgpath:\n",
    "        magic, num, rows, cols = struct.unpack(\">IIII\", imgpath.read(16))\n",
    "        images = np.fromfile(imgpath, dtype=np.uint8).reshape(len(labels), 784)\n",
    " \n",
    "    return images, labels\n",
    "\n",
    "X_train, y_train = load_mnist('data/', kind='fashion_train')\n",
    "print('Rows: %d, columns: %d' % (X_train.shape[0], X_train.shape[1]))\n",
    "\n",
    "X_test, y_test = load_mnist('data/', kind='fashion_t10k')\n",
    "print('Rows: %d, columns: %d' % (X_test.shape[0], X_test.shape[1]))\n",
    "\n",
    "# important pre-processing steps!!\n",
    "X_train = X_train/255.0 - 0.5\n",
    "X_test = X_test/255.0 - 0.5\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch: 20/20"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1min 16s, sys: 13.2 s, total: 1min 29s\n",
      "Wall time: 12.8 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch: 20/20"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1min 49s, sys: 14.8 s, total: 2min 4s\n",
      "Wall time: 18.9 s\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "vals = { 'n_hidden':30, \n",
    "         'C':0.1, 'epochs':20, 'eta':0.01, # poor starting learning rate!!\n",
    "         'alpha':0.001, 'decrease_const':0.1, 'decrease_iter':15,\n",
    "         'minibatches':50,\n",
    "         'shuffle':True,'random_state':1}\n",
    "\n",
    "nn_quad = TLPMiniBatch(**vals)\n",
    "nn_cross = TLPMiniBatchCrossEntropy(**vals)\n",
    "\n",
    "%time nn_cross.fit(X_train, y_train, print_progress=1, XY_test=(X_test, y_test))\n",
    "%time nn_quad.fit(X_train, y_train, print_progress=1, XY_test=(X_test, y_test))\n",
    "print(\"Done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.style.use('ggplot')\n",
    "\n",
    "def print_result(nn,X_train,y_train,X_test,y_test,title=\"\",color=\"red\"):\n",
    "    \n",
    "    print(\"=================\")\n",
    "    print(title,\":\")\n",
    "    yhat = nn.predict(X_train)\n",
    "    print('Resubstitution acc:',accuracy_score(y_train,yhat))\n",
    "    \n",
    "    yhat = nn.predict(X_test)\n",
    "    print('Validation acc:',accuracy_score(y_test,yhat))\n",
    "    \n",
    "    if hasattr(nn,'val_score_'):\n",
    "        plt.plot(range(len(nn.val_score_)), nn.val_score_, color=color,label=title)\n",
    "        plt.ylabel('Validation Accuracy')\n",
    "    else:\n",
    "        plt.plot(range(len(nn.score_)), nn.score_, color=color,label=title)\n",
    "        plt.ylabel('Resub Accuracy')\n",
    "        \n",
    "    plt.xlabel('Epochs')\n",
    "    plt.tight_layout()\n",
    "    plt.legend(loc='best')\n",
    "    plt.grid(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================\n",
      "Cross Entropy Loss :\n",
      "Resubstitution acc: 0.8353666666666667\n",
      "Validation acc: 0.8213\n",
      "=================\n",
      "MSE Loss :\n",
      "Resubstitution acc: 0.19908333333333333\n",
      "Validation acc: 0.1991\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_result(nn_cross,X_train,y_train,X_test,y_test,title=\"Cross Entropy Loss\",color=\"red\")\n",
    "print_result(nn_quad,X_train,y_train,X_test,y_test,title=\"MSE Loss\",color=\"blue\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now let's Do initialization "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TLPBetterInitial(TLPMiniBatchCrossEntropy):             \n",
    "    def _initialize_weights(self):\n",
    "        \"\"\"Initialize weights Glorot and He normalization.\"\"\"\n",
    "        init_bound = 4*np.sqrt(6. / (self.n_hidden + self.n_features_))\n",
    "        W1 = np.random.uniform(-init_bound, init_bound,(self.n_hidden, self.n_features_))\n",
    "\n",
    "        # reduce the final layer magnitude in order to balance the size of the gradients\n",
    "        # between \n",
    "        init_bound = 4*np.sqrt(6 / (self.n_output_ + self.n_hidden))\n",
    "        W2 = np.random.uniform(-init_bound, init_bound,(self.n_output_, self.n_hidden)) \n",
    "        \n",
    "        # set these to zero to start so that\n",
    "        # they do not immediately saturate the neurons\n",
    "        b1 = np.zeros((self.n_hidden, 1))\n",
    "        b2 = np.zeros((self.n_output_, 1))\n",
    "        \n",
    "        return W1, W2, b1, b2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch: 20/20"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1min 16s, sys: 14.4 s, total: 1min 31s\n",
      "Wall time: 13.1 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch: 20/20"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1min 42s, sys: 15.7 s, total: 1min 58s\n",
      "Wall time: 17.7 s\n",
      "=================\n",
      "Traditional :\n",
      "Resubstitution acc: 0.8427\n",
      "Validation acc: 0.8309\n",
      "=================\n",
      "Glorot Initial :\n",
      "Resubstitution acc: 0.8512333333333333\n",
      "Validation acc: 0.8385\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "vals['epochs'] = 20\n",
    "vals['eta'] = 0.001\n",
    "\n",
    "nn_tradit = TLPMiniBatchCrossEntropy(**vals)\n",
    "nn_better = TLPBetterInitial(**vals)\n",
    "\n",
    "%time nn_tradit.fit(X_train, y_train, print_progress=1, XY_test=(X_test, y_test))\n",
    "%time nn_better.fit(X_train, y_train, print_progress=1, XY_test=(X_test, y_test))\n",
    "\n",
    "print_result(nn_tradit,X_train,y_train,X_test,y_test,title=\"Traditional\",color=\"red\")\n",
    "print_result(nn_better,X_train,y_train,X_test,y_test,title=\"Glorot Initial\",color=\"blue\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch: 75/75"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 9min 28s, sys: 56.8 s, total: 10min 25s\n",
      "Wall time: 1min 32s\n",
      "=================\n",
      "Long Run :\n",
      "Resubstitution acc: 0.8976333333333333\n",
      "Validation acc: 0.8641\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# just for fun, let's look at the output of what happens when we let our system loose\n",
    "# these values have been hand tuned\n",
    "vals = {'n_hidden':50, \n",
    "         'C':1e-2, 'epochs':75, 'eta':0.005, \n",
    "         'alpha':0.1, 'decrease_const':0.1,\n",
    "         'decrease_iter':20,\n",
    "         'minibatches':len(X_train)/256,\n",
    "         'shuffle':True,'random_state':1}\n",
    "\n",
    "nn_long_sigmoid = TLPBetterInitial(**vals)\n",
    "\n",
    "%time nn_long_sigmoid.fit(X_train, y_train, print_progress=1, XY_test=(X_test,y_test))\n",
    "print_result(nn_long_sigmoid,X_train,y_train,X_test,y_test,title=\"Long Run\",color=\"red\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "______\n",
    "**Self Test**: Resubstitution accuracy is more important than validation accuracy when training.\n",
    "- A. True\n",
    "- B. False\n",
    "- C. It depends\n",
    "\n",
    "\n",
    "\n",
    "## [Back To Slides]\n",
    "_____"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Adaptive Methods: AdaGrad\n",
    "In this formulation, we use the following update function as follows:\n",
    "$$\\mathbf{W}_{k+1}^{(l)} = \\mathbf{W}_k^{(l)} -  \\eta\\cdot\\rho_{k}^{(l)}$$\n",
    "\n",
    "Where:\n",
    "\n",
    "$$ \\rho_k^{(l)} = \\frac{1}{\\sqrt{\\mathbf{G}_k^{(l)}+\\epsilon}}\\odot\\nabla J(\\mathbf{W}_{k}^{(l)}) $$\n",
    "\n",
    "and \n",
    "\n",
    "$$ \\mathbf{G}_k^{(l)} =\\alpha \\cdot\\mathbf{G}^{(l)}_{k-1}+\\nabla J(\\mathbf{W}_k^{(l)})\\odot \\nabla J(\\mathbf{W}_k^{(l)}) $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# just need to optimizd the fit function such that we use \n",
    "# the G value above\n",
    "class TLPAdaGrad(TLPBetterInitial):\n",
    "        \n",
    "    def fit(self, X, y, print_progress=False, XY_test=None):\n",
    "        \"\"\" Learn weights from training data. With mini-batch\"\"\"\n",
    "        X_data, y_data = X.copy(), y.copy()\n",
    "        Y_enc = self._encode_labels(y)\n",
    "        \n",
    "        # init weights and setup matrices\n",
    "        self.n_features_ = X_data.shape[1]\n",
    "        self.n_output_ = Y_enc.shape[0]\n",
    "        self.W1, self.W2, self.b1, self.b2 = self._initialize_weights()\n",
    "\n",
    "        # start momentum at zero for previous updates\n",
    "        rho_W1_prev = np.zeros(self.W1.shape) # for momentum\n",
    "        rho_W2_prev = np.zeros(self.W2.shape) # for momentum\n",
    "        \n",
    "        # adaptive G for entire gradient\n",
    "        G1_prev = np.zeros(self.W1.shape) # for adaptive\n",
    "        G2_prev = np.zeros(self.W2.shape) # for adaptive\n",
    "\n",
    "        self.cost_ = []\n",
    "        self.score_ = []\n",
    "        # get starting acc\n",
    "        self.score_.append(accuracy_score(y_data,self.predict(X_data)))\n",
    "        # keep track of validation, if given\n",
    "        if XY_test is not None:\n",
    "            X_test = XY_test[0].copy()\n",
    "            y_test = XY_test[1].copy()\n",
    "            self.val_score_ = []\n",
    "            self.val_score_.append(accuracy_score(y_test,self.predict(X_test)))\n",
    "            self.val_cost_ = []\n",
    "            \n",
    "        for i in range(self.epochs):\n",
    "\n",
    "            # adaptive learning rate\n",
    "            # decrease at certain epochs\n",
    "            eta = self.eta * self.decrease_const**(np.floor(i/self.decrease_iter))\n",
    "\n",
    "            if print_progress>0 and (i+1)%print_progress==0:\n",
    "                sys.stderr.write('\\rEpoch: %d/%d' % (i+1, self.epochs))\n",
    "                sys.stderr.flush()\n",
    "\n",
    "            if self.shuffle:\n",
    "                idx_shuffle = np.random.permutation(y_data.shape[0])\n",
    "                X_data, Y_enc, y_data = X_data[idx_shuffle], Y_enc[:, idx_shuffle], y_data[idx_shuffle]\n",
    "\n",
    "            mini = np.array_split(range(y_data.shape[0]), self.minibatches)\n",
    "            mini_cost = []\n",
    "            for idx in mini:\n",
    "\n",
    "                # feedforward\n",
    "                A1, Z1, A2, Z2, A3 = self._feedforward(X_data[idx],\n",
    "                                                       self.W1,\n",
    "                                                       self.W2,\n",
    "                                                       self.b1,\n",
    "                                                       self.b2\n",
    "                                                      )\n",
    "                \n",
    "                cost = self._cost(A3,Y_enc[:, idx],self.W1,self.W2)\n",
    "                mini_cost.append(cost) # this appends cost of mini-batch only\n",
    "\n",
    "                # compute gradient via backpropagation\n",
    "                gradW1, gradW2, gradb1, gradb2 = self._get_gradient(A1=A1, A2=A2, A3=A3, Z1=Z1, Z2=Z2, \n",
    "                                                  Y_enc=Y_enc[:, idx],\n",
    "                                                  W1=self.W1,W2=self.W2)\n",
    "\n",
    "                \n",
    "                \n",
    "                # momentum and adaptation calculations\n",
    "                # Eta-grad implementation:\n",
    "                G1 = gradW1*gradW1 + self.alpha*G1_prev + 1e-7\n",
    "                G2 = gradW2*gradW2 + self.alpha*G2_prev + 1e-7\n",
    "                \n",
    "                # momentum and adagrad\n",
    "                rho_W1, rho_W2 = eta * gradW1/np.sqrt(G1), eta * gradW2/np.sqrt(G2)\n",
    "                self.W1 -= (rho_W1 + (self.alpha * rho_W1_prev)) # update with momentum\n",
    "                self.W2 -= (rho_W2 + (self.alpha * rho_W2_prev)) # update with momentum\n",
    "                self.b1 -= eta * gradb1\n",
    "                self.b2 -= eta * gradb2\n",
    "                \n",
    "                # update previous parameters for the \n",
    "                rho_W1_prev, rho_W2_prev = rho_W1, rho_W2\n",
    "                G1_prev, G2_prev = G1, G2\n",
    "                \n",
    "                \n",
    "\n",
    "            self.cost_.append(np.mean(mini_cost))\n",
    "            self.score_.append(accuracy_score(y_data,self.predict(X_data)))\n",
    "            if XY_test is not None:\n",
    "                yhat = self.predict(X_test)\n",
    "                self.val_score_.append(accuracy_score(y_test,yhat))\n",
    "            \n",
    "        return self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch: 75/75"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 8min 18s, sys: 59.3 s, total: 9min 18s\n",
      "Wall time: 1min 20s\n",
      "=================\n",
      "Long Run :\n",
      "Resubstitution acc: 0.92335\n",
      "Validation acc: 0.8832\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# just for fun, let's look at the output of what happens when we let our system loose\n",
    "# these values have been hand tuned\n",
    "vals = {'n_hidden':50, \n",
    "         'C':1e-2, 'epochs':75, 'eta':0.005, \n",
    "         'alpha':0.1, 'decrease_const':0.1,\n",
    "         'decrease_iter':20,\n",
    "         'minibatches':len(X_train)/256,\n",
    "         'shuffle':True,'random_state':1}\n",
    "\n",
    "nn_long_ada = TLPAdaGrad(**vals)\n",
    "\n",
    "%time nn_long_ada.fit(X_train, y_train, print_progress=1, XY_test=(X_test,y_test))\n",
    "print_result(nn_long_ada,X_train,y_train,X_test,y_test,title=\"Long Run\",color=\"red\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "____\n",
    "# Rectified Linear Units\n",
    "Now lets look at another type of activation function. The rectified linear unit (ReLu) is an interesting choice to use because of its simplicity. Moreover, we will learn that its backpropagated derivative has some characteristics that are advantageous. \n",
    "\n",
    "We define the ReLU neuron as:\n",
    "\n",
    "$$\n",
    "    \\phi(\\mathbf{z}^{(i)})=\\left\\{\n",
    "                \\begin{array}{ll}\n",
    "                \\mathbf{z}^{(i)}  \\text{,  if }\\mathbf{z}^{(i)}>0 \\\\\n",
    "                \\mathbf{0} \\text{,      else } \\\\\n",
    "                \\end{array}\n",
    "              \\right.\n",
    "$$\n",
    "\n",
    "Which has a very simple derivative:\n",
    "$$\n",
    "    \\frac{\\partial\\phi(\\mathbf{z}^{(i)})}{\\partial\\mathbf{z}^{(i)}}=\\left\\{\n",
    "                \\begin{array}{ll}\n",
    "                \\mathbf{1} \\text{,  if }\\mathbf{z}^{(i)}>0 \\\\\n",
    "                \\mathbf{0} \\text{,      else } \\\\\n",
    "                \\end{array}\n",
    "              \\right.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TLPReLU(TLPAdaGrad):\n",
    "    def _initialize_weights(self):\n",
    "        \"\"\"Initialize weights with small random numbers.\"\"\"\n",
    "        # suggested relu/sigmoid bounds\n",
    "        #Xavier Glorot, Yoshua Bengio ; \n",
    "        #  Understanding the difficulty of training deep feedforward neural networks\n",
    "        #  Conference on Artificial Intelligence and Statistics, PMLR 9:249-256, 2010.\n",
    "        init_bound = np.sqrt(2)*np.sqrt(6. / (self.n_hidden + self.n_features_))\n",
    "        W1 = np.random.uniform(-init_bound, init_bound,(self.n_hidden, self.n_features_))\n",
    "        \n",
    "        # reduce the final layer magnitude in order to balance the size of the gradients\n",
    "        # between \n",
    "        init_bound = 4*np.sqrt(6 / (self.n_output_ + self.n_hidden))\n",
    "        W2 = np.random.uniform(-init_bound, init_bound,(self.n_output_, self.n_hidden)) \n",
    "        \n",
    "        b1 = np.zeros((self.n_hidden, 1))\n",
    "        b2 = np.zeros((self.n_output_, 1))\n",
    "        \n",
    "        return W1, W2, b1, b2\n",
    "    \n",
    "    @staticmethod\n",
    "    def _relu(Z):\n",
    "        return np.maximum(0, Z.copy())\n",
    "        \n",
    "    def _feedforward(self, X, W1, W2, b1, b2):\n",
    "        \"\"\"Compute feedforward step\n",
    "        \"\"\"\n",
    "        # A1->W1->ReLu->A2->W2->Sigmoid\n",
    "        A1 = X.T\n",
    "        Z1 = W1 @ A1 + b1\n",
    "        A2 = self._relu(Z1)\n",
    "        Z2 = W2 @ A2 + b2\n",
    "        A3 = self._sigmoid(Z2) # never use relu as last layer for classification (yuck!)\n",
    "        return A1, Z1, A2, Z2, A3\n",
    "    \n",
    "    def _get_gradient(self, A1, A2, A3, Z1, Z2, Y_enc, W1, W2):\n",
    "        \"\"\" Compute gradient step using backpropagation.\n",
    "        \"\"\"\n",
    "        # vectorized backpropagation\n",
    "        V2 = (A3-Y_enc) \n",
    "        \n",
    "        # V3[Z2<=0] = 0 # could can change to be relu back prop on this layer too!\n",
    "        \n",
    "        # old update: V1 = A2*(1-A2)*(W2.T @ V2)\n",
    "        # the derivative of sigmoid was A2(1-A2), but now that is relu\n",
    "        # so we change it to:\n",
    "        \n",
    "        V1 = (W2.T @ V2) \n",
    "        V1[Z1<=0] = 0\n",
    "        # relu derivative only zeros out certain values! easy!\n",
    "        \n",
    "        gradW2 = V2 @ A2.T\n",
    "        gradW1 = V1 @ A1.T\n",
    "        \n",
    "        gradb2 = np.sum(V2, axis=1).reshape((-1,1))\n",
    "        gradb1 = np.sum(V1, axis=1).reshape((-1,1))\n",
    "        \n",
    "        # regularize weights that are not bias terms\n",
    "        gradW1 += (W1 * self.l2_C)\n",
    "        gradW2 += (W2 * self.l2_C)\n",
    "\n",
    "        return gradW1, gradW2, gradb1, gradb2\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch: 75/75"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 8min 45s, sys: 50.6 s, total: 9min 35s\n",
      "Wall time: 1min 24s\n",
      "{'n_hidden': 50, 'C': 0.01, 'epochs': 75, 'eta': 0.005, 'alpha': 0.1, 'decrease_const': 0.1, 'decrease_iter': 20, 'minibatches': 234.375, 'shuffle': True, 'random_state': 1}\n"
     ]
    }
   ],
   "source": [
    "nn_long_relu = TLPReLU(**vals) # same as previous parameter values\n",
    "%time nn_long_relu.fit(X_train, y_train, print_progress=True, XY_test=(X_test,y_test))\n",
    "print(vals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================\n",
      "ReLU :\n",
      "Resubstitution acc: 0.9113833333333333\n",
      "Validation acc: 0.8716\n",
      "=================\n",
      "Sigmoid :\n",
      "Resubstitution acc: 0.92335\n",
      "Validation acc: 0.8832\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_result(nn_long_relu, X_train, y_train, X_test, y_test, title=\"ReLU\",color=\"blue\")\n",
    "print_result(nn_long_ada, X_train, y_train, X_test, y_test, title=\"Sigmoid\",color=\"red\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sklearn Implementation\n",
    "Let's see if our method stacks up to the implementations from `scikit-learn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0.2\n",
      "CPU times: user 3min 20s, sys: 18.8 s, total: 3min 39s\n",
      "Wall time: 55.2 s\n",
      "Validation Acc: 0.8725\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ericlarson/opt/anaconda3/envs/mlenv2022/lib/python3.7/site-packages/sklearn/neural_network/_multilayer_perceptron.py:696: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  ConvergenceWarning,\n"
     ]
    }
   ],
   "source": [
    "from sklearn import __version__ as sklearn_version\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "print(sklearn_version)\n",
    "# these values have been hand tuned\n",
    "# sigmoid with SGD, batching, nesterov's momentum, \n",
    "# L2, adaptive learning rate\n",
    "clf = MLPClassifier(hidden_layer_sizes=(50,), \n",
    "                    activation='logistic', # compare to sigmoid\n",
    "                    solver='sgd', \n",
    "                    alpha=1e-4, # L2 penalty\n",
    "                    batch_size=128, # min of 128, num_samples\n",
    "                    learning_rate='adaptive', # decrease rate if loss goes up\n",
    "                    learning_rate_init=0.1, # only SGD\n",
    "                    power_t=0.5,    # only SGD with inverse scaling\n",
    "                    max_iter=100, \n",
    "                    shuffle=True, \n",
    "                    random_state=1, \n",
    "                    tol=1e-9, # for stopping\n",
    "                    verbose=False, \n",
    "                    momentum=0.9, # only SGD\n",
    "                    nesterovs_momentum=True, # only SGD\n",
    "                    early_stopping=False, \n",
    "                    validation_fraction=0.1, # only if early_stop is true\n",
    "                    beta_1=0.9, # adam decay rate of moment\n",
    "                    beta_2=0.999, # adam decay rate of moment\n",
    "                    epsilon=1e-08) # adam numerical stabilizer\n",
    "\n",
    "%time clf.fit(X_train,y_train)\n",
    "yhat = clf.predict(X_test)\n",
    "print('Validation Acc:',accuracy_score(yhat,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3min 12s, sys: 18 s, total: 3min 30s\n",
      "Wall time: 53.1 s\n",
      "Validation Acc: 0.8678\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ericlarson/opt/anaconda3/envs/mlenv2022/lib/python3.7/site-packages/sklearn/neural_network/_multilayer_perceptron.py:696: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  ConvergenceWarning,\n"
     ]
    }
   ],
   "source": [
    "# but with this implementation we can also easily change Neurons\n",
    "# ReLU with SGD, batching, simple momentum, \n",
    "# L2, adaptive learning rate\n",
    "clf = MLPClassifier(hidden_layer_sizes=(50, ), \n",
    "                    activation='relu', # type of non-linearity, every layer except output layer\n",
    "                    solver='sgd', \n",
    "                    alpha=1e-4, # L2 penalty\n",
    "                    batch_size= 128, # min of 128, num_samples\n",
    "                    learning_rate='adaptive', # adapt learning? \n",
    "                    learning_rate_init=0.1, # only SGD\n",
    "                    power_t=0.0,    # only SGD with inverse scaling of learning rate\n",
    "                    max_iter=100, # stopping criteria\n",
    "                    shuffle=True, \n",
    "                    random_state=1, \n",
    "                    tol=0, # for stopping\n",
    "                    verbose=False, \n",
    "                    momentum=0.9, # only SGD\n",
    "                    nesterovs_momentum=False, # only SGD\n",
    "                    early_stopping=False, \n",
    "                    validation_fraction=0.0, # only if early_stop is true\n",
    "                    beta_1=0.9, # adam decay rate of moment\n",
    "                    beta_2=0.999, # adam decay rate of moment\n",
    "                    epsilon=1e-08) # adam numerical stabilizer\n",
    "\n",
    "%time clf.fit(X_train,y_train)\n",
    "yhat = clf.predict(X_test)\n",
    "print('Validation Acc:',accuracy_score(yhat,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ericlarson/opt/anaconda3/envs/mlenv2022/lib/python3.7/site-packages/sklearn/neural_network/_multilayer_perceptron.py:696: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  ConvergenceWarning,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 17min 11s, sys: 47.8 s, total: 17min 58s\n",
      "Wall time: 4min 31s\n",
      "Validation Acc: 0.858\n"
     ]
    }
   ],
   "source": [
    "# but what if we also use AdaM optimization?\n",
    "# ReLU with AdaM, batching, simple momentum, \n",
    "# L2, adaptive learning rate\n",
    "clf = MLPClassifier(hidden_layer_sizes=(50, ), \n",
    "                    activation='relu', # type of non-linearity, every layer except output layer\n",
    "                    solver='adam', \n",
    "                    alpha=1e-4, # L2 penalty\n",
    "                    batch_size= 128, # min of 200, num_samples\n",
    "                    learning_rate='adaptive', # adapt learning? \n",
    "                    learning_rate_init=0.01, # only SGD\n",
    "                    power_t=1,    # only SGD with inverse scaling of learning rate\n",
    "                    max_iter=100, # stopping criteria\n",
    "                    shuffle=True, \n",
    "                    random_state=1, \n",
    "                    tol=0, # for stopping\n",
    "                    verbose=False, \n",
    "                    momentum=0.9, # only SGD\n",
    "                    nesterovs_momentum=False, # only SGD\n",
    "                    early_stopping=False, \n",
    "                    validation_fraction=0.0, # only if early_stop is true\n",
    "                    beta_1=0.9, # adam decay rate of moment\n",
    "                    beta_2=0.999, # adam decay rate of moment\n",
    "                    epsilon=1e-08) # adam numerical stabilizer\n",
    "\n",
    "%time clf.fit(X_train,y_train)\n",
    "yhat = clf.predict(X_test)\n",
    "print('Validation Acc:',accuracy_score(yhat,y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "source": [
    "## In this notebook, you learned:\n",
    "- Simple optimization methods and tricks for Neural Networks\n",
    "- Cross Entropy Loss\n",
    "- Glorot and He Initialization\n",
    "- Adaptive methods, like AdaGrad\n",
    "- Rectified Linear Activation Functions"
   ]
  },
  {
   "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
}