XOR_PyTorch_ByHand.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a target=\"_blank\" href=\"https://colab.research.google.com/github/nairsatish/4540/blob/master/XOR_PyTorch_ByHand.ipynb\">\n",
    "  <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
    "</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "'''Define the XOR dataset and use only one pattern initially. If you want to check for another pattern, \n",
    "adjust both X and y tensors accordingly. Also, if you want to check for all patterns together, comment  \n",
    "the first two lines below and uncomment the two below that '''\n",
    "X = torch.tensor([[0, 1]], dtype=torch.float32)\n",
    "y = torch.tensor([[1]], dtype=torch.float32)\n",
    "#X = torch.tensor([[0, 1], [0, 0], [1, 0], [1, 1]], dtype=torch.float32)\n",
    "#y = torch.tensor([[1], [0], [1], [0]], dtype=torch.float32)\n",
    "\n",
    "# Define the neural network model\n",
    "class XORModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(XORModel, self).__init__()\n",
    "        self.hidden = nn.Linear(2, 2)  # Two neurons in the hidden layer\n",
    "        self.output = nn.Linear(2, 1)   # One neuron in the output layer\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = torch.relu(self.hidden(x))\n",
    "        x = torch.sigmoid(self.output(x))\n",
    "        return x\n",
    "\n",
    "# Create an instance of the model\n",
    "model = XORModel()\n",
    "\n",
    "'''User input for weights and biases; As with python, PyTorch starts lists from 0, but we start with 1\n",
    "for the matrix notation below; Matrix Wij has i as the row element and j as the column element.\n",
    "In wij, i is the receiver, and j is the sender. That is, w12 connects neuron 2 of a layer to\n",
    "neuron 1 of the next layer. Note that PyTorch stores X as a row vector. \n",
    "Given all this, the summed output = X*W_T + B which is the same as W*X_T'''\n",
    "hidden_weights = torch.tensor([[float(input(f\"Hidden Layer Weight W(1, {i+1}): \")) for i in range(2)],\n",
    "                               [float(input(f\"Hidden Layer Weight W(2, {i+1}): \")) for i in range(2)]])\n",
    "hidden_biases = torch.tensor([float(input(f\"Hidden Layer Bias {i+1}: \")) for i in range(2)])\n",
    "output_weights = torch.tensor([[float(input(\"Output Layer Weight W(3,1): \")),\n",
    "                                float(input(\"Output Layer Weight W(3,2): \"))]])\n",
    "output_biases = torch.tensor([float(input(\"Output Layer Bias: \"))])\n",
    "\n",
    "# Assign user input weights and biases to the model\n",
    "model.hidden.weight.data = hidden_weights\n",
    "model.hidden.bias.data = hidden_biases\n",
    "model.output.weight.data = output_weights\n",
    "model.output.bias.data = output_biases\n",
    "\n",
    "# Define loss function and optimizer\n",
    "criterion = nn.BCELoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.1)\n",
    "\n",
    "# First iteration forward and backward pass\n",
    "outputs = model(X)\n",
    "loss = criterion(outputs, y)\n",
    "optimizer.zero_grad()\n",
    "loss.backward()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print initial weights and biases\n",
    "print(\"\\nInitial Weights and Biases:\")\n",
    "print(\"Hidden Layer Weights:\", model.hidden.weight.data)\n",
    "print(\"Hidden Layer Biases:\", model.hidden.bias.data)\n",
    "print(\"Output Layer Weights:\", model.output.weight.data)\n",
    "print(\"Output Layer Bias:\", model.output.bias.data)\n",
    "\n",
    "# Print forward pass calculations\n",
    "print(\"\\nForward Pass Calculations:\")\n",
    "print(\"Input X:\")\n",
    "print(X)\n",
    "print(\"\\nHidden Layer Weighted Sum:\")\n",
    "print(model.hidden(X))\n",
    "print(\"\\nHidden Layer Output (ReLU):\")\n",
    "hidden_output = torch.relu(model.hidden(X))\n",
    "print(hidden_output)\n",
    "print(\"\\nOutput Layer Weighted Sum:\")\n",
    "print(model.output(hidden_output))\n",
    "print(\"\\nOutput Layer Output (Sigmoid):\")\n",
    "output_layer_output = torch.sigmoid(model.output(hidden_output))\n",
    "print(output_layer_output)\n",
    "print(\"\\nLoss:\")\n",
    "print(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print backward pass calculations\n",
    "print(\"\\nBackward Pass Calculations:\")\n",
    "#Note: Note: [del_L/del_y_hat]*[del_y_hat/del_z3] = y_hat-y\n",
    "print(\"Output Layer Gradients:\")\n",
    "print(\"Weight Gradients:\")\n",
    "print(model.output.weight.grad)\n",
    "print(\"Bias Gradient:\")\n",
    "print(model.output.bias.grad)\n",
    "print(\"\\nHidden Layer Gradients:\")\n",
    "print(\"Weight Gradients:\")\n",
    "print(model.hidden.weight.grad)\n",
    "print(\"Bias Gradient:\")\n",
    "print(model.hidden.bias.grad)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "bmtk",
   "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}