01_PyTorch_workflow.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Moksh45/PyTorch-for-deep-learning/blob/main/01_PyTorch_workflow.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "YVUN-VmBvBNl"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "from torch import nn #nn contains all of Pytorch's building block for neural network\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "68nE0qrjdNix"
      },
      "source": [
        "## Data (Preparing and loading)\n",
        "\n",
        "Data can be almost anything... in machine learning\n",
        "* Excel speadsheet\n",
        "* image of any kind\n",
        "* Video (YouTube has lot of Data)\n",
        "* Audio like songs or podcast\n",
        "* DNA\n",
        "* Text\n",
        "\n",
        "\n",
        "Machine learning is a game of two parts:\n",
        "\n",
        "\n",
        "\n",
        "1.   Get data into a numerical represntation\n",
        "2.   Bulid a model to learn patterns in that numerical representation\n",
        "\n",
        "To showcase this let's create some know data using the linear regression formula."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "psSyWWbbeY8p"
      },
      "source": [
        "We'll usea linear regression formula to make a straight line with *Know* **Parameters**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2wxvstSzdHnJ",
        "outputId": "1f3ba821-85a6-4c4e-dbd9-a0095ff472fc"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[0.0000],\n",
              "         [0.0200],\n",
              "         [0.0400],\n",
              "         [0.0600],\n",
              "         [0.0800],\n",
              "         [0.1000],\n",
              "         [0.1200],\n",
              "         [0.1400],\n",
              "         [0.1600],\n",
              "         [0.1800]]), tensor([[0.3000],\n",
              "         [0.3140],\n",
              "         [0.3280],\n",
              "         [0.3420],\n",
              "         [0.3560],\n",
              "         [0.3700],\n",
              "         [0.3840],\n",
              "         [0.3980],\n",
              "         [0.4120],\n",
              "         [0.4260]]))"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "weight = 0.7\n",
        "bias = 0.3\n",
        "\n",
        "#create \n",
        "start = 0\n",
        "end = 1\n",
        "step = 0.02\n",
        "x = torch.arange(start,end,step).unsqueeze(dim=1)\n",
        "#y = mx + B\n",
        "y = weight*x + bias\n",
        "\n",
        "x[:10],y[:10] "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GoqC0FuKhbdR",
        "outputId": "ce883107-eb08-483a-a306-eede480ab643"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(50, 50)"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "len(x),len(y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PKl9BY_GiuCZ"
      },
      "source": [
        "### Splitting data into training and test sets (one of the most important concept in machine learning in general)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VIbUcEAxjFZ-",
        "outputId": "1a0c34ce-5881-4304-cc3b-7d5417ef56ca"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(40, 40, 10, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "# create a train/test split \n",
        "train_split = int(0.8 * len(x))\n",
        "x_train, y_train = x[:train_split], y[:train_split]\n",
        "x_test, y_test = x[train_split:], y[train_split:]\n",
        "\n",
        "len(x_train), len(y_train), len(x_test), len(y_test)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0ZRPjdtulwqM"
      },
      "source": [
        "How might we better visualize our data?\n",
        "\n",
        "This is Where the data explorer's motto comes in!\n",
        "\n",
        "\"Visualize Visualize Visualize!\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "wltWz_ewmOFx"
      },
      "outputs": [],
      "source": [
        "def plot_predictions(train_data=x_train, \n",
        "                     train_labels=y_train, \n",
        "                     test_data=x_test, \n",
        "                     test_labels=y_test, \n",
        "                     predictions=None):\n",
        "  \"\"\"\n",
        "  Plots training data, test data and compares predictions.\n",
        "  \"\"\"\n",
        "  plt.figure(figsize=(10, 7))\n",
        "\n",
        "  # Plot training data in blue\n",
        "  plt.scatter(train_data, train_labels, c=\"b\", s=4, label=\"Training data\")\n",
        "  \n",
        "  # Plot test data in green\n",
        "  plt.scatter(test_data, test_labels, c=\"g\", s=4, label=\"Testing data\")\n",
        "\n",
        "  if predictions is not None:\n",
        "    # Plot the predictions in red (predictions were made on the test data)\n",
        "    plt.scatter(test_data, predictions, c=\"r\", s=4, label=\"Predictions\")\n",
        "\n",
        "  # Show the legend\n",
        "  plt.legend(prop={\"size\": 14});"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 428
        },
        "id": "1Twe6KSpn7Dd",
        "outputId": "9d70f9e1-3d70-42b5-945c-12e40f651af9"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlMAAAGbCAYAAADgEhWsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXRVhd3u8eeXhCEyxNgE1IBAEQdEVIgo69aCQ+sASr3evgKtQrUaF+R95a1jtUVB7W0Va/Ua22BrsWoVpdhS4IrWQh0qkoCFawBtRCpgSgJtUbQakvzuHydNk5jknLDPfL6ftbKSPZyzf2QzPOyzzxNzdwEAAODgZCV6AAAAgFRGmAIAAAiAMAUAABAAYQoAACAAwhQAAEAAOYk6cEFBgQ8dOjRRhwcAAIjY+vXr97h7YUfbEhamhg4dqsrKykQdHgAAIGJm9pfOtvEyHwAAQACEKQAAgAAIUwAAAAEQpgAAAAIgTAEAAAQQ9t18ZvaIpMmSat19VAfbTdL9ki6Q9LGkme6+IehgH3zwgWpra3XgwIGgT4U016NHDw0YMED9+/dP9CgAgAwUSTXCIkkPSvpFJ9vPlzSi+eM0ST9u/nzQPvjgA+3evVtFRUXKzc1VKK8Bn+Xu+uc//6ldu3ZJEoEKABB3YV/mc/eXJP2ti12mSPqFh6yVdKiZHRFkqNraWhUVFemQQw4hSKFLZqZDDjlERUVFqq2tTfQ4AIAMFI17pook7Wi1vLN53UE7cOCAcnNzAw2FzJKbm8tLwgCAhIjrDehmdrWZVZpZZV1dXbh94zQV0gG/XwAAiRKNMLVL0uBWy4Oa132Guy9092J3Ly4s7PDH2wAAAKSUaISpZZIut5DTJe1z95ooPC8AAEDSCxumzOxJSa9JOtbMdprZlWZ2jZld07zLSknbJFVLeljSrJhNm4FmzpypyZMnd+sxEydOVGlpaYwm6lppaakmTpyYkGMDAJAIYasR3H1amO0uaXbUJkpR4e7ZmTFjhhYtWtTt573//vsV+hZHbunSperRo0e3j5UI27dv17Bhw1RRUaHi4uJEjwMAQLdF0jOFCNTU/PuVzeXLl+uqq65qs679uxMPHDgQUeDJy8vr9iyHHXZYtx8DAAAODj9OJkoOP/zwlo9DDz20zbpPPvlEhx56qJ588kmdddZZys3NVXl5ufbu3atp06Zp0KBBys3N1QknnKCf//znbZ63/ct8EydO1KxZs3TLLbeooKBAAwYM0PXXX6+mpqY2+7R+mW/o0KG68847VVJSov79+2vQoEG655572hzn7bff1oQJE9S7d28de+yxWrlypfr27dvl1bTGxkZdf/31ys/PV35+vubMmaPGxsY2+zz33HM644wzlJ+fr8MOO0znnnuutmzZ0rJ92LBhkqRTTz1VZtbyEmFFRYW+/OUvq6CgQP3799cXvvAFvfbaaxGcCQBAJpm9YrZy5udo9orEvUhGmIqjb3/725o1a5Y2b96sr3zlK/rkk080ZswYLV++XFVVVbr22mtVUlKiF198scvneeKJJ5STk6M//vGPevDBB/WjH/1Iixcv7vIx9913n0488URt2LBBN910k2688caWcNLU1KSLL75YOTk5Wrt2rRYtWqR58+bp008/7fI57733Xj388MMqLy/Xa6+9psbGRj3xxBNt9vnoo480Z84crVu3TmvWrFFeXp4uvPBC1dfXS5LWrVsnKRS6ampqtHTpUknShx9+qMsuu0wvv/yy1q1bp5NPPlkXXHCB9u7d2+VMAIDMUr6+XI3eqPL15Ykbwt0T8jF27FjvzObNmzvd1l2zZrlnZ4c+x8szzzzjoW9tyLvvvuuSfMGCBWEfe+mll/qVV17ZsjxjxgyfNGlSy/KECRP89NNPb/OYc845p81jJkyY4LNnz25ZHjJkiE+dOrXNY44++mi/44473N39ueee8+zsbN+5c2fL9ldffdUl+c9//vNOZz3iiCP8zjvvbFlubGz0ESNG+IQJEzp9zP79+z0rK8tffvlld//396aioqLTx7i7NzU1+eGHH+6PPfZYp/tE8/cNACA1zFo+y7PnZfus5bH9h15SpXeSadL+ylR5udTYGPqcaO1vsG5sbNRdd92l0aNH63Of+5z69u2rpUuX6r333uvyeUaPHt1m+cgjjwz7o1S6eszWrVt15JFHqqjo38X1p556qrKyOv/tsW/fPtXU1Gj8+PEt67KysnTaaW1/LOM777yj6dOna/jw4erfv78GDhyopqamsL/G2tpalZSU6JhjjlFeXp769eun2trasI8DAGSWskllapjboLJJZQmbIe1vQC8pCQWpkpJETyL16dOnzfKCBQt077336v7779eJJ56ovn376pZbbgkbjNrfuG5mbe6ZitZjomHy5MkaNGiQysvLVVRUpJycHI0cObLlZb7OzJgxQ7t379Z9992noUOHqlevXjr77LPDPg4AgHhL+zBVVhb6SEavvPKKLrzwQl122WWSQi+5vv322y03sMfLcccdp/fff1/vv/++jjzySElSZWVll2ErLy9PRxxxhNauXauzzjpLUmj+devW6YgjQj/neu/evdq6daseeughnXnmmZKkDRs2qKGhoeV5evbsKUmfuXH9lVde0QMPPKBJkyZJknbv3t3m3ZEAACSLtH+ZL5kdc8wxevHFF/XKK69o69atKi0t1bvvvhv3Ob70pS/p2GOP1YwZM7Rx40atXbtW3/rWt5STk9Nlf9a1116ru+++W0uWLNFbb72lOXPmtAk8+fn5Kigo0MMPP6zq6mr94Q9/0DXXXKOcnH9n+AEDBig3N1erVq3S7t27tW/fPkmh783jjz+uzZs3q6KiQlOnTm0JXgAAJBPCVAJ95zvf0bhx43T++efri1/8ovr06aOvfe1rcZ8jKytLzz77rD799FONGzdOM2bM0K233iozU+/evTt93HXXXadvfOMb+uY3v6nTTjtNTU1NbebPysrS4sWLtWnTJo0aNUqzZ8/WHXfcoV69erXsk5OTowceeEA//elPdeSRR2rKlCmSpEceeUT79+/X2LFjNXXqVF1xxRUaOnRozL4HAIDkkQx1B91h3s127WgpLi72ysrKDrdt2bJFxx9/fJwnQmsbN27UySefrMrKSo0dOzbR40SE3zcAkB5y5ueo0RuVbdlqmNsQ/gFxYGbr3b3DH9XBlSlIkp599lk9//zzevfdd7V69WrNnDlTJ510ksaMGZPo0QAAGaZkbImyLVslY5Pg3WMRSPsb0BGZDz/8UDfddJN27Nih/Px8TZw4Uffdd1/YnzkIAEC0lU0qS2jVQXcRpiBJuvzyy3X55ZcnegwAAFIOL/MBAAAEQJgCAAAIgDAFAADiItUqDyJFmAIAAHFRvr5cjd6o8vVJ8ANzo4gwBQAA4iLVKg8ixbv5AABAXKRa5UGkuDKVwoYOHaoFCxYk5NiTJ0/WzJkzE3JsAACSCWEqSsysy48gweP222/XqFGjPrO+oqJCs2bNCjB1/KxZs0Zmpj179iR6FAAAooqX+aKkpqam5evly5frqquuarMuNzc36scsLCyM+nMCAIDu4cpUlBx++OEtH4ceeuhn1r300ksaO3asevfurWHDhunWW29VfX19y+OXLl2q0aNHKzc3V4cddpgmTJig3bt3a9GiRZo3b56qqqparnItWrRI0mdf5jMzLVy4UF/96lfVp08fff7zn9fjjz/eZs7XX39dY8aMUe/evXXKKado5cqVMjOtWbOm01/bxx9/rJkzZ6pv374aOHCgvve9731mn8cff1ynnnqq+vXrpwEDBuirX/2qdu3aJUnavn27zjzzTEmhANj6St1zzz2nM844Q/n5+TrssMN07rnnasuWLd3+/gMAEiddKw8iRZiKg1WrVulrX/uaSktLVVVVpUceeURLlizRLbfcIkn661//qqlTp2rGjBnasmWLXnrpJV122WWSpEsvvVTXXXedjj32WNXU1KimpkaXXnppp8eaP3++pkyZoo0bN+rSSy/VFVdcoffee0+StH//fk2ePFnHHXec1q9fr7vvvls33HBD2Pmvv/56vfDCC/rVr36lF198UW+88YZeeumlNvvU19dr3rx52rhxo5YvX649e/Zo2rRpkqTBgwfrV7/6lSSpqqpKNTU1uv/++yVJH330kebMmaN169ZpzZo1ysvL04UXXtgmaAIAklu6Vh5EzN0T8jF27FjvzObNmzvd1l2zls/y7HnZPmv5rKg9ZzjPPPOMh761IWeccYbPnz+/zT7PPvus9+nTx5uamnz9+vUuybdv397h8912221+wgknfGb9kCFD/J577mlZluQ333xzy/KBAwc8NzfXH3vsMXd3/8lPfuL5+fn+8ccft+zzxBNPuCRfvXp1h8f+8MMPvWfPnv7444+3WZeXl+czZszo9HuwZcsWl+Q7duxwd/fVq1e7JK+rq+v0Me7u+/fv96ysLH/55Ze73K8j0fx9AwCIXCL+rY03SZXeSaZJ+ytTyZCW169fr7vuukt9+/Zt+Zg+fbo++ugj/fWvf9VJJ52kc845R6NGjdIll1yiH//4x6qrqzuoY40ePbrl65ycHBUWFqq2tlaStHXrVo0aNarN/VunnXZal8/3zjvvqL6+XuPHj29Z17dvX5144olt9tuwYYOmTJmiIUOGqF+/fiouLpaklqtiXT3/9OnTNXz4cPXv318DBw5UU1NT2McBAJJH2aQyNcxtSMvag0ikfZhKhoKwpqYm3XbbbfrTn/7U8rFp0yb9+c9/VmFhobKzs/X888/r+eef1+jRo/Wzn/1MI0aM0MaNG7t9rB49erRZNjM1NTVF65fSoY8++kjnnnuuDjnkED322GOqqKjQc889J0lhX66bPHmy6urqVF5ertdff11vvPGGcnJyeJkPAJAy0v7dfMlQEDZmzBht3bpVRx99dKf7mJnGjx+v8ePHa+7cuTrhhBO0ePFinXTSSerZs6caGxsDz3Hcccfp0Ucf1T//+c+Wq1Pr1q3r8jHDhw9Xjx49tHbtWn3+85+XFApPb775poYPHy4pdMVrz549+t73vqdhw4ZJCt1Q31rPnj0lqc2vY+/evdq6daseeuihlhvUN2zYoIaGhsC/VgAA4iXtr0wlg7lz5+qXv/yl5s6dqzfffFNbt27VkiVLdOONN0qS1q5dqzvvvFMVFRV67733tGzZMu3YsUMjR46UFHrX3l/+8hdt2LBBe/bs0aeffnpQc0yfPl3Z2dm66qqrtHnzZv3ud79reWeemXX4mL59++rKK6/UTTfdpBdeeEFVVVW64oor2oSio446Sr169dKDDz6obdu2acWKFfrud7/b5nmGDBkiM9OKFStUV1en/fv3Kz8/XwUFBXr44YdVXV2tP/zhD7rmmmuUk5P2GR8AkEYIU3Fw7rnnasWKFVq9erXGjRuncePG6fvf/76OOuooSVJeXp5effVVTZ48WSNGjNB1112n7373u/r6178uSbrkkkt0wQUX6Oyzz1ZhYaGefPLJg5qjX79++u1vf6uqqiqdcsopuuGGG3T77bdLknr37t3p4xYsWKAzzzxTF198sc4880yNGjVKX/ziF1u2FxYW6tFHH9Wvf/1rjRw5UvPmzdMPf/jDNs9RVFSkefPm6dZbb9XAgQNVWlqqrKwsLV68WJs2bdKoUaM0e/Zs3XHHHerVq9dB/foAANGT6XUH3WGhG9Tjr7i42CsrKzvctmXLFh1//PFxnigz/eY3v9HFF1+s2tpaFRQUJHqcQPh9AwDRkzM/R43eqGzLVsNcbr8ws/XuXtzRNq5MZZhHH31UL7/8srZv367ly5drzpw5uvDCC1M+SAEAoisZ3sCVKrg5JcPs3r1bt912m2pqanT44Ydr0qRJ+sEPfpDosQAASSYZ3sCVKghTGebGG29sufEdAAAEx8t8AAAAASRtmIp10STSC79fAACJkpRhqk+fPtq1a5fq6+uVqHcbIjW4u+rr67Vr1y716dMn0eMAQNKj8iD6krIaoampSXv27NG+fftow0ZYOTk5ysvLU0FBgbKykvL/BwCQNKg8ODhdVSMk5Q3oWVlZGjBggAYMGJDoUQAASCslY0tUvr6cyoMoSsorUwAAAMmE0k4AAIAYIUwBAAAEEFGYMrPzzOwtM6s2s5s72D7EzF40s01mtsbMBkV/VAAAgOQTNkyZWbakMknnSxopaZqZjWy32wJJv3D30ZLmS/rf0R4UAAB0jsqDxInkytQ4SdXuvs3d6yU9JWlKu31GSvp989erO9gOAABiqHx9uRq9UeXryxM9SsaJJEwVSdrRanln87rWNkr6n81fXyypn5l9rv0TmdnVZlZpZpV1dXUHMy8AAOhAydgSZVs2lQcJEK0b0K+XNMHM3pA0QdIuSY3td3L3he5e7O7FhYWFUTo0AAAom1SmhrkNKptUluhRMk4kpZ27JA1utTyoeV0Ld39fzVemzKyvpEvc/R/RGhIAACBZRXJlqkLSCDMbZmY9JU2VtKz1DmZWYGb/eq5vS3okumMCAAAkp7Bhyt0bJJVKWiVpi6Sn3b3KzOab2UXNu02U9JaZvS1poKS7YjQvAABAUononil3X+nux7j7cHe/q3ndXHdf1vz1Encf0bzPN93901gODQBAJqDuIDXQgA4AQJKi7iA1EKYAAEhS1B2kBnP3hBy4uLjYKysrE3JsAACA7jCz9e5e3NE2rkwBAAAEQJgCAAAIgDAFAAAQAGEKAIA4o/IgvRCmAACIMyoP0gthCgCAOKPyIL1QjQAAABAG1QgAAAAxQpgCAAAIgDAFAAAQAGEKAIAoofIgMxGmAACIEioPMhNhCgCAKKHyIDNRjQAAABAG1QgAAAAxQpgCAAAIgDAFAAAQAGEKAIAuzJ4t5eSEPgMdIUwBANCF8nKpsTH0GegIYQoAgC6UlEjZ2aHPQEeoRgAAAAiDagQAAIAYIUwBAAAEQJgCAAAIgDAFAMhIVB4gWghTAICMROUBooUwBQDISFQeIFqoRgAAAAiDagQAAIAYIUwBAAAEQJgCAAAIgDAFAEgb1B0gEQhTAIC0Qd0BEoEwBQBIG9QdIBGoRgAAAAiDagQAAIAYIUwBAAAEQJgCAAAIIKIwZWbnmdlbZlZtZjd3sP0oM1ttZm+Y2SYzuyD6owIAMhWVB0hmYW9AN7NsSW9L+pKknZIqJE1z982t9lko6Q13/7GZjZS00t2HdvW83IAOAIhUTk6o8iA7W2poSPQ0yERBb0AfJ6na3be5e72kpyRNabePS+rf/HWepPcPdlgAANqj8gDJLCeCfYok7Wi1vFPSae32uV3S82b2n5L6SDqnoycys6slXS1JRx11VHdnBQBkqLKy0AeQjKJ1A/o0SYvcfZCkCyQ9ZmafeW53X+juxe5eXFhYGKVDAwAAJE4kYWqXpMGtlgc1r2vtSklPS5K7vyapt6SCaAwIAACQzCIJUxWSRpjZMDPrKWmqpGXt9nlP0tmSZGbHKxSm6qI5KAAAQDIKG6bcvUFSqaRVkrZIetrdq8xsvpld1LzbdZKuMrONkp6UNNMT9XNqAAApg8oDpAN+Nh8AIGGoPECq4GfzAQCSEpUHSAdcmQIAAAiDK1MAAAAxQpgCAAAIgDAFAAAQAGEKABBV1B0g0xCmAABRVV4eqjsoL0/0JEB8EKYAAFFF3QEyDdUIAAAAYVCNAAAAECOEKQAAgAAIUwAAAAEQpgAAAAIgTAEAIkJ/FNAxwhQAICL0RwEdI0wBACJCfxTQMXqmAAAAwqBnCgAAIEYIUwAAAAEQpgAAAAIgTAFAhqPyAAiGMAUAGY7KAyAYwhQAZDgqD4BgqEYAAAAIg2oEAACAGCFMAQAABECYAgAACIAwBQBpiLoDIH4IUwCQhqg7AOKHMAUAaYi6AyB+qEYAAAAIg2oEAACAGCFMAQAABECYAgAACIAwBQAphMoDIPkQpgAghVB5ACQfwhQApBAqD4DkQzUCAABAGFQjAAAAxAhhCgAAIADCFAAAQACEKQBIAlQeAKkrojBlZueZ2VtmVm1mN3ew/T4z+1Pzx9tm9o/ojwoA6YvKAyB1hQ1TZpYtqUzS+ZJGSppmZiNb7+Pu/+3uJ7v7yZL+j6SlsRgWANIVlQdA6orkytQ4SdXuvs3d6yU9JWlKF/tPk/RkNIYDgExRViY1NIQ+A0gtkYSpIkk7Wi3vbF73GWY2RNIwSb/vZPvVZlZpZpV1dXXdnRUAACDpRPsG9KmSlrh7Y0cb3X2huxe7e3FhYWGUDw0AABB/kYSpXZIGt1oe1LyuI1PFS3wAACCDRBKmKiSNMLNhZtZTocC0rP1OZnacpHxJr0V3RABITdQdAJkhbJhy9wZJpZJWSdoi6Wl3rzKz+WZ2Uatdp0p6yhP1w/4AIMlQdwBkhpxIdnL3lZJWtls3t93y7dEbCwBSX0lJKEhRdwCkN0vUhaTi4mKvrKxMyLEBAAC6w8zWu3txR9v4cTIAAAABEKYAAAACIEwBAAAEQJgCgG6i8gBAa4QpAOgmKg8AtEaYAoBuKimRsrOpPAAQQjUCAABAGFQjAAAAxAhhCgAAIADCFAAAQACEKQBoRuUBgINBmAKAZlQeADgYhCkAaEblAYCDQTUCAABAGFQjAAAAxAhhCgAAIADCFAAAQACEKQBpjboDALFGmAKQ1qg7ABBrhCkAaY26AwCxRjUCAABAGFQjAAAAxAhhCgAAIADCFAAAQACEKQApicoDAMmCMAUgJVF5ACBZEKYApCQqDwAkC6oRAAAAwqAaAQAAIEYIUwAAAAEQpgAAAAIgTAFIKlQeAEg1hCkASYXKAwCphjAFIKlQeQAg1VCNAAAAEAbVCAAAADFCmAIAAAiAMAUAABAAYQpAzFF3ACCdEaYAxBx1BwDSWURhyszOM7O3zKzazG7uZJ//MLPNZlZlZr+M7pgAUhl1BwDSWdhqBDPLlvS2pC9J2impQtI0d9/cap8Rkp6WdJa7/93MBrh7bVfPSzUCAABIFUGrEcZJqnb3be5eL+kpSVPa7XOVpDJ3/7skhQtSAAAA6SKSMFUkaUer5Z3N61o7RtIxZvaqma01s/M6eiIzu9rMKs2ssq6u7uAmBgAASCLRugE9R9IISRMlTZP0sJkd2n4nd1/o7sXuXlxYWBilQwMAACROJGFql6TBrZYHNa9rbaekZe5+wN3fVegeqxHRGRFAsqLyAAAiC1MVkkaY2TAz6ylpqqRl7fb5tUJXpWRmBQq97LctinMCSEJUHgBABGHK3RsklUpaJWmLpKfdvcrM5pvZRc27rZK018w2S1ot6QZ33xuroQEkByoPACCCaoRYoRoBAACkiqDVCAAAAOgEYQoAACAAwhQAAEAAhCkAbVB3AADdQ5gC0AZ1BwDQPYQpAG1QdwAA3UM1AgAAQBhUIwAAAMQIYQoAACAAwhQAAEAAhCkgQ1B5AACxQZgCMgSVBwAQG4QpIENQeQAAsUE1AgAAQBhUIwAAAMQIYQoAACAAwhQAAEAAhCkgxVF5AACJRZgCUhyVBwCQWIQpIMVReQAAiUU1AgAAQBhUIwAAAMQIYQoAACAAwhQAAEAAhCkgCVF3AACpgzAFJCHqDgAgdRCmgCRE3QEApA6qEQAAAMKgGgEAACBGCFMAAAABEKYAAAACIEwBAAAEQJgC4oj+KABIP4QpII7ojwKA9EOYAuKI/igASD/0TAEAAIRBzxQAAECMEKYAAAACIEwBAAAEQJgCooDKAwDIXIQpIAqoPACAzEWYAqKAygMAyFwRhSkzO8/M3jKzajO7uYPtM82szsz+1PzxzeiPCiSvsjKpoSH0GQCQWXLC7WBm2ZLKJH1J0k5JFWa2zN03t9t1sbuXxmBGAACApBXJlalxkqrdfZu710t6StKU2I4FAACQGiIJU0WSdrRa3tm8rr1LzGyTmS0xs8EdPZGZXW1mlWZWWVdXdxDjAgAAJJdo3YD+W0lD3X20pBckPdrRTu6+0N2L3b24sLAwSocGYoO6AwBAJCIJU7sktb7SNKh5XQt33+vunzYv/lTS2OiMByQOdQcAgEhEEqYqJI0ws2Fm1lPSVEnLWu9gZke0WrxI0pbojQgkBnUHAIBIhH03n7s3mFmppFWSsiU94u5VZjZfUqW7L5P0X2Z2kaQGSX+TNDOGMwNxUVZG1QEAIDxz94QcuLi42CsrKxNybAAAgO4ws/XuXtzRNhrQAQAAAiBMAQAABECYQsah8gAAEE2EKWQcKg8AANFEmELGofIAABBNvJsPAAAgDN7NBwAAECOEKQAAgAAIUwAAAAEQppA2qDwAACQCYQppg8oDAEAiEKaQNqg8AAAkAtUIAAAAYVCNAAAAECOEKQAAgAAIUwAAAAEQppDUqDsAACQ7whSSGnUHAIBkR5hCUqPuAACQ7KhGAAAACINqBAAAgBghTAEAAARAmAIAAAiAMIWEoPIAAJAuCFNICCoPAADpgjCFhKDyAACQLqhGAAAACINqBAAAgBghTAEAAARAmAIAAAiAMIWoovIAAJBpCFOIKioPAACZhjCFqKLyAACQaahGAAAACINqBAAAgBghTAEAAARAmAIAAAiAMIWwqDsAAKBzhCmERd0BAACdI0whLOoOAADoHNUIAAAAYQSuRjCz88zsLTOrNrObu9jvEjNzM+vwYAAAAOkmbJgys2xJZZLOlzRS0jQzG9nBfv0kXSvp9WgPCQAAkKwiuTI1TlK1u29z93pJT0ma0sF+d0j6gaRPojgfAABAUoskTBVJ2tFqeWfzuhZmNkbSYHdf0dUTmdnVZlZpZpV1dXXdHhbRReUBAADBBX43n5llSfqhpOvC7evuC9292N2LCwsLgx4aAVF5AABAcJGEqV2SBrdaHtS87l/6SRolaY2ZbZd0uqRl3ISe/Kg8AAAguLDVCGaWI+ltSWcrFKIqJE1396pO9l8j6Xp377L3gGoEAACQKgJVI7h7g6RSSaskbZH0tLtXmdl8M7souqMCAACklpxIdnL3lZJWtls3t5N9JwYfCwAAIDXw42QAAAACIEylISoPAACIH8JUGqLyAACA+CFMpSEqDwAAiJ+w1QixQjUCAABIFYGqEQAAANA5wlI28D4AAAbeSURBVBQAAEAAhCkAAIAACFMpgroDAACSE2EqRVB3AABAciJMpQjqDgAASE5UIwAAAIRBNQIAAECMEKYAAAACIEwBAAAEQJhKMCoPAABIbYSpBKPyAACA1EaYSjAqDwAASG1UIwAAAIRBNQIAAECMEKYAAAACIEwBAAAEQJiKAeoOAADIHISpGKDuAACAzEGYigHqDgAAyBxUIwAAAIRBNQIAAECMEKYAAAACIEwBAAAEQJjqBioPAABAe4SpbqDyAAAAtEeY6gYqDwAAQHtUIwAAAIRBNQIAAECMEKYAAAACIEwBAAAEQJgSlQcAAODgEaZE5QEAADh4hClReQAAAA4e1QgAAABhUI0AAAAQIxGFKTM7z8zeMrNqM7u5g+3XmNn/M7M/mdkrZjYy+qMCAAAkn7BhysyyJZVJOl/SSEnTOghLv3T3E939ZEl3S/ph1CcFAABIQpFcmRonqdrdt7l7vaSnJE1pvYO7f9BqsY+kxNyIBQAAEGeRhKkiSTtaLe9sXteGmc02s3cUujL1X9EZ7+DRHQUAAOIhajegu3uZuw+XdJOk73S0j5ldbWaVZlZZV1cXrUN3iO4oAAAQD5GEqV2SBrdaHtS8rjNPSfpKRxvcfaG7F7t7cWFhYeRTHgS6owAAQDxEEqYqJI0ws2Fm1lPSVEnLWu9gZiNaLU6S9OfojXhwysqkhobQZwAAgFjJCbeDuzeYWamkVZKyJT3i7lVmNl9Spbsvk1RqZudIOiDp75JmxHJoAACAZBE2TEmSu6+UtLLdurmtvr42ynMBAACkBBrQAQAAAiBMAQAABECYAgAACIAwBQAAEABhCgAAIADCFAAAQACEKQAAgAAIUwAAAAEQpgAAAAIgTAEAAARAmAIAAAiAMAUAABCAuXtiDmxWJ+kvMT5MgaQ9MT4GDh7nJ3lxbpIb5ye5cX6SV5BzM8TdCzvakLAwFQ9mVunuxYmeAx3j/CQvzk1y4/wkN85P8orVueFlPgAAgAAIUwAAAAGke5hamOgB0CXOT/Li3CQ3zk9y4/wkr5icm7S+ZwoAACDW0v3KFAAAQEwRpgAAAAJIizBlZueZ2VtmVm1mN3ewvZeZLW7e/rqZDY3/lJkrgvPzLTPbbGabzOxFMxuSiDkzUbhz02q/S8zMzYy3e8dRJOfHzP6j+c9PlZn9Mt4zZqoI/l47ysxWm9kbzX+3XZCIOTORmT1iZrVm9mYn283MHmg+d5vMbEzQY6Z8mDKzbEllks6XNFLSNDMb2W63KyX93d2PlnSfpB/Ed8rMFeH5eUNSsbuPlrRE0t3xnTIzRXhuZGb9JF0r6fX4TpjZIjk/ZjZC0rcl/Q93P0HSnLgPmoEi/LPzHUlPu/spkqZKeii+U2a0RZLO62L7+ZJGNH9cLenHQQ+Y8mFK0jhJ1e6+zd3rJT0laUq7faZIerT56yWSzjYzi+OMmSzs+XH31e7+cfPiWkmD4jxjporkz44k3aHQf0A+iedwiOj8XCWpzN3/LknuXhvnGTNVJOfGJfVv/jpP0vtxnC+juftLkv7WxS5TJP3CQ9ZKOtTMjghyzHQIU0WSdrRa3tm8rsN93L1B0j5Jn4vLdIjk/LR2paT/G9OJ8C9hz03z5e/B7r4inoNBUmR/do6RdIyZvWpma82sq/+NI3oiOTe3S/q6me2UtFLSf8ZnNESgu/8uhZUTaBwgiszs65KKJU1I9CyQzCxL0g8lzUzwKOhcjkIvVUxU6IruS2Z2orv/I6FTQZKmSVrk7vea2XhJj5nZKHdvSvRgiL50uDK1S9LgVsuDmtd1uI+Z5Sh0yXVvXKZDJOdHZnaOpFslXeTun8ZptkwX7tz0kzRK0hoz2y7pdEnLuAk9biL5s7NT0jJ3P+Du70p6W6FwhdiK5NxcKelpSXL31yT1VuiH7CLxIvp3qTvSIUxVSBphZsPMrKdCN/ota7fPMkkzmr/+X5J+77SVxkvY82Nmp0gqVyhIcc9H/HR5btx9n7sXuPtQdx+q0P1sF7l7ZWLGzTiR/N32a4WuSsnMChR62W9bPIfMUJGcm/cknS1JZna8QmGqLq5TojPLJF3e/K6+0yXtc/eaIE+Y8i/zuXuDmZVKWiUpW9Ij7l5lZvMlVbr7Mkk/U+gSa7VCN6VNTdzEmSXC83OPpL6Snml+X8B77n5RwobOEBGeGyRIhOdnlaQvm9lmSY2SbnB3rrrHWITn5jpJD5vZfyt0M/pM/hMfH2b2pEL/yShovmftNkk9JMndf6LQPWwXSKqW9LGkbwQ+JucWAADg4KXDy3wAAAAJQ5gCAAAIgDAFAAAQAGEKAAAgAMIUAABAAIQpAACAAAhTAAAAAfx/uFwlEAnW8vAAAAAASUVORK5CYII=\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "plot_predictions();"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "udWIFnCBrTIw"
      },
      "source": [
        "2 Build Model\n",
        "\n",
        "our first PyTorch model!\n",
        "\n",
        "This is very exciting ...let's do it!\n",
        "\n",
        "\n",
        "What our Model does:\n",
        "\n",
        "\n",
        "*   Start with random values (Weight & bias)\n",
        "*   Look at training data and adjust the random values to better represent (or get closer to) the ideal values (the weight & bias values we used to create the data) \n",
        "\n",
        "How does it do so?\n",
        "\n",
        "Through two main algorithms:\n",
        "\n",
        "\n",
        "1.   Gradient desent\n",
        "2.   Backpropagation\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "zM7rgV0qqi4_"
      },
      "outputs": [],
      "source": [
        "from torch import nn\n",
        "\n",
        "class LinearRegressionModel(nn.Module):   #<- almost everything in Pytorch inherhits from nn.Module\n",
        "  def __init__(self):    #constructor\n",
        "    super().__init__()\n",
        "    self.weights = nn.Parameter(torch.randn(1,\n",
        "                                           requires_grad=True,\n",
        "                                           dtype=torch.float))\n",
        "    self.bias = nn.Parameter(torch.randn(1,\n",
        "                                           requires_grad=True,\n",
        "                                           dtype=torch.float))\n",
        "                                           \n",
        "  #forward method to define the computition in the model\n",
        "  def forward (self, x: torch.Tensor) -> torch.Tensor:\n",
        "    return self.weights * x + self.bias \n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tpq5Q0rl2lu7",
        "outputId": "e1cfbbf2-e92b-4e5f-afd2-6855ca4a31d2"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0.3367])"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ],
      "source": [
        "torch.manual_seed(42)\n",
        "torch.randn(1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ZVw0XUn0ikI"
      },
      "source": [
        "### Checking the contents of our PyTorch model\n",
        "\n",
        "Now we've created a model, let's see what's inside.\n",
        "\n",
        "So we can chek out model parameters or what's inside our model using .`Parameters().`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eaegdbyf8yj6",
        "outputId": "43bd5188-4ca7-470e-a17a-6044f842904f"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[Parameter containing:\n",
              " tensor([0.3367], requires_grad=True), Parameter containing:\n",
              " tensor([0.1288], requires_grad=True)]"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ],
      "source": [
        "# Create a random seed\n",
        "torch.manual_seed(42)\n",
        "\n",
        "# Create an instance of the model (this is a subclass of nn.Module)\n",
        "model_0 = LinearRegressionModel()\n",
        "\n",
        "# Check out the parameters\n",
        "list(model_0.parameters())\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yy94ekXw3bqw",
        "outputId": "920dec82-5f7a-4e1c-ebbf-e31476db8fd5"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ],
      "source": [
        "# List named parameter\n",
        "model_0.state_dict()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kBCLBsex42EK"
      },
      "source": [
        "### Making prediction using `torch.inference_mode()`\n",
        "\n",
        "To check our model's predictive power, let's see how well it predicts `y_test` based on `X_test`.\n",
        "\n",
        "When we pass data through our model, it's going to run it through the forward() method."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v9fE1Bmm4khB",
        "outputId": "4d062284-e514-4b22-fb20-6cd361f28e47"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.3982],\n",
              "        [0.4049],\n",
              "        [0.4116],\n",
              "        [0.4184],\n",
              "        [0.4251],\n",
              "        [0.4318],\n",
              "        [0.4386],\n",
              "        [0.4453],\n",
              "        [0.4520],\n",
              "        [0.4588]])"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ],
      "source": [
        "# Make predictions with model\n",
        "\n",
        "# y_preds = model_0(x_test)  # You can use this direct also\n",
        "\n",
        "with torch.inference_mode():\n",
        "  y_preds = model_0(x_test)\n",
        "\n",
        "# You can also do something similar with torch.no_grad(), however, inference_mode() is preferred\n",
        "\n",
        "# with torch.no_grad():\n",
        "#   y_preds = model_0(x_test)\n",
        "y_preds"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 428
        },
        "id": "IeglY8kQ_dFQ",
        "outputId": "d54bfb0f-bc54-42ff-90f5-0047560c168b"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "plot_predictions(predictions=y_preds)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N7xtbrCGCU9e"
      },
      "source": [
        "## 3 . Train model\n",
        "\n",
        "The whole idea of training is for a model to move from some unknown parameters (these may be random) to some *known* parameters.\n",
        "\n",
        "Or in other words from a poor representation the data to a better representation of the data\n",
        "\n",
        "one way to measure how poor or how wronge your models presictions are is to use a loss function.\n",
        "\n",
        "* Note: Loss function may also be called cost function or criterion in different areas. For our case, we're going to refer to it as a loss function.\n",
        "\n",
        "* **Loss function:** A function to measure how wrong your model's predictions are to the ideal outputs, lower is better\n",
        "\n",
        "* **Optimizer:** Takes into account the loss of a model and adjust the model's parameters (e.g. weight & bias in our case) to improve the loss function.\n",
        "\n",
        " * Inside the optimizer you'll often habe to set two parameters:\n",
        "\n",
        "   * `params` - the model parameter you'd like to optimize, for example params=model_O.parameters()\n",
        "\n",
        "    * `lr (Learning rate)` - the learning rate is a hyperparamter theat defines how big/samll the optimizer changes the parameters eith each step (a small `lr` results in small changes, a large `lr` results in large changes)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "And specifically for PyTorch, we need:\n",
        "\n",
        "* A training loop\n",
        "* a testing loop\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "list(model_0.parameters())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o9Xc-55SQOXu",
        "outputId": "db160de3-7986-41e0-c6b6-2f7d67e4762d"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[Parameter containing:\n",
              " tensor([0.3367], requires_grad=True), Parameter containing:\n",
              " tensor([0.1288], requires_grad=True)]"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check out our model's parameters (a parameter is a value that the model sets itself)\n",
        "model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eJIXfKoASoRO",
        "outputId": "cc07add6-000b-4fca-cf79-9c6dfbb14168"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup a loss function\n",
        "loss_fn = nn.L1Loss()  # MAE (Mean Absolute Error)\n",
        "\n",
        "# Setup an optimizer (Stochastic gradient descent)\n",
        "optimizer = torch.optim.SGD(params = model_0.parameters(),\n",
        "                            lr=0.01) #lr = learning rate = possibly the most important hyperparameter you can set"
      ],
      "metadata": {
        "id": "5tbpKJRlTSWK"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Q:** Which loss function and optimizer should i use?\n",
        "\n",
        "**A:** This will be problem specific . But with experience, you'll get an idea of what works and what doesn't with your particular problem set.\n",
        "\n",
        "for example, for a regression problem (like ours), a loss function of `nn.L1Loss()` and an optimizer like `torch.optim.SGD()` will suffice \n",
        "\n",
        "But for a classification problem like classifying whether a photo is of a dog or a cat, you'll likely want to use a loss function of `nn.BCELoss()` (Binary cross entropy loss)"
      ],
      "metadata": {
        "id": "1mqZUGeDazH8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Building a training loop (and a testing loop) in Pytorch\n",
        "\n",
        "A couple of things we need in a training loop:\n",
        "\n",
        "0: Loop through the data\n",
        "\n",
        "1: Forward pass(this involves data moving through our model's `forward()` function) to make predictions on data - also called forward propagation \n",
        "\n",
        "2: Calculatethe loss (compare forward pass predictions to ground truth labels)\n",
        "\n",
        "3: Optimizer zero grad\n",
        "\n",
        "4: Loss backward - move backward through the networking to calculate the gradients of each of the parameters of our model with respect to the loss (**backpropagation**)\n",
        "\n",
        "5: Optimizer step - use the optimizer to adjust our model's parameters to try and improve the loss (**gradient descent**)"
      ],
      "metadata": {
        "id": "BMxArJyOKOc3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "\n",
        "# An epoch is one loop through the data... (this is a hyperparameter because we've set it ourselves)\n",
        "epochs = 200  # already run this 200 plus time\n",
        "\n",
        "# Track different values\n",
        "epoch_count = []\n",
        "loss_values = []\n",
        "test_loss_values = []\n",
        "\n",
        "# 0. Loop through the data\n",
        "for epoch in range(epochs):\n",
        "  #set the model to training mode\n",
        "  model_0.train() # train mode in Pytorch sets all parameters that require gradients to require gradients\n",
        "\n",
        "  # 1. forward pass\n",
        "  y_pred = model_0(x_train)\n",
        "\n",
        "  # 2. Calculate the loss\n",
        "  loss = loss_fn(y_pred, y_train)    # using for calculate Mean absolute error (MAE) \n",
        "  #print(f\"Loss : {loss}\")\n",
        "\n",
        "  # 3. Optimizer zero grad\n",
        "  optimizer.zero_grad()\n",
        "\n",
        "  # 4. Perform backpropagation on the loss with respect to the parameters of the mobel\n",
        "  loss.backward()\n",
        "\n",
        "  # 5. step the optimizer (perform gradient descent)\n",
        "  optimizer.step() #by default how to optimizer changes will acculumate through the loop so... We have to zero them above in step 3 for the next iteration of the loop\n",
        "\n",
        "  ### Testing \n",
        "  model_0.eval() #turns off different setting in the model not needed for evaluation/Testing (dropout/batch norm layers)\n",
        "\n",
        "  with torch.inference_mode():   #turn off gradient tracking & a couple more thing behind the scenes\n",
        "  # with torch.no_grad(): # you may also see torch.no_grad() in older PyTorch code\n",
        "\n",
        "    # 1. Do the forward pass\n",
        "    test_pred = model_0(x_test)\n",
        "\n",
        "    # 2. Calculate the loss\n",
        "    test_loss = loss_fn(test_pred, y_test)\n",
        "\n",
        "  # Print out what's happenin\n",
        "  if epoch % 10 == 0:\n",
        "    epoch_count.append(epoch)\n",
        "    loss_values.append(loss)\n",
        "    test_loss_values.append(test_loss)\n",
        "    print(f\"Epoch : {epoch } | Test : {loss} | Test loss : {test_loss}\")\n",
        "    # Print out model state_dict()\n",
        "    print(model_0.state_dict())"
      ],
      "metadata": {
        "id": "zDVvHPmMa3id",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c3ba25f0-753c-4638-80ec-2614c9bf13b6"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch : 0 | Test : 0.31288138031959534 | Test loss : 0.48106518387794495\n",
            "OrderedDict([('weights', tensor([0.3406])), ('bias', tensor([0.1388]))])\n",
            "Epoch : 10 | Test : 0.1976713240146637 | Test loss : 0.3463551998138428\n",
            "OrderedDict([('weights', tensor([0.3796])), ('bias', tensor([0.2388]))])\n",
            "Epoch : 20 | Test : 0.08908725529909134 | Test loss : 0.21729660034179688\n",
            "OrderedDict([('weights', tensor([0.4184])), ('bias', tensor([0.3333]))])\n",
            "Epoch : 30 | Test : 0.053148526698350906 | Test loss : 0.14464017748832703\n",
            "OrderedDict([('weights', tensor([0.4512])), ('bias', tensor([0.3768]))])\n",
            "Epoch : 40 | Test : 0.04543796554207802 | Test loss : 0.11360953003168106\n",
            "OrderedDict([('weights', tensor([0.4748])), ('bias', tensor([0.3868]))])\n",
            "Epoch : 50 | Test : 0.04167863354086876 | Test loss : 0.09919948130846024\n",
            "OrderedDict([('weights', tensor([0.4938])), ('bias', tensor([0.3843]))])\n",
            "Epoch : 60 | Test : 0.03818932920694351 | Test loss : 0.08886633068323135\n",
            "OrderedDict([('weights', tensor([0.5116])), ('bias', tensor([0.3788]))])\n",
            "Epoch : 70 | Test : 0.03476089984178543 | Test loss : 0.0805937647819519\n",
            "OrderedDict([('weights', tensor([0.5288])), ('bias', tensor([0.3718]))])\n",
            "Epoch : 80 | Test : 0.03132382780313492 | Test loss : 0.07232122868299484\n",
            "OrderedDict([('weights', tensor([0.5459])), ('bias', tensor([0.3648]))])\n",
            "Epoch : 90 | Test : 0.02788739837706089 | Test loss : 0.06473556160926819\n",
            "OrderedDict([('weights', tensor([0.5629])), ('bias', tensor([0.3573]))])\n",
            "Epoch : 100 | Test : 0.024458957836031914 | Test loss : 0.05646304413676262\n",
            "OrderedDict([('weights', tensor([0.5800])), ('bias', tensor([0.3503]))])\n",
            "Epoch : 110 | Test : 0.021020207554101944 | Test loss : 0.04819049686193466\n",
            "OrderedDict([('weights', tensor([0.5972])), ('bias', tensor([0.3433]))])\n",
            "Epoch : 120 | Test : 0.01758546568453312 | Test loss : 0.04060482233762741\n",
            "OrderedDict([('weights', tensor([0.6141])), ('bias', tensor([0.3358]))])\n",
            "Epoch : 130 | Test : 0.014155393466353416 | Test loss : 0.03233227878808975\n",
            "OrderedDict([('weights', tensor([0.6313])), ('bias', tensor([0.3288]))])\n",
            "Epoch : 140 | Test : 0.010716589167714119 | Test loss : 0.024059748277068138\n",
            "OrderedDict([('weights', tensor([0.6485])), ('bias', tensor([0.3218]))])\n",
            "Epoch : 150 | Test : 0.0072835334576666355 | Test loss : 0.016474086791276932\n",
            "OrderedDict([('weights', tensor([0.6654])), ('bias', tensor([0.3143]))])\n",
            "Epoch : 160 | Test : 0.0038517764769494534 | Test loss : 0.008201557211577892\n",
            "OrderedDict([('weights', tensor([0.6826])), ('bias', tensor([0.3073]))])\n",
            "Epoch : 170 | Test : 0.008932482451200485 | Test loss : 0.005023092031478882\n",
            "OrderedDict([('weights', tensor([0.6951])), ('bias', tensor([0.2993]))])\n",
            "Epoch : 180 | Test : 0.008932482451200485 | Test loss : 0.005023092031478882\n",
            "OrderedDict([('weights', tensor([0.6951])), ('bias', tensor([0.2993]))])\n",
            "Epoch : 190 | Test : 0.008932482451200485 | Test loss : 0.005023092031478882\n",
            "OrderedDict([('weights', tensor([0.6951])), ('bias', tensor([0.2993]))])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the loss curves\n",
        "import numpy as np\n",
        "plt.plot(epoch_count, np.array(torch.tensor(loss_values).numpy()), label=\"Train loss\")\n",
        "plt.plot(epoch_count, test_loss_values, label=\"Test loss\")\n",
        "plt.title(\"Training and test loss curves\")\n",
        "plt.ylabel(\"loss\")\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.legend();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "YNJ_rMjXiYVo",
        "outputId": "01d2407c-284d-42bb-a813-07c124456e0e"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "weight,bias"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yb1iLuK14SWg",
        "outputId": "fc627247-fd34-463d-c57e-2f185ceb5c93"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.7, 0.3)"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with torch.inference_mode():\n",
        "  y_preds_new = model_0(x_test)"
      ],
      "metadata": {
        "id": "e3tqfBC_8B-y"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions(predictions=y_preds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 428
        },
        "id": "6xskP2Af8PHx",
        "outputId": "294e47e2-7186-44e6-d7d5-02e427ace7c5"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions(predictions=y_preds_new)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 428
        },
        "id": "2tZ2QqjB8uDW",
        "outputId": "ad8712dd-9e50-457e-a3f8-836069d3f953"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Saving a model in Pytorch\n",
        "\n",
        "There are three main method you should and loading models in Pytorch.\n",
        "\n",
        "1. `torch.save() ` - allows you save a Pytorch object in Python's pickle\n",
        "\n",
        "2. `torch.load()` - allows you load a saved PyTorch object\n",
        "\n",
        "3. `torch.nn.Module.load_state_dict()` - this allows to load a model's saved state dictionary"
      ],
      "metadata": {
        "id": "9tQnoNqTnQlj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Saving our PyTorch model\n",
        "from pathlib import Path\n",
        "\n",
        "# 1. Create models directory\n",
        "MODEL_PATH = Path(\"models\")\n",
        "MODEL_PATH.mkdir(parents=True, exist_ok = True)\n",
        "\n",
        "# 2. Create model save path\n",
        "MODEL_NAME= \"01_pytorch_workflow_model_0.pth\"\n",
        "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n",
        "\n",
        "# 3. Save the model state dict\n",
        "print(f\"Saving model to: {MODEL_SAVE_PATH}\")\n",
        "torch.save(obj=model_0.state_dict(),\n",
        "           f=MODEL_SAVE_PATH)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4YzWLGKInU50",
        "outputId": "747571aa-c91f-420c-9b7e-1061b5ad55ae"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving model to: models/01_pytorch_workflow_model_0.pth\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Loading a PyTorch Model\n",
        "\n",
        "since we saved our model's `state_dict()` rather the entire model.we'll create a new instance of our model class and load the saved `state_dict()` into that."
      ],
      "metadata": {
        "id": "s15Y7JNfx3HX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# To load in a saved state_dict we have to instantiate a new instance of our model class \n",
        "loaded_model_0 = LinearRegressionModel()\n",
        "\n",
        "# Load the saved state_dict of model_0 (this will update the new instance with update parametersa)\n",
        "loaded_model_0.load_state_dict(torch.load(f=MODEL_SAVE_PATH))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qGIQ06tuyQaB",
        "outputId": "4aef7204-567b-47fc-d138-36cd63ebde01"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loaded_model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tH_aCeKTzP-R",
        "outputId": "e7877608-e227-46d6-94a7-91653b952c39"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make some predictions with our loaded model\n",
        "loaded_model_0.eval()\n",
        "with torch.inference_mode():\n",
        "  loaded_model_preds = loaded_model_0(x_test)\n",
        "\n",
        "loaded_model_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IkgtOJs51ISu",
        "outputId": "6d1df7f3-c9c9-4fba-e983-966f3abcfa9c"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.8685],\n",
              "        [0.8825],\n",
              "        [0.8965],\n",
              "        [0.9105],\n",
              "        [0.9245],\n",
              "        [0.9384],\n",
              "        [0.9524],\n",
              "        [0.9664],\n",
              "        [0.9804],\n",
              "        [0.9944]])"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# compare loaded model preds with original model preds\n",
        "y_preds_new == loaded_model_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SF6YSeyD2Hfj",
        "outputId": "e5c0ae1a-733d-46b4-c2a3-1d28721da650"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True]])"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOv+UBPEbOyE8RuFWuVwRtD",
      "include_colab_link": true
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}