Neural Networks from Scratch 1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import pandas as pd\n",
    "import scipy as sp\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$y_{j} = g\\left(\\sum_{i = 0}^{m}w_{ij}x_{i}\\right)=\\begin{cases}1 &  g()>0\\\\b &  g() \\leq 0\\end{cases}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Activaton:\n",
    "$$\\sum_{i = 0}^{m}w_{ij}x_{i} =  WX$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Updating the weights: \n",
    "$$ w_{ij} \\rightarrow w_{ij}-\\eta\\left(y_{j}-t_{j}\\right)x_{i} $$\n",
    "$$W \\rightarrow W - \\eta X^{t}(Y-T)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "class pcn:\n",
    "    \"\"\" A basic Perceptron\"\"\"\n",
    "    def __init__(self,inputs,targets):\n",
    "        \"\"\" Constructor \"\"\"\n",
    "        if np.ndim(inputs)>1:\n",
    "            self.nIn = np.shape(inputs)[1]\n",
    "        else: \n",
    "            self.nIn = 1\n",
    "        if np.ndim(targets)>1:\n",
    "            self.nOut = np.shape(targets)[1]\n",
    "        else:\n",
    "            self.nOut = 1\n",
    "\n",
    "        self.nData = np.shape(inputs)[0]\n",
    "        # Initialise network\n",
    "        self.weights = np.random.rand(self.nIn+1,self.nOut)*0.1-0.05\n",
    "        \n",
    "    def accuracy(targets,activations):\n",
    "        acc = 0\n",
    "        for a,b in zip(targets,activations):\n",
    "            if a == b:\n",
    "                acc += 1\n",
    "        return 100*(acc/len(targets))    \n",
    "        \n",
    "    def pcnfwd(self,inputs):\n",
    "        \"\"\" Run the network forward \"\"\"\n",
    "        # Compute activations\n",
    "        activations =  np.dot(inputs,self.weights)\n",
    "\n",
    "        # Threshold the activations\n",
    "        return np.where(activations>0,1,0)        \n",
    "\n",
    "    def pcntrain(self,inputs,targets,eta,nIterations,press = 75):\n",
    "        \"\"\" Train the thing \"\"\"\t\n",
    "        # Add the inputs that match the bias node\n",
    "        inputs = np.concatenate((inputs,-np.ones([self.nData,1])),axis=1)\n",
    "        # Training\n",
    "        change = range(self.nData)\n",
    "\n",
    "        for n in range(nIterations):\n",
    "            self.activations = self.pcnfwd(inputs)\n",
    "            self.weights -= eta*np.dot(np.transpose(inputs),self.activations-targets)\n",
    "            acc = accuracy(targets,self.activations)\n",
    "            \n",
    "            \n",
    "            print('Iteration:',n)\n",
    "            print('Weights:''\\n',self.weights)\n",
    "            print('Results:''\\n',self.activations)\n",
    "            print('Accuracy:',acc,'%')\n",
    "            print('       ')\n",
    "            \n",
    "            if acc >= press:\n",
    "                break\n",
    "            \n",
    "            # Randomise order of inputs\n",
    "            #np.random.shuffle(change)\n",
    "            #inputs = inputs[change,:]\n",
    "            #targets = targets[change,:]\n",
    "\n",
    "        #return self.weights\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inputs logical OR:\n",
    "$$I=\\begin{bmatrix}0 & 0 \\\\0 & 0  \\\\1&0 \\\\1&1 \\end{bmatrix}$$\n",
    "Targets:\n",
    "$$ T=\\begin{bmatrix}0  \\\\1  \\\\1 \\\\1 \\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "I = [[0,0],[0,1],[1,0],[1,1]] #N+1xM(+1 by the bias) #Inputs\n",
    "T = [[0],[1],[1],[1]]         #1XM  \n",
    "#weight dimension = Inputs dim                       #Target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "T1 = [[0],[1],[1],[1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accuracy(targets, activation):\n",
    "    acc = 0\n",
    "    for a,b in zip(targets,activation):\n",
    "        if a == b:\n",
    "            acc += 1\n",
    "    return 100*(acc/len(targets))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100.0"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy(T,T1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0., -1.],\n",
       "       [ 0.,  1., -1.],\n",
       "       [ 1.,  0., -1.],\n",
       "       [ 1.,  1., -1.]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((I,-np.ones([4,1])),axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = pcn(I,T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 0\n",
      "Weights:\n",
      " [[ 0.47912467]\n",
      " [ 0.49569571]\n",
      " [-0.73545629]]\n",
      "Results:\n",
      " [[0]\n",
      " [0]\n",
      " [0]\n",
      " [0]]\n",
      "Accuracy: 25.0 %\n",
      "       \n",
      "Iteration: 1\n",
      "Weights:\n",
      " [[ 0.47912467]\n",
      " [ 0.49569571]\n",
      " [-0.48545629]]\n",
      "Results:\n",
      " [[1]\n",
      " [1]\n",
      " [1]\n",
      " [1]]\n",
      "Accuracy: 75.0 %\n",
      "       \n",
      "Iteration: 2\n",
      "Weights:\n",
      " [[ 0.47912467]\n",
      " [ 0.49569571]\n",
      " [-0.23545629]]\n",
      "Results:\n",
      " [[1]\n",
      " [1]\n",
      " [1]\n",
      " [1]]\n",
      "Accuracy: 75.0 %\n",
      "       \n",
      "Iteration: 3\n",
      "Weights:\n",
      " [[0.47912467]\n",
      " [0.49569571]\n",
      " [0.01454371]]\n",
      "Results:\n",
      " [[1]\n",
      " [1]\n",
      " [1]\n",
      " [1]]\n",
      "Accuracy: 75.0 %\n",
      "       \n",
      "Iteration: 4\n",
      "Weights:\n",
      " [[0.47912467]\n",
      " [0.49569571]\n",
      " [0.01454371]]\n",
      "Results:\n",
      " [[0]\n",
      " [1]\n",
      " [1]\n",
      " [1]]\n",
      "Accuracy: 100.0 %\n",
      "       \n"
     ]
    }
   ],
   "source": [
    "p.pcntrain(I,T,0.25,6,press = 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neurons :\n",
    "1.- Linear: $$ y_{j} = \\sum_{i} w_{ij}x_{i}$$\n",
    "2.- Logistic:\n",
    "3.- Softmax:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chain Rule:\n",
    "$$ \\frac{\\text{d}f\\left(u(x)\\right)}{\\text{d}x} = \\frac{\\text{d}f\\left(u(x)\\right)}{\\text{d}u(x)}\\frac{\\text{d}u(x)}{\\text{d}x} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ACtivation function Sigmoid Function: $$ g(h) = \\frac{1}{1+exp(-\\beta h)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Activation Function Soft Max:\n",
    "$$ g(h_{k}) = \\frac{exp(h_{k})}{\\sum_{k=1}^{N}exp(h_{k})} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "class mlp:\n",
    "    \"\"\" A Multi-Layer Perceptron\"\"\"\n",
    "    \n",
    "    def __init__(self,inputs,targets,nhidden,beta=1,momentum=0.9,outtype='logistic'):\n",
    "        # Set up network size\n",
    "        self.ndata   = np.shape(inputs)[0]\n",
    "        self.nin     = np.shape(inputs)[1]\n",
    "        \n",
    "        self.nout    = np.shape(targets)[1]\n",
    "        self.nhidden = nhidden\n",
    "\n",
    "        self.beta     = beta\n",
    "        self.momentum = momentum\n",
    "        self.outtype  = outtype\n",
    "    \n",
    "        # Initialise network\n",
    "        self.weights1 = (np.random.rand(self.nin+1,self.nhidden)-0.5)*2/np.sqrt(self.nin)\n",
    "        self.weights2 = (np.random.rand(self.nhidden+1,self.nout)-0.5)*2/np.sqrt(self.nhidden)\n",
    "\n",
    "    def earlystopping(self,inputs,targets,valid,validtargets,eta,niterations=100):\n",
    "    \n",
    "        valid = np.concatenate((valid,-np.ones([np.shape(valid)[0],1])),axis=1)\n",
    "        \n",
    "        old_val_error1 = 100002\n",
    "        old_val_error2 = 100001\n",
    "        new_val_error  = 100000\n",
    "        \n",
    "        count = 0\n",
    "        while (((old_val_error1 - new_val_error) > 0.001) or ((old_val_error2 - old_val_error1)>0.001)):\n",
    "            count+=1\n",
    "            print (count)\n",
    "            self.mlptrain(inputs,targets,eta,niterations)\n",
    "            old_val_error2 = old_val_error1\n",
    "            old_val_error1 = new_val_error\n",
    "            validout = self.mlpfwd(valid)\n",
    "            new_val_error = 0.5*np.sum((validtargets-validout)**2)\n",
    "            \n",
    "        print (\"Stopped\", new_val_error,old_val_error1, old_val_error2)\n",
    "        return new_val_error\n",
    "\n",
    "    def mlptrain(self,inputs,targets,eta,niterations):\n",
    "        \"\"\" Train the thing \"\"\"    \n",
    "        # Add the inputs that match the bias node\n",
    "        inputs = np.concatenate((inputs,-np.ones((self.ndata,1))),axis=1)\n",
    "        change = range(self.ndata)\n",
    "    \n",
    "        updatew1 = np.zeros((np.shape(self.weights1)))\n",
    "        updatew2 = np.zeros((np.shape(self.weights2)))\n",
    "            \n",
    "        for n in range(niterations):\n",
    "    \n",
    "            self.outputs = self.mlpfwd(inputs)\n",
    "\n",
    "            error = 0.5*np.sum((self.outputs-targets)**2)\n",
    "            if (np.mod(n,100)==0):\n",
    "                print (\"Iteration: \",n, \" Error: \",error)    \n",
    "\n",
    "            # Different types of output neurons\n",
    "            if self.outtype == 'linear':\n",
    "                deltao = (self.outputs-targets)/self.ndata\n",
    "            elif self.outtype == 'logistic':\n",
    "                deltao = self.beta*(self.outputs-targets)*self.outputs*(1.0-self.outputs)\n",
    "            elif self.outtype == 'softmax':\n",
    "                deltao = (self.outputs-targets)*(self.outputs*(-self.outputs)+self.outputs)/self.ndata \n",
    "            else:\n",
    "                print (\"error\")\n",
    "            \n",
    "            deltah = self.hidden*self.beta*(1.0-self.hidden)*(np.dot(deltao,np.transpose(self.weights2)))\n",
    "                      \n",
    "            updatew1 = eta*(np.dot(np.transpose(inputs),deltah[:,:-1])) + self.momentum*updatew1\n",
    "            updatew2 = eta*(np.dot(np.transpose(self.hidden),deltao)) + self.momentum*updatew2\n",
    "            self.weights1 -= updatew1\n",
    "            self.weights2 -= updatew2\n",
    "                \n",
    "            # Randomise order of inputs (not necessary for matrix-based calculation)\n",
    "            #np.random.shuffle(change)\n",
    "            #inputs = inputs[change,:]\n",
    "            #targets = targets[change,:]\n",
    "            \n",
    "    def mlpfwd(self,inputs):\n",
    "        \"\"\" Run the network forward \"\"\"\n",
    "\n",
    "        self.hidden = np.dot(inputs,self.weights1);\n",
    "        self.hidden = 1.0/(1.0+np.exp(-self.beta*self.hidden))\n",
    "        self.hidden = np.concatenate((self.hidden,-np.ones((np.shape(inputs)[0],1))),axis=1)\n",
    "\n",
    "        outputs = np.dot(self.hidden,self.weights2)\n",
    "\n",
    "        # Different types of output neurons\n",
    "        if self.outtype == 'linear':\n",
    "            return outputs\n",
    "        elif self.outtype == 'logistic':\n",
    "            return 1.0/(1.0+np.exp(-self.beta*outputs))\n",
    "        elif self.outtype == 'softmax':\n",
    "            normalisers = np.sum(np.exp(outputs),axis=1)*np.ones((1,np.shape(outputs)[0]))\n",
    "            return np.transpose(np.transpose(np.exp(outputs))/normalisers)\n",
    "        else:\n",
    "            print (\"error\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0,1,40).reshape((1,40))\n",
    "\n",
    "t = np.sin(2*np.pi*x) + np.cos(4*np.pi*x) + np.random.randn(40)*0.2\n",
    "x = x.T\n",
    "t = t.T\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (10,6))\n",
    "plt.plot(x,t,'.-',color = 'black',markersize = 5)\n",
    "plt.title('$f(t) = sin2\\pi t + cos(4\\pi t)+c$')\n",
    "plt.xlabel('$t$',fontsize = 15)\n",
    "plt.ylabel('$f(t)$',fontsize = 15)\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = x[0::2,:]\n",
    "test = x[1::4,:]\n",
    "valid = x[3::4,:]\n",
    "traintarget = t[0::2,:]\n",
    "testtarget = t[1::4,:]\n",
    "validtarget = t[3::4,:]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration:  0  Error:  8.280880554764751\n",
      "Iteration:  100  Error:  6.273256792625318\n"
     ]
    }
   ],
   "source": [
    "net = mlp(train,traintarget,3,outtype='linear')\n",
    "net.mlptrain(train,traintarget,0.25,101)\n"
   ]
  },
  {
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}