ELM.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len= 5\n",
      "[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]\n",
      "accuracy = 84.61538461538461 %\n",
      "[array([0.10377351])]\n",
      "[[ 0.10377351]\n",
      " [-0.28829142]\n",
      " [ 0.64271111]\n",
      " [ 0.51196342]\n",
      " [ 0.32789037]]\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import random\n",
    "import math\n",
    "from random import shuffle \n",
    "\n",
    "class iNode:\n",
    "    def __init__(self):\n",
    "        self.input=0\n",
    "        self.output=None\n",
    "        self.weights=None\n",
    "        \n",
    "class oNode:\n",
    "    def __init__(self):\n",
    "        self.input=0\n",
    "        self.output=None\n",
    "        self.bias=None\n",
    "        self.error=None\n",
    "        \n",
    "class innerNode:\n",
    "    def __init__(self):\n",
    "        self.input=0\n",
    "        self.output=None\n",
    "        self.bias=None\n",
    "        self.weights=None\n",
    "        self.error=None\n",
    "        \n",
    "class MLP:\n",
    "    def __init__(self,inodes,n,innerlayers,bias,weight1,weight2,learning_rate):\n",
    "        self.rate=learning_rate\n",
    "        self.outputnode=oNode()\n",
    "        self.layers=[[innerNode() for i in range(n)] for j in range(innerlayers)]\n",
    "        self.layers=[[iNode() for i in range(inodes)]]+self.layers+[[self.outputnode]]\n",
    "        for layer in range(len(self.layers)):\n",
    "            if layer==0:\n",
    "                for node in range(len(self.layers[layer])):\n",
    "                    self.layers[layer][node].weights=[random.uniform(-1,1) for i in range(len(self.layers[layer+1]))]\n",
    "            \n",
    "            elif layer==len(self.layers)-1:\n",
    "                for node in range(len(self.layers[layer])):\n",
    "                    #self.layers[layer][node].weights=[weight2 for i in range(len(self.layers[layer+1]))]\n",
    "                    self.layers[layer][node].bias=0        #change\n",
    "                    \n",
    "            else:\n",
    "                for node in range(len(self.layers[layer])):\n",
    "                    self.layers[layer][node].weights=[random.uniform(-1,1) for i in range(len(self.layers[layer+1]))]\n",
    "                    self.layers[layer][node].bias=random.random()\n",
    "                    \n",
    "    def fun(self,x):\n",
    "        return 1/(1+math.exp(-1*x))\n",
    "    \n",
    "    def derivative(self,x):\n",
    "        return (x.output*(1-x.output))\n",
    "    \n",
    "    def classification(self,x):\n",
    "        if x>0.5:\n",
    "            return 1\n",
    "        return 0\n",
    "                    \n",
    "    def train(self,ltrain,ztrain):\n",
    "        number=0\n",
    "        H=[]\n",
    "        for input in ltrain:\n",
    "            H.append([])\n",
    "            for node in range(len(input)):\n",
    "                self.layers[0][node].output=input[node]\n",
    "            \n",
    "            for layer in range(1,len(self.layers)-1):           #forward propagation\n",
    "                for node in range(len(self.layers[layer])):\n",
    "                    self.layers[layer][node].input=self.layers[layer][node].bias\n",
    "                    for i in self.layers[layer-1]:\n",
    "                        self.layers[layer][node].input+=(i.weights[node]*i.output)\n",
    "                    self.layers[layer][node].output=self.fun(self.layers[layer][node].input)\n",
    "                    H[-1].append(self.layers[layer][node].output)\n",
    "            #self.outputnode.output=self.classification(self.outputnode.output)\n",
    "            \n",
    "            \"\"\"self.outputnode.error=(ztrain[number]-self.outputnode.output)   #back propagation\n",
    "            for layer in range(len(self.layers)-2,-1,-1):\n",
    "                for node in range(len(self.layers[layer])):\n",
    "                    self.layers[layer][node].error=0\n",
    "                    for j in range(len(self.layers[layer+1])):\n",
    "                        self.layers[layer][node].error+=(self.layers[layer][node].weights[j]*self.layers[layer+1][j].error)\n",
    "                    self.layers[layer][node].error*=self.derivative(self.layers[layer][node])\n",
    "                                                                    \n",
    "            for i in range(0,len(self.layers)-1):\n",
    "                for j in range(len(self.layers[i])):\n",
    "                    for k in range(len(self.layers[i][j].weights)):\n",
    "                        self.layers[i][j].weights[k]+=self.rate*self.layers[i+1][k].error*self.layers[i][j].output\n",
    "                        \n",
    "                    if i!=0:\n",
    "                        self.layers[i][j].bias+=(self.rate*self.layers[i][j].error)\"\"\"\n",
    "            number+=1\n",
    "        return(H)\n",
    "            \n",
    "    def test(self,ltest,ztest):\n",
    "        number=0\n",
    "        count=0\n",
    "        tp=0\n",
    "        tn=0\n",
    "        fp=0\n",
    "        fn=0\n",
    "        print(ztest)\n",
    "        for input in ltest:\n",
    "            for node in range(len(input)):\n",
    "                self.layers[0][node].output=input[node]\n",
    "            \n",
    "            for layer in range(1,len(self.layers)):           #forward propagation\n",
    "                for node in range(len(self.layers[layer])):\n",
    "                    self.layers[layer][node].input=self.layers[layer][node].bias\n",
    "                    for i in self.layers[layer-1]:\n",
    "                        self.layers[layer][node].input+=(i.weights[node]*i.output)\n",
    "                    t=self.layers[layer][node].input\n",
    "                    self.layers[layer][node].output=self.fun(self.layers[layer][node].input)\n",
    "            #print(t)\n",
    "            self.outputnode.output=self.classification(t)\n",
    "            #print(self.outputnode.output)\n",
    "            if self.outputnode.output==ztest[number]:\n",
    "                count+=1\n",
    "                if ztest[number]==1:\n",
    "                    tp+=1\n",
    "                else:\n",
    "                    tn+=1\n",
    "            elif ztest[number]==1:\n",
    "                fn+=1\n",
    "            else:\n",
    "                fp+=1\n",
    "            number+=1\n",
    "        print('accuracy =',count/len(ztest)*100,'%')\n",
    "        #print('precision(+) =',tp/(tp+fp))\n",
    "        #print('recall(+) =',tp/(tp+fn))\n",
    "        #print('precision(-) =',tn/(tn+fn))\n",
    "        #print('recall(-) =',tn/(tn+fp))\n",
    "        \n",
    "    def findB(self,H,T):\n",
    "        T=np.array(T)\n",
    "        T.shape=(len(T),1)\n",
    "        Htran=np.transpose(H)\n",
    "        prod=np.dot(H,Htran)\n",
    "        row=len(prod)\n",
    "        col=len(prod[0])\n",
    "        lam_invmat=np.zeros((row,col),float)\n",
    "        np.fill_diagonal(lam_invmat,random.random())\n",
    "        if np.linalg.det(prod)!=0:\n",
    "            temp=np.sum([lam_invmat,prod],axis=0)\n",
    "            #print(lam_invmat)\n",
    "            #print(prod)\n",
    "            temp=np.linalg.inv(temp)\n",
    "            B=np.dot(Htran,temp)\n",
    "            B=np.dot(B,T)\n",
    "        else:\n",
    "            prod=np.dot(Htran,H)\n",
    "            row=len(prod)\n",
    "            col=len(prod[0])\n",
    "            lam_invmat=np.zeros((row,col),float)\n",
    "            np.fill_diagonal(lam_invmat,random.random())\n",
    "            temp=np.sum([lam_invmat,prod],axis=0)\n",
    "            #print(lam_invmat)\n",
    "            #print(prod)\n",
    "            temp=np.linalg.inv(temp)\n",
    "            B=np.dot(temp,Htran)\n",
    "            B=np.dot(B,T)\n",
    "        print('len=',len(self.layers[-2]))\n",
    "        for i in range(len(self.layers[-2])):\n",
    "            self.layers[-2][i].weights=[B[i]]\n",
    "        return B\n",
    "        \n",
    "\n",
    "\n",
    "data=pd.read_csv('C:\\\\Users\\\\Rakesh\\\\SC\\\\lab2\\\\SPECT.csv')\n",
    "copy=data.values.tolist()\n",
    "shuffle(copy)\n",
    "#copy=data[:][:]\n",
    "ltrain=[]\n",
    "ztrain=[]\n",
    "ltest=[]\n",
    "ztest=[]\n",
    "dict={}\n",
    "c=0\n",
    "n=data.iloc[:,1].count()\n",
    "\n",
    "for i in range(n):            # dividing train and test dataset\n",
    "    row=random.randint(0,len(copy)-1)\n",
    "    if i<0.9*n:\n",
    "        ltrain.append(copy[row][1:])\n",
    "        ztrain.append(copy[row][0])\n",
    "        if copy[row][0] not in dict:\n",
    "            dict[copy[row][0]]=c\n",
    "            c+=1\n",
    "        copy.remove(copy[row])\n",
    "    else:\n",
    "        ltest.append(copy[row][1:])\n",
    "        ztest.append(copy[row][0])\n",
    "        copy.remove(copy[row])\n",
    "        \n",
    "for i in range(len(ztrain)): #changing categorical variables to numbers\n",
    "    ztrain[i]=dict[ztrain[i]]\n",
    "for i in range(len(ztest)):\n",
    "    ztest[i]=dict[ztest[i]]  \n",
    "inputs=len(ltrain[0])\n",
    "M=MLP(inputs,5,1,1/6,1/(5*inputs),1/5,0.2)\n",
    "H=M.train(ltrain,ztrain)\n",
    "B=M.findB(H,ztrain)\n",
    "M.test(ltest,ztest)\n",
    "print(M.layers[-2][0].weights)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 27 106  65]\n",
      " [ 37 138  94]\n",
      " [188 344 499]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "mat1 = [[1, 6, 5],[3 ,4, 8],[2, 12, 3]]\n",
    "mat2 = [[3, 4, 6],[5, 6, 7],[6,56, 7]]\n",
    "  \n",
    "# This will return dot product \n",
    "res = np.dot(mat2,mat1) \n",
    "  \n",
    "# print resulted matrix \n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  3,  2],\n",
       "       [ 6,  4, 12],\n",
       "       [ 5,  8,  3]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.transpose(mat1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(H[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "241"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(H)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "241"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ztrain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-661d80097997>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m1\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mmat1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'list'"
     ]
    }
   ],
   "source": [
    "1+mat1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.zeros((2,4),int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.fill_diagonal(a,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 0, 0, 0],\n",
       "       [0, 3, 0, 0]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=np.linalg.inv(mat1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.00000000e+00,  0.00000000e+00, -5.55111512e-17],\n",
       "       [ 0.00000000e+00,  1.00000000e+00,  0.00000000e+00],\n",
       "       [-1.11022302e-16,  0.00000000e+00,  1.00000000e+00]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(mat1,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=[[2,0],[0,2]]\n",
    "b=np.linalg.inv(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5, 0. ],\n",
       "       [0. , 0.5]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.det(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.48393699623313"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.random()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4, 10, 11],\n",
       "       [ 8, 10, 15],\n",
       "       [ 8, 68, 10]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum([mat1,mat2],axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.fill_diagonal(np.zeros((3,3),int),random.random())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.zeros((3,3),int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.fill_diagonal(a,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 2]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ltrain[0])"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}