Modified Tree SHAP.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PQyHNu5RwdPD",
        "outputId": "206db61b-ebf7-4330-d623-a1b11fda9dfe"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: shap in /usr/local/lib/python3.10/dist-packages (0.46.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from shap) (1.26.4)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from shap) (1.13.1)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (from shap) (1.5.2)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from shap) (2.2.2)\n",
            "Requirement already satisfied: tqdm>=4.27.0 in /usr/local/lib/python3.10/dist-packages (from shap) (4.66.5)\n",
            "Requirement already satisfied: packaging>20.9 in /usr/local/lib/python3.10/dist-packages (from shap) (24.1)\n",
            "Requirement already satisfied: slicer==0.0.8 in /usr/local/lib/python3.10/dist-packages (from shap) (0.0.8)\n",
            "Requirement already satisfied: numba in /usr/local/lib/python3.10/dist-packages (from shap) (0.60.0)\n",
            "Requirement already satisfied: cloudpickle in /usr/local/lib/python3.10/dist-packages (from shap) (3.1.0)\n",
            "Requirement already satisfied: llvmlite<0.44,>=0.43.0dev0 in /usr/local/lib/python3.10/dist-packages (from numba->shap) (0.43.0)\n",
            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas->shap) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->shap) (2024.2)\n",
            "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.10/dist-packages (from pandas->shap) (2024.2)\n",
            "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->shap) (1.4.2)\n",
            "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->shap) (3.5.0)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas->shap) (1.16.0)\n"
          ]
        }
      ],
      "source": [
        "!pip install shap"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BYFGpVCHy_il"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import shap\n",
        "import random\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from collections import defaultdict"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jWxWcGXGzGlF"
      },
      "outputs": [],
      "source": [
        "def compute_node_importance(tree, feature_names):\n",
        "\n",
        "    node_importance = tree.tree_.compute_feature_importances(normalize=False)\n",
        "    return {feature_names[i]: node_importance[i] for i in range(len(feature_names))}\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yaNULrTWzex7"
      },
      "outputs": [],
      "source": [
        "def detect_feature_interactions(data, model):\n",
        "\n",
        "    interactions = {}\n",
        "    corr_matrix = np.corrcoef(data.T)\n",
        "    for i in range(len(corr_matrix)):\n",
        "        for j in range(i+1, len(corr_matrix)):\n",
        "            if np.abs(corr_matrix[i, j]) > 0.5:\n",
        "                interactions[(i, j)] = corr_matrix[i, j]\n",
        "    return interactions\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def calculate_node_contribution(tree, node):\n",
        "    return tree.tree_.impurity[node] * tree.tree_.n_node_samples[node]"
      ],
      "metadata": {
        "id": "OyrC2cPVa4Na"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Wfe0UMrfzpLK"
      },
      "outputs": [],
      "source": [
        "def initialize_data_structures(data, feature_names):\n",
        "\n",
        "    shap_values = np.zeros((data.shape[0], len(feature_names)))\n",
        "    return shap_values"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T-30LVPWzrZV"
      },
      "outputs": [],
      "source": [
        "def calculate_shap_contribution(node, feature_contributions):\n",
        "    contribution = feature_contributions[node]\n",
        "    return contribution"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def adjust_for_interactions(contribution, feature_interactions, feature_names):\n",
        "    adjustment = np.zeros(len(feature_names))\n",
        "    for (f1, f2), interaction_value in feature_interactions.items():\n",
        "        adjustment[feature_names.index(f1)] += contribution * interaction_value\n",
        "        adjustment[feature_names.index(f2)] += contribution * interaction_value\n",
        "    return adjustment"
      ],
      "metadata": {
        "id": "lcpbUUN3ZSQh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def depth_first_traversal(tree, depth_threshold):\n",
        "    def traverse(node, depth):\n",
        "        if depth <= depth_threshold:\n",
        "            yield node\n",
        "            if tree.tree_.children_left[node] != -1:\n",
        "                yield from traverse(tree.tree_.children_left[node], depth + 1)\n",
        "            if tree.tree_.children_right[node] != -1:\n",
        "                yield from traverse(tree.tree_.children_right[node], depth + 1)\n",
        "    yield from traverse(0, 0)"
      ],
      "metadata": {
        "id": "DGtQFCO1ZlFK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def compute_shap_values(tree, node):\n",
        "    return np.array([tree.tree_.impurity[node]] * tree.tree_.n_node_samples[node])"
      ],
      "metadata": {
        "id": "T9m3tumjZpaK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def detailed_shap_computation(tree, node):\n",
        "    return tree.tree_.impurity[node] * tree.tree_.n_node_samples[node]"
      ],
      "metadata": {
        "id": "YEKPr7LzZu4-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def approximate_shap(tree, node):\n",
        "    return tree.tree_.impurity[node] * 0.5"
      ],
      "metadata": {
        "id": "ZIOYJ5IlZxmF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def select_feature_subset(feature_names, subset_size, sampling_method):\n",
        "    num_features = int(len(feature_names) * subset_size)\n",
        "    if sampling_method == 'importance':\n",
        "        return random.sample(feature_names, num_features)\n",
        "    elif sampling_method == 'stratified':\n",
        "        return feature_names[:num_features]"
      ],
      "metadata": {
        "id": "xg00TWWhZ3WI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def compute_subset_shap(subset_features, model, data):\n",
        "    explainer = shap.TreeExplainer(model)\n",
        "    shap_values = explainer.shap_values(data[subset_features])\n",
        "    return shap_values"
      ],
      "metadata": {
        "id": "tVWmpSeFaDkK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def advanced_sampling(data, sampling_method, feature_importance):\n",
        "    if sampling_method == 'importance':\n",
        "        return data.sample(frac=0.5, weights=feature_importance, axis=1)\n",
        "    elif sampling_method == 'stratified':\n",
        "        return data.sample(frac=0.5, random_state=1)"
      ],
      "metadata": {
        "id": "C6-sqbySaH7e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def compute_shap_for_sampled_data(sampled_data, model):\n",
        "    explainer = shap.TreeExplainer(model)\n",
        "    shap_values = explainer.shap_values(sampled_data)\n",
        "    return shap_values"
      ],
      "metadata": {
        "id": "4EXjqa78aLqc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def combine_and_refine(shap_values, feature_interactions):\n",
        "    refined_values = shap_values.copy()\n",
        "    for (f1, f2), interaction_value in feature_interactions.items():\n",
        "        refined_values[:, f1] += refined_values[:, f2] * interaction_value\n",
        "        refined_values[:, f2] += refined_values[:, f1] * interaction_value\n",
        "    return refined_values"
      ],
      "metadata": {
        "id": "BkK4QHfCaPj3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fSqz9gyvztoB"
      },
      "outputs": [],
      "source": [
        "def modified_tree_shap(model, data, feature_names, depth_threshold=0.1, subset_size=0.5, sampling_method='importance'):\n",
        "    shap_values = np.zeros((data.shape[0], data.shape[1]))\n",
        "\n",
        "    # Node Importance and Feature Interactions\n",
        "    node_importance = {}\n",
        "    for i, tree in enumerate(model.estimators_):\n",
        "        node_importance[i] = compute_node_importance(tree)\n",
        "\n",
        "    feature_interactions = detect_feature_interactions(data, feature_names)\n",
        "\n",
        "    # Dynamic Feature Interaction Handling\n",
        "    for i, tree in enumerate(model.estimators_):\n",
        "        for node in range(tree.tree_.node_count):\n",
        "            if node in node_importance[i]:\n",
        "                contribution = calculate_node_contribution(tree, node)\n",
        "                shap_values += adjust_for_interactions(contribution, feature_interactions, feature_names)\n",
        "\n",
        "    # Adaptive Tree Depth Limiting\n",
        "    for i, tree in enumerate(model.estimators_):\n",
        "        for node in depth_first_traversal(tree, depth_threshold):\n",
        "            if node_importance[i][node] > depth_threshold:\n",
        "                shap_values += compute_shap_values(tree, node)\n",
        "\n",
        "    # Hierarchical Importance-Based Caching\n",
        "    cache = {}\n",
        "    for i, tree in enumerate(model.estimators_):\n",
        "        for node in range(tree.tree_.node_count):\n",
        "            if node_importance[i][node] > depth_threshold:\n",
        "                cache[node] = detailed_shap_computation(tree, node)\n",
        "            else:\n",
        "                cache[node] = approximate_shap(tree, node)\n",
        "\n",
        "    # Approximate SHAP with Feature Subsets\n",
        "    subset_features = select_feature_subset(feature_names, subset_size, sampling_method)\n",
        "    shap_values += compute_subset_shap(subset_features, model, data)\n",
        "\n",
        "    # Advanced Sampling Techniques\n",
        "    sampled_data = advanced_sampling(data, sampling_method, feature_importance=model.feature_importances_)\n",
        "    shap_values += compute_shap_for_sampled_data(sampled_data, model)\n",
        "\n",
        "    # Combine and Refine Results\n",
        "    shap_values = combine_and_refine(shap_values, feature_interactions)\n",
        "\n",
        "    return shap_values"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "znsOKtf-zxuP"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.metrics import accuracy_score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1hQBY41cz0TO",
        "outputId": "5ad869ab-2fc9-497e-82cd-bde2bd5621d7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7vlDSB5e0XYZ"
      },
      "outputs": [],
      "source": [
        "file_path = '/content/drive/My Drive/UNSW_NB15_training-set.csv'\n",
        "unsw_nb15_data = pd.read_csv(file_path)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZL9ZGk8S1VsK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8768fb7c-19e8-4284-93bb-8ee9c02aa6e7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   id       dur proto service state  spkts  dpkts  sbytes  dbytes  \\\n",
            "0   1  0.000011   udp       -   INT      2      0     496       0   \n",
            "1   2  0.000008   udp       -   INT      2      0    1762       0   \n",
            "2   3  0.000005   udp       -   INT      2      0    1068       0   \n",
            "3   4  0.000006   udp       -   INT      2      0     900       0   \n",
            "4   5  0.000010   udp       -   INT      2      0    2126       0   \n",
            "\n",
            "          rate  ...  ct_dst_sport_ltm  ct_dst_src_ltm  is_ftp_login  \\\n",
            "0   90909.0902  ...                 1               2             0   \n",
            "1  125000.0003  ...                 1               2             0   \n",
            "2  200000.0051  ...                 1               3             0   \n",
            "3  166666.6608  ...                 1               3             0   \n",
            "4  100000.0025  ...                 1               3             0   \n",
            "\n",
            "   ct_ftp_cmd  ct_flw_http_mthd  ct_src_ltm  ct_srv_dst  is_sm_ips_ports  \\\n",
            "0           0                 0           1           2                0   \n",
            "1           0                 0           1           2                0   \n",
            "2           0                 0           1           3                0   \n",
            "3           0                 0           2           3                0   \n",
            "4           0                 0           2           3                0   \n",
            "\n",
            "   attack_cat  label  \n",
            "0      Normal      0  \n",
            "1      Normal      0  \n",
            "2      Normal      0  \n",
            "3      Normal      0  \n",
            "4      Normal      0  \n",
            "\n",
            "[5 rows x 45 columns]\n",
            "id                     int64\n",
            "dur                  float64\n",
            "proto                 object\n",
            "service               object\n",
            "state                 object\n",
            "spkts                  int64\n",
            "dpkts                  int64\n",
            "sbytes                 int64\n",
            "dbytes                 int64\n",
            "rate                 float64\n",
            "sttl                   int64\n",
            "dttl                   int64\n",
            "sload                float64\n",
            "dload                float64\n",
            "sloss                  int64\n",
            "dloss                  int64\n",
            "sinpkt               float64\n",
            "dinpkt               float64\n",
            "sjit                 float64\n",
            "djit                 float64\n",
            "swin                   int64\n",
            "stcpb                  int64\n",
            "dtcpb                  int64\n",
            "dwin                   int64\n",
            "tcprtt               float64\n",
            "synack               float64\n",
            "ackdat               float64\n",
            "smean                  int64\n",
            "dmean                  int64\n",
            "trans_depth            int64\n",
            "response_body_len      int64\n",
            "ct_srv_src             int64\n",
            "ct_state_ttl           int64\n",
            "ct_dst_ltm             int64\n",
            "ct_src_dport_ltm       int64\n",
            "ct_dst_sport_ltm       int64\n",
            "ct_dst_src_ltm         int64\n",
            "is_ftp_login           int64\n",
            "ct_ftp_cmd             int64\n",
            "ct_flw_http_mthd       int64\n",
            "ct_src_ltm             int64\n",
            "ct_srv_dst             int64\n",
            "is_sm_ips_ports        int64\n",
            "attack_cat            object\n",
            "label                  int64\n",
            "dtype: object\n",
            "Categorical columns: ['proto', 'service', 'state', 'attack_cat']\n",
            "Accuracy of the model: 99.96%\n"
          ]
        }
      ],
      "source": [
        "print(unsw_nb15_data.head())\n",
        "print(unsw_nb15_data.dtypes)\n",
        "\n",
        "categorical_cols = unsw_nb15_data.select_dtypes(include=['object']).columns.tolist()\n",
        "print(\"Categorical columns:\", categorical_cols)\n",
        "\n",
        "unsw_nb15_data_encoded = pd.get_dummies(unsw_nb15_data, columns=categorical_cols, drop_first=True)\n",
        "\n",
        "X = unsw_nb15_data_encoded.iloc[:, :-1]\n",
        "y = unsw_nb15_data_encoded.iloc[:, -1]\n",
        "\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
        "\n",
        "\n",
        "rf_model = RandomForestClassifier(n_estimators=100, random_state=42)\n",
        "rf_model.fit(X_train, y_train)\n",
        "\n",
        "\n",
        "y_pred = rf_model.predict(X_test)\n",
        "\n",
        "\n",
        "accuracy = accuracy_score(y_test, y_pred)\n",
        "print(f\"Accuracy of the model: {accuracy * 100:.2f}%\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MWdQWRtngaZN"
      },
      "outputs": [],
      "source": [
        "explainer = shap.TreeExplainer(rf_model)\n",
        "shap_values = explainer.shap_values(X_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "R7k228IVg_Mf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ebec2c5b-9666-417f-91e9-2f2e03456a8a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[ 3.99061019e-05 -3.99061019e-05]\n",
            "  [-1.10143298e-04  1.10143298e-04]\n",
            "  [ 6.30226334e-05 -6.30226334e-05]\n",
            "  ...\n",
            "  [ 1.46444267e-04 -1.46444267e-04]\n",
            "  [-3.01364005e-05  3.01364005e-05]\n",
            "  [-1.22544953e-06  1.22544953e-06]]\n",
            "\n",
            " [[-2.78844204e-05  2.78844204e-05]\n",
            "  [-1.68407193e-04  1.68407193e-04]\n",
            "  [-1.24969634e-04  1.24969634e-04]\n",
            "  ...\n",
            "  [-2.28545224e-04  2.28545224e-04]\n",
            "  [-7.59011099e-05  7.59011099e-05]\n",
            "  [-1.99189839e-06  1.99189839e-06]]\n",
            "\n",
            " [[ 1.64201803e-04 -1.64201803e-04]\n",
            "  [-1.46162158e-04  1.46162158e-04]\n",
            "  [-1.61414851e-04  1.61414851e-04]\n",
            "  ...\n",
            "  [-3.52686690e-04  3.52686690e-04]\n",
            "  [-1.30357209e-04  1.30357209e-04]\n",
            "  [-6.33782818e-06  6.33782818e-06]]\n",
            "\n",
            " ...\n",
            "\n",
            " [[ 1.09393150e-04 -1.09393150e-04]\n",
            "  [-4.92725477e-04  4.92725477e-04]\n",
            "  [-2.14705306e-04  2.14705306e-04]\n",
            "  ...\n",
            "  [-2.92123420e-04  2.92123420e-04]\n",
            "  [-1.60765069e-04  1.60765069e-04]\n",
            "  [-2.00931154e-06  2.00931154e-06]]\n",
            "\n",
            " [[ 1.21744028e-04 -1.21744028e-04]\n",
            "  [-1.65160805e-04  1.65160805e-04]\n",
            "  [-1.42266961e-04  1.42266961e-04]\n",
            "  ...\n",
            "  [-3.03441922e-04  3.03441922e-04]\n",
            "  [-8.65947212e-05  8.65947212e-05]\n",
            "  [-3.64900720e-06  3.64900720e-06]]\n",
            "\n",
            " [[ 3.94186489e-05 -3.94186489e-05]\n",
            "  [-3.05636193e-04  3.05636193e-04]\n",
            "  [ 7.25361223e-05 -7.25361223e-05]\n",
            "  ...\n",
            "  [ 1.45295609e-04 -1.45295609e-04]\n",
            "  [-2.73527387e-05  2.73527387e-05]\n",
            "  [-1.17761365e-06  1.17761365e-06]]]\n"
          ]
        }
      ],
      "source": [
        "print(shap_values)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "shap.summary_plot(shap_values, X_test, max_display=20)"
      ],
      "metadata": {
        "id": "u7yqCS5lohKO",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "03eeb5a6-5b2e-41f0-a327-501ba67a2184"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 3100x1700 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}