NeuralNetwork_usingpython.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d4605438",
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing necessary libraries \n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "ed0dc1e9",
   "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>x1</th>\n",
       "      <th>x2</th>\n",
       "      <th>y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   x1  x2  y\n",
       "0   0   0  0\n",
       "1   0   1  0\n",
       "2   1   0  0\n",
       "3   1   1  1"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Creating a dataframe out of a dictionary\n",
    "AND = pd.DataFrame({'x1' : (0,0,1,1), 'x2' : (0,1,0,1), 'y' : (0,0,0,1)})\n",
    "AND"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "67ccc08d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.41531986e-04,  9.52036180e-06, -1.47076092e-04])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#First, we need to initialize small, random weights (can be positive or negative)\n",
    "w = np.random.randn(3) * 1e-4\n",
    "w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "dbd50339",
   "metadata": {},
   "outputs": [],
   "source": [
    "g = lambda inputs,weights: np.where(np.dot(inputs,weights)>0 , 1, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e4ab169",
   "metadata": {},
   "source": [
    "We are writing a simple activation function as lambda function with value as input and weights.\n",
    "np.where(np.dot(inputs,weights)>0 , 1, 0) =  This will output to 1 if dot product of inputs and weights > 0 otherwise 0. One of the purpose of activation function is to normalize the data, that's what we are doing here between 0 and 1."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5d4bec1",
   "metadata": {},
   "source": [
    "## Training function that will iterate learning algorithm and return adapted weights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "ebb5c1a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(inputs, targets, weights, eta, n_iterations):\n",
    "\n",
    "    # Add the inputs that match the bias node\n",
    "    inputs = np.c_[inputs, -np.ones((len(inputs), 1))]\n",
    "\n",
    "    for n in range(n_iterations):\n",
    "\n",
    "        activations = g(inputs, weights)\n",
    "        print(n,activations)\n",
    "        weights -= eta*np.dot(np.transpose(inputs), activations - targets)\n",
    "        print(n,weights)\n",
    "    return(weights)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8b760d4",
   "metadata": {},
   "source": [
    "Let's test it first on the AND function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "68284b7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 [1 1 1 1]\n",
      "0 [ 1.31531986e-04 -4.79638200e-07 -1.17076092e-04]\n",
      "1 [1 1 1 1]\n",
      "1 [ 1.21531986e-04 -1.04796382e-05 -8.70760925e-05]\n",
      "2 [1 1 1 1]\n",
      "2 [ 1.11531986e-04 -2.04796382e-05 -5.70760925e-05]\n",
      "3 [1 1 1 1]\n",
      "3 [ 1.01531986e-04 -3.04796382e-05 -2.70760925e-05]\n",
      "4 [1 0 1 1]\n",
      "4 [ 9.15319861e-05 -3.04796382e-05 -7.07609246e-06]\n",
      "5 [1 0 1 1]\n",
      "5 [ 8.15319861e-05 -3.04796382e-05  1.29239075e-05]\n",
      "6 [0 0 1 1]\n",
      "6 [ 7.15319861e-05 -3.04796382e-05  2.29239075e-05]\n",
      "7 [0 0 1 1]\n",
      "7 [ 6.15319861e-05 -3.04796382e-05  3.29239075e-05]\n",
      "8 [0 0 1 0]\n",
      "8 [ 6.15319861e-05 -2.04796382e-05  3.29239075e-05]\n",
      "9 [0 0 1 1]\n",
      "9 [ 5.15319861e-05 -2.04796382e-05  4.29239075e-05]\n"
     ]
    }
   ],
   "source": [
    "inputs = AND[['x1','x2']]\n",
    "target = AND['y']\n",
    "\n",
    "#Learning rate = 0.00001\n",
    "#Iterations = 10\n",
    "t = train(inputs, target, w,0.00001, 10)\n"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}