code/models/lstm_fgsa.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# LSTM with Attention on FGSA Dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Imports and Loading Data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Laf1vf7gkUcB"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from torch.utils.data import DataLoader, TensorDataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_UfUg9kSllrl"
      },
      "outputs": [],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "opEBeEDXlhLk",
        "outputId": "e2c65312-407a-4c8f-949e-4bbac5dff87a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Using device: cuda\n"
          ]
        }
      ],
      "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 adversarial data\n",
        "adv_train = pd.read_csv(\"/content/drive/MyDrive/models/data/adversarial_train_samples.csv\")\n",
        "adv_test = pd.read_csv(\"/content/drive/MyDrive/models/data/adversarial_test_samples.csv\")\n",
        "\n",
        "# Assuming the last column is the label and the rest are features\n",
        "x_train_adv = adv_train.iloc[:, :-1].values  # Features\n",
        "y_train_adv = adv_train.iloc[:, -1].values   # Labels\n",
        "x_test_adv = adv_test.iloc[:, :-1].values    # Features\n",
        "y_test_adv = adv_test.iloc[:, -1].values     # Labels"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "r0Cp1gdnlxaI"
      },
      "outputs": [],
      "source": [
        "# Normalize features\n",
        "scaler = StandardScaler()\n",
        "x_train_adv = scaler.fit_transform(x_train_adv)\n",
        "x_test_adv = scaler.transform(x_test_adv)\n",
        "\n",
        "# Reshape for LSTM: (num_samples, seq_length, num_features)\n",
        "x_train_adv = x_train_adv.reshape((x_train_adv.shape[0], 1, x_train_adv.shape[1]))\n",
        "x_test_adv = x_test_adv.reshape((x_test_adv.shape[0], 1, x_test_adv.shape[1]))\n",
        "\n",
        "# Convert numpy arrays to PyTorch tensors\n",
        "x_train_adv_tensor = torch.tensor(x_train_adv, dtype=torch.float32).to(device)\n",
        "x_test_adv_tensor = torch.tensor(x_test_adv, dtype=torch.float32).to(device)\n",
        "y_train_adv_tensor = torch.tensor(y_train_adv, dtype=torch.float32).to(device)\n",
        "y_test_adv_tensor = torch.tensor(y_test_adv, dtype=torch.float32).to(device)\n",
        "\n",
        "# Create DataLoader for adversarial data\n",
        "train_adv_dataset = TensorDataset(x_train_adv_tensor, y_train_adv_tensor)\n",
        "test_adv_dataset = TensorDataset(x_test_adv_tensor, y_test_adv_tensor)\n",
        "\n",
        "train_adv_loader = DataLoader(train_adv_dataset, batch_size=64, shuffle=True)\n",
        "test_adv_loader = DataLoader(test_adv_dataset, batch_size=64, shuffle=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Defining LSTM with Attention"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "I20EYA-klxyd"
      },
      "outputs": [],
      "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"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Training Model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UAmxQHr5l9Dd",
        "outputId": "ac64daa0-97eb-4628-998c-1419e2fdce88"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/10, Loss: 0.0137, Accuracy: 0.9960\n",
            "Epoch 2/10, Loss: 0.0020, Accuracy: 0.9994\n",
            "Epoch 3/10, Loss: 0.0011, Accuracy: 0.9997\n",
            "Epoch 4/10, Loss: 0.0008, Accuracy: 0.9998\n",
            "Epoch 5/10, Loss: 0.0005, Accuracy: 0.9999\n",
            "Epoch 6/10, Loss: 0.0003, Accuracy: 0.9999\n",
            "Epoch 7/10, Loss: 0.0002, Accuracy: 0.9999\n",
            "Epoch 8/10, Loss: 0.0002, Accuracy: 1.0000\n",
            "Epoch 9/10, Loss: 0.0001, Accuracy: 1.0000\n",
            "Epoch 10/10, Loss: 0.0001, Accuracy: 1.0000\n",
            "Training complete.\n"
          ]
        }
      ],
      "source": [
        "# Model parameters\n",
        "input_dim = x_train_adv_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).to(device)\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 on adversarial data\n",
        "train_model(model, train_adv_loader)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Evaluating Model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 715
        },
        "id": "2ZRg1phxmA2M",
        "outputId": "950ac748-a341-4b40-82e4-5c06df8545cd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Confusion Matrix:\n",
            "[[56852    11]\n",
            " [    8 56855]]\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"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "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()\n",
        "\n",
        "# Use the evaluate_model function with adversarial test data\n",
        "evaluate_model(model, test_adv_loader)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hBvthMYbmd7h",
        "outputId": "925c8bd6-208a-4e1c-bde9-232874e65fc2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model saved to adv_lstm_attention_model.pth\n"
          ]
        }
      ],
      "source": [
        "# Save the model\n",
        "model_path = \"adv_lstm_attention_model.pth\"\n",
        "torch.save(model.state_dict(), model_path)\n",
        "print(f\"Model saved to {model_path}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kLbenoIQn1Ck"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.11.0 ('base')",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.11.0"
    },
    "vscode": {
      "interpreter": {
        "hash": "40d3a090f54c6569ab1632332b64b2c03c39dcf918b08424e98f38b5ae0af88f"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}