softmax-classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Softmax Classification\n",
    "\n",
    "### Architecture\n",
    "    * Relu in hidden layers and softmax in the output layer\n",
    "    * Number of layers and number of units in each layer can be set using `layers_dims` hyper-parameter\n",
    "    * Uses softmax cross entropy for loss computation\n",
    "   \n",
    "### Dependencies\n",
    "    * Numpy\n",
    "    * Matplotlib (for plotting cost curves)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "c14f5fc3-7ae4-4775-aca6-4e89462d83df"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from utils.sc_utils import load_data, plot_training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "812c485b-1558-4c42-bf28-17cf898d8049"
    }
   },
   "source": [
    "## Parameters Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "a1126408-fd54-4d9e-a169-b248b7656a36"
    }
   },
   "outputs": [],
   "source": [
    "def initialize_parameters(layers_dims):\n",
    "    '''\n",
    "    Arguments:\n",
    "    layers_dims -- a list of dimensions of each layer of our network\n",
    "    \n",
    "    Returns:\n",
    "    parameters -- a dictionary containing weights and biases of the network\n",
    "    '''\n",
    "\n",
    "    parameters = {}\n",
    "    for l in range(len(layers_dims)-1):\n",
    "        parameters['W' + str(l+1)] = np.random.randn(layers_dims[l+1], layers_dims[l]) * 0.01\n",
    "        parameters['b' + str(l+1)] = np.zeros([layers_dims[l+1], 1])\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "fd3b570f-140d-4209-98cb-105a062f0cd7"
    }
   },
   "source": [
    "## Forward Propogation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "571916c8-3488-470d-a8ed-5091c197f9fe"
    }
   },
   "outputs": [],
   "source": [
    "def relu(X):\n",
    "    return np.maximum(X, 0)\n",
    "\n",
    "def softmax(X):\n",
    "    t = np.exp(X)\n",
    "    return  t / np.sum(t, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "965c3245-fdbd-4049-8905-98a0c913f525"
    }
   },
   "outputs": [],
   "source": [
    "def forward_propogation(A, parameters):\n",
    "    '''\n",
    "    Implement the forward propogation in the network\n",
    "    \n",
    "    Arguments:\n",
    "    A -- input to the network\n",
    "    parameters -- a dictionary containing weights and biases of the network\n",
    "    \n",
    "    Returns:\n",
    "    A -- Post activation value of the last layer\n",
    "    caches -- cache of all activation values, required for backpropogation \n",
    "    '''\n",
    "    \n",
    "    L = len(parameters) // 2 # no. of layers\n",
    "    caches  = {}\n",
    "    for l in range(L):\n",
    "        W = parameters['W' + str(l+1)]\n",
    "        b = parameters['b' + str(l+1)]\n",
    "        Z = np.dot(W, A) + b\n",
    "        A = relu(Z) if l<L-1 else softmax(Z) # relu in hidden layers and sigmoid in output layer\n",
    "        caches['A' + str(l+1)] = A\n",
    "        caches['Z' + str(l+1)] = Z\n",
    "\n",
    "    return A, caches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "c4713b4b-8f80-42e8-b0e4-658123b3a73f"
    }
   },
   "source": [
    "## Cost Computation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "938d86d0-a5a7-4a5f-9ef8-8e349fb78f04"
    }
   },
   "outputs": [],
   "source": [
    "def compute_cost(AL, Y):\n",
    "    \"\"\"\n",
    "    Implement the cost function for the network\n",
    "\n",
    "    Arguments:\n",
    "    AL -- probability vector corresponding to the label predictions, shape (10, number of examples)\n",
    "    Y -- true \"label\" vector, shape (10, number of examples)\n",
    "\n",
    "    Returns:\n",
    "    cost -- cross-entropy cost\n",
    "    \"\"\"\n",
    "    m = Y.shape[1]\n",
    "    cost = -1 / m * np.sum(Y * np.log(AL))\n",
    "    cost = np.squeeze(cost)\n",
    "    assert(cost.shape == ())\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "4c54d363-8bad-4c18-8882-3b1ed3c4b7f1"
    }
   },
   "source": [
    "## Backward Propogation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "277f8459-2d5a-4171-918b-1125ec7d553d"
    }
   },
   "outputs": [],
   "source": [
    "def relu_backward(grad_A, Z):\n",
    "    grad_A[Z<=0] = 0\n",
    "    return grad_A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "9d525583-9a97-44aa-940d-94b28dd39f29"
    }
   },
   "outputs": [],
   "source": [
    "def backward_propogation(X, Y, AL, caches, parameters):\n",
    "    '''\n",
    "    Implement Backpropogation\n",
    "    \n",
    "    Arguments:\n",
    "    Al -- Activations of last layer\n",
    "    Y -- True labels of data\n",
    "    caches -- dictionary containing values of A and Z of each layer\n",
    "    parameters -- dictionary containing parameters of the network\n",
    "    \n",
    "    Returns\n",
    "    grads -- dictionary containing gradients of the network parameters\n",
    "    '''\n",
    "    \n",
    "    grads = {}\n",
    "    m = Y.shape[1]\n",
    "    L = len(parameters) // 2\n",
    "\n",
    "    grad_Z =  1/m * (AL - Y)\n",
    "    \n",
    "    for l in reversed(range(1, L)):\n",
    "        grads['W' + str(l+1)] = np.dot(grad_Z, caches['A' + str(l)].T)\n",
    "        grads['b' + str(l+1)] = np.sum(grad_Z, axis=1, keepdims=True)\n",
    "        \n",
    "        assert(grads['W' + str(l+1)].shape == parameters['W' + str(l+1)].shape)\n",
    "        assert(grads['b' + str(l+1)].shape == parameters['b' + str(l+1)].shape)\n",
    "        \n",
    "        grad_A = np.dot(parameters['W' + str(l+1)].T, grad_Z)\n",
    "        grad_Z = relu_backward(grad_A, caches['Z' + str(l)])\n",
    "\n",
    "    #for first layer\n",
    "    grads['W1'] = np.dot(grad_Z, X.T)\n",
    "    grads['b1'] = np.sum(grad_Z, axis=1, keepdims=True)\n",
    "    \n",
    "    assert(grads['W1'].shape == parameters['W1'].shape)\n",
    "    assert(grads['b1'].shape == parameters['b1'].shape)\n",
    "\n",
    "    return grads"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "1736f426-5cad-44ad-92bc-fc6ccc6758db"
    }
   },
   "source": [
    "## Parameters Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "ef33b53a-de6b-4fb5-9111-508c9183f35f"
    }
   },
   "outputs": [],
   "source": [
    "def update_parameters(parameters, grads, learning_rate):\n",
    "    '''\n",
    "    Update parameters of the network using gradient descent\n",
    "    \n",
    "    Arguments:\n",
    "    paramters -- dictionary containing weights and biases of the network\n",
    "    grads -- dictionary containing the gradients of the parameters\n",
    "    learning_rate -- rate of gradient descent\n",
    "    \n",
    "    Returns\n",
    "    parameters -- dictionary containing updated parameters\n",
    "    '''\n",
    "    \n",
    "    L = len(parameters)//2\n",
    "    for l in reversed(range(L-1)):\n",
    "        parameters['W'+str(l+1)] -= learning_rate * grads['W' + str(l+1)]\n",
    "        parameters['b'+str(l+1)] -= learning_rate * grads['b' + str(l+1)]\n",
    "        \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "399cefc4-a924-41c2-994a-43902692ff76"
    }
   },
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "237535d0-fd38-4421-baaf-592076b72e67"
    }
   },
   "outputs": [],
   "source": [
    "def Model(X, Y, X_val, Y_val, layers_dims, epochs, learning_rate):\n",
    "    \n",
    "    parameters = initialize_parameters(layers_dims)\n",
    "    costs_train = []\n",
    "    costs_val = []\n",
    "    \n",
    "    for epoch in range(epochs+1):\n",
    "        AL, caches = forward_propogation(X, parameters)\n",
    "        cost = compute_cost(AL, Y)\n",
    "        grads = backward_propogation(X, Y, AL, caches, parameters)\n",
    "        parameters = update_parameters(parameters, grads, learning_rate)\n",
    "\n",
    "        # compute validation cost\n",
    "        AL_val, _ = forward_propogation(X_val, parameters)\n",
    "        cost_val = compute_cost(AL_val, Y_val)\n",
    "        costs_train.append(cost)\n",
    "        costs_val.append(cost_val)\n",
    "        if epoch%10 == 0:\n",
    "            print('Epoch:', epoch, 'Cost: %0.3f' % cost, '- Val Cost: %0.3f' % cost_val)\n",
    "    \n",
    "    plot_training(costs_train, costs_val)\n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "b12fa819-ef1c-468d-ac07-184adeb85519"
    }
   },
   "source": [
    "## Implementing the model on MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "nbpresent": {
     "id": "5457c250-fd02-466b-8286-02b5749b757b"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(784, 50000) (10, 50000) (784, 10000) (10, 10000)\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Load MNIST dataset, Find the code in utils/sc_utils.py\n",
    "'''\n",
    "train, val = load_data()\n",
    "X_train, Y_train = train\n",
    "X_val, Y_val = val\n",
    "\n",
    "print(X_train.shape, Y_train.shape, X_val.shape, Y_val.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "c551d248-6228-48ec-83cf-d6ec46639245"
    }
   },
   "outputs": [],
   "source": [
    "# hyper-parameters, let's take these values for our example!\n",
    "epochs = 500\n",
    "learning_rate = 0.5\n",
    "layers_dims = [784, 512, 128, 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "nbpresent": {
     "id": "b737c4a1-2309-4dbf-9897-4b564bb2497f"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 Cost: 2.303 - Val Cost: 2.302\n",
      "Epoch: 10 Cost: 2.301 - Val Cost: 2.301\n",
      "Epoch: 20 Cost: 2.299 - Val Cost: 2.299\n",
      "Epoch: 30 Cost: 2.296 - Val Cost: 2.296\n",
      "Epoch: 40 Cost: 2.292 - Val Cost: 2.291\n",
      "Epoch: 50 Cost: 2.286 - Val Cost: 2.285\n",
      "Epoch: 60 Cost: 2.278 - Val Cost: 2.276\n",
      "Epoch: 70 Cost: 2.266 - Val Cost: 2.264\n",
      "Epoch: 80 Cost: 2.248 - Val Cost: 2.245\n",
      "Epoch: 90 Cost: 2.224 - Val Cost: 2.220\n",
      "Epoch: 100 Cost: 2.191 - Val Cost: 2.185\n",
      "Epoch: 110 Cost: 2.147 - Val Cost: 2.139\n",
      "Epoch: 120 Cost: 2.090 - Val Cost: 2.080\n",
      "Epoch: 130 Cost: 2.021 - Val Cost: 2.008\n",
      "Epoch: 140 Cost: 1.939 - Val Cost: 1.923\n",
      "Epoch: 150 Cost: 1.845 - Val Cost: 1.827\n",
      "Epoch: 160 Cost: 1.744 - Val Cost: 1.723\n",
      "Epoch: 170 Cost: 1.639 - Val Cost: 1.615\n",
      "Epoch: 180 Cost: 1.532 - Val Cost: 1.506\n",
      "Epoch: 190 Cost: 1.427 - Val Cost: 1.400\n",
      "Epoch: 200 Cost: 1.329 - Val Cost: 1.299\n",
      "Epoch: 210 Cost: 1.237 - Val Cost: 1.206\n",
      "Epoch: 220 Cost: 1.153 - Val Cost: 1.121\n",
      "Epoch: 230 Cost: 1.079 - Val Cost: 1.045\n",
      "Epoch: 240 Cost: 1.013 - Val Cost: 0.979\n",
      "Epoch: 250 Cost: 0.955 - Val Cost: 0.919\n",
      "Epoch: 260 Cost: 0.904 - Val Cost: 0.867\n",
      "Epoch: 270 Cost: 0.858 - Val Cost: 0.821\n",
      "Epoch: 280 Cost: 0.818 - Val Cost: 0.781\n",
      "Epoch: 290 Cost: 0.783 - Val Cost: 0.745\n",
      "Epoch: 300 Cost: 0.751 - Val Cost: 0.713\n",
      "Epoch: 310 Cost: 0.723 - Val Cost: 0.685\n",
      "Epoch: 320 Cost: 0.697 - Val Cost: 0.659\n",
      "Epoch: 330 Cost: 0.675 - Val Cost: 0.637\n",
      "Epoch: 340 Cost: 0.654 - Val Cost: 0.616\n",
      "Epoch: 350 Cost: 0.635 - Val Cost: 0.598\n",
      "Epoch: 360 Cost: 0.619 - Val Cost: 0.581\n",
      "Epoch: 370 Cost: 0.603 - Val Cost: 0.566\n",
      "Epoch: 380 Cost: 0.589 - Val Cost: 0.552\n",
      "Epoch: 390 Cost: 0.576 - Val Cost: 0.539\n",
      "Epoch: 400 Cost: 0.564 - Val Cost: 0.527\n",
      "Epoch: 410 Cost: 0.553 - Val Cost: 0.516\n",
      "Epoch: 420 Cost: 0.543 - Val Cost: 0.506\n",
      "Epoch: 430 Cost: 0.533 - Val Cost: 0.497\n",
      "Epoch: 440 Cost: 0.524 - Val Cost: 0.488\n",
      "Epoch: 450 Cost: 0.516 - Val Cost: 0.480\n",
      "Epoch: 460 Cost: 0.508 - Val Cost: 0.472\n",
      "Epoch: 470 Cost: 0.501 - Val Cost: 0.465\n",
      "Epoch: 480 Cost: 0.494 - Val Cost: 0.459\n",
      "Epoch: 490 Cost: 0.487 - Val Cost: 0.452\n",
      "Epoch: 500 Cost: 0.481 - Val Cost: 0.446\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2ad043b53630>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "parameters = Model(X_train, Y_train, X_val, Y_val, layers_dims, epochs, learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:ML]",
   "language": "python",
   "name": "conda-env-ML-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.4"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}