train_neural_net-relu_droput.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy\n",
    "from sklearn.metrics import precision_recall_fscore_support\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "# prepare data\n",
    "train_data_features = np.loadtxt(fname=\"train_data.txt\",dtype=float,delimiter=',', usecols = (0,1))\n",
    "train_data_target = np.loadtxt(fname=\"train_data.txt\",dtype=float,delimiter=',', usecols = 2)\n",
    "X_test = np.loadtxt(fname=\"test_data.txt\",dtype=float,delimiter=',', usecols = (0,1))\n",
    "Y_test = np.loadtxt(fname=\"test_data.txt\",dtype=float,delimiter=',', usecols = 2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layers: 4\n",
      "{'W1': matrix([[0.91732521, 0.24366282],\n",
      "        [0.22695608, 0.13566109],\n",
      "        [0.08319326, 0.03149661]]), 'W2': matrix([[0.31371914, 0.34873642, 0.31119451],\n",
      "        [0.57211365, 0.85650461, 0.95483763],\n",
      "        [0.71097728, 0.81796371, 0.95078436]]), 'W3': matrix([[0.43568707, 0.38956284, 0.79545481],\n",
      "        [0.03845922, 0.11334366, 0.54581169]])}\n"
     ]
    }
   ],
   "source": [
    "# intitalize params\n",
    "\n",
    "def init_params(dim):\n",
    "    dim = [2,3,3,2]\n",
    "    parameters = {}\n",
    "    \n",
    "    layers = len(dim)\n",
    "    print (\"layers:\",layers)\n",
    "    \n",
    "    for i in range(1,layers):\n",
    "        parameters['W' + str(i)] = np.matrix(np.random.rand(dim[i],dim[i-1]))\n",
    "    return parameters\n",
    "    \n",
    "     \n",
    "params = init_params('dim')\n",
    "print (params)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''def sigmoid(z):\n",
    "    s = 1/ (1 + np.exp(-z))\n",
    "    return s\n",
    "'''\n",
    "\n",
    "def relu(z):\n",
    "    if z.any() >= 0:\n",
    "        return z\n",
    "    elif z.any() <0:\n",
    "        return 0\n",
    "    \n",
    "#relu = lambda z: z if z>=0 else 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grad_relu(s):\n",
    "    jacobian_m = np.zeros((s.shape[0], s.shape[0])) # For 3*1 vector, jacobian is 3*3 matrix\n",
    "    for i in range(len(jacobian_m)):\n",
    "        for j in range(len(jacobian_m)):    \n",
    "            if i == j:               \n",
    "                jacobian_m[i,j] = s[i] * (1 - (s[i]))\n",
    "            else:\n",
    "                jacobian_m[i,j] = 0          \n",
    "    return jacobian_m    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grad_softmax(s):\n",
    "# initialize the 2-D jacobian matrix.\n",
    "    jacobian_m = np.zeros((s.shape[0], s.shape[0])) #  For 2*1 vector, jacobian is 2*2 matrix\n",
    "    for i in range(len(jacobian_m)):\n",
    "        for j in range(len(jacobian_m)):\n",
    "            if i == j:\n",
    "                #print (\" s[i] :\",  s[i])\n",
    "                jacobian_m[i][j] = s[i] * (1-s[i])\n",
    "            else: \n",
    "                jacobian_m[i][j] = -s[i]*s[j]\n",
    "    return jacobian_m\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax(Z3):\n",
    "    k = 0\n",
    "    for i in range(len(Z3)):\n",
    "        k += np.exp(Z3[i])\n",
    "    for i in range(len(Z3)):\n",
    "        Z3[i] = np.exp(Z3[i])/k\n",
    "    return Z3\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward_prop(W1,W2,W3,train_data_features):       \n",
    "    Z1 = np.dot(W1, np.matrix(train_data_features).T)\n",
    "    # W1 = 3 * 2\n",
    "    #train_feature = 1 * 2\n",
    "    #Z1 = 3 *1\n",
    "\n",
    "    A1 = relu(Z1)\n",
    "    \n",
    "    # define a mask with same size as weight matrix \n",
    "    K2 = np.random.rand(W2.shape[0], W2.shape[1])  \n",
    "    #print (\"K2 orig:\", K2) \n",
    "    '''\n",
    "    for i,v in enumerate(K2):\n",
    "        #print (type(i))\n",
    "        #print (type(v))\n",
    "        if v.any() <=0.5:\n",
    "            K2[i] = 0\n",
    "        else:\n",
    "            K2[i] = 1\n",
    "    '''\n",
    "    #add drop outs by converting the some values of mask to zeroes to be multipled to wt matrix\n",
    "    threshold = 0.5\n",
    "    K2 = (K2 < threshold).astype(int)\n",
    "    #print (\"K2 after modify:\", K2)\n",
    "\n",
    "    \n",
    "    W2 = np.array(W2) * np.array(K2)\n",
    "    #print (\"W2 after droput:\", W2)\n",
    "    \n",
    "\n",
    "    Z2 = np.dot(W2, A1)\n",
    "    #Z2 = np.dot(W2, A1)\n",
    "    A2 = relu(Z2)\n",
    "\n",
    "    #W2 = 3 * 3\n",
    "    #A1 = 3 * 1\n",
    "    #Z2 = 3 * 1\n",
    "    #A2 = 3 * 1\n",
    "    \n",
    "    ### create a mask matrix to mask activation of A1 with drop out\n",
    "    #K2 = np.random.rand(A2.shape[0], A2.shape[1])\n",
    "    #K2 = (K2 < 0.7).astype(int)\n",
    "    #A2 = A2 * K2\n",
    "    \n",
    "    \n",
    "   \n",
    "    \n",
    "    \n",
    "\n",
    "    Z3 = np.dot(W3,A2)\n",
    "    #Z3 = np.dot(W3,A2)\n",
    "    #W3 = 2 * 3\n",
    "    #A2 = 3 * 1\n",
    "    #Z3 = 2 * 1\n",
    "\n",
    "    y_hat = softmax(Z3)\n",
    "    #y_hat = 2 * 1\n",
    "    \n",
    "    return K2,A1,A2,y_hat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimise(K2,A1,A2,W1,W2,W3,y_hat,train_data_target,train_data_features,learning_rate):\n",
    "    \n",
    "    loss = np.sum(np.square(train_data_target - y_hat))\n",
    "\n",
    "    # train_data_features = 1 * 2\n",
    "    # y_hat = 2 * 1\n",
    "    #loss = 1 *2 \n",
    "\n",
    "    change_loss = -2 *(np.transpose(train_data_target)-y_hat)\n",
    "    #change_loss = 2 *1\n",
    "\n",
    "    delta_3 = np.dot(np.matrix(grad_softmax(y_hat)),change_loss)\n",
    "\n",
    "    #delta_3 = 2*1\n",
    "    #A2 = 3 * 1\n",
    "\n",
    "    dW3 = np.multiply (A2,delta_3.T)\n",
    "\n",
    "    #dw3 = 3 *2\n",
    "    #A2 = 3 * 1\n",
    "    #W3 = 2 * 3\n",
    "    #1* 2\n",
    "\n",
    "    delta_2 = np.dot(np.dot(grad_relu(A2),W3.T), delta_3)\n",
    "    #print (\"delta 2 orig shape:\", delta_2.shape)\n",
    "    ## (3 * 1) * (3 * 2) * (2 * 1)\n",
    "    \n",
    "    \n",
    "    # 3*1 = 3*1 1*1\n",
    "\n",
    "    dW2 = np.dot(A1, delta_2.T)\n",
    "    #Multiply with the same mask as forward prop\n",
    "    dW2 =  np.array(dW2) * np.array(K2)\n",
    "\n",
    "    delta_1 = np.dot(np.dot(grad_relu(A1),np.transpose(W2)), delta_2)\n",
    "\n",
    "    dW1 = np.dot(np.transpose(np.matrix(train_data_features)), delta_1.T)\n",
    "\n",
    "    W1 = W1 -learning_rate * np.transpose(dW1)\n",
    "    W2 = W2- learning_rate * dW2.T\n",
    "    W3 = W3 - learning_rate * dW3.T        \n",
    "    return  W1,W2,W3,loss\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train (train_data_features,train_data_target):\n",
    "    epochs = 50\n",
    "    learning_rate = 0.01\n",
    "    loss_list =[]\n",
    "    W1 = params['W1']\n",
    "    W2 = params['W2']\n",
    "    W3 = params['W3']\n",
    "\n",
    "    for i in range(1,epochs):\n",
    "        for j in range(len(train_data_features)):         \n",
    "            K2,A1,A2,y_hat = forward_prop(W1,W2,W3,train_data_features[j])\n",
    "            W1,W2,W3,loss=optimise(K2,A1,A2,W1,W2,W3,y_hat,train_data_target[j],train_data_features[j],learning_rate) \n",
    "        \n",
    "        print(\"The Loss after \" +str(i)+ \" epochs: \", loss )\n",
    "        loss_list.append(loss)\n",
    "        #print (\"loss list:\", loss_list)\n",
    "    return W1,W2,W3,loss_list\n",
    "        \n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Loss after 1 epochs:  0.502944953562907\n",
      "The Loss after 2 epochs:  0.5001060386543216\n",
      "The Loss after 3 epochs:  0.5004793272842332\n",
      "The Loss after 4 epochs:  0.5004666514427821\n",
      "The Loss after 5 epochs:  0.5000369271319016\n",
      "The Loss after 6 epochs:  0.5002332821230151\n",
      "The Loss after 7 epochs:  0.5002222057191594\n",
      "The Loss after 8 epochs:  0.5001445833254887\n",
      "The Loss after 9 epochs:  0.5000592044451054\n",
      "The Loss after 10 epochs:  0.5000053145709947\n",
      "The Loss after 11 epochs:  0.5000001095074638\n",
      "The Loss after 12 epochs:  0.5000553606643865\n",
      "The Loss after 13 epochs:  0.5001759751231271\n",
      "The Loss after 14 epochs:  0.5000001787633556\n",
      "The Loss after 15 epochs:  0.5000110941259811\n",
      "The Loss after 16 epochs:  0.5000178943251944\n",
      "The Loss after 17 epochs:  0.5000104111793005\n",
      "The Loss after 18 epochs:  0.5000460016283762\n",
      "The Loss after 19 epochs:  0.5000024036032563\n",
      "The Loss after 20 epochs:  0.5000355493043681\n",
      "The Loss after 21 epochs:  0.5000361582435189\n",
      "The Loss after 22 epochs:  0.5000003713129737\n",
      "The Loss after 23 epochs:  0.5000242229501359\n",
      "The Loss after 24 epochs:  0.500001104274436\n",
      "The Loss after 25 epochs:  0.5000004696437184\n",
      "The Loss after 26 epochs:  0.5000112744600108\n",
      "The Loss after 27 epochs:  0.5000237984778201\n",
      "The Loss after 28 epochs:  0.5000023703687271\n",
      "The Loss after 29 epochs:  0.5000025274219931\n",
      "The Loss after 30 epochs:  0.5000010980825558\n",
      "The Loss after 31 epochs:  0.5000019645959052\n",
      "The Loss after 32 epochs:  0.5000010823224382\n",
      "The Loss after 33 epochs:  0.5000024630765442\n",
      "The Loss after 34 epochs:  0.500004615708277\n",
      "The Loss after 35 epochs:  0.5000002154108061\n",
      "The Loss after 36 epochs:  0.500001710834014\n",
      "The Loss after 37 epochs:  0.5000038125152814\n",
      "The Loss after 38 epochs:  0.5000031495572944\n",
      "The Loss after 39 epochs:  0.5000001132202602\n",
      "The Loss after 40 epochs:  0.500001687799887\n",
      "The Loss after 41 epochs:  0.500000623640427\n",
      "The Loss after 42 epochs:  0.5000001279596515\n",
      "The Loss after 43 epochs:  0.5000005911105367\n",
      "The Loss after 44 epochs:  0.500000426843753\n",
      "The Loss after 45 epochs:  0.5000010597672839\n",
      "The Loss after 46 epochs:  0.5000000042799798\n",
      "The Loss after 47 epochs:  0.5000004736153028\n",
      "The Loss after 48 epochs:  0.5000004037342686\n",
      "The Loss after 49 epochs:  0.5000001454991966\n",
      "Final Wts 1: (3, 2)\n",
      "Final Wts 2: (3, 3)\n",
      "Final Wts 3: (2, 3)\n"
     ]
    }
   ],
   "source": [
    "W1_final, W2_final, W3_final, loss_list = train(train_data_features,train_data_target)\n",
    "print (\"Final Wts 1:\", W1_final.shape)\n",
    "print (\"Final Wts 2:\", W2_final.shape)\n",
    "print (\"Final Wts 3:\", W3_final.shape)\n",
    "\n",
    "## Divide final weights by 2/3 \n",
    "multiply_mat_1 = np.full((3, 2), 0.67)\n",
    "multiply_mat_2 = np.full((3, 3), 0.67)\n",
    "multiply_mat_3 = np.full((2, 3), 0.67)\n",
    "\n",
    "W1_final = np.array(W1_final) * multiply_mat_1\n",
    "W2_final = np.array(W2_final) * multiply_mat_2\n",
    "W3_final = np.array(W3_final) * multiply_mat_3\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (loss_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'loss')"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0,49,49)\n",
    "y = loss_list\n",
    "plt.plot(x,y)\n",
    "plt.xlabel('epochs')\n",
    "plt.ylabel('loss')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "precision: 0.4898785425101215\n",
      "recall: 0.484\n",
      "F1 score: 0.24346076458752516\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "true_val = []\n",
    "pred_val = []\n",
    "     \n",
    "for j in range(len(X_test)):\n",
    "    K2,A1,A2,y_hat = forward_prop(W1_final,W2_final,W3_final,X_test[j])   \n",
    "    y_hat = np.squeeze(np.asarray(y_hat))\n",
    "    y_true = Y_test[j]\n",
    "    y_true = np.squeeze(np.asarray(y_true))\n",
    "\n",
    "    if y_true == 1:\n",
    "        true_val.append(\"1\")\n",
    "    else:\n",
    "        true_val.append(\"0\")\n",
    "\n",
    "    if y_hat[0] >y_hat[1]:\n",
    "        pred_val.append(\"1\")\n",
    "\n",
    "    else:\n",
    "        pred_val.append(\"0\")\n",
    "\n",
    "confusion_matric = confusion_matrix(true_val, pred_val)\n",
    "tn, fp, fn, tp = confusion_matric.ravel()\n",
    "#print (tn, fp, fn, tp)\n",
    "\n",
    "precision = tp/(tp + fp)\n",
    "recall = tp/(tp + fn)\n",
    "f1_score = (precision * recall)/(precision + recall)\n",
    "print (\"precision:\", precision)\n",
    "print (\"recall:\", recall)\n",
    "print (\"F1 score:\", f1_score)\n",
    "    \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# observations after changing to RELU activaion and adding drop outs\n",
    "New precision recall values are 49 percent and 48 percent respectively.\n",
    "The loss vs epoch graph is also showing some fluctuations with increase in epochs."
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}