TransformerArchitecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "30b18a7c-b40c-4b53-b1cc-90eb0632e6d3",
   "metadata": {},
   "source": [
    "# Transformer-Architecture for the prediction of energy consumption data over 48 hours\n",
    "### 1 - Transformer-Architecture with Energy consumption data and weather data\n",
    "### 2 - Transformer-Architecture with Energy consumption data and 2 variables 'Lastgang_Moving_Average' and 'Lastgang_First_Difference'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "db9e4cca-6b76-41b9-a8c3-645bc7bd97de",
   "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": 19,
   "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": 20,
   "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": 21,
   "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])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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": 23,
   "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_1514653/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 dfClimaAll\n",
    "# Ensure dfClimaAll is already defined before executing this line.\n",
    "print(\"Number of rows in dfClimaAll:\", dfClimaAll.shape[0])\n",
    "\n",
    "# Number of rows in dfEnergyAll\n",
    "print(\"Number of rows in dfEnergyAll:\", dfEnergyAll.shape[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aff293e9-0b20-45bf-981e-5c952ddb4e52",
   "metadata": {},
   "source": [
    "## 1 - Transformer-Architecture with Energy consumption data and weather data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 25,
   "id": "d74e0399-9d4c-4aad-aeb1-b615170f8c5c",
   "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_1514653/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": 26,
   "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']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "f98d7e5d-6358-4ddf-a1e0-907e2c133c40",
   "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": 28,
   "id": "5a0dcfe5-3d9a-40e1-834e-468d8c47864e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU before model training: 2024-05-03 17:23:54\n",
      "GPU: NVIDIA A100 80GB PCIe, GPU RAM Free: 15712.0MB, Used: 65326.0MB, Utilization: 4.0%\n",
      "GPU: NVIDIA A100 80GB PCIe, GPU RAM Free: 236.0MB, Used: 80803.0MB, Utilization: 100.0%\n",
      "CPU before model training:\n",
      "CPU Utilization: 82.1%\n",
      "RAM before model training:\n",
      "Total memory: 146.88 GB\n",
      "Available memory: 110.48 GB\n",
      "Used memory: 34.61 GB\n",
      "Memory usage: 24.8%\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": 29,
   "id": "0d90e033-70b7-4d3d-b038-315db7f388a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences, positional encoding and the LSTM model\n",
    "\n",
    "def create_sequences(data, seq_length):\n",
    "    xs = []\n",
    "    ys = []\n",
    "    for i in range(len(data) - seq_length):\n",
    "        x = data.iloc[i:(i + seq_length)].to_numpy()  # Extract sequence from data\n",
    "        y = data.iloc[i + seq_length, 0]  # Extract target value for the sequence\n",
    "        xs.append(x)\n",
    "        ys.append(y)\n",
    "    return np.array(xs), np.array(ys)  # Convert lists to numpy arrays\n",
    "\n",
    "seq_length = 192  # Length of each sequence\n",
    "X, y = create_sequences(dfEnergyAll, seq_length)  # Create sequences from data\n",
    "\n",
    "# Use the last 192 sequences for testing to maintain a comparable distribution as the TBATS model\n",
    "X_train, X_test = X[:-192], X[-192:]  # Split data into training and testing sets\n",
    "y_train, y_test = y[:-192], y[-192:]  # Split targets into training and testing sets\n",
    "\n",
    "\n",
    "# Function for positional encoding\n",
    "def positional_encoding(seq_len, d_model):\n",
    "    encoding = np.array([\n",
    "        [pos / np.power(10000, 2 * (j // 2) / d_model) for j in range(d_model)]\n",
    "        if pos != 0 else np.zeros(d_model)\n",
    "        for pos in range(seq_len)\n",
    "    ])\n",
    "    encoding[1:, 0::2] = np.sin(encoding[1:, 0::2])  # Apply sin to even indices\n",
    "    encoding[1:, 1::2] = np.cos(encoding[1:, 1::2])  # Apply cos to odd indices\n",
    "    return encoding\n",
    "\n",
    "# Apply positional encodings\n",
    "d_model = X_train.shape[2]  # Number of features in the data\n",
    "pos_enc = positional_encoding(seq_length, d_model)  # Generate positional encoding\n",
    "\n",
    "# Add positional encodings to the sequences\n",
    "X_train_enc = np.array([x + pos_enc for x in X_train])  # Add encoding to training data\n",
    "X_test_enc = np.array([x + pos_enc for x in X_test])  # Add encoding to testing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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",
      "X_train_enc Shape: (104736, 192, 10)\n",
      "X_test_enc 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}\")\n",
    "\n",
    "# Print the shapes of the training and testing datasets with positional encodings applied\n",
    "print(f\"X_train_enc Shape: {X_train_enc.shape}\")\n",
    "print(f\"X_test_enc Shape: {X_test_enc.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "514b9884-3534-4263-b95f-e830396947aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "X_train_tensors = torch.Tensor(X_train_enc).to(device)  # Convert training data to tensors and move to the designated device (GPU or CPU)\n",
    "y_train_tensors = torch.Tensor(y_train).view(-1, 1).to(device)  # Convert training labels to tensors, reshape them and move to the device\n",
    "X_test_tensors = torch.Tensor(X_test_enc).to(device)  # Convert testing data to tensors and move to the designated device\n",
    "y_test_tensors = torch.Tensor(y_test).view(-1, 1).to(device)  # Convert testing labels to tensors, reshape them and move to the device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "e84d8190-9f4f-4e97-94e5-6587d3efa9a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/sarah/anaconda3/envs/BT2024PyTorch/lib/python3.10/site-packages/torch/nn/modules/transformer.py:286: UserWarning: enable_nested_tensor is True, but self.use_nested_tensor is False because encoder_layer.self_attn.batch_first was not True(use batch_first for better inference performance)\n",
      "  warnings.warn(f\"enable_nested_tensor is True, but self.use_nested_tensor is False because {why_not_sparsity_fast_path}\")\n"
     ]
    }
   ],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "#Create Transformer Model\n",
    "import torch.nn as nn\n",
    "\n",
    "class TransformerModel(nn.Module):\n",
    "    def __init__(self, input_size, hidden_layer_size, output_size, num_layers, nhead):\n",
    "        super(TransformerModel, self).__init__()\n",
    "        self.input_size = input_size  # Number of input features\n",
    "        self.hidden_layer_size = hidden_layer_size  # Size of the hidden layer\n",
    "        self.output_size = output_size  # Size of the output layer\n",
    "\n",
    "        # Embedding layer that maps input features to the hidden layer size\n",
    "        self.embedding = nn.Linear(input_size, hidden_layer_size)\n",
    "\n",
    "        # Transformer Encoder\n",
    "        encoder_layers = nn.TransformerEncoderLayer(d_model=hidden_layer_size, nhead=nhead)\n",
    "        self.transformer_encoder = nn.TransformerEncoder(encoder_layers, num_layers=num_layers)\n",
    "\n",
    "        # Linear layer for output\n",
    "        self.linear = nn.Linear(hidden_layer_size, output_size)\n",
    "\n",
    "    def forward(self, src):\n",
    "        # Embedding\n",
    "        src = self.embedding(src)  # Apply embedding layer to source data\n",
    "\n",
    "        # Transformer Encoder\n",
    "        src = src.permute(1, 0, 2)  # Permute the dimensions of src for the Transformer (expects [seq_len, batch, features])\n",
    "        output = self.transformer_encoder(src)  # Pass the embedded src through the transformer encoder\n",
    "\n",
    "        # Only take the output from the last time step for making predictions\n",
    "        output = output[-1]\n",
    "\n",
    "        # Linear layer\n",
    "        output = self.linear(output)  # Apply linear layer to the output of the transformer\n",
    "        return output\n",
    "\n",
    "# Parameters\n",
    "input_size = 10  # Number of features\n",
    "hidden_layer_size = 100  # Size of the hidden layer\n",
    "output_size = 1  # Output size\n",
    "num_layers = 2  # Number of layers in the transformer\n",
    "nhead = 2  # Number of attention heads\n",
    "\n",
    "# Instantiate the model\n",
    "model = TransformerModel(input_size, hidden_layer_size, output_size, num_layers, nhead).to(device)  # Create the model and move it to the designated device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d936195f-89d1-48e4-9acb-4d63cd825590",
   "metadata": {},
   "source": [
    "from torchsummary import summary\n",
    "\n",
    "# Angabe der Eingabedimension für torchsummary\n",
    "seq_length = 192  # Sequenzlänge, wie im Modell verwendet\n",
    "summary(model, input_size=(seq_length, input_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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": [
      "New best model saved at epoch 1 with test loss 0.03984663731534965.\n",
      "Epoch 1, Train Loss: 0.013731314026245361, Test Loss: 0.03984663731534965\n",
      "New best model saved at epoch 2 with test loss 0.016820339420519304.\n",
      "Epoch 2, Train Loss: 0.005286569327589577, Test Loss: 0.016820339420519304\n",
      "Epoch 3, Train Loss: 0.006792317569947825, Test Loss: 0.017148404789622873\n",
      "Epoch 4, Train Loss: 0.004567338423792936, Test Loss: 0.02858270751312375\n",
      "Epoch 5, Train Loss: 0.004809053334021856, Test Loss: 0.017867928676423617\n",
      "Epoch 6, Train Loss: 0.004574279051601939, Test Loss: 0.04403836881829193\n",
      "Epoch 7, Train Loss: 0.0048564385962972505, Test Loss: 0.024106490673148073\n",
      "Early Stopping after 7 epochs!\n"
     ]
    }
   ],
   "source": [
    "# Step 5 - Model Training\n",
    "\n",
    "# Define the number of epochs and batch size\n",
    "loss_function = nn.MSELoss()  # Loss function for measuring the mean squared error loss\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)  # 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 per batch\n",
    "\n",
    "# For storing the loss values\n",
    "train_losses = []  # List to store training loss values for each epoch\n",
    "test_losses = []  # List to store validation loss values for each epoch\n",
    "\n",
    "# Initialize variables for Early Stopping\n",
    "best_test_loss = float('inf')  # Best validation loss seen so far, initialized to infinity\n",
    "best_model_path = 'best_model.pth'  # Path to save the best performing model\n",
    "early_stopping_patience = 5  # Number of epochs to continue without improvement before stopping\n",
    "epochs_without_improvement = 0  # Counter to track epochs without improvement\n",
    "\n",
    "for epoch in range(epochs):  # Loop over each epoch\n",
    "    model.train()  # Set the model to training mode\n",
    "    train_loss = 0.0  # Reset training loss for this 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 adjustment of the batch size for the last batch of the epoch\n",
    "        actual_batch_size = X_batch.size(0)\n",
    "\n",
    "        optimizer.zero_grad()  # Reset the gradients to zero\n",
    "\n",
    "        # No need to manage hidden states for the Transformer model\n",
    "        y_pred = model(X_batch)  # Forward pass through the model\n",
    "\n",
    "        loss = loss_function(y_pred, y_batch)  # Calculate loss\n",
    "        loss.backward()  # Backpropagation\n",
    "        optimizer.step()  # Update model weights\n",
    "        \n",
    "        train_loss += loss.item() * actual_batch_size  # Accumulate the loss\n",
    "\n",
    "    # Calculate the average training loss for this epoch\n",
    "    train_loss /= len(X_train_tensors)\n",
    "    train_losses.append(train_loss)\n",
    "\n",
    "    # Validation phase\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",
    "            y_pred = model(X_batch)  # Forward pass through the model for validation\n",
    "            loss = loss_function(y_pred, y_batch)  # Calculate loss\n",
    "            test_loss += loss.item() * actual_batch_size  # Accumulate the loss\n",
    "        \n",
    "    # Calculate the average validation loss for this 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 the improvement counter\n",
    "        print(f'New best model saved at epoch {epoch+1} with test loss {test_loss}.')\n",
    "    else:\n",
    "        epochs_without_improvement += 1  # Increment the no-improvement counter\n",
    "\n",
    "    print(f'Epoch {epoch + 1}, Train Loss: {train_loss}, Test Loss: {test_loss}')\n",
    "\n",
    "    if epochs_without_improvement >= early_stopping_patience:\n",
    "        print(f'Early Stopping after {epoch+1} epochs!')  # Stop training if no improvement\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "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": "markdown",
   "id": "55e3a217-8042-4676-a203-55e4441ee2cf",
   "metadata": {},
   "source": [
    "Learning Curve Chart: Die Lernkurve zeigt den Verlust von Trainings- und Testdaten über die Anzahl der Epochen. Der kontinuierliche Abwärtstrend beider Kurven deutet darauf hin, dass das Modell im Laufe der Zeit besser wird und keine Anzeichen von Überanpassung zeigt, da der Testverlust (orange Linie) dem Trainingsverlust (blaue Linie) folgt. Das Konvergieren beider Kurven ist ein gutes Zeichen dafür, dass das Modell generalisiert und nicht nur die Trainingsdaten auswendig lernt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "a22fa477-6ab6-4e77-827e-8bb770345c44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Squared Error (MSE): 36304.058488096474\n",
      "Mean Absolute Error (MAE): 162.9043857530535\n",
      "Root Mean Square Error (RMSE): 190.53623930396148\n",
      "Mean Absolute Percentage Error (MAPE): 22.51108406593072%\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():  # No gradients needed for inference\n",
    "    for i in range(len(X_test_tensors)):\n",
    "        X_batch = X_test_tensors[i].unsqueeze(0)  # Add batch dimension\n",
    "        y_pred = model(X_batch)  # No hidden state needed for Transformer\n",
    "        test_predictions.append(y_pred.squeeze().item())  # Remove batch dimension and convert to item\n",
    "\n",
    "# Denormalization of 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='#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: Transformer over 48 Hours')\n",
    "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d %H:%M'))  # Format x-axis for dates\n",
    "plt.gca().xaxis.set_major_locator(mdates.HourLocator(interval=3))  # Set major tick intervals\n",
    "plt.gcf().autofmt_xdate()  # Auto-format date labels for better readability\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a467f613-a988-4cff-8b07-6c24a18061ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 6 - Rescaling, error metrics and visualization\n",
    "\n",
    "# Saving the model for later\n",
    "torch.save(model.state_dict(), 'transformer_model.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "ec2ae0f8-ea84-46c0-90ce-4961b21cb9b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU after model training: 2024-05-03 17:30:49\n",
      "GPU: NVIDIA A100 80GB PCIe, GPU RAM Free: 14824.0MB, Used: 66214.0MB, Utilization: 24.0%\n",
      "GPU: NVIDIA A100 80GB PCIe, GPU RAM Free: 236.0MB, Used: 80803.0MB, Utilization: 55.00000000000001%\n",
      "CPU after model training:\n",
      "CPU Utilization: 81.2%\n",
      "RAM after model training:\n",
      "Total memory: 146.88 GB\n",
      "Available memory: 110.39 GB\n",
      "Used memory: 34.70 GB\n",
      "Memory usage: 24.8%\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": "dcd59d0a-ef66-4e51-886a-ddfb2f42025f",
   "metadata": {},
   "source": [
    "## 2 - Transformer-Architecture with Energy consumption data and 2 variables 'Lastgang_Moving_Average' and 'Lastgang_First_Difference'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04646c37-be07-45ad-98ad-9b2851d89658",
   "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": "86d884b0-1b5e-4041-bcf6-c0cbe4252f0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences, positional encoding and the LSTM model\n",
    "\n",
    "# Step 2 - Data Preparation: Create sequences and add positional encoding\n",
    "def create_sequences(data, seq_length):\n",
    "    xs = []  # list to store sequences\n",
    "    ys = []  # list to store target values corresponding to each sequence\n",
    "    for i in range(len(data) - seq_length):\n",
    "        x = data.iloc[i:(i + seq_length)].to_numpy()  # extract sequence of length seq_length from data\n",
    "        y = data.iloc[i + seq_length, 0]  # target value at the end of the sequence\n",
    "        xs.append(x)\n",
    "        ys.append(y)\n",
    "    return np.array(xs), np.array(ys)  # convert lists to numpy arrays for machine learning processing\n",
    "\n",
    "seq_length = 192  # define the length of sequences\n",
    "X, y = create_sequences(dfEnergyAll, seq_length)  # create sequences and corresponding targets from the dataset\n",
    "\n",
    "# Use the last 192 sequences for testing to maintain a comparable distribution as the TBATS model\n",
    "X_train, X_test = X[:-192], X[-192:]  # split data into training and testing sets\n",
    "y_train, y_test = y[:-192], y[-192:]  # split targets into training and testing sets\n",
    "\n",
    "# Function for positional encoding\n",
    "def positional_encoding(seq_len, d_model):\n",
    "    encoding = np.array([\n",
    "        [pos / np.power(10000, 2 * (j // 2) / d_model) for j in range(d_model)]\n",
    "        if pos != 0 else np.zeros(d_model) \n",
    "        for pos in range(seq_len)\n",
    "    ])\n",
    "    encoding[1:, 0::2] = np.sin(encoding[1:, 0::2])  # apply sine to even indices\n",
    "    encoding[1:, 1::2] = np.cos(encoding[1:, 1::2])  # apply cosine to odd indices\n",
    "    return encoding\n",
    "\n",
    "# Apply positional encodings\n",
    "d_model = X_train.shape[2]  # number of features in the data\n",
    "pos_enc = positional_encoding(seq_length, d_model)  # generate positional encoding based on sequence length and number of features\n",
    "\n",
    "# Add positional encodings to the sequences\n",
    "X_train_enc = np.array([x + pos_enc for x in X_train])  # add positional encoding to training data\n",
    "X_test_enc = np.array([x + pos_enc for x in X_test])  # add positional encoding to testing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d48f7903-acde-4110-a95d-7291ef66848f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences, positional encoding 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}\")\n",
    "\n",
    "# Print the shapes of the training and testing datasets with positional encodings applied\n",
    "print(f\"X_train_enc Shape: {X_train_enc.shape}\")\n",
    "print(f\"X_test_enc Shape: {X_test_enc.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9522a46a-5d2b-462d-8841-57163be8dff2",
   "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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edc7888b-ee3d-40b0-9106-30113640a475",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "X_train_tensors = torch.Tensor(X_train_enc).to(device)  # Convert training data to tensors and move to the designated device (GPU or CPU)\n",
    "y_train_tensors = torch.Tensor(y_train).view(-1, 1).to(device)  # Convert training labels to tensors, reshape them and move to the device\n",
    "X_test_tensors = torch.Tensor(X_test_enc).to(device)  # Convert testing data to tensors and move to the designated device\n",
    "y_test_tensors = torch.Tensor(y_test).view(-1, 1).to(device)  # Convert testing labels to tensors, reshape them and move to the device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8941331-bb15-43d3-aa83-938e47728b9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4 - Creating the sequences and the LSTM model\n",
    "\n",
    "#Create Transformer Model\n",
    "class TransformerModel(nn.Module):\n",
    "    def __init__(self, input_size, hidden_layer_size, output_size, num_layers, nhead):\n",
    "        super(TransformerModel, self).__init__()\n",
    "        self.input_size = input_size  # Number of input features\n",
    "        self.hidden_layer_size = hidden_layer_size  # Size of the hidden layer\n",
    "        self.output_size = output_size  # Size of the output layer\n",
    "\n",
    "        # Embedding layer that maps input features to the hidden layer size\n",
    "        self.embedding = nn.Linear(input_size, hidden_layer_size)\n",
    "\n",
    "        # Transformer Encoder\n",
    "        encoder_layers = nn.TransformerEncoderLayer(d_model=hidden_layer_size, nhead=nhead)\n",
    "        self.transformer_encoder = nn.TransformerEncoder(encoder_layers, num_layers=num_layers)\n",
    "\n",
    "        # Linear layer for output\n",
    "        self.linear = nn.Linear(hidden_layer_size, output_size)\n",
    "\n",
    "    def forward(self, src):\n",
    "        # Apply embedding to the source data\n",
    "        src = self.embedding(src)\n",
    "\n",
    "        # Transformer Encoder processes the data\n",
    "        src = src.permute(1, 0, 2)  # Transformer expects [seq_len, batch, features]\n",
    "        output = self.transformer_encoder(src)\n",
    "\n",
    "        # Take only the output of the last time step for prediction\n",
    "        output = output[-1]\n",
    "\n",
    "        # Output through linear layer\n",
    "        output = self.linear(output)\n",
    "        return output\n",
    "\n",
    "# Parameters\n",
    "input_size = 3  # Number of input features\n",
    "hidden_layer_size = 100  # Size of the hidden layer\n",
    "output_size = 1  # Output size\n",
    "num_layers = 2  # Number of layers in the transformer\n",
    "nhead = 2  # Number of attention heads\n",
    "\n",
    "# Instantiate the model\n",
    "model = TransformerModel(input_size, hidden_layer_size, output_size, num_layers, nhead).to(device)  # Create the model and move it to the designated device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b331b915-ca73-4a0d-93cd-4c59bf6cc766",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 5 - Model Training\n",
    "\n",
    "# Define the number of epochs and batch size\n",
    "loss_function = nn.MSELoss()  # Loss function for measuring the mean squared error loss\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)  # 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 per batch\n",
    "\n",
    "# For storing the loss values\n",
    "train_losses = []  # List to store training loss values for each epoch\n",
    "test_losses = []  # List to store validation loss values for each epoch\n",
    "\n",
    "# Initialize variables for Early Stopping\n",
    "best_test_loss = float('inf')  # Best validation loss seen so far, initialized to infinity\n",
    "best_model_path = 'best_model.pth'  # Path to save the best performing model\n",
    "early_stopping_patience = 5  # Number of epochs to continue without improvement before stopping\n",
    "epochs_without_improvement = 0  # Counter to track epochs without improvement\n",
    "\n",
    "for epoch in range(epochs):  # Loop over each epoch\n",
    "    model.train()  # Set the model to training mode\n",
    "    train_loss = 0.0  # Reset training loss for this 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 adjustment of the batch size for the last batch of the epoch\n",
    "        actual_batch_size = X_batch.size(0)\n",
    "\n",
    "        optimizer.zero_grad()  # Reset the gradients to zero\n",
    "\n",
    "        # No need to manage hidden states for the Transformer model\n",
    "        y_pred = model(X_batch)  # Forward pass through the model\n",
    "\n",
    "        loss = loss_function(y_pred, y_batch)  # Calculate loss\n",
    "        loss.backward()  # Backpropagation\n",
    "        optimizer.step()  # Update model weights\n",
    "        \n",
    "        train_loss += loss.item() * actual_batch_size  # Accumulate the loss\n",
    "\n",
    "    # Calculate the average training loss for this epoch\n",
    "    train_loss /= len(X_train_tensors)\n",
    "    train_losses.append(train_loss)\n",
    "\n",
    "    # Validation phase\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",
    "            y_pred = model(X_batch)  # Forward pass through the model for validation\n",
    "            loss = loss_function(y_pred, y_batch)  # Calculate loss\n",
    "            test_loss += loss.item() * actual_batch_size  # Accumulate the loss\n",
    "        \n",
    "    # Calculate the average validation loss for this 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 the improvement counter\n",
    "        print(f'New best model saved at epoch {epoch+1} with test loss {test_loss}.')\n",
    "    else:\n",
    "        epochs_without_improvement += 1  # Increment the no-improvement counter\n",
    "\n",
    "    print(f'Epoch {epoch + 1}, Train Loss: {train_loss}, Test Loss: {test_loss}')\n",
    "\n",
    "    if epochs_without_improvement >= early_stopping_patience:\n",
    "        print(f'Early Stopping after {epoch+1} epochs!')  # Stop training if no improvement\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df8b91d4-cd5e-4359-9700-8f071cf4f5b4",
   "metadata": {},
   "outputs": [],
   "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": null,
   "id": "ddd6b5d3-6cff-4d55-8272-c56b43074fe1",
   "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():  # No gradients needed for inference\n",
    "    for i in range(len(X_test_tensors)):\n",
    "        X_batch = X_test_tensors[i].unsqueeze(0)  # Add batch dimension\n",
    "        y_pred = model(X_batch)  # No hidden state needed for Transformer\n",
    "        test_predictions.append(y_pred.squeeze().item())  # Remove batch dimension and convert to item\n",
    "\n",
    "# Denormalization of 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='#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: Transformer over 48 Hours')\n",
    "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d %H:%M'))  # Format x-axis for dates\n",
    "plt.gca().xaxis.set_major_locator(mdates.HourLocator(interval=3))  # Set major tick intervals\n",
    "plt.gcf().autofmt_xdate()  # Auto-format date labels for better readability\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
}