evaluation/3_modelling_results-transfer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modelling Results - Transfer\n",
    "\n",
    "In this notebook, the predictions from the finetuned model are utilized. For detailed theoretical information, please refer to the report.\n",
    "\n",
    "After training a Graph Neural Network (GNN), additional features were evaluated using a Random Forest (RF) model. Key features included GNN prediction scores, cosine similarity, and various node metrics like in-degree, out-degree, and cluster coefficients. Permutation Importance was applied to identify the most influential features. \n",
    "\n",
    "Permutation importance is a model-agnostic technique to evaluate feature importance by assessing the change in a model's performance after shuffling the values of a specific feature. A significant drop in performance suggests the feature is crucial for accurate predictions. This process is iterated to obtain a stable importance score.\n",
    "\n",
    "To ensure robustness, a 5-fold cross-validation was performed on the validation set, followed by testing on the test set to verify generalization. This approach ensures that the model's performance and the selected features are reliable and effective.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "current_dir = os.getcwd()\n",
    "if os.path.basename(current_dir) != 'link-prediction-in-graphs':\n",
    "    parent_dir = os.path.dirname(current_dir)\n",
    "    os.chdir(parent_dir)\n",
    "print(f\"current working directory: {os.getcwd()}\")\n",
    "\n",
    "import torch\n",
    "import numpy as np\n",
    "import networkx as nx\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "from ogb.nodeproppred import NodePropPredDataset\n",
    "import dask.dataframe as dd\n",
    "from dask.multiprocessing import get\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.ensemble import RandomForestClassifier,HistGradientBoostingClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from ogb.linkproppred import Evaluator\n",
    "from joblib import dump,load\n",
    "\n",
    "# set default plt figsize to (12,6)\n",
    "plt.rcParams[\"figure.figsize\"] = (12,6)\n",
    "pd.set_option('display.colheader_justify', 'center')\n",
    "# Set default font sizes\n",
    "plt.rcParams['axes.titlesize'] = 20\n",
    "plt.rcParams['xtick.labelsize'] = 16\n",
    "plt.rcParams['ytick.labelsize'] = 16\n",
    "plt.rcParams['axes.labelsize'] = 18 \n",
    "plt.rcParams['legend.fontsize'] = 16\n",
    "plt.rcParams['legend.title_fontsize'] = 18\n",
    "dataset = \"ogbn-arxiv\"\n",
    "\n",
    "data_path = \"./dataset/sample_data_for_evaluation_build/transfer/\"\n",
    "data = NodePropPredDataset(name=dataset)\n",
    "from modelling.dataset_split.dataset_splitter import Dataset_Splitter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating Splits for dataset ogbn-arxiv\n",
      "Returning Splits for dataset ogbn-arxiv\n"
     ]
    }
   ],
   "source": [
    "ds_split = Dataset_Splitter()\n",
    "dataset_ = ds_split.load_dataset(dataset)\n",
    "split_edge, edge_index = ds_split.get_edges_split(dataset_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "source = np.load(f\"{data_path}source.npy\")\n",
    "source_multiplied = np.array(torch.tensor(source).view(-1, 1).repeat(1, 1000).view(-1))\n",
    "target_neg = np.load(f\"{data_path}target_neg.npy\")\n",
    "target_pos = np.load(f\"{data_path}target.npy\")\n",
    "neg_preds = np.load(f\"{data_path}neg_preds.npy\")\n",
    "pos_preds = np.load(f\"{data_path}pos_preds.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## load precalculated_data\n",
    "\n",
    "The data used in this chapter has already been calculated in the notebook `./2_modelling_results.ipynb`, and here it is only loaded into the respective dataframes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_pos_df_featured = pd.read_csv(\"./dataset/modelling_results_calc_saved/pred_pos_df_featured.csv\", index_col=0)\n",
    "pred_neg_df_featured = pd.read_csv(\"./dataset/modelling_results_calc_saved/pred_neg_df_featured.csv\", index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "pos_preds = np.load(f\"{data_path}valid_pos_preds.npy\")\n",
    "neg_preds = np.load(f\"{data_path}valid_neg_preds.npy\")\n",
    "pred_pos_df_featured[\"prediction_model\"] = pos_preds\n",
    "pred_neg_df_featured[\"prediction_model\"] = neg_preds.reshape(-1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "comined_pred_df_featured = pd.concat([pred_neg_df_featured,pred_pos_df_featured])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GCN Transfer\n",
    "### Overall Importances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(0.9324)\n",
      "tensor(0.9394)\n",
      "tensor(0.9432)\n",
      "tensor(0.9391)\n",
      "tensor(0.9381)\n"
     ]
    }
   ],
   "source": [
    "kf = KFold(n_splits=5, shuffle=True, random_state=42)\n",
    "model_to_select = \"Random Forest\"\n",
    "features_to_drop = [\"source\",\"target\"]\n",
    "mrr_list = []\n",
    "n=0\n",
    "for train_index, test_index in kf.split(source):\n",
    "    n+=1\n",
    "    X_train = comined_pred_df_featured[comined_pred_df_featured[\"source\"].isin(source[train_index])].copy()\n",
    "    y_train = X_train.pop(\"output\").values\n",
    "    X_test = comined_pred_df_featured[comined_pred_df_featured[\"source\"].isin(source[test_index])].copy()\n",
    "    y_test = X_test.pop(\"output\").values\n",
    "    if model_to_select == \"Random Forest\":\n",
    "        model = RandomForestClassifier(n_estimators=120, random_state=42,n_jobs = -1)\n",
    "    elif model_to_select == \"Logistic Regression\":\n",
    "        model = LogisticRegression()\n",
    "    model.fit(X_train.copy().drop(columns=features_to_drop), y_train)\n",
    "\n",
    "    X_test_pos = pred_pos_df_featured[pred_pos_df_featured[\"source\"].isin(source[test_index])].copy().drop(columns=\"output\")\n",
    "    y_pred_pos = model.predict_proba(X_test_pos.copy().drop(columns=features_to_drop))[:,1]\n",
    "\n",
    "    X_test_neg = pred_neg_df_featured[pred_neg_df_featured[\"source\"].isin(source[test_index])].copy().drop(columns=\"output\")\n",
    "    y_pred_neg = model.predict_proba(X_test_neg.copy().drop(columns=features_to_drop))[:,1]\n",
    "\n",
    "    evaluator = Evaluator(name='ogbl-citation2')\n",
    "    eval_dict = evaluator.eval({\n",
    "                'y_pred_pos': torch.tensor(y_pred_pos),\n",
    "                'y_pred_neg': torch.tensor(y_pred_neg).view(-1,1000),\n",
    "            })\n",
    "    print(eval_dict[\"mrr_list\"].mean())\n",
    "    mrr_list.append(eval_dict[\"mrr_list\"].mean())\n",
    "    dump(model, f'./models_saved/transfer_random_forest_model_{n}.joblib')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "perm_importance = []\n",
    "n_times = 2\n",
    "for col in comined_pred_df_featured.drop(columns =\"output\").columns.values:\n",
    "    if col not in features_to_drop:\n",
    "        kf = KFold(n_splits=5, shuffle=True, random_state=42)\n",
    "        saved_per_model = []\n",
    "        model_n = 0\n",
    "        for train_index, test_index in kf.split(source):\n",
    "            model_n +=1\n",
    "            model = load(f'./models_saved/transfer_random_forest_model_{model_n}.joblib')\n",
    "            X_train = comined_pred_df_featured[comined_pred_df_featured[\"source\"].isin(source[train_index])].copy()\n",
    "            y_train = X_train.pop(\"output\").values\n",
    "            X_test = comined_pred_df_featured[comined_pred_df_featured[\"source\"].isin(source[test_index])].copy()\n",
    "            y_test = X_test.pop(\"output\").values\n",
    "            \n",
    "            X_test_pos = pred_pos_df_featured[pred_pos_df_featured[\"source\"].isin(source[test_index])].copy().drop(columns=\"output\")\n",
    "            X_test_neg = pred_neg_df_featured[pred_neg_df_featured[\"source\"].isin(source[test_index])].copy().drop(columns=\"output\")\n",
    "            \n",
    "            saved_per_feature = []\n",
    "            for x in range(n_times):\n",
    "                X_test_neg_permuted = X_test_neg.copy()\n",
    "                X_test_pos_permuted = X_test_pos.copy()\n",
    "\n",
    "                permuted_columns = np.random.permutation(np.hstack((X_test_pos_permuted[col].values,X_test_neg_permuted[col].values)))\n",
    "                X_test_neg_permuted[col] = permuted_columns[:X_test_neg_permuted.shape[0]]\n",
    "                X_test_pos_permuted[col] = permuted_columns[X_test_neg_permuted.shape[0]:]\n",
    "\n",
    "                y_pred_pos = model.predict_proba(X_test_pos_permuted.copy().drop(columns=features_to_drop))[:,1]\n",
    "                y_pred_neg = model.predict_proba(X_test_neg_permuted.copy().drop(columns=features_to_drop))[:,1]\n",
    "                evaluator = Evaluator(name='ogbl-citation2')\n",
    "                eval_dict = evaluator.eval({\n",
    "                            'y_pred_pos': torch.tensor(y_pred_pos),\n",
    "                            'y_pred_neg': torch.tensor(y_pred_neg).view(-1,1000),\n",
    "                        })\n",
    "                mrr_mean = eval_dict[\"mrr_list\"].mean()\n",
    "                importance = results[model_n-1] - mrr_mean\n",
    "                saved_per_feature.append(importance)\n",
    "            saved_per_model.append((np.mean(saved_per_feature)))\n",
    "        perm_importance.append((col, np.mean(saved_per_model),np.std(saved_per_model)))\n",
    "perm_importance.sort(key=lambda x: x[1], reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels, values, errors = zip(*perm_importance)\n",
    "\n",
    "# Creating the bar plot with error bars\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.barh(labels, values, xerr=errors, color='skyblue')\n",
    "plt.xlabel('Permutation Importance MRR difference')\n",
    "plt.ylabel('Features')\n",
    "plt.title('Feature Importance with Standard Deviation')\n",
    "plt.gca().invert_yaxis()  # Invert y-axis to have the highest value at the top\n",
    "plt.savefig(\"gcn_transfer_permutation_importnace_all_features.pdf\", format='pdf',dpi=5000,bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(0.9067)\n",
      "tensor(0.9152)\n",
      "tensor(0.9069)\n",
      "tensor(0.9083)\n",
      "tensor(0.9087)\n"
     ]
    }
   ],
   "source": [
    "kf = KFold(n_splits=5, shuffle=True, random_state=42)\n",
    "model_to_select = \"Random Forest\"\n",
    "features_to_drop = comined_pred_df_featured.columns[~comined_pred_df_featured.columns.isin([\"output\",\"prediction_model\",\"node_year_target\",\"common_neighbours_all\",\"in_degrees_target\"])]\n",
    "mrr_list = []\n",
    "n=0\n",
    "for train_index, test_index in kf.split(source):\n",
    "    n+=1\n",
    "   \n",
    "    X_train = comined_pred_df_featured[comined_pred_df_featured[\"source\"].isin(source[train_index])].copy()\n",
    "    y_train = X_train.pop(\"output\").values\n",
    "    X_test = comined_pred_df_featured[comined_pred_df_featured[\"source\"].isin(source[test_index])].copy()\n",
    "    y_test = X_test.pop(\"output\").values\n",
    "    if model_to_select == \"Random Forest\":\n",
    "        model = RandomForestClassifier(n_estimators=120, random_state=42,n_jobs = -1)\n",
    "    elif model_to_select == \"Logistic Regression\":\n",
    "        model = LogisticRegression()\n",
    "    model.fit(X_train.copy().drop(columns=features_to_drop), y_train)\n",
    "    \n",
    "    X_test_pos = pred_pos_df_featured[pred_pos_df_featured[\"source\"].isin(source[test_index])].copy().drop(columns=\"output\")\n",
    "    y_pred_pos = model.predict_proba(X_test_pos.copy().drop(columns=features_to_drop))[:,1]\n",
    "\n",
    "    X_test_neg = pred_neg_df_featured[pred_neg_df_featured[\"source\"].isin(source[test_index])].copy().drop(columns=\"output\")\n",
    "    y_pred_neg = model.predict_proba(X_test_neg.copy().drop(columns=features_to_drop))[:,1]\n",
    "\n",
    "    evaluator = Evaluator(name='ogbl-citation2')\n",
    "    eval_dict = evaluator.eval({\n",
    "                'y_pred_pos': torch.tensor(y_pred_pos),\n",
    "                'y_pred_neg': torch.tensor(y_pred_neg).view(-1,1000),\n",
    "            })\n",
    "    print(eval_dict[\"mrr_list\"].mean())\n",
    "    mrr_list.append(eval_dict[\"mrr_list\"].mean())\n",
    "    dump(model, f'./models_saved/transfer_random_forest_model_further_trained{n}.joblib')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "mrr_list = [0.9067,0.9152,0.9069,0.9083,0.9087]\n",
    "features_to_drop = comined_pred_df_featured.columns[~comined_pred_df_featured.columns.isin([\"output\",\"prediction_model\",\"node_year_target\",\"common_neighbours_all\",\"in_degrees_target\"])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "perm_importance = []\n",
    "n_times = 2\n",
    "for col in comined_pred_df_featured.drop(columns =\"output\").columns.values:\n",
    "    if col not in features_to_drop:\n",
    "        kf = KFold(n_splits=5, shuffle=True, random_state=42)\n",
    "        saved_per_model = []\n",
    "        model_n = 0\n",
    "        for train_index, test_index in kf.split(source):\n",
    "            model_n +=1\n",
    "            model = load(f'./models_saved/transfer_random_forest_model_further_trained{model_n}.joblib')\n",
    "            X_train = comined_pred_df_featured[comined_pred_df_featured[\"source\"].isin(source[train_index])].copy()\n",
    "            y_train = X_train.pop(\"output\").values\n",
    "            X_test = comined_pred_df_featured[comined_pred_df_featured[\"source\"].isin(source[test_index])].copy()\n",
    "            y_test = X_test.pop(\"output\").values\n",
    "\n",
    "            X_test_pos = pred_pos_df_featured[pred_pos_df_featured[\"source\"].isin(source[test_index])].copy().drop(columns=\"output\")\n",
    "\n",
    "            X_test_neg = pred_neg_df_featured[pred_neg_df_featured[\"source\"].isin(source[test_index])].copy().drop(columns=\"output\")\n",
    "            saved_per_feature = []\n",
    "            for x in range(n_times):\n",
    "                X_test_neg_permuted = X_test_neg.copy()\n",
    "                X_test_pos_permuted = X_test_pos.copy()\n",
    "\n",
    "                permuted_columns = np.random.permutation(np.hstack((X_test_pos_permuted[col].values,X_test_neg_permuted[col].values)))\n",
    "                X_test_neg_permuted[col] = permuted_columns[:X_test_neg_permuted.shape[0]]\n",
    "                X_test_pos_permuted[col] = permuted_columns[X_test_neg_permuted.shape[0]:]\n",
    "\n",
    "                y_pred_pos = model.predict_proba(X_test_pos_permuted.copy().drop(columns=features_to_drop))[:,1]\n",
    "                y_pred_neg = model.predict_proba(X_test_neg_permuted.copy().drop(columns=features_to_drop))[:,1]\n",
    "                evaluator = Evaluator(name='ogbl-citation2')\n",
    "                eval_dict = evaluator.eval({\n",
    "                            'y_pred_pos': torch.tensor(y_pred_pos),\n",
    "                            'y_pred_neg': torch.tensor(y_pred_neg).view(-1,1000),\n",
    "                        })\n",
    "                mrr_mean = eval_dict[\"mrr_list\"].mean()\n",
    "                importance = mrr_list[model_n-1] - mrr_mean\n",
    "                saved_per_feature.append(importance)\n",
    "            saved_per_model.append((np.mean(saved_per_feature)))\n",
    "        perm_importance.append((col, np.mean(saved_per_model),np.std(saved_per_model)))\n",
    "perm_importance.sort(key=lambda x: x[1], reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "labels, values, errors = zip(*perm_importance)\n",
    "\n",
    "# Creating the bar plot with error bars\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.barh(labels, values, xerr=errors, color='skyblue')\n",
    "plt.xlabel('Permutation Importance MRR difference')\n",
    "plt.ylabel('Features')\n",
    "plt.title('Feature Importance with Standard Deviation')\n",
    "plt.gca().invert_yaxis()  # Invert y-axis to have the highest value at the top\n",
    "plt.savefig(\"gcn_transfer_permutation_importnace_four_features.pdf\", format='pdf',dpi=5000,bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test on testset\n",
    "\n",
    "Here the random forest model is trained on the validation set and tested on the testset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path_test = \"./dataset/sample_data_for_evaluation_build/gcn_reference/test/\"\n",
    "pos_preds_test = np.load(f\"{data_path_test}pos_preds.npy\")\n",
    "neg_preds_test = np.load(f\"{data_path_test}neg_preds.npy\")\n",
    "pred_pos_df_featured_test= pd.read_csv(\"./dataset/modelling_results_calc_saved/pred_pos_df_featured_test.csv\", index_col=0)\n",
    "pred_neg_df_featured_test = pd.read_csv(\"./dataset/modelling_results_calc_saved/pred_neg_df_featured_test.csv\", index_col=0)\n",
    "pred_pos_df_featured_test[\"prediction_model\"] = pos_preds_test\n",
    "pred_neg_df_featured_test[\"prediction_model\"] = neg_preds_test.reshape(-1)\n",
    "comined_pred_df_featured_test = pd.concat([pred_neg_df_featured_test,pred_pos_df_featured_test])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_to_select = \"Random Forest\"\n",
    "features_to_drop = comined_pred_df_featured.columns[~comined_pred_df_featured.columns.isin([\"output\",\"prediction_model\",\"node_year_target\",\"common_neighbours_all\",\"in_degrees_target\"])]\n",
    "   \n",
    "X_train = comined_pred_df_featured.copy()\n",
    "y_train = X_train.pop(\"output\").values\n",
    "X_test = comined_pred_df_featured_test.copy()\n",
    "y_test = X_test.pop(\"output\").values\n",
    "if model_to_select == \"Random Forest\":\n",
    "    model = RandomForestClassifier(n_estimators=120, random_state=42,n_jobs = -1)\n",
    "elif model_to_select == \"Logistic Regression\":\n",
    "    model = LogisticRegression()\n",
    "model.fit(X_train.copy().drop(columns=features_to_drop), y_train)\n",
    "\n",
    "X_test_pos = pred_pos_df_featured_test.copy().drop(columns=\"output\")\n",
    "y_pred_pos = model.predict_proba(X_test_pos.copy().drop(columns=features_to_drop))[:,1]\n",
    "\n",
    "X_test_neg = pred_neg_df_featured_test.copy().drop(columns=\"output\")\n",
    "y_pred_neg = model.predict_proba(X_test_neg.copy().drop(columns=features_to_drop))[:,1]\n",
    "\n",
    "evaluator = Evaluator(name='ogbl-citation2')\n",
    "eval_dict = evaluator.eval({\n",
    "            'y_pred_pos': torch.tensor(y_pred_pos),\n",
    "            'y_pred_neg': torch.tensor(y_pred_neg).view(-1,1000),\n",
    "        })\n",
    "\n",
    "dump(model, f'./models_saved/transfer_random_forest_model_further_trained_full_data.joblib')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "perm_importance = []\n",
    "result = 0.8856 #eval_dict[\"mrr_list\"].mean()\n",
    "n_times = 5\n",
    "model = load(f'./models_saved/transfer_random_forest_model_further_trained_full_data.joblib')\n",
    "for col in X_test_pos.columns:\n",
    "    if col not in features_to_drop:            \n",
    "\n",
    "        saved_per_feature = []\n",
    "        for x in range(n_times):\n",
    "            X_test_neg_permuted = X_test_neg.copy()\n",
    "            X_test_pos_permuted = X_test_pos.copy()\n",
    "\n",
    "            permuted_columns = np.random.permutation(np.hstack((X_test_pos_permuted[col].values,X_test_neg_permuted[col].values)))\n",
    "            X_test_neg_permuted[col] = permuted_columns[:X_test_neg_permuted.shape[0]]\n",
    "            X_test_pos_permuted[col] = permuted_columns[X_test_neg_permuted.shape[0]:]\n",
    "\n",
    "            y_pred_pos = model.predict_proba(X_test_pos_permuted.copy().drop(columns=features_to_drop))[:,1]\n",
    "            y_pred_neg = model.predict_proba(X_test_neg_permuted.copy().drop(columns=features_to_drop))[:,1]\n",
    "            evaluator = Evaluator(name='ogbl-citation2')\n",
    "            eval_dict = evaluator.eval({\n",
    "                        'y_pred_pos': torch.tensor(y_pred_pos),\n",
    "                        'y_pred_neg': torch.tensor(y_pred_neg).view(-1,1000),\n",
    "                    })\n",
    "            mrr_mean = eval_dict[\"mrr_list\"].mean()\n",
    "            importance = result - mrr_mean\n",
    "            saved_per_feature.append(importance)\n",
    "        perm_importance.append((col, np.mean(saved_per_feature),np.std(saved_per_feature)))\n",
    "perm_importance.sort(key=lambda x: x[1], reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "labels, values, errors = zip(*perm_importance)\n",
    "\n",
    "# Creating the bar plot with error bars\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.barh(labels, values, xerr=errors, color='skyblue')\n",
    "plt.xlabel('Permutation Importance MRR difference')\n",
    "plt.ylabel('Features')\n",
    "plt.title('Feature Importance with Standard Deviation')\n",
    "plt.gca().invert_yaxis()  # Invert y-axis to have the highest value at the top\n",
    "plt.savefig(\"gcn_transfer_permutation_importnace_four_features_test.pdf\", format='pdf',dpi=5000,bbox_inches='tight')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}