nnn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c4b287cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "random.seed(43)\n",
    "\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2bdb3b65",
   "metadata": {},
   "outputs": [],
   "source": [
    "#generate random data with seed for reproducibility\n",
    "#input matrix of shape (1000,4)\n",
    "np.random.seed(43)\n",
    "a = np.random.randn(1000,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b54891d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#generate random data with seed for reproducibility\n",
    "#output vector of shape (1000,1)\n",
    "np.random.seed(43)\n",
    "b = np.random.randn(1000,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "891a0e23",
   "metadata": {},
   "source": [
    "$$J = -\\frac{1}{m}\\sum\\limits_{i=1}^{m}y_i \\ln(a_i)+(1-y_i)\\ln(1-a_i)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0055acbc",
   "metadata": {},
   "source": [
    "$$A = \\sigma(w^{T}x + b)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b080785",
   "metadata": {},
   "source": [
    "$$ \\frac{\\partial J}{\\partial w} = \\frac{1}{m}X(A-Y)^T$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "016318ef",
   "metadata": {},
   "source": [
    "$$\\frac{\\partial J}{\\partial b} = \\frac{1}{m}\\sum\\limits_{i=1}^{m}(a_i - y_i)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6ae3724c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class nn(object):\n",
    "    \"\"\"\n",
    "    Class constructor.\n",
    "    \"\"\"\n",
    "    def __init__(self,x0:np.ndarray,y0:np.ndarray,lr:float=0.001,n_iters:int=1000):\n",
    "        \"\"\"\n",
    "        Constructor method.\n",
    "        \"\"\"\n",
    "        self.x0 = x0\n",
    "        self.y0 = y0\n",
    "        assert(type(x0)==np.ndarray and type(y0)==np.ndarray)\n",
    "        \n",
    "        \n",
    "        \n",
    "        self.lr = lr\n",
    "        self.n_iters = n_iters\n",
    "        \n",
    "        \n",
    "        self.m, self.n = np.shape(self.x0)[0], np.shape(self.x0)[1]\n",
    "    \n",
    "    \n",
    "        #initialise parameters \n",
    "        #weight column vector of shape (4,1)\n",
    "        self.w = np.random.randn(self.n,1)\n",
    "        self.b = 0\n",
    "        \n",
    "        \n",
    "    \n",
    "    \n",
    "    def create_array(self):\n",
    "        \"\"\"Creates a list\n",
    "        :return:\n",
    "        :rtype: list\n",
    "        \"\"\"\n",
    "        \n",
    "        self.array = []\n",
    "        \n",
    "        return self.array\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    def sigmoid(self,z):\n",
    "        \"\"\"Non-linear activation function.\n",
    "        :return: \n",
    "        :rtype: \n",
    "        \"\"\"\n",
    "        return 1/(1+np.exp(-z))\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    def forward_propagate_vectorised(self):\n",
    "        \"\"\"Forward propagation. Vectorised Implementation.\n",
    "        :return: \n",
    "        :rtype: \n",
    "        \"\"\"\n",
    "    \n",
    "        #number of cols in first array must equal the number of rows in second array\n",
    "        if np.shape(self.x0)[1] == np.shape(self.w)[0]:\n",
    "            \n",
    "            #matrix multiplication input matrix and weights\n",
    "            #b is a scalar bias parameter\n",
    "            #shape (1000,4) and (4,1), then result A of shape (1000,1)\n",
    "            #pass into static sigmoid function defined above\n",
    "            A = self.sigmoid(np.matmul(self.x0,self.w)+self.b)\n",
    "            \n",
    "            \n",
    "            #vector A of shape (1000,1) must be equal to (1000,1)\n",
    "            #to check if A calculated correctly\n",
    "            if np.shape(A) == (np.size(self.x0,0),np.size(self.w,1)):\n",
    "            \n",
    "            \n",
    "                #cost function J in vectorised form\n",
    "                #mathematical formula defined above\n",
    "                cost = (-1/self.m)*np.sum(self.y0*np.log(A)+(1-self.y0)*(np.log(1-A)))\n",
    "            \n",
    "            \n",
    "            \n",
    "                #calculate gradients of the cost function w.r.t. parameters\n",
    "                #mathematical formula defined above\n",
    "                #A is of shape (1000,1)\n",
    "                #self.y0 output vector is of shape (1000,1)\n",
    "                #self.x0 is of shape (1000,4)\n",
    "                #matrix multiplication can only be calc if num of cols if\n",
    "                #num of cols in first matrix is equal to num of rows in second matrix\n",
    "                #hence self.x0.T is of shape (4,1000)\n",
    "                #resulting d_w is then of shape (4,1)\n",
    "                d_w = (1/self.m)*np.matmul(self.x0.T,(A-self.y0))\n",
    "                \n",
    "                #divide by 1 over num of samples\n",
    "                d_b = (1/self.m)*np.sum(A-self.y0)\n",
    "        \n",
    "                #store gradients in a dict\n",
    "                gradients = {\n",
    "                        \"d_w\":d_w,\n",
    "                        \"d_b\":d_b\n",
    "                    }\n",
    "                \n",
    "             \n",
    "            else:\n",
    "                print(f\"must be of shape ({np.size(self.x0,0)},{np.size(self.w,1)})\")\n",
    "                \n",
    "        #number of cols in first array not equal the number of rows in second array\n",
    "        #matrix multiplication cannot be calculated\n",
    "        else:\n",
    "            \n",
    "            print(f\"{np.shape(self.x0)[1]} not equal to {np.shape(self.w)[0]}\")\n",
    "        \n",
    "        \n",
    "        \n",
    "        return cost, gradients\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    def forward_propagate_not_vectorised(self):\n",
    "        \"\"\"Forward propagation. Non-Vectorised Implementation.\n",
    "        :return: \n",
    "        :rtype: \n",
    "        \"\"\"\n",
    "        \n",
    "        #matrix multiplication input matrix of shape (1000,4) and weight column vector (4,1)\n",
    "        #resulting vector B_p is then of shape (1000,1)\n",
    "        #hence first initialise B_p to zeros of shape (1000,1)\n",
    "        B_p = np.zeros(\n",
    "                (np.size(self.x0,0),np.size(self.w,1))\n",
    "            )\n",
    "        \n",
    "        \n",
    "        #number of cols in first array must equal the number of rows in second array\n",
    "        #if true, then matrix multiplication of self.x0 and self.w\n",
    "        if np.shape(self.x0)[1] == np.shape(self.w)[0]:\n",
    "        \n",
    "        \n",
    "            for i in range(len(self.x0)):\n",
    "        \n",
    "                for j in range(len(self.w[0])):\n",
    "        \n",
    "                    for k in range(len(self.w)):\n",
    "        \n",
    "                        B_p[i][j] += self.x0[i][k]*self.w[k][j]\n",
    "        \n",
    "            #add scalar bias term to the result and pass to sigmoid function\n",
    "            #B of shape (1000,1)\n",
    "            B = self.sigmoid(B_p + self.b)\n",
    "            \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        #cost function J in non-vectorised form\n",
    "        #mathematical formula defined above\n",
    "        #c_ is equal to cost J, iterate over every sample\n",
    "        #self.y0 and B are both of shape (1000,1)\n",
    "        #result c_ is a scalar because it is not indexed by m\n",
    "        c_ = 0\n",
    "        for m in range(self.m):\n",
    "            c_ += (self.y0[m]*np.log(B[m])+(1-self.y0[m])*(np.log(1-B[m])))\n",
    "        \n",
    "        \n",
    "        cost = (-1/self.m)*c_\n",
    "        cost = float(cost)\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        #derivative of the cost function w.r.t. w in non-vectorised form\n",
    "        #first matrix substraction B - self.y0, both shape (1000,1)\n",
    "        #result K also of shape (1000,1)\n",
    "        #initialise K with zeros of shape (1000,1)\n",
    "        \n",
    "        K = np.zeros(\n",
    "                (np.size(B,0),np.size(self.y0,1))\n",
    "            )\n",
    "        \n",
    "        for u in range(self.m):\n",
    "            K[u] += B[u] - self.y0[u]\n",
    "        \n",
    "        \n",
    "        #K is of shape (1000,1) and self.x0 of shape (1000,4)\n",
    "        #transpose self.x0 for matrix multiplication in non-vectorised form\n",
    "        #then self.x0.T of shape (4,1000) and K of shape (1000,1)\n",
    "        #resulting L is of shape (4,1)\n",
    "        \n",
    "        L = np.zeros((np.size(self.x0.T,0),np.size(K,1)))\n",
    "        \n",
    "        for m in range(len(self.x0.T)):\n",
    "        \n",
    "            for n in range(len(K[0])):\n",
    "        \n",
    "                for k in range(len(K)):\n",
    "        \n",
    "                    L[m][n] += self.x0.T[m][k]*K[k][n]\n",
    "        \n",
    "        \n",
    "        d_w1 = (1/self.m)*L\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        #derivative of the cost function w.r.t. b in non-vectorised form\n",
    "        # result is a scalar hence initialise to zero\n",
    "        #notice d_b1 is not indexed by e\n",
    "        #iterate over each row in input data\n",
    "        #both B and self.y0 are of shape (1000,1)\n",
    "        d_b1 = 0\n",
    "        \n",
    "        for e in range(self.m):\n",
    "            \n",
    "            d_b1 += B[e]-self.y0[e]\n",
    "        \n",
    "        d_b1 = (1/self.m)*d_b1\n",
    "        d_b1 = float(d_b1)\n",
    "        \n",
    "        \n",
    "        #store gradients in a dict\n",
    "        gradients = {\n",
    "                \"d_w1\":d_w1,\n",
    "                \"d_b1\":d_b1\n",
    "            }\n",
    "        \n",
    "        return cost, gradients\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    def gradient_descent(self):\n",
    "        \"\"\"The below functions runs gradient descent.\n",
    "        :return: Optimal parameters w,b\n",
    "        :rtype: np.array\n",
    "        \"\"\"\n",
    "        \n",
    "        costs = self.create_array()\n",
    "        \n",
    "        \n",
    "        for i in range(self.n_iters):\n",
    "                \n",
    "            j, k = self.forward_propagate_vectorised()\n",
    "            \n",
    "            self.w = self.w - self.lr*k[\"d_w\"]\n",
    "            self.b = self.b - self.lr*k[\"d_b\"]\n",
    "    \n",
    "            costs.append(j)\n",
    "            \n",
    "            if i % 100 ==0:\n",
    "                print(f\"Costs after iter {i}:{j}\")\n",
    "        \n",
    "        optim_params = {\n",
    "            \"w\": self.w,\n",
    "            \"b\": self.b\n",
    "            }\n",
    "        \n",
    "        plt.plot(costs)\n",
    "        \n",
    "        return optim_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "82a6813c",
   "metadata": {},
   "outputs": [],
   "source": [
    "neural_nets = nn(a,b,0.005,2500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "689e63ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.7991071 ],\n",
       "       [0.21605666],\n",
       "       [0.99981016],\n",
       "       [0.63657201]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neural_nets.w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7a997e9d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.9364638761160147,\n",
       " {'d_w': array([[0.13694411],\n",
       "         [0.03113021],\n",
       "         [0.22317942],\n",
       "         [0.10489103]]),\n",
       "  'd_b': 0.5094444540829945})"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neural_nets.forward_propagate_vectorised()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d4af58aa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.9364638761160151,\n",
       " {'d_w1': array([[0.13694411],\n",
       "         [0.03113021],\n",
       "         [0.22317942],\n",
       "         [0.10489103]]),\n",
       "  'd_b1': 0.5094444540829937})"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neural_nets.forward_propagate_not_vectorised()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b477ae6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Costs after iter 0:0.9364638761160147\n",
      "Costs after iter 100:0.7803255531585063\n",
      "Costs after iter 200:0.6509218172574857\n",
      "Costs after iter 300:0.5456683422196734\n",
      "Costs after iter 400:0.4612434451386572\n",
      "Costs after iter 500:0.39406150223948505\n",
      "Costs after iter 600:0.3406993328908312\n",
      "Costs after iter 700:0.2981677564601786\n",
      "Costs after iter 800:0.26401617462743593\n",
      "Costs after iter 900:0.23631838671023508\n",
      "Costs after iter 1000:0.2135987513297842\n",
      "Costs after iter 1100:0.1947417565159418\n",
      "Costs after iter 1200:0.1789078765441063\n",
      "Costs after iter 1300:0.1654642564759676\n",
      "Costs after iter 1400:0.15393114763640522\n",
      "Costs after iter 1500:0.1439419197826715\n",
      "Costs after iter 1600:0.13521372798584394\n",
      "Costs after iter 1700:0.1275261481835068\n",
      "Costs after iter 1800:0.12070562566821398\n",
      "Costs after iter 1900:0.1146141145793622\n",
      "Costs after iter 2000:0.1091407278782687\n",
      "Costs after iter 2100:0.10419555264293158\n",
      "Costs after iter 2200:0.0997050297377399\n",
      "Costs after iter 2300:0.09560847095995492\n",
      "Costs after iter 2400:0.0918554095589699\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'w': array([[0.27804286],\n",
       "        [0.02444421],\n",
       "        [0.06776185],\n",
       "        [0.1587318 ]]),\n",
       " 'b': -2.468142975034734}"
      ]
     },
     "execution_count": 9,
     "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": [
    "neural_nets.gradient_descent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "943da3c0",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}