4_LOAD_GNNs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GNNs working on a different cohort \n",
    "\n",
    "In this notebook, we obtain the results for GNNs, baseline, and non-GNN models using a completely different cohort of Late Onset Alzheimer's Disease subjects and healthy controls.\n",
    "\n",
    "The graph datasets were built using the network that obtained best performance in ADNI dataset (both with PET and PET&DX labellings), which is AD PPT-Ohmnet. \n",
    "\n",
    "*Disclaimer*: please note that many parts of this code require the preprocessed data from LOAD (both genetic and diagnostic related) as input. This data has not been uploaded to the repository for privacy reasons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/laura/anaconda3/envs/graphgym/lib/python3.7/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import sys, os, datetime, pickle\n",
    "\n",
    "from sklearn import preprocessing, metrics\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from create_datasets import create_nx_datasets, create_splits, create_table_datasets\n",
    "from ml_models import models_stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Data preprocessing\n",
    "\n",
    "Please refer to `data_preprocessing` subdirectory for this part.\n",
    "2. [extract_and_annotate_missense_LOAD.sh](data_preprocessing/extract_and_annotate_missense_LOAD.sh) is the script for obtaining missense variants from the VCF files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Create graph datasets\n",
    "\n",
    "Create graph datasets (one graph representing each patient) for different targets with LOAD dataset. As previously stated, we only obtain graph datasets using AD PPT-Ohmnet network (named as `snap_brain` in the following code)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Network used: AD snap_brain\n",
      "# nodes = 29\n",
      "# edges = 52\n",
      "\n",
      "Dataset used: LOAD\n",
      "(11, 1678)\n",
      "(11, 1608)\n",
      "missense\n",
      "(29, 1599)\n",
      "Creating samples graphs...\n",
      "Class: LOAD. Found 1014 positive subjects out of 1599\n",
      "Sample graph used: # nodes = 29 # edges = 52\n",
      "Density = 0.12807881773399016 Diameter = 6\n",
      "Coding: number of missense variants per node\n",
      "Resulting dataset saved at: data/graph_datasets/LOAD/AD_PPI_snap_brain_missense.pkl\n",
      "\n",
      "Processing time: 0:00:55.406044\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "networks = ['snap_brain']\n",
    "\n",
    "for network in networks:\n",
    "\n",
    "    outdir = f'data/graph_datasets/LOAD'\n",
    "\n",
    "    start_time = datetime.datetime.now()\n",
    "    print()\n",
    "\n",
    "    result_nodes = create_nx_datasets.main('data', 'LOAD', 'LOAD', 'AD', network, 'missense', None)\n",
    "    print('Coding: number of missense variants per node')\n",
    "\n",
    "    outfile = f'{outdir}/AD_PPI_{network}_missense.pkl'\n",
    "    print('Resulting dataset saved at:', outfile)\n",
    "    print()\n",
    "\n",
    "    with open(outfile, 'wb') as f:\n",
    "        pickle.dump(result_nodes, f)\n",
    "\n",
    "    result_nodes_time = datetime.datetime.now()\n",
    "    print('Processing time:', result_nodes_time - start_time)\n",
    "    print('\\n\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Graph classification with GNNs\n",
    "\n",
    "We then evaluated and tested different GNN configurations in the framework called [GraphGym](https://github.com/snap-stanford/GraphGym) (You *et al.*, 2020).\n",
    "\n",
    "Configuration and grid files employed are in the subdirectory [graphgym_files](graphgym_files).\n",
    "\n",
    "Summarized results obtained by GraphGym in LOAD dataset are in **COMPLETE**\n",
    "\n",
    "We run GraphGym 10 times, with the 10 different splits generated by 10-Fold Stratified Cross-Validation (see below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LOAD\n",
      "Fold -  1   |   train -  [526 913]   |   test -  [ 59 101]\n",
      "Fold -  2   |   train -  [526 913]   |   test -  [ 59 101]\n",
      "Fold -  3   |   train -  [526 913]   |   test -  [ 59 101]\n",
      "Fold -  4   |   train -  [526 913]   |   test -  [ 59 101]\n",
      "Fold -  5   |   train -  [526 913]   |   test -  [ 59 101]\n",
      "Fold -  6   |   train -  [527 912]   |   test -  [ 58 102]\n",
      "Fold -  7   |   train -  [527 912]   |   test -  [ 58 102]\n",
      "Fold -  8   |   train -  [527 912]   |   test -  [ 58 102]\n",
      "Fold -  9   |   train -  [527 912]   |   test -  [ 58 102]\n",
      "Fold -  10   |   train -  [527 913]   |   test -  [ 58 101]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Create split for using it in GraphGym and non-GNN models\n",
    "# Splits are obtained through 10-Fold Stratied Cross Validation\n",
    "\n",
    "create_splits.create_folds_stratified_cv('LOAD', 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Create table datasets\n",
    "\n",
    "Create table datasets for the LOAD target and genes of interest to use as input for more-standard machine learning models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Input: type of variant, best network from previous analysis, missense data, diagnosis/metadata\n",
    "table_dataset = create_table_datasets.load_data('missense',\n",
    "                                                  'data/bio_networks/AD_SNAP_PPI_brain.edgelist',\n",
    "                                                  'data/table_datasets/AD_snap_brain_missense_LOAD.csv',\n",
    "                                                  'data/LOAD/LOAD_metadata.tsv')\n",
    "table_dataset.to_csv(f'data/table_datasets/AD_PPI_missense_LOAD_labeled.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Baseline model - Logistic Regression only with APOE\n",
    "Create baseline models, meaning Logistic Regression models for each label only using the number of missense variants in APOE as input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target = 'LOAD'\n",
    "    \n",
    "result_df = pd.DataFrame(columns = ['fold', 'target', 'dataset', 'model', 'acc', 'pre', 'rec', 'f1', 'auc'])\n",
    "\n",
    "data = pd.read_csv('data/table_datasets/AD_PPI_missense_LOAD_labeled.csv', index_col = 0)\n",
    "data_wclass = create_labels.label_LOAD(data)\n",
    "\n",
    "x = data_wclass.drop(columns=['y'])\n",
    "x = x['APOE']\n",
    "\n",
    "y = data_wclass['y']\n",
    "x.index = x.index.str.upper()\n",
    "\n",
    "for i in range(10):\n",
    "\n",
    "    i += 1\n",
    "\n",
    "    f = open(f'data/splits/10Fold_CV_{target}/k{i}_{target}.pkl', 'rb')\n",
    "    split = pickle.load(f)\n",
    "    f.close()\n",
    "\n",
    "    tr_idx = split['train']\n",
    "    te_idx = split['valid']\n",
    "\n",
    "    x_train, x_test = x.iloc[tr_idx], x.iloc[te_idx]\n",
    "    y_train, y_test = y[tr_idx], y[te_idx]\n",
    "\n",
    "    x_train = np.array(x_train).reshape(-1, 1)\n",
    "    x_test = np.array(x_test).reshape(-1, 1)\n",
    "\n",
    "    scaler = preprocessing.StandardScaler().fit(x_train)\n",
    "    x_train_scaled = scaler.transform(x_train)\n",
    "    x_test_scaled = scaler.transform(x_test)\n",
    "\n",
    "    logreg = LogisticRegression()\n",
    "    logreg.fit(x_train_scaled, y_train)\n",
    "\n",
    "    y_prob = logreg.predict_proba(x_test_scaled)\n",
    "\n",
    "    y_pred = logreg.predict(x_test_scaled)\n",
    "    acc = metrics.accuracy_score(y_test, y_pred)\n",
    "    pre = metrics.precision_score(y_test, y_pred)\n",
    "    rec = metrics.recall_score(y_test, y_pred)\n",
    "    f1  = metrics.f1_score(y_test, y_pred)\n",
    "    auc = metrics.roc_auc_score(y_test, y_prob[:, 1])\n",
    "\n",
    "    result_df.loc[len(result_df)] = [i, target, 'Only APOE', 'Baseline model', acc, pre, rec, f1, auc]\n",
    "\n",
    "result_df.to_csv(f'results/2022_03_baseline_models_{target}.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Other non-GNN models\n",
    "Build non-GNN models (Logistic Regression, SVM with Linear and RBF kernels, and Random Forest) using as input the number of missense variants found in the genes present in AD PPT-Ohmnet network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target = 'LOAD'\n",
    "        \n",
    "data = pd.read_csv('data/table_datasets/AD_PPI_missense_LOAD_labeled.csv', index_col = 0)\n",
    "data_wclass =  create_labels.label_LOAD(data) # label dataset with the corresponding label\n",
    "data_wclass = data_wclass.loc[:, (data_wclass != 0).any(axis=0)] # delete genes that do not have mutations (all zeroes)\n",
    "    \n",
    "x = data_wclass.drop(columns=['y'])\n",
    "y = data_wclass['y']\n",
    "x.index = x.index.str.upper()\n",
    "\n",
    "results = [] # list of lists that stores performance metrics\n",
    "    \n",
    "for i in range(10):\n",
    "\n",
    "    i += 1\n",
    "\n",
    "    print('Fold', i)\n",
    "    print('-------------------------------------------------')\n",
    "\n",
    "    f = open(f'data/splits/10Fold_CV_{target}/k{i}_{target}.pkl', 'rb')\n",
    "    split = pickle.load(f)\n",
    "    f.close()\n",
    "\n",
    "    tr_idx = split['train']\n",
    "    te_idx = split['valid']\n",
    "\n",
    "    x_train, x_test = x.iloc[tr_idx], x.iloc[te_idx]\n",
    "    y_train, y_test = y[tr_idx], y[te_idx]\n",
    "\n",
    "    scaler = preprocessing.StandardScaler().fit(x_train)\n",
    "    x_train_scaled = scaler.transform(x_train)\n",
    "    x_test_scaled = scaler.transform(x_test)\n",
    "\n",
    "    # Logistic Regression\n",
    "    logreg = LogisticRegression()\n",
    "    logreg.fit(x_train_scaled, y_train)\n",
    "    y_prob_logreg = logreg.predict_proba(x_test_scaled)\n",
    "    y_pred_logreg = logreg.predict(x_test_scaled)\n",
    "    results.append([i, target, 'AD PPT-Ohmnet', 'Logistic Regression',\n",
    "                    metrics.accuracy_score(y_test, y_pred_logreg),\n",
    "                    metrics.precision_score(y_test, y_pred_logreg),\n",
    "                    metrics.recall_score(y_test, y_pred_logreg),\n",
    "                    metrics.f1_score(y_test, y_pred_logreg),\n",
    "                    metrics.roc_auc_score(y_test, y_prob_logreg[:, 1])])\n",
    "\n",
    "    # SVM Linear\n",
    "    svm_lin = SVC(probability=True)\n",
    "    param_grid_svm_lin = [{'C': [0.01, 0.1, 1, 10, 100, 1000]}]\n",
    "    grid_search_svm_lin = GridSearchCV(svm_lin, param_grid_svm_lin, cv=10, scoring='roc_auc', n_jobs = -1, verbose = 3)\n",
    "    grid_search_svm_lin.fit(x_train_scaled, y_train)\n",
    "    print(grid_search_svm_lin.best_estimator_)\n",
    "    y_prob_svm_lin = grid_search_svm_lin.predict_proba(x_test_scaled)\n",
    "    y_pred_svm_lin = grid_search_svm_lin.predict(x_test_scaled)\n",
    "    results.append([i, target, 'AD PPT-Ohmnet', 'SVM Linear',\n",
    "                    metrics.accuracy_score(y_test, y_pred_svm_lin),\n",
    "                    metrics.precision_score(y_test, y_pred_svm_lin),\n",
    "                    metrics.recall_score(y_test, y_pred_svm_lin),\n",
    "                    metrics.f1_score(y_test, y_pred_svm_lin),\n",
    "                    metrics.roc_auc_score(y_test, y_prob_svm_lin[:, 1])])\n",
    "\n",
    "    # SVM RBF\n",
    "    svm_rbf = SVC(probability=True, kernel='rbf')\n",
    "    param_grid_svm_rbf = [{'C': [0.01, 0.1, 1, 10, 100, 1000], 'gamma': [0.001, 0.01, 0.1, 1]}]\n",
    "    grid_search_svm_rbf = GridSearchCV(svm_rbf, param_grid_svm_rbf, cv=10, scoring='roc_auc', n_jobs = -1, verbose = 3)\n",
    "    grid_search_svm_rbf.fit(x_train_scaled, y_train)\n",
    "    print(grid_search_svm_rbf.best_estimator_)\n",
    "    y_prob_svm_rbf = grid_search_svm_rbf.predict_proba(x_test_scaled)\n",
    "    y_pred_svm_rbf = grid_search_svm_rbf.predict(x_test_scaled)\n",
    "    results.append([i, target, 'AD PPT-Ohmnet', 'SVM RBF',\n",
    "                    metrics.accuracy_score(y_test, y_pred_svm_rbf),\n",
    "                    metrics.precision_score(y_test, y_pred_svm_rbf),\n",
    "                    metrics.recall_score(y_test, y_pred_svm_rbf),\n",
    "                    metrics.f1_score(y_test, y_pred_svm_rbf),\n",
    "                    metrics.roc_auc_score(y_test, y_prob_svm_rbf[:, 1])])\n",
    "\n",
    "    # Random Forest\n",
    "    rf_clf = RandomForestClassifier()\n",
    "    param_grid = [{'n_estimators': [50, 500, 5000]}]\n",
    "    grid_search_rf = GridSearchCV(rf_clf, param_grid, cv=10, scoring='roc_auc', n_jobs = -1, verbose = 3)\n",
    "    grid_search_rf.fit(x_train, y_train)\n",
    "    print(grid_search_rf.best_estimator_)\n",
    "    y_prob_rf = grid_search_rf.predict_proba(x_test)\n",
    "    y_pred_rf = grid_search_rf.predict(x_test)\n",
    "    results.append([i, target, 'AD PPT-Ohmnet', 'Random Forest',\n",
    "                    metrics.accuracy_score(y_test, y_pred_rf),\n",
    "                    metrics.precision_score(y_test, y_pred_rf),\n",
    "                    metrics.recall_score(y_test, y_pred_rf),\n",
    "                    metrics.f1_score(y_test, y_pred_rf),\n",
    "                    metrics.roc_auc_score(y_test, y_prob_rf[:, 1])])\n",
    "\n",
    "    print()\n",
    "        \n",
    "results_df = pd.DataFrame(results, columns=['fold', 'target', 'dataset', 'model', 'acc', 'pre', 'rec', 'f1', 'auc'])\n",
    "results_df.to_csv(f'results/2022_03_nonGNN_models_{target}.csv', index=False)\n",
    "results_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Analyze results\n",
    "\n",
    "### 7.1. Comparison between labels and datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "pet_GNN     = pd.read_csv('results/2022_03_networks_PET.csv', index_col='fold')\n",
    "pet_bas     = pd.read_csv('results/2022_03_baseline_models_PET.csv',  index_col='fold')\n",
    "\n",
    "petdx_GNN   = pd.read_csv('results/2022_03_networks_PETandDX.csv', index_col='fold')\n",
    "petdx_bas   = pd.read_csv('results/2022_03_baseline_models_PETandDX.csv',  index_col='fold')\n",
    "\n",
    "load_GNN    = pd.read_csv('results/2022_04_networks_LOAD.csv', index_col='fold')\n",
    "load_bas    = pd.read_csv('results/2022_03_baseline_models_LOAD.csv',  index_col='fold')\n",
    "\n",
    "all_labels = pd.concat([pet_GNN, pet_bas, petdx_GNN, petdx_bas, load_GNN, load_bas])\n",
    "all_labels = all_labels.loc[(all_labels['dataset'] == 'AD PPT-Ohmnet') | (all_labels['dataset'] == 'Only APOE')]\n",
    "\n",
    "results = all_labels.replace({'Only APOE': 'Only APOE - Baseline model', 'AD PPT-Ohmnet': 'AD PPT-Ohmnet - GNN GraphGym'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 10))\n",
    "sns.boxplot(x='target', y='auc', data=results, hue='dataset',\n",
    "            hue_order=['Only APOE - Baseline model', 'AD PPT-Ohmnet - GNN GraphGym'],\n",
    "            order=['PET', 'PET&DX', 'LOAD'],\n",
    "            palette=sns.color_palette([\"#F8766D\", \"#E76BF3\"]),\n",
    "            showmeans = True, meanprops = {\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\", \"markersize\":\"10\"}) \n",
    "plt.xticks(fontsize=16)\n",
    "plt.ylim(0.5, 1)\n",
    "plt.yticks(fontsize=14)\n",
    "plt.legend(title='Models', title_fontsize=16, fontsize=16)\n",
    "plt.xlabel('', fontsize=1)\n",
    "plt.ylabel('AUC', fontsize=14)\n",
    "plt.savefig(f'figures/figure5.eps', dpi=500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2. Comparison with other non-GNN models (Supp. Information)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "load_nonGNN = pd.read_csv('results/2022_03_nonGNN_models_LOAD.csv', index_col='fold')\n",
    "load_GNN    = pd.read_csv('results/2022_04_networks_LOAD.csv', index_col='fold')\n",
    "load_bas    = pd.read_csv('results/2022_03_baseline_models_LOAD.csv',  index_col='fold')\n",
    "load_all = pd.concat([load_nonGNN, load_GNN])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Supplementary Figure 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "order = ['Only APOE', 'AD PPT-Ohmnet']\n",
    "hue = ['Logistic Regression','SVM Linear', 'SVM RBF', 'Random Forest', 'GNN GraphGym']\n",
    "hue_bas = ['', '', 'Baseline model', '', '']\n",
    "\n",
    "plt.figure(figsize=(6, 8))\n",
    "sns.boxplot(x = 'dataset', y = 'auc', hue = 'model', data = load_all, order = order, hue_order = hue,\n",
    "           palette = sns.color_palette([\"#B79F00\", \"#00BA38\", \"#00BFC4\", \"#619CFF\", \"#F564E3\"]),\n",
    "           showmeans = True, meanprops = {\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\", \"markersize\":\"10\"})\n",
    "sns.boxplot(x = 'dataset', y = 'auc', hue = 'model', data = load_bas, order = order, hue_order = hue_bas,\n",
    "           palette = sns.color_palette(['#F8766D', \"#F8766D\", \"#F8766D\", \"#F8766D\", \"#F8766D\"]),\n",
    "           showmeans = True, meanprops = {\"markerfacecolor\":\"white\", \"markeredgecolor\":\"black\", \"markersize\":\"10\"})\n",
    "\n",
    "plt.ylim(0.3, 1.0)\n",
    "plt.ylabel('AUC', fontsize=16)\n",
    "plt.xlabel('', fontsize=0)\n",
    "plt.xticks(fontsize=16)\n",
    "plt.title('LOAD label - TGenII dataset', fontsize=16)\n",
    "plt.tight_layout()\n",
    "plt.savefig(f'figures/supp_fig1.png', dpi=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AD PPT-Ohmnet Logistic Regression\n",
      "0.6540565185631225\n",
      "0.6732599999999999\n",
      "\n",
      "AD PPT-Ohmnet SVM Linear\n",
      "0.648240298167748\n",
      "0.6732599999999999\n",
      "\n",
      "AD PPT-Ohmnet SVM RBF\n",
      "0.6589959224976715\n",
      "0.6732599999999999\n",
      "\n",
      "AD PPT-Ohmnet Random Forest\n",
      "0.65393097905555\n",
      "0.6732599999999999\n",
      "\n",
      "AD PPT-Ohmnet GNN GraphGym\n",
      "0.6732599999999999\n",
      "0.6732599999999999\n",
      "\n",
      "AD PPT-Ohmnet no APOE Logistic Regression\n",
      "nan\n",
      "nan\n",
      "\n",
      "AD PPT-Ohmnet no APOE SVM Linear\n",
      "nan\n",
      "nan\n",
      "\n",
      "AD PPT-Ohmnet no APOE SVM RBF\n",
      "nan\n",
      "nan\n",
      "\n",
      "AD PPT-Ohmnet no APOE Random Forest\n",
      "nan\n",
      "nan\n",
      "\n",
      "AD PPT-Ohmnet no APOE GNN GraphGym\n",
      "nan\n",
      "nan\n",
      "\n",
      "Against baseline:\n",
      "( ) 5.9103e-01 AD PPT-Ohmnet - Logistic Regression\n",
      "( ) 6.9812e-01 AD PPT-Ohmnet - SVM Linear\n",
      "( ) 5.0101e-01 AD PPT-Ohmnet - SVM RBF\n",
      "( ) 5.9751e-01 AD PPT-Ohmnet - Random Forest\n",
      "( ) 2.3507e-01 AD PPT-Ohmnet - GNN GraphGym\n",
      "( ) nan AD PPT-Ohmnet no APOE - Logistic Regression\n",
      "( ) nan AD PPT-Ohmnet no APOE - SVM Linear\n",
      "( ) nan AD PPT-Ohmnet no APOE - SVM RBF\n",
      "( ) nan AD PPT-Ohmnet no APOE - Random Forest\n",
      "( ) nan AD PPT-Ohmnet no APOE - GNN GraphGym\n",
      "\n",
      "Against GNN:\n",
      "( ) 1.8120e-01 AD PPT-Ohmnet - Logistic Regression\n",
      "( ) 1.0880e-01 AD PPT-Ohmnet - SVM Linear\n",
      "( ) 2.6273e-01 AD PPT-Ohmnet - SVM RBF\n",
      "( ) 1.6804e-01 AD PPT-Ohmnet - Random Forest\n",
      "( ) 5.0000e-01 AD PPT-Ohmnet - GNN GraphGym\n",
      "( ) nan AD PPT-Ohmnet no APOE - Logistic Regression\n",
      "( ) nan AD PPT-Ohmnet no APOE - SVM Linear\n",
      "( ) nan AD PPT-Ohmnet no APOE - SVM RBF\n",
      "( ) nan AD PPT-Ohmnet no APOE - Random Forest\n",
      "( ) nan AD PPT-Ohmnet no APOE - GNN GraphGym\n",
      "\n",
      "Against random:\n",
      "( ) 1.0000e+00 AD PPT-Ohmnet - Logistic Regression\n",
      "( ) 1.0000e+00 AD PPT-Ohmnet - SVM Linear\n",
      "( ) 1.0000e+00 AD PPT-Ohmnet - SVM RBF\n",
      "( ) 1.0000e+00 AD PPT-Ohmnet - Random Forest\n",
      "( ) 1.0000e+00 AD PPT-Ohmnet - GNN GraphGym\n",
      "( ) nan AD PPT-Ohmnet no APOE - Logistic Regression\n",
      "( ) nan AD PPT-Ohmnet no APOE - SVM Linear\n",
      "( ) nan AD PPT-Ohmnet no APOE - SVM RBF\n",
      "( ) nan AD PPT-Ohmnet no APOE - Random Forest\n",
      "( ) nan AD PPT-Ohmnet no APOE - GNN GraphGym\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/laura/Documents/CODE/graph-genetics/ml_models/models_stats.py:21: RuntimeWarning: Mean of empty slice.\n",
      "  print(tmp.mean())\n",
      "/home/laura/anaconda3/envs/graphgym/lib/python3.7/site-packages/numpy/core/_methods.py:189: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/home/laura/Documents/CODE/graph-genetics/ml_models/models_stats.py:22: RuntimeWarning: Mean of empty slice.\n",
      "  print(gnn.mean())\n",
      "/home/laura/anaconda3/envs/graphgym/lib/python3.7/site-packages/numpy/core/fromnumeric.py:3441: RuntimeWarning: Mean of empty slice.\n",
      "  out=out, **kwargs)\n",
      "/home/laura/anaconda3/envs/graphgym/lib/python3.7/site-packages/numpy/core/fromnumeric.py:3724: RuntimeWarning: Degrees of freedom <= 0 for slice\n",
      "  **kwargs)\n",
      "/home/laura/anaconda3/envs/graphgym/lib/python3.7/site-packages/numpy/core/_methods.py:223: RuntimeWarning: invalid value encountered in true_divide\n",
      "  subok=False)\n",
      "/home/laura/anaconda3/envs/graphgym/lib/python3.7/site-packages/numpy/core/_methods.py:254: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n"
     ]
    }
   ],
   "source": [
    "load_all = pd.concat([load_all, load_bas])\n",
    "pvalues_bas_load, pvalues_ran_load = models_stats.pvalues_nonGNNs(load_all)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Supplementary Tables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>dataset</th>\n",
       "      <th>model</th>\n",
       "      <th>acc_format</th>\n",
       "      <th>pre_format</th>\n",
       "      <th>rec_format</th>\n",
       "      <th>f1_format</th>\n",
       "      <th>auc_format</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>fold</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AD PPT-Ohmnet</td>\n",
       "      <td>Logistic Regression</td>\n",
       "      <td>0.6542 ± 0.0335</td>\n",
       "      <td>0.7353 ± 0.0261</td>\n",
       "      <td>0.7109 ± 0.0491</td>\n",
       "      <td>0.7222 ± 0.032</td>\n",
       "      <td>0.6541 ± 0.0505</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AD PPT-Ohmnet</td>\n",
       "      <td>SVM Linear</td>\n",
       "      <td>0.6535 ± 0.04</td>\n",
       "      <td>0.6962 ± 0.035</td>\n",
       "      <td>0.8135 ± 0.0915</td>\n",
       "      <td>0.7472 ± 0.0373</td>\n",
       "      <td>0.6482 ± 0.0465</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AD PPT-Ohmnet</td>\n",
       "      <td>SVM RBF</td>\n",
       "      <td>0.6485 ± 0.028</td>\n",
       "      <td>0.6747 ± 0.066</td>\n",
       "      <td>0.9131 ± 0.1413</td>\n",
       "      <td>0.7649 ± 0.0243</td>\n",
       "      <td>0.659 ± 0.0564</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AD PPT-Ohmnet</td>\n",
       "      <td>Random Forest</td>\n",
       "      <td>0.6604 ± 0.0405</td>\n",
       "      <td>0.713 ± 0.0267</td>\n",
       "      <td>0.778 ± 0.0623</td>\n",
       "      <td>0.7431 ± 0.0373</td>\n",
       "      <td>0.6539 ± 0.0464</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AD PPT-Ohmnet</td>\n",
       "      <td>GNN GraphGym</td>\n",
       "      <td>0.6523 ± 0.0486</td>\n",
       "      <td>0.6917 ± 0.1004</td>\n",
       "      <td>0.7781 ± 0.0928</td>\n",
       "      <td>0.7236 ± 0.0797</td>\n",
       "      <td>0.6733 ± 0.0409</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Only APOE</td>\n",
       "      <td>Baseline model</td>\n",
       "      <td>0.6648 ± 0.0397</td>\n",
       "      <td>0.7662 ± 0.0341</td>\n",
       "      <td>0.6784 ± 0.0466</td>\n",
       "      <td>0.7191 ± 0.0373</td>\n",
       "      <td>0.6591 ± 0.0451</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            dataset                model       acc_format       pre_format  \\\n",
       "fold                                                                         \n",
       "1     AD PPT-Ohmnet  Logistic Regression  0.6542 ± 0.0335  0.7353 ± 0.0261   \n",
       "1     AD PPT-Ohmnet           SVM Linear    0.6535 ± 0.04   0.6962 ± 0.035   \n",
       "1     AD PPT-Ohmnet              SVM RBF   0.6485 ± 0.028   0.6747 ± 0.066   \n",
       "1     AD PPT-Ohmnet        Random Forest  0.6604 ± 0.0405   0.713 ± 0.0267   \n",
       "1     AD PPT-Ohmnet         GNN GraphGym  0.6523 ± 0.0486  0.6917 ± 0.1004   \n",
       "1         Only APOE       Baseline model  0.6648 ± 0.0397  0.7662 ± 0.0341   \n",
       "\n",
       "           rec_format        f1_format       auc_format  \n",
       "fold                                                     \n",
       "1     0.7109 ± 0.0491   0.7222 ± 0.032  0.6541 ± 0.0505  \n",
       "1     0.8135 ± 0.0915  0.7472 ± 0.0373  0.6482 ± 0.0465  \n",
       "1     0.9131 ± 0.1413  0.7649 ± 0.0243   0.659 ± 0.0564  \n",
       "1      0.778 ± 0.0623  0.7431 ± 0.0373  0.6539 ± 0.0464  \n",
       "1     0.7781 ± 0.0928  0.7236 ± 0.0797  0.6733 ± 0.0409  \n",
       "1     0.6784 ± 0.0466  0.7191 ± 0.0373  0.6591 ± 0.0451  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_load = pd.DataFrame()\n",
    "mean_load['dataset'] = load_all['dataset']\n",
    "mean_load['model'] = load_all['model']\n",
    "mean_load['mean_acc'] = load_all.groupby(['dataset', 'model'])['acc'].transform('mean')\n",
    "mean_load['std_acc'] = load_all.groupby(['dataset', 'model'])['acc'].transform('std')\n",
    "mean_load['mean_pre'] = load_all.groupby(['dataset', 'model'])['pre'].transform('mean')\n",
    "mean_load['std_pre'] = load_all.groupby(['dataset', 'model'])['pre'].transform('std')\n",
    "mean_load['mean_rec'] = load_all.groupby(['dataset', 'model'])['rec'].transform('mean')\n",
    "mean_load['std_rec'] = load_all.groupby(['dataset', 'model'])['rec'].transform('std')\n",
    "mean_load['mean_f1']  = load_all.groupby(['dataset', 'model'])['f1'].transform('mean')\n",
    "mean_load['std_f1']  = load_all.groupby(['dataset', 'model'])['f1'].transform('std')\n",
    "mean_load['mean_auc'] = load_all.groupby(['dataset', 'model'])['auc'].transform('mean')\n",
    "mean_load['std_auc'] = load_all.groupby(['dataset', 'model'])['auc'].transform('std')\n",
    "mean_load = mean_load.drop_duplicates()\n",
    "\n",
    "mean_load['acc_format'] = round(mean_load[\"mean_acc\"], 4).map(str) + ' ± ' + round(mean_load[\"std_acc\"], 4).map(str)\n",
    "mean_load['pre_format'] = round(mean_load[\"mean_pre\"], 4).map(str) + ' ± ' + round(mean_load[\"std_pre\"], 4).map(str)\n",
    "mean_load['rec_format'] = round(mean_load[\"mean_rec\"], 4).map(str) + ' ± ' + round(mean_load[\"std_rec\"], 4).map(str)\n",
    "mean_load['f1_format']  = round(mean_load[\"mean_f1\"], 4).map(str) + ' ± ' + round(mean_load[\"std_f1\"], 4).map(str)\n",
    "mean_load['auc_format'] = round(mean_load[\"mean_auc\"], 4).map(str) + ' ± ' + round(mean_load[\"std_auc\"], 4).map(str)\n",
    "mean_load[['dataset', 'model', 'acc_format', 'pre_format', 'rec_format', 'f1_format', 'auc_format']]"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "5e0466fb38f8b8207bee76f1d5f01e5f82e3be8917a80d900a987709dfd81e7a"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}