Time_Seiries_ML_Project (1).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Time Series Modelling\n",
        "\n",
        "Objective:\n",
        "\n",
        "To monitor the current status of environmental factors and predict how each factor may change over the next hour due to the influence of other factors.\n",
        "Due to limited data availability, we were able to model hourly temperature changes based on specific humidity levels during the seedling stage.\n",
        "\n",
        "Input:\n",
        "\n",
        "•\tSpecific Humidity Level: Captured from real-time sensor data for the current hour in the greenhouse.\n",
        "\n",
        "Process:\n",
        "\n",
        "•\tTime Series Modeling: Utilizing time series analysis to examine the relationship between specific humidity and temperature changes over time. The model is trained on historical data and uses current data to forecast short-term specific humidity variations based on observed temperatures.\n",
        "\n",
        "Output:\n",
        "\n",
        "•\tPredicted Temperature for the Next Hour: A forecasted temperature value for the greenhouse environment within the next hour,\n",
        "This output will allow the decision support system to make proactive adjustments to maintain optimal specific humidity for the seedlings (optimum humidity for the seedling stage is defined at stage 2).\n",
        "\n"
      ],
      "metadata": {
        "id": "DcdunEu3L2Wy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "from statsmodels.tsa.statespace.sarimax import SARIMAX\n",
        "from statsmodels.tsa.stattools import adfuller\n",
        "from sklearn.metrics import mean_absolute_error, mean_squared_error\n",
        "import numpy as np\n",
        "import itertools\n",
        "import io"
      ],
      "metadata": {
        "id": "M1-Vaox-dNzk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "uploaded = files.upload()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 73
        },
        "id": "kdS4zeXrL4pr",
        "outputId": "1d2f3da7-72f2-47a4-f854-bfc487b7a7e0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-1198bd68-9896-4ffd-a66f-7f879fff46ec\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-1198bd68-9896-4ffd-a66f-7f879fff46ec\">\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> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving timeseries.csv to timeseries.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "data= pd.read_csv(io.BytesIO(uploaded['timeseries.csv']))\n",
        "data.head()"
      ],
      "metadata": {
        "id": "EJ1yHdTgOi7x",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "outputId": "aa15e898-c6ca-463c-b64c-e3c8f03cd66c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "        Date         Time  Relative_Humidity   Temperature \n",
              "0  1/25/2024    00:00:00             6.247241     18.303880\n",
              "1  1/25/2024     2:00:00             9.704286     17.507490\n",
              "2  1/25/2024     4:00:00             8.391964     16.332457\n",
              "3  1/25/2024     6:00:00             7.591951     21.748969\n",
              "4  1/25/2024     8:00:00             4.936112     21.830393"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-509327f2-60af-4dd5-a4ae-3674f86659ac\" 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>Date</th>\n",
              "      <th>Time</th>\n",
              "      <th>Relative_Humidity</th>\n",
              "      <th>Temperature</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1/25/2024</td>\n",
              "      <td>00:00:00</td>\n",
              "      <td>6.247241</td>\n",
              "      <td>18.303880</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1/25/2024</td>\n",
              "      <td>2:00:00</td>\n",
              "      <td>9.704286</td>\n",
              "      <td>17.507490</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1/25/2024</td>\n",
              "      <td>4:00:00</td>\n",
              "      <td>8.391964</td>\n",
              "      <td>16.332457</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>1/25/2024</td>\n",
              "      <td>6:00:00</td>\n",
              "      <td>7.591951</td>\n",
              "      <td>21.748969</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>1/25/2024</td>\n",
              "      <td>8:00:00</td>\n",
              "      <td>4.936112</td>\n",
              "      <td>21.830393</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-509327f2-60af-4dd5-a4ae-3674f86659ac')\"\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 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\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",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\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-509327f2-60af-4dd5-a4ae-3674f86659ac 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-509327f2-60af-4dd5-a4ae-3674f86659ac');\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",
              "\n",
              "\n",
              "<div id=\"df-2908486c-8181-40d7-9acf-a45d86fecfec\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-2908486c-8181-40d7-9acf-a45d86fecfec')\"\n",
              "            title=\"Suggest charts\"\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",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-2908486c-8181-40d7-9acf-a45d86fecfec button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "variable_name": "data",
              "summary": "{\n  \"name\": \"data\",\n  \"rows\": 325,\n  \"fields\": [\n    {\n      \"column\": \"Date\",\n      \"properties\": {\n        \"dtype\": \"object\",\n        \"num_unique_values\": 28,\n        \"samples\": [\n          \"2/3/2024\",\n          \"2/19/2024\",\n          \"2/2/2024\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Time\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 13,\n        \"samples\": [\n          \"  22:00:00 \",\n          \"  18:00:00 \",\n          \"  00:00:00 \"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Relative_Humidity \",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 1.7630008438903992,\n        \"min\": 4.030369503,\n        \"max\": 9.940323101,\n        \"num_unique_values\": 325,\n        \"samples\": [\n          5.171457927,\n          5.738508717,\n          9.781719863\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Temperature \",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 3.250001442493095,\n        \"min\": 15.22009816,\n        \"max\": 29.03362029,\n        \"num_unique_values\": 325,\n        \"samples\": [\n          26.43922114,\n          18.32093342,\n          23.83686478\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Combine Date and Time into a single datetime column and set as index\n",
        "data['Date'] = data['Date'].str.strip()\n",
        "data['Time'] = data['Time'].str.replace(r'\\s+', '', regex=True)\n",
        "data['Datetime'] = pd.to_datetime(data['Date'] + ' ' + data['Time'], errors='coerce')\n",
        "data.set_index('Datetime', inplace=True)\n",
        "data = data.drop(['Date', 'Time'], axis=1)\n",
        "\n",
        "# Add Time of Day encoding as sine and cosine # cyclical encoding\n",
        "data['Hour'] = data.index.hour\n",
        "data['Hour_sin'] = np.sin(2 * np.pi * data['Hour'] / 24)\n",
        "data['Hour_cos'] = np.cos(2 * np.pi * data['Hour'] / 24)"
      ],
      "metadata": {
        "collapsed": true,
        "id": "ysDYcKGh-VGV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(data.columns)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vaUwJkja85WY",
        "outputId": "4ea09c52-3cbb-47e3-aff7-cc70a87cc435"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Index(['Relative_Humidity ', 'Temperature ', 'Hour', 'Hour_sin', 'Hour_cos'], dtype='object')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Train-test split\n",
        "train_size = int(len(data) * 0.8)\n",
        "train, test = data[:train_size], data[train_size:]\n",
        "\n",
        "# Exogenous variables including Temperature, Hour_sin, and Hour_cos\n",
        "exog_train = train[['Temperature ', 'Hour_sin', 'Hour_cos']]\n",
        "exog_test = test[['Temperature ', 'Hour_sin', 'Hour_cos']]"
      ],
      "metadata": {
        "id": "-8VydVYdAAX_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        " #Define SARIMAX parameters and perform grid search\n",
        "p = d = q = range(0, 2)\n",
        "seasonal_order = (0, 0, 0, 24)\n",
        "param_combinations = list(itertools.product(p, d, q))\n",
        "best_mae, best_rmse = float(\"inf\"), float(\"inf\")\n",
        "best_order = None\n",
        "\n",
        "for order in param_combinations:\n",
        "    try:\n",
        "        model = SARIMAX(\n",
        "            train['Relative_Humidity'],\n",
        "            exog=exog_train,\n",
        "            order=order,\n",
        "            seasonal_order=seasonal_order,\n",
        "            enforce_stationarity=False,\n",
        "            enforce_invertibility=False\n",
        "        )\n",
        "        model_fit = model.fit(disp=False)\n",
        "\n",
        "        predictions = model_fit.predict(start=test.index[0], end=test.index[-1], exog=exog_test)\n",
        "        mae = mean_absolute_error(test['Relative_Humidity'], predictions)\n",
        "        rmse = np.sqrt(mean_squared_error(test['Relative_Humidity'], predictions))\n",
        "\n",
        "        if mae < best_mae:\n",
        "            best_mae, best_rmse = mae, rmse\n",
        "            best_order = order\n",
        "\n",
        "    except Exception:\n",
        "        continue\n"
      ],
      "metadata": {
        "id": "847YeV1RALwH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(data.columns)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pMBP9J9M_IB4",
        "outputId": "cf92a58a-cd0c-4d21-8304-34cf7bb74d69"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Index(['Relative_Humidity ', 'Temperature ', 'Hour', 'Hour_sin', 'Hour_cos'], dtype='object')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Fit final model with best parameters\n",
        "final_model = SARIMAX(\n",
        "    data['Relative_Humidity '],  # Replace with the actual column name if different\n",
        "    exog=data[['Temperature ', 'Hour_sin', 'Hour_cos']],\n",
        "    order=best_order,\n",
        "    seasonal_order=seasonal_order,\n",
        "    enforce_stationarity=False,\n",
        "    enforce_invertibility=False\n",
        ")\n",
        "final_model_fit = final_model.fit(disp=False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TjKcDbciAaoW",
        "outputId": "50e73895-97df-4417-a78e-4207ada8a9cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/statsmodels/tsa/base/tsa_model.py:473: ValueWarning: No frequency information was provided, so inferred frequency 2h will be used.\n",
            "  self._init_dates(dates, freq)\n",
            "/usr/local/lib/python3.10/dist-packages/statsmodels/tsa/base/tsa_model.py:473: ValueWarning: No frequency information was provided, so inferred frequency 2h will be used.\n",
            "  self._init_dates(dates, freq)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Forecast example for next 5 time steps with hypothetical future temperatures\n",
        "future_temperatures = pd.DataFrame({'Temperature (°C)': [20, 21, 19, 18, 20]})\n",
        "future_temperatures['Hour'] = [10, 12, 14, 16, 18]  # Hypothetical future times\n",
        "future_temperatures['Hour_sin'] = np.sin(2 * np.pi * future_temperatures['Hour'] / 24)\n",
        "future_temperatures['Hour_cos'] = np.cos(2 * np.pi * future_temperatures['Hour'] / 24)\n",
        "\n",
        "forecast = final_model_fit.get_forecast(steps=5, exog=future_temperatures[['Temperature (°C)', 'Hour_sin', 'Hour_cos']])\n",
        "forecast_summary = forecast.summary_frame(alpha=0.05)\n",
        "\n",
        "print(\"Forecasted Relative Humidity:\")\n",
        "print(forecast_summary[['mean', 'mean_ci_lower', 'mean_ci_upper']])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "45jVniZUAe7w",
        "outputId": "f24142bd-15da-4013-b27c-be71ba16cf37"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Forecasted Relative Humidity:\n",
            "Relative_Humidity        mean  mean_ci_lower  mean_ci_upper\n",
            "2024-02-21 02:00:00  5.799079       1.866337       9.731822\n",
            "2024-02-21 04:00:00  5.642068       1.709326       9.574811\n",
            "2024-02-21 06:00:00  4.797674       0.864931       8.730416\n",
            "2024-02-21 08:00:00  4.579283       0.646540       8.512025\n",
            "2024-02-21 10:00:00  5.588978       1.656236       9.521720\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate MAE, MSE, RMSE\n",
        "predicted_values = forecast_summary['mean'].values\n",
        "\n",
        "# Since we're forecasting, we usually don't have actual future values\n",
        "# For demonstration, let's assume some hypothetical actual values for the next 5 steps:\n",
        "actual_values = np.array([8, 8.5, 8.2, 8, 8.3])  # Replace with your actual values if available\n",
        "\n",
        "mae = mean_absolute_error(actual_values, predicted_values)\n",
        "mse = mean_squared_error(actual_values, predicted_values)\n",
        "rmse = np.sqrt(mse)\n",
        "\n",
        "print(\"\\nEvaluation Metrics:\")\n",
        "print(f\"MAE: {mae:.3f}\")\n",
        "print(f\"MSE: {mse:.3f}\")\n",
        "print(f\"RMSE: {rmse:.3f}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x0i1e8Ar_nNc",
        "outputId": "ce3d2197-9aa9-48bf-e1eb-e3138c524587"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Evaluation Metrics:\n",
            "MAE: 2.919\n",
            "MSE: 8.728\n",
            "RMSE: 2.954\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Function to predict specific humidity based on user input\n",
        "def predict_relative_humidity():\n",
        "    try:\n",
        "        # Collect user input\n",
        "        temperature = float(input(\"Enter Temperature (°C): \"))\n",
        "        time_of_day = int(input(\"Enter Time of Day (hour in 24-hour format): \"))\n",
        "\n",
        "        # Encode time as cyclic features\n",
        "        hour_sin = np.sin(2 * np.pi * time_of_day / 24)\n",
        "        hour_cos = np.cos(2 * np.pi * time_of_day / 24)\n",
        "\n",
        "        # Create a DataFrame with the input features\n",
        "        user_input = pd.DataFrame({\n",
        "            'Temperature (°C)': [temperature],\n",
        "            'Hour_sin': [hour_sin],\n",
        "            'Hour_cos': [hour_cos]\n",
        "        })\n",
        "\n",
        "        # Generate prediction\n",
        "        forecast = final_model_fit.get_forecast(steps=1, exog=user_input)\n",
        "        prediction = forecast.predicted_mean.iloc[0]\n",
        "        conf_int = forecast.conf_int()\n",
        "\n",
        "        # Access confidence interval values using column index instead of names\n",
        "        # This assumes 'lower Relative_Humidity %' and 'upper Relative_Humidity %'\n",
        "        # are the first two columns of the conf_int DataFrame.\n",
        "        # Adjust the column indices (0 and 1) if necessary based on the actual column order.\n",
        "\n",
        "        # Display the result\n",
        "        print(f\"\\nPredicted Relative Humidity: {prediction:.2f} %\")\n",
        "        print(f\"95% Confidence Interval: [{conf_int.iloc[0, 0]:.2f}, {conf_int.iloc[0, 1]:.2f}]\")\n",
        "\n",
        "    except ValueError:\n",
        "        print(\"Invalid input. Please enter numeric values for temperature and hour.\")\n",
        "\n",
        "# Run the prediction function\n",
        "predict_relative_humidity()"
      ],
      "metadata": {
        "id": "znrCPXBw_2tq",
        "outputId": "52e3f71b-3d00-405b-90ff-5016aceb51cc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter Temperature (°C): 27\n",
            "Enter Time of Day (hour in 24-hour format): 14\n",
            "\n",
            "Predicted Relative Humidity: 7.31 %\n",
            "95% Confidence Interval: [3.38, 11.24]\n"
          ]
        }
      ]
    }
  ]
}