LSTM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8c7fd0d0-3bc5-4dac-b001-e66d5640ad8a",
   "metadata": {},
   "source": [
    "# LSTM for the prediction of energy consumption data over 48 hours\n",
    "### 1 - LSTM with Energy consumption data and weather data\n",
    "### 2 - LSTM with Energy consumption data and 2 variables 'Lastgang_Moving_Average' and 'Lastgang_First_Difference'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "902e770c-0416-4dca-b678-29739f652ae0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Install all required packages with 'conda install NAME' or with pip install NAME'\n",
    "# pandas\n",
    "# numpy\n",
    "# matplotlib\n",
    "# scikit-learn\n",
    "# torch\n",
    "# gputil\n",
    "# psutil\n",
    "# torchsummary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "abe044e7-e328-433e-8c33-adf3b8442863",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import all required libraries\n",
    "import sys  # Provides access to some variables used or maintained by the interpreter\n",
    "import pandas as pd # Library for data manipulation and analysis, ideal for working with structured data like tables\n",
    "import numpy as np # For scientific computing, supports large, multi-dimensional arrays and matrices\n",
    "import matplotlib.pyplot as plt # For creating static, interactive, and animated visualizations\n",
    "import matplotlib.dates as mdates # Provides classes for manipulating dates in plots\n",
    "from pathlib import Path  # Used for filesystem path manipulation in an object-oriented way\n",
    "import torch # Scientific computing library for ML and neural networks\n",
    "import torch.nn as nn # Module in PyTorch providing various layers and parameters for neural networks, facilitates building and training\n",
    "from sklearn.metrics import mean_squared_error, mean_absolute_error # For calculating key regression metrics\n",
    "from sklearn.preprocessing import MinMaxScaler # For scaling and normalizing features, often useful in data preprocessing\n",
    "import os # Provides a way of using operating system dependent functionality\n",
    "import GPUtil # For monitoring GPU utilization\n",
    "from datetime import datetime # For handling dates and times\n",
    "import psutil # For accessing system details and process utilities\n",
    "from torchsummary import summary  # Import summary from torchsummary to display a summary of model layers and parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "cabbab8f-0d40-44ab-975e-0f18ea6056db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/sarah/anaconda3/envs/BT2024PyTorch/bin/python\n"
     ]
    }
   ],
   "source": [
    "#To display the current environment\n",
    "print(sys.executable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "944e31d4-e885-4fa7-ab6c-e2a2a3bc14e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First and last rows from dfClimaAll:\n",
      "   dy  Globalstrahlung_15Min  Sonnenhöhe  ExtraterrestrischeStrahlung  \\\n",
      "0   1                      0       -65.0                            0   \n",
      "1   1                      0       -65.0                            0   \n",
      "2   1                      0       -65.4                            0   \n",
      "3   1                      0       -65.5                            0   \n",
      "4   1                      0       -65.2                            0   \n",
      "\n",
      "   StundenwertStrahlung  Diffusstrahlung  StrahlungGeneigteFläche  \\\n",
      "0                     0                0                        0   \n",
      "1                     0                0                        0   \n",
      "2                     0                0                        0   \n",
      "3                     0                0                        0   \n",
      "4                     0                0                        0   \n",
      "\n",
      "   DiffusstrahlungGeneigteFläche  Direktnormalstrahlung  Lufttemperatur  \\\n",
      "0                              0                      0             2.5   \n",
      "1                              0                      0             2.5   \n",
      "2                              0                      0             2.5   \n",
      "3                              0                      0             2.5   \n",
      "4                              0                      0             2.4   \n",
      "\n",
      "   Windgeschwindigkeit  Schönwetterstrahlung  Taupunkttemperatur  TheorPVProd  \\\n",
      "0                  1.2                     0                 0.8            0   \n",
      "1                  1.2                     0                 0.8            0   \n",
      "2                  1.2                     0                 0.8            0   \n",
      "3                  1.1                     0                 0.8            0   \n",
      "4                  1.1                     0                 0.8            0   \n",
      "\n",
      "     TimestampWeather  \n",
      "0 2021-01-01 00:00:00  \n",
      "1 2021-01-01 00:15:00  \n",
      "2 2021-01-01 00:30:00  \n",
      "3 2021-01-01 00:45:00  \n",
      "4 2021-01-01 01:00:00  \n",
      "        dy  Globalstrahlung_15Min  Sonnenhöhe  ExtraterrestrischeStrahlung  \\\n",
      "35035  365                      0       -56.5                            0   \n",
      "35036  365                      0       -58.5                            0   \n",
      "35037  365                      0       -60.3                            0   \n",
      "35038  365                      0       -61.9                            0   \n",
      "35039  365                      0       -63.3                            0   \n",
      "\n",
      "       StundenwertStrahlung  Diffusstrahlung  StrahlungGeneigteFläche  \\\n",
      "35035                     0                0                        0   \n",
      "35036                     0                0                        0   \n",
      "35037                     0                0                        0   \n",
      "35038                     0                0                        0   \n",
      "35039                     0                0                        0   \n",
      "\n",
      "       DiffusstrahlungGeneigteFläche  Direktnormalstrahlung  Lufttemperatur  \\\n",
      "35035                              0                      0             5.5   \n",
      "35036                              0                      0             5.5   \n",
      "35037                              0                      0             5.5   \n",
      "35038                              0                      0             5.5   \n",
      "35039                              0                      0             4.9   \n",
      "\n",
      "       Windgeschwindigkeit  Schönwetterstrahlung  Taupunkttemperatur  \\\n",
      "35035                  2.4                     0               -18.2   \n",
      "35036                  2.4                     0               -18.2   \n",
      "35037                  2.4                     0               -18.2   \n",
      "35038                  2.4                     0               -18.2   \n",
      "35039                  1.8                     0               -14.0   \n",
      "\n",
      "       TheorPVProd    TimestampWeather  \n",
      "35035            0 2023-12-31 22:45:00  \n",
      "35036            0 2023-12-31 23:00:00  \n",
      "35037            0 2023-12-31 23:15:00  \n",
      "35038            0 2023-12-31 23:30:00  \n",
      "35039            0 2023-12-31 23:45:00  \n",
      "Number of missing values per column:\n",
      "dy                               0\n",
      "Globalstrahlung_15Min            0\n",
      "Sonnenhöhe                       0\n",
      "ExtraterrestrischeStrahlung      0\n",
      "StundenwertStrahlung             0\n",
      "Diffusstrahlung                  0\n",
      "StrahlungGeneigteFläche          0\n",
      "DiffusstrahlungGeneigteFläche    0\n",
      "Direktnormalstrahlung            0\n",
      "Lufttemperatur                   0\n",
      "Windgeschwindigkeit              0\n",
      "Schönwetterstrahlung             0\n",
      "Taupunkttemperatur               0\n",
      "TheorPVProd                      0\n",
      "TimestampWeather                 0\n",
      "dtype: int64\n",
      "Number of rows in dfClimaAll: 105120\n"
     ]
    }
   ],
   "source": [
    "# Step 1 - Reading Data\n",
    "\n",
    "## dfClimaAll: Data from 2021-2023\n",
    "## dfEnergyAll: All data from the transformer station from 2021-2023\n",
    "\n",
    "# Load data for 2021\n",
    "dfClima21 = pd.read_excel('/home/sarah/Documents/BT2024/Weather_Data/2021TimeWeather.xlsx')\n",
    "\n",
    "# Load data for 2022\n",
    "dfClima22 = pd.read_excel('/home/sarah/Documents/BT2024/Weather_Data/2022TimeWeather.xlsx')\n",
    "\n",
    "# Load data for 2023\n",
    "dfClima23 = pd.read_excel('/home/sarah/Documents/BT2024/Weather_Data/2023TimeWeather.xlsx')\n",
    "\n",
    "# Merge the DataFrames\n",
    "dfClimaAll = pd.concat([dfClima21, dfClima22, dfClima23])\n",
    "\n",
    "# Check the resulting DataFrame\n",
    "print(\"First and last rows from dfClimaAll:\")\n",
    "print(dfClimaAll.head())\n",
    "print(dfClimaAll.tail())\n",
    "\n",
    "# Check for missing values in each column\n",
    "## .isnull(): Returns DF where values with NaN are replaced by True & values without NaN are replaced by False\n",
    "## sum(): Sums up the number of True values\n",
    "print(\"Number of missing values per column:\")\n",
    "print(dfClimaAll.isnull().sum())\n",
    "\n",
    "# Convert 'Timestamp' into a Datetime object and set it as index, if not already set\n",
    "if 'TimestampWeather' in dfClimaAll.columns:\n",
    "    ## pd.to_datetime: Converts values into Datetime objects —> Pandas can then treat these as timestamps\n",
    "    dfClimaAll['TimestampWeather'] = pd.to_datetime(dfClimaAll['TimestampWeather'])\n",
    "    ## set_index: Sets index for the Timestamp column to facilitate access to data based on time points\n",
    "    dfClimaAll = dfClimaAll.set_index('TimestampWeather')\n",
    "\n",
    "# Number of rows in dfClimaAll\n",
    "print(\"Number of rows in dfClimaAll:\", dfClimaAll.shape[0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "dd18e843-0297-4813-a58b-4a448f63c446",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First and last rows from dfEnergyAll:\n",
      "                     Lastgang\n",
      "Timestamp                    \n",
      "2021-01-01 00:00:00    472.88\n",
      "2021-01-01 00:15:00    498.83\n",
      "2021-01-01 00:30:00    480.48\n",
      "2021-01-01 00:45:00    446.74\n",
      "2021-01-01 01:00:00    459.55\n",
      "                     Lastgang\n",
      "Timestamp                    \n",
      "2023-12-31 22:45:00    833.17\n",
      "2023-12-31 23:00:00    767.89\n",
      "2023-12-31 23:15:00    770.04\n",
      "2023-12-31 23:30:00    730.45\n",
      "2023-12-31 23:45:00    744.21\n",
      "Number of rows in dfEnergyAll: 105108\n"
     ]
    }
   ],
   "source": [
    "# Step 1 - Reading Data\n",
    "\n",
    "## dfClimaAll: Data from 2021-2023\n",
    "## dfEnergyAll: All data from the transformer station from 2021-2023\n",
    "\n",
    "# Path to the directory containing the Excel files\n",
    "directory_path = Path('/home/sarah/Documents/BT2024/All')\n",
    "\n",
    "# Create a list of all Excel files in the directory\n",
    "file_paths = list(directory_path.glob('*.xlsx'))\n",
    "\n",
    "# List to store the individual DataFrames\n",
    "dfs = []\n",
    "\n",
    "# Loop over all file paths\n",
    "for file_path in file_paths:\n",
    "    # Read the Excel file\n",
    "    df = pd.read_excel(file_path)\n",
    "    \n",
    "    # Convert the 'Timestamp' column to a datetime\n",
    "    df['Timestamp'] = pd.to_datetime(df['Timestamp'])\n",
    "    \n",
    "    # Convert the 'Lastgang' column to a numeric type, treat errors as NaN\n",
    "    df['Lastgang'] = pd.to_numeric(df['Lastgang'], errors='coerce')\n",
    "    \n",
    "    # Sort the DataFrame by 'Timestamp'\n",
    "    df = df.sort_values(by='Timestamp')\n",
    "    \n",
    "    # Perform linear interpolation for 'Lastgang' on the individual DataFrame\n",
    "    df['Lastgang'] = df['Lastgang'].interpolate(method='linear')\n",
    "    \n",
    "    # Add the DataFrame to the list\n",
    "    dfs.append(df)\n",
    "\n",
    "# Merge all DataFrames in the list\n",
    "dfEnergyAll = pd.concat(dfs).set_index('Timestamp')\n",
    "\n",
    "# Sum the 'Lastgang' values for identical timestamps\n",
    "dfEnergyAll = dfEnergyAll.groupby('Timestamp').sum()\n",
    "\n",
    "# Check the resulting DataFrame\n",
    "print(\"First and last rows from dfEnergyAll:\")\n",
    "print(dfEnergyAll.head())\n",
    "print(dfEnergyAll.tail())\n",
    "\n",
    "# Display the number of rows in dfEnergyAll\n",
    "print(\"Number of rows in dfEnergyAll:\", dfEnergyAll.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f57c59a7-8588-400b-a65e-7798892b3bff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Missing timestamps in dfEnergyAll:\n",
      "DatetimeIndex(['2021-03-28 02:00:00', '2021-03-28 02:15:00',\n",
      "               '2021-03-28 02:30:00', '2021-03-28 02:45:00',\n",
      "               '2022-03-27 02:00:00', '2022-03-27 02:15:00',\n",
      "               '2022-03-27 02:30:00', '2022-03-27 02:45:00',\n",
      "               '2023-03-26 02:00:00', '2023-03-26 02:15:00',\n",
      "               '2023-03-26 02:30:00', '2023-03-26 02:45:00'],\n",
      "              dtype='datetime64[ns]', name='Timestamp', freq=None)\n",
      "Check after adding the missing timestamps:\n",
      "                     Lastgang\n",
      "2021-03-28 02:00:00    372.28\n",
      "2021-03-28 02:15:00    372.28\n",
      "2021-03-28 02:30:00    372.28\n",
      "2021-03-28 02:45:00    372.28\n",
      "2022-03-27 02:00:00    554.20\n",
      "2022-03-27 02:15:00    554.20\n",
      "2022-03-27 02:30:00    554.20\n",
      "2022-03-27 02:45:00    554.20\n",
      "2023-03-26 02:00:00    520.34\n",
      "2023-03-26 02:15:00    520.34\n",
      "2023-03-26 02:30:00    520.34\n",
      "2023-03-26 02:45:00    520.34\n",
      "Number of rows in dfClima21: 105120\n",
      "Number of rows in dfEnergyAll: 105120\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1514655/1871761932.py:32: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n",
      "  dfEnergyAll = dfEnergyAll.sort_index().fillna(method='ffill')\n"
     ]
    }
   ],
   "source": [
    "# Step 2 - Preparing the Data\n",
    "\n",
    "# Create a complete timestamp index for the years 2021 - 2023 in 15-minute intervals\n",
    "all_timestamps = pd.date_range(start='2021-01-01 00:00:00', end='2023-12-31 23:45:00', freq='15T')\n",
    "\n",
    "# Convert this into a DataFrame\n",
    "df_all_timestamps = pd.DataFrame(all_timestamps, columns=['Timestamp'])\n",
    "df_all_timestamps = df_all_timestamps.set_index('Timestamp')\n",
    "\n",
    "# Compare the complete timestamp index with dfEnergyAll\n",
    "missing_timestamps = df_all_timestamps.index.difference(dfEnergyAll.index)\n",
    "\n",
    "print(\"Missing timestamps in dfEnergyAll:\")\n",
    "print(missing_timestamps)\n",
    "\n",
    "\n",
    "# Missing timestamps\n",
    "missing_timestamps = pd.DatetimeIndex(['2021-03-28 02:00:00', '2021-03-28 02:15:00',\n",
    "                                       '2021-03-28 02:30:00', '2021-03-28 02:45:00',\n",
    "                                       '2022-03-27 02:00:00', '2022-03-27 02:15:00',\n",
    "                                       '2022-03-27 02:30:00', '2022-03-27 02:45:00',\n",
    "                                       '2023-03-26 02:00:00', '2023-03-26 02:15:00',\n",
    "                                       '2023-03-26 02:30:00', '2023-03-26 02:45:00'])\n",
    "\n",
    "# Create a DataFrame with the missing timestamps\n",
    "df_missing = pd.DataFrame(index=missing_timestamps)\n",
    "\n",
    "# Merge this DataFrame with the original DataFrame\n",
    "dfEnergyAll = dfEnergyAll.combine_first(df_missing)\n",
    "\n",
    "# Fill the missing values. Use 'ffill' for forward fill.\n",
    "dfEnergyAll = dfEnergyAll.sort_index().fillna(method='ffill')\n",
    "\n",
    "print(\"Check after adding the missing timestamps:\")\n",
    "print(dfEnergyAll.loc[missing_timestamps])\n",
    "\n",
    "# Number of rows in dfClima21\n",
    "# Ensure dfClima21 is already defined before executing this line.\n",
    "print(\"Number of rows in dfClima21:\", dfClimaAll.shape[0])\n",
    "\n",
    "# Number of rows in dfEnergyAll\n",
    "print(\"Number of rows in dfEnergyAll:\", dfEnergyAll.shape[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e091294-f898-4ab8-8f36-16a937be15fb",
   "metadata": {},
   "source": [
    "## 1 - LSTM with Energy consumption data and weather data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "5939df7d-254c-4aba-a087-fccc490a0ee5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of missing values per column:\n",
      "Lastgang                   0\n",
      "StundenwertStrahlung       0\n",
      "Globalstrahlung_15Min      0\n",
      "StrahlungGeneigteFläche    0\n",
      "TheorPVProd                0\n",
      "Direktnormalstrahlung      0\n",
      "Schönwetterstrahlung       0\n",
      "Lufttemperatur             0\n",
      "dtype: int64\n",
      "First and last rows from dfEnergyAll-Edited:\n",
      "                     Lastgang  StundenwertStrahlung  Globalstrahlung_15Min  \\\n",
      "2021-01-01 00:00:00    472.88                     0                      0   \n",
      "2021-01-01 00:15:00    498.83                     0                      0   \n",
      "2021-01-01 00:30:00    480.48                     0                      0   \n",
      "2021-01-01 00:45:00    446.74                     0                      0   \n",
      "2021-01-01 01:00:00    459.55                     0                      0   \n",
      "\n",
      "                     StrahlungGeneigteFläche  TheorPVProd  \\\n",
      "2021-01-01 00:00:00                        0            0   \n",
      "2021-01-01 00:15:00                        0            0   \n",
      "2021-01-01 00:30:00                        0            0   \n",
      "2021-01-01 00:45:00                        0            0   \n",
      "2021-01-01 01:00:00                        0            0   \n",
      "\n",
      "                     Direktnormalstrahlung  Schönwetterstrahlung  \\\n",
      "2021-01-01 00:00:00                      0                     0   \n",
      "2021-01-01 00:15:00                      0                     0   \n",
      "2021-01-01 00:30:00                      0                     0   \n",
      "2021-01-01 00:45:00                      0                     0   \n",
      "2021-01-01 01:00:00                      0                     0   \n",
      "\n",
      "                     Lufttemperatur  \n",
      "2021-01-01 00:00:00             2.5  \n",
      "2021-01-01 00:15:00             2.5  \n",
      "2021-01-01 00:30:00             2.5  \n",
      "2021-01-01 00:45:00             2.5  \n",
      "2021-01-01 01:00:00             2.4  \n",
      "                     Lastgang  StundenwertStrahlung  Globalstrahlung_15Min  \\\n",
      "2023-12-31 22:45:00    833.17                     0                      0   \n",
      "2023-12-31 23:00:00    767.89                     0                      0   \n",
      "2023-12-31 23:15:00    770.04                     0                      0   \n",
      "2023-12-31 23:30:00    730.45                     0                      0   \n",
      "2023-12-31 23:45:00    744.21                     0                      0   \n",
      "\n",
      "                     StrahlungGeneigteFläche  TheorPVProd  \\\n",
      "2023-12-31 22:45:00                        0            0   \n",
      "2023-12-31 23:00:00                        0            0   \n",
      "2023-12-31 23:15:00                        0            0   \n",
      "2023-12-31 23:30:00                        0            0   \n",
      "2023-12-31 23:45:00                        0            0   \n",
      "\n",
      "                     Direktnormalstrahlung  Schönwetterstrahlung  \\\n",
      "2023-12-31 22:45:00                      0                     0   \n",
      "2023-12-31 23:00:00                      0                     0   \n",
      "2023-12-31 23:15:00                      0                     0   \n",
      "2023-12-31 23:30:00                      0                     0   \n",
      "2023-12-31 23:45:00                      0                     0   \n",
      "\n",
      "                     Lufttemperatur  \n",
      "2023-12-31 22:45:00             5.5  \n",
      "2023-12-31 23:00:00             5.5  \n",
      "2023-12-31 23:15:00             5.5  \n",
      "2023-12-31 23:30:00             5.5  \n",
      "2023-12-31 23:45:00             4.9  \n"
     ]
    }
   ],
   "source": [
    "# Step 2 - Preparing the Data\n",
    "\n",
    "# To check if the indexes in both DataFrames are set equally\n",
    "dfClimaAll.index.equals(dfEnergyAll.index)\n",
    "\n",
    "# Adding the columns from dfClima21 to dfEnergyAll\n",
    "dfEnergyAll = dfEnergyAll.join(dfClimaAll[['StundenwertStrahlung', 'Globalstrahlung_15Min', 'StrahlungGeneigteFläche', 'TheorPVProd', 'Direktnormalstrahlung', 'Schönwetterstrahlung', 'Lufttemperatur']])\n",
    "\n",
    "# Checking for missing values in each column\n",
    "print(\"Number of missing values per column:\")\n",
    "print(dfEnergyAll.isnull().sum())\n",
    "\n",
    "# Printing the first and last rows from the dataframe\n",
    "print(\"First and last rows from dfEnergyAll-Edited:\")\n",
    "print(dfEnergyAll.head())\n",
    "print(dfEnergyAll.tail())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "3249555e-d606-4e67-88db-b1719c475f5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                     Lastgang  StundenwertStrahlung  Globalstrahlung_15Min  \\\n",
      "2021-01-01 00:00:00    472.88                     0                      0   \n",
      "2021-01-01 00:15:00    498.83                     0                      0   \n",
      "2021-01-01 00:30:00    480.48                     0                      0   \n",
      "2021-01-01 00:45:00    446.74                     0                      0   \n",
      "2021-01-01 01:00:00    459.55                     0                      0   \n",
      "\n",
      "                     StrahlungGeneigteFläche  TheorPVProd  \\\n",
      "2021-01-01 00:00:00                        0            0   \n",
      "2021-01-01 00:15:00                        0            0   \n",
      "2021-01-01 00:30:00                        0            0   \n",
      "2021-01-01 00:45:00                        0            0   \n",
      "2021-01-01 01:00:00                        0            0   \n",
      "\n",
      "                     Direktnormalstrahlung  Schönwetterstrahlung  \\\n",
      "2021-01-01 00:00:00                      0                     0   \n",
      "2021-01-01 00:15:00                      0                     0   \n",
      "2021-01-01 00:30:00                      0                     0   \n",
      "2021-01-01 00:45:00                      0                     0   \n",
      "2021-01-01 01:00:00                      0                     0   \n",
      "\n",
      "                     Lufttemperatur  Lastgang_Moving_Average  \\\n",
      "2021-01-01 00:00:00             2.5               549.123854   \n",
      "2021-01-01 00:15:00             2.5               549.123854   \n",
      "2021-01-01 00:30:00             2.5               549.123854   \n",
      "2021-01-01 00:45:00             2.5               549.123854   \n",
      "2021-01-01 01:00:00             2.4               549.123854   \n",
      "\n",
      "                     Lastgang_First_Difference  \n",
      "2021-01-01 00:00:00                      25.95  \n",
      "2021-01-01 00:15:00                      25.95  \n",
      "2021-01-01 00:30:00                     -18.35  \n",
      "2021-01-01 00:45:00                     -33.74  \n",
      "2021-01-01 01:00:00                      12.81  \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1514655/1800522370.py:11: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n",
      "  dfEnergyAll = dfEnergyAll.fillna(method='bfill')\n"
     ]
    }
   ],
   "source": [
    "# Step 2 - Preparing the Data\n",
    "\n",
    "# Calculating the moving average for 'Lastgang'\n",
    "window_size = 96  # This corresponds to 24 hours at 15-minute intervals\n",
    "dfEnergyAll['Lastgang_Moving_Average'] = dfEnergyAll['Lastgang'].rolling(window=window_size).mean()\n",
    "\n",
    "# Calculating the first differences for 'Lastgang'\n",
    "dfEnergyAll['Lastgang_First_Difference'] = dfEnergyAll['Lastgang'].diff()\n",
    "\n",
    "# Since the first `window_size - 1` values of the moving average will be NaN and the first value of the first difference will be NaN, fill these values.\n",
    "dfEnergyAll = dfEnergyAll.fillna(method='bfill')\n",
    "\n",
    "# To check the first few rows to ensure the new features look as expected.\n",
    "print(dfEnergyAll.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "c513ae39-9901-490c-939b-c2061b85d5d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 3 - Data Scaling\n",
    "\n",
    "# Initialize the scalers\n",
    "lastgang_scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "features_scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "# Apply the scaler to the corresponding columns\n",
    "dfEnergyAll['Lastgang'] = lastgang_scaler.fit_transform(dfEnergyAll['Lastgang'].values.reshape(-1, 1))\n",
    "dfEnergyAll[['StundenwertStrahlung', 'Lufttemperatur', 'Globalstrahlung_15Min', 'StrahlungGeneigteFläche', 'Lastgang_Moving_Average', 'Lastgang_First_Difference']] = features_scaler.fit_transform(dfEnergyAll[['StundenwertStrahlung', 'Lufttemperatur', 'Globalstrahlung_15Min', 'StrahlungGeneigteFläche', 'Lastgang_Moving_Average', 'Lastgang_First_Difference']])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "c9b3b67e-2833-4759-9987-8dc3eed4fd52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            Lastgang  StundenwertStrahlung  Globalstrahlung_15Min  \\\n",
      "count  105120.000000         105120.000000          105120.000000   \n",
      "mean        0.425947              0.561652               0.125328   \n",
      "std         0.149590              0.111328               0.197261   \n",
      "min         0.000000              0.000000               0.000000   \n",
      "25%         0.312299              0.490186               0.000000   \n",
      "50%         0.397657              0.492149               0.000861   \n",
      "75%         0.527101              0.593719               0.182444   \n",
      "max         1.000000              1.000000               1.000000   \n",
      "\n",
      "       StrahlungGeneigteFläche    TheorPVProd  Direktnormalstrahlung  \\\n",
      "count            105120.000000  105120.000000          105120.000000   \n",
      "mean                  0.125328     116.568056             144.916924   \n",
      "std                   0.197261     177.407501             266.941484   \n",
      "min                   0.000000       0.000000               0.000000   \n",
      "25%                   0.000000       0.000000               0.000000   \n",
      "50%                   0.000861       1.000000               0.000000   \n",
      "75%                   0.182444     179.000000             132.000000   \n",
      "max                   1.000000     799.000000            1010.000000   \n",
      "\n",
      "       Schönwetterstrahlung  Lufttemperatur  Lastgang_Moving_Average  \\\n",
      "count         105120.000000   105120.000000            105120.000000   \n",
      "mean             220.075295        0.487743                 0.468536   \n",
      "std              296.754964        0.169107                 0.234477   \n",
      "min                0.000000        0.000000                 0.000000   \n",
      "25%                0.000000        0.359408                 0.282593   \n",
      "50%                6.000000        0.482030                 0.433883   \n",
      "75%              403.000000        0.606765                 0.641900   \n",
      "max             1020.000000        1.000000                 1.000000   \n",
      "\n",
      "       Lastgang_First_Difference  \n",
      "count              105120.000000  \n",
      "mean                    0.504792  \n",
      "std                     0.046065  \n",
      "min                     0.000000  \n",
      "25%                     0.476896  \n",
      "50%                     0.504275  \n",
      "75%                     0.532252  \n",
      "max                     1.000000  \n",
      "Skalierparameter für Lastgang: [0.00068067] [-0.03440131]\n"
     ]
    }
   ],
   "source": [
    "# Step 3 - Check the scaled values\n",
    "\n",
    "print(dfEnergyAll.describe())\n",
    "\n",
    "print(\"Skalierparameter für Lastgang:\", lastgang_scaler.scale_, lastgang_scaler.min_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "90e7229f-5224-4bf1-8aa6-7883794b6f2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU before model training: 2024-05-03 17:00:39\n",
      "GPU: NVIDIA A100 80GB PCIe, GPU RAM Free: 17694.0MB, Used: 63345.0MB, Utilization: 92.0%\n",
      "GPU: NVIDIA A100 80GB PCIe, GPU RAM Free: 236.0MB, Used: 80803.0MB, Utilization: 28.000000000000004%\n",
      "CPU before model training:\n",
      "CPU Utilization: 89.2%\n",
      "RAM before model training:\n",
      "Total memory: 146.88 GB\n",
      "Available memory: 115.63 GB\n",
      "Used memory: 29.34 GB\n",
      "Memory usage: 21.3%\n"
     ]
    }
   ],
   "source": [
    "# Step 3 - Show GPU Utilization and Memory Usage before Model Training\n",
    "\n",
    "def print_gpu_utilization():\n",
    "    # Retrieve and print GPU utilization and memory stats\n",
    "    GPUs = GPUtil.getGPUs()\n",
    "    for GPU in GPUs:\n",
    "        print(f\"GPU: {GPU.name}, GPU RAM Free: {GPU.memoryFree}MB, Used: {GPU.memoryUsed}MB, Utilization: {GPU.load*100}%\")\n",
    "\n",
    "print(\"GPU before model training:\", datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"))\n",
    "print_gpu_utilization()\n",
    "\n",
    "# Function to print CPU utilization\n",
    "def print_cpu_utilization():\n",
    "    # Retrieve and print the percentage of CPU utilization\n",
    "    print(f\"CPU Utilization: {psutil.cpu_percent(interval=1)}%\")\n",
    "\n",
    "print(\"CPU before model training:\")\n",
    "print_cpu_utilization()\n",
    "\n",
    "def print_memory_usage():\n",
    "    # Retrieve and print memory statistics\n",
    "    memory = psutil.virtual_memory()\n",
    "    print(f\"Total memory: {memory.total / (1024**3):.2f} GB\")\n",
    "    print(f\"Available memory: {memory.available / (1024**3):.2f} GB\")\n",
    "    print(f\"Used memory: {memory.used / (1024**3):.2f} GB\")\n",
    "    print(f\"Memory usage: {memory.percent}%\")\n",
    "\n",
    "print(\"RAM before model training:\")\n",
    "print_memory_usage()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "0d90e033-70b7-4d3d-b038-315db7f388a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "def create_sequences(data, seq_length):\n",
    "    # Create input/output sequences from the dataset for model training\n",
    "    xs = []\n",
    "    ys = []\n",
    "    for i in range(len(data) - seq_length):\n",
    "        x = data.iloc[i:(i + seq_length)].to_numpy() # Extract input sequence\n",
    "        y = data.iloc[i + seq_length, 0] # Extract the corresponding output\n",
    "        xs.append(x)\n",
    "        ys.append(y)\n",
    "    return np.array(xs), np.array(ys)\n",
    "\n",
    "seq_length = 192\n",
    "X, y = create_sequences(dfEnergyAll, seq_length)  # Generate sequences using the specified sequence length\n",
    "\n",
    "# Split the dataset into training and testing sets using the last 192 sequences for testing\n",
    "X_train, X_test = X[:-192], X[-192:]\n",
    "y_train, y_test = y[:-192], y[-192:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "e0e131ce-7193-42fb-94dc-f2bd0876aa2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train Shape: (104736, 192, 10)\n",
      "X_test Shape: (192, 192, 10)\n"
     ]
    }
   ],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "# Print the shapes of the training and testing datasets\n",
    "print(f\"X_train Shape: {X_train.shape}\")\n",
    "print(f\"X_test Shape: {X_test.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "69131796-20f7-4e93-a091-5fa9dfed0237",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "# Check Hardware Availability for the PyTorch code\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "e84d8190-9f4f-4e97-94e5-6587d3efa9a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "class LSTMModel(nn.Module):\n",
    "    def __init__(self, input_size, hidden_layer_size, output_size):\n",
    "        super(LSTMModel, self).__init__()\n",
    "        # Initialize the LSTM layer with the specified input size and hidden layer size\n",
    "        self.hidden_layer_size = hidden_layer_size\n",
    "        self.lstm = nn.LSTM(input_size, hidden_layer_size, batch_first=True)\n",
    "        # Initialize a linear layer to map the output of the LSTM to the desired output size\n",
    "        self.linear = nn.Linear(hidden_layer_size, output_size)\n",
    "\n",
    "    def forward(self, input_seq, hidden_state):\n",
    "        # Define the forward pass through the LSTM layer followed by a linear layer\n",
    "        lstm_out, hidden_state = self.lstm(input_seq, hidden_state) # LSTM output and updated hidden state\n",
    "        predictions = self.linear(lstm_out[:, -1, :]) # Linear layer uses the last time step output\n",
    "        return predictions, hidden_state\n",
    "\n",
    "# Instantiate the LSTM model with specific dimensions for input size, hidden layer size, and output size\n",
    "model = LSTMModel(10, 100, 1).to(device) # Model is set to run on the specified device (here GPU)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "1dbd5f07-59df-4f57-a4e0-342da9da76d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "#Convert training data into PyTorch tensors\n",
    "# Convert training data to tensor and transfer it to the configured device (GPU or CPU)\n",
    "X_train_tensors = torch.Tensor(X_train).to(device)\n",
    "# Convert training labels to tensor, reshape to match the output format, and transfer to the device\n",
    "y_train_tensors = torch.Tensor(y_train).view(-1, 1).to(device)\n",
    "\n",
    "# Convert testing data to tensor and transfer it to the configured device\n",
    "X_test_tensors = torch.Tensor(X_test).to(device)\n",
    "# Convert testing labels to tensor, reshape to match the output format, and transfer to the device\n",
    "y_test_tensors = torch.Tensor(y_test).view(-1, 1).to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e9774e4-a3dc-4f6b-ba4d-6c22ea466750",
   "metadata": {},
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "# Input dimension for torchsummary\n",
    "# Call the summary function with the appropriate input size\n",
    "seq_length = 192  # length of sequence\n",
    "input_size = 10   # number of features\n",
    "model_summary(model, (seq_length, input_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5ba77573-4e7b-45d1-8a98-d0c25deed352",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/sarah/anaconda3/envs/BT2024PyTorch/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Neues bestes Modell bei Epoche 1 mit Testverlust 0.002240444806375308 gespeichert.\n",
      "Epoch 1, Train Loss: 0.0035617551574962775, Test Loss: 0.002240444806375308\n",
      "Epoch 2, Train Loss: 0.0028713790915957543, Test Loss: 0.003409684640246269\n",
      "Epoch 3, Train Loss: 0.002853152419040494, Test Loss: 0.0028365009657136397\n",
      "Epoch 4, Train Loss: 0.0026575870853470054, Test Loss: 0.002615272085677134\n",
      "Epoch 5, Train Loss: 0.0024344039566272678, Test Loss: 0.002584929561635363\n",
      "Epoch 6, Train Loss: 0.0022661723844511054, Test Loss: 0.0029679268427571515\n",
      "Early Stopping nach 6 Epochen!\n"
     ]
    }
   ],
   "source": [
    "# Step 5 - Model Training\n",
    "\n",
    "# Define the number of epochs and batch size\n",
    "loss_function = nn.MSELoss() # Define the loss function to measure the model performance\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # Define the optimizer with a learning rate of 0.001\n",
    "epochs = 70 # Total number of epochs to train the model\n",
    "batch_size = 12 # Number of samples in each batch\n",
    "\n",
    "# For storing the loss values\n",
    "train_losses = []  # List to store loss values for each epoch during training\n",
    "test_losses = []  # List to store loss values for each epoch during validation\n",
    "\n",
    "# Initialize variables for Early Stopping\n",
    "best_test_loss = float('inf') # Set the best test loss to infinity\n",
    "best_model_path = 'best_model.pth' # Path to save the best model\n",
    "early_stopping_patience = 5  # Number of epochs to wait without improvement before stopping the training\n",
    "epochs_without_improvement = 0  # Counter to track the number of epochs without improvement\n",
    "\n",
    "for epoch in range(epochs): # Loop over the number of epochs\n",
    "    model.train() # Set the model to training mode\n",
    "    train_loss = 0.0 # Initialize the train loss for the epoch\n",
    "    for i in range(0, len(X_train_tensors), batch_size): # Iterate over the training data in batches\n",
    "        X_batch = X_train_tensors[i:i + batch_size] # Get the current batch of input data\n",
    "        y_batch = y_train_tensors[i:i + batch_size] # Get the current batch of target data\n",
    "\n",
    "        # Dynamic batch size adjustment for the last batch of the epoch\n",
    "        actual_batch_size = X_batch.size(0)\n",
    "\n",
    "        # Initialize the hidden and cell states based on the actual batch size\n",
    "        hidden = (torch.zeros(1, actual_batch_size, model.hidden_layer_size).to(device),\n",
    "                  torch.zeros(1, actual_batch_size, model.hidden_layer_size).to(device))\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # Perform a forward pass through the model and store the new hidden state\n",
    "        y_pred, hidden = model(X_batch, hidden)\n",
    "\n",
    "        # Detach hidden state to prevent history from being saved\n",
    "        hidden = tuple([h.detach() for h in hidden])\n",
    "\n",
    "        loss = loss_function(y_pred, y_batch) # Calculate the loss\n",
    "        loss.backward() #Perform backpropagation\n",
    "        optimizer.step() # Update the weights\n",
    "        \n",
    "        train_loss += loss.item() * actual_batch_size # Accumulate the loss for the batch\n",
    "\n",
    "    # Calculate the average training loss for the epoch\n",
    "    train_loss /= len(X_train_tensors)\n",
    "    train_losses.append(train_loss)\n",
    "\n",
    "    # Validation\n",
    "    model.eval()  # Set the model to evaluation mode\n",
    "    test_loss = 0.0 \n",
    "    with torch.no_grad():  # Do not calculate gradients\n",
    "        for i in range(0, len(X_test_tensors), batch_size):\n",
    "            X_batch = X_test_tensors[i:i + batch_size]\n",
    "            y_batch = y_test_tensors[i:i + batch_size]\n",
    "\n",
    "            # Repeat the dynamic batch size adjustment for validation\n",
    "            actual_batch_size = X_batch.size(0)\n",
    "            hidden = (torch.zeros(1, actual_batch_size, model.hidden_layer_size).to(device),\n",
    "                      torch.zeros(1, actual_batch_size, model.hidden_layer_size).to(device))\n",
    "\n",
    "            y_pred = model(X_batch, hidden)[0]  # Get predictions only, state is ignored\n",
    "            loss = loss_function(y_pred, y_batch)\n",
    "            test_loss += loss.item() * actual_batch_size\n",
    "            \n",
    "    # Calculate the average test loss for the epoch\n",
    "    test_loss /= len(X_test_tensors)\n",
    "    test_losses.append(test_loss)\n",
    "\n",
    "    if test_loss < best_test_loss:\n",
    "        best_test_loss = test_loss\n",
    "        torch.save(model.state_dict(), best_model_path) # Save the best model\n",
    "        epochs_without_improvement = 0  # Reset since improvement was found\n",
    "        print(f'Neues bestes Modell bei Epoche {epoch+1} mit Testverlust {test_loss} gespeichert.')\n",
    "    else:\n",
    "        epochs_without_improvement += 1  # Increment since no improvement\n",
    "\n",
    "    print(f'Epoch {epoch + 1}, Train Loss: {train_loss}, Test Loss: {test_loss}')\n",
    "\n",
    "    # Check if the early stopping criterion is met\n",
    "    if epochs_without_improvement >= early_stopping_patience:\n",
    "        print(f'Early Stopping nach {epoch+1} Epochen!')\n",
    "        break  # End the loop and thus the training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "2eb9a478-fe5e-4e77-9b67-4cd32b584b00",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Step 5 - Model Training\n",
    "\n",
    "#Printing the learning curve\n",
    "plt.plot(train_losses, label='Train Loss')\n",
    "plt.plot(test_losses, label='Test Loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Learning Curve')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a22fa477-6ab6-4e77-827e-8bb770345c44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Squared Error (MSE): 4835.649345629893\n",
      "Mean Absolute Error (MAE): 48.19281085729443\n",
      "Root Mean Square Error (RMSE): 69.53883336402684\n",
      "Mean Absolute Percentage Error (MAPE): 5.7064004220498035%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Step 6 - Rescaling, error metrics and visualization\n",
    "\n",
    "# Load the best model weights\n",
    "best_model_path = 'best_model.pth'\n",
    "model.load_state_dict(torch.load(best_model_path, map_location=device))\n",
    "\n",
    "# Evaluate the model\n",
    "model.eval()\n",
    "test_predictions = []\n",
    "with torch.no_grad():\n",
    "    for i in range(len(X_test_tensors)):\n",
    "        # Prepare each batch from the test data\n",
    "        X_batch = X_test_tensors[i].unsqueeze(0)  # Add batch dimension\n",
    "        # Predict using the model\n",
    "        y_pred, _ = model(X_batch, (torch.zeros(1, 1, model.hidden_layer_size).to(device), torch.zeros(1, 1, model.hidden_layer_size).to(device)))\n",
    "        test_predictions.append(y_pred.squeeze().item())  # Store the predicted values\n",
    "\n",
    "# Denormalizing the predictions and actual values to their original scale\n",
    "test_predictions_denorm = lastgang_scaler.inverse_transform(np.array(test_predictions).reshape(-1, 1))\n",
    "y_test_denorm = lastgang_scaler.inverse_transform(y_test.reshape(-1, 1))\n",
    "\n",
    "# Calculate error metrics\n",
    "mse = mean_squared_error(y_test_denorm, test_predictions_denorm)  # Mean Squared Error\n",
    "mae = mean_absolute_error(y_test_denorm, test_predictions_denorm)  # Mean Absolute Error\n",
    "rmse = np.sqrt(mse)  # Root Mean Square Error\n",
    "mape = np.mean(np.abs((y_test_denorm - test_predictions_denorm) / y_test_denorm)) * 100  # Mean Absolute Percentage Error\n",
    "\n",
    "print(f\"Mean Squared Error (MSE): {mse}\")\n",
    "print(f\"Mean Absolute Error (MAE): {mae}\")\n",
    "print(f\"Root Mean Square Error (RMSE): {rmse}\")\n",
    "print(f\"Mean Absolute Percentage Error (MAPE): {mape}%\")\n",
    "\n",
    "# Visualization of actual vs predicted values\n",
    "plt.figure(figsize=(12, 6))\n",
    "test_dates = pd.date_range(start=dfEnergyAll.index[-len(X_test):][0], periods=len(y_test), freq='15T')\n",
    "plt.plot(test_dates, y_test_denorm, label='Actual Values', color='#3E7A6F')\n",
    "plt.plot(test_dates, test_predictions_denorm, label='Predicted Values', color='#7DFFE7')\n",
    "plt.legend()\n",
    "plt.title('Comparison of Actual and Predicted Values: LSTM over 48 hours')\n",
    "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d %H:%M'))\n",
    "#plt.gca().xaxis.set_major_locator(mdates.DayLocator())\n",
    "plt.gca().xaxis.set_major_locator(mdates.HourLocator(interval=3))\n",
    "plt.gcf().autofmt_xdate()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "6fcfd2c6-43f4-4a26-afa0-8f412c7306b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU after model training: 2024-05-03 16:44:12\n",
      "GPU: NVIDIA A100 80GB PCIe, GPU RAM Free: 16696.0MB, Used: 64343.0MB, Utilization: 23.0%\n",
      "GPU: NVIDIA A100 80GB PCIe, GPU RAM Free: 2326.0MB, Used: 78713.0MB, Utilization: 100.0%\n",
      "CPU after model training:\n",
      "CPU Utilization: 15.0%\n",
      "RAM after model training:\n",
      "Total memory: 146.88 GB\n",
      "Available memory: 115.61 GB\n",
      "Used memory: 29.27 GB\n",
      "Memory usage: 21.3%\n"
     ]
    }
   ],
   "source": [
    "# Step 7 - Show GPU Utilization and Memory Usage after Model Training\n",
    "\n",
    "print(\"GPU after model training:\", datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")) # Print GPU utilization after model training\n",
    "print_gpu_utilization() # Call function to print GPU utilization\n",
    "\n",
    "print(\"CPU after model training:\") # Print CPU utilization after model training\n",
    "print_cpu_utilization() # Call function to print CPU utilization\n",
    "\n",
    "print(\"RAM after model training:\") # Print RAM usage after model training\n",
    "print_memory_usage() # Call function to print RAM usage"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c06792b-b9f6-4536-abc5-d6073e5b3600",
   "metadata": {},
   "source": [
    "## 2 - LSTM with Energy consumption data and 2 variables 'Lastgang_Moving_Average' and 'Lastgang_First_Difference'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c5a6ba2-9bea-4615-8ca2-d3a5bc354446",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 3 - Data Scaling\n",
    "\n",
    "# Initialize the scalers\n",
    "lastgang_scaler = MinMaxScaler(feature_range=(0, 1))  # Scaler for the target variable\n",
    "features_scaler = MinMaxScaler(feature_range=(0, 1))  # Scaler for the feature variables\n",
    "\n",
    "# Apply the scaler to the appropriate columns\n",
    "dfEnergyAll['Lastgang'] = lastgang_scaler.fit_transform(dfEnergyAll['Lastgang'].values.reshape(-1, 1))  # Scale the main target variable\n",
    "dfEnergyAll[['Lastgang_Moving_Average', 'Lastgang_First_Difference']] = features_scaler.fit_transform(dfEnergyAll[['Lastgang_Moving_Average', 'Lastgang_First_Difference']])  # Scale selected features\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47151f28-f353-4732-aa33-5c74bc1519ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "def create_sequences(data, seq_length):\n",
    "    # Initialize lists to hold the input sequences (xs) and the corresponding target values (ys)\n",
    "    xs = []\n",
    "    ys = []\n",
    "    for i in range(len(data) - seq_length):\n",
    "        # Create a sequence of length seq_length from the data starting at index i\n",
    "        x = data.iloc[i:(i + seq_length)].to_numpy()\n",
    "        # Get the target value corresponding to the end of the sequence\n",
    "        y = data.iloc[i + seq_length, 0]\n",
    "        # Append the sequence to the list of inputs\n",
    "        xs.append(x)\n",
    "        # Append the target value to the list of outputs\n",
    "        ys.append(y)\n",
    "    # Convert lists to numpy arrays for further processing in machine learning models\n",
    "    return np.array(xs), np.array(ys)\n",
    "\n",
    "# Define the length of sequences\n",
    "seq_length = 192\n",
    "# Generate sequences and corresponding target values from the dataset\n",
    "X, y = create_sequences(dfEnergyAll, seq_length)\n",
    "\n",
    "# Use the last 192 sequences for testing to maintain a comparable distribution as in the TBATS model\n",
    "X_train, X_test = X[:-192], X[-192:]  # Split the data into training and testing sets\n",
    "y_train, y_test = y[:-192], y[-192:]  # Split the target values into training and testing sets\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "776ce941-9729-4cb7-82a0-2beb2169ec9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "# Print the shapes of the training and testing datasets\n",
    "print(f\"X_train Shape: {X_train.shape}\")\n",
    "print(f\"X_test Shape: {X_test.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb141e4d-c842-4f37-a69d-f7a9485dd78e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "# Check Hardware Availability for the PyTorch code\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f97772d-d556-4063-9cd1-45520a86ab55",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "class LSTMModel(nn.Module):\n",
    "    def __init__(self, input_size, hidden_layer_size, output_size):\n",
    "        super(LSTMModel, self).__init__()\n",
    "        # Initialize the LSTM layer with specified input size and hidden layer size\n",
    "        self.hidden_layer_size = hidden_layer_size  # Store the hidden layer size\n",
    "        self.lstm = nn.LSTM(input_size, hidden_layer_size, batch_first=True)  # LSTM module\n",
    "        self.linear = nn.Linear(hidden_layer_size, output_size)  # Linear layer to map the LSTM outputs to the desired output size\n",
    "\n",
    "    def forward(self, input_seq, hidden_state):\n",
    "        # Define the forward pass of the LSTM model\n",
    "        lstm_out, hidden_state = self.lstm(input_seq, hidden_state)  # Execute the LSTM layer\n",
    "        predictions = self.linear(lstm_out[:, -1, :])  # Apply the linear layer to the last time step output of the LSTM\n",
    "        return predictions, hidden_state  # Return the final predictions and the hidden state\n",
    "\n",
    "# Initialize the LSTM model with specific dimensions\n",
    "model = LSTMModel(3, 100, 1).to(device)  # 3 features as input, 'device' specifies where to run the model (here GPU)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8ccc2c6-e58e-464a-9270-7e79f00732f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "#Convert training data into PyTorch tensors\n",
    "# Convert training data to tensor and transfer it to the configured device (GPU or CPU)\n",
    "X_train_tensors = torch.Tensor(X_train).to(device)\n",
    "# Convert training labels to tensor, reshape to match the output format, and transfer to the device\n",
    "y_train_tensors = torch.Tensor(y_train).view(-1, 1).to(device)\n",
    "\n",
    "# Convert testing data to tensor and transfer it to the configured device\n",
    "X_test_tensors = torch.Tensor(X_test).to(device)\n",
    "# Convert testing labels to tensor, reshape to match the output format, and transfer to the device\n",
    "y_test_tensors = torch.Tensor(y_test).view(-1, 1).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f3305bb-2ec2-419c-9685-d91e3c2c1d16",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 5 - Model Training\n",
    "\n",
    "# Define the number of epochs and the batch size\n",
    "loss_function = nn.MSELoss()  # Loss function to measure how well the model performs\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)  # Optimizer to update model weights\n",
    "epochs = 70  # Total number of training epochs\n",
    "batch_size = 12  # Number of samples per batch\n",
    "\n",
    "# For storing loss values\n",
    "train_losses = []  # List to store training loss per epoch\n",
    "test_losses = []  # List to store validation loss per epoch\n",
    "\n",
    "# Initialize variables for Early Stopping\n",
    "best_test_loss = float('inf')  # Best loss for the validation set seen so far\n",
    "best_model_path = 'best_model.pth'  # Path to save the best model\n",
    "early_stopping_patience = 5  # Number of epochs to continue without improvement before stopping\n",
    "epochs_without_improvement = 0  # Count of epochs since last improvement\n",
    "\n",
    "for epoch in range(epochs):  # Iterate over each epoch\n",
    "    model.train()  # Set the model to training mode\n",
    "    train_loss = 0.0  # Accumulator for the loss of the current epoch\n",
    "    for i in range(0, len(X_train_tensors), batch_size):  # Iterate over batches\n",
    "        X_batch = X_train_tensors[i:i + batch_size]  # Current batch of input data\n",
    "        y_batch = y_train_tensors[i:i + batch_size]  # Current batch of target data\n",
    "\n",
    "        # Dynamic adjustment of batch size for the last batch of the epoch\n",
    "        actual_batch_size = X_batch.size(0)\n",
    "\n",
    "        # Initialize hidden and cell states based on the actual batch size\n",
    "        hidden = (torch.zeros(1, actual_batch_size, model.hidden_layer_size).to(device),\n",
    "                  torch.zeros(1, actual_batch_size, model.hidden_layer_size).to(device))\n",
    "\n",
    "        optimizer.zero_grad()  # Reset gradients\n",
    "\n",
    "        # Store the new hidden state after forward pass\n",
    "        y_pred, hidden = model(X_batch, hidden)\n",
    "\n",
    "        # Detach hidden state to prevent saving history\n",
    "        hidden = tuple([h.detach() for h in hidden])\n",
    "\n",
    "        loss = loss_function(y_pred, y_batch)  # Compute loss\n",
    "        loss.backward()  # Backpropagation\n",
    "        optimizer.step()  # Update weights\n",
    "        \n",
    "        train_loss += loss.item() * actual_batch_size  # Aggregate loss for the epoch\n",
    "\n",
    "    # Calculate average training loss for the epoch\n",
    "    train_loss /= len(X_train_tensors)\n",
    "    train_losses.append(train_loss)\n",
    "\n",
    "    # Validation\n",
    "    model.eval()  # Set the model to evaluation mode\n",
    "    test_loss = 0.0\n",
    "    with torch.no_grad():  # No gradient calculations\n",
    "        for i in range(0, len(X_test_tensors), batch_size):\n",
    "            X_batch = X_test_tensors[i:i + batch_size]\n",
    "            y_batch = y_test_tensors[i:i + batch_size]\n",
    "\n",
    "            # Repeat dynamic batch size adjustment for validation\n",
    "            actual_batch_size = X_batch.size(0)\n",
    "            hidden = (torch.zeros(1, actual_batch_size, model.hidden_layer_size).to(device),\n",
    "                      torch.zeros(1, actual_batch_size, model.hidden_layer_size).to(device))\n",
    "\n",
    "            y_pred = model(X_batch, hidden)[0]  # Only predictions needed, state ignored\n",
    "            loss = loss_function(y_pred, y_batch)\n",
    "            test_loss += loss.item() * actual_batch_size\n",
    "            \n",
    "    # Calculate average test loss for the epoch\n",
    "    test_loss /= len(X_test_tensors)\n",
    "    test_losses.append(test_loss)\n",
    "\n",
    "    if test_loss < best_test_loss:\n",
    "        best_test_loss = test_loss  # Update the best test loss\n",
    "        torch.save(model.state_dict(), best_model_path)  # Save the best model\n",
    "        epochs_without_improvement = 0  # Reset since improvement was found\n",
    "        print(f'New best model saved at epoch {epoch+1} with test loss {test_loss}.')\n",
    "    else:\n",
    "        epochs_without_improvement += 1  # Increment since no improvement\n",
    "\n",
    "    print(f'Epoch {epoch + 1}, Train Loss: {train_loss}, Test Loss: {test_loss}')\n",
    "\n",
    "    # Check if early stopping criterion is met\n",
    "    if epochs_without_improvement >= early_stopping_patience:\n",
    "        print(f'Early Stopping after {epoch+1} epochs!')\n",
    "        break  # End the loop and thus the training\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25769da1-b581-4015-a00f-b6f21ebb58c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Step 5 - Model Training\n",
    "\n",
    "# Printint the Learning Curve\n",
    "plt.plot(train_losses, label='Train Loss')\n",
    "plt.plot(test_losses, label='Test Loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Learning Curve')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8361e817-e439-45c6-84cc-f1c0d9c5e06c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 6 - Rescaling, error metrics and visualization\n",
    "\n",
    "# Load the best model weights\n",
    "best_model_path = 'best_model.pth'\n",
    "model.load_state_dict(torch.load(best_model_path, map_location=device))\n",
    "\n",
    "# Evaluate the model\n",
    "model.eval()\n",
    "test_predictions = []\n",
    "with torch.no_grad():  # Disable gradient tracking for inference, which saves memory and computations\n",
    "    for i in range(len(X_test_tensors)):\n",
    "        X_batch = X_test_tensors[i].unsqueeze(0)  # Add a batch dimension to the tensor\n",
    "        y_pred, _ = model(X_batch, (torch.zeros(1, 1, model.hidden_layer_size).to(device), \n",
    "                                    torch.zeros(1, 1, model.hidden_layer_size).to(device)))\n",
    "        test_predictions.append(y_pred.squeeze().item())  # Squeeze to remove batch dimension and convert tensor to item\n",
    "\n",
    "# Denormalization of the predictions and actual values\n",
    "test_predictions_denorm = lastgang_scaler.inverse_transform(np.array(test_predictions).reshape(-1, 1))\n",
    "y_test_denorm = lastgang_scaler.inverse_transform(y_test.reshape(-1, 1))\n",
    "\n",
    "# Calculation of error metrics\n",
    "mse = mean_squared_error(y_test_denorm, test_predictions_denorm)  # Mean Squared Error\n",
    "mae = mean_absolute_error(y_test_denorm, test_predictions_denorm)  # Mean Absolute Error\n",
    "rmse = np.sqrt(mse)  # Root Mean Square Error\n",
    "mape = np.mean(np.abs((y_test_denorm - test_predictions_denorm) / y_test_denorm)) * 100  # Mean Absolute Percentage Error\n",
    "\n",
    "print(f\"Mean Squared Error (MSE): {mse}\")\n",
    "print(f\"Mean Absolute Error (MAE): {mae}\")\n",
    "print(f\"Root Mean Square Error (RMSE): {rmse}\")\n",
    "print(f\"Mean Absolute Percentage Error (MAPE): {mape}%\")\n",
    "\n",
    "# Visualization of actual vs predicted values\n",
    "plt.figure(figsize=(12, 6))\n",
    "test_dates = pd.date_range(start=dfEnergyAll.index[-len(X_test):][0], periods=len(y_test), freq='15T')\n",
    "plt.plot(test_dates, y_test_denorm, label='Actual Values', color='blue')\n",
    "plt.plot(test_dates, test_predictions_denorm, label='Predicted Values', color='red')\n",
    "plt.legend()\n",
    "plt.title('Comparison of Actual and Predicted Values')\n",
    "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d %H:%M'))  # Format the x-axis for dates\n",
    "#plt.gca().xaxis.set_major_locator(mdates.DayLocator())\n",
    "plt.gca().xaxis.set_major_locator(mdates.HourLocator(interval=3))  # Set major tick interval\n",
    "plt.gcf().autofmt_xdate()  # Auto format date labels\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}