06_2_model_loss_and_ optimizer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d8ff4a79",
   "metadata": {},
   "source": [
    "1) Design model (input, output, forward pass with different layers)\n",
    "2) Construct loss and optimizer\n",
    "3) Training loop\n",
    "      - Forward = compute prediction and loss\n",
    "      - Backward = compute gradients\n",
    "      - Update weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "58b4e11d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import icecream as ic"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c5b960d",
   "metadata": {},
   "source": [
    "Linear regression\n",
    "f = w * x "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffd14aca",
   "metadata": {},
   "source": [
    "here : f = 2 * x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f900226e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 0) Training samples, watch the shape!\n",
    "X = torch.tensor([[1], [2], [3], [4]], dtype=torch.float32)\n",
    "Y = torch.tensor([[2], [4], [6], [8]], dtype=torch.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e20b898e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#samples: 4, #features: 1\n",
      "torch.Size([4, 1])\n"
     ]
    }
   ],
   "source": [
    "n_samples, n_features = X.shape\n",
    "print(f'#samples: {n_samples}, #features: {n_features}')\n",
    "print(X.shape)\n",
    "# 0) create a test sample\n",
    "X_test = torch.tensor([5], dtype=torch.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8a0d2ef1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1) Design Model, the model has to implement the forward pass!\n",
    "# Here we can use a built-in model from PyTorch\n",
    "input_size = n_features\n",
    "output_size = n_features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "04aaf876",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can call this model with samples X\n",
    "model = nn.Linear(input_size, output_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d80b4d66",
   "metadata": {},
   "source": [
    "'''\n",
    "class LinearRegression(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim):\n",
    "        super(LinearRegression, self).__init__()\n",
    "        # define diferent layers+\n",
    "        \n",
    "        self.lin = nn.Linear(input_dim, output_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.lin(x)\n",
    "\n",
    "model = LinearRegression(input_size, output_size)\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "de6169d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction before training: f(5) = 2.059\n"
     ]
    }
   ],
   "source": [
    "print(f'Prediction before training: f(5) = {model(X_test).item():.3f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "978385f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2) Define loss and optimizer\n",
    "learning_rate = 0.01\n",
    "n_iters = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "04e948ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = nn.MSELoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a6173548",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch  1 : w =  0.6479976177215576  loss =  tensor(18.8883, grad_fn=<MseLossBackward0>)\n",
      "epoch  11 : w =  1.6471731662750244  loss =  tensor(0.5259, grad_fn=<MseLossBackward0>)\n",
      "epoch  21 : w =  1.8118878602981567  loss =  tensor(0.0486, grad_fn=<MseLossBackward0>)\n",
      "epoch  31 : w =  1.8422622680664062  loss =  tensor(0.0342, grad_fn=<MseLossBackward0>)\n",
      "epoch  41 : w =  1.850913643836975  loss =  tensor(0.0319, grad_fn=<MseLossBackward0>)\n",
      "epoch  51 : w =  1.8559596538543701  loss =  tensor(0.0301, grad_fn=<MseLossBackward0>)\n",
      "epoch  61 : w =  1.8603177070617676  loss =  tensor(0.0283, grad_fn=<MseLossBackward0>)\n",
      "epoch  71 : w =  1.8644604682922363  loss =  tensor(0.0267, grad_fn=<MseLossBackward0>)\n",
      "epoch  81 : w =  1.8684667348861694  loss =  tensor(0.0251, grad_fn=<MseLossBackward0>)\n",
      "epoch  91 : w =  1.8723524808883667  loss =  tensor(0.0237, grad_fn=<MseLossBackward0>)\n"
     ]
    }
   ],
   "source": [
    "# 3) Training loop\n",
    "for epoch in range(n_iters):\n",
    "    # predict = forward pass with our model\n",
    "    y_predicted = model(X)\n",
    "\n",
    "    # loss\n",
    "    l = loss(Y, y_predicted)\n",
    "\n",
    "    # calculate gradients = backward pass\n",
    "    l.backward()\n",
    "\n",
    "    # update weights\n",
    "    optimizer.step()\n",
    "\n",
    "    # zero the gradients after updating\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    if epoch % 10 == 0:\n",
    "        [w, b] = model.parameters() # unpack parameters\n",
    "        print('epoch ', epoch+1, ': w = ', w[0][0].item(), ' loss = ', l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "efe13805",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction after training: f(5) = 9.744\n"
     ]
    }
   ],
   "source": [
    "print(f'Prediction after training: f(5) = {model(X_test).item():.3f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9792e7dd",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all"
  },
  "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.8.18"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}