MADALINE.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 408
    },
    "colab_type": "code",
    "id": "dOG3NZaIv_0T",
    "outputId": "bf29551e-3666-45ef-f9da-b6b496793d8a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stage 1) Random starting synaptic weights: \n",
      "    Layer 1 (4 neurons, each with 3 inputs): \n",
      "[[-0.16595599  0.44064899 -0.99977125 -0.39533485]\n",
      " [-0.70648822 -0.81532281 -0.62747958 -0.30887855]\n",
      " [-0.20646505  0.07763347 -0.16161097  0.370439  ]]\n",
      "    Layer 2 (1 neuron, with 4 inputs):\n",
      "[[-0.5910955 ]\n",
      " [ 0.75623487]\n",
      " [-0.94522481]\n",
      " [ 0.34093502]]\n",
      "Stage 2) New synaptic weights after training: \n",
      "    Layer 1 (4 neurons, each with 3 inputs): \n",
      "[[-2.81850325  3.2491946  -3.58559813 -0.11520687]\n",
      " [-2.78950106  3.05944946 -3.65345378 -0.04030098]\n",
      " [ 2.44718593 -3.39583113  4.28846198 -0.08874238]]\n",
      "    Layer 2 (1 neuron, with 4 inputs):\n",
      "[[ -7.24558983]\n",
      " [  7.32095473]\n",
      " [-10.31802333]\n",
      " [ -0.46611113]]\n",
      "Stage 3) Considering a new situation  \n",
      "So testing the data using [1 0 0 ]\n",
      "[0.99785264]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "from numpy import exp, array, random, dot\n",
    "\n",
    "\n",
    "class NeuronLayer():\n",
    "    def __init__(self, number_of_neurons, number_of_inputs_per_neuron):\n",
    "        self.synaptic_weights = 2 * random.random((number_of_inputs_per_neuron, number_of_neurons)) - 1\n",
    "\n",
    "\n",
    "class NeuralNetwork():\n",
    "    def __init__(self, layer1, layer2):\n",
    "        self.layer1 = layer1\n",
    "        self.layer2 = layer2\n",
    "\n",
    "    # The Sigmoid function, which describes an S shaped curve.\n",
    "    # We pass the weighted sum of the inputs through this function to\n",
    "    # normalise them between 0 and 1.\n",
    "    def __sigmoid(self, x):\n",
    "        return 1 / (1 + exp(-x))\n",
    "\n",
    "    # The derivative of the Sigmoid function.\n",
    "    # This is the gradient of the Sigmoid curve.\n",
    "    # It indicates how confident we are about the existing weight.\n",
    "    def __sigmoid_derivative(self, x):\n",
    "        return x * (1 - x)\n",
    "\n",
    "    # We train the neural network through a process of trial and error.\n",
    "    # Adjusting the synaptic weights each time.\n",
    "    def train(self, training_set_inputs, training_set_outputs, number_of_training_iterations):\n",
    "        for iteration in range(number_of_training_iterations):\n",
    "            # Pass the training set through our neural network\n",
    "            output_from_layer_1, output_from_layer_2 = self.think(training_set_inputs)\n",
    "\n",
    "            # Calculate the error for layer 2 (The difference between the desired output\n",
    "            # and the predicted output).\n",
    "            layer2_error = training_set_outputs - output_from_layer_2\n",
    "            layer2_delta = layer2_error * self.__sigmoid_derivative(output_from_layer_2)\n",
    "\n",
    "            # Calculate the error for layer 1 (By looking at the weights in layer 1,\n",
    "            # we can determine by how much layer 1 contributed to the error in layer 2).\n",
    "            layer1_error = layer2_delta.dot(self.layer2.synaptic_weights.T)\n",
    "            layer1_delta = layer1_error * self.__sigmoid_derivative(output_from_layer_1)\n",
    "\n",
    "            # Calculate how much to adjust the weights by\n",
    "            layer1_adjustment = training_set_inputs.T.dot(layer1_delta)\n",
    "            layer2_adjustment = output_from_layer_1.T.dot(layer2_delta)\n",
    "\n",
    "            # Adjust the weights.\n",
    "            self.layer1.synaptic_weights += layer1_adjustment\n",
    "            self.layer2.synaptic_weights += layer2_adjustment\n",
    "\n",
    "    # The neural network thinks.\n",
    "    def think(self, inputs):\n",
    "        output_from_layer1 = self.__sigmoid(dot(inputs, self.layer1.synaptic_weights))\n",
    "        output_from_layer2 = self.__sigmoid(dot(output_from_layer1, self.layer2.synaptic_weights))\n",
    "        return output_from_layer1, output_from_layer2\n",
    "\n",
    "    # The neural network prints its weights\n",
    "    def print_weights(self):\n",
    "        print (\"    Layer 1 (4 neurons, each with 3 inputs): \")\n",
    "        print (self.layer1.synaptic_weights)\n",
    "        print (\"    Layer 2 (1 neuron, with 4 inputs):\")\n",
    "        print (self.layer2.synaptic_weights)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "\n",
    "    #Seed the random number generator\n",
    "    random.seed(1)\n",
    "\n",
    "    # Create layer 1 (4 neurons, each with 3 inputs)\n",
    "    layer1 = NeuronLayer(4, 3)\n",
    "\n",
    "    # Create layer 2 (a single neuron with 4 inputs)\n",
    "    layer2 = NeuronLayer(1, 4)\n",
    "\n",
    "    # Combine the layers to create a neural network\n",
    "    neural_network = NeuralNetwork(layer1, layer2)\n",
    "\n",
    "    print (\"Stage 1) Random starting synaptic weights: \")\n",
    "    neural_network.print_weights()\n",
    "\n",
    "    # The training set. We have 7 examples, each consisting of 3 input values\n",
    "    # and 1 output value.\n",
    "    training_set_inputs = array([[0, 0, 0],[1,0,0], [0, 1, 1], [1, 0, 1], [0, 1, 0], [1, 0, 0], [1, 1, 1]])\n",
    "    training_set_outputs = array([[0,1, 0,0, 1, 1,1]]).T\n",
    "\n",
    "    # Train the neural network using the training set.\n",
    "    # Do it 60,000 times and make small adjustments each time.\n",
    "    neural_network.train(training_set_inputs, training_set_outputs, 60000)\n",
    "\n",
    "    print (\"Stage 2) New synaptic weights after training: \")\n",
    "    neural_network.print_weights()\n",
    "\n",
    "    # Test the neural network with a new situation.\n",
    "    print (\"Stage 3) Considering a new situation  \")\n",
    "    print(\"So testing the data using [1 0 0 ]\")\n",
    "    hidden_state, output = neural_network.think(array([1, 0, 0]))\n",
    "    print (output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "T9DpLGCawDOA"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "name": "MADALINE.ipynb",
   "provenance": []
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}