Repository: greenelab/mpmp

Issue:
Combining data modalities
See https://github.com/greenelab/mpmp/pull/2#discussion_r541016738

Discussion:

Patch:
diff --git a/02_classify_mutations/run_mutation_classification.py b/02_classify_mutations/run_mutation_classification.py
index c2883c7..999da6b 100644
--- a/02_classify_mutations/run_mutation_classification.py
+++ b/02_classify_mutations/run_mutation_classification.py
@@ -121,7 +121,7 @@ if __name__ == '__main__':
 
     # create empty log file if it doesn't exist
     log_columns = [
-        'cancer_type',
+        'gene',
         'training_data',
         'shuffle_labels',
         'skip_reason'
@@ -154,7 +154,7 @@ if __name__ == '__main__':
                         file=sys.stdout)
 
         for gene_idx, gene_series in progress:
-            cancer_type_log_df = None
+            log_df = None
             gene = gene_series.gene
             classification = gene_series.classification
             progress.set_description('gene: {}'.format(gene))
@@ -175,22 +175,22 @@ if __name__ == '__main__':
                 if io_args.verbose:
                     print('Skipping because results file exists already: gene {}'.format(
                         gene), file=sys.stderr)
-                cancer_type_log_df = fu.generate_log_df(
+                log_df = fu.generate_log_df(
                     log_columns,
                     [gene, model_options.training_data, shuffle_labels, 'file_exists']
                 )
-                fu.write_log_file(cancer_type_log_df, io_args.log_file)
+                fu.write_log_file(log_df, io_args.log_file)
                 continue
             except KeyError:
                 # this might happen if the given gene isn't in the mutation data
                 # (or has a different alias, TODO we could check for this later)
                 print('Gene {} not found in mutation data, skipping'.format(gene),
                       file=sys.stderr)
-                cancer_type_log_df = fu.generate_log_df(
+                log_df = fu.generate_log_df(
                     log_columns,
                     [gene, model_options.training_data, shuffle_labels, 'gene_not_found']
                 )
-                fu.write_log_file(cancer_type_log_df, io_args.log_file)
+                fu.write_log_file(log_df, io_args.log_file)
                 continue
 
             try:
@@ -218,7 +218,7 @@ if __name__ == '__main__':
                 if io_args.verbose:
                     print('Skipping due to no train samples: gene {}'.format(
                         gene), file=sys.stderr)
-                cancer_type_log_df = fu.generate_log_df(
+                log_df = fu.generate_log_df(
                     log_columns,
                     [gene, model_options.training_data, shuffle_labels, 'no_train_samples']
                 )
@@ -226,11 +226,11 @@ if __name__ == '__main__':
                 if io_args.verbose:
                     print('Skipping due to one holdout class: gene {}'.format(
                         gene), file=sys.stderr)
-                cancer_type_log_df = fu.generate_log_df(
+                log_df = fu.generate_log_df(
                     log_columns,
                     [gene, model_options.training_data, shuffle_labels, 'one_class']
                 )
 
-            if cancer_type_log_df is not None:
-                fu.write_log_file(cancer_type_log_df, io_args.log_file)
+            if log_df is not None:
+                fu.write_log_file(log_df, io_args.log_file)
 
diff --git a/05_classify_mutations_multimodal/nbconverted/plot_multimodal_results.py b/05_classify_mutations_multimodal/nbconverted/plot_multimodal_results.py
new file mode 100644
index 0000000..13dcd21
--- /dev/null
+++ b/05_classify_mutations_multimodal/nbconverted/plot_multimodal_results.py
@@ -0,0 +1,303 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# ## Plot results of multi-omics classification experiments
+# 
+# In these experiments, we compare elastic net logistic regression models using multiple data types to models using only a single data type. We're not doing anything particularly fancy here, just concatenating the feature sets (genes or CpG probes) from the individual data types to create a "multi-omics" model.
+# 
+# For now, we're just doing this for gene expression and the two methylation datasets.
+
+# In[1]:
+
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+import seaborn as sns
+from scipy.stats import ttest_ind
+from adjustText import adjust_text
+
+import mpmp.config as cfg
+import mpmp.utilities.analysis_utilities as au
+
+
+# In[2]:
+
+
+# set results directory
+results_dir = Path(
+    cfg.results_dirs['multimodal'],
+    # 'pilot_results',
+    'pilot_results_all_feats',
+    'gene'
+).resolve()
+
+
+# ### Compare raw results (signal and shuffled)
+
+# In[3]:
+
+
+# load raw data
+results_df = au.load_stratified_prediction_results(results_dir, 'gene')
+
+# make sure that we have data for all data types and for two replicates (random seeds)
+print(results_df.shape)
+print(results_df.seed.unique())
+print(results_df.identifier.unique())
+print(results_df.training_data.unique())
+results_df.head()
+
+
+# In[4]:
+
+
+# each subplot will show results for one gene
+sns.set({'figure.figsize': (24, 12)})
+fig, axarr = plt.subplots(2, 4)
+results_df.sort_values(by=['identifier', 'signal', 'training_data'], inplace=True)
+max_aupr = results_df.aupr.max()
+
+data_order =['expression.me_27k',
+             'expression.me_450k',
+             'me_27k.me_450k',
+             'expression.me_27k.me_450k']
+
+# plot mean performance over all genes in Vogelstein dataset
+for ix, gene in enumerate(results_df.identifier.unique()):
+    
+    ax = axarr[ix // 4, ix % 4]
+    
+    plot_df = results_df[(results_df.identifier == gene) &
+                         (results_df.data_type == 'test')]
+
+    sns.boxplot(data=plot_df, x='signal', y='aupr', hue='training_data',
+                hue_order=data_order, ax=ax)
+    ax.set_title('Prediction for {} mutation'.format(gene))
+    ax.set_xlabel('')
+    ax.set_ylabel('AUPR')
+    ax.set_ylim(-0.1, max_aupr)
+    ax.legend_.remove()
+    
+handles = []
+for ix, data in enumerate(data_order):
+    handle = mpatches.Patch(color=sns.color_palette()[ix], label=data)
+    handles.append(handle)
+    
+fig.delaxes(axarr[1, 3])
+plt.legend(handles=handles, loc='lower right')
+
+
+# ### Compare single-omics and multi-omics results
+
+# In[5]:
+
+
+# get results from unimodal prediction (individual data types) to compare with
+# these are spread across 3 different results directories
+# this is such a mess, I really need to clean up the results directories eventually
+
+# expression, seed 1
+unimodal_results_dir_1 = Path(
+    cfg.results_dirs['mutation'],
+    'bmiq_results',
+    'gene'
+)
+
+# expression, seed 2
+unimodal_results_dir_2 = Path(
+    cfg.results_dirs['mutation'],
+    'bmiq_results_2',
+    'gene'
+)
+
+# me_27k, both seeds
+unimodal_results_dir_3 = Path(
+    cfg.results_dirs['mutation'],
+    'bmiq_results_me_control',
+    'gene'
+)
+
+# me_450k, both seeds
+# use compressed data for this
+unimodal_results_dir_4 = Path(
+    cfg.results_dirs['mutation'],
+    'compressed_results',
+    'gene'
+)
+
+
+# In[6]:
+
+
+# load expression and me_27k results
+u_results_df_1 = au.load_stratified_prediction_results(unimodal_results_dir_1, 'gene')
+u_results_df_1 = u_results_df_1[(u_results_df_1.training_data == 'expression') &
+                                (u_results_df_1.seed == 1)].copy()
+u_results_df_2 = au.load_stratified_prediction_results(unimodal_results_dir_2, 'gene')
+u_results_df_2 = u_results_df_2[u_results_df_2.training_data == 'expression'].copy()
+u_results_df_3 = au.load_stratified_prediction_results(unimodal_results_dir_3, 'gene')
+
+# load me_450k results
+u_results_df_4 = au.load_compressed_prediction_results(unimodal_results_dir_4, 'gene',
+                                                       old_filenames=True)
+u_results_df_4 = u_results_df_4[(u_results_df_4.training_data == 'me_450k') &
+                                (u_results_df_4.n_dims == 5000)].copy()
+u_results_df_4.drop(columns='n_dims', inplace=True)
+
+# make sure data loaded matches our expectations
+print(u_results_df_1.training_data.unique())
+print(u_results_df_2.training_data.unique())
+print(u_results_df_3.training_data.unique())
+print(u_results_df_4.training_data.unique())
+print(u_results_df_1.seed.unique())
+print(u_results_df_2.seed.unique())
+print(u_results_df_3.seed.unique())
+print(u_results_df_4.seed.unique())
+
+
+# In[7]:
+
+
+# first, take the unimodal results and the multimodal results,
+# and concatenate them into one giant results df
+all_results_df = pd.concat((results_df,
+                            u_results_df_1,
+                            u_results_df_2,
+                            u_results_df_3,
+                            u_results_df_4))
+
+print(all_results_df.shape)
+print(all_results_df.training_data.unique())
+all_results_df.head()
+
+
+# In[8]:
+
+
+# then, for each training data type, get the AUPR difference between signal and shuffled
+compare_df = pd.DataFrame()
+for training_data in all_results_df.training_data.unique():
+    data_compare_df = au.compare_control_ind(
+        all_results_df[all_results_df.training_data == training_data],
+        identifier='identifier',
+        metric='aupr',
+        verbose=True
+    )
+    data_compare_df['training_data'] = training_data
+    data_compare_df.rename(columns={'identifier': 'gene'}, inplace=True)
+    compare_df = pd.concat((compare_df, data_compare_df))
+    
+compare_df.head(10)
+
+
+# In[9]:
+
+
+# each subplot will show results for one gene
+sns.set({'figure.figsize': (24, 12)})
+fig, axarr = plt.subplots(2, 4)
+compare_df.sort_values(by=['gene', 'training_data'], inplace=True)
+compare_map = {v: str(i) for i, v in enumerate(compare_df.training_data.unique())}
+compare_df['train_index'] = compare_df.training_data.map(compare_map)
+min_aupr = compare_df.delta_aupr.min()
+max_aupr = compare_df.delta_aupr.max()
+
+
+data_order =['expression',
+             'me_27k',
+             'me_450k',
+             'expression.me_27k',
+             'expression.me_450k',
+             'me_27k.me_450k',
+             'expression.me_27k.me_450k']
+
+# plot mean performance over all genes in pilot experiment
+for ix, gene in enumerate(results_df.identifier.unique()):
+    
+    ax = axarr[ix // 4, ix % 4]
+    
+    plot_df = compare_df[(compare_df.gene == gene)]
+
+    sns.boxplot(data=plot_df, x='training_data', y='delta_aupr',
+                order=data_order, ax=ax)
+    ax.set_title('Prediction for {} mutation'.format(gene))
+    ax.set_xlabel('Training data type')
+    # hide x-axis tick text
+    ax.get_xaxis().set_ticklabels([])
+    ax.set_ylabel('AUPR(signal) - AUPR(shuffled)')
+    ax.set_ylim(-0.2, max_aupr)
+    
+handles = []
+for ix, data in enumerate(data_order):
+    handle = mpatches.Patch(color=sns.color_palette()[ix], label=data)
+    handles.append(handle)
+    
+fig.delaxes(axarr[1, 3])
+plt.legend(handles=handles, loc='lower right')
+
+
+# ### Compare best-performing single-omics and multi-omics data types
+
+# In[10]:
+
+
+# for each data type, classify it as single-omics or multi-omics
+compare_df['model_type'] = 'single-omics'
+# multi-omics data types are concatenated using dots
+compare_df.loc[compare_df.training_data.str.contains('\.'), 'model_type'] = 'multi-omics'
+print(compare_df.training_data.unique())
+compare_df[compare_df.gene == 'TP53'].head(10)
+
+
+# In[11]:
+
+
+sns.set({'figure.figsize': (10, 6)})
+
+plot_df = pd.DataFrame()
+
+# plot mean performance over all genes in pilot experiment
+for ix, gene in enumerate(results_df.identifier.unique()):
+    
+    plot_gene_df = compare_df[(compare_df.gene == gene)].reset_index(drop=True)
+    
+    # get the best-performing data types from the single-omics and multi-omics models
+    max_single_data_type = (
+        plot_gene_df[plot_gene_df.model_type == 'single-omics']
+          .groupby('training_data')
+          .agg('mean')
+          .delta_aupr.idxmax()
+    )
+    max_multi_data_type = (
+        plot_gene_df[plot_gene_df.model_type == 'multi-omics']
+          .groupby('training_data')
+          .agg('mean')
+          .delta_aupr.idxmax()
+    )
+    
+    # get samples with that data type
+    max_single_df = plot_gene_df[plot_gene_df.training_data == max_single_data_type]
+    max_multi_df = plot_gene_df[plot_gene_df.training_data == max_multi_data_type]
+    
+    # calculate difference between means and t-test p-val for that data type
+    mean_diff = max_single_df.delta_aupr.mean() - max_multi_df.delta_aupr.mean()
+    _, p_val = ttest_ind(max_single_df.delta_aupr.values,
+                         max_multi_df.delta_aupr.values)
+    print('{} diff: {:.4f} (pval: {:.4f})'.format(gene, mean_diff, p_val))
+    
+    plot_df = pd.concat((plot_df, max_single_df, max_multi_df))
+
+sns.boxplot(data=plot_df, x='gene', y='delta_aupr', hue='model_type')
+plt.title('Best performing single-omics vs. multi-omics data type, per gene')
+plt.xlabel('Target gene')
+plt.ylabel('AUPR(signal) - AUPR(shuffled)')
+
+
+# Summary and interpretation:
+# 
+# * In this last figure, we can see that the difference in distributions between the best-performing single-omics and multi-omics model is visually quite small for all of the target genes, and none of the differences are statistically significant using a t-test over the 8 total CV folds.
+# * Looking at the other two figures, when we consider all data types the difference between single-omics and multi-omics models is still pretty minimal in general. There are some genes where adding expression data helps a lot (EGFR, PIK3CA, KRAS) and others where it doesn't really (IDH1, SETD2), but in general there's not a lot of added predictive ability when expression is combined with other data types, suggesting that methylation may be most useful in that it correlates with expression patterns (although more follow-up would be needed to really confirm this).
diff --git a/05_classify_mutations_multimodal/plot_multimodal_results.ipynb b/05_classify_mutations_multimodal/plot_multimodal_results.ipynb
new file mode 100644
index 0000000..ed72e28
--- /dev/null
+++ b/05_classify_mutations_multimodal/plot_multimodal_results.ipynb
@@ -0,0 +1,1054 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plot results of multi-omics classification experiments\n",
+    "\n",
+    "In these experiments, we compare elastic net logistic regression models using multiple data types to models using only a single data type. We're not doing anything particularly fancy here, just concatenating the feature sets (genes or CpG probes) from the individual data types to create a \"multi-omics\" model.\n",
+    "\n",
+    "For now, we're just doing this for gene expression and the two methylation datasets."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.patches as mpatches\n",
+    "import seaborn as sns\n",
+    "from scipy.stats import ttest_ind\n",
+    "from adjustText import adjust_text\n",
+    "\n",
+    "import mpmp.config as cfg\n",
+    "import mpmp.utilities.analysis_utilities as au"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# set results directory\n",
+    "results_dir = Path(\n",
+    "    cfg.results_dirs['multimodal'],\n",
+    "    # 'pilot_results',\n",
+    "    'pilot_results_all_feats',\n",
+    "    'gene'\n",
+    ").resolve()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Compare raw results (signal and shuffled)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1344, 9)\n",
+      "[ 1 42]\n",
+      "['TP53' 'TET2' 'EGFR' 'IDH1' 'PIK3CA' 'SETD2' 'KRAS']\n",
+      "['expression.me_450k' 'expression.me_27k.me_450k' 'expression.me_27k'\n",
+      " 'me_27k.me_450k']\n"
+     ]
+    },
+    {
+     "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>auroc</th>\n",
+       "      <th>aupr</th>\n",
+       "      <th>identifier</th>\n",
+       "      <th>training_data</th>\n",
+       "      <th>signal</th>\n",
+       "      <th>seed</th>\n",
+       "      <th>data_type</th>\n",
+       "      <th>fold</th>\n",
+       "      <th>experiment</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.58776</td>\n",
+       "      <td>0.53598</td>\n",
+       "      <td>TP53</td>\n",
+       "      <td>expression.me_450k</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>1</td>\n",
+       "      <td>train</td>\n",
+       "      <td>0</td>\n",
+       "      <td>gene</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.51092</td>\n",
+       "      <td>0.45544</td>\n",
+       "      <td>TP53</td>\n",
+       "      <td>expression.me_450k</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>1</td>\n",
+       "      <td>test</td>\n",
+       "      <td>0</td>\n",
+       "      <td>gene</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0.50821</td>\n",
+       "      <td>0.47307</td>\n",
+       "      <td>TP53</td>\n",
+       "      <td>expression.me_450k</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>1</td>\n",
+       "      <td>cv</td>\n",
+       "      <td>0</td>\n",
+       "      <td>gene</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.52199</td>\n",
+       "      <td>0.48146</td>\n",
+       "      <td>TP53</td>\n",
+       "      <td>expression.me_450k</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>1</td>\n",
+       "      <td>train</td>\n",
+       "      <td>1</td>\n",
+       "      <td>gene</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.51623</td>\n",
+       "      <td>0.48159</td>\n",
+       "      <td>TP53</td>\n",
+       "      <td>expression.me_450k</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>1</td>\n",
+       "      <td>test</td>\n",
+       "      <td>1</td>\n",
+       "      <td>gene</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     auroc     aupr identifier       training_data    signal  seed data_type  \\\n",
+       "0  0.58776  0.53598       TP53  expression.me_450k  shuffled     1     train   \n",
+       "1  0.51092  0.45544       TP53  expression.me_450k  shuffled     1      test   \n",
+       "2  0.50821  0.47307       TP53  expression.me_450k  shuffled     1        cv   \n",
+       "3  0.52199  0.48146       TP53  expression.me_450k  shuffled     1     train   \n",
+       "4  0.51623  0.48159       TP53  expression.me_450k  shuffled     1      test   \n",
+       "\n",
+       "   fold experiment  \n",
+       "0     0       gene  \n",
+       "1     0       gene  \n",
+       "2     0       gene  \n",
+       "3     1       gene  \n",
+       "4     1       gene  "
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# load raw data\n",
+    "results_df = au.load_stratified_prediction_results(results_dir, 'gene')\n",
+    "\n",
+    "# make sure that we have data for all data types and for two replicates (random seeds)\n",
+    "print(results_df.shape)\n",
+    "print(results_df.seed.unique())\n",
+    "print(results_df.identifier.unique())\n",
+    "print(results_df.training_data.unique())\n",
+    "results_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7ff00682afd0>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1728x864 with 7 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# each subplot will show results for one gene\n",
+    "sns.set({'figure.figsize': (24, 12)})\n",
+    "fig, axarr = plt.subplots(2, 4)\n",
+    "results_df.sort_values(by=['identifier', 'signal', 'training_data'], inplace=True)\n",
+    "max_aupr = results_df.aupr.max()\n",
+    "\n",
+    "data_order =['expression.me_27k',\n",
+    "             'expression.me_450k',\n",
+    "             'me_27k.me_450k',\n",
+    "             'expression.me_27k.me_450k']\n",
+    "\n",
+    "# plot mean performance over all genes in Vogelstein dataset\n",
+    "for ix, gene in enumerate(results_df.identifier.unique()):\n",
+    "    \n",
+    "    ax = axarr[ix // 4, ix % 4]\n",
+    "    \n",
+    "    plot_df = results_df[(results_df.identifier == gene) &\n",
+    "                         (results_df.data_type == 'test')]\n",
+    "\n",
+    "    sns.boxplot(data=plot_df, x='signal', y='aupr', hue='training_data',\n",
+    "                hue_order=data_order, ax=ax)\n",
+    "    ax.set_title('Prediction for {} mutation'.format(gene))\n",
+    "    ax.set_xlabel('')\n",
+    "    ax.set_ylabel('AUPR')\n",
+    "    ax.set_ylim(-0.1, max_aupr)\n",
+    "    ax.legend_.remove()\n",
+    "    \n",
+    "handles = []\n",
+    "for ix, data in enumerate(data_order):\n",
+    "    handle = mpatches.Patch(color=sns.color_palette()[ix], label=data)\n",
+    "    handles.append(handle)\n",
+    "    \n",
+    "fig.delaxes(axarr[1, 3])\n",
+    "plt.legend(handles=handles, loc='lower right')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Compare single-omics and multi-omics results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# get results from unimodal prediction (individual data types) to compare with\n",
+    "# these are spread across 3 different results directories\n",
+    "# this is such a mess, I really need to clean up the results directories eventually\n",
+    "\n",
+    "# expression, seed 1\n",
+    "unimodal_results_dir_1 = Path(\n",
+    "    cfg.results_dirs['mutation'],\n",
+    "    'bmiq_results',\n",
+    "    'gene'\n",
+    ")\n",
+    "\n",
+    "# expression, seed 2\n",
+    "unimodal_results_dir_2 = Path(\n",
+    "    cfg.results_dirs['mutation'],\n",
+    "    'bmiq_results_2',\n",
+    "    'gene'\n",
+    ")\n",
+    "\n",
+    "# me_27k, both seeds\n",
+    "unimodal_results_dir_3 = Path(\n",
+    "    cfg.results_dirs['mutation'],\n",
+    "    'bmiq_results_me_control',\n",
+    "    'gene'\n",
+    ")\n",
+    "\n",
+    "# me_450k, both seeds\n",
+    "# use compressed data for this\n",
+    "unimodal_results_dir_4 = Path(\n",
+    "    cfg.results_dirs['mutation'],\n",
+    "    'compressed_results',\n",
+    "    'gene'\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['expression']\n",
+      "['expression']\n",
+      "['me_27k']\n",
+      "['me_450k']\n",
+      "[1]\n",
+      "[42]\n",
+      "[ 1 42]\n",
+      "[42  1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# load expression and me_27k results\n",
+    "u_results_df_1 = au.load_stratified_prediction_results(unimodal_results_dir_1, 'gene')\n",
+    "u_results_df_1 = u_results_df_1[(u_results_df_1.training_data == 'expression') &\n",
+    "                                (u_results_df_1.seed == 1)].copy()\n",
+    "u_results_df_2 = au.load_stratified_prediction_results(unimodal_results_dir_2, 'gene')\n",
+    "u_results_df_2 = u_results_df_2[u_results_df_2.training_data == 'expression'].copy()\n",
+    "u_results_df_3 = au.load_stratified_prediction_results(unimodal_results_dir_3, 'gene')\n",
+    "\n",
+    "# load me_450k results\n",
+    "u_results_df_4 = au.load_compressed_prediction_results(unimodal_results_dir_4, 'gene',\n",
+    "                                                       old_filenames=True)\n",
+    "u_results_df_4 = u_results_df_4[(u_results_df_4.training_data == 'me_450k') &\n",
+    "                                (u_results_df_4.n_dims == 5000)].copy()\n",
+    "u_results_df_4.drop(columns='n_dims', inplace=True)\n",
+    "\n",
+    "# make sure data loaded matches our expectations\n",
+    "print(u_results_df_1.training_data.unique())\n",
+    "print(u_results_df_2.training_data.unique())\n",
+    "print(u_results_df_3.training_data.unique())\n",
+    "print(u_results_df_4.training_data.unique())\n",
+    "print(u_results_df_1.seed.unique())\n",
+    "print(u_results_df_2.seed.unique())\n",
+    "print(u_results_df_3.seed.unique())\n",
+    "print(u_results_df_4.seed.unique())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(15240, 9)\n",
+      "['expression.me_27k' 'expression.me_27k.me_450k' 'expression.me_450k'\n",
+      " 'me_27k.me_450k' 'expression' 'me_27k' 'me_450k']\n"
+     ]
+    },
+    {
+     "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>auroc</th>\n",
+       "      <th>aupr</th>\n",
+       "      <th>identifier</th>\n",
+       "      <th>training_data</th>\n",
+       "      <th>signal</th>\n",
+       "      <th>seed</th>\n",
+       "      <th>data_type</th>\n",
+       "      <th>fold</th>\n",
+       "      <th>experiment</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.50000</td>\n",
+       "      <td>0.104120</td>\n",
+       "      <td>EGFR</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>42</td>\n",
+       "      <td>train</td>\n",
+       "      <td>0</td>\n",
+       "      <td>gene</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.50000</td>\n",
+       "      <td>0.098765</td>\n",
+       "      <td>EGFR</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>42</td>\n",
+       "      <td>test</td>\n",
+       "      <td>0</td>\n",
+       "      <td>gene</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0.50531</td>\n",
+       "      <td>0.104980</td>\n",
+       "      <td>EGFR</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>42</td>\n",
+       "      <td>cv</td>\n",
+       "      <td>0</td>\n",
+       "      <td>gene</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.56624</td>\n",
+       "      <td>0.147600</td>\n",
+       "      <td>EGFR</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>42</td>\n",
+       "      <td>train</td>\n",
+       "      <td>1</td>\n",
+       "      <td>gene</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.50897</td>\n",
+       "      <td>0.123030</td>\n",
+       "      <td>EGFR</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>42</td>\n",
+       "      <td>test</td>\n",
+       "      <td>1</td>\n",
+       "      <td>gene</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     auroc      aupr identifier      training_data    signal  seed data_type  \\\n",
+       "0  0.50000  0.104120       EGFR  expression.me_27k  shuffled    42     train   \n",
+       "1  0.50000  0.098765       EGFR  expression.me_27k  shuffled    42      test   \n",
+       "2  0.50531  0.104980       EGFR  expression.me_27k  shuffled    42        cv   \n",
+       "3  0.56624  0.147600       EGFR  expression.me_27k  shuffled    42     train   \n",
+       "4  0.50897  0.123030       EGFR  expression.me_27k  shuffled    42      test   \n",
+       "\n",
+       "   fold experiment  \n",
+       "0     0       gene  \n",
+       "1     0       gene  \n",
+       "2     0       gene  \n",
+       "3     1       gene  \n",
+       "4     1       gene  "
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# first, take the unimodal results and the multimodal results,\n",
+    "# and concatenate them into one giant results df\n",
+    "all_results_df = pd.concat((results_df,\n",
+    "                            u_results_df_1,\n",
+    "                            u_results_df_2,\n",
+    "                            u_results_df_3,\n",
+    "                            u_results_df_4))\n",
+    "\n",
+    "print(all_results_df.shape)\n",
+    "print(all_results_df.training_data.unique())\n",
+    "all_results_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "shapes unequal for ACVR1B, skipping\n",
+      "shapes unequal for HNF1A, skipping\n",
+      "shapes unequal for MPL, skipping\n",
+      "shapes unequal for MSH6, skipping\n",
+      "shapes unequal for PAX5, skipping\n",
+      "shapes unequal for SMO, skipping\n",
+      "shapes unequal for TSHR, skipping\n",
+      "shapes unequal for ACVR1B, skipping\n",
+      "shapes unequal for CBL, skipping\n",
+      "shapes unequal for CDC73, skipping\n",
+      "shapes unequal for CYLD, skipping\n",
+      "shapes unequal for HIST1H3B, skipping\n",
+      "shapes unequal for HNF1A, skipping\n",
+      "shapes unequal for MLH1, skipping\n",
+      "shapes unequal for MPL, skipping\n",
+      "shapes unequal for MSH6, skipping\n",
+      "shapes unequal for PTPN11, skipping\n",
+      "shapes unequal for ACVR1B, skipping\n",
+      "shapes unequal for CBL, skipping\n",
+      "shapes unequal for CYLD, skipping\n",
+      "shapes unequal for MLH1, skipping\n",
+      "shapes unequal for PAX5, skipping\n",
+      "shapes unequal for SMO, skipping\n"
+     ]
+    },
+    {
+     "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>gene</th>\n",
+       "      <th>seed</th>\n",
+       "      <th>fold</th>\n",
+       "      <th>delta_aupr</th>\n",
+       "      <th>training_data</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>EGFR</td>\n",
+       "      <td>42</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.462095</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>EGFR</td>\n",
+       "      <td>42</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.575210</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>EGFR</td>\n",
+       "      <td>42</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.546220</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>EGFR</td>\n",
+       "      <td>42</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.511270</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>EGFR</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.529412</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>EGFR</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.493000</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>EGFR</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.541130</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>EGFR</td>\n",
+       "      <td>1</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.583159</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>IDH1</td>\n",
+       "      <td>42</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.463950</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>IDH1</td>\n",
+       "      <td>42</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.377540</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   gene  seed  fold  delta_aupr      training_data\n",
+       "0  EGFR    42     0    0.462095  expression.me_27k\n",
+       "1  EGFR    42     1    0.575210  expression.me_27k\n",
+       "2  EGFR    42     2    0.546220  expression.me_27k\n",
+       "3  EGFR    42     3    0.511270  expression.me_27k\n",
+       "4  EGFR     1     0    0.529412  expression.me_27k\n",
+       "5  EGFR     1     1    0.493000  expression.me_27k\n",
+       "6  EGFR     1     2    0.541130  expression.me_27k\n",
+       "7  EGFR     1     3    0.583159  expression.me_27k\n",
+       "8  IDH1    42     0    0.463950  expression.me_27k\n",
+       "9  IDH1    42     1    0.377540  expression.me_27k"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# then, for each training data type, get the AUPR difference between signal and shuffled\n",
+    "compare_df = pd.DataFrame()\n",
+    "for training_data in all_results_df.training_data.unique():\n",
+    "    data_compare_df = au.compare_control_ind(\n",
+    "        all_results_df[all_results_df.training_data == training_data],\n",
+    "        identifier='identifier',\n",
+    "        metric='aupr',\n",
+    "        verbose=True\n",
+    "    )\n",
+    "    data_compare_df['training_data'] = training_data\n",
+    "    data_compare_df.rename(columns={'identifier': 'gene'}, inplace=True)\n",
+    "    compare_df = pd.concat((compare_df, data_compare_df))\n",
+    "    \n",
+    "compare_df.head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7ff0057bbd50>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1728x864 with 7 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# each subplot will show results for one gene\n",
+    "sns.set({'figure.figsize': (24, 12)})\n",
+    "fig, axarr = plt.subplots(2, 4)\n",
+    "compare_df.sort_values(by=['gene', 'training_data'], inplace=True)\n",
+    "compare_map = {v: str(i) for i, v in enumerate(compare_df.training_data.unique())}\n",
+    "compare_df['train_index'] = compare_df.training_data.map(compare_map)\n",
+    "min_aupr = compare_df.delta_aupr.min()\n",
+    "max_aupr = compare_df.delta_aupr.max()\n",
+    "\n",
+    "\n",
+    "data_order =['expression',\n",
+    "             'me_27k',\n",
+    "             'me_450k',\n",
+    "             'expression.me_27k',\n",
+    "             'expression.me_450k',\n",
+    "             'me_27k.me_450k',\n",
+    "             'expression.me_27k.me_450k']\n",
+    "\n",
+    "# plot mean performance over all genes in pilot experiment\n",
+    "for ix, gene in enumerate(results_df.identifier.unique()):\n",
+    "    \n",
+    "    ax = axarr[ix // 4, ix % 4]\n",
+    "    \n",
+    "    plot_df = compare_df[(compare_df.gene == gene)]\n",
+    "\n",
+    "    sns.boxplot(data=plot_df, x='training_data', y='delta_aupr',\n",
+    "                order=data_order, ax=ax)\n",
+    "    ax.set_title('Prediction for {} mutation'.format(gene))\n",
+    "    ax.set_xlabel('Training data type')\n",
+    "    # hide x-axis tick text\n",
+    "    ax.get_xaxis().set_ticklabels([])\n",
+    "    ax.set_ylabel('AUPR(signal) - AUPR(shuffled)')\n",
+    "    ax.set_ylim(-0.2, max_aupr)\n",
+    "    \n",
+    "handles = []\n",
+    "for ix, data in enumerate(data_order):\n",
+    "    handle = mpatches.Patch(color=sns.color_palette()[ix], label=data)\n",
+    "    handles.append(handle)\n",
+    "    \n",
+    "fig.delaxes(axarr[1, 3])\n",
+    "plt.legend(handles=handles, loc='lower right')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Compare best-performing single-omics and multi-omics data types"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['expression' 'me_27k' 'me_450k' 'expression.me_27k'\n",
+      " 'expression.me_27k.me_450k' 'expression.me_450k' 'me_27k.me_450k']\n"
+     ]
+    },
+    {
+     "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>gene</th>\n",
+       "      <th>seed</th>\n",
+       "      <th>fold</th>\n",
+       "      <th>delta_aupr</th>\n",
+       "      <th>training_data</th>\n",
+       "      <th>train_index</th>\n",
+       "      <th>model_type</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>704</th>\n",
+       "      <td>TP53</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.40978</td>\n",
+       "      <td>expression</td>\n",
+       "      <td>0</td>\n",
+       "      <td>single-omics</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>705</th>\n",
+       "      <td>TP53</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.40749</td>\n",
+       "      <td>expression</td>\n",
+       "      <td>0</td>\n",
+       "      <td>single-omics</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>706</th>\n",
+       "      <td>TP53</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.40269</td>\n",
+       "      <td>expression</td>\n",
+       "      <td>0</td>\n",
+       "      <td>single-omics</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>707</th>\n",
+       "      <td>TP53</td>\n",
+       "      <td>1</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.43339</td>\n",
+       "      <td>expression</td>\n",
+       "      <td>0</td>\n",
+       "      <td>single-omics</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>708</th>\n",
+       "      <td>TP53</td>\n",
+       "      <td>42</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.42613</td>\n",
+       "      <td>expression</td>\n",
+       "      <td>0</td>\n",
+       "      <td>single-omics</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>709</th>\n",
+       "      <td>TP53</td>\n",
+       "      <td>42</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.42219</td>\n",
+       "      <td>expression</td>\n",
+       "      <td>0</td>\n",
+       "      <td>single-omics</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>710</th>\n",
+       "      <td>TP53</td>\n",
+       "      <td>42</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.40556</td>\n",
+       "      <td>expression</td>\n",
+       "      <td>0</td>\n",
+       "      <td>single-omics</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>711</th>\n",
+       "      <td>TP53</td>\n",
+       "      <td>42</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.38959</td>\n",
+       "      <td>expression</td>\n",
+       "      <td>0</td>\n",
+       "      <td>single-omics</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>48</th>\n",
+       "      <td>TP53</td>\n",
+       "      <td>42</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.41009</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "      <td>3</td>\n",
+       "      <td>multi-omics</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>49</th>\n",
+       "      <td>TP53</td>\n",
+       "      <td>42</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.44884</td>\n",
+       "      <td>expression.me_27k</td>\n",
+       "      <td>3</td>\n",
+       "      <td>multi-omics</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     gene  seed  fold  delta_aupr      training_data train_index    model_type\n",
+       "704  TP53     1     0     0.40978         expression           0  single-omics\n",
+       "705  TP53     1     1     0.40749         expression           0  single-omics\n",
+       "706  TP53     1     2     0.40269         expression           0  single-omics\n",
+       "707  TP53     1     3     0.43339         expression           0  single-omics\n",
+       "708  TP53    42     0     0.42613         expression           0  single-omics\n",
+       "709  TP53    42     1     0.42219         expression           0  single-omics\n",
+       "710  TP53    42     2     0.40556         expression           0  single-omics\n",
+       "711  TP53    42     3     0.38959         expression           0  single-omics\n",
+       "48   TP53    42     0     0.41009  expression.me_27k           3   multi-omics\n",
+       "49   TP53    42     1     0.44884  expression.me_27k           3   multi-omics"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# for each data type, classify it as single-omics or multi-omics\n",
+    "compare_df['model_type'] = 'single-omics'\n",
+    "# multi-omics data types are concatenated using dots\n",
+    "compare_df.loc[compare_df.training_data.str.contains('\\.'), 'model_type'] = 'multi-omics'\n",
+    "print(compare_df.training_data.unique())\n",
+    "compare_df[compare_df.gene == 'TP53'].head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "EGFR diff: 0.0163 (pval: 0.3766)\n",
+      "IDH1 diff: 0.0187 (pval: 0.4427)\n",
+      "KRAS diff: -0.0051 (pval: 0.8444)\n",
+      "PIK3CA diff: -0.0109 (pval: 0.5544)\n",
+      "SETD2 diff: -0.0147 (pval: 0.7544)\n",
+      "TET2 diff: 0.0533 (pval: 0.1416)\n",
+      "TP53 diff: -0.0111 (pval: 0.1593)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'AUPR(signal) - AUPR(shuffled)')"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.set({'figure.figsize': (10, 6)})\n",
+    "\n",
+    "plot_df = pd.DataFrame()\n",
+    "\n",
+    "# plot mean performance over all genes in pilot experiment\n",
+    "for ix, gene in enumerate(results_df.identifier.unique()):\n",
+    "    \n",
+    "    plot_gene_df = compare_df[(compare_df.gene == gene)].reset_index(drop=True)\n",
+    "    \n",
+    "    # get the best-performing data types from the single-omics and multi-omics models\n",
+    "    max_single_data_type = (\n",
+    "        plot_gene_df[plot_gene_df.model_type == 'single-omics']\n",
+    "          .groupby('training_data')\n",
+    "          .agg('mean')\n",
+    "          .delta_aupr.idxmax()\n",
+    "    )\n",
+    "    max_multi_data_type = (\n",
+    "        plot_gene_df[plot_gene_df.model_type == 'multi-omics']\n",
+    "          .groupby('training_data')\n",
+    "          .agg('mean')\n",
+    "          .delta_aupr.idxmax()\n",
+    "    )\n",
+    "    \n",
+    "    # get samples with that data type\n",
+    "    max_single_df = plot_gene_df[plot_gene_df.training_data == max_single_data_type]\n",
+    "    max_multi_df = plot_gene_df[plot_gene_df.training_data == max_multi_data_type]\n",
+    "    \n",
+    "    # calculate difference between means and t-test p-val for that data type\n",
+    "    mean_diff = max_single_df.delta_aupr.mean() - max_multi_df.delta_aupr.mean()\n",
+    "    _, p_val = ttest_ind(max_single_df.delta_aupr.values,\n",
+    "                         max_multi_df.delta_aupr.values)\n",
+    "    print('{} diff: {:.4f} (pval: {:.4f})'.format(gene, mean_diff, p_val))\n",
+    "    \n",
+    "    plot_df = pd.concat((plot_df, max_single_df, max_multi_df))\n",
+    "\n",
+    "sns.boxplot(data=plot_df, x='gene', y='delta_aupr', hue='model_type')\n",
+    "plt.title('Best performing single-omics vs. multi-omics data type, per gene')\n",
+    "plt.xlabel('Target gene')\n",
+    "plt.ylabel('AUPR(signal) - AUPR(shuffled)')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Summary and interpretation:\n",
+    "\n",
+    "* In this last figure, we can see that the difference in distributions between the best-performing single-omics and multi-omics model is visually quite small for all of the target genes, and none of the differences are statistically significant using a t-test over the 8 total CV folds.\n",
+    "* Looking at the other two figures, when we consider all data types the difference between single-omics and multi-omics models is still pretty minimal in general. There are some genes where adding expression data helps a lot (EGFR, PIK3CA, KRAS) and others where it doesn't really (IDH1, SETD2), but in general there's not a lot of added predictive ability when expression is combined with other data types, suggesting that methylation may be most useful in that it correlates with expression patterns (although more follow-up would be needed to really confirm this)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:mpmp]",
+   "language": "python",
+   "name": "conda-env-mpmp-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.7.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/05_classify_mutations_multimodal/run_mutation_classification.py b/05_classify_mutations_multimodal/run_mutation_classification.py
new file mode 100644
index 0000000..7528e56
--- /dev/null
+++ b/05_classify_mutations_multimodal/run_mutation_classification.py
@@ -0,0 +1,258 @@
+"""
+Script to run pan-cancer mutation classification experiments, with stratified
+train and test sets, for multiple data types at once.
+"""
+import sys
+import argparse
+from pathlib import Path
+
+import pandas as pd
+from tqdm import tqdm
+
+import mpmp.config as cfg
+from mpmp.data_models.tcga_data_model import TCGADataModel
+from mpmp.exceptions import (
+    ResultsFileExistsError,
+    NoTrainSamplesError,
+    NoTestSamplesError,
+    OneClassError,
+)
+from mpmp.prediction.cross_validation import run_cv_stratified
+import mpmp.utilities.data_utilities as du
+import mpmp.utilities.file_utilities as fu
+from mpmp.utilities.tcga_utilities import get_overlap_data_types
+
+def process_args():
+    """Parse and format command line arguments."""
+
+    parser = argparse.ArgumentParser()
+
+    # argument group for parameters related to input/output
+    # (e.g. filenames, logging/verbosity options, target genes)
+    #
+    # these don't affect the model output, and thus don't need to be saved
+    # with the results of the experiment
+    io = parser.add_argument_group('io',
+                                   'arguments related to script input/output, '
+                                   'note these will *not* be saved in metadata ')
+    io.add_argument('--custom_genes', nargs='*', default=None,
+                    help='currently this needs to be a subset of top_50')
+    io.add_argument('--gene_set', type=str,
+                    choices=['top_50', 'vogelstein', 'custom'],
+                    default='top_50',
+                    help='choose which gene set to use. top_50 and vogelstein are '
+                         'predefined gene sets (see data_utilities), and custom allows '
+                         'any gene or set of genes in TCGA, specified in --custom_genes')
+    io.add_argument('--log_file', default=None,
+                    help='name of file to log skipped genes to')
+    io.add_argument('--results_dir', default=cfg.results_dirs['multimodal'],
+                    help='where to write results to')
+    io.add_argument('--verbose', action='store_true')
+
+    # argument group for parameters related to model training/evaluation
+    # (e.g. model hyperparameters, preprocessing options)
+    #
+    # these affect the output of the model, so we want to save them in the
+    # same directory as the experiment results
+    opts = parser.add_argument_group('model_options',
+                                     'parameters for training/evaluating model, '
+                                     'these will affect output and are saved as '
+                                     'experiment metadata ')
+    opts.add_argument('--debug', action='store_true',
+                      help='use subset of data for fast debugging')
+    opts.add_argument('--n_dim', nargs='*', default=None,
+                      help='list of compressed dimensions to use, defaults to '
+                           'uncompressed data for all data types')
+    opts.add_argument('--num_folds', type=int, default=4,
+                      help='number of folds of cross-validation to run')
+    opts.add_argument('--seed', type=int, default=cfg.default_seed)
+    opts.add_argument('--subset_mad_genes', type=int, default=cfg.num_features_raw,
+                      help='if included, subset gene features to this number of '
+                           'features having highest mean absolute deviation')
+    opts.add_argument('--training_data', nargs='*', default=['expression'],
+                      help='which data types to train model on')
+
+    args = parser.parse_args()
+
+    args.results_dir = Path(args.results_dir).resolve()
+
+    if args.log_file is None:
+        args.log_file = Path(args.results_dir, 'log_skipped.tsv').resolve()
+
+    if args.gene_set == 'custom':
+        if args.custom_genes is None:
+            parser.error('must include --custom_genes when --gene_set=\'custom\'')
+        args.gene_set = args.custom_genes
+        del args.custom_genes
+    elif (args.gene_set != 'custom' and args.custom_genes is not None):
+        parser.error('must use option --gene_set=\'custom\' if custom genes are included')
+
+    if (len(set(args.training_data).intersection(set(cfg.data_types.keys()))) !=
+            len(set(args.training_data))):
+        parser.error('training_data data types must be in config.data_types')
+
+    # split args into defined argument groups, since we'll use them differently
+    arg_groups = du.split_argument_groups(args, parser)
+    io_args, model_options = arg_groups['io'], arg_groups['model_options']
+
+    # if no n_dim argument provided, set all to None
+    if model_options.n_dim is None:
+        model_options.n_dim = [None] * len(model_options.training_data)
+    else:
+        # convert None strings from argparse to python Nones
+        model_options.n_dim = (
+            [None if n == 'None' else n for n in model_options.n_dim]
+        )
+
+    # add some additional hyperparameters/ranges from config file to model options
+    # these shouldn't be changed by the user, so they aren't added as arguments
+    model_options.alphas = cfg.alphas
+    model_options.l1_ratios = cfg.l1_ratios
+
+    # for these experiments, we need to standardize all data types that are not
+    # already PCA compressed
+    model_options.standardize_data_types = (
+        [t for ix, t in enumerate(model_options.training_data)
+           if model_options.n_dim[ix] == None]
+    )
+
+    # add information about valid samples to model options
+    model_options.sample_overlap_data_types = list(
+        get_overlap_data_types(use_subsampled=model_options.debug).keys()
+    )
+
+    return io_args, model_options
+
+
+if __name__ == '__main__':
+
+    # process command line arguments
+    io_args, model_options = process_args()
+
+    # TODO: how to do this for all training datatypes?
+    sample_info_df = du.load_sample_info_multi(model_options.training_data,
+                                               verbose=io_args.verbose)
+
+    # create results dir and subdir for experiment if they don't exist
+    experiment_dir = Path(io_args.results_dir, 'gene').resolve()
+    experiment_dir.mkdir(parents=True, exist_ok=True)
+
+    # save model options for this experiment
+    # (hyperparameters, preprocessing info, etc)
+    fu.save_model_options(experiment_dir, model_options)
+
+    # create empty log file if it doesn't exist
+    log_columns = [
+        'gene',
+        'training_data',
+        'shuffle_labels',
+        'skip_reason'
+    ]
+    if io_args.log_file.exists() and io_args.log_file.is_file():
+        log_df = pd.read_csv(io_args.log_file, sep='\t')
+    else:
+        log_df = pd.DataFrame(columns=log_columns)
+        log_df.to_csv(io_args.log_file, sep='\t')
+
+    tcga_data = TCGADataModel(seed=model_options.seed,
+                              subset_mad_genes=model_options.subset_mad_genes,
+                              training_data=model_options.training_data,
+                              n_dim=model_options.n_dim,
+                              sample_info_df=sample_info_df,
+                              verbose=io_args.verbose,
+                              debug=model_options.debug)
+    genes_df = tcga_data.load_gene_set(io_args.gene_set)
+
+    # we want to run mutation prediction experiments:
+    # - for true labels and shuffled labels
+    #   (shuffled labels acts as our lower baseline)
+    # - for all genes in the given gene set
+    for shuffle_labels in (False, True):
+
+        print('shuffle_labels: {}'.format(shuffle_labels))
+
+        progress = tqdm(genes_df.iterrows(),
+                        total=genes_df.shape[0],
+                        ncols=100,
+                        file=sys.stdout)
+
+        for gene_idx, gene_series in progress:
+            log_df = None
+            gene = gene_series.gene
+            classification = gene_series.classification
+            progress.set_description('gene: {}'.format(gene))
+
+            try:
+                gene_dir = fu.make_output_dir(experiment_dir, gene)
+                check_file = fu.check_output_file(gene_dir,
+                                                  gene,
+                                                  shuffle_labels,
+                                                  model_options)
+                tcga_data.process_data_for_gene(gene,
+                                                classification,
+                                                gene_dir,
+                                                shuffle_labels=shuffle_labels)
+            except ResultsFileExistsError:
+                # this happens if cross-validation for this gene has already been
+                # run (i.e. the results file already exists)
+                if io_args.verbose:
+                    print('Skipping because results file exists already: gene {}'.format(
+                        gene), file=sys.stderr)
+                log_df = fu.generate_log_df(
+                    log_columns,
+                    [gene, '.'.join(model_options.training_data), shuffle_labels, 'file_exists']
+                )
+                fu.write_log_file(log_df, io_args.log_file)
+                continue
+            except KeyError:
+                # this might happen if the given gene isn't in the mutation data
+                # (or has a different alias, TODO we could check for this later)
+                print('Gene {} not found in mutation data, skipping'.format(gene),
+                      file=sys.stderr)
+                log_df = fu.generate_log_df(
+                    log_columns,
+                    [gene, '.'.join(model_options.training_data), shuffle_labels, 'gene_not_found']
+                )
+                fu.write_log_file(log_df, io_args.log_file)
+                continue
+
+            try:
+                standardize_columns = [(t in model_options.standardize_data_types)
+                                          for t in model_options.training_data]
+                results = run_cv_stratified(tcga_data,
+                                            'gene',
+                                            gene,
+                                            model_options.training_data,
+                                            sample_info_df,
+                                            model_options.num_folds,
+                                            classify=True,
+                                            shuffle_labels=shuffle_labels,
+                                            standardize_columns=standardize_columns)
+                # only save results if no exceptions
+                fu.save_results(gene_dir,
+                                check_file,
+                                results,
+                                'gene',
+                                gene,
+                                shuffle_labels,
+                                model_options)
+            except NoTrainSamplesError:
+                if io_args.verbose:
+                    print('Skipping due to no train samples: gene {}'.format(
+                        gene), file=sys.stderr)
+                log_df = fu.generate_log_df(
+                    log_columns,
+                    [gene, '.'.join(model_options.training_data), shuffle_labels, 'no_train_samples']
+                )
+            except OneClassError:
+                if io_args.verbose:
+                    print('Skipping due to one holdout class: gene {}'.format(
+                        gene), file=sys.stderr)
+                log_df = fu.generate_log_df(
+                    log_columns,
+                    [gene, '.'.join(model_options.training_data), shuffle_labels, 'one_class']
+                )
+
+            if log_df is not None:
+                fu.write_log_file(log_df, io_args.log_file)
+
diff --git a/05_classify_mutations_multimodal/scripts/run_multimodal_prediction.sh b/05_classify_mutations_multimodal/scripts/run_multimodal_prediction.sh
new file mode 100755
index 0000000..1ae4779
--- /dev/null
+++ b/05_classify_mutations_multimodal/scripts/run_multimodal_prediction.sh
@@ -0,0 +1,59 @@
+#!/bin/bash
+RESULTS_DIR=./05_classify_mutations_multimodal/results/pilot_results_all_feats
+ERRORS_DIR=./multimodal_pilot_errors
+GENES="TP53 KRAS EGFR PIK3CA IDH1 SETD2 TET2"
+
+mkdir -p $ERRORS_DIR
+
+for seed in 42 1; do
+
+    # run all combinations of expression, me_27k, me_450k
+    # use compressed data for me_450k, raw features for expression/27k
+    cmd="python 05_classify_mutations_multimodal/run_mutation_classification.py "
+    cmd+="--gene_set custom "
+    cmd+="--custom_genes ${GENES} "
+    cmd+="--results_dir $RESULTS_DIR "
+    cmd+="--training_data expression me_27k "
+    cmd+="--subset_mad_genes -1 "
+    cmd+="--seed $seed "
+    cmd+="2>$ERRORS_DIR/errors_expression_me_27k.txt"
+    echo "Running: $cmd"
+    eval $cmd
+
+    cmd="python 05_classify_mutations_multimodal/run_mutation_classification.py "
+    cmd+="--gene_set custom "
+    cmd+="--custom_genes ${GENES} "
+    cmd+="--results_dir $RESULTS_DIR "
+    cmd+="--training_data expression me_450k "
+    cmd+="--subset_mad_genes -1 "
+    cmd+="--n_dim None 5000 "
+    cmd+="--seed $seed "
+    cmd+="2>$ERRORS_DIR/errors_expression_me_450k.txt"
+    echo "Running: $cmd"
+    eval $cmd
+
+    cmd="python 05_classify_mutations_multimodal/run_mutation_classification.py "
+    cmd+="--gene_set custom "
+    cmd+="--custom_genes ${GENES} "
+    cmd+="--results_dir $RESULTS_DIR "
+    cmd+="--training_data me_27k me_450k "
+    cmd+="--subset_mad_genes -1 "
+    cmd+="--n_dim None 5000 "
+    cmd+="--seed $seed "
+    cmd+="2>$ERRORS_DIR/errors_me_27k_me_450k.txt"
+    echo "Running: $cmd"
+    eval $cmd
+
+    cmd="python 05_classify_mutations_multimodal/run_mutation_classification.py "
+    cmd+="--gene_set custom "
+    cmd+="--custom_genes ${GENES} "
+    cmd+="--results_dir $RESULTS_DIR "
+    cmd+="--training_data expression me_27k me_450k "
+    cmd+="--subset_mad_genes -1 "
+    cmd+="--n_dim None None 5000 "
+    cmd+="--seed $seed "
+    cmd+="2>$ERRORS_DIR/errors_all.txt"
+    echo "Running: $cmd"
+    eval $cmd
+
+done
diff --git a/mpmp/config.py b/mpmp/config.py
index 98f508c..d8aaa67 100644
--- a/mpmp/config.py
+++ b/mpmp/config.py
@@ -8,6 +8,7 @@ results_dirs = {
     'mutation': repo_root / '02_classify_mutations' / 'results',
     'cancer_type': repo_root / '03_classify_cancer_type' / 'results',
     'purity': repo_root / '04_predict_tumor_purity' / 'results',
+    'multimodal': repo_root / '05_classify_mutations_multimodal' / 'results',
 }
 
 # locations of saved data files
@@ -133,3 +134,8 @@ standardize_data_types = ['expression', 'rppa']
 # subsample data to smallest cancer type
 # hopefully this will improve prediction for imbalanced cancer types
 subsample_to_smallest = False
+
+# constant for non-gene feature indices
+# this is used in multimodal prediction experiments, e.g. scripts in
+# 05_classify_mutations_multimodal directory
+NONGENE_FEATURE = -1
diff --git a/mpmp/data_models/tcga_data_model.py b/mpmp/data_models/tcga_data_model.py
index eb3836e..69eedfc 100644
--- a/mpmp/data_models/tcga_data_model.py
+++ b/mpmp/data_models/tcga_data_model.py
@@ -176,6 +176,17 @@ class TCGADataModel():
         )
         train_filtered_df, y_filtered_df, gene_features = filtered_data
 
+        # add non-gene features to data_types array if necessary
+        if hasattr(self, 'data_types'):
+            # this has to have a different name than the general data_types
+            # array, since this preprocessing may happen multiple times (for
+            # each gene) in the same script call
+            self.gene_data_types = np.concatenate(
+                (self.data_types, np.array([cfg.NONGENE_FEATURE] *
+                                            np.count_nonzero(~gene_features)))
+            )
+            assert self.gene_data_types.shape[0] == gene_features.shape[0]
+
         if shuffle_labels:
             y_filtered_df.status = np.random.permutation(
                 y_filtered_df.status.values)
@@ -271,7 +282,15 @@ class TCGADataModel():
         test (bool): whether or not to subset columns in mutation data, for testing
         """
         # load training data
-        if compressed_data:
+        if not isinstance(train_data_type, str):
+            # if a list of train data types is provided, we have to load each
+            # of them and concatenate columns
+            # n_dim should be a list here
+            self.data_df, self.data_types = du.load_multiple_data_types(
+                                                train_data_type,
+                                                n_dims=n_dim,
+                                                verbose=self.verbose)
+        elif compressed_data:
             self.data_df = du.load_compressed_data(train_data_type,
                                                    n_dim=n_dim,
                                                    verbose=self.verbose,
diff --git a/mpmp/prediction/classification.py b/mpmp/prediction/classification.py
index 23ca36f..9b595ec 100644
--- a/mpmp/prediction/classification.py
+++ b/mpmp/prediction/classification.py
@@ -217,6 +217,9 @@ def summarize_results(results,
     data_type: the type of data (either training, testing, or cv)
     fold_no: the fold number for the external cross-validation loop
     """
+    if not isinstance(training_data, str):
+        training_data = '.'.join(training_data)
+
     results_append_list = [
         identifier,
         training_data,
diff --git a/mpmp/prediction/cross_validation.py b/mpmp/prediction/cross_validation.py
index ae13286..cee908c 100644
--- a/mpmp/prediction/cross_validation.py
+++ b/mpmp/prediction/cross_validation.py
@@ -89,11 +89,21 @@ def run_cv_stratified(data_model,
         y_train_df = data_model.y_df.reindex(X_train_raw_df.index)
         y_test_df = data_model.y_df.reindex(X_test_raw_df.index)
 
-        X_train_df, X_test_df = tu.preprocess_data(X_train_raw_df,
-                                                   X_test_raw_df,
-                                                   data_model.gene_features,
-                                                   standardize_columns,
-                                                   data_model.subset_mad_genes)
+        # choose single-omics or multi-omics preprocessing function based on
+        # data_model.gene_data_types class attribute
+        if hasattr(data_model, 'gene_data_types'):
+            X_train_df, X_test_df = tu.preprocess_multi_data(X_train_raw_df,
+                                                             X_test_raw_df,
+                                                             data_model.gene_features,
+                                                             data_model.gene_data_types,
+                                                             standardize_columns,
+                                                             data_model.subset_mad_genes)
+        else:
+            X_train_df, X_test_df = tu.preprocess_data(X_train_raw_df,
+                                                       X_test_raw_df,
+                                                       data_model.gene_features,
+                                                       standardize_columns,
+                                                       data_model.subset_mad_genes)
 
         if cfg.subsample_to_smallest:
             sample_counts_df = pd.read_csv(cfg.sample_counts, sep='\t')
@@ -139,7 +149,10 @@ def run_cv_stratified(data_model,
 
         )
         coef_df = coef_df.assign(identifier=identifier)
-        coef_df = coef_df.assign(training_data=training_data)
+        if isinstance(training_data, str):
+            coef_df = coef_df.assign(training_data=training_data)
+        else:
+            coef_df = coef_df.assign(training_data='.'.join(training_data))
         coef_df = coef_df.assign(fold=fold_no)
         results['{}_coef'.format(exp_string)].append(coef_df)
 
diff --git a/mpmp/utilities/analysis_utilities.py b/mpmp/utilities/analysis_utilities.py
index 4a79162..53908aa 100644
--- a/mpmp/utilities/analysis_utilities.py
+++ b/mpmp/utilities/analysis_utilities.py
@@ -377,6 +377,62 @@ def compare_control(results_df,
     return pd.DataFrame(results, columns=['identifier', 'delta_mean', 'p_value'])
 
 
+def compare_control_ind(results_df,
+                        identifier='gene',
+                        metric='auroc',
+                        verbose=False):
+    """Compare signal vs. shuffled results for each seed/CV fold independently.
+
+    This allows customized statistical analysis after performing comparison
+    (as opposed to compare_control which automatically aggregates over
+    seeds/folds).
+    """
+
+    results = []
+    unique_identifiers = np.unique(results_df[identifier].values)
+
+    for id_str in unique_identifiers:
+
+        conditions = ((results_df[identifier] == id_str) &
+                      (results_df.data_type == 'test') &
+                      (results_df.signal == 'signal'))
+        signal_results = results_df[conditions].copy()
+
+        conditions = ((results_df[identifier] == id_str) &
+                      (results_df.data_type == 'test') &
+                     (results_df.signal == 'shuffled'))
+        shuffled_results = results_df[conditions].copy()
+
+        if signal_results.shape != shuffled_results.shape:
+            if verbose:
+                print('shapes unequal for {}, skipping'.format(id_str),
+                      file=sys.stderr)
+            continue
+
+        if (signal_results.size == 0) or (shuffled_results.size == 0):
+            if verbose:
+                print('size 0 results array for {}, skipping'.format(id_str),
+                      file=sys.stderr)
+            continue
+
+        for seed in results_df.seed.unique():
+            for fold in results_df.fold.unique():
+                try:
+                    signal_value = signal_results[(signal_results.seed == seed) &
+                                                 (signal_results.fold == fold)][metric].values[0]
+                    shuffled_value = shuffled_results[(shuffled_results.seed == seed) &
+                                                      (shuffled_results.fold == fold)][metric].values[0]
+                    delta = signal_value - shuffled_value
+                    results.append([id_str, seed, fold, delta])
+                except IndexError:
+                    # this seed/fold combo doesn't exist, just skip it
+                    continue
+
+    return pd.DataFrame(results,
+                        columns=['identifier', 'seed', 'fold',
+                                'delta_{}'.format(metric)])
+
+
 def compare_experiment(single_cancer_df,
                        pancancer_df,
                        identifier='gene',
diff --git a/mpmp/utilities/data_utilities.py b/mpmp/utilities/data_utilities.py
index e645f99..8bc3696 100644
--- a/mpmp/utilities/data_utilities.py
+++ b/mpmp/utilities/data_utilities.py
@@ -85,6 +85,45 @@ def load_compressed_data(data_type, n_dim, verbose=False, load_subset=False):
     return data_df
 
 
+def load_multiple_data_types(data_types, n_dims, verbose=False):
+    """Load multiple data types and concatenate columns.
+
+    Arguments
+    ---------
+    data_types (list): list of data types to use
+    n_dims (list): list of compressed dimensions to use, None for raw data
+    verbose (bool): whether or not to print verbose output
+
+    Returns
+    -------
+    data_df: samples x latent dimensions dataframe
+    data_ixs: 1D numpy array containing data type index for each column
+    """
+    data_df = pd.DataFrame()
+    data_ixs = []
+    if verbose:
+        print('Loading data for data types {}...'.format(', '.join(data_types)),
+              file=sys.stderr)
+    for ix, (data_type, n_dim) in enumerate(zip(data_types, n_dims)):
+        if verbose:
+            print('- Loading {} data...'.format(data_type), file=sys.stderr)
+        if n_dim is not None:
+            partial_data_df = load_compressed_data(data_type, n_dim)
+            # the default PC name is just the integer index, so here we need
+            # to rename them in case we have PCs for more than one data type
+            #
+            # just rename them to {data_type}_pc{pc_number}
+            partial_data_df = partial_data_df.add_prefix(
+                                  '{}_pc'.format(data_type))
+        else:
+            partial_data_df = load_raw_data(data_type)
+        data_ixs += [ix] * partial_data_df.shape[1]
+        # only keep samples that are in all data types (inner join)
+        data_df = pd.concat((data_df, partial_data_df), axis=1,
+                            join=('outer' if ix == 0 else 'inner'))
+    return data_df, np.array(data_ixs)
+
+
 def load_pancancer_data(verbose=False, test=False, subset_columns=None):
     """Load pan-cancer relevant data from previous Greene Lab repos.
 
@@ -225,6 +264,18 @@ def load_sample_info(train_data_type, verbose=False):
     return pd.read_csv(cfg.sample_infos[train_data_type],
                        sep='\t', index_col='sample_id')
 
+def load_sample_info_multi(train_data_types, verbose=False):
+    if verbose:
+        print('Loading sample info for multiple data types...',
+              file=sys.stderr)
+    sample_info_df = load_sample_info(train_data_types[0])
+    for training_data in train_data_types[1:]:
+        # add the rows that are not in current sample info
+        add_df = load_sample_info(training_data)
+        add_df = add_df[~add_df.index.isin(sample_info_df.index)]
+        sample_info_df = pd.concat((sample_info_df, add_df))
+    return sample_info_df
+
 
 def load_purity(mut_burden_df,
                 sample_info_df,
diff --git a/mpmp/utilities/file_utilities.py b/mpmp/utilities/file_utilities.py
index 78793e6..1408cd1 100644
--- a/mpmp/utilities/file_utilities.py
+++ b/mpmp/utilities/file_utilities.py
@@ -65,12 +65,18 @@ def save_model_options(output_dir, model_options, classify=True):
     model_options is an argparse Namespace, and is converted to a dictionary
     and pickled.
     """
+    if not isinstance(model_options.training_data, str):
+        training_data = '.'.join(model_options.training_data)
+    else:
+        training_data = model_options.training_data
+
     output_file = construct_filename(output_dir,
                                      'model_options',
                                      '.pkl',
-                                     model_options.training_data,
+                                     training_data,
                                      ('classify' if classify else 'regression'),
                                      s=model_options.seed)
+
     with open(output_file, 'wb') as f:
         pkl.dump(vars(model_options), f)
 
@@ -86,15 +92,26 @@ def check_output_file(output_dir,
     """
 
     signal = 'shuffled' if shuffle_labels else 'signal'
+
+    if not isinstance(model_options.training_data, str):
+        training_data = '.'.join(model_options.training_data)
+    else:
+        training_data = model_options.training_data
+
+    if isinstance(model_options.n_dim, list):
+        n_dim = '.'.join(map(str, model_options.n_dim))
+    else:
+        n_dim = model_options.n_dim
+
     check_file = construct_filename(output_dir,
                                     'coefficients',
                                     '.tsv.gz',
                                     identifier,
-                                    model_options.training_data,
+                                    training_data,
                                     signal,
                                     ('classify' if classify else 'regression'),
                                     s=model_options.seed,
-                                    n=model_options.n_dim)
+                                    n=n_dim)
     if check_file.is_file():
         raise ResultsFileExistsError(
             'Results file already exists for identifier: {}\n'.format(
@@ -115,6 +132,16 @@ def save_results(output_dir,
 
     signal = 'shuffled' if shuffle_labels else 'signal'
 
+    if not isinstance(model_options.training_data, str):
+        training_data = '.'.join(model_options.training_data)
+    else:
+        training_data = model_options.training_data
+
+    if isinstance(model_options.n_dim, list):
+        n_dim = '.'.join(map(str, model_options.n_dim))
+    else:
+        n_dim = model_options.n_dim
+
     if classify:
         auc_df = pd.concat(results[
             '{}_auc'.format(exp_string)
@@ -123,10 +150,10 @@ def save_results(output_dir,
                                          'auc_threshold_metrics',
                                          '.tsv.gz',
                                          identifier,
-                                         model_options.training_data,
+                                         training_data,
                                          signal,
                                          s=model_options.seed,
-                                         n=model_options.n_dim)
+                                         n=n_dim)
         auc_df.to_csv(
             output_file, sep="\t", index=False, float_format="%.5g"
         )
@@ -138,10 +165,10 @@ def save_results(output_dir,
                                          'aupr_threshold_metrics',
                                          '.tsv.gz',
                                          identifier,
-                                         model_options.training_data,
+                                         training_data,
                                          signal,
                                          s=model_options.seed,
-                                         n=model_options.n_dim)
+                                         n=n_dim)
         aupr_df.to_csv(
             output_file, sep="\t", index=False, float_format="%.5g"
         )
@@ -168,11 +195,12 @@ def save_results(output_dir,
                                      'metrics',
                                      '.tsv.gz',
                                      identifier,
-                                     model_options.training_data,
+                                     training_data,
                                      signal,
                                      ('classify' if classify else 'regression'),
                                      s=model_options.seed,
-                                     n=model_options.n_dim)
+
+                                     n=n_dim)
     metrics_df.to_csv(
         output_file, sep="\t", index=False, float_format="%.5g"
     )
@@ -182,11 +210,11 @@ def save_results(output_dir,
                                          'preds',
                                          '.tsv.gz',
                                          identifier,
-                                         model_options.training_data,
+                                         training_data,
                                          signal,
                                          ('classify' if classify else 'regression'),
                                          s=model_options.seed,
-                                         n=model_options.n_dim)
+                                         n=n_dim)
         preds_df.to_csv(
             output_file, sep="\t", float_format="%.5g"
         )
diff --git a/mpmp/utilities/tcga_utilities.py b/mpmp/utilities/tcga_utilities.py
index e01a490..0c2c89c 100644
--- a/mpmp/utilities/tcga_utilities.py
+++ b/mpmp/utilities/tcga_utilities.py
@@ -214,21 +214,22 @@ def preprocess_data(X_train_raw_df,
     return X_train_df, X_test_df
 
 
-def standardize_gene_features(x_df, gene_features):
+
+def standardize_gene_features(X_df, gene_features):
     """Standardize (take z-scores of) real-valued gene expression features.
 
     Note this should be done for train and test sets independently. Also note
     this doesn't necessarily preserve the order of features (this shouldn't
     matter in most cases).
     """
-    x_df_gene = x_df.loc[:, gene_features]
-    x_df_other = x_df.loc[:, ~gene_features]
-    x_df_scaled = pd.DataFrame(
-        StandardScaler().fit_transform(x_df_gene),
-        index=x_df_gene.index.copy(),
-        columns=x_df_gene.columns.copy()
+    X_df_gene = X_df.loc[:, gene_features]
+    X_df_other = X_df.loc[:, ~gene_features]
+    X_df_scaled = pd.DataFrame(
+        StandardScaler().fit_transform(X_df_gene),
+        index=X_df_gene.index.copy(),
+        columns=X_df_gene.columns.copy()
     )
-    return pd.concat((x_df_scaled, x_df_other), axis=1)
+    return pd.concat((X_df_scaled, X_df_other), axis=1)
 
 
 def subset_by_mad(X_train_df, X_test_df, gene_features, subset_mad_genes, verbose=False):
@@ -241,7 +242,8 @@ def subset_by_mad(X_train_df, X_test_df, gene_features, subset_mad_genes, verbos
     ---------
     X_train_df: training data, samples x genes
     X_test_df: test data, samples x genes
-    gene_features: numpy bool array, indicating which features are genes (and should be subsetted/standardized)
+    gene_features: numpy bool array, indicating which features are genes
+                   (and should be subsetted/standardized)
     subset_mad_genes (int): number of genes to take
 
     Returns
@@ -272,6 +274,154 @@ def subset_by_mad(X_train_df, X_test_df, gene_features, subset_mad_genes, verbos
     return train_df, test_df, gene_features
 
 
+def preprocess_multi_data(X_train_raw_df,
+                          X_test_raw_df,
+                          gene_features,
+                          data_types,
+                          standardize_columns=True,
+                          subset_mad_genes=-1):
+    """
+    Data processing for multi-omics experiments.
+
+    Arguments
+    ---------
+    X_train_raw_df (pd.DataFrame): training dataset
+    X_test_raw_df (pd.DataFrame): test dataset
+    gene_features (np.array): 1D boolean array, indicating which features
+                              correspond to genes and should be preprocessed
+    data_types (np.array): 1D int array, indicating which data type each
+                           feature corresponds to. Non-gene features should
+                           have a data type of config.NONGENE_FEATURE, and other
+                           features should be indexed from 0.
+    standardize_columns (list): list of whether or not to standardize each
+                                data type, in the same order as indexing in
+                                data_types. Defaults to True for all data
+                                types.
+
+    Returns
+    -------
+    X_train_df (pd.DataFrame): preprocessed training data
+    X_test_df (pd.DataFrame): preprocessed test data
+    """
+    # standardize_columns should be a list having the same length as
+    # the number of data types, in the same order
+    # default to standardizing all data types
+    if not isinstance(standardize_columns, list):
+        standardize_columns = [True] * (np.unique(data_types).shape[0] - 1)
+
+    # first deal with subsetting gene features by MAD
+    if subset_mad_genes > 0:
+        train_datasets, test_datasets = [], []
+        gene_features_filtered = []
+        data_types_filtered = []
+
+        # for each gene feature dataset, separately take top n mad genes
+        for data_type in np.unique(data_types):
+
+            # skip non-gene features, we don't want to subset those
+            # we can add them back untransformed at the end
+            if data_type == cfg.NONGENE_FEATURE: continue
+
+            # subset to the features for the given data type, and filter
+            data_ixs = (data_types == data_type)
+            X_train_data_df = X_train_raw_df.loc[:, data_ixs]
+            X_test_data_df = X_test_raw_df.loc[:, data_ixs]
+            X_train_data_df, X_test_data_df, _ = subset_by_mad(
+                X_train_data_df,
+                X_test_data_df,
+                np.ones((X_train_data_df.shape[1],), dtype=bool),
+                subset_mad_genes
+            )
+
+            # append info for current data type
+            train_datasets.append(X_train_data_df)
+            test_datasets.append(X_test_data_df)
+            gene_features_filtered += [True] * X_train_data_df.shape[1]
+            data_types_filtered += [data_type] * X_train_data_df.shape[1]
+
+        # then add non-gene features, this preserves the order from before
+        X_train_non_gene_df = X_train_raw_df.loc[:, ~gene_features]
+        X_test_non_gene_df = X_test_raw_df.loc[:, ~gene_features]
+        train_datasets.append(X_train_non_gene_df)
+        test_datasets.append(X_test_non_gene_df)
+        gene_features_filtered += [False] * X_train_non_gene_df.shape[1]
+        data_types_filtered += [cfg.NONGENE_FEATURE] * X_train_non_gene_df.shape[1]
+
+        # then concatenate all datasets together to get the final df
+        X_train_raw_df = pd.concat(train_datasets, axis=1)
+        X_test_raw_df = pd.concat(test_datasets, axis=1)
+        gene_features_filtered = np.array(gene_features_filtered)
+        data_types_filtered = np.array(data_types_filtered)
+
+        assert X_train_raw_df.shape[1] == X_test_raw_df.shape[1]
+        assert X_train_raw_df.shape[1] == gene_features_filtered.shape[0]
+        assert X_train_raw_df.shape[1] == data_types_filtered.shape[0]
+
+        # next, standardize columns using the new gene features
+        X_train_df = standardize_multi_gene_features(
+            X_train_raw_df,
+            standardize_columns,
+            gene_features_filtered,
+            data_types_filtered
+        )
+        X_test_df = standardize_multi_gene_features(
+            X_test_raw_df,
+            standardize_columns,
+            gene_features_filtered,
+            data_types_filtered
+        )
+
+    else:
+        # if no filtering by MAD, just standardize using original gene features
+        X_train_df = standardize_multi_gene_features(
+            X_train_raw_df,
+            standardize_columns,
+            gene_features,
+            data_types
+        )
+        X_test_df = standardize_multi_gene_features(
+            X_test_raw_df,
+            standardize_columns,
+            gene_features,
+            data_types
+        )
+
+    return X_train_df, X_test_df
+
+
+def standardize_multi_gene_features(X_df, standardize_columns, gene_features, data_types):
+    """Standardize features for multiple data types.
+
+    Functions similarly to standardize_gene_features, but applied to each data
+    type in data_types separately.
+    """
+    # for each gene feature dataset, take top n mad genes (separately)
+    datasets = []
+    for data_type in np.unique(data_types):
+
+        # skip non-gene features, these shouldn't be transformed
+        if data_type == cfg.NONGENE_FEATURE: continue
+
+        # get relevant columns of X_data_df
+        data_ixs = (data_types == data_type)
+        X_data_df = X_df.loc[:, data_ixs]
+
+        # if we don't want to standardize the current data type, just add it
+        # to the list untransformed, otherwise standardize it
+        if standardize_columns[data_type]:
+            X_data_df = standardize_gene_features(
+                X_data_df, np.ones((X_data_df.shape[1],), dtype=bool)
+            )
+        datasets.append(X_data_df)
+
+    # then add non-gene features, we don't standardize these
+    X_non_gene_df = X_df.loc[:, ~gene_features]
+    datasets.append(X_non_gene_df)
+
+    # concatenate datasets back together and return
+    return pd.concat(datasets, axis=1)
+
+
 def subsample_to_smallest_cancer_type(X_df,
                                       y_df,
                                       sample_info_df,


Test patch:
diff --git a/tests/test_data_type_filtering.py b/tests/test_data_type_filtering.py
index 1d3a66a..4d68168 100644
--- a/tests/test_data_type_filtering.py
+++ b/tests/test_data_type_filtering.py
@@ -1,5 +1,5 @@
 """
-Test cases for cross-validation code in data_utilities.py
+Test cases for data type filtering in tcga_utilities.py
 """
 import pytest
 import numpy as np
diff --git a/tests/test_multimodal_preprocessing.py b/tests/test_multimodal_preprocessing.py
new file mode 100644
index 0000000..54ef525
--- /dev/null
+++ b/tests/test_multimodal_preprocessing.py
@@ -0,0 +1,90 @@
+"""
+Test cases for multimodal preprocessing in tcga_utilities.py
+"""
+import string
+import itertools as it
+
+import pytest
+import numpy as np
+import pandas as pd
+
+import mpmp.config as cfg
+import mpmp.utilities.tcga_utilities as tu
+
+@pytest.fixture(scope='module')
+def raw_data():
+    """Generate a raw dataset"""
+    cols = list(string.ascii_lowercase)[:11]
+    X_train_raw_df = pd.DataFrame(np.random.uniform(size=(20, 11)), columns=cols)
+    X_test_raw_df = pd.DataFrame(np.random.uniform(size=(10, 11)), columns=cols)
+    data_types = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2,
+                           cfg.NONGENE_FEATURE, cfg.NONGENE_FEATURE])
+    gene_features = np.array([True] * 9 + [False] * 2)
+    return (X_train_raw_df,
+            X_test_raw_df,
+            gene_features,
+            data_types)
+
+@pytest.mark.parametrize('standardize_columns', [[False, False, False],
+                                                 [True, True, True],
+                                                 [True, False, True]])
+@pytest.mark.parametrize('subset_mad_genes', [-1, 1, 2])
+def test_preprocessing(raw_data, standardize_columns, subset_mad_genes):
+    (X_train_raw_df,
+     X_test_raw_df,
+     gene_features,
+     data_types) = raw_data
+    X_train_df, X_test_df = tu.preprocess_multi_data(X_train_raw_df,
+                                                     X_test_raw_df,
+                                                     gene_features,
+                                                     data_types,
+                                                     standardize_columns,
+                                                     subset_mad_genes)
+    # make sure no samples were lost
+    assert X_train_df.shape[0] == X_train_raw_df.shape[0]
+    assert X_test_df.shape[0] == X_test_raw_df.shape[0]
+    # make sure no NaN values
+    assert X_train_df.isna().sum().sum() == 0
+    # make sure no non-gene features were lost, and make sure that
+    # each data type has the correct number of subset columns
+    if subset_mad_genes == -1:
+        # if no subsetting by MAD, number of features shouldn't change
+        assert (X_train_df.shape[1] == X_train_raw_df.shape[1])
+    else:
+        # if we do subset by MAD:
+        # total number of features = (number of data types * number of features to
+        # subset to) + number of non-gene features
+        assert (X_train_df.shape[1] ==
+                  (subset_mad_genes * (np.unique(data_types).shape[0] - 1)) +
+                  (np.count_nonzero(data_types == cfg.NONGENE_FEATURE)))
+    # make sure standardized columns were actually standardized
+    for ix, std_col in enumerate(standardize_columns):
+        if subset_mad_genes == -1:
+            data_types_filtered = data_types
+        else:
+            # here we have to reconstruct the data types of each column, since
+            # we filtered columns by MAD
+            #
+            # we can do that by adding each index in order * the number of
+            # top MAD columns we took, then adding the non-gene features to the end
+            data_types_filtered = sum(
+                [[ix] * subset_mad_genes
+                    for ix in range(np.unique(data_types).shape[0] - 1)],
+                []
+            )
+            data_types_filtered += [cfg.NONGENE_FEATURE] * np.count_nonzero(
+                    data_types == cfg.NONGENE_FEATURE)
+            data_types_filtered = np.array(data_types_filtered)
+        valid_cols = (data_types_filtered == ix)
+        if std_col:
+            # if a column is standardized, it should be ~standard normal, with
+            # values above and below 0
+            assert X_train_df.loc[:, valid_cols].values.flatten().min() < 0
+            assert X_train_df.loc[:, valid_cols].values.flatten().max() > 0
+        else:
+            # if a column is not standardized, we sampled from a uniform (0, 1)
+            # so it should only have values above 0
+            assert X_train_df.loc[:, valid_cols].values.flatten().min() > 0
+            assert X_train_df.loc[:, valid_cols].values.flatten().max() > 0
+
+