ann-6 forward and backward prop.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "35IYAKxuqvDa"
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "CQaYJ-PIqvDd"
   },
   "outputs": [],
   "source": [
    "# Define the sigmoid activation function\n",
    "def sigmoid(x):\n",
    "    return 1 / (1 + np.exp(-x))\n",
    "\n",
    "# Define the derivative of the sigmoid function\n",
    "def sigmoid_derivative(x):\n",
    "    return x * (1 - x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "Ab_JxpjWqvDd"
   },
   "outputs": [],
   "source": [
    "class NeuralNetwork:\n",
    "    def __init__(self, x, y):\n",
    "        # Initialize the input and output layers\n",
    "        self.input = x\n",
    "        self.output = y\n",
    "        # Define the number of neurons in the hidden layer\n",
    "        self.hidden_size = 4\n",
    "        # Initialize the weight matrices with random values\n",
    "        self.weights1 = np.random.randn(self.input.shape[1], self.hidden_size)\n",
    "        self.weights2 = np.random.randn(self.hidden_size, 1)\n",
    "\n",
    "    def feedforward(self):\n",
    "        # Compute the dot product of the input and the first set of weights\n",
    "        self.hidden = sigmoid(np.dot(self.input, self.weights1))\n",
    "        # Compute the dot product of the hidden layer and the second set of weights\n",
    "        self.predicted_output = sigmoid(np.dot(self.hidden, self.weights2))\n",
    "\n",
    "    def backpropagate(self):\n",
    "        # Compute the error in the output layer\n",
    "        output_error = self.output - self.predicted_output\n",
    "        # Compute the derivative of the error with respect to the predicted output\n",
    "        d_predicted_output = output_error * sigmoid_derivative(self.predicted_output)\n",
    "        # Compute the error in the hidden layer\n",
    "        hidden_error = d_predicted_output.dot(self.weights2.T)\n",
    "        # Compute the derivative of the error with respect to the hidden layer\n",
    "        d_hidden = hidden_error * sigmoid_derivative(self.hidden)\n",
    "        # Update the weights\n",
    "        self.weights1 += self.input.T.dot(d_hidden)\n",
    "        self.weights2 += self.hidden.T.dot(d_predicted_output)\n",
    "\n",
    "    def train(self, epochs):\n",
    "        for epoch in range(epochs):\n",
    "            # Compute the output using forward propagation\n",
    "            self.feedforward()\n",
    "            # Update the weights using backpropagation\n",
    "            self.backpropagate()\n",
    "\n",
    "    def predict(self, x):\n",
    "        # Compute the dot product of the input and the first set of weights\n",
    "        hidden = sigmoid(np.dot(x, self.weights1))\n",
    "        # Compute the dot product of the hidden layer and the second set of weights\n",
    "        predicted_output = sigmoid(np.dot(hidden, self.weights2))\n",
    "        return predicted_output\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nVQALtj4qvDe",
    "outputId": "ae48843b-bc54-47e3-c36b-d44ccf0fa97c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: [0 0 0]\n",
      "Output: [0.00997864]\n",
      "Input: [1 0 1]\n",
      "Output: [0.99271315]\n"
     ]
    }
   ],
   "source": [
    "# X = np.array([[0, 0, 1], [0, 1, 1], [1, 0, 1], [1, 1, 1]])\n",
    "X = np.array([[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 0]])\n",
    "y = np.array([[0], [1], [1], [0]])\n",
    "\n",
    "# Create a neural network instance and train it\n",
    "nn = NeuralNetwork(X, y)\n",
    "nn.train(10000)\n",
    "\n",
    "# Make predictions on new data\n",
    "x_test = np.array([[0, 0, 0], [1, 0, 1]])\n",
    "for x in x_test:\n",
    "    print(\"Input:\", x)\n",
    "    print(\"Output:\", nn.predict(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "usb0mXkrrTBB"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}