Prediction_models_4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "# data processing\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from datetime import datetime\n",
    "from datetime import timedelta\n",
    "\n",
    "# plotting\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Statistics (correlation)\n",
    "from scipy.stats import pearsonr, spearmanr\n",
    "\n",
    "# libraries for the model\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import Dataset, DataLoader, TensorDataset\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.utils.class_weight import compute_class_weight\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.metrics import f1_score, precision_score, recall_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# custom functions\n",
    "from pt_helpers import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the training data\n",
    "This is the clean data that we processed in the notebook `Training_data_preparation`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = \"DATA/training_data/\"\n",
    "\n",
    "df = pd.read_csv(data_path + \"VEX_edac_mag_labeled.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>DATE_TIME</th>\n",
       "      <th>EDAC</th>\n",
       "      <th>BX</th>\n",
       "      <th>BY</th>\n",
       "      <th>BZ</th>\n",
       "      <th>BT</th>\n",
       "      <th>XSC</th>\n",
       "      <th>YSC</th>\n",
       "      <th>ZSC</th>\n",
       "      <th>RSC</th>\n",
       "      <th>cme</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2006-04-24 00:00:00</td>\n",
       "      <td>0</td>\n",
       "      <td>12.357658</td>\n",
       "      <td>-1.304164</td>\n",
       "      <td>-3.332425</td>\n",
       "      <td>12.881274</td>\n",
       "      <td>-4451.055178</td>\n",
       "      <td>-3196.485753</td>\n",
       "      <td>-65466.762260</td>\n",
       "      <td>65695.760575</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2006-04-24 00:05:00</td>\n",
       "      <td>0</td>\n",
       "      <td>12.868947</td>\n",
       "      <td>-0.980800</td>\n",
       "      <td>-3.360027</td>\n",
       "      <td>13.340680</td>\n",
       "      <td>-4202.246280</td>\n",
       "      <td>-3138.377907</td>\n",
       "      <td>-65806.350827</td>\n",
       "      <td>66015.078600</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2006-04-24 00:10:00</td>\n",
       "      <td>0</td>\n",
       "      <td>12.857438</td>\n",
       "      <td>-0.871986</td>\n",
       "      <td>-3.487877</td>\n",
       "      <td>13.355384</td>\n",
       "      <td>-3954.000329</td>\n",
       "      <td>-3080.233288</td>\n",
       "      <td>-66137.913808</td>\n",
       "      <td>66327.612616</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2006-04-24 00:15:00</td>\n",
       "      <td>0</td>\n",
       "      <td>12.898635</td>\n",
       "      <td>-0.684986</td>\n",
       "      <td>-2.885689</td>\n",
       "      <td>13.248405</td>\n",
       "      <td>-3705.057257</td>\n",
       "      <td>-3021.761270</td>\n",
       "      <td>-66463.291041</td>\n",
       "      <td>66635.079608</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2006-04-24 00:20:00</td>\n",
       "      <td>0</td>\n",
       "      <td>12.766473</td>\n",
       "      <td>-0.517608</td>\n",
       "      <td>-2.217135</td>\n",
       "      <td>12.972905</td>\n",
       "      <td>-3453.676541</td>\n",
       "      <td>-2962.553108</td>\n",
       "      <td>-66784.717784</td>\n",
       "      <td>66939.596338</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             DATE_TIME  EDAC         BX        BY        BZ         BT  \\\n",
       "0  2006-04-24 00:00:00     0  12.357658 -1.304164 -3.332425  12.881274   \n",
       "1  2006-04-24 00:05:00     0  12.868947 -0.980800 -3.360027  13.340680   \n",
       "2  2006-04-24 00:10:00     0  12.857438 -0.871986 -3.487877  13.355384   \n",
       "3  2006-04-24 00:15:00     0  12.898635 -0.684986 -2.885689  13.248405   \n",
       "4  2006-04-24 00:20:00     0  12.766473 -0.517608 -2.217135  12.972905   \n",
       "\n",
       "           XSC          YSC           ZSC           RSC  cme  \n",
       "0 -4451.055178 -3196.485753 -65466.762260  65695.760575    0  \n",
       "1 -4202.246280 -3138.377907 -65806.350827  66015.078600    0  \n",
       "2 -3954.000329 -3080.233288 -66137.913808  66327.612616    0  \n",
       "3 -3705.057257 -3021.761270 -66463.291041  66635.079608    0  \n",
       "4 -3453.676541 -2962.553108 -66784.717784  66939.596338    0  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We separate the feature matrix `X` and the labels `y`.\n",
    "- `X` will contain X Y and Z coordinates of the magnetic field"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = df['cme'].values\n",
    "X = df[['BX', 'BY', 'BZ']].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of y: (893069,)\n",
      "Shape of X: (893069, 3)\n"
     ]
    }
   ],
   "source": [
    "print(\"Shape of y:\", y.shape)\n",
    "print(\"Shape of X:\", X.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_steps = 36  # 3 hours of data\n",
    "X_seq, y_seq = create_sequences(X, y, time_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CMEPredictor(nn.Module):\n",
    "    def __init__(self, n_features, n_hidden=50, n_layers=2):\n",
    "        super(CMEPredictor, self).__init__()\n",
    "        self.lstm = nn.LSTM(input_size=n_features, hidden_size=n_hidden, num_layers=n_layers, batch_first=True)\n",
    "        self.linear = nn.Linear(n_hidden, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x, _ = self.lstm(x)\n",
    "        x = self.linear(x[:, -1, :])\n",
    "        return torch.sigmoid(x)\n",
    "\n",
    "n_features = X_seq.shape[2]  # Number of features in the dataset\n",
    "model = CMEPredictor(n_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(893033, 36, 3)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_seq.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_val, y_train, y_val = train_test_split(X_seq, y_seq, test_size=0.2, random_state=42)\n",
    "\n",
    "# Convert to PyTorch tensors\n",
    "train_data = TensorDataset(torch.tensor(X_train, dtype=torch.float32), torch.tensor(y_train, dtype=torch.float32))\n",
    "val_data = TensorDataset(torch.tensor(X_val, dtype=torch.float32), torch.tensor(y_val, dtype=torch.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create DataLoaders\n",
    "batch_size = 32  # Adjust this based on your system's capability\n",
    "train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)\n",
    "val_loader = DataLoader(val_data, batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCELoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
    "n_epochs = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training and evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1, Loss: 0.027205409482121468, Val Loss: 0.05169392659492218\n",
      "Epoch 2, Loss: 0.01583762839436531, Val Loss: 0.044151000564042656\n",
      "Epoch 3, Loss: 0.0022829226218163967, Val Loss: 0.03417239301476847\n",
      "Epoch 4, Loss: 0.020978279411792755, Val Loss: 0.028188733547968577\n",
      "Epoch 5, Loss: 0.0016961646033450961, Val Loss: 0.02534894986760983\n",
      "Epoch 6, Loss: 0.0021002606954425573, Val Loss: 0.020588622067348433\n",
      "Epoch 7, Loss: 0.0007419955218210816, Val Loss: 0.01946681995389429\n",
      "Epoch 8, Loss: 0.0033761681988835335, Val Loss: 0.017162688995538078\n",
      "Epoch 9, Loss: 0.00022286208695732057, Val Loss: 0.013975792310095582\n",
      "Epoch 10, Loss: 0.0004701327416114509, Val Loss: 0.011868051151635613\n"
     ]
    }
   ],
   "source": [
    "# Training loop with reduced batch size and data loading on-the-fly\n",
    "for epoch in range(n_epochs):\n",
    "    model.train()\n",
    "    for X_batch, y_batch in train_loader:\n",
    "        optimizer.zero_grad()\n",
    "        output = model(X_batch)\n",
    "        loss = criterion(output, y_batch.view(-1, 1))\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "    # Validation\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        val_loss = 0\n",
    "        for X_batch, y_batch in val_loader:\n",
    "            val_output = model(X_batch)\n",
    "            val_loss += criterion(val_output, y_batch.view(-1, 1)).item()\n",
    "    val_loss /= len(val_loader)\n",
    "    \n",
    "    print(f'Epoch {epoch+1}, Loss: {loss.item()}, Val Loss: {val_loss}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9960415885155677\n",
      "F1 Score: 0.8830438378825476\n",
      "Precision: 0.9146675805346127\n",
      "Recall: 0.8535337384074193\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "predictions = []\n",
    "true_labels = []\n",
    "with torch.no_grad():\n",
    "    for X_batch, y_batch in val_loader:\n",
    "        outputs = model(X_batch)\n",
    "        predicted = (outputs > 0.5).float()  # Using 0.5 as the threshold for binary classification\n",
    "        predictions.extend(predicted.view(-1).tolist())\n",
    "        true_labels.extend(y_batch.tolist())\n",
    "\n",
    "# Calculate metrics\n",
    "accuracy = accuracy_score(true_labels, predictions)\n",
    "f1 = f1_score(true_labels, predictions)\n",
    "precision = precision_score(true_labels, predictions)\n",
    "recall = recall_score(true_labels, predictions)\n",
    "\n",
    "print(f'Accuracy: {accuracy}')\n",
    "print(f'F1 Score: {f1}')\n",
    "print(f'Precision: {precision}')\n",
    "print(f'Recall: {recall}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LSTM with class weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_weights = compute_class_weight(class_weight='balanced', classes=np.unique(y_train), y=y_train)\n",
    "class_weights = torch.tensor(class_weights, dtype=torch.float32)\n",
    "\n",
    "# Use the class weights in your loss function\n",
    "criterion = nn.BCELoss(weight=class_weights[1])  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1, Loss: 0.016685394570231438, Val Loss: 0.31954262459213756\n",
      "Epoch 2, Loss: 0.01373108197003603, Val Loss: 0.27624625025029853\n",
      "Epoch 3, Loss: 0.02301291562616825, Val Loss: 0.2396752243539735\n",
      "Epoch 4, Loss: 0.12997180223464966, Val Loss: 0.28266959688653237\n",
      "Epoch 5, Loss: 0.0013374778209254146, Val Loss: 0.23060823440533634\n",
      "Epoch 6, Loss: 0.4464322328567505, Val Loss: 0.2102536807217629\n",
      "Epoch 7, Loss: 0.00554665457457304, Val Loss: 0.19836650296054145\n",
      "Epoch 8, Loss: 0.7542791962623596, Val Loss: 0.22506573631425825\n",
      "Epoch 9, Loss: 0.03719411790370941, Val Loss: 0.23387905123019448\n",
      "Epoch 10, Loss: 0.051757436245679855, Val Loss: 0.18090363184466993\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(n_epochs):\n",
    "    model.train()\n",
    "    for X_batch, y_batch in train_loader:\n",
    "        optimizer.zero_grad()\n",
    "        output = model(X_batch)\n",
    "        loss = criterion(output, y_batch.view(-1, 1))\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # Validation\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        val_loss = 0\n",
    "        for X_batch, y_batch in val_loader:\n",
    "            val_output = model(X_batch)\n",
    "            val_loss += criterion(val_output, y_batch.view(-1, 1)).item()\n",
    "    val_loss /= len(val_loader)\n",
    "    \n",
    "    print(f'Epoch {epoch+1}, Loss: {loss.item()}, Val Loss: {val_loss}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.997990000391922\n",
      "F1 Score: 0.9415214204267797\n",
      "Precision: 0.9594953519256308\n",
      "Recall: 0.9242085065558043\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "predictions = []\n",
    "true_labels = []\n",
    "with torch.no_grad():\n",
    "    for X_batch, y_batch in val_loader:\n",
    "        outputs = model(X_batch)\n",
    "        predicted = (outputs > 0.5).float()  # Using 0.5 as the threshold for binary classification\n",
    "        predictions.extend(predicted.view(-1).tolist())\n",
    "        true_labels.extend(y_batch.tolist())\n",
    "\n",
    "# Calculate metrics\n",
    "accuracy = accuracy_score(true_labels, predictions)\n",
    "f1 = f1_score(true_labels, predictions)\n",
    "precision = precision_score(true_labels, predictions)\n",
    "recall = recall_score(true_labels, predictions)\n",
    "\n",
    "print(f'Accuracy: {accuracy}')\n",
    "print(f'F1 Score: {f1}')\n",
    "print(f'Precision: {precision}')\n",
    "print(f'Recall: {recall}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}