ANN-Pytorch-Multivariate.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fc8005dd",
   "metadata": {
    "id": "fc8005dd"
   },
   "source": [
    "# ANN- Multivariate Time Series Solar Radiation(GHI) Forecasting with MLP, CNN, and LSTM Networks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6db958e-c7fb-4950-8406-b3fe5b41a604",
   "metadata": {},
   "source": [
    "#  MLP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "81d57f75-b81b-41fc-b63b-a074c4fefe13",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\bahgat.ayasi\\AppData\\Local\\Temp\\ipykernel_15084\\3043929999.py:15: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n",
      "  dataset.index = pd.to_datetime(dataset.index)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trainable parameters: 2753\n",
      "layers.0.weight: 576 parameters\n",
      "layers.0.bias: 32 parameters\n",
      "layers.2.weight: 1024 parameters\n",
      "layers.2.bias: 32 parameters\n",
      "layers.5.weight: 1024 parameters\n",
      "layers.5.bias: 32 parameters\n",
      "layers.8.weight: 32 parameters\n",
      "layers.8.bias: 1 parameters\n",
      "Epoch 1/60, Loss: 0.002472, Val Loss: 0.001823\n",
      "Epoch 2/60, Loss: 0.006174, Val Loss: 0.001035\n",
      "Epoch 3/60, Loss: 0.002706, Val Loss: 0.001013\n",
      "Epoch 4/60, Loss: 0.003388, Val Loss: 0.000860\n",
      "Epoch 5/60, Loss: 0.002232, Val Loss: 0.001028\n",
      "Epoch 6/60, Loss: 0.001860, Val Loss: 0.000631\n",
      "Epoch 7/60, Loss: 0.001803, Val Loss: 0.000537\n",
      "Epoch 8/60, Loss: 0.002000, Val Loss: 0.001402\n",
      "Epoch 9/60, Loss: 0.002763, Val Loss: 0.000786\n",
      "Epoch 10/60, Loss: 0.001758, Val Loss: 0.000494\n",
      "Epoch 11/60, Loss: 0.002415, Val Loss: 0.000641\n",
      "Epoch 12/60, Loss: 0.003173, Val Loss: 0.000525\n",
      "Epoch 13/60, Loss: 0.001892, Val Loss: 0.000696\n",
      "Epoch 14/60, Loss: 0.001093, Val Loss: 0.000411\n",
      "Epoch 15/60, Loss: 0.001290, Val Loss: 0.000914\n",
      "Epoch 16/60, Loss: 0.005388, Val Loss: 0.000410\n",
      "Epoch 17/60, Loss: 0.002401, Val Loss: 0.000646\n",
      "Epoch 18/60, Loss: 0.005960, Val Loss: 0.000412\n",
      "Epoch 19/60, Loss: 0.001344, Val Loss: 0.000394\n",
      "Epoch 20/60, Loss: 0.002089, Val Loss: 0.000505\n",
      "Epoch 21/60, Loss: 0.001559, Val Loss: 0.000687\n",
      "Epoch 22/60, Loss: 0.004533, Val Loss: 0.000471\n",
      "Epoch 23/60, Loss: 0.001000, Val Loss: 0.000862\n",
      "Epoch 24/60, Loss: 0.006595, Val Loss: 0.000817\n",
      "Epoch 25/60, Loss: 0.002152, Val Loss: 0.000375\n",
      "Epoch 26/60, Loss: 0.003540, Val Loss: 0.000473\n",
      "Epoch 27/60, Loss: 0.002174, Val Loss: 0.000420\n",
      "Epoch 28/60, Loss: 0.001599, Val Loss: 0.000412\n",
      "Epoch 29/60, Loss: 0.001893, Val Loss: 0.000466\n",
      "Epoch 30/60, Loss: 0.001703, Val Loss: 0.000721\n",
      "Epoch 31/60, Loss: 0.002085, Val Loss: 0.000411\n",
      "Epoch 32/60, Loss: 0.002831, Val Loss: 0.000398\n",
      "Epoch 33/60, Loss: 0.003076, Val Loss: 0.000334\n",
      "Epoch 34/60, Loss: 0.008289, Val Loss: 0.000392\n",
      "Epoch 35/60, Loss: 0.002729, Val Loss: 0.000417\n",
      "Epoch 36/60, Loss: 0.002091, Val Loss: 0.000498\n",
      "Epoch 37/60, Loss: 0.003769, Val Loss: 0.000485\n",
      "Epoch 38/60, Loss: 0.004294, Val Loss: 0.000483\n",
      "Epoch 39/60, Loss: 0.004826, Val Loss: 0.000312\n",
      "Epoch 40/60, Loss: 0.002854, Val Loss: 0.000453\n",
      "Epoch 41/60, Loss: 0.006321, Val Loss: 0.000441\n",
      "Epoch 42/60, Loss: 0.001547, Val Loss: 0.000305\n",
      "Epoch 43/60, Loss: 0.000576, Val Loss: 0.000366\n",
      "Epoch 44/60, Loss: 0.005203, Val Loss: 0.000323\n",
      "Epoch 45/60, Loss: 0.005817, Val Loss: 0.000456\n",
      "Epoch 46/60, Loss: 0.003290, Val Loss: 0.000321\n",
      "Epoch 47/60, Loss: 0.002043, Val Loss: 0.000461\n",
      "Epoch 48/60, Loss: 0.003446, Val Loss: 0.000466\n",
      "Epoch 49/60, Loss: 0.008347, Val Loss: 0.000496\n",
      "Epoch 50/60, Loss: 0.002626, Val Loss: 0.000479\n",
      "Epoch 51/60, Loss: 0.003320, Val Loss: 0.000469\n",
      "Epoch 52/60, Loss: 0.001088, Val Loss: 0.000332\n",
      "Epoch 53/60, Loss: 0.001111, Val Loss: 0.000358\n",
      "Epoch 54/60, Loss: 0.003609, Val Loss: 0.000308\n",
      "Epoch 55/60, Loss: 0.000791, Val Loss: 0.000641\n",
      "Epoch 56/60, Loss: 0.003429, Val Loss: 0.000603\n",
      "Epoch 57/60, Loss: 0.001057, Val Loss: 0.000355\n",
      "Epoch 58/60, Loss: 0.001768, Val Loss: 0.000404\n",
      "Epoch 59/60, Loss: 0.002318, Val Loss: 0.000911\n",
      "Epoch 60/60, Loss: 0.001471, Val Loss: 0.000421\n",
      "Minimum Validation Loss: 0.000305\n",
      "Minimum Validation Loss nRMSE: 0.017460\n",
      "Train - Predicted: [23.086605] Actual: [0.]\n",
      "Test - Predicted: [101.940506] Actual: [125.00001]\n",
      "Train - Predicted: [41.905552] Actual: [0.]\n",
      "Test - Predicted: [305.79587] Actual: [338.]\n",
      "Train - Predicted: [121.60716] Actual: [120.]\n",
      "Test - Predicted: [527.4112] Actual: [557.]\n",
      "Train - Predicted: [286.14444] Actual: [126.]\n",
      "Test - Predicted: [717.7909] Actual: [753.]\n",
      "Train - Predicted: [274.37448] Actual: [244.]\n",
      "Test - Predicted: [880.33044] Actual: [905.]\n",
      "Train MSE: 2105.310303\n",
      "Test MSE: 498.421387\n",
      "Train RMSE: 45.883659\n",
      "Test RMSE: 22.325354\n",
      "Train MAE: 24.285839\n",
      "Test MAE: 16.934694\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.metrics import mean_squared_error, mean_absolute_error  # Imported mean_absolute_error\n",
    "\n",
    "# Load and preprocess the dataset\n",
    "#dataset = pd.read_csv('Palestine-PV.csv', parse_dates=['date'], index_col='date')\n",
    "dataset = pd.read_csv('jordan_pv.csv',  index_col='date')\n",
    "dataset.index = pd.to_datetime(dataset.index)\n",
    "dataset = dataset.sort_index()\n",
    "dataset = dataset.dropna()\n",
    "dataset = dataset.astype(np.float64)\n",
    "\n",
    "def series_to_supervised(data, target_col_name, n_in=1, n_out=1, dropnan=True):\n",
    "    n_vars = data.shape[1]\n",
    "    df = pd.DataFrame(data)\n",
    "    cols, names = list(), list()\n",
    "    df = df[[col for col in df if col != target_col_name] + [target_col_name]]\n",
    "    for i in range(n_in, 0, -1):\n",
    "        cols.append(df.shift(i))\n",
    "        names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]\n",
    "    for i in range(0, n_out):\n",
    "        cols.append(df.shift(-i))\n",
    "        if i == 0:\n",
    "            names += [('var%d(t)' % (j+1)) for j in range(n_vars-1)]\n",
    "            names.append(target_col_name + '(t)')\n",
    "        else:\n",
    "            names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]\n",
    "    agg = pd.concat(cols, axis=1)\n",
    "    agg.columns = names\n",
    "    agg = agg[[col for col in agg if target_col_name in col or '(t)' not in col]]\n",
    "    if dropnan:\n",
    "        agg.dropna(inplace=True)\n",
    "    return agg\n",
    "\n",
    "values = dataset.values\n",
    "scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "scaled = scaler.fit_transform(values)\n",
    "df_scaled = pd.DataFrame(scaled, columns=dataset.columns)\n",
    "target_scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "target_scaled = target_scaler.fit_transform(dataset[['Solar Radiation(GHI)']])\n",
    "reframed = series_to_supervised(df_scaled, 'Solar Radiation(GHI)', 3, 1)\n",
    "values = reframed.values\n",
    "n_train_hours = 876 * 24\n",
    "train = values[:n_train_hours, :]\n",
    "test = values[n_train_hours:, :]\n",
    "train_X, train_y = train[:, :-1], train[:, -1]\n",
    "test_X, test_y = test[:, :-1], test[:, -1]\n",
    "train_X, train_y = torch.Tensor(train_X), torch.Tensor(train_y).view(-1, 1)\n",
    "test_X, test_y = torch.Tensor(test_X), torch.Tensor(test_y).view(-1, 1)\n",
    "\n",
    "# Define the model\n",
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, input_dim, neurons, layers1, activation, dropout_rate):\n",
    "        super(NeuralNetwork, self).__init__()\n",
    "        self.layers = nn.ModuleList()\n",
    "        self.layers.append(nn.Linear(input_dim, neurons))\n",
    "        self.layers.append(getattr(nn, activation)())\n",
    "        for _ in range(layers1):\n",
    "            self.layers.append(nn.Linear(neurons, neurons))\n",
    "            self.layers.append(getattr(nn, activation)())\n",
    "            if dropout_rate > 0:\n",
    "                self.layers.append(nn.Dropout(p=dropout_rate))\n",
    "        self.layers.append(nn.Linear(neurons, 1))\n",
    "        \n",
    "    def forward(self, x):\n",
    "        for layer in self.layers:\n",
    "            x = layer(x)\n",
    "        return x\n",
    "\n",
    "# Function to count the trainable parameters\n",
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "# Parameters\n",
    "activation = 'ReLU'\n",
    "batch_size = 64\n",
    "dropout_rate = 0.05\n",
    "epochs = 60\n",
    "layers1 = 2\n",
    "learning_rate = 0.001\n",
    "neurons = 32\n",
    "input_dim = train_X.shape[1]\n",
    "\n",
    "# Prepare the data\n",
    "train_dataset = TensorDataset(train_X, train_y)\n",
    "test_dataset = TensorDataset(test_X, test_y)\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "# Initialize the model, loss function, and optimizer\n",
    "model = NeuralNetwork(input_dim, neurons, layers1, activation, dropout_rate)\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "model = model.to(device)\n",
    "\n",
    "# Print trainable parameters\n",
    "print(f\"Trainable parameters: {count_parameters(model)}\")\n",
    "for name, param in model.named_parameters():\n",
    "    if param.requires_grad:\n",
    "        print(f\"{name}: {param.numel()} parameters\")\n",
    "\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
    "\n",
    "# Train the model\n",
    "train_losses = []\n",
    "val_losses = []\n",
    "min_val_loss = float('inf')\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    model.train()\n",
    "    for batch_X, batch_y in train_loader:\n",
    "        batch_X, batch_y = batch_X.to(device), batch_y.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(batch_X)\n",
    "        loss = criterion(outputs, batch_y)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        val_loss = 0\n",
    "        for val_X, val_y in test_loader:\n",
    "            val_X, val_y = val_X.to(device), val_y.to(device)\n",
    "            val_outputs = model(val_X)\n",
    "            val_loss += criterion(val_outputs, val_y).item()\n",
    "        val_loss /= len(test_loader)\n",
    "    train_losses.append(loss.item())\n",
    "    val_losses.append(val_loss)\n",
    "    print(f'Epoch {epoch+1}/{epochs}, Loss: {loss.item():.6f}, Val Loss: {val_loss:.6f}')\n",
    "    if val_loss < min_val_loss:\n",
    "        min_val_loss = val_loss\n",
    "        min_val_loss_nRMSE=np.sqrt(min_val_loss)\n",
    "# Print the minimum validation loss\n",
    "print(f\"Minimum Validation Loss: {min_val_loss:.6f}\")\n",
    "print(f\"Minimum Validation Loss nRMSE: {min_val_loss_nRMSE:.6f}\")\n",
    "# Make predictions\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    train_predictions = model(train_X.to(device)).cpu().numpy()\n",
    "    test_predictions = model(test_X.to(device)).cpu().numpy()\n",
    "\n",
    "# Inverse transform the predictions and actual values\n",
    "train_predict_inv = target_scaler.inverse_transform(train_predictions)\n",
    "test_predict_inv = target_scaler.inverse_transform(test_predictions)\n",
    "train_y_inv = target_scaler.inverse_transform(train_y.cpu().numpy().reshape(-1, 1))\n",
    "test_y_inv = target_scaler.inverse_transform(test_y.cpu().numpy().reshape(-1, 1))\n",
    "\n",
    "# Print the predicted and actual values for the first 5 items\n",
    "for i in range(5):\n",
    "    print('Train - Predicted:', train_predict_inv[i], 'Actual:', train_y_inv[i])\n",
    "    print('Test - Predicted:', test_predict_inv[i], 'Actual:', test_y_inv[i])\n",
    "\n",
    "# Calculate and print the MSE, RMSE, and MAE\n",
    "train_mse = mean_squared_error(train_y_inv, train_predict_inv)\n",
    "test_mse = mean_squared_error(test_y_inv, test_predict_inv)\n",
    "train_rmse = np.sqrt(train_mse)\n",
    "test_rmse = np.sqrt(test_mse)\n",
    "\n",
    "train_mae = mean_absolute_error(train_y_inv, train_predict_inv)\n",
    "test_mae = mean_absolute_error(test_y_inv, test_predict_inv)\n",
    "\n",
    "print(\"Train MSE: {:.6f}\".format(train_mse))\n",
    "print(\"Test MSE: {:.6f}\".format(test_mse))\n",
    "print(\"Train RMSE: {:.6f}\".format(train_rmse))\n",
    "print(\"Test RMSE: {:.6f}\".format(test_rmse))\n",
    "print(\"Train MAE: {:.6f}\".format(train_mae))\n",
    "print(\"Test MAE: {:.6f}\".format(test_mae))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c816a481-78f5-481c-b62b-8159d317a294",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NeuralNetwork(\n",
      "  (layers): ModuleList(\n",
      "    (0): Linear(in_features=18, out_features=32, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=32, out_features=32, bias=True)\n",
      "    (3): ReLU()\n",
      "    (4): Dropout(p=0.05, inplace=False)\n",
      "    (5): Linear(in_features=32, out_features=32, bias=True)\n",
      "    (6): ReLU()\n",
      "    (7): Dropout(p=0.05, inplace=False)\n",
      "    (8): Linear(in_features=32, out_features=1, bias=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4886c4a",
   "metadata": {
    "id": "f4886c4a"
   },
   "source": [
    "#  CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "55983fbd-3082-453f-8b41-4608fbaa8aea",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\bahgat.ayasi\\AppData\\Local\\Temp\\ipykernel_17032\\2058398237.py:13: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n",
      "  dataset = pd.read_csv('jordan_pv.csv', parse_dates=['date'], index_col='date')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trainable parameters: 21729\n",
      "conv1.weight: 32 parameters\n",
      "conv1.bias: 32 parameters\n",
      "conv2.weight: 1024 parameters\n",
      "conv2.bias: 32 parameters\n",
      "layers.0.weight: 18432 parameters\n",
      "layers.0.bias: 32 parameters\n",
      "layers.2.weight: 1024 parameters\n",
      "layers.2.bias: 32 parameters\n",
      "layers.5.weight: 1024 parameters\n",
      "layers.5.bias: 32 parameters\n",
      "output_layer.weight: 32 parameters\n",
      "output_layer.bias: 1 parameters\n",
      "Epoch 1/60, Loss: 0.003233, Val Loss: 0.001128\n",
      "Epoch 2/60, Loss: 0.003051, Val Loss: 0.001333\n",
      "Epoch 3/60, Loss: 0.001223, Val Loss: 0.000842\n",
      "Epoch 4/60, Loss: 0.004021, Val Loss: 0.000663\n",
      "Epoch 5/60, Loss: 0.003489, Val Loss: 0.000752\n",
      "Epoch 6/60, Loss: 0.002616, Val Loss: 0.001097\n",
      "Epoch 7/60, Loss: 0.001757, Val Loss: 0.001164\n",
      "Epoch 8/60, Loss: 0.003079, Val Loss: 0.000536\n",
      "Epoch 9/60, Loss: 0.001698, Val Loss: 0.000413\n",
      "Epoch 10/60, Loss: 0.001463, Val Loss: 0.001576\n",
      "Epoch 11/60, Loss: 0.000677, Val Loss: 0.000761\n",
      "Epoch 12/60, Loss: 0.000834, Val Loss: 0.000884\n",
      "Epoch 13/60, Loss: 0.001739, Val Loss: 0.000971\n",
      "Epoch 14/60, Loss: 0.006566, Val Loss: 0.001441\n",
      "Epoch 15/60, Loss: 0.001615, Val Loss: 0.001053\n",
      "Epoch 16/60, Loss: 0.001081, Val Loss: 0.000533\n",
      "Epoch 17/60, Loss: 0.002219, Val Loss: 0.001264\n",
      "Epoch 18/60, Loss: 0.002404, Val Loss: 0.000521\n",
      "Epoch 19/60, Loss: 0.012887, Val Loss: 0.000778\n",
      "Epoch 20/60, Loss: 0.000716, Val Loss: 0.001014\n",
      "Epoch 21/60, Loss: 0.001461, Val Loss: 0.000476\n",
      "Epoch 22/60, Loss: 0.001019, Val Loss: 0.000660\n",
      "Epoch 23/60, Loss: 0.001913, Val Loss: 0.000472\n",
      "Epoch 24/60, Loss: 0.002055, Val Loss: 0.000614\n",
      "Epoch 25/60, Loss: 0.002182, Val Loss: 0.000611\n",
      "Epoch 26/60, Loss: 0.001693, Val Loss: 0.000753\n",
      "Epoch 27/60, Loss: 0.002110, Val Loss: 0.001132\n",
      "Epoch 28/60, Loss: 0.001910, Val Loss: 0.000511\n",
      "Epoch 29/60, Loss: 0.001339, Val Loss: 0.000385\n",
      "Epoch 30/60, Loss: 0.001650, Val Loss: 0.000768\n",
      "Epoch 31/60, Loss: 0.000627, Val Loss: 0.000477\n",
      "Epoch 32/60, Loss: 0.003408, Val Loss: 0.000513\n",
      "Epoch 33/60, Loss: 0.001188, Val Loss: 0.000830\n",
      "Epoch 34/60, Loss: 0.001698, Val Loss: 0.000697\n",
      "Epoch 35/60, Loss: 0.005285, Val Loss: 0.000354\n",
      "Epoch 36/60, Loss: 0.006464, Val Loss: 0.000682\n",
      "Epoch 37/60, Loss: 0.002338, Val Loss: 0.000451\n",
      "Epoch 38/60, Loss: 0.002156, Val Loss: 0.000827\n",
      "Epoch 39/60, Loss: 0.001756, Val Loss: 0.000329\n",
      "Epoch 40/60, Loss: 0.001543, Val Loss: 0.001270\n",
      "Epoch 41/60, Loss: 0.000746, Val Loss: 0.000431\n",
      "Epoch 42/60, Loss: 0.002833, Val Loss: 0.000561\n",
      "Epoch 43/60, Loss: 0.000387, Val Loss: 0.001145\n",
      "Epoch 44/60, Loss: 0.003025, Val Loss: 0.000643\n",
      "Epoch 45/60, Loss: 0.001106, Val Loss: 0.000326\n",
      "Epoch 46/60, Loss: 0.001480, Val Loss: 0.000944\n",
      "Epoch 47/60, Loss: 0.005824, Val Loss: 0.000416\n",
      "Epoch 48/60, Loss: 0.001453, Val Loss: 0.001536\n",
      "Epoch 49/60, Loss: 0.000770, Val Loss: 0.000643\n",
      "Epoch 50/60, Loss: 0.000809, Val Loss: 0.001055\n",
      "Epoch 51/60, Loss: 0.000786, Val Loss: 0.000574\n",
      "Epoch 52/60, Loss: 0.004752, Val Loss: 0.000337\n",
      "Epoch 53/60, Loss: 0.001353, Val Loss: 0.000464\n",
      "Epoch 54/60, Loss: 0.002104, Val Loss: 0.000378\n",
      "Epoch 55/60, Loss: 0.001017, Val Loss: 0.000386\n",
      "Epoch 56/60, Loss: 0.001199, Val Loss: 0.000566\n",
      "Epoch 57/60, Loss: 0.004110, Val Loss: 0.000523\n",
      "Epoch 58/60, Loss: 0.000969, Val Loss: 0.000788\n",
      "Epoch 59/60, Loss: 0.003726, Val Loss: 0.000370\n",
      "Epoch 60/60, Loss: 0.002876, Val Loss: 0.000360\n",
      "The training process took 70.11 seconds.\n",
      "Minimum Validation Loss: 0.000326\n",
      "Minimum Validation Loss nRMSE: 0.018054\n",
      "Train - Predicted: 4.096447, Actual: 0.000000\n",
      "Test - Predicted: 85.653419, Actual: 125.000008\n",
      "Train - Predicted: 4.848754, Actual: 0.000000\n",
      "Test - Predicted: 299.050842, Actual: 338.000000\n",
      "Train - Predicted: 89.069351, Actual: 120.000000\n",
      "Test - Predicted: 506.542877, Actual: 557.000000\n",
      "Train - Predicted: 270.687592, Actual: 126.000000\n",
      "Test - Predicted: 710.151611, Actual: 753.000000\n",
      "Train - Predicted: 248.574844, Actual: 244.000000\n",
      "Test - Predicted: 877.966125, Actual: 905.000000\n",
      "Train MSE: 1974.171997\n",
      "Test MSE: 429.129028\n",
      "Train RMSE: 44.431656\n",
      "Test RMSE: 20.715429\n",
      "Train MAE: 20.562147\n",
      "Test MAE: 12.752629\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 708.661x708.661 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.metrics import mean_squared_error, mean_absolute_error  # Imported mean_absolute_error\n",
    "\n",
    "# Load and preprocess the dataset\n",
    "dataset = pd.read_csv('jordan_pv.csv', parse_dates=['date'], index_col='date')\n",
    "#dataset = pd.read_csv('Palestine-PV.csv', parse_dates=['date'], index_col='date')\n",
    "dataset.index = pd.to_datetime(dataset.index)\n",
    "dataset = dataset.sort_index()\n",
    "dataset = dataset.dropna()\n",
    "dataset = dataset.astype(np.float64)\n",
    "\n",
    "def series_to_supervised(data, target_col_name, n_in=1, n_out=1, dropnan=True):\n",
    "    n_vars = data.shape[1]\n",
    "    df = pd.DataFrame(data)\n",
    "    cols, names = list(), list()\n",
    "    df = df[[col for col in df if col != target_col_name] + [target_col_name]]\n",
    "    for i in range(n_in, 0, -1):\n",
    "        cols.append(df.shift(i))\n",
    "        names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]\n",
    "    for i in range(0, n_out):\n",
    "        cols.append(df.shift(-i))\n",
    "        if i == 0:\n",
    "            names += [('var%d(t)' % (j+1)) for j in range(n_vars-1)]\n",
    "            names.append(target_col_name + '(t)')\n",
    "        else:\n",
    "            names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]\n",
    "    agg = pd.concat(cols, axis=1)\n",
    "    agg.columns = names\n",
    "    agg = agg[[col for col in agg if target_col_name in col or '(t)' not in col]]\n",
    "    if dropnan:\n",
    "        agg.dropna(inplace=True)\n",
    "    return agg\n",
    "\n",
    "values = dataset.values\n",
    "scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "scaled = scaler.fit_transform(values)\n",
    "df_scaled = pd.DataFrame(scaled, columns=dataset.columns)\n",
    "target_scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "target_scaled = target_scaler.fit_transform(dataset[['Solar Radiation(GHI)']])\n",
    "reframed = series_to_supervised(df_scaled, 'Solar Radiation(GHI)', 3, 1)\n",
    "values = reframed.values\n",
    "n_train_hours = 876 * 24\n",
    "train = values[:n_train_hours, :]\n",
    "test = values[n_train_hours:, :]\n",
    "train_X, train_y = train[:, :-1], train[:, -1]\n",
    "test_X, test_y = test[:, :-1], test[:, -1]\n",
    "train_X, train_y = torch.tensor(train_X).float(), torch.tensor(train_y).view(-1, 1).float()\n",
    "test_X, test_y = torch.tensor(test_X).float(), torch.tensor(test_y).view(-1, 1).float()\n",
    "\n",
    "# Define the model\n",
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, input_dim, neurons, layers1, activation, dropout_rate):\n",
    "        super(NeuralNetwork, self).__init__()\n",
    "        self.conv1 = nn.Conv1d(1, 32, kernel_size=1)\n",
    "        self.conv2 = nn.Conv1d(32, 32, kernel_size=1)\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.layers = nn.ModuleList()\n",
    "        self.layers.append(nn.Linear(input_dim * 32, neurons))\n",
    "        self.layers.append(getattr(nn, activation)())\n",
    "        for _ in range(layers1):\n",
    "            self.layers.append(nn.Linear(neurons, neurons))\n",
    "            self.layers.append(getattr(nn, activation)())\n",
    "            if dropout_rate > 0:\n",
    "                self.layers.append(nn.Dropout(p=dropout_rate))\n",
    "        self.output_layer = nn.Linear(neurons, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.flatten(x)\n",
    "        for layer in self.layers:\n",
    "            x = layer(x)\n",
    "        x = self.output_layer(x)\n",
    "        return x\n",
    "\n",
    "# Function to count the trainable parameters\n",
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "# Parameters\n",
    "activation = 'ReLU'\n",
    "batch_size = 64\n",
    "dropout_rate = 0.05\n",
    "epochs = 60\n",
    "layers1 = 2\n",
    "learning_rate = 0.001\n",
    "neurons = 32\n",
    "input_dim = train_X.shape[1]\n",
    "\n",
    "# Prepare the data\n",
    "train_X = train_X.reshape((train_X.shape[0], 1, train_X.shape[1]))\n",
    "test_X = test_X.reshape((test_X.shape[0], 1, test_X.shape[1]))\n",
    "\n",
    "train_dataset = TensorDataset(train_X, train_y)\n",
    "test_dataset = TensorDataset(test_X, test_y)\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "# Initialize the model, loss function, and optimizer\n",
    "model = NeuralNetwork(input_dim, neurons, layers1, activation, dropout_rate)\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "model = model.to(device)\n",
    "\n",
    "# Print trainable parameters\n",
    "print(f\"Trainable parameters: {count_parameters(model)}\")\n",
    "for name, param in model.named_parameters():\n",
    "    if param.requires_grad:\n",
    "        print(f\"{name}: {param.numel()} parameters\")\n",
    "\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
    "\n",
    "# Train the model\n",
    "train_losses = []\n",
    "val_losses = []\n",
    "min_val_loss = float('inf')\n",
    "start_time = time.time()\n",
    "for epoch in range(epochs):\n",
    "    model.train()\n",
    "    for batch_X, batch_y in train_loader:\n",
    "        batch_X, batch_y = batch_X.to(device), batch_y.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(batch_X)\n",
    "        loss = criterion(outputs, batch_y)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        val_loss = 0\n",
    "        for val_X, val_y in test_loader:\n",
    "            val_X, val_y = val_X.to(device), val_y.to(device)\n",
    "            val_outputs = model(val_X)\n",
    "            val_loss += criterion(val_outputs, val_y).item()\n",
    "    val_loss /= len(test_loader)\n",
    "    train_losses.append(loss.item())\n",
    "    val_losses.append(val_loss)\n",
    "    print(f'Epoch {epoch+1}/{epochs}, Loss: {loss.item():.6f}, Val Loss: {val_loss:.6f}')\n",
    "    if val_loss < min_val_loss:\n",
    "        min_val_loss = val_loss\n",
    "        min_val_loss_nRMSE=np.sqrt(min_val_loss)\n",
    "end_time = time.time()\n",
    "elapsed_time = end_time - start_time\n",
    "print(f\"The training process took {elapsed_time:.2f} seconds.\")\n",
    "\n",
    "# Print the minimum validation loss\n",
    "print(f\"Minimum Validation Loss: {min_val_loss:.6f}\")\n",
    "print(f\"Minimum Validation Loss nRMSE: {min_val_loss_nRMSE:.6f}\")\n",
    "\n",
    "# Make predictions\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    train_predictions = model(train_X.to(device)).cpu().numpy()\n",
    "    test_predictions = model(test_X.to(device)).cpu().numpy()\n",
    "\n",
    "# Inverse transform the predictions and actual values\n",
    "train_predict_inv = target_scaler.inverse_transform(train_predictions)\n",
    "test_predict_inv = target_scaler.inverse_transform(test_predictions)\n",
    "train_y_inv = target_scaler.inverse_transform(train_y.cpu().numpy())\n",
    "test_y_inv = target_scaler.inverse_transform(test_y.cpu().numpy())\n",
    "\n",
    "# Print the predicted and actual values for the first 5 items\n",
    "for i in range(5):\n",
    "    print(f'Train - Predicted: {train_predict_inv[i][0]:.6f}, Actual: {train_y_inv[i][0]:.6f}')\n",
    "    print(f'Test - Predicted: {test_predict_inv[i][0]:.6f}, Actual: {test_y_inv[i][0]:.6f}')\n",
    "\n",
    "# Calculate and print the MSE, RMSE, and MAE\n",
    "train_mse = mean_squared_error(train_y_inv, train_predict_inv)\n",
    "test_mse = mean_squared_error(test_y_inv, test_predict_inv)\n",
    "train_rmse = np.sqrt(train_mse)\n",
    "test_rmse = np.sqrt(test_mse)\n",
    "\n",
    "train_mae = mean_absolute_error(train_y_inv, train_predict_inv)\n",
    "test_mae = mean_absolute_error(test_y_inv, test_predict_inv)\n",
    "\n",
    "print(\"Train MSE: {:.6f}\".format(train_mse))\n",
    "print(\"Test MSE: {:.6f}\".format(test_mse))\n",
    "print(\"Train RMSE: {:.6f}\".format(train_rmse))\n",
    "print(\"Test RMSE: {:.6f}\".format(test_rmse))\n",
    "print(\"Train MAE: {:.6f}\".format(train_mae))\n",
    "print(\"Test MAE: {:.6f}\".format(test_mae))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5e641005-ff8e-4664-9353-3c80f1b1f120",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NeuralNetwork(\n",
      "  (conv1): Conv1d(1, 32, kernel_size=(1,), stride=(1,))\n",
      "  (conv2): Conv1d(32, 32, kernel_size=(1,), stride=(1,))\n",
      "  (flatten): Flatten(start_dim=1, end_dim=-1)\n",
      "  (layers): ModuleList(\n",
      "    (0): Linear(in_features=576, out_features=100, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=100, out_features=100, bias=True)\n",
      "    (3): ReLU()\n",
      "    (4): Linear(in_features=100, out_features=100, bias=True)\n",
      "    (5): ReLU()\n",
      "  )\n",
      "  (output_layer): Linear(in_features=100, out_features=1, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c90529f7-271e-40cf-a849-c8a5a8f1b25a",
   "metadata": {
    "id": "2419d51d"
   },
   "source": [
    "# LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c81b3d87-4513-4322-8254-34501c217b95",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\bahgat.ayasi\\AppData\\Local\\Temp\\ipykernel_17032\\2986102517.py:12: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n",
      "  dataset = pd.read_csv('jordan_pv.csv', parse_dates=['date'], index_col='date')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trainable parameters: 8801\n",
      "lstm.weight_ih_l0: 2304 parameters\n",
      "lstm.weight_hh_l0: 4096 parameters\n",
      "lstm.bias_ih_l0: 128 parameters\n",
      "lstm.bias_hh_l0: 128 parameters\n",
      "layers.0.weight: 1024 parameters\n",
      "layers.0.bias: 32 parameters\n",
      "layers.2.weight: 1024 parameters\n",
      "layers.2.bias: 32 parameters\n",
      "output_layer.weight: 32 parameters\n",
      "output_layer.bias: 1 parameters\n",
      "Epoch 1/60, Loss: 0.008658, Val Loss: 0.001601\n",
      "Epoch 2/60, Loss: 0.001849, Val Loss: 0.001039\n",
      "Epoch 3/60, Loss: 0.006275, Val Loss: 0.000900\n",
      "Epoch 4/60, Loss: 0.001652, Val Loss: 0.000899\n",
      "Epoch 5/60, Loss: 0.003800, Val Loss: 0.000681\n",
      "Epoch 6/60, Loss: 0.002129, Val Loss: 0.000744\n",
      "Epoch 7/60, Loss: 0.000632, Val Loss: 0.000776\n",
      "Epoch 8/60, Loss: 0.001918, Val Loss: 0.000478\n",
      "Epoch 9/60, Loss: 0.001165, Val Loss: 0.000456\n",
      "Epoch 10/60, Loss: 0.001359, Val Loss: 0.000664\n",
      "Epoch 11/60, Loss: 0.002189, Val Loss: 0.000458\n",
      "Epoch 12/60, Loss: 0.001651, Val Loss: 0.000444\n",
      "Epoch 13/60, Loss: 0.002955, Val Loss: 0.000476\n",
      "Epoch 14/60, Loss: 0.001619, Val Loss: 0.000611\n",
      "Epoch 15/60, Loss: 0.004684, Val Loss: 0.000471\n",
      "Epoch 16/60, Loss: 0.000967, Val Loss: 0.000427\n",
      "Epoch 17/60, Loss: 0.000904, Val Loss: 0.000348\n",
      "Epoch 18/60, Loss: 0.000233, Val Loss: 0.000733\n",
      "Epoch 19/60, Loss: 0.004670, Val Loss: 0.000425\n",
      "Epoch 20/60, Loss: 0.000354, Val Loss: 0.000710\n",
      "Epoch 21/60, Loss: 0.000724, Val Loss: 0.000430\n",
      "Epoch 22/60, Loss: 0.000742, Val Loss: 0.000484\n",
      "Epoch 23/60, Loss: 0.002212, Val Loss: 0.000310\n",
      "Epoch 24/60, Loss: 0.001873, Val Loss: 0.000332\n",
      "Epoch 25/60, Loss: 0.001984, Val Loss: 0.000394\n",
      "Epoch 26/60, Loss: 0.002727, Val Loss: 0.001846\n",
      "Epoch 27/60, Loss: 0.004169, Val Loss: 0.000684\n",
      "Epoch 28/60, Loss: 0.000658, Val Loss: 0.000517\n",
      "Epoch 29/60, Loss: 0.004150, Val Loss: 0.000311\n",
      "Epoch 30/60, Loss: 0.002198, Val Loss: 0.000898\n",
      "Epoch 31/60, Loss: 0.002929, Val Loss: 0.000352\n",
      "Epoch 32/60, Loss: 0.001137, Val Loss: 0.000336\n",
      "Epoch 33/60, Loss: 0.002478, Val Loss: 0.000465\n",
      "Epoch 34/60, Loss: 0.000956, Val Loss: 0.000277\n",
      "Epoch 35/60, Loss: 0.000858, Val Loss: 0.000376\n",
      "Epoch 36/60, Loss: 0.002621, Val Loss: 0.000641\n",
      "Epoch 37/60, Loss: 0.000671, Val Loss: 0.000479\n",
      "Epoch 38/60, Loss: 0.001694, Val Loss: 0.000305\n",
      "Epoch 39/60, Loss: 0.001550, Val Loss: 0.000780\n",
      "Epoch 40/60, Loss: 0.006156, Val Loss: 0.000451\n",
      "Epoch 41/60, Loss: 0.001230, Val Loss: 0.000293\n",
      "Epoch 42/60, Loss: 0.001617, Val Loss: 0.000375\n",
      "Epoch 43/60, Loss: 0.002012, Val Loss: 0.000347\n",
      "Epoch 44/60, Loss: 0.001278, Val Loss: 0.000708\n",
      "Epoch 45/60, Loss: 0.004564, Val Loss: 0.000357\n",
      "Epoch 46/60, Loss: 0.001835, Val Loss: 0.000479\n",
      "Epoch 47/60, Loss: 0.003394, Val Loss: 0.000828\n",
      "Epoch 48/60, Loss: 0.003297, Val Loss: 0.000349\n",
      "Epoch 49/60, Loss: 0.001307, Val Loss: 0.000401\n",
      "Epoch 50/60, Loss: 0.001882, Val Loss: 0.000355\n",
      "Epoch 51/60, Loss: 0.004500, Val Loss: 0.000551\n",
      "Epoch 52/60, Loss: 0.005713, Val Loss: 0.000559\n",
      "Epoch 53/60, Loss: 0.001493, Val Loss: 0.000976\n",
      "Epoch 54/60, Loss: 0.001231, Val Loss: 0.000460\n",
      "Epoch 55/60, Loss: 0.001068, Val Loss: 0.000627\n",
      "Epoch 56/60, Loss: 0.002513, Val Loss: 0.000558\n",
      "Epoch 57/60, Loss: 0.000608, Val Loss: 0.000359\n",
      "Epoch 58/60, Loss: 0.003141, Val Loss: 0.000391\n",
      "Epoch 59/60, Loss: 0.000719, Val Loss: 0.000320\n",
      "Epoch 60/60, Loss: 0.007186, Val Loss: 0.000380\n",
      "Minimum Validation Loss: 0.000277\n",
      "Minimum Validation Loss nRMSE: 0.016649\n",
      "Train - Predicted: 3.645711, Actual: 0.000000\n",
      "Test - Predicted: 62.464108, Actual: 125.000008\n",
      "Train - Predicted: 4.598991, Actual: 0.000000\n",
      "Test - Predicted: 296.030396, Actual: 338.000000\n",
      "Train - Predicted: 70.015381, Actual: 120.000000\n",
      "Test - Predicted: 530.386963, Actual: 557.000000\n",
      "Train - Predicted: 255.462082, Actual: 126.000000\n",
      "Test - Predicted: 715.656799, Actual: 753.000000\n",
      "Train - Predicted: 278.359222, Actual: 244.000000\n",
      "Test - Predicted: 901.208923, Actual: 905.000000\n",
      "Train MSE: 2060.362549\n",
      "Test MSE: 452.864410\n",
      "Train RMSE: 45.391216\n",
      "Test RMSE: 21.280611\n",
      "Train MAE: 19.896488\n",
      "Test MAE: 12.769577\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 708.661x472.441 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.metrics import mean_squared_error, mean_absolute_error  # Imported mean_absolute_error\n",
    "\n",
    "# Load and preprocess the dataset\n",
    "dataset = pd.read_csv('jordan_pv.csv', parse_dates=['date'], index_col='date')\n",
    "#dataset = pd.read_csv('Palestine-PV.csv', parse_dates=['date'], index_col='date')\n",
    "dataset.index = pd.to_datetime(dataset.index)\n",
    "dataset = dataset.sort_index()\n",
    "dataset = dataset.dropna()\n",
    "dataset = dataset.astype(np.float64)\n",
    "\n",
    "def series_to_supervised(data, target_col_name, n_in=1, n_out=1, dropnan=True):\n",
    "    n_vars = data.shape[1]\n",
    "    df = pd.DataFrame(data)\n",
    "    cols, names = list(), list()\n",
    "\n",
    "    # Ensure the target column is the last column in the dataframe\n",
    "    df = df[[col for col in df if col != target_col_name] + [target_col_name]]\n",
    "\n",
    "    # Input sequence (t-n, ... t-1)\n",
    "    for i in range(n_in, 0, -1):\n",
    "        cols.append(df.shift(i))\n",
    "        names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]\n",
    "\n",
    "    # Forecast sequence (t, t+1, ... t+n)\n",
    "    for i in range(0, n_out):\n",
    "        cols.append(df.shift(-i))\n",
    "        if i == 0:\n",
    "            names += [('var%d(t)' % (j+1)) for j in range(n_vars-1)]\n",
    "            names.append(target_col_name + '(t)')\n",
    "        else:\n",
    "            names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]\n",
    "\n",
    "    # Put it all together\n",
    "    agg = pd.concat(cols, axis=1)\n",
    "    agg.columns = names\n",
    "\n",
    "    # Remove the forecasted sequence for other variables, keep only for the target variable\n",
    "    agg = agg[[col for col in agg if target_col_name in col or '(t)' not in col]]\n",
    "\n",
    "    # Drop rows with NaN values\n",
    "    if dropnan:\n",
    "        agg.dropna(inplace=True)\n",
    "\n",
    "    return agg\n",
    "\n",
    "values = dataset.values\n",
    "scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "scaled = scaler.fit_transform(values)\n",
    "df_scaled = pd.DataFrame(scaled, columns=dataset.columns)\n",
    "target_scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "target_scaled = target_scaler.fit_transform(dataset[['Solar Radiation(GHI)']])\n",
    "reframed = series_to_supervised(df_scaled, 'Solar Radiation(GHI)', 3, 1)\n",
    "values = reframed.values\n",
    "n_train_hours = 876 * 24\n",
    "train = values[:n_train_hours, :]\n",
    "test = values[n_train_hours:, :]\n",
    "train_X, train_y = train[:, :-1], train[:, -1]\n",
    "test_X, test_y = test[:, :-1], test[:, -1]\n",
    "train_X, train_y = torch.tensor(train_X).float(), torch.tensor(train_y).view(-1, 1).float()\n",
    "test_X, test_y = torch.tensor(test_X).float(), torch.tensor(test_y).view(-1, 1).float()\n",
    "\n",
    "# Define the LSTM model\n",
    "class LSTMNetwork(nn.Module):\n",
    "    def __init__(self, input_dim, neurons, layers1, activation, dropout_rate):\n",
    "        super(LSTMNetwork, self).__init__()\n",
    "        self.lstm = nn.LSTM(18, neurons, batch_first=True)\n",
    "        self.layers = nn.ModuleList()\n",
    "        self.layers.append(nn.Linear(neurons, neurons))\n",
    "        self.layers.append(getattr(nn, activation)())\n",
    "        for _ in range(layers1 - 1):\n",
    "            self.layers.append(nn.Linear(neurons, neurons))\n",
    "            self.layers.append(getattr(nn, activation)())\n",
    "            if dropout_rate > 0:\n",
    "                self.layers.append(nn.Dropout(p=dropout_rate))\n",
    "        self.output_layer = nn.Linear(neurons, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x, _ = self.lstm(x)\n",
    "        x = x[:, -1, :]  # get the last output of the sequence\n",
    "        for layer in self.layers:\n",
    "            x = layer(x)\n",
    "        x = self.output_layer(x)\n",
    "        return x\n",
    "\n",
    "# Function to count the trainable parameters\n",
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "# Parameters\n",
    "activation = 'ReLU'\n",
    "batch_size = 64\n",
    "dropout_rate = 0.05\n",
    "epochs = 60\n",
    "layers1 = 2\n",
    "learning_rate = 0.001\n",
    "neurons = 32\n",
    "#input_dim = train_X.shape[2]  # Updated for LSTM input\n",
    "\n",
    "# Prepare the data\n",
    "train_X = train_X.reshape((train_X.shape[0], 1, train_X.shape[1]))\n",
    "test_X = test_X.reshape((test_X.shape[0], 1, test_X.shape[1]))\n",
    "\n",
    "train_dataset = TensorDataset(train_X, train_y)\n",
    "test_dataset = TensorDataset(test_X, test_y)\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "# Initialize the model, loss function, and optimizer\n",
    "model = LSTMNetwork(input_dim, neurons, layers1, activation, dropout_rate)\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "model = model.to(device)\n",
    "\n",
    "# Print trainable parameters\n",
    "print(f\"Trainable parameters: {count_parameters(model)}\")\n",
    "for name, param in model.named_parameters():\n",
    "    if param.requires_grad:\n",
    "        print(f\"{name}: {param.numel()} parameters\")\n",
    "\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
    "\n",
    "# Train the model\n",
    "train_losses = []\n",
    "val_losses = []\n",
    "min_val_loss = float('inf')\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    model.train()\n",
    "    for batch_X, batch_y in train_loader:\n",
    "        batch_X, batch_y = batch_X.to(device), batch_y.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(batch_X)\n",
    "        loss = criterion(outputs, batch_y)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        val_loss = 0\n",
    "        for val_X, val_y in test_loader:\n",
    "            val_X, val_y = val_X.to(device), val_y.to(device)\n",
    "            val_outputs = model(val_X)\n",
    "            val_loss += criterion(val_outputs, val_y).item()\n",
    "    val_loss /= len(test_loader)\n",
    "    train_losses.append(loss.item())\n",
    "    val_losses.append(val_loss)\n",
    "    print(f'Epoch {epoch+1}/{epochs}, Loss: {loss.item():.6f}, Val Loss: {val_loss:.6f}')\n",
    "    if val_loss < min_val_loss:\n",
    "        min_val_loss = val_loss\n",
    "        min_val_loss_nRMSE=np.sqrt(min_val_loss)\n",
    "\n",
    "# Print the minimum validation loss\n",
    "print(f\"Minimum Validation Loss: {min_val_loss:.6f}\")\n",
    "print(f\"Minimum Validation Loss nRMSE: {min_val_loss_nRMSE:.6f}\")\n",
    "# Make predictions\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    train_predictions = model(train_X.to(device)).cpu().numpy()\n",
    "    test_predictions = model(test_X.to(device)).cpu().numpy()\n",
    "\n",
    "# Inverse transform the predictions and actual values\n",
    "train_predict_inv = target_scaler.inverse_transform(train_predictions)\n",
    "test_predict_inv = target_scaler.inverse_transform(test_predictions)\n",
    "train_y_inv = target_scaler.inverse_transform(train_y.cpu().numpy())\n",
    "test_y_inv = target_scaler.inverse_transform(test_y.cpu().numpy())\n",
    "\n",
    "# Print the predicted and actual values for the first 5 items\n",
    "for i in range(5):\n",
    "    print(f'Train - Predicted: {train_predict_inv[i][0]:.6f}, Actual: {train_y_inv[i][0]:.6f}')\n",
    "    print(f'Test - Predicted: {test_predict_inv[i][0]:.6f}, Actual: {test_y_inv[i][0]:.6f}')\n",
    "\n",
    "# Calculate and print the MSE, RMSE, and MAE\n",
    "train_mse = mean_squared_error(train_y_inv, train_predict_inv)\n",
    "test_mse = mean_squared_error(test_y_inv, test_predict_inv)\n",
    "train_rmse = np.sqrt(train_mse)\n",
    "test_rmse = np.sqrt(test_mse)\n",
    "\n",
    "train_mae = mean_absolute_error(train_y_inv, train_predict_inv)\n",
    "test_mae = mean_absolute_error(test_y_inv, test_predict_inv)\n",
    "\n",
    "print(\"Train MSE: {:.6f}\".format(train_mse))\n",
    "print(\"Test MSE: {:.6f}\".format(test_mse))\n",
    "print(\"Train RMSE: {:.6f}\".format(train_rmse))\n",
    "print(\"Test RMSE: {:.6f}\".format(test_rmse))\n",
    "print(\"Train MAE: {:.6f}\".format(train_mae))\n",
    "print(\"Test MAE: {:.6f}\".format(test_mae))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "13e922a5-ff57-4f6c-9b88-607f6da8fade",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LSTMNetwork(\n",
      "  (lstm): LSTM(60, 32, batch_first=True)\n",
      "  (layers): ModuleList(\n",
      "    (0): Linear(in_features=32, out_features=32, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=32, out_features=32, bias=True)\n",
      "    (3): ReLU()\n",
      "    (4): Dropout(p=0.05, inplace=False)\n",
      "  )\n",
      "  (output_layer): Linear(in_features=32, out_features=1, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(model)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}