asg_1_dl.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "w8XmlkNOjuKd"
      },
      "outputs": [],
      "source": [
        "#your code here\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import pandas as pd\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.model_selection import train_test_split"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 73
        },
        "id": "4kCBV5M3j13V",
        "outputId": "212567ce-b901-443b-c3bc-62664c03ce17"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-6988f67b-a16d-409d-bbc4-098978ddbe04\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-6988f67b-a16d-409d-bbc4-098978ddbe04\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Saving data - Sheet1.csv to data - Sheet1 (1).csv\n"
          ]
        }
      ],
      "source": [
        "#your code here\n",
        "from google.colab import files\n",
        "uploaded=files.upload()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 423
        },
        "id": "mRiaDx0Xj6OL",
        "outputId": "e67d4cee-2ca4-44f2-840e-ba535bfb7597"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "  <div id=\"df-a9716b74-0415-442f-9206-8b9c02332aa6\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>AT</th>\n",
              "      <th>V</th>\n",
              "      <th>AP</th>\n",
              "      <th>RH</th>\n",
              "      <th>PE</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>14.96</td>\n",
              "      <td>41.76</td>\n",
              "      <td>1024.07</td>\n",
              "      <td>73.17</td>\n",
              "      <td>463.26</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>25.18</td>\n",
              "      <td>62.96</td>\n",
              "      <td>1020.04</td>\n",
              "      <td>59.08</td>\n",
              "      <td>444.37</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>5.11</td>\n",
              "      <td>39.40</td>\n",
              "      <td>1012.16</td>\n",
              "      <td>92.14</td>\n",
              "      <td>488.56</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>20.86</td>\n",
              "      <td>57.32</td>\n",
              "      <td>1010.24</td>\n",
              "      <td>76.64</td>\n",
              "      <td>446.48</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>10.82</td>\n",
              "      <td>37.50</td>\n",
              "      <td>1009.23</td>\n",
              "      <td>96.62</td>\n",
              "      <td>473.90</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9563</th>\n",
              "      <td>16.65</td>\n",
              "      <td>49.69</td>\n",
              "      <td>1014.01</td>\n",
              "      <td>91.00</td>\n",
              "      <td>460.03</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9564</th>\n",
              "      <td>13.19</td>\n",
              "      <td>39.18</td>\n",
              "      <td>1023.67</td>\n",
              "      <td>66.78</td>\n",
              "      <td>469.62</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9565</th>\n",
              "      <td>31.32</td>\n",
              "      <td>74.33</td>\n",
              "      <td>1012.92</td>\n",
              "      <td>36.48</td>\n",
              "      <td>429.57</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9566</th>\n",
              "      <td>24.48</td>\n",
              "      <td>69.45</td>\n",
              "      <td>1013.86</td>\n",
              "      <td>62.39</td>\n",
              "      <td>435.74</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9567</th>\n",
              "      <td>21.60</td>\n",
              "      <td>62.52</td>\n",
              "      <td>1017.23</td>\n",
              "      <td>67.87</td>\n",
              "      <td>453.28</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>9568 rows × 5 columns</p>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-a9716b74-0415-442f-9206-8b9c02332aa6')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-a9716b74-0415-442f-9206-8b9c02332aa6 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-a9716b74-0415-442f-9206-8b9c02332aa6');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ],
            "text/plain": [
              "         AT      V       AP     RH      PE\n",
              "0     14.96  41.76  1024.07  73.17  463.26\n",
              "1     25.18  62.96  1020.04  59.08  444.37\n",
              "2      5.11  39.40  1012.16  92.14  488.56\n",
              "3     20.86  57.32  1010.24  76.64  446.48\n",
              "4     10.82  37.50  1009.23  96.62  473.90\n",
              "...     ...    ...      ...    ...     ...\n",
              "9563  16.65  49.69  1014.01  91.00  460.03\n",
              "9564  13.19  39.18  1023.67  66.78  469.62\n",
              "9565  31.32  74.33  1012.92  36.48  429.57\n",
              "9566  24.48  69.45  1013.86  62.39  435.74\n",
              "9567  21.60  62.52  1017.23  67.87  453.28\n",
              "\n",
              "[9568 rows x 5 columns]"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#your code here\n",
        "data=pd.read_csv('data - Sheet1.csv')\n",
        "data\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "dJ3Hk75gkLiV",
        "outputId": "6afb5d1c-5260-4b4b-ec38-9eccac35eb24"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f5fcf1ea790>"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(data)\n",
        "plt.legend([\"AT\",\"V\",\"AP\",\"RH\",\"PE\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "hAYC23Hokkzx"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "from torch import nn\n",
        "from torch.utils.data import DataLoader\n",
        "from torchvision import datasets\n",
        "from torchvision.transforms import ToTensor\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import tensorflow as tf\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import MinMaxScaler\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "6ikoP7C5rAAc"
      },
      "outputs": [],
      "source": [
        "train, test = train_test_split(data, test_size=0.2, random_state=42)\n",
        "train, val = train_test_split(train, test_size=0.25, random_state=42)\n",
        "scaler_x = StandardScaler()\n",
        "scaler_y = StandardScaler()\n",
        "train_x = scaler_x.fit_transform(train.iloc[:,:-1].values)\n",
        "train_y = scaler_y.fit_transform(train.iloc[:,-1].values.reshape(-1,1))\n",
        "val_x = scaler_x.transform(val.iloc[:,:-1].values)\n",
        "val_y = scaler_y.transform(val.iloc[:,-1].values.reshape(-1,1))\n",
        "test_x = scaler_x.transform(test.iloc[:,:-1].values)\n",
        "test_y = scaler_y.transform(test.iloc[:,-1].values.reshape(-1,1))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "YCvfQJXC6MPZ"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "hcLyi2V_xhSW"
      },
      "outputs": [],
      "source": [
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.fc1 = nn.Linear(4, 16)\n",
        "        self.fc2 = nn.Linear(16, 32)\n",
        "        self.fc3 = nn.Linear(32, 1)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = torch.relu(self.fc1(x))\n",
        "        x = torch.relu(self.fc2(x))\n",
        "        x = self.fc3(x)\n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "LCnnIdXaD9Kj"
      },
      "outputs": [],
      "source": [
        "net = Net()\n",
        "\n",
        "# define the loss function and the optimizer\n",
        "criterion = nn.MSELoss()\n",
        "optimizer = torch.optim.Adam(net.parameters(), lr=0.01)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HkZ8bmsbD-h1",
        "outputId": "ab536942-3c4d-4a9b-f3eb-099ee708f7df"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch: 0, Loss: 0.04733758419752121, Validation Loss: 0.055631764233112335\n",
            "Epoch: 200, Loss: 0.0477137491106987, Validation Loss: 0.056083060801029205\n",
            "Epoch: 400, Loss: 0.04703415930271149, Validation Loss: 0.05552566796541214\n",
            "Epoch: 600, Loss: 0.04664517194032669, Validation Loss: 0.05538364127278328\n",
            "Epoch: 800, Loss: 0.04659849777817726, Validation Loss: 0.05576063692569733\n",
            "Epoch: 1000, Loss: 0.04626961052417755, Validation Loss: 0.05525946244597435\n",
            "Epoch: 1200, Loss: 0.04631252586841583, Validation Loss: 0.05574225261807442\n",
            "Epoch: 1400, Loss: 0.0462372712790966, Validation Loss: 0.055828895419836044\n",
            "Epoch: 1600, Loss: 0.04589521139860153, Validation Loss: 0.055525459349155426\n",
            "Epoch: 1800, Loss: 0.04586445912718773, Validation Loss: 0.05545135214924812\n"
          ]
        }
      ],
      "source": [
        "for epoch in range(2000):\n",
        "    optimizer.zero_grad()\n",
        "    outputs = net(torch.Tensor(train_x))\n",
        "    loss = criterion(outputs, torch.Tensor(train_y))\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    if epoch % 200 == 0:\n",
        "        val_outputs = net(torch.Tensor(val_x))\n",
        "        val_loss = criterion(val_outputs, torch.Tensor(val_y))\n",
        "        print(\"Epoch: {}, Loss: {}, Validation Loss: {}\".format(epoch, loss.item(), val_loss.item()))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_OgPAftLEIJ0",
        "outputId": "eb07769c-8b06-451d-a407-f891b09f0019"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tensor([[ 0.2341],\n",
            "        [-1.0957],\n",
            "        [-1.1996],\n",
            "        ...,\n",
            "        [ 1.6284],\n",
            "        [-1.1463],\n",
            "        [ 0.1991]], grad_fn=<AddmmBackward0>)\n"
          ]
        }
      ],
      "source": [
        "test_outputs = net(torch.Tensor(test_x))\n",
        "print(test_outputs)\n",
        "     "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5cxG2yhsELyZ",
        "outputId": "4ff60d9f-00cf-451c-910a-2ab07daf6fce"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Loss: 0.04912165552377701\n"
          ]
        }
      ],
      "source": [
        "test_loss = criterion(test_outputs, torch.Tensor(test_y))\n",
        "print(\"Test Loss: {}\".format(test_loss.item()))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "pFXah1uDEO2T"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LEn_oqJSEcVL"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}