amr_engraftment_2019-04-16.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Engraftment of AMR genes\n",
    "\n",
    "1. What AMR genes crop up in placebo and FMT patients?\n",
    "2. What types of genes come up?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pathlib, itertools\n",
    "import pandas as pd, seaborn as sns, matplotlib.pyplot as plt, numpy as np\n",
    "import scipy.spatial.distance as dist, itertools\n",
    "import skbio.diversity as div, scipy.stats as stats, skbio.stats.ordination as ordination\n",
    "from matplotlib.lines import Line2D\n",
    "\n",
    "sns.set_style('white')\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get patient colors\n",
    "dd_pat_col = {'0044': (0.5490196078431373, 0.33725490196078434, 0.29411764705882354),\n",
    "              '0073': (0.7686274509803922, 0.611764705882353, 0.5803921568627451),\n",
    "              '001': (0.17254901960784313, 0.6274509803921569, 0.17254901960784313),\n",
    "              '004': (1.0, 0.4980392156862745, 0.054901960784313725),\n",
    "              '005': (1.0, 0.7333333333333333, 0.47058823529411764),\n",
    "              '006': (0.8392156862745098, 0.15294117647058825, 0.1568627450980392),\n",
    "              '007': (0.596078431372549, 0.8745098039215686, 0.5411764705882353),\n",
    "              '008': (0.5803921568627451, 0.403921568627451, 0.7411764705882353),\n",
    "              '009': (1.0, 0.596078431372549, 0.5882352941176471),\n",
    "              '010': (0.7725490196078432, 0.6901960784313725, 0.8352941176470589),\n",
    "              '011': (0.12156862745098039, 0.4666666666666667, 0.7058823529411765),\n",
    "              '012': (0.8901960784313725, 0.4666666666666667, 0.7607843137254902),\n",
    "              '013': (0.9686274509803922, 0.7137254901960784, 0.8235294117647058),\n",
    "              '014': (0.6823529411764706, 0.7803921568627451, 0.9098039215686274)}\n",
    "dd_pat_col_name = {'patient_' + str(k): v for k, v in dd_pat_col.items()}\n",
    "\n",
    "#get patient colors on treatment\n",
    "dd_pat_treat = {'0044': (0.5490196078431373, 0.33725490196078434, 0.29411764705882354),\n",
    "              '0073': (0.7686274509803922, 0.611764705882353, 0.5803921568627451),\n",
    "              '001': sns.color_palette()[0], '004': sns.color_palette()[1],\n",
    "              '005': sns.color_palette()[1], '006': sns.color_palette()[1],\n",
    "              '007': sns.color_palette()[0], '008': sns.color_palette()[0],\n",
    "              '009': sns.color_palette()[1], '010': sns.color_palette()[0],\n",
    "              '011': sns.color_palette()[0], '012': sns.color_palette()[1],\n",
    "              '013': sns.color_palette()[1], '014': sns.color_palette()[0]}\n",
    "dd_pat_treat_name = {'patient_' + str(k): v for k, v in dd_pat_treat.items()}\n",
    "\n",
    "#get patient dashes on responder\n",
    "dd_pat_dash = {'0044': (), '0073': (),\n",
    "               '001': (), '004': (), '005': (),\n",
    "               '006': (), '007': (3, 2), '008': (3, 2),\n",
    "               '009': (), '010': (), '011': (),\n",
    "               '012': (), '013': (), '014': (3, 2)}\n",
    "dd_pat_dash_name = {'patient_' + str(k): v for k, v in dd_pat_dash.items()}\n",
    "\n",
    "#make a dictionary of colors for sources\n",
    "dd_source_set = {'shared': (0.878, 0.878, 0.878),\n",
    "                 'patient': (0.909, 0.470, 0.470),\n",
    "                 'env': (0.933, 0.674, 0.349),\n",
    "                 'donor0044': (0.305, 0.749, 0.776),\n",
    "                 'donor0073': (0.643, 0.450, 0.850),\n",
    "                 'donor0044_0073': (0.376, 0.470, 0.803),\n",
    "                 'donor': (0.376, 0.470, 0.803)}\n",
    "\n",
    "dd_source_set_tint = {k: tuple([x + ((255 - 255*x) * 0.8)/255 for x in v]) for k, v in dd_source_set.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#read in metadata\n",
    "md = pd.read_csv('/Users/ndchu/Documents/uc_fmt/metadata/metadata_stool_dna_NV022018.tsv',\n",
    "                 sep='\\t', dtype={'patient': 'object',\n",
    "                                  'fmt': 'object',\n",
    "                                  'fmt_induction': 'object'})\n",
    "md.loc[:, 'patient_plt'] = 'patient_' + md['patient']\n",
    "\n",
    "#read in patient metadata\n",
    "md_pat = pd.read_csv('/Users/ndchu/Documents/uc_fmt/metadata/metadata_patients_2019-04-10.tsv',\n",
    "                     sep='\\t', dtype={'patient': 'object',\n",
    "                                      'fmt': 'object',\n",
    "                                      'fmt_induction': 'object'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#make a dictionary of patient to publication label\n",
    "pub_label_dict = md_pat.set_index('patient').to_dict()['label_pub']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#read in annotations\n",
    "db = '/Users/ndchu/Documents/uc_fmt/metagenomics/function/amr/cheng_amr_10.1.2018_update'\n",
    "ncbi_amr = pd.read_csv(db + '/ncbi_amr_db_mapping_nucleotide.csv')\n",
    "card_amr = pd.read_csv(db + '/card_amr_class_annotation.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#read in the file\n",
    "amr_sb = pd.read_csv('/Users/ndchu/Documents/uc_fmt/metagenomics/function/amr/sb_AG102018/amr_sb_all.tsv.gz',\n",
    "                     sep='\\t', compression='gzip')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#add metadata\n",
    "amr_sb = amr_sb.merge(md, left_on='sample', right_on='sample_id')\n",
    "\n",
    "#add antibiotic information\n",
    "amr_class = pd.concat([ncbi_amr[['genbank_prot_accession', \n",
    "                                 'antibiotic_class']].rename(columns={'genbank_prot_accession': 'prot_accession'}),\n",
    "                       card_amr[['Protein Accession', \n",
    "                                 'antibiotic_class']].rename(columns={'Protein Accession': 'prot_accession'}),\n",
    "                       ncbi_amr[['refseq_prot_accession', \n",
    "                                 'antibiotic_class']].rename(columns={'refseq_prot_accession': 'prot_accession'})])\n",
    "\n",
    "#get rid of strain\n",
    "amr_class.loc[:, 'prot_accession_nostr'] = amr_class['prot_accession'].str.split('.').str[0]\n",
    "tmp_dict = amr_class.set_index('prot_accession_nostr').to_dict()['antibiotic_class']\n",
    "\n",
    "#add abx information\n",
    "amr_sb.loc[:, 'prot_accession'] = amr_sb['Family'].str.split('|').str[1]\n",
    "tmp = []\n",
    "for x in amr_sb['prot_accession']:\n",
    "    test = x.rsplit('_', 1)[0]\n",
    "    if len(test) > 2:\n",
    "        tmp.append(test)\n",
    "    else:\n",
    "        tmp.append(x)\n",
    "amr_sb.loc[:, 'antibiotic_class'] = [tmp_dict[x] for x in tmp]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#add antibiotics class data\n",
    "amr_sb.loc[:, 'accession'] = amr_sb['Family'].str.split('|').str[1]\n",
    "\n",
    "ncbi_amr.loc[:, 'accession'] = ncbi_amr['refseq_prot_accession'].str.replace('.', '_', regex=False)\n",
    "card_amr.loc[:, 'accession'] = card_amr['Protein Accession'].str.replace('.', '_', regex=False)\n",
    "acc_cls_map = pd.concat([ncbi_amr[['accession', 'antibiotic_class']], \n",
    "                         card_amr[['accession', 'antibiotic_class']]])\n",
    "\n",
    "amr_sb = amr_sb.merge(acc_cls_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get abundance of each antibiotic class in each sample\n",
    "amr_cls = amr_sb[['sample', 'Count', 'antibiotic_class']].groupby(['sample', 'antibiotic_class']).sum()\n",
    "amr_cls = amr_cls.reset_index()\n",
    "amr_cls = amr_cls.merge(md, left_on='sample', right_on='sample_id')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What antibiotic clusters engraft"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "donor_amr_dict = {'0044': set(amr_sb.loc[amr_sb['patient'] == '0044']['Family']),\n",
    "                  '0073': set(amr_sb.loc[amr_sb['patient'] == '0073']['Family'])}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "amr_eng = []\n",
    "for patient, sub_df in amr_sb.groupby('patient'):\n",
    "    if patient in ['0044', '0073']:\n",
    "        continue\n",
    "    #get patient baseline amr genes\n",
    "    bl_sam = md.loc[(md['patient'] == patient) & \\\n",
    "                    (md['days_past_fmt'] < -5)]['sample_id'].tolist()\n",
    "    bl_amr = set(sub_df.loc[sub_df['sample_id'].isin(bl_sam)]['Family'])\n",
    "    \n",
    "    #get patient pfmt amr genes that occur at least 3 times\n",
    "    pfmt_sam = md.loc[(md['patient'] == patient) & \\\n",
    "                      (md['days_past_fmt'] > 0)]['sample_id'].tolist()\n",
    "    tmp = sub_df.loc[sub_df['sample_id'].isin(pfmt_sam)]\n",
    "    tmp = tmp.groupby('Family').size()\n",
    "    pfmt_amr = set(tmp.loc[tmp >= 3].index)\n",
    "    \n",
    "    if sub_df['treatment'].iloc[0] == 'placebo':\n",
    "        eng_amr = pfmt_amr - bl_amr\n",
    "        #add env amr\n",
    "        amr_eng.extend([[patient, x, 'env'] for x in eng_amr])\n",
    "        #add patient amr\n",
    "        pat_amr = pfmt_amr & bl_amr\n",
    "        amr_eng.extend([[patient, x, 'patient'] for x in pat_amr])\n",
    "    else:\n",
    "        donor = sub_df['fmt_induction'].iloc[0]\n",
    "        donor_amr = donor_amr_dict[donor]\n",
    "        #get engrafted donor amr\n",
    "        eng_amr = (donor_amr & pfmt_amr) - bl_amr\n",
    "        amr_eng.extend([[patient, x, 'donor'] for x in eng_amr])\n",
    "        #get shared amr\n",
    "        shared_amr = donor_amr & pfmt_amr & bl_amr\n",
    "        amr_eng.extend([[patient, x, 'shared'] for x in shared_amr])\n",
    "        #get all the unknowns\n",
    "        env_amr = pfmt_amr - donor_amr - bl_amr\n",
    "        amr_eng.extend([[patient, x, 'env'] for x in env_amr])\n",
    "        #get patient amr\n",
    "        pat_amr = (pfmt_amr - donor_amr) & bl_amr\n",
    "        amr_eng.extend([[patient, x, 'patient'] for x in pat_amr])\n",
    "\n",
    "amr_eng_df = pd.DataFrame(amr_eng, columns=['patient', 'amr_family', 'source'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1a241fe240>"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the frequencies of these sources overall for each patient\n",
    "amr_eng_cts_pp = amr_eng_df.groupby(['patient', 'source']).size()\n",
    "amr_eng_freq = amr_eng_cts_pp / amr_eng_df.groupby('patient').size()\n",
    "amr_eng_freq = amr_eng_freq.rename('amr_freq').reset_index()\n",
    "\n",
    "# plot for the FMT patients\n",
    "fmt_pats = set(md.loc[md['treatment'] == 'fmt']['patient'].unique())\n",
    "plt_df = amr_eng_freq.loc[amr_eng_freq['patient'].isin(fmt_pats)]\n",
    "sns.barplot(x='patient', y='amr_freq',\n",
    "            hue='source',\n",
    "            data=plt_df,\n",
    "            palette=dd_source_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot raw numbers as well\n",
    "amr_eng_cts_pp = amr_eng_cts_pp.rename('amr_ct')\n",
    "tmp = amr_eng_cts_pp.reset_index()\n",
    "\n",
    "plt_df = tmp.loc[tmp['patient'].isin(fmt_pats)]\n",
    "plt_df.loc[:, 'patient_plt'] = plt_df['patient'].apply(lambda x: pub_label_dict[x])\n",
    "\n",
    "fig = plt.figure(figsize = (5,2))\n",
    "\n",
    "ax = sns.barplot(x='patient_plt', y='amr_ct',\n",
    "                 hue='source', data=plt_df,\n",
    "                 palette=dd_source_set)\n",
    "\n",
    "ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
    "\n",
    "ax.set_ylabel('AMR gene count')\n",
    "ax.set_xlabel('')\n",
    "sns.despine()\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Longitudinal engraftment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "amr_source = []\n",
    "for patient, sub_df in amr_sb.groupby('patient'):\n",
    "    if patient in ['0044', '0073']:\n",
    "        continue\n",
    "    #get patient baseline amr genes\n",
    "    bl_sam = md.loc[(md['patient'] == patient) & \\\n",
    "                    (md['days_past_fmt'] < -5)]['sample_id'].tolist()\n",
    "    bl_amr = set(sub_df.loc[sub_df['sample_id'].isin(bl_sam)]['Family'])\n",
    "    \n",
    "    for sample, sub_sub_df in sub_df.groupby('sample_id'):\n",
    "        sam_amr = set(sub_sub_df['Family'])\n",
    "        \n",
    "        if sub_df['treatment'].iloc[0] == 'placebo':\n",
    "            pat_amr = sam_amr & bl_amr #patient amr\n",
    "            env_amr = sam_amr - bl_amr #env amr\n",
    "            \n",
    "            amr_source.extend([[patient, sample, \n",
    "                                x, 'patient'] for x in pat_amr])\n",
    "            amr_source.extend([[patient, sample, \n",
    "                                x, 'env'] for x in env_amr])\n",
    "        \n",
    "        elif sub_df['treatment'].iloc[0] == 'fmt':\n",
    "            donor = sub_df['fmt_induction'].iloc[0]\n",
    "            donor_amr = donor_amr_dict[donor]\n",
    "            \n",
    "            pat_amr = (sam_amr & bl_amr) - donor_amr #patient amr\n",
    "            don_amr = (donor_amr & sam_amr) - bl_amr #donor amr\n",
    "            shr_amr = donor_amr & sam_amr & bl_amr #shared amr\n",
    "            env_amr = sam_amr - donor_amr - bl_amr #env amr\n",
    "            \n",
    "            amr_source.extend([[patient, sample, \n",
    "                                x, 'patient'] for x in pat_amr])\n",
    "            amr_source.extend([[patient, sample, \n",
    "                                x, 'env'] for x in env_amr])\n",
    "            amr_source.extend([[patient, sample, \n",
    "                                x, 'donor'] for x in don_amr])\n",
    "            amr_source.extend([[patient, sample, \n",
    "                                x, 'shared'] for x in shr_amr])\n",
    "\n",
    "amr_source_df = pd.DataFrame(amr_source, \n",
    "                             columns=['patient', 'sample_id', \n",
    "                                      'Family', 'source'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add metadata\n",
    "amr_source_df = amr_source_df.merge(amr_sb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write to a file\n",
    "amr_source_df.to_csv('/Users/ndchu/Documents/uc_fmt/metagenomics/function/amr/sb_AG102018/amr_source_2019-04-16.tsv.gz',\n",
    "                     sep='\\t', index=False, compression='gzip')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read in a file\n",
    "amr_source_df = pd.read_csv('/Users/ndchu/Documents/uc_fmt/metagenomics/function/amr/sb_AG102018/amr_source_2019-04-16.tsv.gz',\n",
    "                           sep='\\t', compression='gzip', dtype={'patient': 'object'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get frequencies over time\n",
    "amr_source_freq = amr_source_df.groupby(['patient', 'sample_id', \n",
    "                                         'days_past_fmt', 'source']).size()\n",
    "amr_sample_sum = amr_source_df.groupby(['patient', 'sample_id', \n",
    "                                         'days_past_fmt']).size()\n",
    "\n",
    "amr_source_freq = amr_source_freq.rename('source_count').reset_index()\n",
    "amr_sample_sum = amr_sample_sum.rename('amr_count').reset_index()\n",
    "\n",
    "amr_source_freq = amr_source_freq.merge(amr_sample_sum)\n",
    "amr_source_freq.loc[:, 'source_freq'] = amr_source_freq['source_count'] / amr_source_freq['amr_count']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get rid of samples with less than 2 butyrate genes, since they are likely errors\n",
    "amr_source_freq = amr_source_freq.loc[amr_source_freq['amr_count'] > 1]\n",
    "\n",
    "#fill the zeroes\n",
    "amr_source_freq_ftab = amr_source_freq.pivot(index='sample_id',\n",
    "                                               columns='source',\n",
    "                                               values='source_freq')\n",
    "amr_source_freq_filled = pd.melt(amr_source_freq_ftab.reset_index(),\n",
    "                                  id_vars='sample_id',\n",
    "                                  var_name='source',\n",
    "                                  value_name='source_freq')\n",
    "#add metadata\n",
    "amr_source_freq_filled = amr_source_freq_filled.fillna(0)\n",
    "tmp = amr_source_freq[['sample_id', 'source', 'source_count']]\n",
    "amr_source_freq_filled = amr_source_freq_filled.merge(tmp, how='outer').fillna(0)\n",
    "tmp = amr_source_freq[['sample_id', 'amr_count']].drop_duplicates()\n",
    "amr_source_freq_filled = amr_source_freq_filled.merge(tmp)\n",
    "amr_source_freq_filled = amr_source_freq_filled.merge(md)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ndchu/programs/anaconda3/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x252 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot these amr sources\n",
    "#collapse all donor categories\n",
    "\n",
    "fig = plt.figure(figsize = (5,3.5))\n",
    "\n",
    "counter = 1\n",
    "for patient, sub_df in amr_source_freq.groupby('patient'):\n",
    "    if patient in ['001', '007', '008', '010', '011', '014']:\n",
    "        ax = fig.add_subplot(3,2,counter)\n",
    "        sns.lineplot(x='days_past_fmt', y='source_freq',\n",
    "                     hue='source', data=sub_df, palette=dd_source_set)\n",
    "        \n",
    "        ax.axvspan(-8, 0, alpha=0.05, color='red') #antibiotics\n",
    "        ax.axvspan(0, 84, alpha=0.05, color='green') #capsules\n",
    "        \n",
    "        ax.set_title(pub_label_dict[patient])\n",
    "        \n",
    "        ax.set_ylim(0, 1)\n",
    "        \n",
    "        if counter in [3]:\n",
    "            ax.set_ylabel('Fraction of\\nAMR genes')\n",
    "        else:\n",
    "            ax.set_ylabel('')\n",
    "        \n",
    "        if counter in [5, 6]:\n",
    "            ax.set_xlabel('Days after fecal transplant')\n",
    "        else:\n",
    "            ax.set_xlabel('')\n",
    "        \n",
    "        if counter != 4:\n",
    "            ax.legend_.remove()\n",
    "        else:\n",
    "            ax.legend(loc='center left', bbox_to_anchor=(1, 0.5),\n",
    "                     labels=['Patient', 'Shared',\n",
    "                             'Donor', 'Unknown']\n",
    "                     )\n",
    "    \n",
    "        counter += 1\n",
    "\n",
    "sns.despine()\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig('/Users/ndchu/Documents/uc_fmt/figures/amr_engfmt_ts_2019-05-04.png',\n",
    "            dpi=300)\n",
    "plt.savefig('/Users/ndchu/Documents/uc_fmt/figures/amr_engfmt_ts_2019-05-04.pdf',\n",
    "            dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 144x252 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot FMT N, E, and A\n",
    "\n",
    "fig = plt.figure(figsize = (2,3.5))\n",
    "\n",
    "counter = 1\n",
    "for patient, sub_df in amr_source_freq_filled.groupby('patient'):\n",
    "    if patient in ['001', '007', '011']:\n",
    "        ax = fig.add_subplot(3,1,counter)\n",
    "        sns.lineplot(x='days_past_fmt', y='source_freq',\n",
    "                     hue='source', data=sub_df, palette=dd_source_set)\n",
    "        \n",
    "        ax.axvspan(-8, 0, alpha=0.05, color='red') #antibiotics\n",
    "        ax.axvspan(0, 84, alpha=0.05, color='green') #capsules\n",
    "        \n",
    "        ax.set_title(pub_label_dict[patient])\n",
    "        \n",
    "        ax.set_ylim(0, 1)\n",
    "        \n",
    "        if counter in [2]:\n",
    "            ax.set_ylabel('Fraction of\\nAMR genes')\n",
    "        else:\n",
    "            ax.set_ylabel('')\n",
    "        \n",
    "        if counter in [3]:\n",
    "            ax.set_xlabel('Days after fecal transplant')\n",
    "        else:\n",
    "            ax.set_xlabel('')\n",
    "        \n",
    "        ax.legend_.remove()\n",
    "        \n",
    "        counter += 1\n",
    "\n",
    "sns.despine()\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig('/Users/ndchu/Documents/uc_fmt/figures/amr_engfmt_ts_NEA_2019-05-07.png',\n",
    "            dpi=300)\n",
    "plt.savefig('/Users/ndchu/Documents/uc_fmt/figures/amr_engfmt_ts_NEA_2019-05-07.pdf',\n",
    "            dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 144x252 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot FMT WPF\n",
    "\n",
    "fig = plt.figure(figsize = (2,3.5))\n",
    "\n",
    "counter = 1\n",
    "for patient, sub_df in amr_source_freq_filled.groupby('patient'):\n",
    "    if patient in ['008', '010', '014']:\n",
    "        ax = fig.add_subplot(3,1,counter)\n",
    "        sns.lineplot(x='days_past_fmt', y='source_freq',\n",
    "                     hue='source', data=sub_df, palette=dd_source_set)\n",
    "        \n",
    "        ax.axvspan(-8, 0, alpha=0.05, color='red') #antibiotics\n",
    "        ax.axvspan(0, 84, alpha=0.05, color='green') #capsules\n",
    "        \n",
    "        ax.set_title(pub_label_dict[patient])\n",
    "        \n",
    "        ax.set_ylim(0, 1)\n",
    "        \n",
    "        if counter in [2]:\n",
    "            ax.set_ylabel('Fraction of\\nAMR genes')\n",
    "        else:\n",
    "            ax.set_ylabel('')\n",
    "        \n",
    "        if counter in [3]:\n",
    "            ax.set_xlabel('Days after fecal transplant')\n",
    "        else:\n",
    "            ax.set_xlabel('')\n",
    "        \n",
    "        ax.legend_.remove()\n",
    "        \n",
    "        counter += 1\n",
    "\n",
    "sns.despine()\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig('/Users/ndchu/Documents/uc_fmt/figures/amr_engfmt_ts_WPF_2019-05-07.png',\n",
    "            dpi=300)\n",
    "plt.savefig('/Users/ndchu/Documents/uc_fmt/figures/amr_engfmt_ts_WPF_2019-05-07.pdf',\n",
    "            dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 540x324 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot these for placebo patients as well\n",
    "\n",
    "fig = plt.figure(figsize = (7.5,4.5))\n",
    "\n",
    "counter = 1\n",
    "for patient, sub_df in amr_source_freq.groupby('patient'):\n",
    "    if patient in ['004', '005', '006', '009', '013']:\n",
    "        ax = fig.add_subplot(3,2,counter)\n",
    "        sns.lineplot(x='days_past_fmt', y='source_freq',\n",
    "                     hue='source', data=sub_df, palette=dd_source_set)\n",
    "        \n",
    "        ax.axvspan(-8, 0, alpha=0.05, color='red') #antibiotics\n",
    "        ax.axvspan(0, 84, alpha=0.05, color='green') #capsules\n",
    "        \n",
    "        ax.set_title(pub_label_dict[patient])\n",
    "        \n",
    "        #ax.set_ylim(0, 0.9)\n",
    "        \n",
    "        if counter in [3]:\n",
    "            ax.set_ylabel('Fraction of AMR genes')\n",
    "        else:\n",
    "            ax.set_ylabel('')\n",
    "        \n",
    "        if counter in [5, 6]:\n",
    "            ax.set_xlabel('Days after fecal transplant')\n",
    "        else:\n",
    "            ax.set_xlabel('')\n",
    "        \n",
    "        if counter != 4:\n",
    "            ax.legend_.remove()\n",
    "        else:\n",
    "            ax.legend(loc='center left', bbox_to_anchor=(1, 0.5),\n",
    "                     #labels=['Patient', 'Shared',\n",
    "                     #        'Donor', 'Unknown']\n",
    "                     )\n",
    "    \n",
    "        counter += 1\n",
    "\n",
    "sns.despine()\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig('/Users/ndchu/Documents/uc_fmt/figures/amr_engplc_ts_2019-04-17.png',\n",
    "            dpi=300)\n",
    "plt.savefig('/Users/ndchu/Documents/uc_fmt/figures/amr_engplc_ts_2019-04-17.pdf',\n",
    "            dpi=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot cumulative abundance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#do this for cumulative abundance\n",
    "amr_source_cabun = amr_source_df.groupby(['patient', 'sample_id', \n",
    "                                         'days_past_fmt', 'source'])['Count'].sum()\n",
    "\n",
    "amr_source_cabun = amr_source_cabun.rename('cum_abun').reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ndchu/programs/anaconda3/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot these vf sources\n",
    "#collapse all donor categories\n",
    "\n",
    "fig = plt.figure(figsize = (6,5))\n",
    "\n",
    "counter = 1\n",
    "for patient, sub_df in amr_source_cabun.groupby('patient'):\n",
    "    if patient in ['001', '007', '008', '010', '011', '014']:\n",
    "        ax = fig.add_subplot(3,2,counter)\n",
    "        sns.lineplot(x='days_past_fmt', y='cum_abun',\n",
    "                     hue='source', data=sub_df, palette=dd_source_set)\n",
    "        \n",
    "        ax.axvspan(-8, 0, alpha=0.05, color='red') #antibiotics\n",
    "        ax.axvspan(0, 84, alpha=0.05, color='green') #capsules\n",
    "        \n",
    "        ax.set_title(pub_label_dict[patient])\n",
    "        \n",
    "        #ax.set_ylim(0, 1)\n",
    "        \n",
    "        if counter in [3]:\n",
    "            ax.set_ylabel('Abundance')\n",
    "        else:\n",
    "            ax.set_ylabel('')\n",
    "        \n",
    "        if counter in [5, 6]:\n",
    "            ax.set_xlabel('Days after fecal transplant')\n",
    "        else:\n",
    "            ax.set_xlabel('')\n",
    "        \n",
    "        if counter != 4:\n",
    "            ax.legend_.remove()\n",
    "        else:\n",
    "            ax.legend(loc='center left', bbox_to_anchor=(1, 0.5),\n",
    "                     labels=['Patient', 'Shared',\n",
    "                             'Donor', 'Unknown']\n",
    "                     )\n",
    "        \n",
    "        counter += 1\n",
    "\n",
    "sns.despine()\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig('/Users/ndchu/Documents/uc_fmt/figures/amr_cabun_source_ts_2019-05-06.png',\n",
    "            dpi=300)\n",
    "plt.savefig('/Users/ndchu/Documents/uc_fmt/figures/amr_cabun_source_ts_2019-05-06.pdf',\n",
    "            dpi=300)"
   ]
  },
  {
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}