Datasets
Models
Downloads: 1
Diff of
/notebooks/benchmark.ipynb
[000000]
..
[efd906]
Switch to side-by-side view
--- a +++ b/notebooks/benchmark.ipynb @@ -0,0 +1,1245 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c750922c-9af8-43c0-9083-18f43259664d", + "metadata": {}, + "source": [ + "# Plot benchmarks\n", + "This jupyter notebook shows how to plot benchmarks of the performances of different multimodal strategies (i.e., late fusion, early fusion, DyAM...) for both classification and survival tasks." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "58c7932a-5abc-40ef-abbd-3723eed8f689", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.lines import Line2D\n", + "from matplotlib.colors import LogNorm\n", + "import pandas as pd \n", + "import seaborn as sns\n", + "from sksurv.util import Surv\n", + "from tqdm import tqdm\n", + "\n", + "# Setup for local running - please delete this block\n", + "import sys\n", + "sys.path.append('C:\\\\Users\\\\ncaptier\\\\Documents\\\\GitHub\\\\multipit\\\\')\n", + "\n", + "from multipit.result_analysis.compute_metrics import compute_all_classif, compute_cindex\n", + "from multipit.result_analysis.plot import plot_metrics" + ] + }, + { + "cell_type": "markdown", + "id": "bb2be0af-f871-473e-9cb4-fef306965fcf", + "metadata": {}, + "source": [ + "## 1. Benchmark for classification tasks" + ] + }, + { + "cell_type": "markdown", + "id": "15daa262-65cf-4da5-befe-8a45683a79f6", + "metadata": {}, + "source": [ + "### 1.1 Define models to benchmark" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1388c547-8b10-489a-918d-ac60caaa2bb6", + "metadata": {}, + "outputs": [], + "source": [ + "#{model_name: (path for 1y death results, path for 6m progression results)}\n", + "\n", + "models_dict = {'late_XGboost': (\"classification\\\\xgboost_perm_100CV_OS\\\\\", \"classification\\\\xgboost_perm_100CV_PFS\\\\\"),\n", + " 'late_LR': (\"classification\\\\LR_perm_100CV_OS\\\\\", \"classification\\\\LR_perm_100CV_PFS\\\\\"),\n", + " 'early_XGboost': (\"classification_early\\\\xgboost_100CV_OS\\\\\", \"classification_early\\\\xgboost_100CV_PFS\\\\\"),\n", + " 'early_select_XGboost': (\"classification_early\\\\xgboost_select_bis_100CV_OS\\\\\", \"classification_early\\\\xgboost_select_bis_100CV_PFS\\\\\"),\n", + " 'early_LR':(\"classification_early\\\\LR_100CV_OS\\\\\", \"classification_early\\\\LR_100CV_PFS\\\\\"),\n", + " 'early_select_LR': (\"classification_early\\\\LR_select_bis_100CV_OS\\\\\", \"classification_early\\\\LR_select_bis_100CV_PFS\\\\\"),\n", + " 'dyam': (\"classification\\\\Dyam_100CV_OS\\\\\", \"classification\\Dyam_100CV_PFS\\\\\"),\n", + " 'dyam_optim': (\"classification\\\\Dyam_tuned_10CV_OS\\\\\", \"classification\\Dyam_tuned_10CV_PFS\\\\\"),\n", + " 'dyam_select': (\"Dyam_select_bis_100CV_OS\\\\\", \"classification\\Dyam_select_bis_100CV_PFS\\\\\"),\n", + " 'dyam_optim_select': (\"classification\\\\Dyam_tuned_select_bis_10CV_OS\\\\\", \"classification\\Dyam_tuned_select_bis_10CV_PFS\\\\\")}" + ] + }, + { + "cell_type": "markdown", + "id": "47468890-144a-42d9-99ed-ab5d48238267", + "metadata": {}, + "source": [ + "### 1.2 Load data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "53782741-b1b3-4001-81a7-bb4cd49b488b", + "metadata": {}, + "outputs": [], + "source": [ + "df_omics = pd.read_csv(\"omics.csv\", sep=\";\", index_col=0)\n", + "patient_omics = df_omics.index\n", + "\n", + "df_clinicals = pd.read_csv(\"clinicals.csv\", index_col = 0, sep=\";\")\n", + "bool_mask_OS = (df_clinicals['OS'].isnull()) | ((df_clinicals['OS'] <= 365) & (df_clinicals['Statut Vital'] == \"Vivant\"))\n", + "bool_mask_PFS = (df_clinicals['PFS'].isnull()) | ((df_clinicals['PFS'] <= 180) & (df_clinicals['Progression'] == \"No\"))\n", + "df_clinicals_OS = df_clinicals[~bool_mask_OS]\n", + "patient_clinicals_OS = df_clinicals_OS.index\n", + "df_clinicals_PFS = df_clinicals[~bool_mask_PFS]\n", + "patient_clinicals_PFS = df_clinicals_PFS.index\n", + "\n", + "df_radiomics = pd.read_csv(\"radiomics.csv\", index_col=0, sep=\";\")\n", + "patient_radiomics = df_radiomics.index\n", + "\n", + "patient_pathomics = pd.read_csv(\"pathomics.csv\", index_col=0, sep=\";\").index\n", + "\n", + "all_patients_OS = set(patient_radiomics) & set(patient_pathomics) & set(patient_clinicals_OS) & set(patient_omics)\n", + "all_patients_PFS = set(patient_radiomics) & set(patient_pathomics) & set(patient_clinicals_PFS) & set(patient_omics)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ccf6fbd8-0d3d-49b1-a831-ae8ff44029b7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Patient OS: 77\n", + "Patient PFS: 75\n" + ] + } + ], + "source": [ + "print(\"Patient OS: \", len(all_patients_OS))\n", + "print(\"Patient PFS: \", len(all_patients_PFS))" + ] + }, + { + "cell_type": "markdown", + "id": "ec0c1dc4-c16a-4436-9678-425b77da4a20", + "metadata": {}, + "source": [ + "### 1.3 Save best results for each model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f85184b6-13ea-4edb-8462-5dce6dc95fa2", + "metadata": {}, + "outputs": [], + "source": [ + "def save_results(df, patients, model, list_best, list_best_name, list_clin, list_rad, list_path, list_rna):\n", + " # 1. Compute performance metrics\n", + " results = compute_all_classif(df.set_index(\"samples\").loc[list(set(list(patients)) & set(df[\"samples\"].unique()))],\n", + " names=list(df.columns[2:-2].values)\n", + " )\n", + " results = results[results[\"metric\"] == \"roc_auc\"].drop(columns = \"metric\")\n", + " \n", + " # 2. Select model with the best average performance (over the repeats)\n", + " best = results.mean().idxmax()\n", + " list_best.append(results[best].rename(model))\n", + " list_best_name.append(best)\n", + " \n", + " # 3. Save the performances of the unimodal models\n", + " list_clin.append(results[\"clinicals\"])\n", + " list_rad.append(results[\"radiomics\"])\n", + " list_path.append(results[\"pathomics\"])\n", + " list_rna.append(results[\"RNA\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "fc5c7563-8cf9-4db9-808c-e9223ed5ae80", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████| 10/10 [01:36<00:00, 9.69s/it]\n" + ] + } + ], + "source": [ + "list_OS, list_PFS = [], []\n", + "list_best_OS, list_best_PFS = [], []\n", + "list_clinicals_OS, list_radiomics_OS, list_pathomics_OS, list_RNA_OS = [], [], [], []\n", + "list_clinicals_PFS, list_radiomics_PFS, list_pathomics_PFS, list_RNA_PFS = [], [], [], []\n", + "\n", + "for model, pathes in tqdm(models_dict.items(), total = len(models_dict)):\n", + " df_OS = pd.read_csv(pathes[0] + \"predictions.csv\").rename(columns = {\"Unnamed: 0\": \"samples\"}).drop(columns=\"Dummy\", errors=\"ignore\")\n", + " df_PFS = pd.read_csv(pathes[1] + \"predictions.csv\").rename(columns = {\"Unnamed: 0\": \"samples\"}).drop(columns=\"Dummy\", errors=\"ignore\")\n", + " \n", + " save_results(df_OS, all_patients_OS, model, list_OS, list_best_OS, list_clinicals_OS, list_radiomics_OS, list_pathomics_OS, list_RNA_OS)\n", + " save_results(df_PFS, all_patients_PFS, model, list_PFS, list_best_PFS, list_clinicals_PFS, list_radiomics_PFS, list_pathomics_PFS, list_RNA_PFS)\n", + "\n", + "# Concat best performances \n", + "metric_OS = pd.concat(list_OS, axis=1)\n", + "metric_OS[\"metric\"] = \"1y death AUC\"\n", + "metric_PFS = pd.concat(list_PFS, axis=1)\n", + "metric_PFS[\"metric\"] = \"6m progression AUC\"\n", + "\n", + "# Save best unimodal performances\n", + "best_clinicals = np.argmax([mod.mean() for mod in list_clinicals_OS])\n", + "best_radiomics = np.argmax([mod.mean() for mod in list_radiomics_OS])\n", + "best_pathomics = np.argmax([mod.mean() for mod in list_pathomics_OS])\n", + "best_RNA = np.argmax([mod.mean() for mod in list_RNA_OS])\n", + "unimodal_OS = pd.concat([list_clinicals_OS[best_clinicals], list_radiomics_OS[best_radiomics], list_pathomics_OS[best_pathomics], list_RNA_OS[best_RNA]], axis=1)\n", + "unimodal_OS[\"metric\"] = \"1y death AUC\"\n", + "\n", + "best_clinicals_PFS = np.argmax([mod.mean() for mod in list_clinicals_PFS])\n", + "best_radiomics_PFS = np.argmax([mod.mean() for mod in list_radiomics_PFS])\n", + "best_pathomics_PFS = np.argmax([mod.mean() for mod in list_pathomics_PFS])\n", + "best_RNA_PFS = np.argmax([mod.mean() for mod in list_RNA_PFS])\n", + "unimodal_PFS = pd.concat([list_clinicals_PFS[best_clinicals_PFS], list_radiomics_PFS[best_radiomics_PFS], list_pathomics_PFS[best_pathomics_PFS], list_RNA_PFS[best_RNA_PFS]], axis=1)\n", + "unimodal_PFS[\"metric\"] = \"6m progression AUC\"" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "269401a0-1e97-4a1d-b071-bfa2d96cddd7", + "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>late_XGboost</th>\n", + " <th>late_LR</th>\n", + " <th>early_XGboost</th>\n", + " <th>early_select_XGboost</th>\n", + " <th>early_LR</th>\n", + " <th>early_select_LR</th>\n", + " <th>dyam</th>\n", + " <th>dyam_optim</th>\n", + " <th>dyam_select</th>\n", + " <th>dyam_optim_select</th>\n", + " <th>metric</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>5</th>\n", + " <td>0.764065</td>\n", + " <td>0.780399</td>\n", + " <td>0.775862</td>\n", + " <td>0.823956</td>\n", + " <td>0.718693</td>\n", + " <td>0.789474</td>\n", + " <td>0.788566</td>\n", + " <td>0.788566</td>\n", + " <td>0.806715</td>\n", + " <td>0.797641</td>\n", + " <td>1y death AUC</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11</th>\n", + " <td>0.854809</td>\n", + " <td>0.794918</td>\n", + " <td>0.769510</td>\n", + " <td>0.730490</td>\n", + " <td>0.697822</td>\n", + " <td>0.735935</td>\n", + " <td>0.767695</td>\n", + " <td>0.805808</td>\n", + " <td>0.808530</td>\n", + " <td>0.801270</td>\n", + " <td>1y death AUC</td>\n", + " </tr>\n", + " <tr>\n", + " <th>17</th>\n", + " <td>0.833938</td>\n", + " <td>0.757713</td>\n", + " <td>0.726860</td>\n", + " <td>0.725953</td>\n", + " <td>0.735027</td>\n", + " <td>0.756806</td>\n", + " <td>0.718693</td>\n", + " <td>0.754991</td>\n", + " <td>0.802178</td>\n", + " <td>0.743194</td>\n", + " <td>1y death AUC</td>\n", + " </tr>\n", + " <tr>\n", + " <th>23</th>\n", + " <td>0.835753</td>\n", + " <td>0.754991</td>\n", + " <td>0.778584</td>\n", + " <td>0.744102</td>\n", + " <td>0.744102</td>\n", + " <td>0.742287</td>\n", + " <td>0.742287</td>\n", + " <td>0.770417</td>\n", + " <td>0.833938</td>\n", + " <td>0.798548</td>\n", + " <td>1y death AUC</td>\n", + " </tr>\n", + " <tr>\n", + " <th>29</th>\n", + " <td>0.813975</td>\n", + " <td>0.775862</td>\n", + " <td>0.835753</td>\n", + " <td>0.723230</td>\n", + " <td>0.729583</td>\n", + " <td>0.725953</td>\n", + " <td>0.794011</td>\n", + " <td>0.690563</td>\n", + " <td>0.776770</td>\n", + " <td>0.725045</td>\n", + " <td>1y death AUC</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " late_XGboost late_LR early_XGboost early_select_XGboost early_LR \\\n", + "5 0.764065 0.780399 0.775862 0.823956 0.718693 \n", + "11 0.854809 0.794918 0.769510 0.730490 0.697822 \n", + "17 0.833938 0.757713 0.726860 0.725953 0.735027 \n", + "23 0.835753 0.754991 0.778584 0.744102 0.744102 \n", + "29 0.813975 0.775862 0.835753 0.723230 0.729583 \n", + "\n", + " early_select_LR dyam dyam_optim dyam_select dyam_optim_select \\\n", + "5 0.789474 0.788566 0.788566 0.806715 0.797641 \n", + "11 0.735935 0.767695 0.805808 0.808530 0.801270 \n", + "17 0.756806 0.718693 0.754991 0.802178 0.743194 \n", + "23 0.742287 0.742287 0.770417 0.833938 0.798548 \n", + "29 0.725953 0.794011 0.690563 0.776770 0.725045 \n", + "\n", + " metric \n", + "5 1y death AUC \n", + "11 1y death AUC \n", + "17 1y death AUC \n", + "23 1y death AUC \n", + "29 1y death AUC " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_multi = pd.concat([metric_OS, metric_PFS], axis=0)\n", + "results_multi.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bc33e5c4-4de8-450f-bb9d-3df9d50b88df", + "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>clinical</th>\n", + " <th>radiomics</th>\n", + " <th>pathomics</th>\n", + " <th>RNA</th>\n", + " <th>metric</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>5</th>\n", + " <td>0.770417</td>\n", + " <td>0.593466</td>\n", + " <td>0.540835</td>\n", + " <td>0.782214</td>\n", + " <td>1y death AUC</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11</th>\n", + " <td>0.756806</td>\n", + " <td>0.660617</td>\n", + " <td>0.510889</td>\n", + " <td>0.724138</td>\n", + " <td>1y death AUC</td>\n", + " </tr>\n", + " <tr>\n", + " <th>17</th>\n", + " <td>0.770417</td>\n", + " <td>0.607078</td>\n", + " <td>0.576225</td>\n", + " <td>0.701452</td>\n", + " <td>1y death AUC</td>\n", + " </tr>\n", + " <tr>\n", + " <th>23</th>\n", + " <td>0.702359</td>\n", + " <td>0.598004</td>\n", + " <td>0.581670</td>\n", + " <td>0.705989</td>\n", + " <td>1y death AUC</td>\n", + " </tr>\n", + " <tr>\n", + " <th>29</th>\n", + " <td>0.774047</td>\n", + " <td>0.601633</td>\n", + " <td>0.546279</td>\n", + " <td>0.805808</td>\n", + " <td>1y death AUC</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " clinical radiomics pathomics RNA metric\n", + "5 0.770417 0.593466 0.540835 0.782214 1y death AUC\n", + "11 0.756806 0.660617 0.510889 0.724138 1y death AUC\n", + "17 0.770417 0.607078 0.576225 0.701452 1y death AUC\n", + "23 0.702359 0.598004 0.581670 0.705989 1y death AUC\n", + "29 0.774047 0.601633 0.546279 0.805808 1y death AUC" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_unimodal = pd.concat([unimodal_OS, unimodal_PFS], axis=0).rename(columns = {\"clinicals\": \"clinical\"})\n", + "results_unimodal.head()" + ] + }, + { + "cell_type": "markdown", + "id": "12d9ee3d-46e4-4b13-a9a4-c983ea047c46", + "metadata": {}, + "source": [ + "### 1.4 Plot benchmark" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1fdf37db-c0ac-4a03-87db-dbec755fef5c", + "metadata": {}, + "outputs": [], + "source": [ + "def change_width(ax, new_value, multi=False) :\n", + " \"\"\"\n", + " Change bar width\n", + " \"\"\"\n", + " for i, patch in enumerate(ax.patches):\n", + " current_width = patch.get_width()\n", + " diff = current_width - new_value\n", + " # we change the bar width\n", + " patch.set_width(new_value)\n", + " # we recenter the bar\n", + " patch.set_x(patch.get_x() + diff * .5)\n", + " \n", + " # move groups of bars for multimodal benchmark\n", + " if multi:\n", + " if i in [0, 1, 2, 3]:\n", + " patch.set_x(patch.get_x() + diff * .5 - 0.03)\n", + " if i in [12, 13, 14, 15,16, 17, 18, 19]:\n", + " patch.set_x(patch.get_x() + diff * .5 + 0.03)\n", + " \n", + "def annotate_unimodal(ax, l1, l2):\n", + " \"\"\"\n", + " Add text annotation on each bar for unimodal benchmark\n", + " \"\"\"\n", + " for i, patch in enumerate(ax.patches[:len(l1) + len(l2)]):\n", + " if i%2 == 0:\n", + " model = l1[i//2]\n", + " else:\n", + " model = l2[i//2]\n", + " height = patch.get_height()\n", + " x_bar = patch.get_x() + 0.5*patch.get_width()\n", + " ax.text(x_bar, height - (height - 0.5)/2 , model, weight='bold', va='center', ha='center', fontsize=18, color=\"white\")\n", + "\n", + "def annotate_multimodal(ax, l1, l2, dic):\n", + " \"\"\"\n", + " Add text annotation on each bar for multimodal benchmark\n", + " \"\"\"\n", + " for i, patch in enumerate(ax.patches[:len(l1)+len(l2)]):\n", + " if i%2 == 0:\n", + " modas = [dic[n] for n in l1[i//2].split('+')]\n", + " else:\n", + " modas = [dic[n] for n in l2[i//2].split('+')]\n", + " n_modas = len(modas)\n", + " height = patch.get_height()\n", + " x_bar = patch.get_x() + 0.5*patch.get_width()\n", + " for j, mod in enumerate(modas):\n", + " ax.text(x_bar, height - (height - 0.5)/2 + (0.5*(n_modas-1) - j)*0.02, mod, weight='bold', va='center', ha='center', fontsize=18, color=\"white\")\n", + " \n", + "def errorbar(ax, results):\n", + " \"\"\"\n", + " Add error bar on each bar\n", + " \"\"\"\n", + " for i, patch in enumerate(ax.patches[:2*(len(results.columns) - 1)]):\n", + " columns = list(results.columns[:-1].values)\n", + " x_bar = patch.get_x() + 0.5*patch.get_width()\n", + " if i%2 == 0:\n", + " m = \"1y death AUC\"\n", + " else:\n", + " m = \"6m progression AUC\"\n", + " ax.errorbar(x=[patch.get_x() + 0.5*patch.get_width()],\n", + " y=results[results[\"metric\"] == m][columns[i//2]].mean(),\n", + " yerr=results[results[\"metric\"] == m][columns[i//2]].std(),\n", + " fmt='none',\n", + " ecolor='k',\n", + " capsize=10,\n", + " elinewidth=1.2)" + ] + }, + { + "cell_type": "markdown", + "id": "4488a1b7-f4fa-46f3-9fff-46c3b601e15d", + "metadata": {}, + "source": [ + "#### **Unimodal benchmark**" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "03aeb479-7a8e-443d-824f-530c54445a3d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1800x720 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(25, 10))\n", + "\n", + "df_plot = results_unimodal.melt(id_vars = [\"metric\"])\n", + "sns.barplot(data=df_plot, x=\"metric\", y=\"value\", hue=\"variable\", ax=ax, errorbar=None)\n", + "change_width(ax, 0.15)\n", + "errorbar(ax, results_unimodal)\n", + "\n", + "models = [\"XGboost\", \"LR\", \"XGboost\", \"XGboost\", \"LR\", \"LR\", \"Perceptron\", \"Perceptron\", \"Perceptron\", \"Perceptron\"]\n", + "annotate_unimodal(ax, l1= [models[best_clinicals], models[best_radiomics], models[best_pathomics], models[best_RNA]],\n", + " l2=[models[best_clinicals_PFS], models[best_radiomics_PFS], models[best_pathomics_PFS], models[best_RNA_PFS]])\n", + "\n", + "ax.legend(bbox_to_anchor=(0.955, 1.005), fontsize=16)\n", + "ax.set_ylim(0.5, 0.86)\n", + "ax.set_axisbelow(True)\n", + "ax.yaxis.grid(color='gray', linestyle='dashed')\n", + "ax.set(xlabel=None, ylabel=None)\n", + "ax.tick_params(axis='y', labelsize=16)\n", + "ax.tick_params(axis='x', labelsize=16)\n", + "sns.despine()\n", + "ax.set_title(\"Best unimodal models\", fontsize=16)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "20ba9f58-9b12-4de0-9065-2f5141e6967c", + "metadata": {}, + "source": [ + "#### **Multimodal benchmark**" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8e4ebb07-72ad-48e6-a68a-a011689b4075", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1800x720 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(25, 10))\n", + "\n", + "df_plot = results_multi.melt(id_vars = [\"metric\"])\n", + "sns.barplot(data=df_plot, x=\"metric\", y=\"value\", hue=\"variable\", ax=ax, errorbar=None)\n", + "change_width(ax, 0.07, multi=True)\n", + "errorbar(ax, results_multi)\n", + "\n", + "annotate_multimodal(ax, l1=list_best_OS, l2=list_best_PFS, dic = {\"clinicals\": \"C\", \"radiomics\": \"R\", \"pathomics\": \"P\", \"RNA\": \"RNA\"})\n", + "\n", + "ax.legend(bbox_to_anchor=(0.955, 1.005), fontsize=16)\n", + "ax.set_ylim(0.5, 0.86)\n", + "ax.set_axisbelow(True)\n", + "ax.yaxis.grid(color='gray', linestyle='dashed')\n", + "ax.set(xlabel=None, ylabel=None)\n", + "ax.tick_params(axis='y', labelsize=16)\n", + "ax.tick_params(axis='x', labelsize=16)\n", + "sns.despine()\n", + "ax.set_title(\"Best multimodal combination for different integration strategies\", fontsize=16)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "e0370cec-0bf6-4c7d-88d4-c9f0da44f4fb", + "metadata": {}, + "source": [ + "## 2. Benchmark for survival tasks" + ] + }, + { + "cell_type": "markdown", + "id": "e5fab263-83bb-46ed-8bea-2f035f5b096a", + "metadata": {}, + "source": [ + "### 2.1 Define models to benchmark" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e778d2b7-6674-4768-8541-3a08d137e2c6", + "metadata": {}, + "outputs": [], + "source": [ + "#{model_name: (path for OS results, path for PFS results)}\n", + "\n", + "models_dict = {'late_RF': (\"survival\\\\RF_perm_100cv_OS\\\\\", \"survival\\\\RF_perm_100cv_PFS\\\\\"),\n", + " 'late_Cox': (\"survival\\\\Cox_perm_100cv_OS\\\\\", \"survival\\\\Cox_perm_100cv_PFS\\\\\"),\n", + " 'early_RF': (\"survival_early\\\\RF_100CV_OS\\\\\", \"survival_early\\\\RF_100CV_PFS\\\\\"),\n", + " 'early_select_RF': (\"survival_early\\\\RF_select_bis_100cv_OS\\\\\", \"survival_early\\\\RF_select_bis_100cv_PFS\\\\\"),\n", + " 'early_Cox':(\"survival_early\\\\Cox_100CV_OS\\\\\", \"survival_early\\\\Cox_100CV_PFS\\\\\"),\n", + " 'early_select_Cox': (\"survival_early\\\\Cox_select_bis_100CV_OS\\\\\", \"survival_early\\\\Cox_select_bis_100CV_PFS\\\\\")}" + ] + }, + { + "cell_type": "markdown", + "id": "3b10a5d0-750d-4c32-aace-98a959565ad1", + "metadata": {}, + "source": [ + "### 2.2 Load data" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "eb8e9c77-f67a-4bce-9a3b-7ddba430f8ed", + "metadata": {}, + "outputs": [], + "source": [ + "df_omics = pd.read_csv(\"omics.csv\", sep=\";\", index_col=0)\n", + "patient_omics = df_omics.index\n", + "\n", + "df_clinicals = pd.read_csv(\"clinicals.csv\", index_col = 0, sep=\";\")\n", + "bool_mask_OS = df_clinicals['OS'].isnull()\n", + "bool_mask_PFS = df_clinicals['PFS'].isnull()\n", + "df_clinicals_OS = df_clinicals[~bool_mask_OS]\n", + "patient_clinicals_OS = df_clinicals_OS.index\n", + "df_clinicals_PFS = df_clinicals[~bool_mask_PFS]\n", + "patient_clinicals_PFS = df_clinicals_PFS.index\n", + "\n", + "df_radiomics = pd.read_csv(\"radiomics.csv\", index_col=0, sep=\";\")\n", + "patient_radiomics = df_radiomics.index\n", + "\n", + "patient_pathomics = pd.read_csv(\"pathomics.csv\", index_col=0, sep=\";\").index\n", + "\n", + "all_patients_OS = set(patient_radiomics) & set(patient_pathomics) & set(patient_clinicals_OS) & set(patient_omics)\n", + "all_patients_PFS = set(patient_radiomics) & set(patient_pathomics) & set(patient_clinicals_PFS) & set(patient_omics)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "dee0e7cd-1880-4b3f-90a9-b92c3b5b1c05", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Patient OS: 79\n", + "Patient PFS: 80\n" + ] + } + ], + "source": [ + "print(\"Patient OS: \", len(all_patients_OS))\n", + "print(\"Patient PFS: \", len(all_patients_PFS))" + ] + }, + { + "cell_type": "markdown", + "id": "cd12c05c-64ca-4ea5-80a4-3e4f133f14f1", + "metadata": {}, + "source": [ + "### 2.3 Save best results for each model" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "87cba174-2dfb-44a8-a001-d2dc0471af7f", + "metadata": {}, + "outputs": [], + "source": [ + "def save_results_survival(df, patients, model, list_best, list_best_name, list_clin, list_rad, list_path, list_rna):\n", + " # 1. Compute C_index\n", + " data_train = Surv.from_arrays(event=df[df[\"repeat\"] == 0][\"label.event\"].values,\n", + " time=df[df[\"repeat\"] == 0][\"label.time\"].values\n", + " )\n", + " results = compute_cindex(df.set_index(\"samples\").loc[list(set(list(patients)) & set(df[\"samples\"].unique()))],\n", + " names=list(df_OS.columns[2:-3].values),\n", + " data_train = data_train\n", + " )\n", + " results = results[results[\"metric\"] == \"c_index\"].drop(columns = \"metric\")\n", + " \n", + " # 2. Select model with the best average performance (over the repeats)\n", + " best = results.mean().idxmax()\n", + " list_best.append(results[best].rename(model))\n", + " list_best_name.append(best)\n", + " \n", + " # 3. Save the performances of the unimodal models\n", + " list_clin.append(results[\"clinicals\"])\n", + " list_rad.append(results[\"radiomics\"])\n", + " list_path.append(results[\"pathomics\"])\n", + " list_rna.append(results[\"RNA\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "0008befb-4dfb-4484-967b-90d57c3faaf1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████| 6/6 [01:07<00:00, 11.32s/it]\n" + ] + } + ], + "source": [ + "list_OS, list_PFS = [], []\n", + "list_best_OS, list_best_PFS = [], []\n", + "list_clinicals_OS, list_radiomics_OS, list_pathomics_OS, list_RNA_OS = [], [], [], []\n", + "list_clinicals_PFS, list_radiomics_PFS, list_pathomics_PFS, list_RNA_PFS = [], [], [], []\n", + "\n", + "for model, pathes in tqdm(models_dict.items(), total=len(models_dict)):\n", + " df_OS = pd.read_csv(pathes[0] + \"predictions.csv\").rename(columns = {\"Unnamed: 0\": \"samples\"})\n", + " df_PFS = pd.read_csv(pathes[1] + \"predictions.csv\").rename(columns = {\"Unnamed: 0\": \"samples\"})\n", + "\n", + " save_results_survival(df_OS, all_patients_OS, model, list_OS, list_best_OS, list_clinicals_OS, list_radiomics_OS, list_pathomics_OS, list_RNA_OS)\n", + " save_results_survival(df_PFS, all_patients_PFS, model, list_PFS, list_best_PFS, list_clinicals_PFS, list_radiomics_PFS, list_pathomics_PFS, list_RNA_PFS)\n", + " \n", + "# Concat best performances \n", + "metric_OS = pd.concat(list_OS, axis=1)\n", + "metric_OS[\"metric\"] = \"OS C-index\"\n", + "metric_PFS = pd.concat(list_PFS, axis=1)\n", + "metric_PFS[\"metric\"] = \"PFS C-index\"\n", + "\n", + "# Save best unimodal performances\n", + "best_clinicals = np.argmax([mod.mean() for mod in list_clinicals_OS])\n", + "best_radiomics = np.argmax([mod.mean() for mod in list_radiomics_OS])\n", + "best_pathomics = np.argmax([mod.mean() for mod in list_pathomics_OS])\n", + "best_RNA = np.argmax([mod.mean() for mod in list_RNA_OS])\n", + "unimodal_OS = pd.concat([list_clinicals_OS[best_clinicals], list_radiomics_OS[best_radiomics], list_pathomics_OS[best_pathomics], list_RNA_OS[best_RNA]], axis=1)\n", + "unimodal_OS[\"metric\"] = \"OS C-index\"\n", + "\n", + "best_clinicals_PFS = np.argmax([mod.mean() for mod in list_clinicals_PFS])\n", + "best_radiomics_PFS = np.argmax([mod.mean() for mod in list_radiomics_PFS])\n", + "best_pathomics_PFS = np.argmax([mod.mean() for mod in list_pathomics_PFS])\n", + "best_RNA_PFS = np.argmax([mod.mean() for mod in list_RNA_PFS])\n", + "unimodal_PFS = pd.concat([list_clinicals_PFS[best_clinicals_PFS], list_radiomics_PFS[best_radiomics_PFS], list_pathomics_PFS[best_pathomics_PFS], list_RNA_PFS[best_RNA_PFS]], axis=1)\n", + "unimodal_PFS[\"metric\"] = \"PFS C-index\"" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b68d35f0-12f7-438a-a78e-c795729f7c51", + "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>late_RF</th>\n", + " <th>late_Cox</th>\n", + " <th>early_RF</th>\n", + " <th>early_select_RF</th>\n", + " <th>early_Cox</th>\n", + " <th>early_select_Cox</th>\n", + " <th>metric</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>0.749478</td>\n", + " <td>0.624095</td>\n", + " <td>0.741186</td>\n", + " <td>0.691367</td>\n", + " <td>0.613522</td>\n", + " <td>0.707324</td>\n", + " <td>OS C-index</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>0.762107</td>\n", + " <td>0.668953</td>\n", + " <td>0.706343</td>\n", + " <td>0.745034</td>\n", + " <td>0.698746</td>\n", + " <td>0.694353</td>\n", + " <td>OS C-index</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>0.760881</td>\n", + " <td>0.645266</td>\n", + " <td>0.702678</td>\n", + " <td>0.715890</td>\n", + " <td>0.619757</td>\n", + " <td>0.705873</td>\n", + " <td>OS C-index</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>0.731493</td>\n", + " <td>0.664652</td>\n", + " <td>0.715622</td>\n", + " <td>0.748301</td>\n", + " <td>0.632621</td>\n", + " <td>0.720428</td>\n", + " <td>OS C-index</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>0.738403</td>\n", + " <td>0.632853</td>\n", + " <td>0.750647</td>\n", + " <td>0.729391</td>\n", + " <td>0.646983</td>\n", + " <td>0.694566</td>\n", + " <td>OS C-index</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " late_RF late_Cox early_RF early_select_RF early_Cox early_select_Cox \\\n", + "0 0.749478 0.624095 0.741186 0.691367 0.613522 0.707324 \n", + "1 0.762107 0.668953 0.706343 0.745034 0.698746 0.694353 \n", + "2 0.760881 0.645266 0.702678 0.715890 0.619757 0.705873 \n", + "3 0.731493 0.664652 0.715622 0.748301 0.632621 0.720428 \n", + "4 0.738403 0.632853 0.750647 0.729391 0.646983 0.694566 \n", + "\n", + " metric \n", + "0 OS C-index \n", + "1 OS C-index \n", + "2 OS C-index \n", + "3 OS C-index \n", + "4 OS C-index " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_multi = pd.concat([metric_OS, metric_PFS], axis=0)\n", + "results_multi.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "36fecf6f-480a-4765-ab5a-bf9df6466fa7", + "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>clinicals</th>\n", + " <th>radiomics</th>\n", + " <th>pathomics</th>\n", + " <th>RNA</th>\n", + " <th>metric</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>0.659810</td>\n", + " <td>0.574972</td>\n", + " <td>0.607118</td>\n", + " <td>0.693620</td>\n", + " <td>OS C-index</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>0.695589</td>\n", + " <td>0.632664</td>\n", + " <td>0.597955</td>\n", + " <td>0.691800</td>\n", + " <td>OS C-index</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>0.690391</td>\n", + " <td>0.609958</td>\n", + " <td>0.589263</td>\n", + " <td>0.696218</td>\n", + " <td>OS C-index</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>0.668751</td>\n", + " <td>0.604428</td>\n", + " <td>0.627711</td>\n", + " <td>0.671152</td>\n", + " <td>OS C-index</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>0.671193</td>\n", + " <td>0.579824</td>\n", + " <td>0.603053</td>\n", + " <td>0.697055</td>\n", + " <td>OS C-index</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " clinicals radiomics pathomics RNA metric\n", + "0 0.659810 0.574972 0.607118 0.693620 OS C-index\n", + "1 0.695589 0.632664 0.597955 0.691800 OS C-index\n", + "2 0.690391 0.609958 0.589263 0.696218 OS C-index\n", + "3 0.668751 0.604428 0.627711 0.671152 OS C-index\n", + "4 0.671193 0.579824 0.603053 0.697055 OS C-index" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_unimodal = pd.concat([unimodal_OS, unimodal_PFS], axis=0)\n", + "results_unimodal.head()" + ] + }, + { + "cell_type": "markdown", + "id": "60d5c8eb-d1ff-4c00-af90-e2ceeaac1f3d", + "metadata": {}, + "source": [ + "### 2.4 Plot benchmark" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "a3d17cf2-0e54-4974-88c3-ed076b1f79ad", + "metadata": {}, + "outputs": [], + "source": [ + "def change_width(ax, new_value, multi=False) :\n", + " \"\"\"\n", + " Change bar width\n", + " \"\"\"\n", + " for i, patch in enumerate(ax.patches):\n", + " current_width = patch.get_width()\n", + " diff = current_width - new_value\n", + " # we change the bar width\n", + " patch.set_width(new_value)\n", + " # we recenter the bar\n", + " patch.set_x(patch.get_x() + diff * .5)\n", + " \n", + " # move groups of bars for multimodal benchmark\n", + " if multi:\n", + " if i in [0, 1, 2, 3]:\n", + " patch.set_x(patch.get_x() + diff * .5 - 0.03)\n", + " \n", + "def annotate_unimodal(ax, l1, l2):\n", + " \"\"\"\n", + " Add text annotation on each bar for unimodal benchmark\n", + " \"\"\"\n", + " for i, patch in enumerate(ax.patches[:len(l1) + len(l2)]):\n", + " if i%2 == 0:\n", + " model = l1[i//2]\n", + " else:\n", + " model = l2[i//2]\n", + " height = patch.get_height()\n", + " x_bar = patch.get_x() + 0.5*patch.get_width()\n", + " ax.text(x_bar, height - (height - 0.5)/2 , model, weight='bold', va='center', ha='center', fontsize=18, color=\"white\")\n", + "\n", + "def annotate_multimodal(ax, l1, l2, dic):\n", + " \"\"\"\n", + " Add text annotation on each bar for multimodal benchmark\n", + " \"\"\"\n", + " for i, patch in enumerate(ax.patches[:len(l1)+len(l2)]):\n", + " if i%2 == 0:\n", + " modas = [dic[n] for n in l1[i//2].split('+')]\n", + " else:\n", + " modas = [dic[n] for n in l2[i//2].split('+')]\n", + " n_modas = len(modas)\n", + " height = patch.get_height()\n", + " x_bar = patch.get_x() + 0.5*patch.get_width()\n", + " for j, mod in enumerate(modas):\n", + " ax.text(x_bar, height - (height - 0.5)/2 + (0.5*(n_modas-1) - j)*0.02, mod, weight='bold', va='center', ha='center', fontsize=18, color=\"white\")\n", + " \n", + "def errorbar(ax, results):\n", + " \"\"\"\n", + " Add error bar on each bar\n", + " \"\"\"\n", + " for i, patch in enumerate(ax.patches[:2*(len(results.columns) - 1)]):\n", + " columns = list(results.columns[:-1].values)\n", + " x_bar = patch.get_x() + 0.5*patch.get_width()\n", + " if i%2 == 0:\n", + " m = \"OS C-index\"\n", + " else:\n", + " m = \"PFS C-index\"\n", + " \n", + " ax.errorbar(x=[patch.get_x() + 0.5*patch.get_width()],\n", + " y=results[results[\"metric\"] == m][columns[i//2]].mean(),\n", + " yerr=results[results[\"metric\"] == m][columns[i//2]].std(),\n", + " fmt='none',\n", + " ecolor='k',\n", + " capsize=10,\n", + " elinewidth=1.2)" + ] + }, + { + "cell_type": "markdown", + "id": "7b8bbec5-bb7a-4d59-bd41-a11c657919bc", + "metadata": {}, + "source": [ + "#### **Unimodal benchmark**" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "88902107-9a65-4f01-a9b2-cfc839b38a29", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1800x720 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(25, 10))\n", + "\n", + "df_plot = results_unimodal.melt(id_vars = [\"metric\"])\n", + "sns.barplot(data=df_plot, x=\"metric\", y=\"value\", hue=\"variable\", ax=ax, errorbar=None)\n", + "change_width(ax, 0.15)\n", + "errorbar(ax, results_unimodal)\n", + "\n", + "models = [\"RF\", \"Cox\", \"RF\", \"Cox\", \"Cox\"] #[\"RF\", \"Cox\", \"RF\", \"RF\", \"Cox\", \"Cox\"]\n", + "annotate_unimodal(ax, l1= [models[best_clinicals], models[best_radiomics], models[best_pathomics], models[best_RNA]],\n", + " l2=[models[best_clinicals_PFS], models[best_radiomics_PFS], models[best_pathomics_PFS], models[best_RNA_PFS]])\n", + "\n", + "ax.legend(bbox_to_anchor=(0.955, 1.005), fontsize=16)\n", + "ax.set_ylim(0.5, 0.78)\n", + "ax.set_axisbelow(True)\n", + "ax.yaxis.grid(color='gray', linestyle='dashed')\n", + "ax.set(xlabel=None, ylabel=None)\n", + "ax.tick_params(axis='y', labelsize=16)\n", + "ax.tick_params(axis='x', labelsize=16)\n", + "sns.despine()\n", + "ax.set_title(\"Best combinations accross the multimodal strategies\", fontsize=16)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "69db0f2a-fc53-4144-89df-11cc2291e41e", + "metadata": {}, + "source": [ + "#### **Multimodal benchmark**" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "19b65984-972f-402a-96e7-4911b010cac1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1800x720 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(25, 10))\n", + "\n", + "df_plot = results_multi.melt(id_vars = [\"metric\"])\n", + "sns.barplot(data=df_plot, x=\"metric\", y=\"value\", hue=\"variable\", ax=ax, errorbar=None)\n", + "change_width(ax, 0.12, multi=True)\n", + "errorbar(ax, results_multi)\n", + "\n", + "annotate_multimodal(ax, l1=list_best_OS, l2=list_best_PFS, dic = {\"clinicals\": \"C\", \"radiomics\": \"R\", \"pathomics\": \"P\", \"RNA\": \"RNA\"})\n", + "\n", + "ax.legend(bbox_to_anchor=(0.955, 1.005), fontsize=16)\n", + "ax.set_ylim(0.5, 0.78)\n", + "ax.set_axisbelow(True)\n", + "ax.yaxis.grid(color='gray', linestyle='dashed')\n", + "ax.set(xlabel=None, ylabel=None)\n", + "ax.tick_params(axis='y', labelsize=16)\n", + "ax.tick_params(axis='x', labelsize=16)\n", + "sns.despine()\n", + "ax.set_title(\"Best combinations accross the multimodal strategies\", fontsize=16)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "31b6b7df-204e-484e-aa5d-a0af2e6c379b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:latefus_env]", + "language": "python", + "name": "conda-env-latefus_env-py" + }, + "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.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}