Aggregate_Random_Forest_Results.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<b> This notebook aggregates the results from 100 iterations of random forest. </b>\n",
    "    \n",
    "Notebook by YB & RM\n",
    "\n",
    "Environment (Qiime2 2018.11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy as np, pandas as pd, qiime2 as q2, seaborn as sns\n",
    "import os\n",
    "from skbio import DistanceMatrix\n",
    "from scipy.spatial import procrustes\n",
    "from skbio.stats.ordination import pcoa\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Download the results from the N jobs that you run on barnacle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random-forests-results\n",
    "#Metabolomics\n",
    "#MP_Common/MP_Common\n",
    "#Metagenome\n",
    "#MG_gOTU\n",
    "#16S\n",
    "#Serum_Proteins\n",
    "#MB_Norm\n",
    "\n",
    "for i in range(1, 100):\n",
    "    visualization = os.path.join('MG_gOTU', str(i), 'accuracy_results.qzv')\n",
    "    data_path = os.path.join('MG_gOTU', str(i), 'results')\n",
    "    \n",
    "    artifact = q2.Visualization.load(visualization)\n",
    "    artifact.export_data(data_path)\n",
    "    \n",
    "    features = os.path.join('MG_gOTU', str(i), 'feature_importance.qza')\n",
    "    feat_path = os.path.join('MG_gOTU', str(i), 'features')\n",
    "    \n",
    "    artifact_feat = q2.Artifact.load(features)\n",
    "    artifact_feat.export_data(feat_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compile the results together from `predictive_accuracy.tsv`. Probably better to put them all in a single dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    results_path = os.path.join('MG_gOTU', str(i), 'results', 'predictive_accuracy.tsv')\n",
    "    \n",
    "    collation.append(pd.read_table(results_path))\n",
    "    \n",
    "collation = pd.concat(collation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "collation.rename(columns = {'Mean squared error' : 'Mean squared error_MGgOTU'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation['Data_type'] = 'MGgOTU'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation['Mean squared error_MGgOTU_scaled'] = ((collation['Mean squared error_MGgOTU']**(0.5))*9)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation_melt = collation.melt(id_vars = 'Data_type', value_vars = 'Mean squared error_MGgOTU_scaled')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random-forests-results\n",
    "#Metabolomics\n",
    "#MP_Common/MP_Common\n",
    "#Metagenome\n",
    "#16S\n",
    "#Serum_Proteins\n",
    "\n",
    "for i in range(1, 100):\n",
    "    visualization = os.path.join('Metagenome', str(i), 'accuracy_results.qzv')\n",
    "    data_path = os.path.join('Metagenome', str(i), 'results')\n",
    "    \n",
    "    artifact = q2.Visualization.load(visualization)\n",
    "    artifact.export_data(data_path)\n",
    "    \n",
    "    features = os.path.join('Metagenome', str(i), 'feature_importance.qza')\n",
    "    feat_path = os.path.join('Metagenome', str(i), 'features')\n",
    "    \n",
    "    artifact_feat = q2.Artifact.load(features)\n",
    "    artifact_feat.export_data(feat_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation2 = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    results_path = os.path.join('Metagenome', str(i), 'results', 'predictive_accuracy.tsv')\n",
    "    \n",
    "    collation2.append(pd.read_table(results_path))\n",
    "    \n",
    "collation2 = pd.concat(collation2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation2.rename(columns = {'Mean squared error' : 'Mean squared error_MG'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation2['Data_type'] = 'MG'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation2_melt = collation2.melt(id_vars = 'Data_type', value_vars = 'Mean squared error_MG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random-forests-results\n",
    "#Metabolomics\n",
    "#MP_Common/MP_Common\n",
    "#Metagenome\n",
    "#16S\n",
    "#Serum_Proteins\n",
    "\n",
    "for i in range(1, 100):\n",
    "    visualization = os.path.join('16S', str(i), 'accuracy_results.qzv')\n",
    "    data_path = os.path.join('16S', str(i), 'results')\n",
    "    \n",
    "    artifact = q2.Visualization.load(visualization)\n",
    "    artifact.export_data(data_path)\n",
    "    \n",
    "    features = os.path.join('16S', str(i), 'feature_importance.qza')\n",
    "    feat_path = os.path.join('16S', str(i), 'features')\n",
    "    \n",
    "    artifact_feat = q2.Artifact.load(features)\n",
    "    artifact_feat.export_data(feat_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation3 = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    results_path = os.path.join('16S', str(i), 'results', 'predictive_accuracy.tsv')\n",
    "    \n",
    "    collation3.append(pd.read_table(results_path))\n",
    "    \n",
    "collation3 = pd.concat(collation3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation3['Data_type'] = '16S'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation3.rename(columns = {'Mean squared error' : 'Mean squared error_16S'}, inplace=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation3_melt = collation3.melt(id_vars = 'Data_type', value_vars = 'Mean squared error_16S')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random-forests-results\n",
    "#Metabolomics\n",
    "#MP_Common/MP_Common\n",
    "#Metagenome\n",
    "#16S\n",
    "#Serum_Proteins\n",
    "\n",
    "for i in range(1, 100):\n",
    "    visualization = os.path.join('MP_Common/MP_Common', str(i), 'accuracy_results.qzv')\n",
    "    data_path = os.path.join('MP_Common/MP_Common', str(i), 'results')\n",
    "    \n",
    "    artifact = q2.Visualization.load(visualization)\n",
    "    artifact.export_data(data_path)\n",
    "    \n",
    "    features = os.path.join('MP_Common/MP_Common', str(i), 'feature_importance.qza')\n",
    "    feat_path = os.path.join('MP_Common/MP_Common', str(i), 'features')\n",
    "    \n",
    "    artifact_feat = q2.Artifact.load(features)\n",
    "    artifact_feat.export_data(feat_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation4 = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    results_path = os.path.join('MP_Common/MP_Common', str(i), 'results', 'predictive_accuracy.tsv')\n",
    "    \n",
    "    collation4.append(pd.read_table(results_path))\n",
    "    \n",
    "collation4 = pd.concat(collation4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation4['Data_type'] = 'Metaproteome'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation4.rename(columns = {'Mean squared error' : 'Mean squared error_Metaproteome'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "collation4_melt = collation4.melt(id_vars = 'Data_type', value_vars = 'Mean squared error_Metaproteome')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random-forests-results\n",
    "#Metabolomics\n",
    "#MP_Common/MP_Common\n",
    "#Metagenome\n",
    "#16S\n",
    "#Serum_Proteins\n",
    "\n",
    "for i in range(1, 100):\n",
    "    visualization = os.path.join('MB_Norm', str(i), 'accuracy_results.qzv')\n",
    "    data_path = os.path.join('MB_Norm', str(i), 'results')\n",
    "    \n",
    "    artifact = q2.Visualization.load(visualization)\n",
    "    artifact.export_data(data_path)\n",
    "    \n",
    "    features = os.path.join('MB_Norm', str(i), 'feature_importance.qza')\n",
    "    feat_path = os.path.join('MB_Norm', str(i), 'features')\n",
    "    \n",
    "    artifact_feat = q2.Artifact.load(features)\n",
    "    artifact_feat.export_data(feat_path)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation5 = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    results_path = os.path.join('MB_Norm', str(i), 'results', 'predictive_accuracy.tsv')\n",
    "    \n",
    "    collation5.append(pd.read_table(results_path))\n",
    "    \n",
    "collation5 = pd.concat(collation5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "collation5['Data_type'] = 'Metabolome'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation5.rename(columns = {'Mean squared error' : 'Mean squared error_Metabolome'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation5_melt = collation5.melt(id_vars = 'Data_type', value_vars = 'Mean squared error_Metabolome')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random-forests-results - this is the folder name for the combined results\n",
    "#random-forests-results\n",
    "#Metabolomics\n",
    "#MP_Common/MP_Common\n",
    "#Metagenome\n",
    "#16S\n",
    "#Serum_Proteins\n",
    "\n",
    "for i in range(1, 100):\n",
    "    visualization = os.path.join('allfeatgotu_Norm', str(i), 'accuracy_results.qzv')\n",
    "    data_path = os.path.join('allfeatgotu_Norm', str(i), 'results')\n",
    "    \n",
    "    artifact = q2.Visualization.load(visualization)\n",
    "    artifact.export_data(data_path)\n",
    "    \n",
    "    features = os.path.join('allfeatgotu_Norm', str(i), 'feature_importance.qza')\n",
    "    feat_path = os.path.join('allfeatgotu_Norm', str(i), 'features')\n",
    "    \n",
    "    artifact_feat = q2.Artifact.load(features)\n",
    "    artifact_feat.export_data(feat_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation6 = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    results_path = os.path.join('allfeatgotu_Norm', str(i), 'results', 'predictive_accuracy.tsv')\n",
    "    \n",
    "    collation6.append(pd.read_table(results_path))\n",
    "    \n",
    "collation6 = pd.concat(collation6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation6['Data_type'] = 'Combined Data'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation6.rename(columns = {'Mean squared error' : 'Mean squared error_Combined'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation6_melt = collation6.melt(id_vars = 'Data_type', value_vars = 'Mean squared error_Combined')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random-forests-results - this is the folder name for the combined results\n",
    "#random-forests-results\n",
    "#Metabolomics\n",
    "#MP_Common/MP_Common\n",
    "#Metagenome\n",
    "#16S\n",
    "#Serum_Proteins\n",
    "\n",
    "for i in range(1, 100):\n",
    "    visualization = os.path.join('Serum_Proteins', str(i), 'accuracy_results.qzv')\n",
    "    data_path = os.path.join('Serum_Proteins', str(i), 'results')\n",
    "    \n",
    "    artifact = q2.Visualization.load(visualization)\n",
    "    artifact.export_data(data_path)\n",
    "    \n",
    "    features = os.path.join('Serum_Proteins', str(i), 'feature_importance.qza')\n",
    "    feat_path = os.path.join('Serum_Proteins', str(i), 'features')\n",
    "    \n",
    "    artifact_feat = q2.Artifact.load(features)\n",
    "    artifact_feat.export_data(feat_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation7 = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    results_path = os.path.join('Serum_Proteins', str(i), 'results', 'predictive_accuracy.tsv')\n",
    "    \n",
    "    collation7.append(pd.read_table(results_path))\n",
    "    \n",
    "collation7 = pd.concat(collation7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation7['Data_type'] = 'Serum_Proteins'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation7.rename(columns = {'Mean squared error' : 'Mean squared error_Serum'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation7_melt = collation7.melt(id_vars = 'Data_type', value_vars = 'Mean squared error_Serum')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "merge_melt = pd.concat([collation_melt,collation2_melt,collation3_melt,collation4_melt,collation5_melt,collation6_melt,collation7_melt])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "order = ['Metabolome', 'Combined Data', 'Metaproteome', 'MG','MGgOTU', '16S', 'Serum_Proteins']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot the RF mean squared error values in each data type\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "#Set style to have grids\n",
    "sns.set_style(\"whitegrid\")\n",
    "\n",
    "fig, ax = plt.subplots(figsize = (6,8))\n",
    "#sns.violinplot(x = 'value', y = 'Description', inner = None, data = merge_melt,cut=0, palette = sns.hls_palette(20, l=.4, s=.8))\n",
    "sns.swarmplot(x = 'value', y = 'Data_type', order = order, alpha = 1, data = merge_melt, color = 'black', size=5)\n",
    "sns.boxplot(x = 'value', y = 'Data_type', order = order, data = merge_melt, palette = 'Reds')\n",
    "#fig.autofmt_xdate(rotation = 90, ha = 'center')\n",
    "plt.savefig('./DataType_RF_MeanSqurdError_boxplots_UC40_3.pdf', bbox_inches = 'tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Updates with second cohort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random-forests-results\n",
    "#IBD200/16S\n",
    "#IBD200/Combined2\n",
    "#IBD200/MBNorm\n",
    "#IBD200/MGgOTU\n",
    "#IBD200/MG\n",
    "#IBD200/MP\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/16S/%s' % str(i)):\n",
    "        visualization = os.path.join('IBD200/16S', str(i), 'accuracy_results.qzv')\n",
    "        data_path = os.path.join('IBD200/16S', str(i), 'results')\n",
    "\n",
    "        artifact = q2.Visualization.load(visualization)\n",
    "        artifact.export_data(data_path)\n",
    "        \n",
    "        features = os.path.join('IBD200/16S', str(i), 'feature_importance.qza')\n",
    "        feat_path = os.path.join('IBD200/16S', str(i), 'features')\n",
    "    \n",
    "        artifact_feat = q2.Artifact.load(features)\n",
    "        artifact_feat.export_data(feat_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:7: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  import sys\n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/16S/%s' % str(i)):\n",
    "        results_path = os.path.join('IBD200/16S/%s' % str(i), 'results', 'predictive_accuracy.tsv')\n",
    "\n",
    "        collation.append(pd.read_table(results_path))\n",
    "    \n",
    "collation = pd.concat(collation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation.rename(columns = {'Mean squared error' : 'Mean squared error_16S'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation['Data_type'] = '16S'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation_melt = collation.melt(id_vars = 'Data_type', value_vars = 'Mean squared error_16S')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random-forests-results\n",
    "#IBD200/16S\n",
    "#IBD200/Combined\n",
    "#IBD200/MB\n",
    "#IBD200/MGgOTU\n",
    "#IBD200/MP\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/Combined2/%s' % str(i)):\n",
    "        visualization = os.path.join('IBD200/Combined2', str(i), 'accuracy_results.qzv')\n",
    "        data_path = os.path.join('IBD200/Combined2', str(i), 'results')\n",
    "\n",
    "        artifact = q2.Visualization.load(visualization)\n",
    "        artifact.export_data(data_path)\n",
    "        \n",
    "        features = os.path.join('IBD200/Combined2', str(i), 'feature_importance.qza')\n",
    "        feat_path = os.path.join('IBD200/Combined2', str(i), 'features')\n",
    "    \n",
    "        artifact_feat = q2.Artifact.load(features)\n",
    "        artifact_feat.export_data(feat_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:7: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  import sys\n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/Combined2/%s' % str(i)):\n",
    "        results_path = os.path.join('IBD200/Combined2/%s' % str(i), 'results', 'predictive_accuracy.tsv')\n",
    "\n",
    "        collation.append(pd.read_table(results_path))\n",
    "    \n",
    "collation = pd.concat(collation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation.rename(columns = {'Mean squared error' : 'Mean squared error_Combined'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation['Data_type'] = 'Combined Data'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation_melt2 = collation.melt(id_vars = 'Data_type', value_vars = 'Mean squared error_Combined')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random-forests-results\n",
    "#IBD200/16S\n",
    "#IBD200/Combined\n",
    "#IBD200/MB\n",
    "#IBD200/MGgOTU\n",
    "#IBD200/MP\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/MBNorm/%s' % str(i)):\n",
    "        visualization = os.path.join('IBD200/MBNorm', str(i), 'accuracy_results.qzv')\n",
    "        data_path = os.path.join('IBD200/MBNorm', str(i), 'results')\n",
    "\n",
    "        artifact = q2.Visualization.load(visualization)\n",
    "        artifact.export_data(data_path)\n",
    "        \n",
    "        features = os.path.join('IBD200/MBNorm', str(i), 'feature_importance.qza')\n",
    "        feat_path = os.path.join('IBD200/MBNorm', str(i), 'features')\n",
    "    \n",
    "        artifact_feat = q2.Artifact.load(features)\n",
    "        artifact_feat.export_data(feat_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:7: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  import sys\n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/MBNorm/%s' % str(i)):\n",
    "        results_path = os.path.join('IBD200/MBNorm/%s' % str(i), 'results', 'predictive_accuracy.tsv')\n",
    "\n",
    "        collation.append(pd.read_table(results_path))\n",
    "    \n",
    "collation = pd.concat(collation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation.rename(columns = {'Mean squared error' : 'Mean squared error_MB'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation['Data_type'] = 'Metabolome'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation_melt3 = collation.melt(id_vars = 'Data_type', value_vars = 'Mean squared error_MB')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random-forests-results\n",
    "#IBD200/16S\n",
    "#IBD200/Combined\n",
    "#IBD200/MB\n",
    "#IBD200/MGgOTU\n",
    "#IBD200/MP\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/MGgOTU/%s' % str(i)):\n",
    "        visualization = os.path.join('IBD200/MGgOTU', str(i), 'accuracy_results.qzv')\n",
    "        data_path = os.path.join('IBD200/MGgOTU', str(i), 'results')\n",
    "\n",
    "        artifact = q2.Visualization.load(visualization)\n",
    "        artifact.export_data(data_path)\n",
    "        features = os.path.join('IBD200/MGgOTU', str(i), 'feature_importance.qza')\n",
    "        feat_path = os.path.join('IBD200/MGgOTU', str(i), 'features')\n",
    "    \n",
    "        artifact_feat = q2.Artifact.load(features)\n",
    "        artifact_feat.export_data(feat_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/MGgOTU/%s' % str(i)):\n",
    "        results_path = os.path.join('IBD200/MGgOTU/%s' % str(i), 'results', 'predictive_accuracy.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation.rename(columns = {'Mean squared error' : 'Mean squared error_MGgOTU'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation['Data_type'] = 'Metagenome'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation_melt4 = collation.melt(id_vars = 'Data_type', value_vars = 'Mean squared error_MGgOTU')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random-forests-results\n",
    "#IBD200/16S\n",
    "#IBD200/Combined\n",
    "#IBD200/MB\n",
    "#IBD200/MGgOTU\n",
    "#IBD200/MP\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/MP/%s' % str(i)):\n",
    "        visualization = os.path.join('IBD200/MP', str(i), 'accuracy_results.qzv')\n",
    "        data_path = os.path.join('IBD200/MP', str(i), 'results')\n",
    "\n",
    "        artifact = q2.Visualization.load(visualization)\n",
    "        artifact.export_data(data_path)\n",
    "        features = os.path.join('IBD200/MP', str(i), 'feature_importance.qza')\n",
    "        feat_path = os.path.join('IBD200/MP', str(i), 'features')\n",
    "    \n",
    "        artifact_feat = q2.Artifact.load(features)\n",
    "        artifact_feat.export_data(feat_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/MP/%s' % str(i)):\n",
    "        results_path = os.path.join('IBD200/MP/%s' % str(i), 'results', 'predictive_accuracy.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation.rename(columns = {'Mean squared error' : 'Mean squared error_MP'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation['Data_type'] = 'Metaproteome'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation_melt5 = collation.melt(id_vars = 'Data_type', value_vars = 'Mean squared error_MP')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random-forests-results\n",
    "#IBD200/16S\n",
    "#IBD200/Combined\n",
    "#IBD200/MB\n",
    "#IBD200/MGgOTU\n",
    "#IBD200/MP\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/MG/%s' % str(i)):\n",
    "        visualization = os.path.join('IBD200/MG', str(i), 'accuracy_results.qzv')\n",
    "        data_path = os.path.join('IBD200/MG', str(i), 'results')\n",
    "\n",
    "        artifact = q2.Visualization.load(visualization)\n",
    "        artifact.export_data(data_path)\n",
    "        features = os.path.join('IBD200/MG', str(i), 'feature_importance.qza')\n",
    "        feat_path = os.path.join('IBD200/MG', str(i), 'features')\n",
    "    \n",
    "        artifact_feat = q2.Artifact.load(features)\n",
    "        artifact_feat.export_data(feat_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/MG/%s' % str(i)):\n",
    "        results_path = os.path.join('IBD200/MG/%s' % str(i), 'results', 'predictive_accuracy.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation.rename(columns = {'Mean squared error' : 'Mean squared error_MG'}, inplace=True)\n",
    "collation['Data_type'] = 'Metagenome_ReadBased'\n",
    "\n",
    "#This version was done on a different scale (0-1 instead of 0-9 scale, so adjusting errors accordingly)\n",
    "collation['Mean squared error_MG_scaled'] = ((collation['Mean squared error_MG']**(0.5))*9)**2\n",
    "collation_melt6 = collation.melt(id_vars = 'Data_type', value_vars = 'Mean squared error_MG_scaled')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "merge_melt2 = pd.concat([collation_melt,collation_melt2,collation_melt3,collation_melt4,collation_melt5,collation_melt6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "order = ['16S', 'Combined Data', 'Metabolome', 'Metagenome','Metagenome_ReadBased', 'Metaproteome']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot the RF mean squared error values in each data type\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "#Set style to have grids\n",
    "sns.set_style(\"whitegrid\")\n",
    "\n",
    "fig, ax = plt.subplots(figsize = (6,8))\n",
    "#sns.violinplot(x = 'value', y = 'Description', inner = None, data = merge_melt,cut=0, palette = sns.hls_palette(20, l=.4, s=.8))\n",
    "sns.swarmplot(x = 'value', y = 'Data_type', order = order, alpha = 1, data = merge_melt2, color = 'black', size=5)\n",
    "sns.boxplot(x = 'value', y = 'Data_type', order = order, data = merge_melt2, palette = 'Reds')\n",
    "#fig.autofmt_xdate(rotation = 90, ha = 'center')\n",
    "plt.savefig('./DataType_RF_MeanSqurdError_IBD200UCsub_boxplots3.pdf', bbox_inches = 'tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Rename columns to align between studies\n",
    "merge_melt['Data_type'].replace({'MGgOTU':'Metagenome','Serum_Proteins':'Serum Proteome'},inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "merge_melt['Data_set'] = 'UC40'\n",
    "merge_melt2['Data_set'] = 'IBD200'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Data_type</th>\n",
       "      <th>variable</th>\n",
       "      <th>value</th>\n",
       "      <th>Data_set</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>6.453419</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>8.150869</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>6.616894</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>9.144380</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>5.558104</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>9.208654</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>13.571502</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>2.077243</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>7.762024</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>6.623045</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>7.292865</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>5.580549</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>8.000457</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>4.362200</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>5.765729</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>10.164191</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>2.237729</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>7.330827</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>5.816900</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>7.100778</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>7.027157</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>7.528843</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>3.512066</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>5.633657</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>6.062192</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>9.140891</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>4.594544</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>6.923414</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>10.156914</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU</td>\n",
       "      <td>7.715602</td>\n",
       "      <td>IBD200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>69</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>6.785450</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>70</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>2.952241</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>71</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>5.482315</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>72</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>8.246697</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>73</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>8.868350</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>74</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>7.500900</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>4.400880</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>76</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>3.797025</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>77</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>3.813775</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>78</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>2.476150</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>79</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>1.313325</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>80</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>1.475105</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>81</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>4.348949</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>82</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>2.104103</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>83</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>1.814284</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>84</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>6.414950</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>85</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>4.354575</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>86</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>6.848450</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>87</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>9.869048</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>88</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>4.537475</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>89</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>2.140498</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>90</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>2.577375</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>91</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>1.307900</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>92</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>7.610350</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>93</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>5.074262</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>94</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>8.194204</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>95</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>2.971282</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>96</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>1.860150</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>97</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>13.125403</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>98</th>\n",
       "      <td>Metagenome</td>\n",
       "      <td>Mean squared error_MGgOTU_scaled</td>\n",
       "      <td>4.755405</td>\n",
       "      <td>UC40</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>198 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     Data_type                          variable      value Data_set\n",
       "0   Metagenome         Mean squared error_MGgOTU   6.453419   IBD200\n",
       "1   Metagenome         Mean squared error_MGgOTU   8.150869   IBD200\n",
       "2   Metagenome         Mean squared error_MGgOTU   6.616894   IBD200\n",
       "3   Metagenome         Mean squared error_MGgOTU   9.144380   IBD200\n",
       "4   Metagenome         Mean squared error_MGgOTU   5.558104   IBD200\n",
       "5   Metagenome         Mean squared error_MGgOTU   9.208654   IBD200\n",
       "6   Metagenome         Mean squared error_MGgOTU  13.571502   IBD200\n",
       "7   Metagenome         Mean squared error_MGgOTU   2.077243   IBD200\n",
       "8   Metagenome         Mean squared error_MGgOTU   7.762024   IBD200\n",
       "9   Metagenome         Mean squared error_MGgOTU   6.623045   IBD200\n",
       "10  Metagenome         Mean squared error_MGgOTU   7.292865   IBD200\n",
       "11  Metagenome         Mean squared error_MGgOTU   5.580549   IBD200\n",
       "12  Metagenome         Mean squared error_MGgOTU   8.000457   IBD200\n",
       "13  Metagenome         Mean squared error_MGgOTU   4.362200   IBD200\n",
       "14  Metagenome         Mean squared error_MGgOTU   5.765729   IBD200\n",
       "15  Metagenome         Mean squared error_MGgOTU  10.164191   IBD200\n",
       "16  Metagenome         Mean squared error_MGgOTU   2.237729   IBD200\n",
       "17  Metagenome         Mean squared error_MGgOTU   7.330827   IBD200\n",
       "18  Metagenome         Mean squared error_MGgOTU   5.816900   IBD200\n",
       "19  Metagenome         Mean squared error_MGgOTU   7.100778   IBD200\n",
       "20  Metagenome         Mean squared error_MGgOTU   7.027157   IBD200\n",
       "21  Metagenome         Mean squared error_MGgOTU   7.528843   IBD200\n",
       "22  Metagenome         Mean squared error_MGgOTU   3.512066   IBD200\n",
       "23  Metagenome         Mean squared error_MGgOTU   5.633657   IBD200\n",
       "24  Metagenome         Mean squared error_MGgOTU   6.062192   IBD200\n",
       "25  Metagenome         Mean squared error_MGgOTU   9.140891   IBD200\n",
       "26  Metagenome         Mean squared error_MGgOTU   4.594544   IBD200\n",
       "27  Metagenome         Mean squared error_MGgOTU   6.923414   IBD200\n",
       "28  Metagenome         Mean squared error_MGgOTU  10.156914   IBD200\n",
       "29  Metagenome         Mean squared error_MGgOTU   7.715602   IBD200\n",
       "..         ...                               ...        ...      ...\n",
       "69  Metagenome  Mean squared error_MGgOTU_scaled   6.785450     UC40\n",
       "70  Metagenome  Mean squared error_MGgOTU_scaled   2.952241     UC40\n",
       "71  Metagenome  Mean squared error_MGgOTU_scaled   5.482315     UC40\n",
       "72  Metagenome  Mean squared error_MGgOTU_scaled   8.246697     UC40\n",
       "73  Metagenome  Mean squared error_MGgOTU_scaled   8.868350     UC40\n",
       "74  Metagenome  Mean squared error_MGgOTU_scaled   7.500900     UC40\n",
       "75  Metagenome  Mean squared error_MGgOTU_scaled   4.400880     UC40\n",
       "76  Metagenome  Mean squared error_MGgOTU_scaled   3.797025     UC40\n",
       "77  Metagenome  Mean squared error_MGgOTU_scaled   3.813775     UC40\n",
       "78  Metagenome  Mean squared error_MGgOTU_scaled   2.476150     UC40\n",
       "79  Metagenome  Mean squared error_MGgOTU_scaled   1.313325     UC40\n",
       "80  Metagenome  Mean squared error_MGgOTU_scaled   1.475105     UC40\n",
       "81  Metagenome  Mean squared error_MGgOTU_scaled   4.348949     UC40\n",
       "82  Metagenome  Mean squared error_MGgOTU_scaled   2.104103     UC40\n",
       "83  Metagenome  Mean squared error_MGgOTU_scaled   1.814284     UC40\n",
       "84  Metagenome  Mean squared error_MGgOTU_scaled   6.414950     UC40\n",
       "85  Metagenome  Mean squared error_MGgOTU_scaled   4.354575     UC40\n",
       "86  Metagenome  Mean squared error_MGgOTU_scaled   6.848450     UC40\n",
       "87  Metagenome  Mean squared error_MGgOTU_scaled   9.869048     UC40\n",
       "88  Metagenome  Mean squared error_MGgOTU_scaled   4.537475     UC40\n",
       "89  Metagenome  Mean squared error_MGgOTU_scaled   2.140498     UC40\n",
       "90  Metagenome  Mean squared error_MGgOTU_scaled   2.577375     UC40\n",
       "91  Metagenome  Mean squared error_MGgOTU_scaled   1.307900     UC40\n",
       "92  Metagenome  Mean squared error_MGgOTU_scaled   7.610350     UC40\n",
       "93  Metagenome  Mean squared error_MGgOTU_scaled   5.074262     UC40\n",
       "94  Metagenome  Mean squared error_MGgOTU_scaled   8.194204     UC40\n",
       "95  Metagenome  Mean squared error_MGgOTU_scaled   2.971282     UC40\n",
       "96  Metagenome  Mean squared error_MGgOTU_scaled   1.860150     UC40\n",
       "97  Metagenome  Mean squared error_MGgOTU_scaled  13.125403     UC40\n",
       "98  Metagenome  Mean squared error_MGgOTU_scaled   4.755405     UC40\n",
       "\n",
       "[198 rows x 4 columns]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "merge_melt_combined = pd.concat([merge_melt2,merge_melt])\n",
    "merge_melt_combined[merge_melt_combined['Data_type']=='Metagenome']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "order = ['Metaproteome','Combined Data','Metabolome',  'Metagenome', '16S','Serum Proteome']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot the RF mean squared error values in each data type\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "#Set style to have grids\n",
    "sns.set_style(\"whitegrid\")\n",
    "\n",
    "fig, ax = plt.subplots(figsize = (3,4))\n",
    "#sns.violinplot(x = 'value', y = 'Description', inner = None, data = merge_melt,cut=0, palette = sns.hls_palette(20, l=.4, s=.8))\n",
    "sns.swarmplot(x = 'value', y = 'Data_type', order = order, alpha = 1, data = merge_melt_combined, hue='Data_set',palette=['gray','blue'], size=1.5)\n",
    "sns.boxplot(x = 'value', y = 'Data_type', order = order, data = merge_melt_combined, palette = 'Reds')\n",
    "#fig.autofmt_xdate(rotation = 90, ha = 'center')\n",
    "plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
    "plt.savefig('./DataType_RF_MeanSqurdError_CombinedData_boxplots_gOTUs2.pdf', bbox_inches = 'tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Determine statistics on different datatypes:\n",
    "Combined = merge_melt_combined[merge_melt_combined['Data_type'] == 'Combined Data']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    198.000000\n",
       "mean       4.298612\n",
       "std        2.566092\n",
       "min        0.355161\n",
       "25%        2.279609\n",
       "50%        3.866287\n",
       "75%        5.899767\n",
       "max       13.575550\n",
       "Name: value, dtype: float64"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Combined['value'].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Determine statistics on different datatypes:\n",
    "Amp = merge_melt_combined[merge_melt_combined['Data_type'] == '16S']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    189.000000\n",
       "mean       5.877531\n",
       "std        2.986770\n",
       "min        0.943937\n",
       "25%        3.525311\n",
       "50%        5.379755\n",
       "75%        7.383990\n",
       "max       17.766824\n",
       "Name: value, dtype: float64"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Amp['value'].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Determine statistics on different datatypes:\n",
    "MP = merge_melt_combined[merge_melt_combined['Data_type'] == 'Metaproteome']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    191.000000\n",
       "mean       4.281190\n",
       "std        2.472172\n",
       "min        0.087874\n",
       "25%        2.428654\n",
       "50%        4.043434\n",
       "75%        5.577758\n",
       "max       14.233450\n",
       "Name: value, dtype: float64"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MP['value'].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Determine statistics on different datatypes:\n",
    "MB = merge_melt_combined[merge_melt_combined['Data_type'] == 'Metabolome']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    198.000000\n",
       "mean       5.270654\n",
       "std        3.044406\n",
       "min        0.417317\n",
       "25%        2.683058\n",
       "50%        4.945426\n",
       "75%        7.132563\n",
       "max       16.384633\n",
       "Name: value, dtype: float64"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MB['value'].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Determine statistics on different datatypes:\n",
    "MG = merge_melt_combined[merge_melt_combined['Data_type'] == 'Metagenome']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    198.000000\n",
       "mean       5.811956\n",
       "std        3.068117\n",
       "min        0.354225\n",
       "25%        3.671058\n",
       "50%        5.403479\n",
       "75%        7.482798\n",
       "max       16.899382\n",
       "Name: value, dtype: float64"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MG['value'].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Determine statistics on different datatypes:\n",
    "SP = merge_melt_combined[merge_melt_combined['Data_type'] == 'Serum Proteome']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    99.000000\n",
       "mean      7.106859\n",
       "std       3.054861\n",
       "min       0.816064\n",
       "25%       4.958853\n",
       "50%       7.049061\n",
       "75%       9.128139\n",
       "max      15.746500\n",
       "Name: value, dtype: float64"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SP['value'].describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aggregate RF feature importance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/MP/%s' % str(i)):\n",
    "        results_path = os.path.join('IBD200/MP/%s' % str(i), 'features', 'importance.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation2=collation.groupby('feature')['importance'].sum()\n",
    "MP100=collation2.to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3058: DtypeWarning: Columns (7,24) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  interactivity=interactivity, compiler=compiler, result=result)\n"
     ]
    }
   ],
   "source": [
    "protein_ann = pd.read_csv('../../IBD200/Metagenomics/MGDB/MGDB_Full_Protein_Annotations_AllProteomic_hits2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "MP100=MP100.merge(protein_ann,left_on='feature',right_on='queryID',how='left')\n",
    "MP100.index=MP100['queryID']\n",
    "MP100['Protein_and_Species']=MP100['Protein names'] + ' ' +MP100['Species']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "IBD200MP=MP100.groupby('Protein_and_Species')['importance'].sum().to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('MP_Common/MP_Common/%s' % str(i)):\n",
    "        results_path = os.path.join('MP_Common/MP_Common/%s' % str(i), 'features', 'importance.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation2=collation.groupby('feature')['importance'].sum()\n",
    "MP100=collation2.to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3058: DtypeWarning: Columns (10,22,31,36,37,44) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  interactivity=interactivity, compiler=compiler, result=result)\n"
     ]
    }
   ],
   "source": [
    "protein_meta = pd.read_csv('../../IBD200/Metagenomics/MGDB/UC40_Full_Protein_Annotations_All_hitsV2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "MP100=MP100.merge(protein_ann,left_on='feature',right_on='queryID',how='left')\n",
    "MP100.index=MP100['queryID']\n",
    "MP100['Protein_and_Species']=MP100['Protein names'] + ' ' +MP100['Species']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "UC40MP=MP100.groupby('Protein_and_Species')['importance'].sum().to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "UC40MP.rename(columns={'importance':'Importance (Cohort1)'},inplace=True)\n",
    "IBD200MP.rename(columns={'importance':'Importance (Cohort2)'},inplace=True)\n",
    "MPtab=UC40MP.merge(IBD200MP,left_index=True,right_index=True,how='outer')\n",
    "MPtab['Importance (Cohort1)'] = MPtab['Importance (Cohort1)']/MPtab['Importance (Cohort1)'].sum()\n",
    "MPtab['Importance (Cohort2)'] = MPtab['Importance (Cohort2)']/MPtab['Importance (Cohort2)'].sum()\n",
    "MPtab=MPtab.fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "MPtab['Importance Sum'] = MPtab['Importance (Cohort1)']+MPtab['Importance (Cohort2)']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "MPtab=MPtab.sort_values(by='Importance Sum',ascending=False)[0:100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "MPtab.to_csv('./Top100_MP_CombinedCohorts.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/MGgOTU/%s' % str(i)):\n",
    "        results_path = os.path.join('IBD200/MGgOTU/%s' % str(i), 'features', 'importance.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)\n",
    "collation2=collation.groupby('feature')['importance'].sum()\n",
    "IBD200=collation2.to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('MG_gOTU/%s' % str(i)):\n",
    "        results_path = os.path.join('MG_gOTU/%s' % str(i), 'features', 'importance.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)\n",
    "collation2=collation.groupby('feature')['importance'].sum()\n",
    "UC40=collation2.to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "UC40.rename(columns={'importance':'Importance (Cohort1)'},inplace=True)\n",
    "IBD200.rename(columns={'importance':'Importance (Cohort2)'},inplace=True)\n",
    "MGtab=UC40.merge(IBD200,left_index=True,right_index=True,how='outer')\n",
    "MGtab['Importance (Cohort1)'] = MGtab['Importance (Cohort1)']/MGtab['Importance (Cohort1)'].sum()\n",
    "MGtab['Importance (Cohort2)'] = MGtab['Importance (Cohort2)']/MGtab['Importance (Cohort2)'].sum()\n",
    "MGtab=MGtab.fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "MGtab['Importance Sum'] = MGtab['Importance (Cohort1)']+MGtab['Importance (Cohort2)']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "ann=pd.read_csv('../../IBD200/lineage.txt',sep='\\t',header=None)\n",
    "ann.rename(columns={0:'gOTU',1:'Lineage'},inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "MGtab=MGtab.merge(ann,left_index=True,right_on='gOTU',how='left')\n",
    "MGtab=MGtab.sort_values(by='Importance Sum',ascending=False)[0:100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "MGtab.index=MGtab['gOTU']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "MGtab.to_csv('./Top100_MG_CombinedCohorts.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/16S/%s' % str(i)):\n",
    "        results_path = os.path.join('IBD200/16S/%s' % str(i), 'features', 'importance.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)\n",
    "collation2=collation.groupby('feature')['importance'].sum()\n",
    "IBD200=collation2.to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('16S/%s' % str(i)):\n",
    "        results_path = os.path.join('16S/%s' % str(i), 'features', 'importance.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)\n",
    "collation2=collation.groupby('feature')['importance'].sum()\n",
    "UC40=collation2.to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "UC40.rename(columns={'importance':'Importance (Cohort1)'},inplace=True)\n",
    "IBD200.rename(columns={'importance':'Importance (Cohort2)'},inplace=True)\n",
    "amptab=UC40.merge(IBD200,left_index=True,right_index=True,how='outer')\n",
    "amptab['Importance (Cohort1)'] = amptab['Importance (Cohort1)']/amptab['Importance (Cohort1)'].sum()\n",
    "amptab['Importance (Cohort2)'] = amptab['Importance (Cohort2)']/amptab['Importance (Cohort2)'].sum()\n",
    "amptab=amptab.fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "amptab['Importance Sum'] = amptab['Importance (Cohort1)']+amptab['Importance (Cohort2)']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "ann=pd.read_csv('../Genomics/16S/Taxonomy_metadata.tsv',sep='\\t')\n",
    "ann2=pd.read_csv('./IBD20016STaxonomy.tsv/taxonomy.tsv',sep='\\t')\n",
    "\n",
    "anns=pd.concat([ann,ann2])\n",
    "amptab=amptab.merge(anns,left_index=True,right_on='Feature ID',how='left')\n",
    "amptab.index = amptab['Taxon']\n",
    "columns=['Importance (Cohort1)','Importance (Cohort2)','Importance Sum']\n",
    "amptab=amptab[columns]\n",
    "amptab=amptab.drop_duplicates()\n",
    "amptab=amptab.sort_values(by='Importance Sum',ascending=False)[0:100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "amptab.to_csv('./Top100_16S_CombinedCohorts.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/MBNorm/%s' % str(i)):\n",
    "        results_path = os.path.join('IBD200/MBNorm/%s' % str(i), 'features', 'importance.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)\n",
    "collation2=collation.groupby('feature')['importance'].sum()\n",
    "IBD200=collation2.to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('MB_Norm/%s' % str(i)):\n",
    "        results_path = os.path.join('MB_Norm/%s' % str(i), 'features', 'importance.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)\n",
    "collation2=collation.groupby('feature')['importance'].sum()\n",
    "UC40=collation2.to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "ann2=pd.read_csv('../Metabolomics/StandardizedMzMIne2020Rerun/UC40_MB_Annotations.txt',sep='\\t')\n",
    "ann=pd.read_csv('../../IBD200/Metabolomics/Qemistree_IDs.txt',sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "UC40=UC40.merge(ann2,left_index=True,right_on='rowID',how='left')\n",
    "IBD200=IBD200.merge(ann,left_index=True,right_on='rowid',how='left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "IBD200=IBD200.fillna('None')\n",
    "IBD200['LibraryMatch_and_DirectParent']=IBD200['ms2_library_match']+ ' '+IBD200['direct_parent']\n",
    "\n",
    "UC40=UC40.fillna('None')\n",
    "UC40['LibraryMatch_and_DirectParent']=UC40['ms2_library_match']+ ' '+UC40['direct_parent']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "UC40MB=UC40.groupby('LibraryMatch_and_DirectParent')['importance'].sum().to_frame().sort_values(by='importance',ascending=False)\n",
    "IBD200MB=IBD200.groupby('LibraryMatch_and_DirectParent')['importance'].sum().to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "UC40MB.rename(columns={'importance':'Importance (Cohort1)'},inplace=True)\n",
    "IBD200MB.rename(columns={'importance':'Importance (Cohort2)'},inplace=True)\n",
    "\n",
    "MBtab=UC40MB.merge(IBD200MB,left_on='LibraryMatch_and_DirectParent',right_on='LibraryMatch_and_DirectParent',how='outer')\n",
    "MBtab['Importance (Cohort1)'] = MBtab['Importance (Cohort1)']/MBtab['Importance (Cohort1)'].sum()\n",
    "MBtab['Importance (Cohort2)'] = MBtab['Importance (Cohort2)']/MBtab['Importance (Cohort2)'].sum()\n",
    "MBtab=MBtab.fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "MBtab['Importance Sum'] = MBtab['Importance (Cohort1)']+MBtab['Importance (Cohort2)']\n",
    "MBtab=MBtab.sort_values(by='Importance Sum',ascending=False)[0:100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "MBtab.to_csv('./Top100_MB_CombinedCohorts.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('Serum_Proteins/%s' % str(i)):\n",
    "        results_path = os.path.join('Serum_Proteins/%s' % str(i), 'features', 'importance.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)\n",
    "collation2=collation.groupby('feature')['importance'].sum()\n",
    "UC40=collation2.to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "ann = pd.read_csv('../Serum/All_uniprot_annotations.txt',sep='\\t')\n",
    "UC40=UC40.merge(ann,left_index=True,right_on='Entry')\n",
    "UC40.index=UC40['Entry']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "UC40[0:100].to_csv('./Top100_SerumProteins_UC1.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('IBD200/Combined2/%s' % str(i)):\n",
    "        results_path = os.path.join('IBD200/Combined2/%s' % str(i), 'features', 'importance.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)\n",
    "collation2=collation.groupby('feature')['importance'].sum()\n",
    "IBD200=collation2.to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:6: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "collation = []\n",
    "\n",
    "for i in range(1, 100):\n",
    "    if os.path.exists('allfeatgotu_Norm/%s' % str(i)):\n",
    "        results_path = os.path.join('allfeatgotu_Norm/%s' % str(i), 'features', 'importance.tsv')\n",
    "        collation.append(pd.read_table(results_path))\n",
    "collation = pd.concat(collation)\n",
    "collation2=collation.groupby('feature')['importance'].sum()\n",
    "UC40=collation2.to_frame().sort_values(by='importance',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3058: DtypeWarning: Columns (10,22,31,36,37,44) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  interactivity=interactivity, compiler=compiler, result=result)\n",
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3058: DtypeWarning: Columns (7,24) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  interactivity=interactivity, compiler=compiler, result=result)\n"
     ]
    }
   ],
   "source": [
    "#Annotate IBD200 top hits:\n",
    "UC_MB=pd.read_csv('../Metabolomics/StandardizedMzMIne2020Rerun/UC40_MB_Annotations.txt',sep='\\t',index_col='rowID')\n",
    "IBD_MB=pd.read_csv('../../IBD200/Metabolomics/Qemistree_IDs.txt',sep='\\t',index_col='rowid')\n",
    "UC_16S=pd.read_csv('../Genomics/16S/Taxonomy_metadata.tsv',sep='\\t',index_col='Feature ID')\n",
    "IBD_16S=pd.read_csv('./IBD20016STaxonomy.tsv/taxonomy.tsv',sep='\\t',index_col='Feature ID')\n",
    "UC_Serum= pd.read_csv('../Serum/All_uniprot_annotations.txt',sep='\\t',index_col='Entry')\n",
    "MG=pd.read_csv('../../IBD200/lineage.txt',sep='\\t',header=None)\n",
    "MG.rename(columns={0:'gOTU',1:'Lineage'},inplace=True)\n",
    "MG.index=MG['gOTU']\n",
    "UC_MP=pd.read_csv('../../IBD200/Metagenomics/MGDB/UC40_Full_Protein_Annotations_All_hitsV2.csv',index_col='queryID')\n",
    "IBD_MP=pd.read_csv('../../IBD200/Metagenomics/MGDB/MGDB_Full_Protein_Annotations_AllProteomic_hits2.csv',index_col='queryID')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "UC_MB['Feature']=UC_MB.index\n",
    "IBD_MB['Feature']=IBD_MB.index\n",
    "IBD_MB['Feature']=IBD_MB['Feature'].astype('str')\n",
    "UC_16S['Feature']=UC_16S.index\n",
    "IBD_16S['Feature']=IBD_16S.index\n",
    "UC_Serum['Feature']=UC_Serum.index\n",
    "MG['Feature']=MG.index\n",
    "UC_MP['Feature']=UC_MP.index\n",
    "IBD_MP['Feature']=IBD_MP.index\n",
    "UC_MP['Feature']= UC_MP['Feature']+'_MP'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>importance</th>\n",
       "      <th>csi_smiles</th>\n",
       "      <th>ms2_smiles</th>\n",
       "      <th>ms2_library_match</th>\n",
       "      <th>parent_mass</th>\n",
       "      <th>retention_time</th>\n",
       "      <th>table_number</th>\n",
       "      <th>smiles</th>\n",
       "      <th>structure_source</th>\n",
       "      <th>kingdom</th>\n",
       "      <th>superclass</th>\n",
       "      <th>class</th>\n",
       "      <th>subclass</th>\n",
       "      <th>direct_parent</th>\n",
       "      <th>Feature</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [importance, csi_smiles, ms2_smiles, ms2_library_match, parent_mass, retention_time, table_number, smiles, structure_source, kingdom, superclass, class, subclass, direct_parent, Feature]\n",
       "Index: []"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IBD200.merge(IBD_MB,left_index=True,right_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n",
      "of pandas will change to not sort by default.\n",
      "\n",
      "To accept the future behavior, pass 'sort=False'.\n",
      "\n",
      "To retain the current behavior and silence the warning, pass 'sort=True'.\n",
      "\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n",
      "/Users/rhmills/miniconda3/envs/qiime2-2019.7/lib/python3.6/site-packages/ipykernel_launcher.py:2: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n",
      "of pandas will change to not sort by default.\n",
      "\n",
      "To accept the future behavior, pass 'sort=False'.\n",
      "\n",
      "To retain the current behavior and silence the warning, pass 'sort=True'.\n",
      "\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "UC_Ann=pd.concat([UC_MB,UC_16S,UC_Serum,MG,UC_MP])\n",
    "IBD_Ann=pd.concat([IBD_MB,IBD_16S,MG,IBD_MP])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "UC100_ann=UC40[0:100].merge(UC_Ann,left_index=True,right_on='Feature',how='left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "UC100_ann.to_csv('./UC40_combined_top100_annotated.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "IBD100_ann=IBD200[0:100].merge(IBD_Ann,left_index=True,right_on='Feature',how='left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "IBD100_ann.to_csv('./IBD200_combined_top100_annotated.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "IBD100_ann=IBD200.merge(IBD_Ann,left_index=True,right_on='Feature',how='left')\n",
    "IBD100_ann.to_csv('./IBD200_combined_all_annotated.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}