01.Simple NN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # helps with the math\n",
    "import matplotlib.pyplot as plt # to plot error during training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# input data\n",
    "inputs = np.array([[0, 1, 0],\n",
    "                   [0, 1, 1],\n",
    "                   [0, 0, 0],\n",
    "                   [1, 0, 0],\n",
    "                   [1, 1, 1],\n",
    "                   [1, 0, 1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# output data\n",
    "outputs = np.array([[0], [0], [0], [1], [1], [1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create NeuralNetwork class\n",
    "class NeuralNetwork:\n",
    "\n",
    "    # intialize variables in class\n",
    "    def __init__(self, inputs, outputs):\n",
    "        self.inputs  = inputs\n",
    "        self.outputs = outputs\n",
    "        # initialize weights as .50 for simplicity\n",
    "        self.weights = np.array([[.50], [.50], [.50]])\n",
    "        self.error_history = []\n",
    "        self.epoch_list = []\n",
    "\n",
    "    #activation function ==> S(x) = 1/1+e^(-x)\n",
    "    def sigmoid(self, x, deriv=False):\n",
    "        if deriv == True:\n",
    "            return x * (1 - x)\n",
    "        return 1 / (1 + np.exp(-x))\n",
    "\n",
    "    # data will flow through the neural network.\n",
    "    def feed_forward(self):\n",
    "        self.hidden = self.sigmoid(np.dot(self.inputs, self.weights))\n",
    "\n",
    "    # going backwards through the network to update weights\n",
    "    def backpropagation(self):\n",
    "        self.error  = self.outputs - self.hidden\n",
    "        delta = self.error * self.sigmoid(self.hidden, deriv=True)\n",
    "        self.weights += np.dot(self.inputs.T, delta)\n",
    "\n",
    "    # train the neural net for 25,000 iterations\n",
    "    def train(self, epochs=25000):\n",
    "        for epoch in range(epochs):\n",
    "            # flow forward and produce an output\n",
    "            self.feed_forward()\n",
    "            # go back though the network to make corrections based on the output\n",
    "            self.backpropagation()    \n",
    "            # keep track of the error history over each epoch\n",
    "            self.error_history.append(np.average(np.abs(self.error)))\n",
    "            self.epoch_list.append(epoch)\n",
    "\n",
    "    # function to predict output on new and unseen input data                               \n",
    "    def predict(self, new_input):\n",
    "        prediction = self.sigmoid(np.dot(new_input, self.weights))\n",
    "        return prediction\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create neural network   \n",
    "NN = NeuralNetwork(inputs, outputs)\n",
    "# train neural network\n",
    "NN.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create two new examples to predict                                   \n",
    "example = np.array([[1, 1, 0]])\n",
    "example_2 = np.array([[0, 1, 1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.99089925]]  - Correct:  1\n",
      "[[0.006409]]  - Correct:  0\n"
     ]
    }
   ],
   "source": [
    "# print the predictions for both examples                                   \n",
    "print(NN.predict(example), ' - Correct: ', example[0][0])\n",
    "print(NN.predict(example_2), ' - Correct: ', example_2[0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the error over the entire training duration\n",
    "plt.figure(figsize=(15,5))\n",
    "plt.plot(NN.epoch_list, NN.error_history)\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Error')\n",
    "plt.show()"
   ]
  }
 ],
 "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}