Logistic Regression - Student Notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Rhyme](https://rhyme.com/assets/img/logo-dark.png)\n",
    "\n",
    "# Deep Learning Fundamentals - Logistic Regression\n",
    "\n",
    "# Task 1: Introduction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Libraries imported\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import warnings\n",
    "import helpers.plt, helpers.dataset\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "print('Libraries imported')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 2: Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "parameters"
    ]
   },
   "outputs": [],
   "source": [
    "lr = 0.3\n",
    "batch_size = 300\n",
    "iterations = 40"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 3: Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading data..\n",
      "Done.\n"
     ]
    }
   ],
   "source": [
    "(X_train, Y_train), (X_test, Y_test) =helpers.dataset.get_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of X_train: (12665, 28, 28)\n",
      "Shape of Y_train: (12665,)\n",
      "Shape of X_test: (2115, 28, 28)\n",
      "Shape of Y_test: (2115,)\n"
     ]
    }
   ],
   "source": [
    "print('Shape of X_train:', X_train.shape)\n",
    "print('Shape of Y_train:', Y_train.shape)\n",
    "print('Shape of X_test:', X_test.shape)\n",
    "print('Shape of Y_test:', Y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "helpers.plt.show_example(X_train[0], Y_train[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "helpers.plt.show_example(X_train[-1],Y_train[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 4: A Mini Batch of Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_batch Shape (1, 784)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_batch, Y_batch = helpers.dataset.get_random_batch(X_train, Y_train, 1)\n",
    "print('X_batch Shape', X_batch.shape)\n",
    "helpers.plt.show_example(X_batch[0], Y_batch[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_batch, Y_batch = helpers.dataset.get_random_batch(X_test, Y_test, 1)\n",
    "helpers.plt.show_example(X_batch[0], Y_batch[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_batch, Y_batch = helpers.dataset.get_random_batch(X_train, Y_train, 10)\n",
    "helpers.plt.show_ten_examples(X_batch, Y_batch, Y_batch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 5: Create Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A logistic model is simply a multi variable linear equation which gives a binary output. The pixel values of our input images are going to be the input features - the independent variables that form the logistic regression equation. And the class label - either 0 or 1 in our case, is the output y."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{equation}\n",
    "z = b + w_1x_1 + w_2x_2 + ... + w_N * x_N\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "y = \\sigma(z)\n",
    "\\end{equation}\n",
    "\n",
    "To simplify, we can use vectorized represenation where X is the feature matrix and W is the weight matrix:\n",
    "\n",
    "\\begin{equation}\n",
    "y = \\sigma(W^T.X + b)\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================\n",
      "Number of features: 784\n",
      "Shape of weights: (784, 1)\n",
      "Shape of biases: (1, 1)\n",
      "=================================\n"
     ]
    }
   ],
   "source": [
    "class LogisticModel:\n",
    "    def __init__(self, num_features):\n",
    "        # Your code here\n",
    "        self.W=np.reshape(np.random.randn((num_features)), (num_features,1 ))\n",
    "        self.b=np.zeros((1,1))\n",
    "        self.num_features =num_features\n",
    "        self.losses=[]\n",
    "        self.accuracies=[]\n",
    "        \n",
    "    def summary(self):\n",
    "        print('=================================')\n",
    "        print('Number of features:', self.num_features)\n",
    "        print('Shape of weights:', self.W.shape)\n",
    "        print('Shape of biases:', self.b.shape)\n",
    "        print('=================================')\n",
    "        \n",
    "# Your code here\n",
    "model=LogisticModel(num_features=784)\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 5: Forward Pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a single training example, the loss should be:\n",
    "\n",
    "\\begin{equation}\n",
    "L(y, \\hat{y}) = -(y * log(\\hat{y}) + (1 - y) * log(1 - \\hat{y}))\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LogisticModel(LogisticModel):\n",
    "    def _forward_pass(self, X, Y=None):\n",
    "        # Your code here\n",
    "        batch_size=X.shape[0]\n",
    "        Z= np.dot(X, self.W) +self.b\n",
    "        A =1./(1+np.exp(-Z))\n",
    "        loss =float(1e6)\n",
    "        if Y is not None:\n",
    "            loss =-1*np.sum(np.dot(np.transpose(Y), np.log(A)) + \\\n",
    "                     np.matmul(np.transpose(1-Y), np.log(1-A)))\n",
    "            loss /=batch_size\n",
    "        return A, loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 6: Backward Pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LogisticModel(LogisticModel):\n",
    "    def _backward_pass(self, A, X, Y):\n",
    "        # Your code here\n",
    "        batch_size = X.shape[0]\n",
    "        dZ = A-Y\n",
    "        dW=np.dot(np.transpose(X), dZ) / batch_size\n",
    "        db=np.sum(dZ) / batch_size\n",
    "        return dW, db"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 7: Update Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LogisticModel(LogisticModel):\n",
    "    def _update_params(self, dW, db, lr):\n",
    "        # Your code here\n",
    "        self.W -= lr *dW\n",
    "        self.b -= lr *db"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 8: Check Model Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LogisticModel(LogisticModel):\n",
    "    def predict(self, X, Y=None):\n",
    "        # Your code here\n",
    "        A, loss =self._forward_pass (X,Y)\n",
    "        Y_hat =A>0.5\n",
    "        return np.squeeze(Y_hat), loss\n",
    "    \n",
    "    def evaluate(self, X, Y):\n",
    "        # Your code here\n",
    "        Y_hat ,loss =self.predict(X,Y)\n",
    "        accuracy =np.sum(Y_hat ==np.squeeze(Y)) /X.shape[0]\n",
    "        return accuracy, loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================\n",
      "Number of features: 784\n",
      "Shape of weights: (784, 1)\n",
      "Shape of biases: (1, 1)\n",
      "=================================\n",
      "Untrained mode; accuracy: 0.2633333333333333, loss: 4.3975221631705335\n"
     ]
    }
   ],
   "source": [
    "model = LogisticModel(784)\n",
    "model.summary()\n",
    "X, Y = helpers.dataset.get_random_batch(X_test, Y_test, batch_size)\n",
    "acc, loss =model.evaluate(X, Y)\n",
    "print('Untrained mode; accuracy: {}, loss: {}'.format(acc, loss))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "preds, _ = model.predict(X)\n",
    "helpers.plt.show_ten_examples(X, Y, preds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 9: Training Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LogisticModel(LogisticModel):\n",
    "    def train(self, batch_size, get_batch, lr, iterations, X_train, Y_train, X_test, Y_test):\n",
    "        # Your code here\n",
    "        print('Training..')\n",
    "        self.accuracies =[]\n",
    "        self.losses =[]\n",
    "        for i in range(iterations):\n",
    "            X, Y =get_batch(X_train, Y_train, batch_size)\n",
    "            A, _ =self._forward_pass(X,Y)\n",
    "            dW,db =self._backward_pass(A, X, Y)\n",
    "            self._update_params(dW, db, lr)\n",
    "            \n",
    "            X, Y = get_batch(X_test , Y_test, batch_size)\n",
    "            val_acc, val_loss =self.evaluate(X,Y)\n",
    "            self.accuracies.append(val_acc)\n",
    "            self.losses.append(val_loss)\n",
    "            \n",
    "            print('Iter: {}, Val Acc:{:.3f}, Val Loss:{:.3f}'.format(i, val_acc, val_loss))\n",
    "        print('Traing is finished')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 10: Training the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before Training performance: (0.79, 0.6930897547120676)\n",
      "Training..\n",
      "Iter: 0, Val Acc:0.880, Val Loss:0.368\n",
      "Iter: 1, Val Acc:0.897, Val Loss:0.331\n",
      "Iter: 2, Val Acc:0.877, Val Loss:0.317\n",
      "Iter: 3, Val Acc:0.890, Val Loss:0.313\n",
      "Iter: 4, Val Acc:0.907, Val Loss:0.236\n",
      "Iter: 5, Val Acc:0.910, Val Loss:0.290\n",
      "Iter: 6, Val Acc:0.933, Val Loss:0.241\n",
      "Iter: 7, Val Acc:0.933, Val Loss:0.206\n",
      "Iter: 8, Val Acc:0.953, Val Loss:0.134\n",
      "Iter: 9, Val Acc:0.923, Val Loss:0.197\n",
      "Iter: 10, Val Acc:0.950, Val Loss:0.173\n",
      "Iter: 11, Val Acc:0.960, Val Loss:0.133\n",
      "Iter: 12, Val Acc:0.940, Val Loss:0.160\n",
      "Iter: 13, Val Acc:0.930, Val Loss:0.137\n",
      "Iter: 14, Val Acc:0.953, Val Loss:0.153\n",
      "Iter: 15, Val Acc:0.967, Val Loss:0.087\n",
      "Iter: 16, Val Acc:0.970, Val Loss:0.103\n",
      "Iter: 17, Val Acc:0.960, Val Loss:0.081\n",
      "Iter: 18, Val Acc:0.953, Val Loss:0.124\n",
      "Iter: 19, Val Acc:0.950, Val Loss:0.119\n",
      "Iter: 20, Val Acc:0.970, Val Loss:0.079\n",
      "Iter: 21, Val Acc:0.973, Val Loss:0.061\n",
      "Iter: 22, Val Acc:0.950, Val Loss:0.112\n",
      "Iter: 23, Val Acc:0.983, Val Loss:0.071\n",
      "Iter: 24, Val Acc:0.973, Val Loss:0.067\n",
      "Iter: 25, Val Acc:0.983, Val Loss:0.066\n",
      "Iter: 26, Val Acc:0.973, Val Loss:0.077\n",
      "Iter: 27, Val Acc:0.980, Val Loss:0.098\n",
      "Iter: 28, Val Acc:0.970, Val Loss:0.081\n",
      "Iter: 29, Val Acc:0.973, Val Loss:0.064\n",
      "Iter: 30, Val Acc:0.983, Val Loss:0.043\n",
      "Iter: 31, Val Acc:0.967, Val Loss:0.089\n",
      "Iter: 32, Val Acc:0.980, Val Loss:0.054\n",
      "Iter: 33, Val Acc:0.977, Val Loss:0.044\n",
      "Iter: 34, Val Acc:0.983, Val Loss:0.045\n",
      "Iter: 35, Val Acc:0.980, Val Loss:0.043\n",
      "Iter: 36, Val Acc:0.983, Val Loss:0.047\n",
      "Iter: 37, Val Acc:0.980, Val Loss:0.062\n",
      "Iter: 38, Val Acc:0.993, Val Loss:0.032\n",
      "Iter: 39, Val Acc:0.990, Val Loss:0.033\n",
      "Traing is finished\n",
      "After Training performance: (0.9866666666666667, 0.04525148732022815)\n"
     ]
    }
   ],
   "source": [
    "model = LogisticModel(784)\n",
    "\n",
    "X, Y =helpers.dataset.get_random_batch(X_test, Y_test, batch_size)\n",
    "print('Before Training performance:', model.evaluate(X, Y))\n",
    "model.train(\n",
    "    batch_size,\n",
    "    helpers.dataset.get_random_batch,\n",
    "    lr,\n",
    "    iterations,\n",
    "    X_train, Y_train,\n",
    "    X_test, Y_test\n",
    "    \n",
    ")\n",
    "print('After Training performance:', model.evaluate(X, Y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 11: Display the Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "helpers.plt.plot_metrics(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "preds, _ =model.predict(X, Y)\n",
    "helpers.plt.show_ten_examples(X, Y, preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}