code/models/lstm.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IYL4t1oy5Hac"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score, roc_curve, auc\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import pandas as pd\n",
        "from itertools import product\n",
        "from sklearn.preprocessing import label_binarize\n",
        "import numpy as np\n",
        "from torch.utils.data import DataLoader, TensorDataset\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.metrics import accuracy_score"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LmXKeSMn8BGM",
        "outputId": "87cadf04-a92c-4aea-e5a7-d7124f2cf9e5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check if GPU is available\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(f\"Using device: {device}\")\n",
        "\n",
        "# Load the data\n",
        "x_train = pd.read_csv(\"/content/drive/MyDrive/models/data/X_train.csv\")\n",
        "x_test = pd.read_csv(\"/content/drive/MyDrive/models/data/X_test.csv\")\n",
        "y_train = pd.read_csv(\"/content/drive/MyDrive/models/data/y_train.csv\")\n",
        "y_test = pd.read_csv(\"/content/drive/MyDrive/models/data/y_test.csv\")"
      ],
      "metadata": {
        "id": "doMTKNVl6Bp1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "66578b54-d325-4248-e872-ccdef0ec0264"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using device: cuda\n",
            "x_train shape: (454904, 30)\n",
            "x_test shape: (113726, 30)\n",
            "y_train shape: (454904, 1)\n",
            "y_test shape: (113726, 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert to numpy arrays\n",
        "x_train_np = x_train.to_numpy()\n",
        "x_test_np = x_test.to_numpy()\n",
        "y_train_np = y_train.to_numpy().squeeze()  # Convert to 1D\n",
        "y_test_np = y_test.to_numpy().squeeze()    # Convert to 1D\n",
        "\n",
        "# Normalize features\n",
        "scaler = StandardScaler()\n",
        "x_train_np = scaler.fit_transform(x_train_np)\n",
        "x_test_np = scaler.transform(x_test_np)\n",
        "\n",
        "# Reshape for LSTM: (num_samples, seq_length, num_features)\n",
        "x_train_np = x_train_np.reshape((x_train_np.shape[0], 1, x_train_np.shape[1]))\n",
        "x_test_np = x_test_np.reshape((x_test_np.shape[0], 1, x_test_np.shape[1]))\n",
        "\n",
        "# Convert numpy arrays to PyTorch tensors\n",
        "x_train_tensor = torch.tensor(x_train_np, dtype=torch.float32).cuda()\n",
        "x_test_tensor = torch.tensor(x_test_np, dtype=torch.float32).cuda()\n",
        "y_train_tensor = torch.tensor(y_train_np, dtype=torch.float32).cuda()\n",
        "y_test_tensor = torch.tensor(y_test_np, dtype=torch.float32).cuda()\n",
        "\n",
        "# Create DataLoader\n",
        "train_dataset = TensorDataset(x_train_tensor, y_train_tensor)\n",
        "test_dataset = TensorDataset(x_test_tensor, y_test_tensor)\n",
        "\n",
        "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)"
      ],
      "metadata": {
        "id": "RcMkVmw5hEWm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Attention(nn.Module):\n",
        "    def __init__(self, hidden_dim):\n",
        "        super(Attention, self).__init__()\n",
        "        self.W = nn.Linear(hidden_dim, hidden_dim)\n",
        "        self.v = nn.Parameter(torch.randn(hidden_dim))\n",
        "\n",
        "    def forward(self, hidden_states):\n",
        "        scores = torch.tanh(self.W(hidden_states))\n",
        "        scores = torch.matmul(scores, self.v.unsqueeze(0).unsqueeze(-1)).squeeze(-1)\n",
        "        attn_weights = torch.softmax(scores, dim=1)\n",
        "        context = torch.bmm(attn_weights.unsqueeze(1), hidden_states).squeeze(1)\n",
        "        return context\n",
        "\n",
        "class LSTMWithAttention(nn.Module):\n",
        "    def __init__(self, input_dim, hidden_dim, output_dim, num_layers=1):\n",
        "        super(LSTMWithAttention, self).__init__()\n",
        "        self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers, batch_first=True)\n",
        "        self.attention = Attention(hidden_dim)\n",
        "        self.fc = nn.Linear(hidden_dim, output_dim)\n",
        "\n",
        "    def forward(self, x):\n",
        "        lstm_out, _ = self.lstm(x)\n",
        "        attn_out = self.attention(lstm_out)\n",
        "        out = self.fc(attn_out)\n",
        "        return out"
      ],
      "metadata": {
        "id": "ESZ2H2dQ5_bN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Model parameters\n",
        "input_dim = x_train_tensor.shape[2]  # Number of features\n",
        "hidden_dim = 128\n",
        "output_dim = 1  # Binary classification\n",
        "num_layers = 1\n",
        "\n",
        "# Initialize the model\n",
        "model = LSTMWithAttention(input_dim, hidden_dim, output_dim, num_layers).cuda()\n",
        "\n",
        "def train_model(model, train_loader, num_epochs=10, learning_rate=0.001):\n",
        "    criterion = nn.BCEWithLogitsLoss()\n",
        "    optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
        "\n",
        "    for epoch in range(num_epochs):\n",
        "        model.train()\n",
        "        running_loss = 0.0\n",
        "        correct = 0\n",
        "        total = 0\n",
        "\n",
        "        for inputs, labels in train_loader:\n",
        "            optimizer.zero_grad()\n",
        "            outputs = model(inputs)\n",
        "            loss = criterion(outputs.squeeze(), labels)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "            running_loss += loss.item() * inputs.size(0)\n",
        "\n",
        "            # Compute predictions and accuracy\n",
        "            predicted = (torch.sigmoid(outputs.squeeze()) > 0.5).float()\n",
        "            correct += (predicted == labels).sum().item()\n",
        "            total += labels.size(0)\n",
        "\n",
        "        epoch_loss = running_loss / len(train_loader.dataset)\n",
        "        epoch_accuracy = correct / total\n",
        "        print(f\"Epoch {epoch + 1}/{num_epochs}, Loss: {epoch_loss:.4f}, Accuracy: {epoch_accuracy:.4f}\")\n",
        "\n",
        "    print(\"Training complete.\")\n",
        "\n",
        "# Training the model\n",
        "train_model(model, train_loader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZMItlEpmh-Yj",
        "outputId": "2075eb3c-300a-40e1-d7bb-e2ee735b5264"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10, Loss: 0.0127, Accuracy: 0.9966\n",
            "Epoch 2/10, Loss: 0.0024, Accuracy: 0.9995\n",
            "Epoch 3/10, Loss: 0.0017, Accuracy: 0.9996\n",
            "Epoch 4/10, Loss: 0.0013, Accuracy: 0.9997\n",
            "Epoch 5/10, Loss: 0.0011, Accuracy: 0.9997\n",
            "Epoch 6/10, Loss: 0.0010, Accuracy: 0.9998\n",
            "Epoch 7/10, Loss: 0.0009, Accuracy: 0.9998\n",
            "Epoch 8/10, Loss: 0.0007, Accuracy: 0.9998\n",
            "Epoch 9/10, Loss: 0.0006, Accuracy: 0.9999\n",
            "Epoch 10/10, Loss: 0.0005, Accuracy: 0.9999\n",
            "Training complete.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.metrics import confusion_matrix, classification_report, roc_curve, auc\n",
        "\n",
        "def evaluate_model(model, test_loader):\n",
        "    model.eval()\n",
        "    all_labels = []\n",
        "    all_preds = []\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for inputs, labels in test_loader:\n",
        "            outputs = model(inputs)\n",
        "            predicted = (torch.sigmoid(outputs.squeeze()) > 0.5).float()\n",
        "            all_labels.extend(labels.cpu().numpy())\n",
        "            all_preds.extend(predicted.cpu().numpy())\n",
        "\n",
        "    all_labels = np.array(all_labels)\n",
        "    all_preds = np.array(all_preds)\n",
        "\n",
        "    # Compute metrics\n",
        "    conf_matrix = confusion_matrix(all_labels, all_preds)\n",
        "    class_report = classification_report(all_labels, all_preds)\n",
        "\n",
        "    # ROC Curve\n",
        "    fpr, tpr, _ = roc_curve(all_labels, all_preds)\n",
        "    roc_auc = auc(fpr, tpr)\n",
        "\n",
        "    # Print confusion matrix and classification report\n",
        "    print(\"Confusion Matrix:\")\n",
        "    print(conf_matrix)\n",
        "    print(\"\\nClassification Report:\")\n",
        "    print(class_report)\n",
        "\n",
        "    # Plot ROC Curve\n",
        "    plt.figure()\n",
        "    plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)\n",
        "    plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n",
        "    plt.xlim([0.0, 1.0])\n",
        "    plt.ylim([0.0, 1.05])\n",
        "    plt.xlabel('False Positive Rate')\n",
        "    plt.ylabel('True Positive Rate')\n",
        "    plt.title('Receiver Operating Characteristic (ROC)')\n",
        "    plt.legend(loc='lower right')\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "PkvBqK7z7Ak7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Evaluating the model\n",
        "evaluate_model(model, test_loader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 715
        },
        "id": "Zkm7kkT3jque",
        "outputId": "2fa40a7c-1ecf-453a-f75d-7fd05e7697bb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Confusion Matrix:\n",
            "[[56851    12]\n",
            " [   23 56840]]\n",
            "\n",
            "Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "         0.0       1.00      1.00      1.00     56863\n",
            "         1.0       1.00      1.00      1.00     56863\n",
            "\n",
            "    accuracy                           1.00    113726\n",
            "   macro avg       1.00      1.00      1.00    113726\n",
            "weighted avg       1.00      1.00      1.00    113726\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Save the model\n",
        "model_path = \"lstm_attention_model.pth\"\n",
        "torch.save(model.state_dict(), model_path)\n",
        "print(f\"Model saved to {model_path}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pVl0jlZtjt89",
        "outputId": "d6fe970e-1468-4e61-ce26-9af7529a533d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model saved to lstm_attention_model.pth\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "RZTZQtX5kCCT"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}