closed-world/closed-multi-feature_selection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6a7b3a0l2ep4"
   },
   "source": [
    "## Data Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "5mfwrTwPtd36"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading datafile...\n",
      "Total samples: 19000\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "\n",
    "USE_SUBLABEL = False\n",
    "URL_PER_SITE = 10\n",
    "TOTAL_URLS   = 950\n",
    "\n",
    "# Load the pickle file\n",
    "print(\"Loading datafile...\")\n",
    "with open(\"mon_standard.pkl\", 'rb') as fi:\n",
    "    data = pickle.load(fi)\n",
    "\n",
    "X1 = [] # Array to store instances (timestamps) - 19,000 instances, e.g., [[0.0, 0.5, 3.4, ...], [0.0, 4.5, ...], [0.0, 1.5, ...], ... [... ,45.8]]\n",
    "X2 = [] # Array to store instances (direction*size) - size information\n",
    "y = [] # Array to store the site of each instance - 19,000 instances, e.g., [0, 0, 0, 0, 0, 0, ..., 94, 94, 94, 94, 94]\n",
    "\n",
    "# Differentiate instances and sites, and store them in the respective x and y arrays\n",
    "# x array (direction*timestamp), y array (site label)\n",
    "for i in range(TOTAL_URLS):\n",
    "    if USE_SUBLABEL:\n",
    "        label = i\n",
    "    else:\n",
    "        label = i // URL_PER_SITE # Calculate which site's URL the current URL being processed belongs to and set that value as the label. Thus, URLs fetched from the same site are labeled identically.\n",
    "    for sample in data[i]:\n",
    "        size_seq = []\n",
    "        time_seq = []\n",
    "        for c in sample:\n",
    "            dr = 1 if c > 0 else -1\n",
    "            time_seq.append(abs(c))\n",
    "            size_seq.append(dr * 512)\n",
    "        X1.append(time_seq)\n",
    "        X2.append(size_seq)\n",
    "        y.append(label)\n",
    "size = len(y)\n",
    "\n",
    "print(f'Total samples: {size}') # Output: 19000\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Selection - Experiment 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-1. Select 8 Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def create_features(X1, X2):\n",
    "    X = []\n",
    "    for i in range(len(X1)):\n",
    "        packet_size_direction = sum(X2[i])\n",
    "        cumulative_packet_size = np.sum([abs(c) for c in X2[i]])\n",
    "        burst_lengths = len([c for c in X2[i] if c != 0])\n",
    "\n",
    "        num_incoming_packets = len([c for c in X2[i] if c > 0])\n",
    "        ratio_incoming_packets = num_incoming_packets / len(X2[i]) if len(X2[i]) > 0 else 0\n",
    "        num_outgoing_packets = len([c for c in X2[i] if c < 0])\n",
    "        total_packet_count = len(X2[i])\n",
    "\n",
    "        feature_vector = [\n",
    "            packet_size_direction,\n",
    "            np.mean(X1[i]) if X1[i] else 0,\n",
    "            cumulative_packet_size,\n",
    "            burst_lengths,\n",
    "            num_incoming_packets,\n",
    "            ratio_incoming_packets,\n",
    "            num_outgoing_packets,\n",
    "            total_packet_count\n",
    "        ]\n",
    "        X.append(feature_vector)\n",
    "    return np.array(X)\n",
    "\n",
    "X = create_features(X1, X2)\n",
    "y = np.array(y)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-2. Train, Test and Evaluate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.5226\n",
      "Precision (Weighted): 0.5178\n",
      "Recall (Weighted): 0.5226\n",
      "F1 Score (Weighted): 0.5150\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score, auc,roc_auc_score, precision_score, precision_recall_curve, roc_curve, recall_score, f1_score, average_precision_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
    "\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "rf_model = RandomForestClassifier(\n",
    "    n_estimators=2000,\n",
    "    min_samples_leaf=2,\n",
    "    max_depth=35,\n",
    "    max_features='sqrt',\n",
    "    random_state=42\n",
    ")\n",
    "\n",
    "rf_model.fit(X_train, y_train)\n",
    "y_pred = rf_model.predict(X_test)\n",
    "\n",
    "# Calculate Accuracy, Precison, Recall, F1 Score\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "precision = precision_score(y_test, y_pred, average = 'weighted')\n",
    "recall = recall_score(y_test, y_pred, average = 'weighted')\n",
    "f1 = f1_score(y_test, y_pred, average='weighted')\n",
    "\n",
    "print(f\"Accuracy: {accuracy:.4f}\")\n",
    "print(f\"Precision (Weighted): {precision:.4f}\")\n",
    "print(f\"Recall (Weighted): {recall:.4f}\")\n",
    "print(f\"F1 Score (Weighted): {f1:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Selection - Experiment 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-1. Select 24 Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from itertools import groupby\n",
    "\n",
    "# Initialize a list to store the newly created features\n",
    "features = []\n",
    "\n",
    "# Calculate each feature\n",
    "for i in range(len(X2)):\n",
    "    size_seq = X2[i]\n",
    "    time_seq = X1[i]\n",
    "    \n",
    "    # 1. Number of incoming packets\n",
    "    num_incoming_packets = sum(1 for size in size_seq if size < 0)\n",
    "    \n",
    "    # 2. Total number of packets\n",
    "    num_total_packets = len(size_seq)\n",
    "    \n",
    "    # 3. Number of outgoing packets\n",
    "    num_outgoing_packets = sum(1 for size in size_seq if size > 0)\n",
    "    \n",
    "    # 4. Ratio of outgoing packets to total packets\n",
    "    ratio_outgoing = num_outgoing_packets / num_total_packets if num_total_packets > 0 else 0\n",
    "    \n",
    "    # 5. Ratio of incoming packets to total packets\n",
    "    ratio_incoming = num_incoming_packets / num_total_packets if num_total_packets > 0 else 0\n",
    "    \n",
    "    # 6. Ratio of incoming packets in the first 30 packets\n",
    "    incoming_first_30 = sum(1 for size in size_seq[:30] if size < 0) / 30 if num_total_packets >= 30 else 0\n",
    "    \n",
    "    # 7. Ratio of incoming packets in the first 30 packets to total packets\n",
    "    incoming_first_30_all = sum(1 for size in size_seq[:30] if size < 0) / 30 if num_total_packets >= 30 else 0\n",
    "    \n",
    "    # 8. Maximum number of packets in an outgoing burst\n",
    "    burst_outgoing_max = max(len(list(g)) for k, g in groupby(size_seq) if k > 0) if num_outgoing_packets > 0 else 0\n",
    "    \n",
    "    # 9. Ratio of outgoing packets in the first 30 packets\n",
    "    outgoing_first_30 = sum(1 for size in size_seq[:30] if size > 0) / 30 if num_total_packets >= 30 else 0\n",
    "    \n",
    "    # 10. Ratio of outgoing packets in the first 30 packets to total packets\n",
    "    outgoing_first_30_all = sum(1 for size in size_seq[:30] if size > 0) / 30 if num_total_packets >= 30 else 0\n",
    "    \n",
    "    # 11. Number of packets in the last 5 seconds\n",
    "    last_5_seconds_packets = len([size for size in size_seq[-5:] if size != 0])\n",
    "    \n",
    "    # 12. Standard deviation of packet counts in outgoing bursts\n",
    "    outgoing_burst_std = np.std([len(list(g)) for k, g in groupby(size_seq) if k > 0])\n",
    "    \n",
    "    # 13. Average packet count in outgoing bursts\n",
    "    outgoing_burst_avg = np.mean([len(list(g)) for k, g in groupby(size_seq) if k > 0])\n",
    "    \n",
    "    # 14. Number of outgoing bursts\n",
    "    num_outgoing_bursts = len([1 for k, g in groupby(size_seq) if k > 0])\n",
    "    \n",
    "    # 15. Number of incoming bursts\n",
    "    num_incoming_bursts = len([1 for k, g in groupby(size_seq) if k < 0])\n",
    "    \n",
    "    # 16. Number of packets in incoming bursts in the first 5 seconds\n",
    "    incoming_burst_first_5_seconds = sum(1 for size in size_seq[:5] if size < 0)\n",
    "    \n",
    "    # 17. Number of packets in outgoing bursts in the first 5 seconds\n",
    "    outgoing_burst_first_5_seconds = sum(1 for size in size_seq[:5] if size > 0)\n",
    "    \n",
    "    # 18. Average number of incoming packets per second\n",
    "    incoming_per_second_avg = num_incoming_packets / (len(time_seq) / 60) if len(time_seq) > 0 else 0\n",
    "    \n",
    "    # 19. Ratio of incoming packets in the first 5 packets to total packets\n",
    "    incoming_first_5 = sum(1 for size in size_seq[:5] if size < 0) / 5 if num_total_packets >= 5 else 0\n",
    "    \n",
    "    # 20. Ratio of outgoing packets in the first 5 packets to total packets\n",
    "    outgoing_first_5 = sum(1 for size in size_seq[:5] if size > 0) / 5 if num_total_packets >= 5 else 0\n",
    "    \n",
    "    # 21. Website loading time (total time)\n",
    "    total_time = sum(time_seq)\n",
    "    \n",
    "    # 22. Ratio of incoming packets in the first 5 packets to total packets for incoming packets\n",
    "    incoming_first_5_all = sum(1 for size in size_seq[:5] if size < 0) / 5 if num_total_packets >= 5 else 0\n",
    "    \n",
    "    # 23. Average time interval between packets in the last 5 seconds\n",
    "    last_5_seconds_time_intervals = np.mean([time_seq[i+1] - time_seq[i] for i in range(len(time_seq)-1) if time_seq[i] > 0]) if len(time_seq) > 1 else 0\n",
    "    \n",
    "    # 24. Ratio of outgoing packets in the first 5 packets to total packets for outgoing packets\n",
    "    outgoing_first_5_all = sum(1 for size in size_seq[:5] if size > 0) / 5 if num_total_packets >= 5 else 0\n",
    "\n",
    "    # Append all generated features to the features list\n",
    "    features.append([\n",
    "        num_incoming_packets, num_total_packets, num_outgoing_packets,\n",
    "        ratio_outgoing, ratio_incoming, incoming_first_30, incoming_first_30_all,\n",
    "        burst_outgoing_max, outgoing_first_30, outgoing_first_30_all, last_5_seconds_packets,\n",
    "        outgoing_burst_std, outgoing_burst_avg, num_outgoing_bursts, num_incoming_bursts,\n",
    "        incoming_burst_first_5_seconds, outgoing_burst_first_5_seconds, incoming_per_second_avg,\n",
    "        incoming_first_5, outgoing_first_5, total_time, incoming_first_5_all,\n",
    "        last_5_seconds_time_intervals, outgoing_first_5_all\n",
    "    ])\n",
    "\n",
    "# X is the dataset containing 24 features\n",
    "X = np.array(features)\n",
    "\n",
    "# y is the labels for each sample\n",
    "y = np.array(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-2. Train, Test and Evaluate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7387\n",
      "Precision (Weighted): 0.7409\n",
      "Recall (Weighted): 0.7387\n",
      "F1 Score (Weighted): 0.7342\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score, auc,roc_auc_score, precision_score, precision_recall_curve, roc_curve, recall_score, f1_score, average_precision_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
    "\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "rf_model = RandomForestClassifier(\n",
    "    n_estimators=2000,\n",
    "    min_samples_leaf=2,\n",
    "    max_depth=35,\n",
    "    max_features='sqrt',\n",
    "    random_state=42\n",
    ")\n",
    "\n",
    "rf_model.fit(X_train, y_train)\n",
    "y_pred = rf_model.predict(X_test)\n",
    "\n",
    "# Calculate Accuracy, Precison, Recall, F1 Score\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "precision = precision_score(y_test, y_pred, average = 'weighted')\n",
    "recall = recall_score(y_test, y_pred, average = 'weighted')\n",
    "f1 = f1_score(y_test, y_pred, average='weighted')\n",
    "\n",
    "print(f\"Accuracy: {accuracy:.4f}\")\n",
    "print(f\"Precision (Weighted): {precision:.4f}\")\n",
    "print(f\"Recall (Weighted): {recall:.4f}\")\n",
    "print(f\"F1 Score (Weighted): {f1:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Selection - Experiment 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3-1. Select 32 Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from itertools import groupby\n",
    "\n",
    "# Initialize a list to store all features\n",
    "features = []\n",
    "\n",
    "# Feature extraction\n",
    "for i in range(len(X2)):\n",
    "    size_seq = X2[i]\n",
    "    time_seq = X1[i]\n",
    "    \n",
    "    # 1. Number of incoming packets\n",
    "    num_incoming_packets = sum(1 for size in size_seq if size < 0)\n",
    "    \n",
    "    # 2. Total number of packets\n",
    "    num_total_packets = len(size_seq)\n",
    "    \n",
    "    # 3. Number of outgoing packets\n",
    "    num_outgoing_packets = sum(1 for size in size_seq if size > 0)\n",
    "    \n",
    "    # 4. Proportion of outgoing packets\n",
    "    ratio_outgoing = num_outgoing_packets / num_total_packets if num_total_packets > 0 else 0\n",
    "    \n",
    "    # 5. Proportion of incoming packets\n",
    "    ratio_incoming = num_incoming_packets / num_total_packets if num_total_packets > 0 else 0\n",
    "    \n",
    "    # 6. Proportion of incoming packets in the first 30 packets\n",
    "    incoming_first_30 = sum(1 for size in size_seq[:30] if size < 0) / 30 if num_total_packets >= 30 else 0\n",
    "    \n",
    "    # 7. Proportion of outgoing packets in the first 30 packets\n",
    "    outgoing_first_30 = sum(1 for size in size_seq[:30] if size > 0) / 30 if num_total_packets >= 30 else 0\n",
    "    \n",
    "    # 8. Maximum number of packets in outgoing bursts\n",
    "    burst_outgoing_max = max(len(list(g)) for k, g in groupby(size_seq) if k > 0) if num_outgoing_packets > 0 else 0\n",
    "    \n",
    "    # 9. Number of packets in the last 5 seconds\n",
    "    last_5_seconds_packets = len([size for size in size_seq[-5:] if size != 0])\n",
    "    \n",
    "    # 10. Standard deviation of outgoing burst sizes\n",
    "    outgoing_burst_std = np.std([len(list(g)) for k, g in groupby(size_seq) if k > 0])\n",
    "    \n",
    "    # 11. Average size of outgoing bursts\n",
    "    outgoing_burst_avg = np.mean([len(list(g)) for k, g in groupby(size_seq) if k > 0])\n",
    "    \n",
    "    # 12. Number of outgoing bursts\n",
    "    num_outgoing_bursts = len([1 for k, g in groupby(size_seq) if k > 0])\n",
    "    \n",
    "    # 13. Number of incoming bursts\n",
    "    num_incoming_bursts = len([1 for k, g in groupby(size_seq) if k < 0])\n",
    "    \n",
    "    # 14. Number of incoming packets in the first 5 seconds\n",
    "    incoming_burst_first_5_seconds = sum(1 for size in size_seq[:5] if size < 0)\n",
    "    \n",
    "    # 15. Number of outgoing packets in the first 5 seconds\n",
    "    outgoing_burst_first_5_seconds = sum(1 for size in size_seq[:5] if size > 0)\n",
    "    \n",
    "    # 16. Average number of incoming packets per second\n",
    "    incoming_per_second_avg = num_incoming_packets / (len(time_seq) / 60) if len(time_seq) > 0 else 0\n",
    "    \n",
    "    # 17. Proportion of incoming packets in the first 5 packets\n",
    "    incoming_first_5 = sum(1 for size in size_seq[:5] if size < 0) / 5 if num_total_packets >= 5 else 0\n",
    "    \n",
    "    # 18. Proportion of outgoing packets in the first 5 packets\n",
    "    outgoing_first_5 = sum(1 for size in size_seq[:5] if size > 0) / 5 if num_total_packets >= 5 else 0\n",
    "    \n",
    "    # 19. Total transmission time\n",
    "    total_time = sum(time_seq)\n",
    "    \n",
    "    # 20. Proportion of incoming packets in the first 5 packets (relative to total incoming packets)\n",
    "    incoming_first_5_all = sum(1 for size in size_seq[:5] if size < 0) / 5 if num_total_packets >= 5 else 0\n",
    "    \n",
    "    # 21. Average time interval in the last 5 seconds\n",
    "    last_5_seconds_time_intervals = np.mean([time_seq[i+1] - time_seq[i] for i in range(len(time_seq)-1) if time_seq[i] > 0]) if len(time_seq) > 1 else 0\n",
    "    \n",
    "    # 22. Proportion of outgoing packets in the first 5 packets (relative to total outgoing packets)\n",
    "    outgoing_first_5_all = sum(1 for size in size_seq[:5] if size > 0) / 5 if num_total_packets >= 5 else 0\n",
    "\n",
    "    # 23. Sum of packet sizes\n",
    "    sum_packets = sum(size_seq)\n",
    "    \n",
    "    # 24. Packets per second\n",
    "    packets_per_second = len(size_seq) / sum(time_seq) if sum(time_seq) > 0 else 0\n",
    "    \n",
    "    # 25. Mean packets per second\n",
    "    packets_per_second_values = [1 / t for t in time_seq if t > 0]\n",
    "    mean_packets_per_second = np.mean(packets_per_second_values) if packets_per_second_values else 0\n",
    "    \n",
    "    # 26. Standard deviation of packets per second\n",
    "    std_packets_per_second = np.std(packets_per_second_values) if packets_per_second_values else 0\n",
    "    \n",
    "    # 27. Transmission time Q1 (25th percentile)\n",
    "    transmission_time_Q1 = np.percentile(time_seq, 25) if len(time_seq) > 0 else 0\n",
    "    \n",
    "    # 28. Transmission time Q2 (median)\n",
    "    transmission_time_Q2 = np.percentile(time_seq, 50) if len(time_seq) > 0 else 0\n",
    "    \n",
    "    # 29. Transmission time Q3 (75th percentile)\n",
    "    transmission_time_Q3 = np.percentile(time_seq, 75) if len(time_seq) > 0 else 0\n",
    "    \n",
    "    # 30. Transmission time Q4 (maximum)\n",
    "    transmission_time_Q4 = np.percentile(time_seq, 100) if len(time_seq) > 0 else 0\n",
    "    \n",
    "    # 31. Average ordering of outgoing packets\n",
    "    outgoing_order = [i for i, size in enumerate(size_seq) if size > 0]\n",
    "    average_outgoing_ordering = np.mean(outgoing_order) if outgoing_order else 0\n",
    "    \n",
    "    # 32. Standard deviation of outgoing packet ordering\n",
    "    std_dev_outgoing_ordering = np.std(outgoing_order) if outgoing_order else 0\n",
    "    \n",
    "    # Add all features to the list\n",
    "    features.append([\n",
    "        num_incoming_packets, num_total_packets, num_outgoing_packets, ratio_outgoing,\n",
    "        ratio_incoming, incoming_first_30, outgoing_first_30, burst_outgoing_max,\n",
    "        last_5_seconds_packets, outgoing_burst_std, outgoing_burst_avg, num_outgoing_bursts,\n",
    "        num_incoming_bursts, incoming_burst_first_5_seconds, outgoing_burst_first_5_seconds,\n",
    "        incoming_per_second_avg, incoming_first_5, outgoing_first_5, total_time,\n",
    "        incoming_first_5_all, last_5_seconds_time_intervals, outgoing_first_5_all,\n",
    "        sum_packets, packets_per_second, mean_packets_per_second, std_packets_per_second,\n",
    "        transmission_time_Q1, transmission_time_Q2, transmission_time_Q3, transmission_time_Q4,\n",
    "        average_outgoing_ordering, std_dev_outgoing_ordering\n",
    "    ])\n",
    "\n",
    "# Convert the feature list to a numpy array\n",
    "X = np.array(features)\n",
    "\n",
    "# Labels for each sample\n",
    "y = np.array(y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3-2. Train, Test and Evaluate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7889\n",
      "Precision (Weighted): 0.7935\n",
      "Recall (Weighted): 0.7889\n",
      "F1 Score (Weighted): 0.7867\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score, auc,roc_auc_score, precision_score, precision_recall_curve, roc_curve, recall_score, f1_score, average_precision_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
    "\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "rf_model = RandomForestClassifier(\n",
    "    n_estimators=2000,\n",
    "    min_samples_leaf=2,\n",
    "    max_depth=35,\n",
    "    max_features='sqrt',\n",
    "    random_state=42\n",
    ")\n",
    "\n",
    "rf_model.fit(X_train, y_train)\n",
    "y_pred = rf_model.predict(X_test)\n",
    "\n",
    "# Calculate Accuracy, Precison, Recall, F1 Score\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "precision = precision_score(y_test, y_pred, average = 'weighted')\n",
    "recall = recall_score(y_test, y_pred, average = 'weighted')\n",
    "f1 = f1_score(y_test, y_pred, average='weighted')\n",
    "\n",
    "print(f\"Accuracy: {accuracy:.4f}\")\n",
    "print(f\"Precision (Weighted): {precision:.4f}\")\n",
    "print(f\"Recall (Weighted): {recall:.4f}\")\n",
    "print(f\"F1 Score (Weighted): {f1:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Selection - Experiment 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4-1. Compute Feature Importances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature Importance (Top 10):\n",
      "                      Feature  Importance\n",
      "30  average_outgoing_ordering    0.067711\n",
      "31  std_dev_outgoing_ordering    0.062392\n",
      "1           num_total_packets    0.060027\n",
      "22                sum_packets    0.056494\n",
      "0        num_incoming_packets    0.055130\n",
      "2        num_outgoing_packets    0.054016\n",
      "15    incoming_per_second_avg    0.049784\n",
      "3              ratio_outgoing    0.049653\n",
      "4              ratio_incoming    0.049281\n",
      "9          outgoing_burst_std    0.048912\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7889\n",
      "Precision (Weighted): 0.7935\n",
      "Recall (Weighted): 0.7889\n",
      "F1 Score (Weighted): 0.7867\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
    "\n",
    "# Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
    "\n",
    "# Standardize the features\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "# Train the RandomForestClassifier\n",
    "rf_model = RandomForestClassifier(\n",
    "    n_estimators=2000,\n",
    "    min_samples_leaf=2,\n",
    "    max_depth=35,\n",
    "    max_features='sqrt',\n",
    "    random_state=42\n",
    ")\n",
    "\n",
    "rf_model.fit(X_train, y_train)\n",
    "\n",
    "# Get feature importances\n",
    "feature_importances = rf_model.feature_importances_\n",
    "\n",
    "# Create a DataFrame to store the feature names and their importance\n",
    "feature_names = [\n",
    "    'num_incoming_packets', 'num_total_packets', 'num_outgoing_packets', 'ratio_outgoing',\n",
    "    'ratio_incoming', 'incoming_first_30', 'outgoing_first_30', 'burst_outgoing_max',\n",
    "    'last_5_seconds_packets', 'outgoing_burst_std', 'outgoing_burst_avg', 'num_outgoing_bursts',\n",
    "    'num_incoming_bursts', 'incoming_burst_first_5_seconds', 'outgoing_burst_first_5_seconds',\n",
    "    'incoming_per_second_avg', 'incoming_first_5', 'outgoing_first_5', 'total_time',\n",
    "    'incoming_first_5_all', 'last_5_seconds_time_intervals', 'outgoing_first_5_all',\n",
    "    'sum_packets', 'packets_per_second', 'mean_packets_per_second', 'std_packets_per_second',\n",
    "    'transmission_time_Q1', 'transmission_time_Q2', 'transmission_time_Q3', 'transmission_time_Q4',\n",
    "    'average_outgoing_ordering', 'std_dev_outgoing_ordering'\n",
    "]\n",
    "\n",
    "# Create a DataFrame for feature importances\n",
    "feature_importance_df = pd.DataFrame({\n",
    "    'Feature': feature_names,\n",
    "    'Importance': feature_importances\n",
    "})\n",
    "\n",
    "# Sort by importance\n",
    "feature_importance_df = feature_importance_df.sort_values(by='Importance', ascending=False)\n",
    "\n",
    "# Print the top 10 important features\n",
    "print(\"Feature Importance (Top 10):\")\n",
    "print(feature_importance_df.head(10))\n",
    "\n",
    "# Optionally, plot the feature importances\n",
    "plt.figure(figsize=(12, 8))\n",
    "plt.barh(feature_importance_df['Feature'], feature_importance_df['Importance'], color='skyblue')\n",
    "plt.xlabel('Importance')\n",
    "plt.ylabel('Features')\n",
    "plt.title('Feature Importance')\n",
    "plt.gca().invert_yaxis()  # Reverse the order for better readability\n",
    "plt.show()\n",
    "\n",
    "# Calculate model performance\n",
    "y_pred = rf_model.predict(X_test)\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "precision = precision_score(y_test, y_pred, average='weighted')\n",
    "recall = recall_score(y_test, y_pred, average='weighted')\n",
    "f1 = f1_score(y_test, y_pred, average='weighted')\n",
    "\n",
    "# Print model performance metrics\n",
    "print(f\"Accuracy: {accuracy:.4f}\")\n",
    "print(f\"Precision (Weighted): {precision:.4f}\")\n",
    "print(f\"Recall (Weighted): {recall:.4f}\")\n",
    "print(f\"F1 Score (Weighted): {f1:.4f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4-2. Remove unnecessary features and keep only 26 features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from itertools import groupby\n",
    "\n",
    "# Initialize a list to store all features\n",
    "features = []\n",
    "\n",
    "# Feature extraction\n",
    "for i in range(len(X2)): \n",
    "    size_seq = X2[i-]\n",
    "    time_seq = X1[i]\n",
    "    \n",
    "    # 1. Number of incoming packets\n",
    "    num_incoming_packets = sum(1 for size in size_seq if size < 0)\n",
    "    \n",
    "    # 2. Total number of packets\n",
    "    num_total_packets = len(size_seq)\n",
    "    \n",
    "    # 3. Number of outgoing packets\n",
    "    num_outgoing_packets = sum(1 for size in size_seq if size > 0)\n",
    "    \n",
    "    # 4. Proportion of outgoing packets\n",
    "    ratio_outgoing = num_outgoing_packets / num_total_packets if num_total_packets > 0 else 0\n",
    "    \n",
    "    # 5. Proportion of incoming packets\n",
    "    ratio_incoming = num_incoming_packets / num_total_packets if num_total_packets > 0 else 0\n",
    "    \n",
    "    # 6. Proportion of incoming packets in the first 30 packets\n",
    "    incoming_first_30 = sum(1 for size in size_seq[:30] if size < 0) / 30 if num_total_packets >= 30 else 0\n",
    "    \n",
    "    # 7. Proportion of outgoing packets in the first 30 packets\n",
    "    outgoing_first_30 = sum(1 for size in size_seq[:30] if size > 0) / 30 if num_total_packets >= 30 else 0\n",
    "    \n",
    "    # 8. Maximum number of packets in outgoing bursts\n",
    "    burst_outgoing_max = max(len(list(g)) for k, g in groupby(size_seq) if k > 0) if num_outgoing_packets > 0 else 0\n",
    "    \n",
    "    # 9. Standard deviation of outgoing burst sizes\n",
    "    outgoing_burst_std = np.std([len(list(g)) for k, g in groupby(size_seq) if k > 0])\n",
    "    \n",
    "    # 10. Average size of outgoing bursts\n",
    "    outgoing_burst_avg = np.mean([len(list(g)) for k, g in groupby(size_seq) if k > 0])\n",
    "    \n",
    "    # 11. Number of outgoing bursts\n",
    "    num_outgoing_bursts = len([1 for k, g in groupby(size_seq) if k > 0])\n",
    "    \n",
    "    # 12. Number of incoming bursts\n",
    "    num_incoming_bursts = len([1 for k, g in groupby(size_seq) if k < 0])\n",
    "    \n",
    "    # 13. Average number of incoming packets per second\n",
    "    incoming_per_second_avg = num_incoming_packets / (len(time_seq) / 60) if len(time_seq) > 0 else 0\n",
    "\n",
    "    # 14. Total transmission time\n",
    "    total_time = sum(time_seq)\n",
    "\n",
    "    # 15. Average time interval in the last 5 seconds\n",
    "    last_5_seconds_time_intervals = np.mean([time_seq[i+1] - time_seq[i] for i in range(len(time_seq)-1) if time_seq[i] > 0]) if len(time_seq) > 1 else 0\n",
    "    \n",
    "    # 16. Sum of packet sizes\n",
    "    sum_packets = sum(size_seq)\n",
    "    \n",
    "    # 17. Packets per second\n",
    "    packets_per_second = len(size_seq) / sum(time_seq) if sum(time_seq) > 0 else 0\n",
    "    \n",
    "    # 18. Mean packets per second\n",
    "    packets_per_second_values = [1 / t for t in time_seq if t > 0]\n",
    "    \n",
    "    # 19. mean of the packets per second values\n",
    "    mean_packets_per_second = np.mean(packets_per_second_values) if packets_per_second_values else 0\n",
    "    \n",
    "    # 20. Standard deviation of packets per second\n",
    "    std_packets_per_second = np.std(packets_per_second_values) if packets_per_second_values else 0\n",
    "    \n",
    "    # 21. Transmission time Q1 (25th percentile)\n",
    "    transmission_time_Q1 = np.percentile(time_seq, 25) if len(time_seq) > 0 else 0\n",
    "    \n",
    "    # 22. Transmission time Q2 (median)\n",
    "    transmission_time_Q2 = np.percentile(time_seq, 50) if len(time_seq) > 0 else 0\n",
    "    \n",
    "    # 23. Transmission time Q3 (75th percentile)\n",
    "    transmission_time_Q3 = np.percentile(time_seq, 75) if len(time_seq) > 0 else 0\n",
    "    \n",
    "    # 24. Transmission time Q4 (maximum)\n",
    "    transmission_time_Q4 = np.percentile(time_seq, 100) if len(time_seq) > 0 else 0\n",
    "    \n",
    "    # 25. Average ordering of outgoing packets\n",
    "    outgoing_order = [i for i, size in enumerate(size_seq) if size > 0]\n",
    "    average_outgoing_ordering = np.mean(outgoing_order) if outgoing_order else 0\n",
    "    \n",
    "    # 26. Standard deviation of outgoing packet ordering\n",
    "    std_dev_outgoing_ordering = np.std(outgoing_order) if outgoing_order else 0\n",
    "    \n",
    "    # Add all features to the list\n",
    "    features.append([\n",
    "        num_incoming_packets, num_total_packets, num_outgoing_packets, ratio_outgoing,\n",
    "        ratio_incoming, incoming_first_30, outgoing_first_30, burst_outgoing_max,\n",
    "        outgoing_burst_std, outgoing_burst_avg, num_outgoing_bursts,\n",
    "        num_incoming_bursts, incoming_per_second_avg,  total_time,\n",
    "        last_5_seconds_time_intervals, \n",
    "        sum_packets, packets_per_second, mean_packets_per_second, std_packets_per_second,\n",
    "        transmission_time_Q1, transmission_time_Q2, transmission_time_Q3, transmission_time_Q4,\n",
    "        average_outgoing_ordering, std_dev_outgoing_ordering\n",
    "    ])\n",
    "\n",
    "# Convert the feature list to a numpy array\n",
    "X = np.array(features)\n",
    "\n",
    "# Labels for each sample\n",
    "y = np.array(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4-3. Train, Test and Evaluate the Final model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7937\n",
      "Precision (Weighted): 0.7966\n",
      "Recall (Weighted): 0.7937\n",
      "F1 Score (Weighted): 0.7913\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score, auc,roc_auc_score, precision_score, precision_recall_curve, roc_curve, recall_score, f1_score, average_precision_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
    "\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "rf_model = RandomForestClassifier(\n",
    "    n_estimators=2000,\n",
    "    min_samples_leaf=2,\n",
    "    max_depth=35,\n",
    "    max_features='sqrt',\n",
    "    random_state=42\n",
    ")\n",
    "\n",
    "rf_model.fit(X_train, y_train)\n",
    "y_pred = rf_model.predict(X_test)\n",
    "\n",
    "# Calculate Accuracy, Precison, Recall, F1 Score\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "precision = precision_score(y_test, y_pred, average = 'weighted')\n",
    "recall = recall_score(y_test, y_pred, average = 'weighted')\n",
    "f1 = f1_score(y_test, y_pred, average='weighted')\n",
    "\n",
    "print(f\"Accuracy: {accuracy:.4f}\")\n",
    "print(f\"Precision (Weighted): {precision:.4f}\")\n",
    "print(f\"Recall (Weighted): {recall:.4f}\")\n",
    "print(f\"F1 Score (Weighted): {f1:.4f}\")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "gpuClass": "standard",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}