3.2_SimpleNeuralNetwork.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.2 Simple Neural Networks\n",
    "\n",
    "Module - Neural Networks\n",
    "\n",
    "For book, references and training materials, please check this project website [http://activefitness.ai/ai-in-sports-with-python](http://activefitness.ai/ai-in-sports-with-python).\n",
    "\n",
    "Reference: Chapter 4, [Applied Machine Learning for Health and Fitness](https://www.apress.com/us/book/9781484257715)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Building and training Perceptron in Python\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# simple perceptron model\n",
    "import numpy as np\n",
    "import matplotlib.pylab as plt\n",
    "%matplotlib inline\n",
    "\n",
    "class Perceptron():\n",
    "\n",
    "    def __init__(self, features):\n",
    "        np.random.seed(1) # for consistency \n",
    "        self.weights = np.zeros((features, 1)) \n",
    "        self.bias = 0\n",
    "        # alternatively: use small random numbers for weights\n",
    "        #self.weights = 0.01* np.random.randn(features, 1) \n",
    "        #self.bias = 1\n",
    "        \n",
    "    def activation(self, x):\n",
    "        return np.where(x>=0, 1, 0)\n",
    "        \n",
    "    \n",
    "    def predict(self, x):\n",
    "        return self.activation(np.dot(x, self.weights) + self.bias)\n",
    "        \n",
    "    def train(self, inputs, labels, lr=0.1, epochs=20):\n",
    "        errors = []\n",
    "        for t in range(epochs):\n",
    "            # calculate prediction\n",
    "            prediction = self.activation(np.dot(inputs, self.weights) + self.bias)\n",
    "            # adjust weights and bias\n",
    "            self.weights += lr * np.dot(inputs.T, (labels - prediction))\n",
    "            self.bias += lr * np.sum(labels - prediction)\n",
    "            # calculate loss (MSE)\n",
    "            loss = np.square(np.subtract(labels,prediction)).mean() \n",
    "            errors.append(loss)\n",
    "            print(f\"epoch {t}/{epochs} loss: {loss}\")\n",
    "            \n",
    "        plt.plot(errors)\n",
    "        plt.xlabel('epoch')\n",
    "        plt.ylabel('loss (MSE)') \n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating a dataset\n",
    "==================\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize train data set: inputs and labels\n",
    "labels = np.array([ [1], [0], [0], [0]])\n",
    "inputs = np.array([[1, 1],[1,0],[0,1],[0,0]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training the model\n",
    "==================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 0/20 loss: 0.75\n",
      "epoch 1/20 loss: 0.25\n",
      "epoch 2/20 loss: 0.25\n",
      "epoch 3/20 loss: 0.0\n",
      "epoch 4/20 loss: 0.0\n",
      "epoch 5/20 loss: 0.0\n",
      "epoch 6/20 loss: 0.0\n",
      "epoch 7/20 loss: 0.0\n",
      "epoch 8/20 loss: 0.0\n",
      "epoch 9/20 loss: 0.0\n",
      "epoch 10/20 loss: 0.0\n",
      "epoch 11/20 loss: 0.0\n",
      "epoch 12/20 loss: 0.0\n",
      "epoch 13/20 loss: 0.0\n",
      "epoch 14/20 loss: 0.0\n",
      "epoch 15/20 loss: 0.0\n",
      "epoch 16/20 loss: 0.0\n",
      "epoch 17/20 loss: 0.0\n",
      "epoch 18/20 loss: 0.0\n",
      "epoch 19/20 loss: 0.0\n",
      "[[0.1]\n",
      " [0.1]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "perceptron = Perceptron(2) \n",
    "perceptron.train(inputs,labels)\n",
    "print(perceptron.weights)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Validating the model\n",
    "===================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n"
     ]
    }
   ],
   "source": [
    "# testing prediction\n",
    "test = np.array([1,1])\n",
    "print(perceptron.predict(test))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (ch4)",
   "language": "python",
   "name": "ch4"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}