simple_neural_network_from_scratch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.99839495]\n",
      " [ 0.99753652]\n",
      " [ 0.00288053]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "#import pandas\n",
    "#from sklearn import model_selection\n",
    "#from sklearn.linear_model import LogisticRegression\n",
    "#import pickle\n",
    "\n",
    "#def neuralnetwork():\n",
    "    #Input array\n",
    "X=np.array([[1,0,1,0],[1,0,1,1],[0,1,0,1]])\n",
    "\n",
    "    #Output\n",
    "y=np.array([[1],[1],[0]])\n",
    "\n",
    "    #Sigmoid Function\n",
    "def sigmoid (x):\n",
    "    return 1/(1 + np.exp(-x))\n",
    "\n",
    "    #Derivative of Sigmoid Function\n",
    "def derivatives_sigmoid(x):\n",
    "    return x * (1 - x)\n",
    "\n",
    "    #Variable initialization\n",
    "epoch=500000 #Setting training iterations\n",
    "lr=0.1 #Setting learning rate\n",
    "inputlayer_neurons = X.shape[1] #number of features in data set\n",
    "hiddenlayer_neurons = 3 #number of hidden layers neurons\n",
    "output_neurons = 1 #number of neurons at output layer\n",
    "\n",
    "    #weight and bias initialization\n",
    "wh=np.random.uniform(size=(inputlayer_neurons,hiddenlayer_neurons))\n",
    "bh=np.random.uniform(size=(1,hiddenlayer_neurons))\n",
    "wout=np.random.uniform(size=(hiddenlayer_neurons,output_neurons))\n",
    "bout=np.random.uniform(size=(1,output_neurons))\n",
    "\n",
    "for i in range(epoch):\n",
    "\n",
    "    #Forward Propogation\n",
    "    hidden_layer_input1=np.dot(X,wh)\n",
    "    hidden_layer_input=hidden_layer_input1 + bh\n",
    "    hiddenlayer_activations = sigmoid(hidden_layer_input)\n",
    "    output_layer_input1=np.dot(hiddenlayer_activations,wout)\n",
    "    output_layer_input= output_layer_input1+ bout\n",
    "    output = sigmoid(output_layer_input)\n",
    "\n",
    "    #Backpropagation\n",
    "    E = y-output\n",
    "    slope_output_layer = derivatives_sigmoid(output)\n",
    "    slope_hidden_layer = derivatives_sigmoid(hiddenlayer_activations)\n",
    "    d_output = E * slope_output_layer\n",
    "    Error_at_hidden_layer = d_output.dot(wout.T)\n",
    "    d_hiddenlayer = Error_at_hidden_layer * slope_hidden_layer\n",
    "    wout += hiddenlayer_activations.T.dot(d_output) *lr\n",
    "    bout += np.sum(d_output, axis=0,keepdims=True) *lr\n",
    "    wh += X.T.dot(d_hiddenlayer) *lr\n",
    "    bh += np.sum(d_hiddenlayer, axis=0,keepdims=True) *lr\n",
    "\n",
    "print output\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=np.array([[1,0,1,0],[1,0,1,1],[1,1,1,1]])\n",
    "y=np.array([[1],[0],[1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define sigmoid function\n",
    "def sigmoid(x):\n",
    "    return 1/(1+np.exp(-x))\n",
    "\n",
    "#define derivative of sigmoid\n",
    "\n",
    "def dvsigmoid(x):\n",
    "    return x*(1-x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#variables initialization\n",
    "\n",
    "epoch = 100000 #number of itteration\n",
    "lr=.1\n",
    "input_layer_neuron = X.shape[1]   #number of features in data set\n",
    "hidden_layer_neuron= 10\n",
    "output_neuron = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# weights and bias initialization\n",
    "wh=np.random.uniform(size=(input_layer_neuron,hidden_layer_neuron))\n",
    "bh=np.random.uniform(size=(1,hidden_layer_neuron))\n",
    "wout=np.random.uniform(size=(hidden_layer_neuron,output_neuron))\n",
    "bout=np.random.uniform(size=(1,output_neuron))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.99468945]\n",
      " [ 0.00769922]\n",
      " [ 0.99451912]]\n"
     ]
    }
   ],
   "source": [
    "for i in range(epoch):\n",
    "    #forward propogation\n",
    "    hidden_layer_input1=np.dot(X,wh)\n",
    "    hidden_layer_input=hidden_layer_input1+bh\n",
    "    hidden_layer_activation=sigmoid(hidden_layer_input)\n",
    "    output_layer_input1=np.dot(hidden_layer_activation,wout)\n",
    "    output_layer_input=output_layer_input1+bout\n",
    "    output = sigmoid(output_layer_input)\n",
    "    \n",
    "    \n",
    "    #backward propogation\n",
    "    \n",
    "    E=y-output\n",
    "    slope_of_output = dvsigmoid(output)\n",
    "    slope_hidden_layer = dvsigmoid(hidden_layer_activation)\n",
    "    d_output = E*slope_of_output\n",
    "    Error_at_hidden_layer = d_output.dot(wout.T)\n",
    "    d_hiddenlayer = Error_at_hidden_layer * slope_hidden_layer\n",
    "    #d_hiddenlayer= Error_at_hiddenlayer*slope_hidden_layer\n",
    "    wout += hidden_layer_activation.T.dot(d_output)*lr\n",
    "    bout +=np.sum(d_output,axis=0,keepdims=True)*lr\n",
    "    wh +=X.T.dot(d_hiddenlayer)*lr\n",
    "    bh +=np.sum(d_hiddenlayer,axis=0, keepdims=True)*lr\n",
    "    \n",
    "    \n",
    "print output\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_data = {\"first_name\":[\"janmejay\", \"arun\",\"deepak\",\"pankaj\",\"govind\",\"rohit\"],\"last_name\":[\"singh\",'singh','mishra','singh','gupta','kapoor'],'age':[28,32,27,29,24,27]}\n",
    "df = pd.DataFrame(raw_data,columns=['first_name','last_name','age'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['janmejay' 'singh' 28]\n",
      "['arun' 'singh' 32]\n",
      "['deepak' 'mishra' 27]\n",
      "['pankaj' 'singh' 29]\n",
      "['govind' 'gupta' 24]\n",
      "['rohit' 'kapoor' 27]\n"
     ]
    }
   ],
   "source": [
    "a=np.array(df)\n",
    "\n",
    "a\n",
    "\n",
    "for i in a:\n",
    "    print i\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>first_name</th>\n",
       "      <th>last_name</th>\n",
       "      <th>age</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>janmejay</td>\n",
       "      <td>singh</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  first_name last_name  age\n",
       "0   janmejay     singh   28"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[0:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'age': [28, 32, 27, 29, 24, 27],\n",
       " 'first_name': ['janmejay', 'arun', 'deepak', 'pankaj', 'govind', 'rohit'],\n",
       " 'last_name': ['singh', 'singh', 'mishra', 'singh', 'gupta', 'kapoor']}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raw_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    return 1/(1+np.exp(-x))\n",
    "def dersigmoid(x):\n",
    "    return x*(1-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "    #Input array\n",
    "X=np.array([[1,0,1,0],[1,0,1,1],[0,1,0,1]])\n",
    "\n",
    "    #Output\n",
    "y=np.array([[1],[1],[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#initializing variable\n",
    "epoch = 10000  # number of itterations\n",
    "lr = .1\n",
    "input_neuron =X.shape[1]\n",
    "hidden_layer_neuron =3\n",
    "output_neuron = 1\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#weights and bais initialization\n",
    "wh= np.random.uniform(size=(input_neuron,hidden_layer_neuron))\n",
    "bh=np.random.uniform(size=(1,hidden_layer_neuron))\n",
    "wout= np.random.uniform(size=(hidden_layer_neuron,output_neuron))\n",
    "bout= np.random.uniform(size=(1,output_neuron))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.98918636],\n",
       "       [ 0.98256188],\n",
       "       [ 0.02323246]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(epoch):\n",
    "    #forward propogation\n",
    "    \n",
    "    hidden_layer_input1=np.dot(X,wh)\n",
    "    hidden_layer_input=hidden_layer_input1+bh\n",
    "    hidden_layer_activation=sigmoid(hidden_layer_input)\n",
    "    output_layer_input1= np.dot(hidden_layer_activation,wout)\n",
    "    output_layer_input = output_layer_input1+bout\n",
    "    output= sigmoid(output_layer_input)\n",
    "    \n",
    "    \n",
    "    #backward propagation\n",
    "    \n",
    "    E=y-output\n",
    "    slope_of_output = dersigmoid(output)\n",
    "    slope_of_hiddenlayer=dersigmoid(hidden_layer_activation)\n",
    "    d_output = slope_of_output*E\n",
    "    error_at_hiddenlayer = d_output.dot(wout.T)\n",
    "    d_hiddenlayer = error_at_hiddenlayer*slope_of_hiddenlayer\n",
    "    wout+=hidden_layer_activation.T.dot(d_output)*lr\n",
    "    bout+=np.sum(d_output,axis=0,keepdims=True)*lr\n",
    "    wh +=X.T.dot(d_hiddenlayer)*lr\n",
    "    bh+=np.sum(d_hiddenlayer,axis=0,keepdims=True)*lr\n",
    "    \n",
    "output\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.9931998 ],\n",
       "       [ 0.98896481],\n",
       "       [ 0.01468949]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(epoch):\n",
    "    #forwad propogation\n",
    "    hidden_layer_input1=np.dot(X,wh)\n",
    "    hidden_layer_input=hidden_layer_input1+bh\n",
    "    hidden_layer_activation = sigmoid(hidden_layer_input)\n",
    "    output_layer_input1 = np.dot(hidden_layer_activation,wout)\n",
    "    output_layer_input = output_layer_input1+bout\n",
    "    output= sigmoid(output_layer_input)\n",
    "    output\n",
    "    \n",
    "    \n",
    "    #backward propogation\n",
    "    E= y-output\n",
    "    slope_of_ouput = dersigmoid(output)\n",
    "    slope_of_hiddenlayer = dersigmoid(hidden_layer_activation)\n",
    "    d_output = slope_of_output*E\n",
    "    error_at_hiddenlayer=d_output.dot(wout.T)\n",
    "    d_hiddenlayer = error_at_hiddenlayer*slope_of_hiddenlayer\n",
    "    wout +=hidden_layer_activation.T.dot(d_output)*lr\n",
    "    bout +=np.sum(d_output,axis=0,keepdims=True)*lr\n",
    "    wh +=X.T.dot(d_hiddenlayer)*lr\n",
    "    bh +=np.sum(d_hiddenlayer,axis=0,keepdims=True)*lr\n",
    "output    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}