type.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T14:39:08.709082Z",
          "iopub.status.busy": "2024-02-06T14:39:08.708773Z",
          "iopub.status.idle": "2024-02-06T14:39:12.686144Z",
          "shell.execute_reply": "2024-02-06T14:39:12.684832Z",
          "shell.execute_reply.started": "2024-02-06T14:39:08.709056Z"
        },
        "id": "LnC_d-NoXcmK",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import os\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "import time\n",
        "\n",
        "import torch\n",
        "from torch.utils.data import DataLoader\n",
        "import torch.utils.data as data_utils\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import os\n",
        "\n",
        "import pandas as pd\n",
        "from sklearn import preprocessing\n",
        "from sklearn.metrics import f1_score\n",
        "import torch\n",
        "from torch.utils.data import Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T14:39:12.688265Z",
          "iopub.status.busy": "2024-02-06T14:39:12.687775Z",
          "iopub.status.idle": "2024-02-06T14:39:12.982503Z",
          "shell.execute_reply": "2024-02-06T14:39:12.981495Z",
          "shell.execute_reply.started": "2024-02-06T14:39:12.688232Z"
        },
        "id": "j_mc6gogXcmL",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import pandas as pd\n",
        "\n",
        "# Set the path to the directory containing the datasets\n",
        "dataset_path = '/kaggle/input/fault-detection'\n",
        "\n",
        "# Get the list of files in the directory\n",
        "files = os.listdir(dataset_path)\n",
        "\n",
        "# Initialize an empty list to store DataFrames\n",
        "dfs = []\n",
        "\n",
        "# Loop through the files and read them into DataFrames\n",
        "for file in files[:3]:  # Assuming you want to read the first 15 datasets\n",
        "    file_path = os.path.join(dataset_path, file)\n",
        "    df= pd.read_csv(file_path)\n",
        "    # df['class'] = 'faultySignal'  # Change the file reading method based on your file format\n",
        "    dfs.append(df)\n",
        "\n",
        "# Concatenate all DataFrames into one\n",
        "final_df = pd.concat(dfs, ignore_index=True)\n",
        "\n",
        "final_df\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T14:39:12.983775Z",
          "iopub.status.busy": "2024-02-06T14:39:12.983511Z",
          "iopub.status.idle": "2024-02-06T14:39:13.584829Z",
          "shell.execute_reply": "2024-02-06T14:39:13.583854Z",
          "shell.execute_reply.started": "2024-02-06T14:39:12.983748Z"
        },
        "id": "pxxI8nQJXcmL",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "final_df.to_csv('new_data.csv', index=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T14:39:13.586872Z",
          "iopub.status.busy": "2024-02-06T14:39:13.586569Z",
          "iopub.status.idle": "2024-02-06T14:39:13.598217Z",
          "shell.execute_reply": "2024-02-06T14:39:13.596465Z",
          "shell.execute_reply.started": "2024-02-06T14:39:13.586845Z"
        },
        "id": "vgaZp2G5XcmL",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# Path of the dataset\n",
        "datasetPath = '/content/drive/MyDrive/Dataset.csv'\n",
        "\n",
        "# Path of the model (saved/to save)\n",
        "modelPath = '/content/new-RNN (3).pth'\n",
        "\n",
        "# When True, retrain the whole model\n",
        "retrain = False\n",
        "\n",
        "# Size of the split\n",
        "trainSize = 0.85\n",
        "valSize = 0.05\n",
        "testSize = 0.1\n",
        "\n",
        "# Specify number of seconds for the window. Default: 16\n",
        "window_size = 16\n",
        "\n",
        "# Model hyper-parameters\n",
        "batch_size = 32\n",
        "learning_rate = 1e-3\n",
        "num_epochs = 80\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "# Seed for reproducibility\n",
        "seed = 42\n",
        "torch.manual_seed(seed)\n",
        "\n",
        "# When True create graphs (takes more time)\n",
        "makeGraphs = False"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T14:39:14.691594Z",
          "iopub.status.busy": "2024-02-06T14:39:14.691269Z",
          "iopub.status.idle": "2024-02-06T14:39:14.698306Z",
          "shell.execute_reply": "2024-02-06T14:39:14.696940Z",
          "shell.execute_reply.started": "2024-02-06T14:39:14.691566Z"
        },
        "id": "Y5xf_AusXcmM",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "classes_to_drop=['faultLabel']\n",
        "target_classes = final_df[['faultLabel']]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T14:39:17.667151Z",
          "iopub.status.busy": "2024-02-06T14:39:17.666844Z",
          "iopub.status.idle": "2024-02-06T14:39:17.684219Z",
          "shell.execute_reply": "2024-02-06T14:39:17.683181Z",
          "shell.execute_reply.started": "2024-02-06T14:39:17.667126Z"
        },
        "id": "_9qgcJIIXcmM",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "def min_max_norm(self,col):\n",
        "    self._data[col]=(self._data[col]-self._data[col].min())/(self._data[col].max()-self._data[col].min())\n",
        "\n",
        "\n",
        "def std_scaler(self,col):\n",
        "    self._data[col]=(self._data[col]-self._data[col].mean())/(self._data[col].std())\n",
        "\n",
        "def f1(test_loader, model):\n",
        "    f1 = 0\n",
        "    with torch.no_grad():\n",
        "        for i, (data, labels) in enumerate(test_loader):\n",
        "            outputs = model(data)\n",
        "            pred = outputs.data.max(1, keepdim=True)[1]\n",
        "            f1 += f1_score(labels, pred, average='macro')\n",
        "    avg_f1 = f1/len(test_loader)\n",
        "    return (avg_f1)\n",
        "\n",
        "\n",
        "class CustomDataset(Dataset):\n",
        "    def __init__(self, file_path='/kaggle/working/new_data.csv', classes_to_drop=classes_to_drop, window_size=window_size, normalize=True, normalize_method='mean_std'):\n",
        "\n",
        "\n",
        "        self._window_size=window_size\n",
        "        self._data=pd.read_csv(file_path)\n",
        "\n",
        "        # The data is sorted by Class A,B,C the indexes of the dataframe have restarted by ignore index\n",
        "        self._data = self._data.sort_values(by=['faultLabel'], inplace=False,ignore_index = True)\n",
        "\n",
        "        # class_uniq contains the letters of the drivers A,B and it loops across all of them\n",
        "        for class_uniq in list(self._data['faultLabel'].unique()):\n",
        "            # Find the total number of elements belonging to a class\n",
        "            tot_number=sum(self._data['faultLabel']==class_uniq)\n",
        "            # Number of elements to drop so that the class element is divisible by window size\n",
        "            to_drop=tot_number%window_size\n",
        "            # Returns the index of the first element of the class\n",
        "            index_to_start_removing=self._data[self._data['faultLabel']==class_uniq].index[0]\n",
        "            # Drop element from first element to the element required\n",
        "            self._data.drop(self._data.index[index_to_start_removing:index_to_start_removing+to_drop],inplace=True)\n",
        "\n",
        "\n",
        "        # Resetting index of dataframe after dropping values\n",
        "        self._data = self._data.reset_index()\n",
        "        self._data = self._data.drop(['index'], axis=1)\n",
        "\n",
        "        index_starting_class=[] # This array contains the starting index of each class in the df\n",
        "        for class_uniq in list(self._data['faultLabel'].unique()):\n",
        "            # Appending the index of first element of each clas\n",
        "            index_starting_class.append(self._data[self._data['faultLabel']==class_uniq].index[0])\n",
        "\n",
        "        # Create the sequence of indexs of the windows\n",
        "        sequences=[]\n",
        "        for i in range(len(index_starting_class)):\n",
        "            # Check if beginning of next class is there\n",
        "            if i!=len(index_starting_class)-1:\n",
        "                ranges=np.arange(index_starting_class[i], index_starting_class[i+1])\n",
        "            else:\n",
        "                ranges = np.arange(index_starting_class[i], len(self._data))\n",
        "            for j in range(0,len(ranges),int(self._window_size/2)):\n",
        "                if len(ranges[j:j+self._window_size])==16:\n",
        "                    sequences.append(ranges[j:j+self._window_size])\n",
        "        self._sequences=sequences\n",
        "\n",
        "\n",
        "        # Take only the 'Class' which are the actual labels and store it in the labels of self\n",
        "        self._labels=self._data['faultLabel']\n",
        "        # Dropping columns which have constant measurements because they would return nan in std\n",
        "        self._data.drop(classes_to_drop, inplace=True, axis=1)\n",
        "\n",
        "        # Function to normalize the data either with min_max or mean_std\n",
        "        if normalize:\n",
        "            for col in self._data.columns:\n",
        "                if normalize_method=='min_max':\n",
        "                    min_max_norm(self,col)\n",
        "                elif normalize_method==\"mean_std\":\n",
        "                    std_scaler(self,col)\n",
        "\n",
        "        # Create the array holding the windowed multidimensional arrays\n",
        "        X=np.empty((len(sequences), self._window_size, len(self._data.columns)))\n",
        "        y=[]\n",
        "\n",
        "        for n_row, sequence in enumerate(sequences):\n",
        "            X[n_row,:,:]=self._data.iloc[sequence]\n",
        "            # The corresponding driver of the sequence is the driver at first sequence\n",
        "            y.append(self._labels[sequence[0]])\n",
        "\n",
        "\n",
        "        assert len(y)==len(X)\n",
        "        #Assing the windowed dataset to the X of self\n",
        "        self._X= X\n",
        "\n",
        "        # Targets is a transformed version of y with drivers are encoded into 0 to 9\n",
        "        targets = preprocessing.LabelEncoder().fit_transform(y)\n",
        "        targets = torch.as_tensor(targets)  # Just converting it to a pytorch tensor\n",
        "        self._y=targets # Assign it to y of self\n",
        "\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self._X)\n",
        "\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        return torch.FloatTensor(self._X[index,:,:]), self._y[index]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T14:39:20.538183Z",
          "iopub.status.busy": "2024-02-06T14:39:20.537657Z",
          "iopub.status.idle": "2024-02-06T14:39:20.543785Z",
          "shell.execute_reply": "2024-02-06T14:39:20.542958Z",
          "shell.execute_reply.started": "2024-02-06T14:39:20.538151Z"
        },
        "id": "hv9dSP2VXcmM",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "np.random.seed(seed)\n",
        "torch.manual_seed(seed)\n",
        "torch.cuda.manual_seed(seed)\n",
        "torch.cuda.manual_seed_all(seed)\n",
        "torch.backends.cudnn.deterministic = True\n",
        "torch.backends.cudnn.benchmark = True\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T14:39:22.104609Z",
          "iopub.status.busy": "2024-02-06T14:39:22.104190Z",
          "iopub.status.idle": "2024-02-06T14:39:23.414945Z",
          "shell.execute_reply": "2024-02-06T14:39:23.414212Z",
          "shell.execute_reply.started": "2024-02-06T14:39:22.104576Z"
        },
        "id": "OISLmulqXcmM",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "a = CustomDataset()\n",
        "\n",
        "# Defining sizes\n",
        "train_size = int(trainSize * len(a))\n",
        "val_size = int(valSize * len(a))\n",
        "test_size = len(a)-train_size-val_size\n",
        "\n",
        "train_dataset, val_dataset, test_dataset = torch.utils.data.random_split(\n",
        "    a, [train_size, val_size, test_size])\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(dataset=train_dataset,\n",
        "                                           batch_size=4,\n",
        "                                           shuffle=True,\n",
        "                                           drop_last=True)\n",
        "\n",
        "validation_loader = torch.utils.data.DataLoader(dataset=val_dataset,\n",
        "                                                batch_size=4,\n",
        "                                                shuffle=False,\n",
        "                                                drop_last=True)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(dataset=test_dataset,\n",
        "                                          batch_size=4,\n",
        "                                          shuffle=False,drop_last=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "k8VJPNn0XcmN",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "final_df.drop(classes_to_drop,inplace=True, axis=1)\n",
        "final_df"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T14:39:28.513138Z",
          "iopub.status.busy": "2024-02-06T14:39:28.512762Z",
          "iopub.status.idle": "2024-02-06T14:39:28.546632Z",
          "shell.execute_reply": "2024-02-06T14:39:28.545816Z",
          "shell.execute_reply.started": "2024-02-06T14:39:28.513103Z"
        },
        "id": "WPNsfR4UXcmN",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "scaler = StandardScaler()\n",
        "\n",
        "# Apply the scaler to your DataFrame\n",
        "normalized_data = scaler.fit_transform(final_df)\n",
        "\n",
        "# Create a new DataFrame with the normalized data\n",
        "normalized_df = pd.DataFrame(normalized_data, columns=final_df.columns)\n",
        "\n",
        "normalized_df"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rz4CkCWZXcmN",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "result_df = pd.concat([normalized_df, target_classes], axis=1)\n",
        "result_df"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eeytTwTZXcmN",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "from sklearn.preprocessing import LabelEncoder\n",
        "\n",
        "encoder = LabelEncoder()\n",
        "result_df['faultLabel'] = encoder.fit_transform(result_df['faultLabel'])\n",
        "\n",
        "# Retrieve the mapping of numerical codes to original class labels\n",
        "class_labels = encoder.classes_\n",
        "\n",
        "# Display the mapping\n",
        "for code, label in enumerate(class_labels):\n",
        "    print(f'Code: {code} -> Label: {label}')\n",
        "result_df"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qTbMMCXKXcmO",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "\n",
        "X = result_df.drop('faultLabel',axis=1)\n",
        "y = result_df['faultLabel']\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.1,random_state=42)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T15:17:32.317518Z",
          "iopub.status.busy": "2024-02-06T15:17:32.317173Z",
          "iopub.status.idle": "2024-02-06T15:17:37.401159Z",
          "shell.execute_reply": "2024-02-06T15:17:37.400201Z",
          "shell.execute_reply.started": "2024-02-06T15:17:32.317488Z"
        },
        "id": "vVHmEF3cXcmO",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "from xgboost import XGBClassifier\n",
        "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "\n",
        "# Create and train an XGBoost classification model\n",
        "model = XGBClassifier(objective='multi:softmax', random_state=42)  # You may need to adjust the objective based on your problem\n",
        "model.fit(X_train, y_train)\n",
        "\n",
        "# Make predictions on the test data\n",
        "y_pred = model.predict(X_test)\n",
        "\n",
        "# Evaluate model performance\n",
        "accuracy = accuracy_score(y_test, y_pred)\n",
        "conf_matrix = confusion_matrix(y_test, y_pred)\n",
        "class_report = classification_report(y_test, y_pred)\n",
        "\n",
        "print(f\"Accuracy: {accuracy:.2f}\")\n",
        "print(f\"Confusion Matrix:\\n{conf_matrix}\")\n",
        "print(f\"Classification Report:\\n{class_report}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T15:18:05.073141Z",
          "iopub.status.busy": "2024-02-06T15:18:05.072787Z",
          "iopub.status.idle": "2024-02-06T15:18:12.806173Z",
          "shell.execute_reply": "2024-02-06T15:18:12.805194Z",
          "shell.execute_reply.started": "2024-02-06T15:18:05.073110Z"
        },
        "id": "T9USETm7XcmP",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "# Create and train a Random Forest classification model\n",
        "model1 = RandomForestClassifier(n_estimators=100, random_state=42)  # You can adjust the number of trees (n_estimators) as needed\n",
        "model1.fit(X_train, y_train)\n",
        "\n",
        "# Make predictions on the test data\n",
        "y_pred = model1.predict(X_test)\n",
        "\n",
        "# Evaluate model performance\n",
        "accuracy = accuracy_score(y_test, y_pred)\n",
        "conf_matrix = confusion_matrix(y_test, y_pred)\n",
        "class_report = classification_report(y_test, y_pred)\n",
        "\n",
        "print(f\"Accuracy: {accuracy:.2f}\")\n",
        "print(f\"Confusion Matrix:\\n{conf_matrix}\")\n",
        "print(f\"Classification Report:\\n{class_report}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T15:18:35.291441Z",
          "iopub.status.busy": "2024-02-06T15:18:35.291088Z",
          "iopub.status.idle": "2024-02-06T15:18:36.291105Z",
          "shell.execute_reply": "2024-02-06T15:18:36.290111Z",
          "shell.execute_reply.started": "2024-02-06T15:18:35.291397Z"
        },
        "id": "w97BI9pQXcmP",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "from sklearn.tree import DecisionTreeClassifier\n",
        "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n",
        "\n",
        "\n",
        "# Create and train a Decision Tree classification model\n",
        "model3 = DecisionTreeClassifier(max_depth=None, random_state=42)  # You can adjust max_depth as needed\n",
        "model3.fit(X_train, y_train)\n",
        "\n",
        "# Make predictions on the test data\n",
        "y_pred = model3.predict(X_test)\n",
        "\n",
        "# Evaluate model performance\n",
        "accuracy = accuracy_score(y_test, y_pred)\n",
        "conf_matrix = confusion_matrix(y_test, y_pred)\n",
        "class_report = classification_report(y_test, y_pred)\n",
        "\n",
        "print(f\"Accuracy: {accuracy:.2f}\")\n",
        "print(f\"Confusion Matrix:\\n{conf_matrix}\")\n",
        "print(f\"Classification Report:\\n{class_report}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "# Set seeds for reproducibility\n",
        "seed_value = 42\n",
        "np.random.seed(seed_value)\n",
        "tf.random.set_seed(seed_value)\n",
        "model = Sequential()\n",
        "#model.add(Dense(int((len(data[1])*2)), activation='relu', input_shape=(48, ))\n",
        "#model.add(Dense(y_train_encoded.shape[1]), activation='softmax', kernel_initializer=GlorotNormal())\n",
        "\n",
        "model.add(Dense(64, activation='relu', input_shape=(X_train.shape[1],), kernel_initializer=GlorotNormal()))\n",
        "#model.add(Dropout(0.2))\n",
        "model.add(Dense(32, activation='relu', kernel_regularizer=L2())) #kernel_initializer=GlorotNormal()\n",
        "model.add(Dropout(0.2))\n",
        "#model.add(Dense(16, activation='relu', kernel_regularizer=L2())) #kernel_initializer=GlorotNormal()\n",
        "#model.add(Dropout(0.2))\n",
        "model.add(Dense(11, activation='softmax', kernel_initializer=GlorotNormal()))\n",
        "model.summary()\n",
        "\n",
        "model.compile(optimizer=Adam(learning_rate=1e-3),\n",
        "              loss='categorical_crossentropy',\n",
        "              metrics=['accuracy'])\n",
        "\n",
        "model.fit(X_train, y_train_encoded, epochs=500, batch_size=32, validation_split = 0.1)"
      ],
      "metadata": {
        "id": "uYpS_zZHkgCF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "res_type = model.evaluate(X_test, y_test_encoded)[1]\n",
        "print(res_type)"
      ],
      "metadata": {
        "id": "hL0u0VCgk4B0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def fgsm_attack(model, input_data, epsilon):\n",
        "    with tf.GradientTape() as tape:\n",
        "        tape.watch(input_data)\n",
        "        predictions = model(input_data)\n",
        "        loss = tf.keras.losses.categorical_crossentropy(y_test_encoded, predictions)\n",
        "\n",
        "    # Get the gradients of the loss w.r.t. the input data\n",
        "    gradient = tape.gradient(loss, input_data)\n",
        "    # Get the sign of the gradients\n",
        "    signed_grad = tf.sign(gradient)\n",
        "    # Perturb the input data\n",
        "    perturbed_data = input_data + epsilon * signed_grad\n",
        "    # Clip the perturbed data to ensure it stays within the valid range\n",
        "    perturbed_data = tf.clip_by_value(perturbed_data, 0, 1)\n",
        "    return perturbed_data\n",
        "\n",
        "# Define parameters for the FGSM attack\n",
        "epsilon = 0.5\n",
        "\n",
        "# Convert X_train DataFrame to a TensorFlow tensor\n",
        "X_train_tensor = tf.constant(X_train.values, dtype=tf.float32)\n",
        "X_test_tensor = tf.constant(X_test.values, dtype=tf.float32)\n",
        "# Generate adversarial examples using FGSM\n",
        "adversarial_X_test = fgsm_attack(model, X_test_tensor, epsilon)\n",
        "\n",
        "# Evaluate the model on adversarial examples\n",
        "model.evaluate(adversarial_X_test, y_test_encoded)"
      ],
      "metadata": {
        "id": "4rvQAGOEk6ux"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Given ASR values for two sets\n",
        "asr_values_set1 = [0.793,0.333, 0.259, 0.206, 0.21, 0.147, 0.136, 0.127, 0.124, 0.124, 0.122]\n",
        "\n",
        "# Create a list of feature numbers starting from one\n",
        "feature_numbers = [0,0.05,0.1,0.15,0.20,0.25,0.30,0.35,0.40,0.45,0.50]\n",
        "\n",
        "# Plotting the graphs\n",
        "plt.ylim(0, 1.0)\n",
        "plt.plot(feature_numbers, asr_values_set1, marker='o', linestyle='-', color='b', label='fgsm')\n",
        "# Adding legend\n",
        "plt.legend()\n",
        "plt.xlabel('epsilon')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.title('Accuracy vs epsilon')\n",
        "plt.grid(True)\n",
        "plt.tight_layout()\n",
        "plt.savefig('/kaggle/working/model_reimplemented.pdf', format='pdf')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "dvugcRHuqmWP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "im-EB2XTXsNx"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "np.random.seed(seed)\n",
        "torch.manual_seed(seed)\n",
        "torch.cuda.manual_seed(seed)\n",
        "torch.cuda.manual_seed_all(seed)\n",
        "torch.backends.cudnn.deterministic = True\n",
        "torch.backends.cudnn.benchmark = True\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T12:49:21.295235Z",
          "iopub.status.busy": "2024-02-06T12:49:21.294292Z",
          "iopub.status.idle": "2024-02-06T12:49:21.307898Z",
          "shell.execute_reply": "2024-02-06T12:49:21.307107Z",
          "shell.execute_reply.started": "2024-02-06T12:49:21.295197Z"
        },
        "id": "Js0B309BXcmQ",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "\n",
        "class RNN(torch.nn.Module):\n",
        "    def __init__(self, batch_size, window_size, num_features):\n",
        "        super(RNN, self).__init__()\n",
        "        self.rnn1 = torch.nn.GRU(num_features, 220, batch_first=True, bidirectional=True)\n",
        "        self.dropout = torch.nn.Dropout(p=0.5)\n",
        "        self.fc = torch.nn.Linear(440, 11)  # Adjust the input size to the linear layer\n",
        "        self.sigmoid = torch.nn.Sigmoid()\n",
        "\n",
        "    def forward(self, x):\n",
        "        rnn1_out, h_t1 = self.rnn1(x)\n",
        "        rnn1_out1 = self.dropout(rnn1_out)\n",
        "        fc_out = self.fc(rnn1_out1[:, -1, :])\n",
        "        out = self.sigmoid(fc_out)\n",
        "        return out\n",
        "inputs, classes = next(iter(train_loader))\n",
        "model5 = RNN(inputs.shape[0],inputs.shape[1],inputs.shape[2])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T12:49:24.181750Z",
          "iopub.status.busy": "2024-02-06T12:49:24.180900Z",
          "iopub.status.idle": "2024-02-06T12:50:37.994194Z",
          "shell.execute_reply": "2024-02-06T12:50:37.993202Z",
          "shell.execute_reply.started": "2024-02-06T12:49:24.181716Z"
        },
        "id": "Wie68tTgXcmQ",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "import time\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "model5 = model5.to(device)\n",
        "criterion = torch.nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(model5.parameters(), lr=0.001)\n",
        "\n",
        "\n",
        "n_epochs = 80\n",
        "start_time = time.time()\n",
        "for epoch in range(n_epochs):\n",
        "    train_loss = 0.0\n",
        "    train_acc = 0.0\n",
        "\n",
        "    for inputs, labels in train_loader:\n",
        "        inputs, labels = inputs.to(device), labels.to(device)\n",
        "        # Reset gradients\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        # Forward pass\n",
        "        outputs = model5(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "\n",
        "        # Backward pass\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # Update metrics\n",
        "        train_loss += loss.item() * inputs.size(0)\n",
        "        _, preds = torch.max(outputs, 1)\n",
        "        train_acc += torch.sum(preds == labels.data)\n",
        "\n",
        "    # Calculate metrics for the epoch\n",
        "    train_loss /= len(train_loader.dataset)\n",
        "    train_acc = train_acc.double() / len(train_loader.dataset)\n",
        "\n",
        "    print(f\"Epoch {epoch+1}/{n_epochs} -- Train Loss: {train_loss:.4f} -- Train Accuracy: {train_acc:.4f}\")\n",
        "end_time = time.time()\n",
        "training_time = end_time - start_time\n",
        "print(training_time)\n",
        "total_params = sum(p.numel() for p in model5.parameters())\n",
        "print(f\"Total Model Parameters: {total_params}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-01-25T13:05:56.890230Z",
          "iopub.status.busy": "2024-01-25T13:05:56.889399Z",
          "iopub.status.idle": "2024-01-25T13:05:56.897440Z",
          "shell.execute_reply": "2024-01-25T13:05:56.896668Z",
          "shell.execute_reply.started": "2024-01-25T13:05:56.890196Z"
        },
        "id": "ybjiQc-OXcmQ",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "save_path = '/kaggle/working/model_without_defence.pt'\n",
        "torch.save(model5.state_dict(), save_path)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T12:50:43.882917Z",
          "iopub.status.busy": "2024-02-06T12:50:43.882415Z",
          "iopub.status.idle": "2024-02-06T12:50:55.525745Z",
          "shell.execute_reply": "2024-02-06T12:50:55.524585Z",
          "shell.execute_reply.started": "2024-02-06T12:50:43.882882Z"
        },
        "id": "nULb5KCoXcmR",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "pip install torchattacks"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-06T12:52:02.998645Z",
          "iopub.status.busy": "2024-02-06T12:52:02.997912Z",
          "iopub.status.idle": "2024-02-06T12:52:33.745806Z",
          "shell.execute_reply": "2024-02-06T12:52:33.744836Z",
          "shell.execute_reply.started": "2024-02-06T12:52:02.998609Z"
        },
        "id": "bbaAJ84XXcmR",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# import torchvision\n",
        "import torchattacks\n",
        "# Load the pre-trained model\n",
        "model5.to(\"cpu\")\n",
        "model5.eval()\n",
        "\n",
        "\n",
        "# Attack parameters\n",
        "epsilon_fgsm = 0.2  # Perturbation magnitude for FGSM\n",
        "epsilon_bim = 0.2 # Perturbation magnitude for BIM\n",
        "epsilon_cw = 0.2 # Perturbation magnitude for C&W\n",
        "\n",
        "correct_original = 0\n",
        "correct_adversarial_fgsm = 0\n",
        "correct_adversarial_bim = 0\n",
        "correct_adversarial_cw = 0\n",
        "correct_adversarial_rfgsm=0\n",
        "correct_adversarial_PGD=0\n",
        "total = 0\n",
        "\n",
        "# Iterate over the test set\n",
        "for inputs, labels in test_loader:\n",
        "\n",
        "    # Forward pass on the original input\n",
        "    outputs_original = model5(inputs)\n",
        "    _, predicted_original = torch.max(outputs_original, 1)\n",
        "\n",
        "    # FGSM: Craft adversarial example\n",
        "    attack_fgsm = torchattacks.FGSM(model5, eps=epsilon_fgsm)\n",
        "    adversarial_inputs_fgsm = attack_fgsm(inputs, labels)\n",
        "\n",
        "    # BIM: Craft adversarial example\n",
        "    attack_bim = torchattacks.BIM(model5, eps=epsilon_bim)\n",
        "    adversarial_inputs_bim = attack_bim(inputs, labels)\n",
        "\n",
        "    # C&W: Craft adversarial example\n",
        "    attack_cw = torchattacks.CW(model5, c=epsilon_cw, kappa=0)\n",
        "    adversarial_inputs_cw = attack_cw(inputs, labels)\n",
        "\n",
        "    attack_RFGSM = torchattacks.RFGSM(model5, eps=epsilon_bim)\n",
        "    adversarial_inputs_RFGSM = attack_RFGSM(inputs, labels)\n",
        "\n",
        "    attack_PGD = torchattacks.PGD(model5, eps=epsilon_bim)\n",
        "    adversarial_inputs_PGD = attack_PGD(inputs, labels)\n",
        "\n",
        "\n",
        "\n",
        "    # Forward pass on the adversarial inputs\n",
        "    outputs_adversarial_fgsm = model5(adversarial_inputs_fgsm)\n",
        "    outputs_adversarial_bim = model5(adversarial_inputs_bim)\n",
        "    outputs_adversarial_cw = model5(adversarial_inputs_cw)\n",
        "    outputs_adversarial_rfgsm = model5(adversarial_inputs_RFGSM)\n",
        "    outputs_adversarial_PGD = model5(adversarial_inputs_PGD)\n",
        "\n",
        "\n",
        "    # Update accuracy metrics\n",
        "    total += labels.size(0)\n",
        "    correct_original += (predicted_original == labels).sum().item()\n",
        "    correct_adversarial_fgsm += (torch.argmax(outputs_adversarial_fgsm, dim=1) == labels).sum().item()\n",
        "    correct_adversarial_bim += (torch.argmax(outputs_adversarial_bim, dim=1) == labels).sum().item()\n",
        "    correct_adversarial_cw += (torch.argmax(outputs_adversarial_cw, dim=1) == labels).sum().item()\n",
        "    correct_adversarial_rfgsm += (torch.argmax(outputs_adversarial_rfgsm, dim=1) == labels).sum().item()\n",
        "    correct_adversarial_PGD += (torch.argmax(outputs_adversarial_PGD, dim=1) == labels).sum().item()\n",
        "\n",
        "\n",
        "# Calculate and print accuracy\n",
        "accuracy_original = correct_original / total\n",
        "accuracy_adversarial_fgsm = correct_adversarial_fgsm / total\n",
        "accuracy_adversarial_bim = correct_adversarial_bim / total\n",
        "accuracy_adversarial_cw = correct_adversarial_cw / total\n",
        "accuracy_adversarial_rfgsm = correct_adversarial_rfgsm / total\n",
        "accuracy_adversarial_PGD = correct_adversarial_PGD / total\n",
        "\n",
        "print(f'Accuracy on Original Data: {accuracy_original * 100:.2f}%')\n",
        "print(f'Accuracy on Adversarial Data (FGSM): {accuracy_adversarial_fgsm * 100:.2f}%')\n",
        "print(f'Accuracy on Adversarial Data (BIM): {accuracy_adversarial_bim * 100:.2f}%')\n",
        "print(f'Accuracy on Adversarial Data (C&W): {accuracy_adversarial_cw * 100:.2f}%')\n",
        "print(f'Accuracy on Adversarial Data (RFGSM): {accuracy_adversarial_rfgsm * 100:.2f}%')\n",
        "print(f'Accuracy on Adversarial Data (PDG): {accuracy_adversarial_PGD * 100:.2f}%')\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-01-25T13:15:52.243446Z",
          "iopub.status.busy": "2024-01-25T13:15:52.242741Z",
          "iopub.status.idle": "2024-01-25T13:15:53.263811Z",
          "shell.execute_reply": "2024-01-25T13:15:53.262902Z",
          "shell.execute_reply.started": "2024-01-25T13:15:52.243413Z"
        },
        "id": "_JyiXhxxXcmR",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Given ASR values for two sets\n",
        "asr_values_set1 = [0.604,0.18, 0.173, 0.159, 0.131, 0.131, 0.111, 0.111, 0.111, 0.104, 0.104]\n",
        "asr_values_set2 = [0.604,0.208, 0.125, 0.097, 0.09,0.083, 0.083,  0.076, 0.076, 0.062, 0.055]\n",
        "asr_values_set3 = [0.604,0.138, 0.131, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125]\n",
        "asr_values_set4 = [0.604,0.125, 0.062, 0.055, 0.041, 0.034,0.041, 0.048,  0.027, 0.027,0.027]\n",
        "asr_values_set5 = [0.604,0.125, 0.083, 0.048, 0.034, 0.027, 0.041, 0.041, 0.013, 0.027, 0.041]\n",
        "\n",
        "# Create a list of feature numbers starting from one\n",
        "feature_numbers = [0,0.05,0.1,0.15,0.20,0.25,0.30,0.35,0.40,0.45,0.50]\n",
        "\n",
        "# Plotting the graphs\n",
        "plt.ylim(0, 1.0)\n",
        "plt.plot(feature_numbers, asr_values_set1, marker='o', linestyle='-', color='b', label='fgsm')\n",
        "plt.plot(feature_numbers, asr_values_set2, marker='s', linestyle='-', color='r', label='bim')\n",
        "plt.plot(feature_numbers, asr_values_set3, marker='^', linestyle='-', color='g', label='cw')  # Different color for set3\n",
        "plt.plot(feature_numbers, asr_values_set4, marker='*', linestyle='-', color='orange', label='rfgsm')  # Different color for set4\n",
        "plt.plot(feature_numbers, asr_values_set5, marker='D', linestyle='-', color='purple', label='pgd')\n",
        "# Adding legend\n",
        "plt.legend()\n",
        "plt.xlabel('epsilon')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.title('Accuracy vs epsilon')\n",
        "plt.grid(True)\n",
        "plt.tight_layout()\n",
        "plt.savefig('/kaggle/working/model_WB.pdf', format='pdf')\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T16:10:04.795671Z",
          "iopub.status.busy": "2024-02-03T16:10:04.795275Z",
          "iopub.status.idle": "2024-02-03T16:10:04.807703Z",
          "shell.execute_reply": "2024-02-03T16:10:04.806477Z",
          "shell.execute_reply.started": "2024-02-03T16:10:04.795637Z"
        },
        "id": "bef1uuvfXcmR",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "np.random.seed(seed)\n",
        "torch.manual_seed(seed)\n",
        "torch.cuda.manual_seed(seed)\n",
        "torch.cuda.manual_seed_all(seed)\n",
        "torch.backends.cudnn.deterministic = True\n",
        "torch.backends.cudnn.benchmark = True\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T16:10:05.500842Z",
          "iopub.status.busy": "2024-02-03T16:10:05.500360Z",
          "iopub.status.idle": "2024-02-03T16:10:05.575647Z",
          "shell.execute_reply": "2024-02-03T16:10:05.574412Z",
          "shell.execute_reply.started": "2024-02-03T16:10:05.500807Z"
        },
        "id": "2qhbkQ9CXcmS",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "class RNN(torch.nn.Module):\n",
        "    def __init__(self, batch_size, window_size, num_features):\n",
        "        super(RNN, self).__init__()\n",
        "        self.rnn1 = torch.nn.GRU(num_features, 220, batch_first=True, bidirectional=True)\n",
        "        self.dropout = torch.nn.Dropout(p=0.5)\n",
        "        self.fc = torch.nn.Linear(440, 11)  # Adjust the input size to the linear layer\n",
        "        self.sigmoid = torch.nn.Sigmoid()\n",
        "\n",
        "    def forward(self, x):\n",
        "        rnn1_out, h_t1 = self.rnn1(x)\n",
        "        rnn1_out1 = self.dropout(rnn1_out)\n",
        "        fc_out = self.fc(rnn1_out1[:, -1, :])\n",
        "        out = self.sigmoid(fc_out)\n",
        "        return out\n",
        "inputs, classes = next(iter(train_loader))\n",
        "model5 = RNN(inputs.shape[0],inputs.shape[1],inputs.shape[2])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-01-25T13:16:10.786037Z",
          "iopub.status.busy": "2024-01-25T13:16:10.785694Z",
          "iopub.status.idle": "2024-01-25T14:35:08.989230Z",
          "shell.execute_reply": "2024-01-25T14:35:08.988256Z",
          "shell.execute_reply.started": "2024-01-25T13:16:10.786011Z"
        },
        "id": "JmU2bdZLXcmS",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "\n",
        "import torchattacks\n",
        "# model5.to(\"cpu\")\n",
        "\n",
        "criterion = torch.nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(model5.parameters(), lr=0.001)\n",
        "epsilon_fgsm = 0.2  # FGSM perturbation magnitude\n",
        "epsilon_bim = 0.2 # BIM perturbation magnitude\n",
        " # C&W perturbation magnitude\n",
        "\n",
        "n_epochs = 80\n",
        "start_time = time.time()\n",
        "for epoch in range(n_epochs):\n",
        "    model5.train()\n",
        "    train_loss = 0.0\n",
        "    train_acc = 0.0\n",
        "\n",
        "    for inputs, labels in train_loader:\n",
        "        # Reset gradients\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        # Forward pass on the original input\n",
        "        outputs = model5(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "\n",
        "        # Backward pass on the original input\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        # FGSM: Add perturbation to the input for FGSM attack\n",
        "\n",
        "        fgsm_attack = torchattacks.FGSM(model5, eps=epsilon_fgsm)\n",
        "        fgsm_adversarial_inputs = fgsm_attack(inputs, labels)\n",
        "\n",
        "        # BIM: Add perturbation to the input for BIM attack\n",
        "        bim_attack = torchattacks.BIM(model5, eps=epsilon_bim)\n",
        "        bim_adversarial_inputs = bim_attack(inputs, labels)\n",
        "\n",
        "\n",
        "        # Forward pass on adversarial inputs for all attacks\n",
        "        fgsm_adversarial_outputs = model5(fgsm_adversarial_inputs)\n",
        "        bim_adversarial_outputs = model5(bim_adversarial_inputs)\n",
        "\n",
        "        # Calculate losses for all attacks\n",
        "        fgsm_adversarial_loss = criterion(fgsm_adversarial_outputs, labels)\n",
        "        bim_adversarial_loss = criterion(bim_adversarial_outputs, labels)\n",
        "\n",
        "        # Backward pass on adversarial inputs for all attacks\n",
        "        fgsm_adversarial_loss.backward()\n",
        "        bim_adversarial_loss.backward()\n",
        "\n",
        "        # Update gradients\n",
        "        optimizer.step()\n",
        "\n",
        "        # Update metrics\n",
        "        train_loss += (fgsm_adversarial_loss.item() + bim_adversarial_loss.item()) * inputs.size(0)\n",
        "        _, fgsm_preds = torch.max(fgsm_adversarial_outputs, 1)\n",
        "        _, bim_preds = torch.max(bim_adversarial_outputs, 1)\n",
        "        train_acc += (torch.sum(fgsm_preds == labels.data) + torch.sum(bim_preds == labels.data))\n",
        "\n",
        "    # Calculate metrics for the epoch\n",
        "    train_loss /= (2 * len(train_loader.dataset))\n",
        "    train_acc = train_acc.double() / (2 * len(train_loader.dataset))\n",
        "\n",
        "    print(f\"Epoch {epoch+1}/{n_epochs} -- Train Loss: {train_loss:.4f} -- Train Accuracy: {train_acc:.4f}\")\n",
        "\n",
        "end_time = time.time()\n",
        "training_time = end_time - start_time\n",
        "print(training_time)\n",
        "total_params = sum(p.numel() for p in model5.parameters())\n",
        "print(f\"Total Model Parameters: {total_params}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-01-25T14:40:00.157203Z",
          "iopub.status.busy": "2024-01-25T14:40:00.156239Z",
          "iopub.status.idle": "2024-01-25T14:40:00.164481Z",
          "shell.execute_reply": "2024-01-25T14:40:00.163545Z",
          "shell.execute_reply.started": "2024-01-25T14:40:00.157171Z"
        },
        "id": "zzVCYcW6XcmS",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "save_path = '/kaggle/working/model_with_defence.pt'\n",
        "torch.save(model5.state_dict(), save_path)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T12:17:08.660931Z",
          "iopub.status.busy": "2024-02-03T12:17:08.660195Z",
          "iopub.status.idle": "2024-02-03T12:17:08.696204Z",
          "shell.execute_reply": "2024-02-03T12:17:08.695075Z",
          "shell.execute_reply.started": "2024-02-03T12:17:08.660894Z"
        },
        "id": "3oz_Bd4BXcmS",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "model5.load_state_dict(torch.load('/kaggle/input/test-data/model_with_defence.pt'))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-01-25T14:38:29.395916Z",
          "iopub.status.busy": "2024-01-25T14:38:29.394996Z",
          "iopub.status.idle": "2024-01-25T14:38:29.400937Z",
          "shell.execute_reply": "2024-01-25T14:38:29.399980Z",
          "shell.execute_reply.started": "2024-01-25T14:38:29.395881Z"
        },
        "id": "lnl4zH-0XcmS",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "print(end_time)\n",
        "print(start_time)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T10:04:12.736869Z",
          "iopub.status.busy": "2024-02-03T10:04:12.736153Z",
          "iopub.status.idle": "2024-02-03T10:05:05.105603Z",
          "shell.execute_reply": "2024-02-03T10:05:05.104611Z",
          "shell.execute_reply.started": "2024-02-03T10:04:12.736838Z"
        },
        "id": "AXFvPjcpXcmS",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "### import torchvision\n",
        "import torchattacks\n",
        "\n",
        "# Load the pre-trained model\n",
        "model5.eval()\n",
        "\n",
        "\n",
        "# Attack parameters\n",
        "epsilon_fgsm = 0.5  # Perturbation magnitude for FGSM\n",
        "epsilon_bim = 0.5# Perturbation magnitude for BIM\n",
        "epsilon_cw = 0.5# Perturbation magnitude for C&W\n",
        "\n",
        "correct_original = 0\n",
        "correct_adversarial_fgsm = 0\n",
        "correct_adversarial_bim = 0\n",
        "correct_adversarial_cw = 0\n",
        "correct_adversarial_rfgsm=0\n",
        "correct_adversarial_PGD=0\n",
        "total = 0\n",
        "\n",
        "# Iterate over the test set\n",
        "for inputs, labels in test_loader:\n",
        "    # Forward pass on the original input\n",
        "    outputs_original = model5(inputs)\n",
        "    _, predicted_original = torch.max(outputs_original, 1)\n",
        "\n",
        "    # FGSM: Craft adversarial example\n",
        "    attack_fgsm = torchattacks.FGSM(model5, eps=epsilon_fgsm)\n",
        "    adversarial_inputs_fgsm = attack_fgsm(inputs, labels)\n",
        "\n",
        "    # BIM: Craft adversarial example\n",
        "    attack_bim = torchattacks.BIM(model5, eps=epsilon_bim)\n",
        "    adversarial_inputs_bim = attack_bim(inputs, labels)\n",
        "\n",
        "    # C&W: Craft adversarial example\n",
        "    attack_cw = torchattacks.CW(model5, c=epsilon_cw, kappa=0,steps=100)\n",
        "    adversarial_inputs_cw = attack_cw(inputs, labels)\n",
        "\n",
        "    attack_RFGSM = torchattacks.RFGSM(model5, eps=epsilon_bim)\n",
        "    adversarial_inputs_RFGSM = attack_RFGSM(inputs, labels)\n",
        "\n",
        "    attack_PGD = torchattacks.PGD(model5, eps=epsilon_bim)\n",
        "    adversarial_inputs_PGD = attack_PGD(inputs, labels)\n",
        "\n",
        "\n",
        "\n",
        "    # Forward pass on the adversarial inputs\n",
        "    outputs_adversarial_fgsm = model5(adversarial_inputs_fgsm)\n",
        "    outputs_adversarial_bim = model5(adversarial_inputs_bim)\n",
        "    outputs_adversarial_cw = model5(adversarial_inputs_cw)\n",
        "    outputs_adversarial_rfgsm = model5(adversarial_inputs_RFGSM)\n",
        "    outputs_adversarial_PGD = model5(adversarial_inputs_PGD)\n",
        "\n",
        "\n",
        "    # Update accuracy metrics\n",
        "    total += labels.size(0)\n",
        "    correct_original += (predicted_original == labels).sum().item()\n",
        "    correct_adversarial_fgsm += (torch.argmax(outputs_adversarial_fgsm, dim=1) == labels).sum().item()\n",
        "    correct_adversarial_bim += (torch.argmax(outputs_adversarial_bim, dim=1) == labels).sum().item()\n",
        "    correct_adversarial_cw += (torch.argmax(outputs_adversarial_cw, dim=1) == labels).sum().item()\n",
        "    correct_adversarial_rfgsm += (torch.argmax(outputs_adversarial_rfgsm, dim=1) == labels).sum().item()\n",
        "    correct_adversarial_PGD += (torch.argmax(outputs_adversarial_PGD, dim=1) == labels).sum().item()\n",
        "\n",
        "\n",
        "# Calculate and print accuracy\n",
        "accuracy_original = correct_original / total\n",
        "accuracy_adversarial_fgsm = correct_adversarial_fgsm / total\n",
        "accuracy_adversarial_bim = correct_adversarial_bim / total\n",
        "accuracy_adversarial_cw = correct_adversarial_cw / total\n",
        "accuracy_adversarial_rfgsm = correct_adversarial_rfgsm / total\n",
        "accuracy_adversarial_PGD = correct_adversarial_PGD / total\n",
        "\n",
        "print(f'Accuracy on Original Data: {accuracy_original * 100:.2f}%')\n",
        "print(f'Accuracy on Adversarial Data (FGSM): {accuracy_adversarial_fgsm * 100:.2f}%')\n",
        "print(f'Accuracy on Adversarial Data (BIM): {accuracy_adversarial_bim * 100:.2f}%')\n",
        "print(f'Accuracy on Adversarial Data (C&W): {accuracy_adversarial_cw * 100:.2f}%')\n",
        "print(f'Accuracy on Adversarial Data (RFGSM): {accuracy_adversarial_rfgsm * 100:.2f}%')\n",
        "print(f'Accuracy on Adversarial Data (PDG): {accuracy_adversarial_PGD * 100:.2f}%')\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-01-25T14:49:52.106977Z",
          "iopub.status.busy": "2024-01-25T14:49:52.105829Z",
          "iopub.status.idle": "2024-01-25T14:49:52.832131Z",
          "shell.execute_reply": "2024-01-25T14:49:52.831230Z",
          "shell.execute_reply.started": "2024-01-25T14:49:52.106922Z"
        },
        "id": "7Qh_lsi2XcmT",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Given ASR values for two sets\n",
        "asr_values_set1 = [0.618,0.50, 0.472, 0.451, 0.437, 0.388, 0.347, 0.319, 0.284, 0.201, 0.187]\n",
        "asr_values_set2 = [0.618,0.479, 0.444, 0.402, 0.381,0.354, 0.312, 0.25, 0.208, 0.173, 0.159]\n",
        "asr_values_set3 = [0.618,0.458, 0.458, 0.451, 0.451, 0.437, 0.437, 0.437, 0.437, 0.437, 0.437]\n",
        "asr_values_set4 = [0.618,0.451, 0.423, 0.409, 0.388, 0.368,0.347, 0.291,  0.284, 0.229, 0.194]\n",
        "asr_values_set5 = [0.618,0.444, 0.444, 0.43, 0.388, 0.354, 0.326, 0.312, 0.236, 0.166, 0.18]\n",
        "\n",
        "# Create a list of feature numbers starting from one\n",
        "feature_numbers = [0,0.05,0.1,0.15,0.20,0.25,0.30,0.35,0.40,0.45,0.50]\n",
        "\n",
        "# Plotting the graphs\n",
        "plt.ylim(0, 1.0)\n",
        "plt.plot(feature_numbers, asr_values_set1, marker='o', linestyle='-', color='b', label='fgsm')\n",
        "plt.plot(feature_numbers, asr_values_set2, marker='s', linestyle='-', color='r', label='bim')\n",
        "plt.plot(feature_numbers, asr_values_set3, marker='^', linestyle='-', color='g', label='cw')  # Different color for set3\n",
        "plt.plot(feature_numbers, asr_values_set4, marker='*', linestyle='-', color='orange', label='rfgsm')  # Different color for set4\n",
        "plt.plot(feature_numbers, asr_values_set5, marker='D', linestyle='-', color='purple', label='pgd')\n",
        "# Adding legend\n",
        "plt.legend()\n",
        "\n",
        "plt.xlabel('epsilon')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.title('Accuracy vs epsilon')\n",
        "plt.grid(True)\n",
        "plt.tight_layout()\n",
        "plt.savefig('/kaggle/working/model_WB_Defence.pdf', format='pdf')\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T12:17:17.780408Z",
          "iopub.status.busy": "2024-02-03T12:17:17.779995Z",
          "iopub.status.idle": "2024-02-03T12:17:17.788240Z",
          "shell.execute_reply": "2024-02-03T12:17:17.786414Z",
          "shell.execute_reply.started": "2024-02-03T12:17:17.780373Z"
        },
        "id": "j0HO_pqJXcmT",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "np.random.seed(seed)\n",
        "torch.manual_seed(seed)\n",
        "torch.cuda.manual_seed(seed)\n",
        "torch.cuda.manual_seed_all(seed)\n",
        "torch.backends.cudnn.deterministic = True\n",
        "torch.backends.cudnn.benchmark = True\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T16:11:28.588623Z",
          "iopub.status.busy": "2024-02-03T16:11:28.587662Z",
          "iopub.status.idle": "2024-02-03T16:11:33.374506Z",
          "shell.execute_reply": "2024-02-03T16:11:33.373342Z",
          "shell.execute_reply.started": "2024-02-03T16:11:28.588575Z"
        },
        "id": "kkyDfExIXcmY",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "a = CustomDataset()\n",
        "trainSize = 0.9\n",
        "# valSize = 0.05\n",
        "a = CustomDataset()\n",
        "\n",
        "# Defining sizes\n",
        "train_size = int(trainSize * len(a))\n",
        "test_size = len(a)-train_size\n",
        "\n",
        "train_dataset, test_dataset = torch.utils.data.random_split(\n",
        "    a, [train_size, test_size])\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(dataset=train_dataset,\n",
        "                                           batch_size=4,\n",
        "                                           shuffle=True,\n",
        "                                           drop_last=True)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(dataset=test_dataset,\n",
        "                                          batch_size=4,\n",
        "                                          shuffle=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T16:11:53.132775Z",
          "iopub.status.busy": "2024-02-03T16:11:53.131858Z",
          "iopub.status.idle": "2024-02-03T17:35:39.538779Z",
          "shell.execute_reply": "2024-02-03T17:35:39.537449Z",
          "shell.execute_reply.started": "2024-02-03T16:11:53.132730Z"
        },
        "id": "ybdHzgnaXcmY",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import numpy as np\n",
        "import torchattacks\n",
        "\n",
        "# Define the generator and discriminator for the GAN\n",
        "class Generator(nn.Module):\n",
        "    def __init__(self, batch_size,window_size,num_features,latent_dim=100):\n",
        "        super(Generator, self).__init__()\n",
        "        self.batch_size = batch_size\n",
        "        self.num_features = num_features\n",
        "        self.window_size = window_size\n",
        "       # self.fc1 = nn.Linear(latent_dim, 128)\n",
        "        self.fc1 = nn.Linear(num_features, latent_dim)\n",
        "        self.fc2 = nn.Linear(latent_dim, 256)\n",
        "        self.fc3 = nn.Linear(256,batch_size*window_size)\n",
        "        self.fc4 = nn.Linear(batch_size*window_size,num_features)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = F.relu(self.fc2(x))\n",
        "        x = F.relu(self.fc3(x))\n",
        "        x = self.fc4(x)\n",
        "        #return x.view(x.size(0), 1, -1)\n",
        "        return x\n",
        "\n",
        "class Discriminator(nn.Module):\n",
        "    def __init__(self, batch_size, window_size, num_features):\n",
        "        super(Discriminator, self).__init__()\n",
        "        self.fc1 = nn.Linear(num_features, 160)\n",
        "        self.fc2 = nn.Linear(160, 200)\n",
        "        self.fc3 = nn.Linear(200, 256)\n",
        "        self.fc4 = nn.Linear(256, 512)\n",
        "        self.fc5 = nn.Linear(512, 1)\n",
        "        self.window_size = window_size\n",
        "        self.num_features = num_features\n",
        "        self.batch_size = batch_size\n",
        "\n",
        "    def forward(self, x):\n",
        "      #x = x.view(-1, self.num_features)\n",
        "      x = F.relu(self.fc1(x))\n",
        "      x = F.relu(self.fc2(x))\n",
        "      x = F.relu(self.fc3(x))\n",
        "      x = F.relu(self.fc4(x))\n",
        "      x = torch.sigmoid(self.fc5(x))\n",
        "      return x\n",
        "\n",
        "\n",
        "\n",
        "# Define the GAN training function\n",
        "\n",
        "def train_gan(generator, discriminator, train_loader, num_epochs=100, lr=0.0002,\n",
        "              device=torch.device('cpu')):\n",
        "\n",
        "    generator.to(device)\n",
        "    discriminator.to(device)\n",
        "\n",
        "    # Define the loss functions and optimizers\n",
        "\n",
        "    adversarial_loss = nn.BCELoss()\n",
        "    generator_optimizer = torch.optim.Adam(generator.parameters(), lr=lr)\n",
        "    discriminator_optimizer = torch.optim.Adam(discriminator.parameters(), lr=lr)\n",
        "\n",
        "\n",
        "    for epoch in range(num_epochs):\n",
        "        for i, (inputs,Labels) in enumerate(train_loader):\n",
        "            # Move data to device\n",
        "            inputs = inputs.to(device)\n",
        "            Labels = Labels.to(device)\n",
        "\n",
        "            # Train discriminator on real data\n",
        "            discriminator_optimizer.zero_grad()\n",
        "            real_labels = torch.ones(inputs.size(0), inputs.size(1), 1).to(device)\n",
        "            real_outputs = discriminator(inputs)\n",
        "            discriminator_loss_real = adversarial_loss(real_outputs, real_labels)\n",
        "            discriminator_loss_real.backward()\n",
        "\n",
        "            # Train discriminator on fake data generated by the generator\n",
        "            generator_optimizer.zero_grad()\n",
        "            latent_inputs = torch.randn(inputs.shape[0], inputs.shape[1], inputs.shape[2]).to(device)\n",
        "            fake_inputs = generator(latent_inputs)\n",
        "            fake_labels = torch.zeros(inputs.size(0), inputs.size(1), 1).to(device)\n",
        "            fake_outputs = discriminator(fake_inputs)\n",
        "            discriminator_loss_fake = adversarial_loss(fake_outputs, fake_labels)\n",
        "            discriminator_loss_fake.backward()\n",
        "            discriminator_optimizer.step()\n",
        "\n",
        "            attack_fgsm = torchattacks.FGSM(model5, eps=0.05)\n",
        "            adversarial_inputs_fgsm = attack_fgsm(inputs, torch.ones_like(Labels))\n",
        "            attack_bim = torchattacks.BIM(model5, eps=0.05)\n",
        "            adversarial_inputs_bim = attack_bim(inputs, torch.ones_like(Labels))\n",
        "            adversarial_inputs_combined = torch.cat([adversarial_inputs_fgsm, adversarial_inputs_bim], dim=0)\n",
        "            fake_labels = torch.zeros(adversarial_inputs_combined.size(0), adversarial_inputs_combined.size(1), 1).to(device)\n",
        "            fake_outputs = discriminator(adversarial_inputs_combined)\n",
        "            discriminator_loss_fake = adversarial_loss(fake_outputs, fake_labels)\n",
        "            discriminator_loss_fake.backward()\n",
        "            discriminator_optimizer.step()\n",
        "\n",
        "\n",
        "            # Train generator to generate samples that increase the discriminator loss\n",
        "            generator_optimizer.zero_grad()\n",
        "            latent_inputs = torch.randn(inputs.shape[0], inputs.shape[1], inputs.shape[2]).to(device)\n",
        "            fake_inputs = generator(latent_inputs)\n",
        "            # @S: generator wants to maximize the probability of the discriminator being wrong. So loss is computed between discriminator's output to a fake image and the\n",
        "            #fake label (if the fake label is 0)\n",
        "            fake_labels = torch.zeros(inputs.size(0), inputs.size(1), 1).to(device)\n",
        "            generator_loss =adversarial_loss(discriminator(fake_inputs), real_labels)\n",
        "            generator_loss.backward()\n",
        "            generator_optimizer.step()\n",
        "            if i % 10 == 0:\n",
        "              print('Epoch [{}/{}], Step [{}/{}], Discriminator Loss: {:.4f}, Generator Loss: {:.4f}'\n",
        "                      .format(epoch, num_epochs, i, len(train_loader),\n",
        "discriminator_loss_real.item() + discriminator_loss_fake.item(), generator_loss.item()))\n",
        "                # Return the trained generator\n",
        "    return generator,discriminator\n",
        "\n",
        "\n",
        "# Define the number of epochs and learning rate for training the GAN\n",
        "num_epochs = 100\n",
        "lr = 0.0002\n",
        "inputs, classes = next(iter(train_loader))\n",
        "# Create the GAN models\n",
        "batch_size, window_size, num_features = inputs.shape\n",
        "generator = Generator(batch_size,window_size,num_features)\n",
        "discriminator = Discriminator(batch_size, window_size, num_features)\n",
        "\n",
        "# Train the GAN on your data\n",
        "trained_generator_new,trained_discriminator = train_gan(generator, discriminator, train_loader, num_epochs=num_epochs, lr=lr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T17:53:55.392052Z",
          "iopub.status.busy": "2024-02-03T17:53:55.391557Z",
          "iopub.status.idle": "2024-02-03T17:53:55.404481Z",
          "shell.execute_reply": "2024-02-03T17:53:55.402953Z",
          "shell.execute_reply.started": "2024-02-03T17:53:55.392010Z"
        },
        "id": "dXw3Xh9DXcmY",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "torch.save(trained_generator_new.state_dict(), '/kaggle/working/trained_generator_Faulttype.pth')\n",
        "torch.save(trained_discriminator.state_dict(), '/kaggle/working/trained_discriminator_Faulttype.pth')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T17:45:16.174324Z",
          "iopub.status.busy": "2024-02-03T17:45:16.173815Z",
          "iopub.status.idle": "2024-02-03T17:45:16.740426Z",
          "shell.execute_reply": "2024-02-03T17:45:16.739294Z",
          "shell.execute_reply.started": "2024-02-03T17:45:16.174289Z"
        },
        "id": "Y_9b_gZtXcmZ",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "noise4 = torch.randn(800, 16, 51)\n",
        "\n",
        "generated_data4 = trained_generator_new(noise4)\n",
        "\n",
        "surrogate_outputs = model5(generated_data4)\n",
        "\n",
        "# Get the predicted class labels for each sample in the generated data\n",
        "predicted_labels = torch.argmax(surrogate_outputs, dim=1)\n",
        "print(predicted_labels)\n",
        "# Print the predicted labels"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T17:49:19.556386Z",
          "iopub.status.busy": "2024-02-03T17:49:19.555235Z",
          "iopub.status.idle": "2024-02-03T17:49:19.601471Z",
          "shell.execute_reply": "2024-02-03T17:49:19.600349Z",
          "shell.execute_reply.started": "2024-02-03T17:49:19.556345Z"
        },
        "id": "6suWLeZWXcmZ",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# List to store predicted class labels\n",
        "predicted_labels = []\n",
        "\n",
        "# Set the discriminator to evaluation mode\n",
        "trained_discriminator.eval()\n",
        "\n",
        "with torch.no_grad():\n",
        "    for inputs, _ in test_loader:\n",
        "\n",
        "        # Get the discriminator's output for the current batch\n",
        "        surrogate_outputs = trained_discriminator(inputs)\n",
        "\n",
        "        # Apply thresholding to determine class labels\n",
        "        threshold = 0.45\n",
        "        batch_predicted_labels = (surrogate_outputs >= threshold).int()  # 1 if >= threshold, 0 otherwise\n",
        "        predicted_labels.append(batch_predicted_labels)\n",
        "\n",
        "# Convert the list of predicted labels to a single tensor\n",
        "predicted_labels = torch.cat(predicted_labels, dim=0)\n",
        "\n",
        "# Print the predicted labels\n",
        "print(predicted_labels)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T17:49:22.281264Z",
          "iopub.status.busy": "2024-02-03T17:49:22.279850Z",
          "iopub.status.idle": "2024-02-03T17:49:22.291102Z",
          "shell.execute_reply": "2024-02-03T17:49:22.289817Z",
          "shell.execute_reply.started": "2024-02-03T17:49:22.281207Z"
        },
        "id": "9FkONsJTXcmZ",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# True labels (all 1)\n",
        "true_labels = torch.ones_like(predicted_labels)\n",
        "\n",
        "# Calculate accuracy\n",
        "correct_predictions = (predicted_labels == true_labels).sum().item()\n",
        "total_samples = true_labels.numel()  # Total number of elements in the tensor\n",
        "accuracy = correct_predictions / total_samples * 100\n",
        "\n",
        "print(f\"Accuracy: {accuracy:.2f}%\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T17:49:24.227376Z",
          "iopub.status.busy": "2024-02-03T17:49:24.226905Z",
          "iopub.status.idle": "2024-02-03T17:49:24.397336Z",
          "shell.execute_reply": "2024-02-03T17:49:24.396165Z",
          "shell.execute_reply.started": "2024-02-03T17:49:24.227344Z"
        },
        "id": "7xs-xufkXcmZ",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "\n",
        "noise4 = torch.randn(1500, 16, 51)\n",
        "\n",
        "generated_data4 = trained_generator_new(noise4)\n",
        "\n",
        "surrogate_outputs = trained_discriminator(generated_data4)\n",
        "predicted_labels = []\n",
        "\n",
        "# Apply thresholding to determine class labels\n",
        "threshold = 0.45\n",
        "batch_predicted_labels = (surrogate_outputs >= threshold).int()  # 1 if >= threshold, 0 otherwise\n",
        "predicted_labels.append(batch_predicted_labels)\n",
        "\n",
        "# Convert the list of predicted labels to a single tensor\n",
        "predicted_labels = torch.cat(predicted_labels, dim=0)\n",
        "\n",
        "# Print the predicted labels\n",
        "print(predicted_labels)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T17:49:26.640052Z",
          "iopub.status.busy": "2024-02-03T17:49:26.639604Z",
          "iopub.status.idle": "2024-02-03T17:49:26.648518Z",
          "shell.execute_reply": "2024-02-03T17:49:26.647197Z",
          "shell.execute_reply.started": "2024-02-03T17:49:26.640008Z"
        },
        "id": "Zuva2r9BXcmZ",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# True labels (all 0)\n",
        "true_labels = torch.zeros_like(predicted_labels)\n",
        "\n",
        "# Calculate accuracy\n",
        "correct_predictions = (predicted_labels == true_labels).sum().item()\n",
        "total_samples = true_labels.numel()  # Total number of elements in the tensor\n",
        "accuracy = correct_predictions / total_samples * 100\n",
        "\n",
        "print(f\"Accuracy: {accuracy:.2f}%\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T18:05:22.450841Z",
          "iopub.status.busy": "2024-02-03T18:05:22.450403Z",
          "iopub.status.idle": "2024-02-03T18:05:53.381839Z",
          "shell.execute_reply": "2024-02-03T18:05:53.380374Z",
          "shell.execute_reply.started": "2024-02-03T18:05:22.450809Z"
        },
        "id": "W-nSBJpVXcmZ",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "\n",
        "import torchvision\n",
        "import torchattacks\n",
        "\n",
        "# Load the pre-trained model\n",
        "model5.eval()\n",
        "predicted_labels_fgsm= []\n",
        "predicted_labels_bim= []\n",
        "predicted_labels_cw= []\n",
        "predicted_labels_RFGSM=[]\n",
        "predicted_labels_PGD=[]\n",
        "\n",
        "# Attack parameters\n",
        "epsilon_fgsm = 0.5 # Perturbation magnitude for FGSM\n",
        "epsilon_bim = 0.5# Perturbation magnitude for BIM\n",
        "epsilon_cw = 0.5# Perturbation magnitude for C&W\n",
        "\n",
        "threshold = 0.5\n",
        "correct_original = 0\n",
        "correct_adversarial_fgsm = 0\n",
        "correct_adversarial_bim = 0\n",
        "correct_adversarial_cw = 0\n",
        "total = 0\n",
        "\n",
        "# Iterate over the test set\n",
        "for inputs, labels in test_loader:\n",
        "    # Forward pass on the original input\n",
        "    outputs_original = model5(inputs)\n",
        "    _, predicted_original = torch.max(outputs_original, 1)\n",
        "\n",
        "    # FGSM: Craft adversarial example\n",
        "    attack_fgsm = torchattacks.FGSM(model5, eps=epsilon_fgsm)\n",
        "    adversarial_inputs_fgsm = attack_fgsm(inputs, labels)\n",
        "\n",
        "    # BIM: Craft adversarial example\n",
        "    attack_bim = torchattacks.BIM(model5, eps=epsilon_bim)\n",
        "    adversarial_inputs_bim = attack_bim(inputs, labels)\n",
        "\n",
        "    # C&W: Craft adversarial example\n",
        "    attack_cw = torchattacks.CW(model5, c=epsilon_cw, kappa=0)\n",
        "    adversarial_inputs_cw = attack_cw(inputs, labels)\n",
        "\n",
        "\n",
        "    attack_RFGSM = torchattacks.RFGSM(model5, eps=epsilon_bim)\n",
        "    adversarial_inputs_RFGSM = attack_RFGSM(inputs, labels)\n",
        "\n",
        "    attack_PGD = torchattacks.PGD(model5, eps=epsilon_bim)\n",
        "    adversarial_inputs_PGD = attack_PGD(inputs, labels)\n",
        "\n",
        "    # Forward pass on the adversarial inputs\n",
        "    outputs_adversarial_fgsm = trained_discriminator(adversarial_inputs_fgsm)\n",
        "    batch_predicted_labels1 = (outputs_adversarial_fgsm >= threshold).int()  # 1 if >= threshold, 0 otherwise\n",
        "    predicted_labels_fgsm.append(batch_predicted_labels1)\n",
        "    outputs_adversarial_bim = trained_discriminator(adversarial_inputs_bim)\n",
        "    batch_predicted_labels2 = (outputs_adversarial_bim >= threshold).int()\n",
        "    predicted_labels_bim.append(batch_predicted_labels2)\n",
        "    outputs_adversarial_cw = trained_discriminator(adversarial_inputs_cw)\n",
        "    batch_predicted_labels3 = (outputs_adversarial_cw >= threshold).int()\n",
        "    predicted_labels_cw.append(batch_predicted_labels3)\n",
        "    outputs_adversarial_RFGSM = trained_discriminator(adversarial_inputs_RFGSM)\n",
        "    batch_predicted_labels4 = (outputs_adversarial_RFGSM >= threshold).int()\n",
        "    predicted_labels_RFGSM.append(batch_predicted_labels4)\n",
        "    outputs_adversarial_PGD = trained_discriminator(adversarial_inputs_PGD)\n",
        "    batch_predicted_labels5 = (outputs_adversarial_PGD >= threshold).int()\n",
        "    predicted_labels_PGD.append(batch_predicted_labels5)\n",
        "\n",
        "\n",
        "predicted_labels = torch.cat(predicted_labels_fgsm, dim=0)\n",
        "predicted_labels1 = torch.cat(predicted_labels_bim, dim=0)\n",
        "predicted_labels2= torch.cat(predicted_labels_cw, dim=0)\n",
        "predicted_labels3= torch.cat(predicted_labels_RFGSM, dim=0)\n",
        "predicted_labels4= torch.cat(predicted_labels_PGD, dim=0)\n",
        "\n",
        "print(predicted_labels)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T18:05:57.128098Z",
          "iopub.status.busy": "2024-02-03T18:05:57.126531Z",
          "iopub.status.idle": "2024-02-03T18:05:57.138495Z",
          "shell.execute_reply": "2024-02-03T18:05:57.136656Z",
          "shell.execute_reply.started": "2024-02-03T18:05:57.128019Z"
        },
        "id": "yUT7SxQ9Xcma",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# True labels (all 0)\n",
        "true_labels = torch.zeros_like(predicted_labels)\n",
        "\n",
        "# Calculate accuracy\n",
        "correct_predictions = (predicted_labels == true_labels).sum().item()\n",
        "total_samples = true_labels.numel()  # Total number of elements in the tensor\n",
        "accuracy = correct_predictions / total_samples * 100\n",
        "\n",
        "print(f\"Accuracy: {accuracy:.2f}%\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T18:05:58.506328Z",
          "iopub.status.busy": "2024-02-03T18:05:58.505053Z",
          "iopub.status.idle": "2024-02-03T18:05:58.516138Z",
          "shell.execute_reply": "2024-02-03T18:05:58.514545Z",
          "shell.execute_reply.started": "2024-02-03T18:05:58.506278Z"
        },
        "id": "RgX10-8AXcma",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# True labels (all 0)\n",
        "true_labels = torch.zeros_like(predicted_labels1)\n",
        "\n",
        "# Calculate accuracy\n",
        "correct_predictions = (predicted_labels1 == true_labels).sum().item()\n",
        "total_samples = true_labels.numel()  # Total number of elements in the tensor\n",
        "accuracy = correct_predictions / total_samples * 100\n",
        "\n",
        "print(f\"Accuracy: {accuracy:.2f}%\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T18:05:59.689016Z",
          "iopub.status.busy": "2024-02-03T18:05:59.688550Z",
          "iopub.status.idle": "2024-02-03T18:05:59.697443Z",
          "shell.execute_reply": "2024-02-03T18:05:59.695757Z",
          "shell.execute_reply.started": "2024-02-03T18:05:59.688982Z"
        },
        "id": "2af4ZG2NXcma",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# True labels (all 0)\n",
        "true_labels = torch.zeros_like(predicted_labels2)\n",
        "\n",
        "# Calculate accuracy\n",
        "correct_predictions = (predicted_labels2 == true_labels).sum().item()\n",
        "total_samples = true_labels.numel()  # Total number of elements in the tensor\n",
        "accuracy = correct_predictions / total_samples * 100\n",
        "\n",
        "print(f\"Accuracy: {accuracy:.2f}%\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T18:06:01.357578Z",
          "iopub.status.busy": "2024-02-03T18:06:01.357100Z",
          "iopub.status.idle": "2024-02-03T18:06:01.366158Z",
          "shell.execute_reply": "2024-02-03T18:06:01.364376Z",
          "shell.execute_reply.started": "2024-02-03T18:06:01.357533Z"
        },
        "id": "8sFttIOFXcma",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "###### True labels (all 0)\n",
        "true_labels = torch.zeros_like(predicted_labels3)\n",
        "\n",
        "# Calculate accuracy\n",
        "correct_predictions = (predicted_labels3 == true_labels).sum().item()\n",
        "total_samples = true_labels.numel()  # Total number of elements in the tensor\n",
        "accuracy = correct_predictions / total_samples * 100\n",
        "\n",
        "print(f\"Accuracy: {accuracy:.2f}%\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2024-02-03T18:06:02.993259Z",
          "iopub.status.busy": "2024-02-03T18:06:02.992789Z",
          "iopub.status.idle": "2024-02-03T18:06:03.002232Z",
          "shell.execute_reply": "2024-02-03T18:06:03.000631Z",
          "shell.execute_reply.started": "2024-02-03T18:06:02.993225Z"
        },
        "id": "-lCRVpN_Xcma",
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# True labels (all 0)\n",
        "true_labels = torch.zeros_like(predicted_labels4)\n",
        "\n",
        "# Calculate accuracy\n",
        "correct_predictions = (predicted_labels4 == true_labels).sum().item()\n",
        "total_samples = true_labels.numel()  # Total number of elements in the tensor\n",
        "accuracy = correct_predictions / total_samples * 100\n",
        "\n",
        "print(f\"Accuracy: {accuracy:.2f}%\")"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kaggle": {
      "accelerator": "none",
      "dataSources": [
        {
          "datasetId": 4259241,
          "sourceId": 7336598,
          "sourceType": "datasetVersion"
        },
        {
          "datasetId": 4273891,
          "sourceId": 7358200,
          "sourceType": "datasetVersion"
        },
        {
          "datasetId": 4358836,
          "sourceId": 7487035,
          "sourceType": "datasetVersion"
        }
      ],
      "dockerImageVersionId": 30627,
      "isGpuEnabled": false,
      "isInternetEnabled": true,
      "language": "python",
      "sourceType": "notebook"
    },
    "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.10.12"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}