FlowClassification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "n20VxiLpVujk"
      },
      "outputs": [],
      "source": [
        "import pandas as pd"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df=pd.read_csv('/content/dataset_sdn (1).csv', memory_map=True, header='infer')"
      ],
      "metadata": {
        "id": "Y-JSIRFYV7dy"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for column in df.columns:\n",
        "    print(f\"Column: {column}\")\n",
        "    print(df[column].value_counts())\n",
        "    print(\"------------------------\")"
      ],
      "metadata": {
        "id": "nXNyfLnCXdTu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df['Protocol'].unique()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fZ-DOZgG87J_",
        "outputId": "2956aca3-2086-4607-d7ee-0c32e5d530a8"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array(['UDP', 'TCP', 'ICMP'], dtype=object)"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df['src'] = df['src'].str.split('.').str[-1]\n",
        "df['dst'] = df['dst'].str.split('.').str[-1]\n",
        "\n",
        "protocol_mapping = {'TCP': -1, 'UDP': 0, 'ICMP': 1}\n",
        "df['Protocol'] = df['Protocol'].replace(protocol_mapping)"
      ],
      "metadata": {
        "id": "dbUR5atZ8-Wh"
      },
      "execution_count": 67,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 256
        },
        "id": "FrMZRws0-D6U",
        "outputId": "d83acea6-a540-4293-96dd-ef08c0296d27"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "         dt  switch src dst  pktcount  bytecount       dur  dur_nsec  \\\n",
              "0 -0.542890       1   1   8  0.174242   0.328245 -0.781249  0.919175   \n",
              "1 -0.527862       1   1   8  0.486123   0.915781 -0.146367  0.984157   \n",
              "2 -0.542890       1   2   8  0.347427   0.654498 -0.428537  1.020258   \n",
              "3 -0.542890       1   2   8  0.347427   0.654498 -0.428537  1.020258   \n",
              "4 -0.542890       1   2   8  0.347427   0.654498 -0.428537  1.020258   \n",
              "\n",
              "    tot_dur  flows  ...  pktrate  Pairflow  Protocol  port_no  tx_bytes  \\\n",
              "0 -0.779412      3  ...  0.96733         0         0        3  0.333532   \n",
              "1 -0.144270      2  ...  0.96733         0         0        4 -0.613732   \n",
              "2 -0.426555      3  ...  0.96733         0         0        1 -0.613733   \n",
              "3 -0.426555      3  ...  0.96733         0         0        2 -0.613733   \n",
              "4 -0.426555      3  ...  0.96733         0         0        3 -0.613735   \n",
              "\n",
              "   rx_bytes   tx_kbps  rx_kbps  tot_kbps  label  \n",
              "0 -0.701328 -0.412179      0.0       0.0      0  \n",
              "1 -0.701331 -0.412179      0.0       0.0      0  \n",
              "2 -0.701348 -0.412179      0.0       0.0      0  \n",
              "3 -0.701346 -0.412179      0.0       0.0      0  \n",
              "4 -0.701330 -0.412179      0.0       0.0      0  \n",
              "\n",
              "[5 rows x 23 columns]"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-c0cffb5f-ff27-4122-9d0e-5a6e4646acdd\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>dt</th>\n",
              "      <th>switch</th>\n",
              "      <th>src</th>\n",
              "      <th>dst</th>\n",
              "      <th>pktcount</th>\n",
              "      <th>bytecount</th>\n",
              "      <th>dur</th>\n",
              "      <th>dur_nsec</th>\n",
              "      <th>tot_dur</th>\n",
              "      <th>flows</th>\n",
              "      <th>...</th>\n",
              "      <th>pktrate</th>\n",
              "      <th>Pairflow</th>\n",
              "      <th>Protocol</th>\n",
              "      <th>port_no</th>\n",
              "      <th>tx_bytes</th>\n",
              "      <th>rx_bytes</th>\n",
              "      <th>tx_kbps</th>\n",
              "      <th>rx_kbps</th>\n",
              "      <th>tot_kbps</th>\n",
              "      <th>label</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>-0.542890</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>8</td>\n",
              "      <td>0.174242</td>\n",
              "      <td>0.328245</td>\n",
              "      <td>-0.781249</td>\n",
              "      <td>0.919175</td>\n",
              "      <td>-0.779412</td>\n",
              "      <td>3</td>\n",
              "      <td>...</td>\n",
              "      <td>0.96733</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "      <td>0.333532</td>\n",
              "      <td>-0.701328</td>\n",
              "      <td>-0.412179</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>-0.527862</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>8</td>\n",
              "      <td>0.486123</td>\n",
              "      <td>0.915781</td>\n",
              "      <td>-0.146367</td>\n",
              "      <td>0.984157</td>\n",
              "      <td>-0.144270</td>\n",
              "      <td>2</td>\n",
              "      <td>...</td>\n",
              "      <td>0.96733</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>4</td>\n",
              "      <td>-0.613732</td>\n",
              "      <td>-0.701331</td>\n",
              "      <td>-0.412179</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>-0.542890</td>\n",
              "      <td>1</td>\n",
              "      <td>2</td>\n",
              "      <td>8</td>\n",
              "      <td>0.347427</td>\n",
              "      <td>0.654498</td>\n",
              "      <td>-0.428537</td>\n",
              "      <td>1.020258</td>\n",
              "      <td>-0.426555</td>\n",
              "      <td>3</td>\n",
              "      <td>...</td>\n",
              "      <td>0.96733</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>-0.613733</td>\n",
              "      <td>-0.701348</td>\n",
              "      <td>-0.412179</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>-0.542890</td>\n",
              "      <td>1</td>\n",
              "      <td>2</td>\n",
              "      <td>8</td>\n",
              "      <td>0.347427</td>\n",
              "      <td>0.654498</td>\n",
              "      <td>-0.428537</td>\n",
              "      <td>1.020258</td>\n",
              "      <td>-0.426555</td>\n",
              "      <td>3</td>\n",
              "      <td>...</td>\n",
              "      <td>0.96733</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>2</td>\n",
              "      <td>-0.613733</td>\n",
              "      <td>-0.701346</td>\n",
              "      <td>-0.412179</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>-0.542890</td>\n",
              "      <td>1</td>\n",
              "      <td>2</td>\n",
              "      <td>8</td>\n",
              "      <td>0.347427</td>\n",
              "      <td>0.654498</td>\n",
              "      <td>-0.428537</td>\n",
              "      <td>1.020258</td>\n",
              "      <td>-0.426555</td>\n",
              "      <td>3</td>\n",
              "      <td>...</td>\n",
              "      <td>0.96733</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "      <td>-0.613735</td>\n",
              "      <td>-0.701330</td>\n",
              "      <td>-0.412179</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>5 rows × 23 columns</p>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-c0cffb5f-ff27-4122-9d0e-5a6e4646acdd')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-c0cffb5f-ff27-4122-9d0e-5a6e4646acdd button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-c0cffb5f-ff27-4122-9d0e-5a6e4646acdd');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-c380c3f2-a679-40b2-99f9-65e8ede02ee7\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-c380c3f2-a679-40b2-99f9-65e8ede02ee7')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-c380c3f2-a679-40b2-99f9-65e8ede02ee7 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "variable_name": "df"
            }
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n",
        "from scipy.stats import skew, kurtosis\n",
        "\n",
        "columns_to_normalize = ['dt', 'pktcount', 'bytecount', 'dur', 'dur_nsec', 'tot_dur',\n",
        "                         'packetins', 'pktperflow', 'byteperflow', 'pktrate',\n",
        "                         'tx_bytes', 'rx_bytes', 'tx_kbps', 'rx_kbps', 'tot_kbps']\n",
        "\n",
        "for column in df.columns:\n",
        "    if column in columns_to_normalize:\n",
        "        skewness = skew(df[column])\n",
        "        kurt = kurtosis(df[column])\n",
        "\n",
        "        if abs(skewness) > 1 or abs(kurt) > 1:\n",
        "            # Apply Standardization for skewed or kurtotic data\n",
        "            scaler = StandardScaler()\n",
        "            df[column] = scaler.fit_transform(df[[column]])\n",
        "            print(f\"Applied Standardization to column: {column}\")\n",
        "        else:\n",
        "            # Apply Min-Max Scaling for approximately normally distributed data\n",
        "            scaler = MinMaxScaler()\n",
        "            df[column] = scaler.fit_transform(df[[column]])\n",
        "            print(f\"Applied Min-Max Scaling to column: {column}\")\n",
        "\n",
        "# Display the normalized DataFrame\n",
        "print(df)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ok7fGBukA5sw",
        "outputId": "a8be62e9-c165-4eaa-8cc6-0b4da49bc947"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Applied Standardization to column: dt\n",
            "Applied Min-Max Scaling to column: pktcount\n",
            "Applied Min-Max Scaling to column: bytecount\n",
            "Applied Standardization to column: dur\n",
            "Applied Standardization to column: dur_nsec\n",
            "Applied Standardization to column: tot_dur\n",
            "Applied Standardization to column: packetins\n",
            "Applied Standardization to column: pktperflow\n",
            "Applied Standardization to column: byteperflow\n",
            "Applied Standardization to column: pktrate\n",
            "Applied Standardization to column: tx_bytes\n",
            "Applied Standardization to column: rx_bytes\n",
            "Applied Standardization to column: tx_kbps\n",
            "Applied Min-Max Scaling to column: rx_kbps\n",
            "Applied Min-Max Scaling to column: tot_kbps\n",
            "              dt  switch src dst  pktcount  bytecount       dur  dur_nsec  \\\n",
            "0      -0.542890       1   1   8  0.174242   0.328245 -0.781249  0.919175   \n",
            "1      -0.527862       1   1   8  0.486123   0.915781 -0.146367  0.984157   \n",
            "2      -0.542890       1   2   8  0.347427   0.654498 -0.428537  1.020258   \n",
            "3      -0.542890       1   2   8  0.347427   0.654498 -0.428537  1.020258   \n",
            "4      -0.542890       1   2   8  0.347427   0.654498 -0.428537  1.020258   \n",
            "...          ...     ...  ..  ..       ...        ...       ...       ...   \n",
            "104340 -1.057435       3   5   7  0.000304   0.000053 -0.848265  1.374048   \n",
            "104341 -1.057435       3   5   7  0.000304   0.000053 -0.848265  1.374048   \n",
            "104342 -1.057435       3  11   5  0.000119   0.000021 -1.024621  1.240474   \n",
            "104343 -1.057435       3  11   5  0.000119   0.000021 -1.024621  1.240474   \n",
            "104344 -1.057435       3  11   5  0.000119   0.000021 -1.024621  1.240474   \n",
            "\n",
            "         tot_dur  flows  ...   pktrate  Pairflow  Protocol  port_no  tx_bytes  \\\n",
            "0      -0.779412      3  ...  0.967330         0         0        3  0.333532   \n",
            "1      -0.144270      2  ...  0.967330         0         0        4 -0.613732   \n",
            "2      -0.426555      3  ...  0.967330         0         0        1 -0.613733   \n",
            "3      -0.426555      3  ...  0.967330         0         0        2 -0.613733   \n",
            "4      -0.426555      3  ...  0.967330         0         0        3 -0.613735   \n",
            "...          ...    ...  ...       ...       ...       ...      ...       ...   \n",
            "104340 -0.847012      5  ... -0.859661         0         1        1 -0.613657   \n",
            "104341 -0.847012      5  ... -0.859661         0         1        3 -0.613658   \n",
            "104342 -1.023570      5  ... -0.855610         0         1        2 -0.613735   \n",
            "104343 -1.023570      5  ... -0.855610         0         1        1 -0.613657   \n",
            "104344 -1.023570      5  ... -0.855610         0         1        3 -0.613658   \n",
            "\n",
            "        rx_bytes   tx_kbps  rx_kbps  tot_kbps  label  \n",
            "0      -0.701328 -0.412179  0.00000  0.000000      0  \n",
            "1      -0.701331 -0.412179  0.00000  0.000000      0  \n",
            "2      -0.701348 -0.412179  0.00000  0.000000      0  \n",
            "3      -0.701346 -0.412179  0.00000  0.000000      0  \n",
            "4      -0.701330 -0.412179  0.00000  0.000000      0  \n",
            "...          ...       ...      ...       ...    ...  \n",
            "104340 -0.701262 -0.411767  0.00006  0.000097      0  \n",
            "104341 -0.701247 -0.411767  0.00006  0.000097      0  \n",
            "104342 -0.701329 -0.412179  0.00000  0.000000      0  \n",
            "104343 -0.701262 -0.411767  0.00006  0.000097      0  \n",
            "104344 -0.701247 -0.411767  0.00006  0.000097      0  \n",
            "\n",
            "[104345 rows x 23 columns]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# ONE-HOT ENCODING"
      ],
      "metadata": {
        "id": "grH-15y04Z_K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df_one_hot = pd.get_dummies(df, columns=['switch', 'dst', 'src', 'flows', 'Protocol', 'port_no'], prefix=['switch', 'dst', 'src', 'flows', 'Protocol', 'port_no'])"
      ],
      "metadata": {
        "id": "9P8B7dF4bNZl"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# IMPUTATION WITH ONE-HOT ENCODING"
      ],
      "metadata": {
        "id": "SNmST8Fsn1Kh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Get count of null values in each column\n",
        "null_count = df_one_hot.isnull().sum()\n",
        "\n",
        "# Display the count of null values\n",
        "for index,value in enumerate(null_count):\n",
        "  if (value!=0):\n",
        "    print(list(df_one_hot.columns)[index])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RbyFazqLk7iv",
        "outputId": "9230a0e0-35bd-4423-e50c-9d34e5b58010"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "rx_kbps\n",
            "tot_kbps\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "from sklearn.impute import KNNImputer\n",
        "from sklearn.impute import SimpleImputer\n",
        "\n",
        "# Assuming df_one_hot is your DataFrame\n",
        "# df_one_hot = pd.read_csv('your_file.csv')\n",
        "\n",
        "# Selecting columns with missing values\n",
        "columns_with_missing = ['rx_kbps', 'tot_kbps']\n",
        "df_missing = df_one_hot[columns_with_missing]\n",
        "\n",
        "# Hot-Deck (HD) Imputation\n",
        "# Filling missing values with the next available observation\n",
        "df_hd = df_missing.fillna(method='bfill')\n",
        "\n",
        "# Expectation Maximization (EM) Imputation\n",
        "# Using SimpleImputer with EM method\n",
        "em_imputer = SimpleImputer(strategy='constant', fill_value=None)  # EM is the default strategy\n",
        "df_em = pd.DataFrame(em_imputer.fit_transform(df_missing), columns=df_missing.columns)\n",
        "\n",
        "# K-Nearest Neighbor (KNN) Imputation\n",
        "knn_imputer = KNNImputer(n_neighbors=5)  # Using 5 nearest neighbors\n",
        "df_knn = pd.DataFrame(knn_imputer.fit_transform(df_missing), columns=df_missing.columns)\n",
        "\n",
        "# Comparing the imputed values\n",
        "print(\"Hot-Deck Imputation:\")\n",
        "print(df_hd.head())\n",
        "print(\"\\nExpectation Maximization (EM) Imputation:\")\n",
        "print(df_em.head())\n",
        "print(\"\\nK-Nearest Neighbor (KNN) Imputation:\")\n",
        "print(df_knn.head())\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JeIkUtJinWct",
        "outputId": "75e6f8a6-3bee-40c8-86b0-285b59208c94"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hot-Deck Imputation:\n",
            "   rx_kbps  tot_kbps\n",
            "0      0.0       0.0\n",
            "1      0.0       0.0\n",
            "2      0.0       0.0\n",
            "3      0.0       0.0\n",
            "4      0.0       0.0\n",
            "\n",
            "Expectation Maximization (EM) Imputation:\n",
            "   rx_kbps  tot_kbps\n",
            "0      0.0       0.0\n",
            "1      0.0       0.0\n",
            "2      0.0       0.0\n",
            "3      0.0       0.0\n",
            "4      0.0       0.0\n",
            "\n",
            "K-Nearest Neighbor (KNN) Imputation:\n",
            "   rx_kbps  tot_kbps\n",
            "0      0.0       0.0\n",
            "1      0.0       0.0\n",
            "2      0.0       0.0\n",
            "3      0.0       0.0\n",
            "4      0.0       0.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Replace missing values in df_one_hot with imputed values\n",
        "df_one_hot_hd = df_one_hot.copy()\n",
        "df_one_hot_em = df_one_hot.copy()\n",
        "df_one_hot_knn = df_one_hot.copy()\n",
        "\n",
        "df_one_hot_hd[columns_with_missing] = df_hd\n",
        "df_one_hot_em[columns_with_missing] = df_em\n",
        "df_one_hot_knn[columns_with_missing] = df_knn\n"
      ],
      "metadata": {
        "id": "bMeaOA85nQb5"
      },
      "execution_count": 39,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "# Define features (X) and target (y)\n",
        "X_hd = df_one_hot_hd.drop('label', axis=1)\n",
        "y_hd = df_one_hot_hd['label']\n",
        "\n",
        "X_em = df_one_hot_em.drop('label', axis=1)\n",
        "y_em = df_one_hot_em['label']\n",
        "\n",
        "X_knn = df_one_hot_knn.drop('label', axis=1)\n",
        "y_knn = df_one_hot_knn['label']\n",
        "\n",
        "# Split the data\n",
        "X_train_hd, X_test_hd, y_train_hd, y_test_hd = train_test_split(X_hd, y_hd, test_size=0.2, random_state=42)\n",
        "X_train_em, X_test_em, y_train_em, y_test_em = train_test_split(X_em, y_em, test_size=0.2, random_state=42)\n",
        "X_train_knn, X_test_knn, y_train_knn, y_test_knn = train_test_split(X_knn, y_knn, test_size=0.2, random_state=42)\n"
      ],
      "metadata": {
        "id": "kB2a2q-1niDe"
      },
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.metrics import accuracy_score\n",
        "\n",
        "# Initialize RandomForestClassifier\n",
        "clf = RandomForestClassifier(random_state=42)\n",
        "\n",
        "# Train the model with Hot-Deck imputed data\n",
        "clf.fit(X_train_hd, y_train_hd)\n",
        "y_pred_hd = clf.predict(X_test_hd)\n",
        "accuracy_hd = accuracy_score(y_test_hd, y_pred_hd)\n",
        "\n",
        "# Train the model with Expectation Maximization (EM) imputed data\n",
        "clf.fit(X_train_em, y_train_em)\n",
        "y_pred_em = clf.predict(X_test_em)\n",
        "accuracy_em = accuracy_score(y_test_em, y_pred_em)\n",
        "\n",
        "# Train the model with K-Nearest Neighbor (KNN) imputed data\n",
        "clf.fit(X_train_knn, y_train_knn)\n",
        "y_pred_knn = clf.predict(X_test_knn)\n",
        "accuracy_knn = accuracy_score(y_test_knn, y_pred_knn)\n",
        "\n",
        "print(f\"Accuracy with Hot-Deck imputation: {accuracy_hd:.4f}\")\n",
        "print(f\"Accuracy with Expectation Maximization (EM) imputation: {accuracy_em:.4f}\")\n",
        "print(f\"Accuracy with K-Nearest Neighbor (KNN) imputation: {accuracy_knn:.4f}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y0aLmCAVnlJJ",
        "outputId": "49a67ebc-b987-4765-f040-afaf5b255b63"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy with Hot-Deck imputation: 0.9997\n",
            "Accuracy with Expectation Maximization (EM) imputation: 0.9998\n",
            "Accuracy with K-Nearest Neighbor (KNN) imputation: 0.9999\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Compare the accuracies\n",
        "if accuracy_hd > accuracy_em and accuracy_hd > accuracy_knn:\n",
        "    print(\"Hot-Deck imputation performs the best.\")\n",
        "elif accuracy_em > accuracy_hd and accuracy_em > accuracy_knn:\n",
        "    print(\"Expectation Maximization (EM) imputation performs the best.\")\n",
        "else:\n",
        "    print(\"K-Nearest Neighbor (KNN) imputation performs the best.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ubZQelc-nnpG",
        "outputId": "1f164b4e-3857-4f4f-efba-bfe2c93e1cf8"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "K-Nearest Neighbor (KNN) imputation performs the best.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# FEATURE SELECTION AFTER ONE-HOT ENCODING"
      ],
      "metadata": {
        "id": "zcrcdIGKoUcs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.feature_selection import RFECV\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "# Assuming df_one_hot is your DataFrame\n",
        "# df_one_hot = pd.read_csv('your_file.csv')\n",
        "\n",
        "# Splitting the data into features (X) and target (y)\n",
        "X = df_one_hot_knn.drop('label', axis=1)  # Features\n",
        "y = df_one_hot_knn['label']  # Target\n",
        "\n",
        "# Initialize Random Forest Classifier\n",
        "rf_classifier = RandomForestClassifier(random_state=42)\n",
        "\n",
        "# Initialize RFECV\n",
        "rfecv = RFECV(estimator=rf_classifier, step=1, cv=5, scoring='accuracy', n_jobs=-1)\n",
        "\n",
        "# Fit RFECV\n",
        "rfecv.fit(X, y)"
      ],
      "metadata": {
        "id": "6z23rTebkZse"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the optimal number of features\n",
        "print(f\"Optimal number of features: {rfecv.n_features_}\")\n",
        "\n",
        "# Get the selected features\n",
        "selected_features = X.columns[rfecv.support_].tolist()\n",
        "print(\"Selected features:\")\n",
        "print(selected_features)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cvL1Vdm620Xd",
        "outputId": "47e06e95-0c3c-4cda-acd5-e77b478ab210"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimal number of features: 6\n",
            "Selected features:\n",
            "['pktcount', 'bytecount', 'packetins', 'pktperflow', 'byteperflow', 'pktrate']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Plot number of features vs. cross-validation scores\n",
        "plt.figure(figsize=(10, 6))\n",
        "plt.xlabel(\"Number of features selected\")\n",
        "plt.ylabel(\"Cross validation score (accuracy)\")\n",
        "plt.plot(range(1, len(rfecv.cv_results_['mean_test_score']) + 1), rfecv.cv_results_['mean_test_score'])\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 542
        },
        "id": "RbNgwjhD2ywY",
        "outputId": "e678d296-579e-41e8-abca-a9df2beb86c5"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# IMPUTATION WITHOUT ONE-HOT ENCODING"
      ],
      "metadata": {
        "id": "uHukAedo37Ba"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Assuming df_one_hot is your DataFrame\n",
        "# df_one_hot = pd.read_csv('your_file.csv')\n",
        "\n",
        "# Get count of null values in each column\n",
        "null_count = df.isnull().sum()\n",
        "\n",
        "# Display the count of null values\n",
        "for index,value in enumerate(null_count):\n",
        "  if (value!=0):\n",
        "    print(list(df.columns)[index])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f42de58c-40ce-400e-8deb-9984cf6090fa",
        "id": "-ZfOmzLS7LKI"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "rx_kbps\n",
            "tot_kbps\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "from sklearn.impute import KNNImputer\n",
        "from sklearn.impute import SimpleImputer\n",
        "\n",
        "# Assuming df is your DataFrame\n",
        "# df_one_hot = pd.read_csv('your_file.csv')\n",
        "\n",
        "# Selecting columns with missing values\n",
        "columns_with_missing = ['rx_kbps', 'tot_kbps']\n",
        "df_missing = df[columns_with_missing]\n",
        "\n",
        "# Hot-Deck (HD) Imputation\n",
        "# Filling missing values with the next available observation\n",
        "df_hd = df_missing.fillna(method='bfill')\n",
        "\n",
        "# Expectation Maximization (EM) Imputation\n",
        "# Using SimpleImputer with EM method\n",
        "em_imputer = SimpleImputer(strategy='constant', fill_value=None)  # EM is the default strategy\n",
        "df_em = pd.DataFrame(em_imputer.fit_transform(df_missing), columns=df_missing.columns)\n",
        "\n",
        "# K-Nearest Neighbor (KNN) Imputation\n",
        "knn_imputer = KNNImputer(n_neighbors=5)  # Using 5 nearest neighbors\n",
        "df_knn = pd.DataFrame(knn_imputer.fit_transform(df_missing), columns=df_missing.columns)\n",
        "\n",
        "# Comparing the imputed values\n",
        "print(\"Hot-Deck Imputation:\")\n",
        "print(df_hd.head())\n",
        "print(\"\\nExpectation Maximization (EM) Imputation:\")\n",
        "print(df_em.head())\n",
        "print(\"\\nK-Nearest Neighbor (KNN) Imputation:\")\n",
        "print(df_knn.head())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b56849d4-80f7-466d-f341-6b75d826c954",
        "id": "C6GgHzBo7LKJ"
      },
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hot-Deck Imputation:\n",
            "   rx_kbps  tot_kbps\n",
            "0      0.0       0.0\n",
            "1      0.0       0.0\n",
            "2      0.0       0.0\n",
            "3      0.0       0.0\n",
            "4      0.0       0.0\n",
            "\n",
            "Expectation Maximization (EM) Imputation:\n",
            "   rx_kbps  tot_kbps\n",
            "0      0.0       0.0\n",
            "1      0.0       0.0\n",
            "2      0.0       0.0\n",
            "3      0.0       0.0\n",
            "4      0.0       0.0\n",
            "\n",
            "K-Nearest Neighbor (KNN) Imputation:\n",
            "   rx_kbps  tot_kbps\n",
            "0      0.0       0.0\n",
            "1      0.0       0.0\n",
            "2      0.0       0.0\n",
            "3      0.0       0.0\n",
            "4      0.0       0.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Replace missing values in df with imputed values\n",
        "df_with_hd = df.copy()\n",
        "df_with_em = df.copy()\n",
        "df_with_knn = df.copy()\n",
        "\n",
        "df_with_hd[columns_with_missing] = df_hd\n",
        "df_with_em[columns_with_missing] = df_em\n",
        "df_with_knn[columns_with_missing] = df_knn"
      ],
      "metadata": {
        "id": "tdBDmcG-7LKK"
      },
      "execution_count": 80,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "# Define features (X) and target (y)\n",
        "X_hd = df_with_hd.drop('label', axis=1)\n",
        "y_hd = df_with_hd['label']\n",
        "\n",
        "X_em = df_with_em.drop('label', axis=1)\n",
        "y_em = df_with_em['label']\n",
        "\n",
        "X_knn = df_with_knn.drop('label', axis=1)\n",
        "y_knn = df_with_knn['label']\n",
        "\n",
        "# Split the data\n",
        "X_train_hd, X_test_hd, y_train_hd, y_test_hd = train_test_split(X_hd, y_hd, test_size=0.2, random_state=42)\n",
        "X_train_em, X_test_em, y_train_em, y_test_em = train_test_split(X_em, y_em, test_size=0.2, random_state=42)\n",
        "X_train_knn, X_test_knn, y_train_knn, y_test_knn = train_test_split(X_knn, y_knn, test_size=0.2, random_state=42)\n"
      ],
      "metadata": {
        "id": "dnEcfIwj7LKK"
      },
      "execution_count": 81,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.metrics import accuracy_score\n",
        "\n",
        "# Initialize RandomForestClassifier\n",
        "clf = RandomForestClassifier(random_state=42)\n",
        "\n",
        "# Train the model with Hot-Deck imputed data\n",
        "clf.fit(X_train_hd, y_train_hd)\n",
        "y_pred_hd = clf.predict(X_test_hd)\n",
        "accuracy_hd = accuracy_score(y_test_hd, y_pred_hd)\n",
        "\n",
        "# Train the model with Expectation Maximization (EM) imputed data\n",
        "clf.fit(X_train_em, y_train_em)\n",
        "y_pred_em = clf.predict(X_test_em)\n",
        "accuracy_em = accuracy_score(y_test_em, y_pred_em)\n",
        "\n",
        "# Train the model with K-Nearest Neighbor (KNN) imputed data\n",
        "clf.fit(X_train_knn, y_train_knn)\n",
        "y_pred_knn = clf.predict(X_test_knn)\n",
        "accuracy_knn = accuracy_score(y_test_knn, y_pred_knn)\n",
        "\n",
        "print(f\"Accuracy with Hot-Deck imputation: {accuracy_hd:.4f}\")\n",
        "print(f\"Accuracy with Expectation Maximization (EM) imputation: {accuracy_em:.4f}\")\n",
        "print(f\"Accuracy with K-Nearest Neighbor (KNN) imputation: {accuracy_knn:.4f}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e078a039-d1c6-4b5b-ef79-377800513369",
        "id": "EMb2-7_x7LKL"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy with Hot-Deck imputation: 1.0000\n",
            "Accuracy with Expectation Maximization (EM) imputation: 1.0000\n",
            "Accuracy with K-Nearest Neighbor (KNN) imputation: 1.0000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Compare the accuracies\n",
        "if accuracy_hd > accuracy_em and accuracy_hd > accuracy_knn:\n",
        "    print(\"Hot-Deck imputation performs the best.\")\n",
        "elif accuracy_em > accuracy_hd and accuracy_em > accuracy_knn:\n",
        "    print(\"Expectation Maximization (EM) imputation performs the best.\")\n",
        "else:\n",
        "    print(\"K-Nearest Neighbor (KNN) imputation performs the best.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "39c71c63-0c2c-4255-f544-6c500812a223",
        "id": "eot7XJZX7LKL"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "K-Nearest Neighbor (KNN) imputation performs the best.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# FEATURE SELECTION WITHOUT ONE-HOT ENCODING"
      ],
      "metadata": {
        "id": "ivAdpBeI_LmH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.feature_selection import RFECV\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "\n",
        "# Splitting the data into features (X) and target (y)\n",
        "X = df_with_knn.drop('label', axis=1)  # Features\n",
        "y = df_with_knn['label']  # Target\n",
        "\n",
        "# Initialize Random Forest Classifier\n",
        "rf_classifier = RandomForestClassifier(random_state=42)\n",
        "\n",
        "# Initialize RFECV\n",
        "rfecv = RFECV(estimator=rf_classifier, step=1, cv=5, scoring='accuracy', n_jobs=-1)\n",
        "\n",
        "# Fit RFECV\n",
        "rfecv.fit(X, y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 118
        },
        "id": "RAKm-D7j_fgX",
        "outputId": "1c20ca88-ea10-4b6f-cd18-dd25f3664c54"
      },
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RFECV(cv=5, estimator=RandomForestClassifier(random_state=42), n_jobs=-1,\n",
              "      scoring='accuracy')"
            ],
            "text/html": [
              "<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>RFECV(cv=5, estimator=RandomForestClassifier(random_state=42), n_jobs=-1,\n",
              "      scoring=&#x27;accuracy&#x27;)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" ><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">RFECV</label><div class=\"sk-toggleable__content\"><pre>RFECV(cv=5, estimator=RandomForestClassifier(random_state=42), n_jobs=-1,\n",
              "      scoring=&#x27;accuracy&#x27;)</pre></div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" ><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">estimator: RandomForestClassifier</label><div class=\"sk-toggleable__content\"><pre>RandomForestClassifier(random_state=42)</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-3\" type=\"checkbox\" ><label for=\"sk-estimator-id-3\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">RandomForestClassifier</label><div class=\"sk-toggleable__content\"><pre>RandomForestClassifier(random_state=42)</pre></div></div></div></div></div></div></div></div></div></div>"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the optimal number of features\n",
        "print(f\"Optimal number of features: {rfecv.n_features_}\")\n",
        "\n",
        "# Get the selected features\n",
        "selected_features = X.columns[rfecv.support_].tolist()\n",
        "print(\"Selected features:\")\n",
        "print(selected_features)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ea544111-9bc7-490a-b403-2677551a0339",
        "id": "l8h6uvRi_fgY"
      },
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimal number of features: 6\n",
            "Selected features:\n",
            "['pktcount', 'bytecount', 'packetins', 'pktperflow', 'byteperflow', 'pktrate']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Plot number of features vs. cross-validation scores\n",
        "plt.figure(figsize=(10, 6))\n",
        "plt.xlabel(\"Number of features selected\")\n",
        "plt.ylabel(\"Cross validation score (accuracy)\")\n",
        "plt.plot(range(1, len(rfecv.cv_results_['mean_test_score']) + 1), rfecv.cv_results_['mean_test_score'])\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 542
        },
        "outputId": "63d59fd1-df4b-4974-8f2b-8441f8c21eb2",
        "id": "D6MDKIMQ_fgY"
      },
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# CREATING FINAL DATAFRAME\n",
        "Same features with and without one-hot encoding, and they don't include the categorical variables which were encoded."
      ],
      "metadata": {
        "id": "9GivX2uaFAKr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "all_features= selected_features+['label']\n",
        "final_df=df[all_features]"
      ],
      "metadata": {
        "id": "xbOKBJ8uFJQx"
      },
      "execution_count": 92,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SPLITTING THE DATA"
      ],
      "metadata": {
        "id": "2LCOSNuoIcaO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import train_test_split"
      ],
      "metadata": {
        "id": "pRKWHdDpIfW-"
      },
      "execution_count": 95,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "shuffled_df = final_df.sample(frac=1, random_state=42)  # Replace 42 with any random seed for reproducibility\n",
        "X_train, X_test, y_train, y_test = train_test_split(shuffled_df.drop('label', axis=1),  # Features (all but target)\n",
        "                                                    shuffled_df['label'],\n",
        "                                                    test_size=0.2,  # Adjust test size (common: 20-30%)\n",
        "                                                    stratify=shuffled_df['label'],  # Stratify by target variable\n",
        "                                                    random_state=42)\n"
      ],
      "metadata": {
        "id": "TIPSUtezIiPJ"
      },
      "execution_count": 97,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from collections import Counter\n",
        "\n",
        "print(\"Training set class distribution:\", Counter(y_train))\n",
        "print(\"Testing set class distribution:\", Counter(y_test))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QiV6ZOHIIvR7",
        "outputId": "30ae560f-7f05-41cd-f85e-381a6368dac6"
      },
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training set class distribution: Counter({0: 50849, 1: 32627})\n",
            "Testing set class distribution: Counter({0: 12712, 1: 8157})\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# MODEL TRAINING"
      ],
      "metadata": {
        "id": "QY_lAYfGNUpV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Logistic Regression"
      ],
      "metadata": {
        "id": "z-abNDGRPvLr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.metrics import make_scorer, f1_score, roc_auc_score\n",
        "\n",
        "# Define a pipeline to standardize the data and apply logistic regression\n",
        "pipeline = Pipeline([\n",
        "    ('scaler', StandardScaler()),  # Standardize the features\n",
        "    ('logistic_regression', LogisticRegression(random_state=42))  # Logistic regression model\n",
        "])\n",
        "\n",
        "# Define the parameters grid to search over\n",
        "param_grid = {\n",
        "    'logistic_regression__C': [0.001, 0.01, 0.1, 1, 10, 100],  # Regularization strength\n",
        "    'logistic_regression__penalty': ['l1', 'l2'],  # Regularization penalty\n",
        "    'logistic_regression__solver': ['liblinear', 'saga']  # Solver for optimization\n",
        "}\n",
        "\n",
        "# Define scoring metrics\n",
        "scoring = {\n",
        "    'F1 Score': make_scorer(f1_score),\n",
        "    'ROC AUC': make_scorer(roc_auc_score)\n",
        "}\n",
        "\n",
        "# Initialize GridSearchCV\n",
        "grid_search = GridSearchCV(\n",
        "    pipeline,  # Pipeline object\n",
        "    param_grid=param_grid,  # Parameters grid\n",
        "    scoring=scoring,  # Scoring metrics\n",
        "    refit='F1 Score',  # Metric to refit on, i.e., F1 Score\n",
        "    cv=5,  # 5-fold cross-validation\n",
        "    verbose=1,  # Verbosity level\n",
        "    n_jobs=-1  # Use all available CPU cores\n",
        ")\n",
        "\n",
        "# Train the model using GridSearchCV\n",
        "grid_search.fit(X_train, y_train)\n",
        "\n",
        "# Get the best parameters and best scores\n",
        "best_params = grid_search.best_params_\n",
        "best_score = grid_search.best_score_\n",
        "\n",
        "print(f\"Best Parameters: {best_params}\")\n",
        "print(f\"Best F1 Score: {best_score}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gf2X8SvKNWpM",
        "outputId": "48fa5909-755a-4e29-b71c-e123901b7148"
      },
      "execution_count": 107,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Fitting 5 folds for each of 24 candidates, totalling 120 fits\n",
            "Best Parameters: {'logistic_regression__C': 100, 'logistic_regression__penalty': 'l2', 'logistic_regression__solver': 'liblinear'}\n",
            "Best F1 Score: 0.62447692648817\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Decision Trees"
      ],
      "metadata": {
        "id": "TW9CeaxZV8jx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.tree import DecisionTreeClassifier\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.metrics import make_scorer, f1_score, roc_auc_score\n",
        "\n",
        "# Define a Decision Tree classifier\n",
        "decision_tree = DecisionTreeClassifier(random_state=42)\n",
        "\n",
        "# Define the parameters grid to search over\n",
        "param_grid = {\n",
        "    'criterion': ['gini', 'entropy'],  # Splitting criterion\n",
        "    'max_depth': [None, 10, 20, 30, 40, 50],  # Maximum depth of the tree\n",
        "    'min_samples_split': [2, 5, 10],  # Minimum number of samples required to split an internal node\n",
        "    'min_samples_leaf': [1, 2, 4]  # Minimum number of samples required to be at a leaf node\n",
        "}\n",
        "\n",
        "# Define scoring metrics\n",
        "scoring = {\n",
        "    'F1 Score': make_scorer(f1_score),\n",
        "    'ROC AUC': make_scorer(roc_auc_score)\n",
        "}\n",
        "\n",
        "# Initialize GridSearchCV\n",
        "grid_search = GridSearchCV(\n",
        "    decision_tree,  # Decision Tree classifier\n",
        "    param_grid=param_grid,  # Parameters grid\n",
        "    scoring=scoring,  # Scoring metrics\n",
        "    refit='F1 Score',  # Metric to refit on, i.e., F1 Score\n",
        "    cv=5,  # 5-fold cross-validation\n",
        "    verbose=1,  # Verbosity level\n",
        "    n_jobs=-1  # Use all available CPU cores\n",
        ")\n",
        "\n",
        "# Train the model using GridSearchCV\n",
        "grid_search.fit(X_train, y_train)\n",
        "\n",
        "# Get the best parameters and best scores\n",
        "best_params = grid_search.best_params_\n",
        "best_score = grid_search.best_score_\n",
        "\n",
        "print(f\"Best Parameters: {best_params}\")\n",
        "print(f\"Best F1 Score: {best_score}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "STUko2zKV-e3",
        "outputId": "db3c2ead-cb8d-466e-d2e3-22ba2cd97c12"
      },
      "execution_count": 108,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Fitting 5 folds for each of 108 candidates, totalling 540 fits\n",
            "Best Parameters: {'criterion': 'entropy', 'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2}\n",
            "Best F1 Score: 0.9999693439607602\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Random Forest"
      ],
      "metadata": {
        "id": "i1K37mE-V_kW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "\n",
        "\n",
        "# Define a Random Forest classifier\n",
        "random_forest = RandomForestClassifier(random_state=42)\n",
        "\n",
        "# Define the parameters grid to search over\n",
        "param_grid = {\n",
        "    'n_estimators': [50, 100, 150],  # Number of trees in the forest\n",
        "    'criterion': ['gini', 'entropy'],  # Splitting criterion\n",
        "    'max_depth': [None, 10, 20, 30],  # Maximum depth of the trees\n",
        "    'min_samples_split': [2, 5, 10],  # Minimum number of samples required to split an internal node\n",
        "    'min_samples_leaf': [1, 2, 4]  # Minimum number of samples required to be at a leaf node\n",
        "}\n",
        "\n",
        "# Define scoring metrics\n",
        "scoring = {\n",
        "    'F1 Score': make_scorer(f1_score),\n",
        "    'ROC AUC': make_scorer(roc_auc_score)\n",
        "}\n",
        "\n",
        "# Initialize GridSearchCV\n",
        "grid_search = GridSearchCV(\n",
        "    random_forest,  # Random Forest classifier\n",
        "    param_grid=param_grid,  # Parameters grid\n",
        "    scoring=scoring,  # Scoring metrics\n",
        "    refit='F1 Score',  # Metric to refit on, i.e., F1 Score\n",
        "    cv=5,  # 5-fold cross-validation\n",
        "    verbose=1,  # Verbosity level\n",
        "    n_jobs=-1  # Use all available CPU cores\n",
        ")\n",
        "\n",
        "# Train the model using GridSearchCV\n",
        "grid_search.fit(X_train, y_train)\n",
        "\n",
        "# Get the best parameters and best scores\n",
        "best_params = grid_search.best_params_\n",
        "best_score = grid_search.best_score_\n",
        "\n",
        "print(f\"Best Parameters: {best_params}\")\n",
        "print(f\"Best F1 Score: {best_score}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_prCTrv8WCuO",
        "outputId": "d60cf174-bd1a-4c5a-d9fa-4343713cc9a1"
      },
      "execution_count": null,
      "outputs": [
        {
          "metadata": {
            "tags": null
          },
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Fitting 5 folds for each of 216 candidates, totalling 1080 fits\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## SVM"
      ],
      "metadata": {
        "id": "Ic0nJBCuWNMw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.svm import SVC\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.metrics import make_scorer, f1_score, roc_auc_score\n",
        "\n",
        "# Define an SVM classifier\n",
        "svm_classifier = SVC(random_state=42, probability=True)  # Setting probability to True for ROC AUC calculation\n",
        "\n",
        "# Define the parameters grid to search over\n",
        "param_grid = {\n",
        "    'C': [0.1, 1, 10],  # Regularization parameter\n",
        "    'kernel': ['linear', 'poly', 'rbf', 'sigmoid'],  # Kernel type\n",
        "    'gamma': ['scale', 'auto'],  # Kernel coefficient\n",
        "    'degree': [2, 3, 4],  # Degree of the polynomial kernel\n",
        "    'class_weight': [None, 'balanced']  # Weights associated with classes\n",
        "}\n",
        "\n",
        "# Define scoring metrics\n",
        "scoring = {\n",
        "    'F1 Score': make_scorer(f1_score),\n",
        "    'ROC AUC': make_scorer(roc_auc_score)\n",
        "}\n",
        "\n",
        "# Initialize GridSearchCV\n",
        "grid_search = GridSearchCV(\n",
        "    svm_classifier,  # SVM classifier\n",
        "    param_grid=param_grid,  # Parameters grid\n",
        "    scoring=scoring,  # Scoring metrics\n",
        "    refit='F1 Score',  # Metric to refit on, i.e., F1 Score\n",
        "    cv=5,  # 5-fold cross-validation\n",
        "    verbose=1,  # Verbosity level\n",
        "    n_jobs=-1  # Use all available CPU cores\n",
        ")\n",
        "\n",
        "# Train the model using GridSearchCV\n",
        "grid_search.fit(X_train, y_train)\n",
        "\n",
        "# Get the best parameters and best scores\n",
        "best_params = grid_search.best_params_\n",
        "best_score = grid_search.best_score_\n",
        "\n",
        "print(f\"Best Parameters: {best_params}\")\n",
        "print(f\"Best F1 Score: {best_score}\")\n"
      ],
      "metadata": {
        "id": "ZnXjnCVEWPM7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Gradient Boosting"
      ],
      "metadata": {
        "id": "oIc3oo42WZEh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import xgboost as xgb\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.metrics import make_scorer, f1_score, roc_auc_score\n",
        "\n",
        "# Define an XGBoost classifier\n",
        "xgb_classifier = xgb.XGBClassifier(random_state=42)\n",
        "\n",
        "# Define the parameters grid to search over\n",
        "param_grid = {\n",
        "    'learning_rate': [0.01, 0.05, 0.1],\n",
        "    'n_estimators': [50, 100, 200],\n",
        "    'max_depth': [3, 4, 5],\n",
        "    'min_child_weight': [1, 3, 5],\n",
        "    'gamma': [0, 0.1, 0.2],\n",
        "    'subsample': [0.6, 0.8, 1.0],\n",
        "    'colsample_bytree': [0.6, 0.8, 1.0],\n",
        "    'reg_alpha': [0, 0.1, 0.5],\n",
        "    'reg_lambda': [1, 1.5, 2],\n",
        "    'scale_pos_weight': [1, 3, 5]\n",
        "}\n",
        "\n",
        "# Define scoring metrics\n",
        "scoring = {\n",
        "    'F1 Score': make_scorer(f1_score),\n",
        "    'ROC AUC': make_scorer(roc_auc_score)\n",
        "}\n",
        "\n",
        "# Initialize GridSearchCV\n",
        "grid_search = GridSearchCV(\n",
        "    xgb_classifier,  # XGBoost classifier\n",
        "    param_grid=param_grid,  # Parameters grid\n",
        "    scoring=scoring,  # Scoring metrics\n",
        "    refit='F1 Score',  # Metric to refit on, i.e., F1 Score\n",
        "    cv=5,  # 5-fold cross-validation\n",
        "    verbose=1,  # Verbosity level\n",
        "    n_jobs=-1  # Use all available CPU cores\n",
        ")\n",
        "\n",
        "# Train the model using GridSearchCV\n",
        "grid_search.fit(X_train, y_train)\n",
        "\n",
        "# Get the best parameters and best scores\n",
        "best_params = grid_search.best_params_\n",
        "best_score = grid_search.best_score_\n",
        "\n",
        "print(f\"Best Parameters: {best_params}\")\n",
        "print(f\"Best F1 Score: {best_score}\")\n"
      ],
      "metadata": {
        "id": "s31rH2x9WfFT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Neural Networks"
      ],
      "metadata": {
        "id": "B6_PwQHBW2KW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install torch torchvision"
      ],
      "metadata": {
        "id": "IIWtfhrcW4tc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.metrics import make_scorer, f1_score, roc_auc_score\n",
        "\n",
        "# Define a simple feedforward neural network using PyTorch\n",
        "class NeuralNetwork(nn.Module):\n",
        "    def __init__(self, input_dim, hidden_dim, output_dim):\n",
        "        super(NeuralNetwork, self).__init__()\n",
        "        self.fc1 = nn.Linear(input_dim, hidden_dim)\n",
        "        self.fc2 = nn.Linear(hidden_dim, output_dim)\n",
        "        self.relu = nn.ReLU()\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.fc1(x)\n",
        "        x = self.relu(x)\n",
        "        x = self.fc2(x)\n",
        "        x = self.softmax(x)\n",
        "        return x\n",
        "\n",
        "# Initialize the neural network\n",
        "input_dim = X_train.shape[1]\n",
        "output_dim = 2  # Binary classification\n",
        "neural_network = NeuralNetwork(input_dim, 128, output_dim)\n",
        "\n",
        "# Convert data to PyTorch tensors\n",
        "X_train_tensor = torch.tensor(X_train.values, dtype=torch.float32)\n",
        "y_train_tensor = torch.tensor(y_train.values, dtype=torch.long)\n",
        "\n",
        "# Define the loss function and optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(neural_network.parameters(), lr=0.001)\n",
        "\n",
        "# Define the parameters grid to search over\n",
        "param_grid = {\n",
        "    'hidden_dim': [64, 128, 256],  # Number of units in the hidden layer\n",
        "    'optimizer': [optim.Adam, optim.SGD],  # Optimizer\n",
        "    'lr': [0.001, 0.01, 0.1]  # Learning rate\n",
        "}\n",
        "\n",
        "# Define scoring metrics\n",
        "scoring = {\n",
        "    'F1 Score': make_scorer(f1_score),\n",
        "    'ROC AUC': make_scorer(roc_auc_score)\n",
        "}\n",
        "\n",
        "# Define a custom PyTorch classifier for GridSearchCV\n",
        "class PyTorchClassifier(nn.Module):\n",
        "    def __init__(self, neural_network):\n",
        "        super(PyTorchClassifier, self).__init__()\n",
        "        self.neural_network = neural_network\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.neural_network(x)\n",
        "\n",
        "# Initialize GridSearchCV\n",
        "pytorch_classifier = PyTorchClassifier(neural_network)\n",
        "grid_search = GridSearchCV(\n",
        "    pytorch_classifier,  # PyTorch classifier\n",
        "    param_grid=param_grid,  # Parameters grid\n",
        "    scoring=scoring,  # Scoring metrics\n",
        "    refit='F1 Score',  # Metric to refit on, i.e., F1 Score\n",
        "    cv=5,  # 5-fold cross-validation\n",
        "    verbose=1,  # Verbosity level\n",
        "    n_jobs=-1  # Use all available CPU cores\n",
        ")\n",
        "\n",
        "# Train the model using GridSearchCV\n",
        "grid_search.fit(X_train_tensor, y_train_tensor)\n",
        "\n",
        "# Get the best parameters and best scores\n",
        "best_params = grid_search.best_params_\n",
        "best_score = grid_search.best_score_\n",
        "\n",
        "print(f\"Best Parameters: {best_params}\")\n",
        "print(f\"Best F1 Score: {best_score}\")\n"
      ],
      "metadata": {
        "id": "Zrd1pnVeX3LG"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}