Pytorch_Basics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "0661b154-c4a8-4cc2-8403-f3aa4d2551ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Looking in links: /usr/share/pip-wheels\n",
      "Requirement already satisfied: torchviz in ./.local/lib/python3.11/site-packages (0.0.2)\n",
      "Requirement already satisfied: torch in /opt/conda/envs/anaconda-panel-2023.05-py310/lib/python3.11/site-packages (from torchviz) (1.13.1)\n",
      "Requirement already satisfied: graphviz in ./.local/lib/python3.11/site-packages (from torchviz) (0.20.1)\n",
      "Requirement already satisfied: typing-extensions in /opt/conda/envs/anaconda-panel-2023.05-py310/lib/python3.11/site-packages (from torch->torchviz) (4.5.0)\n"
     ]
    }
   ],
   "source": [
    "!pip install torchviz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "21ad361c-012f-45ea-8b86-85144248d1f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "from torchviz import make_dot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "74ce61cb-5cc3-4ee6-8dc7-f05768f3076f",
   "metadata": {},
   "outputs": [],
   "source": [
    "true_b = 1\n",
    "true_w = 2\n",
    "N = 100\n",
    "np.random.seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b11fbeeb-a829-424f-bb18-434ebeb685ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Data Generation\"\"\"\n",
    "X = np.random.randn(N,1)\n",
    "epsilon = (.1 * np.random.randn(N,1))\n",
    "y = true_b + true_w * X + epsilon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9af86d15-4737-4585-a300-881674321525",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Shuffle and Indices\"\"\"\n",
    "idx = np.arange(N)\n",
    "np.random.shuffle(idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b6578d93-86fb-43fc-a222-d2765344c92e",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Use first 80 indexes for training\"\"\"\n",
    "train_idx = idx[:int(N* 0.8)]\n",
    "\"\"\"Use remaning indexes for validation\"\"\"\n",
    "val_idx = idx[int(N*0.8):]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "11cc3ee0-c0b8-43c4-ac41-a88c7717e077",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.3276621465977682"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Generate traning and validation sets\"\"\"\n",
    "X_train,y_train,X_val,y_val = X[train_idx],y[train_idx],X[val_idx],y[val_idx]\n",
    "X_train[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b1bfb0f3-f67c-471a-b841-840ecaf797fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(-0.3277)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Generate tensors from numpy array\"\"\"\n",
    "X_train_tensor = torch.as_tensor(X_train).float()\n",
    "X_train_tensor[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ff65d11e-2dad-4c2c-820c-638ffa726e24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cpu'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Configure device\"\"\"\n",
    "device = ('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e514ce03-e9b8-4c00-99ba-66ee39dabbf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Generat GPU tensor\"\"\"\n",
    "X_train_tensor = torch.as_tensor(X_train).float().to(device)\n",
    "y_train_tensor = torch.as_tensor(y_train).float().to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ef0265e1-0b1b-4f8e-ba98-2023a1320a25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.32766214"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Back to Numpy\"\"\"\n",
    "back_to_numpy = X_train_tensor.numpy()\n",
    "back_to_numpy[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1debb03a-39c7-49a1-8620-330780f78a4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.3367], requires_grad=True) tensor([0.1288], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "\"\"\"First Step\"\"\"\n",
    "torch.manual_seed(42)\n",
    "b = torch.randn(1,dtype=torch.float32,requires_grad=True,device=device)\n",
    "w = torch.randn(1,dtype=torch.float32,requires_grad=True,device=device)\n",
    "print(b,w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f1ac800d-5228-440a-83a2-7708c6bfa495",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(3.0535, grad_fn=<MeanBackward0>)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yhat =  w * X_train_tensor + b\n",
    "error = (yhat - y_train_tensor)\n",
    "loss = (error**2).mean()\n",
    "loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2aceb6c2-dff0-4719-bdb3-4c44dada62c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "93bbfe4f-e64b-483a-be50-c94567564ad9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-1.1663])\n",
      "tensor([-2.8676])\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Actual values of the grad\"\"\"\n",
    "print(b.grad)\n",
    "print(w.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8ab34c82-4789-4c40-a305-894d597ed7a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([0.]), tensor([0.]))"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Updatint the weights and bias\"\"\"\n",
    "b.grad.zero_(), w.grad.zero_()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "93b365a6-bf7e-45ed-b3df-505c2e01e6e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.9958], requires_grad=True) tensor([1.9852], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "from torchviz import make_dot\n",
    "# Set the learning rate \n",
    "lr = 0.1\n",
    "\n",
    "# Step 0: Initialize weights and balances\n",
    "torch.manual_seed(42)\n",
    "b = torch.randn(1,dtype=torch.float32,requires_grad=True,device=device)\n",
    "w = torch.randn(1,dtype=torch.float32,requires_grad=True,device=device)\n",
    "\n",
    "# Define the number of epochs\n",
    "n_epochs = 1000\n",
    "\n",
    "for epoch in range(n_epochs):\n",
    "    # Step 1 - Compute model's predicted output \n",
    "    yhat = w * X_train_tensor + b\n",
    "    \n",
    "    # Step 2 - Compute error and loss\n",
    "    error = (yhat - y_train_tensor)\n",
    "    loss = (error **2).mean()\n",
    "    \n",
    "    #Step 3 - Compute gradients for both w and b\n",
    "    loss.backward()\n",
    "    \n",
    "    #Step 4 - Update the gradients \n",
    "    with torch.no_grad():\n",
    "        b -= lr * b.grad\n",
    "        w -= lr * w.grad\n",
    "        b.grad.zero_()\n",
    "        w.grad.zero_()\n",
    "\n",
    "print(b,w)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "5a7c617c-4bd5-4028-b965-b4de29d00b54",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.43.0 (0)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"222pt\" height=\"283pt\"\n",
       " viewBox=\"0.00 0.00 222.00 283.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 279)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-279 218,-279 218,4 -4,4\"/>\n",
       "<!-- 140163746919312 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>140163746919312</title>\n",
       "<polygon fill=\"#caff70\" stroke=\"black\" points=\"139,-31 74,-31 74,0 139,0 139,-31\"/>\n",
       "<text text-anchor=\"middle\" x=\"106.5\" y=\"-7\" font-family=\"monospace\" font-size=\"10.00\"> (80, 1)</text>\n",
       "</g>\n",
       "<!-- 140163761934096 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>140163761934096</title>\n",
       "<polygon fill=\"lightgrey\" stroke=\"black\" points=\"151,-86 62,-86 62,-67 151,-67 151,-86\"/>\n",
       "<text text-anchor=\"middle\" x=\"106.5\" y=\"-74\" font-family=\"monospace\" font-size=\"10.00\">AddBackward0</text>\n",
       "</g>\n",
       "<!-- 140163761934096&#45;&gt;140163746919312 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>140163761934096&#45;&gt;140163746919312</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M106.5,-66.79C106.5,-60.07 106.5,-50.4 106.5,-41.34\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"110,-41.19 106.5,-31.19 103,-41.19 110,-41.19\"/>\n",
       "</g>\n",
       "<!-- 140163761936112 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>140163761936112</title>\n",
       "<polygon fill=\"lightgrey\" stroke=\"black\" points=\"95,-141 6,-141 6,-122 95,-122 95,-141\"/>\n",
       "<text text-anchor=\"middle\" x=\"50.5\" y=\"-129\" font-family=\"monospace\" font-size=\"10.00\">MulBackward0</text>\n",
       "</g>\n",
       "<!-- 140163761936112&#45;&gt;140163761934096 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>140163761936112&#45;&gt;140163761934096</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M59.5,-121.98C67.69,-114.23 80.01,-102.58 89.97,-93.14\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"92.48,-95.59 97.34,-86.17 87.67,-90.5 92.48,-95.59\"/>\n",
       "</g>\n",
       "<!-- 140163761933856 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>140163761933856</title>\n",
       "<polygon fill=\"lightgrey\" stroke=\"black\" points=\"101,-202 0,-202 0,-183 101,-183 101,-202\"/>\n",
       "<text text-anchor=\"middle\" x=\"50.5\" y=\"-190\" font-family=\"monospace\" font-size=\"10.00\">AccumulateGrad</text>\n",
       "</g>\n",
       "<!-- 140163761933856&#45;&gt;140163761936112 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>140163761933856&#45;&gt;140163761936112</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M50.5,-182.79C50.5,-174.6 50.5,-162.06 50.5,-151.55\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"54,-151.24 50.5,-141.24 47,-151.24 54,-151.24\"/>\n",
       "</g>\n",
       "<!-- 140163746921552 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>140163746921552</title>\n",
       "<polygon fill=\"lightblue\" stroke=\"black\" points=\"77.5,-275 23.5,-275 23.5,-244 77.5,-244 77.5,-275\"/>\n",
       "<text text-anchor=\"middle\" x=\"50.5\" y=\"-251\" font-family=\"monospace\" font-size=\"10.00\"> (1)</text>\n",
       "</g>\n",
       "<!-- 140163746921552&#45;&gt;140163761933856 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>140163746921552&#45;&gt;140163761933856</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M50.5,-243.75C50.5,-234.39 50.5,-222.19 50.5,-212.16\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"54,-212.02 50.5,-202.02 47,-212.02 54,-212.02\"/>\n",
       "</g>\n",
       "<!-- 140163761931696 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>140163761931696</title>\n",
       "<polygon fill=\"lightgrey\" stroke=\"black\" points=\"214,-141 113,-141 113,-122 214,-122 214,-141\"/>\n",
       "<text text-anchor=\"middle\" x=\"163.5\" y=\"-129\" font-family=\"monospace\" font-size=\"10.00\">AccumulateGrad</text>\n",
       "</g>\n",
       "<!-- 140163761931696&#45;&gt;140163761934096 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>140163761931696&#45;&gt;140163761934096</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M154.34,-121.98C146,-114.23 133.47,-102.58 123.32,-93.14\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"125.53,-90.42 115.82,-86.17 120.76,-95.54 125.53,-90.42\"/>\n",
       "</g>\n",
       "<!-- 140165035879680 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>140165035879680</title>\n",
       "<polygon fill=\"lightblue\" stroke=\"black\" points=\"190.5,-208 136.5,-208 136.5,-177 190.5,-177 190.5,-208\"/>\n",
       "<text text-anchor=\"middle\" x=\"163.5\" y=\"-184\" font-family=\"monospace\" font-size=\"10.00\"> (1)</text>\n",
       "</g>\n",
       "<!-- 140165035879680&#45;&gt;140163761931696 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>140165035879680&#45;&gt;140163761931696</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M163.5,-176.92C163.5,-169.22 163.5,-159.69 163.5,-151.43\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"167,-151.25 163.5,-141.25 160,-151.25 167,-151.25\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.graphs.Digraph at 0x7f7a6b674cd0>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set the learning rate \n",
    "lr = 0.1\n",
    "\n",
    "# Step 0: Initialize weights and balances\n",
    "torch.manual_seed(42)\n",
    "b = torch.randn(1,dtype=torch.float32,requires_grad=True,device=device)\n",
    "w = torch.randn(1,dtype=torch.float32,requires_grad=True,device=device)\n",
    "\n",
    "# Step 1 - Compute model's predicted output \n",
    "yhat = w * X_train_tensor + b\n",
    "    \n",
    "# Step 2 - Compute error and loss\n",
    "error = (yhat - y_train_tensor)\n",
    "loss = (error **2).mean()\n",
    "\n",
    "make_dot(yhat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "6411f2c5-0f22-4baf-b521-f07c6513858a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.9957802] [1.9851683] 0.0075665177\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Using optimizer SGD\"\"\"\n",
    "\n",
    "\"\"\"Using pytorch actual MSELoss\"\"\"\n",
    "\n",
    "# Set the learning rate \n",
    "lr = 0.1\n",
    "\n",
    "# Step 0: Initialize weights and balances\n",
    "torch.manual_seed(42)\n",
    "b = torch.randn(1,dtype=torch.float32,requires_grad=True,device=device)\n",
    "w = torch.randn(1,dtype=torch.float32,requires_grad=True,device=device)\n",
    "\n",
    "# Define the optmizer \n",
    "optimizer = torch.optim.SGD([w,b],lr=lr)\n",
    "\n",
    "# Define the number of epochs\n",
    "n_epochs = 1000\n",
    "\n",
    "for epoch in range(n_epochs):\n",
    "    # Step 1 - Compute model's predicted output \n",
    "    yhat = w * X_train_tensor + b\n",
    "    \n",
    "    # Step 2 - Compute error and loss\n",
    "    #error = (yhat - y_train_tensor)\n",
    "    #loss = (error **2).mean()\n",
    "    loss_fun = torch.nn.MSELoss(reduction='mean')\n",
    "    loss = loss_fun(yhat,y_train_tensor)\n",
    "    \n",
    "    #Step 3 - Compute gradients for both w and b\n",
    "    loss.backward()\n",
    "    \n",
    "    #Step 4 - Update the gradients \n",
    "    optimizer.step()\n",
    "    \n",
    "    #Step 5 - Setting graidents to zero\n",
    "    optimizer.zero_grad()\n",
    "    \n",
    "print(b.detach().numpy(),w.detach().numpy(),loss.detach().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "19fed5e3-587e-408a-8fd0-562d877b39c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'state': {0: {'momentum_buffer': None}, 1: {'momentum_buffer': None}},\n",
       " 'param_groups': [{'lr': 0.1,\n",
       "   'momentum': 0,\n",
       "   'dampening': 0,\n",
       "   'weight_decay': 0,\n",
       "   'nesterov': False,\n",
       "   'maximize': False,\n",
       "   'foreach': None,\n",
       "   'differentiable': False,\n",
       "   'params': [0, 1]}]}"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "optimizer.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d632a936-fce2-4f28-b89a-dc20c4030886",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.007566517684608698 0.007566517684608698\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Using item() and tolist() on loss function\"\"\"\n",
    "print(loss.item(),loss.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "95742e8b-35ff-4cc6-a20c-1d4208bdface",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Implementing the model class \"\"\"\n",
    "\n",
    "class ManualLinearRegression(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.b = torch.nn.Parameter(torch.randn(1,dtype=torch.float32,requires_grad=True))\n",
    "        self.w = torch.nn.Parameter(torch.randn(1,dtype=torch.float32,requires_grad=True))\n",
    "        \n",
    "    def forward(self,X):\n",
    "        # Compute the predictions\n",
    "        return self.w * X + self.b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "3ab0d33d-532d-4952-8867-a22e71f79142",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Parameter containing:\n",
       " tensor([0.3367], requires_grad=True),\n",
       " Parameter containing:\n",
       " tensor([0.1288], requires_grad=True)]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.manual_seed(42)\n",
    "dummy = ManualLinearRegression()\n",
    "list(dummy.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "e781124b-660e-43f0-bb4f-dc2e75bd5844",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('b', tensor([0.3367])), ('w', tensor([0.1288]))])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Getting the current value of all the parameters\"\"\"\n",
    "dummy.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "828587b7-e79f-432e-abbb-1df8fb1c7209",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict([('b', tensor([0.9958])), ('w', tensor([1.9852]))])\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Implementing complete training loop with model class\"\"\"\n",
    "\n",
    "# Learning Rate \n",
    "lr = 0.1\n",
    "\n",
    "#Step 0 - Define the weights and bias\n",
    "torch.manual_seed(42)\n",
    "model = ManualLinearRegression().to(device)\n",
    "\n",
    "optimizer = torch.optim.SGD(model.parameters(),lr=lr)\n",
    "loss_fun = torch.nn.MSELoss(reduction='mean')\n",
    "\n",
    "# Defint the number of epoch\n",
    "n_epochs = 1000\n",
    "\n",
    "for epochs in range(n_epochs):\n",
    "    model.train()  # Put the model in training mode\n",
    "    \n",
    "    # Step1 - Forward pass/make predictions\n",
    "    yhat = model(X_train_tensor)\n",
    "    \n",
    "    # Step2 - Compute loss \n",
    "    loss = loss_fun(yhat,y_train_tensor)\n",
    "    \n",
    "    # Step3 - Compute the backward pass\n",
    "    loss.backward()\n",
    "    \n",
    "    # Step4 - Update the weights and bias \n",
    "    optimizer.step()\n",
    "    \n",
    "    #Step 5 - Set the weights and bias to zero\n",
    "    optimizer.zero_grad()\n",
    "    \n",
    "    \n",
    "print(model.state_dict())\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "a5cfddc6-7bde-406c-8cd2-406ad8458fdd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weight', tensor([[-0.2191]])), ('bias', tensor([0.2018]))])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Linear Model\"\"\"\n",
    "linear = torch.nn.Linear(1,1)\n",
    "linear.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "92a5481e-2c3a-4fc5-ad0d-7ba53dc65a83",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Making using Linear Model\"\"\"\n",
    "class MyLinearRegressionModel(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.linear = torch.nn.Linear(1,1) # in_feature =1 , out_feature =1, bias = True\n",
    "        \n",
    "    def forward(self,X):\n",
    "        return self.Linear(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "5d25f62e-0ec2-49f7-ba92-f328e394fa8d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Parameter containing:\n",
       " tensor([[0.7645]], requires_grad=True),\n",
       " Parameter containing:\n",
       " tensor([0.8300], requires_grad=True)]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.manual_seed(42)\n",
    "dummy1 = MyLinearRegressionModel()\n",
    "list(dummy1.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "f5fd03a0-ad0a-4ad4-9fab-21b6bbda61d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Building lienar model with 3 inputs and 1 outputs with 5 hidden\"\"\"\n",
    "torch.manual_seed(42)\n",
    "model = torch.nn.Sequential(\n",
    "        torch.nn.Linear(3,5),\n",
    "        torch.nn.Linear(5,1)\n",
    ").to(device)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "0cf17317-ba8c-4174-9076-674a00a8e71e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('0.weight',\n",
       "              tensor([[ 0.4414,  0.4792, -0.1353],\n",
       "                      [ 0.5304, -0.1265,  0.1165],\n",
       "                      [-0.2811,  0.3391,  0.5090],\n",
       "                      [-0.4236,  0.5018,  0.1081],\n",
       "                      [ 0.4266,  0.0782,  0.2784]])),\n",
       "             ('0.bias', tensor([-0.0815,  0.4451,  0.0853, -0.2695,  0.1472])),\n",
       "             ('1.weight',\n",
       "              tensor([[-0.2060, -0.0524, -0.1816,  0.2967, -0.3530]])),\n",
       "             ('1.bias', tensor([-0.2062]))])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "bfbf1e91-e719-4950-8b14-814ccd26c21a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (Input_Layer): Linear(in_features=3, out_features=5, bias=True)\n",
       "  (Output_Layer): Linear(in_features=5, out_features=1, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Using add_module() to rename the layers\"\"\"\n",
    "torch.manual_seed(42)\n",
    "model = torch.nn.Sequential()\n",
    "model.add_module('Input_Layer', torch.nn.Linear(3,5))\n",
    "model.add_module('Output_Layer', torch.nn.Linear(5,1))\n",
    "model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f22f7467-9651-4e91-b4d3-8836180e3b7e",
   "metadata": {},
   "source": [
    "### Putting all together\n",
    "* Data Preparation\n",
    "* Model Configuration\n",
    "* Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "c1d62c52-bff5-4829-b0c5-d10ecd31d081",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing data_preparation/v0.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile data_preparation/v0.py\n",
    "\n",
    "\"\"\"Data Preparation\"\"\"\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "X_train_tensor = torch.as_tensor(X_train).float().to(device)\n",
    "y_train_tensor = torch.as_tensor(y_train).float().to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "9a35100c-eb0e-4127-887a-f955716aba57",
   "metadata": {},
   "outputs": [],
   "source": [
    "%run -i data_preparation/v0.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "0554084e-0a2d-4d0b-a2d5-7ad656295392",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting model_configuration/v0.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile model_configuration/v0.py\n",
    "\n",
    "torch.manual_seed(42)\n",
    "# Learning rate \n",
    "lr = 0.1\n",
    "\n",
    "# Model \n",
    "model = torch.nn.Sequential(torch.nn.Linear(1,1)).to(device)\n",
    "\n",
    "# Optimizer \n",
    "optimizer = torch.optim.SGD(model.parameters(),lr=lr)\n",
    "\n",
    "# Loss \n",
    "loss_fun = torch.nn.MSELoss(reduction='mean')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "dd97bccb-e3f3-4e8b-bf04-d187a51f75af",
   "metadata": {},
   "outputs": [],
   "source": [
    "%run -i model_configuration/v0.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "b11b967c-1308-4454-a9f3-8279ade7821a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting model_training/v0.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile model_training/v0.py\n",
    "\n",
    "# Define the epochs\n",
    "n_epochs = 1000\n",
    "\n",
    "for epoch in range(n_epochs):\n",
    "    model.train() # put model in training mode\n",
    "    \n",
    "    #Step 1 - Forward pass/make predictions\n",
    "    yhat = model(X_train_tensor)\n",
    "    \n",
    "    #Step 2 - Calcuate the loss\n",
    "    loss = loss_fun(yhat,y_train_tensor)\n",
    "    \n",
    "    #Step 3 - Calculate the gradient \n",
    "    loss.backward()\n",
    "    \n",
    "    #Sep 4 - Update the parameters\n",
    "    optimizer.step()\n",
    "    \n",
    "    #Step 5 - Set gradient to zero \n",
    "    optimizer.zero_grad()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "efa691cc-7734-48f1-bbda-8b53667d9a17",
   "metadata": {},
   "outputs": [],
   "source": [
    "%run -i model_training/v0.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "b30628c0-01c0-4e4c-86a3-385323f511e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict([('0.weight', tensor([[1.9852]])), ('0.bias', tensor([0.9958]))])\n"
     ]
    }
   ],
   "source": [
    "print(model.state_dict())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec7f77a4-96c8-4070-8369-b3deefe3e37a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "anaconda-panel-2023.05-py310",
   "language": "python",
   "name": "conda-env-anaconda-panel-2023.05-py310-py"
  },
  "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.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}