3.filter-variants.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Processing annotated variant files\n",
    "\n",
    "The script will process each annotated variant file and output the processed file along with several summary statistics. The summary statistics include read depth summary, filtration summary, and functional location and effect of called variants.\n",
    "\n",
    "The pipeline is run once for all replcates and then again, with different filtering criteria, for the concatenated variant files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pandas.api.types import CategoricalDtype\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import plotnine as gg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "plt.style.use('seaborn-notebook')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'001-F0': '001-F0',\n",
       " '001-F5': '001-F5',\n",
       " '006-F0': '006-F0',\n",
       " '006-F5': '006-F5',\n",
       " '008-F0': '008-F0',\n",
       " '008-F5': '008-F5',\n",
       " '029-F0': '029-F0',\n",
       " '029-F5': '029-F5',\n",
       " '030-F0': '030-F0',\n",
       " '030-F5': '030-F5',\n",
       " '032-F0': '032-F0',\n",
       " '032-F5': '032-F5',\n",
       " '040-F0': '040-F0',\n",
       " '040-F5': '040-F5',\n",
       " '018-F0': '008-M1-F0',\n",
       " '018-F5': '008-M1-F5',\n",
       " '019-F0': '008-M2-F0',\n",
       " '019-F5': '008-M2-F5',\n",
       " '004-primary': '004-M',\n",
       " '004-F0': '004-M-F0',\n",
       " '004-F5': '004-M-F5',\n",
       " '005-primary': '005-M',\n",
       " '005-F0': '005-M-F0',\n",
       " '005-F5': '005-M-F5',\n",
       " 'KS25': '008-ORTH-M',\n",
       " 'KS26': '008-ORTH',\n",
       " 'KS27': '048-F0',\n",
       " 'KS28': '048-F5',\n",
       " 'KS29': '048-M1-F0',\n",
       " 'KS30': '048-M1-F5'}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load Phenotype Data\n",
    "file = 'pdx_phenotype.csv'\n",
    "pheno_df = pd.read_table(file, sep=',')\n",
    "\n",
    "# Create variable for ID updating\n",
    "id_updater = dict(zip([x[0] for x in pheno_df.read_id.str.split('_')],\n",
    "                      pheno_df.final_id))\n",
    "id_updater"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class VariantProcessor():\n",
    "    \"\"\"\n",
    "    Process summary statistics and filter variants for input file\n",
    "    \n",
    "    Usage:\n",
    "            variant_object = VariantProcessor(<filename>)\n",
    "\n",
    "    Methods act on annotated variant dataframes\n",
    "    \n",
    "    Filter variants based on low and high read depth and minor allele frequency\n",
    "    Also output summary files including the functional location distribution (e.g. exon),\n",
    "    the read depth summary, and mutation classification (e.g. frameshift)\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, variant_file, id_updater, filter_min_depth=10, filter_max_depth=800,\n",
    "                 filter_common_maf=0.05):\n",
    "        \"\"\"\n",
    "        Initialize VariantProcessor() class\n",
    "        \n",
    "        Arguments:\n",
    "        variant_file - location of a variant file\n",
    "        id_updater - a dictionary mapping old to new sample ids\n",
    "        filter_min_depth - in processed file output, remove all variants with depth below\n",
    "        filter_max_depth - in processed file output, remove all variants with depth above\n",
    "        filter_common_maf - in processed file output, remove all variants with MAF above\n",
    "        \"\"\"\n",
    "        self.variant_file = variant_file\n",
    "        self.sample_name = os.path.basename(self.variant_file).split('.')[0]\n",
    "        self.final_id = id_updater[self.sample_name.split('_')[0]]\n",
    "        self.filter_min_depth = filter_min_depth\n",
    "        self.filter_max_depth = filter_max_depth\n",
    "        self.filter_common_maf = filter_common_maf\n",
    "        self.variant_df = pd.read_csv(self.variant_file)\n",
    "        self.variant_df = self.variant_df.assign(sample_name = self.sample_name,\n",
    "                                                 final_id = self.final_id)\n",
    "        self.all_variant_count = self.variant_df.shape[0]\n",
    "        \n",
    "    def _process_depth(self):\n",
    "        \"\"\"\n",
    "        Private method to extract read depth from each variant\n",
    "        \"\"\"\n",
    "        other_info_list = self.variant_df['Otherinfo'].str.split('\\t').tolist()\n",
    "        depth_info_df = pd.DataFrame(other_info_list, columns=['het', 'quality', 'depth'])\n",
    "        self.variant_df.index = depth_info_df.index\n",
    "        self.variant_df = pd.concat([self.variant_df, depth_info_df], axis=1)\n",
    "    \n",
    "    def filter_depth(self):\n",
    "        \"\"\"\n",
    "        Method to remove variants with low and high depth beyond initialized threshold\n",
    "\n",
    "        Also stores the resulting variant file following the specific filtration step\n",
    "        \"\"\"\n",
    "        # Filter min depth\n",
    "        self._process_depth()\n",
    "        self.variant_df = (\n",
    "            self.variant_df[self.variant_df['depth'].astype(int) >= self.filter_min_depth]\n",
    "            )\n",
    "        self.filter_min_depth_count = self.variant_df.shape[0]\n",
    "        \n",
    "        # Which variants are filtered by max depth?\n",
    "        self.filtered_max_variants = (\n",
    "            self.variant_df[self.variant_df['depth'].astype(int) > self.filter_max_depth]\n",
    "            )\n",
    "        self.filtered_max_variants = self.filtered_max_variants.assign(sample_id=self.final_id)\n",
    "    \n",
    "        # Filter max depth\n",
    "        self.variant_df = (\n",
    "            self.variant_df[self.variant_df['depth'].astype(int) <= self.filter_max_depth]\n",
    "            )\n",
    "        self.filter_max_depth_count = self.variant_df.shape[0]\n",
    "        \n",
    "    def filter_common_variation(self):\n",
    "        \"\"\"\n",
    "        Method to remove common variants based on minor allele frequency.\n",
    "\n",
    "        First separates the variant file between known and unknown MAF,then removes variants\n",
    "        that are greater than the theshold MAF. The final variant file includes variants with\n",
    "        less than common MAF plus all unknown MAFs.\n",
    "        \n",
    "        Also stores the number of unknown variants and the number of common variants filtered.\n",
    "        \"\"\"\n",
    "        # Filter common variation\n",
    "        unknown_freq_df = self.variant_df.query('gnomAD_exome_ALL == \".\"')\n",
    "        other_freq_df = self.variant_df.query('gnomAD_exome_ALL != \".\"')\n",
    "        self.unknown_maf_count = unknown_freq_df.shape[0]\n",
    "       \n",
    "        # Filter common variants\n",
    "        other_freq_df = other_freq_df[other_freq_df['gnomAD_exome_ALL'].astype(float) <= self.filter_common_maf]\n",
    "        self.variant_df = pd.concat([other_freq_df, unknown_freq_df], axis=0)\n",
    "        self.filter_common_var_count = self.variant_df.shape[0]\n",
    "        \n",
    "    def plot_depth(self, bins=100):\n",
    "        \"\"\"\n",
    "        Method to plot a histogram of variant depths\n",
    "        \n",
    "        Arguments:\n",
    "        bins - how many bins to draw in the seaborn distplot\n",
    "        \"\"\"\n",
    "        sns.set(font_scale=1.5)\n",
    "        sns.set_style('whitegrid')\n",
    "        g = sns.distplot(self.variant_df['depth'].astype(float), bins=bins)\n",
    "        g.set_title('Read Depth Distribution for {}'.format(self.final_id))\n",
    "    \n",
    "    def get_summary_statistics(self):\n",
    "        \"\"\"\n",
    "        Method to summarize processed variant files\n",
    "        \n",
    "        Returns functional, mutational, read depth, and cosmic counts.\n",
    "        Also stores log10 mutation count for processed variant file and file with all cosmic variants\n",
    "        \"\"\"\n",
    "        # Get log 10 total mutation count\n",
    "        self.log_mut_count = np.log10(self.variant_df.shape[0])\n",
    "\n",
    "        # Get the number of variants stratified by functional location of variant\n",
    "        # E.g. Exon, Intron, 5'UTR, etc.\n",
    "        self.functional_counts = pd.DataFrame(self.variant_df['Func.refGene'].value_counts())\n",
    "        self.functional_counts.columns = [self.sample_name]\n",
    "        \n",
    "        # Get the number of variants stratified by exonic functional outcome of variant\n",
    "        # E.g. Silent, Nonsense, Missense, etc.\n",
    "        self.mutational_class_counts = (\n",
    "            pd.DataFrame(self.variant_df['ExonicFunc.refGene'].value_counts())\n",
    "            )\n",
    "        self.mutational_class_counts.columns = [self.sample_name]\n",
    "        \n",
    "        # Get number of COSMIC curated events\n",
    "        self.cosmic_variants = self.variant_df[self.variant_df['cosmic70'] != '.']\n",
    "        self.cosmic_variants = self.cosmic_variants.assign(sample_name = self.sample_name,\n",
    "                                                           final_id = self.final_id)\n",
    "        self.cosmic_variant_counts = self.cosmic_variants.shape[0]\n",
    "        \n",
    "        # Get depth summary\n",
    "        self.depth_summary = pd.DataFrame(self.variant_df['depth'].astype(int).describe())\n",
    "        self.depth_summary.columns = [self.sample_name]\n",
    "        \n",
    "        return self.functional_counts, self.mutational_class_counts, self.depth_summary\n",
    "\n",
    "    def curate_filter_info(self):\n",
    "        \"\"\"\n",
    "        Method to extract internal processed data\n",
    "        \"\"\"\n",
    "        filter_list = [\n",
    "            self.sample_name, self.final_id, self.all_variant_count,\n",
    "            self.filter_min_depth_count, self.filter_max_depth_count,\n",
    "            self.filter_common_var_count, self.log_mut_count,\n",
    "            self.cosmic_variant_counts, self.unknown_maf_count\n",
    "        ]\n",
    "        return filter_list\n",
    "    \n",
    "    def output_processed_data(self, out_dir, cosmic_file=False, replicates=False):\n",
    "        \"\"\"\n",
    "        Method to write all processed variants to file (final variants to analyze downstream)\n",
    "        \n",
    "        Arguments:\n",
    "        outdir - directory of where the file should be written\n",
    "        cosmic_file - boolean if file written is the cosmic variants. Will not write both files\n",
    "        \"\"\"\n",
    "        if cosmic_file:\n",
    "            \n",
    "            out_file = os.path.join(out_dir,\n",
    "                                    '{}_cosmic_variants.tsv.bz2'.format(self.final_id))\n",
    "            self.cosmic_variants.to_csv(out_file, sep='\\t', compression='bz2')\n",
    "        else:\n",
    "            if replicates:\n",
    "                output_id = self.sample_name.replace(self.sample_name.split('_')[0], self.final_id)\n",
    "            else:\n",
    "                output_id = self.final_id\n",
    "            out_file = os.path.join(out_dir,\n",
    "                                    '{}_processed_variants.tsv.bz2'.format(output_id))\n",
    "            self.variant_df.to_csv(out_file, sep='\\t', compression='bz2')\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Process Replicates - Four Technical Replicates per Sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "filter_common_maf = 0.05\n",
    "replicate_filter_min_depth_count = 10\n",
    "replicate_filter_max_depth_count = 800"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/gway/anaconda3/envs/pdx-exomeseq-analysis/lib/python3.6/site-packages/IPython/core/interactiveshell.py:2901: DtypeWarning: Columns (0) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  if self.run_code(code, result):\n"
     ]
    }
   ],
   "source": [
    "# Process variant results\n",
    "variant_file_path = os.path.join('results', 'annotated_vcfs')\n",
    "processed_file_path = os.path.join('results', 'processed_vcfs')\n",
    "cosmic_file_path = os.path.join('results', 'cosmic_vcfs')\n",
    "\n",
    "filter_info_all = []\n",
    "functional_counts_all = []\n",
    "mutational_counts_all = []\n",
    "depth_summary_all = []\n",
    "filtered_max_variants = []\n",
    "\n",
    "for variant_file in os.listdir(variant_file_path):\n",
    "    full_variant_file = os.path.join(variant_file_path, variant_file)\n",
    "\n",
    "    variant_info = VariantProcessor(variant_file=full_variant_file,\n",
    "                                    id_updater=id_updater,\n",
    "                                    filter_min_depth=replicate_filter_min_depth_count,\n",
    "                                    filter_max_depth=replicate_filter_max_depth_count,\n",
    "                                    filter_common_maf=filter_common_maf)\n",
    "\n",
    "    variant_info.filter_common_variation()\n",
    "    variant_info.filter_depth()\n",
    "\n",
    "    func_count, mut_count, depth_summary = variant_info.get_summary_statistics()\n",
    "    filter_info_all.append(variant_info.curate_filter_info())\n",
    "    \n",
    "    functional_counts_all.append(func_count)\n",
    "    mutational_counts_all.append(mut_count)\n",
    "    depth_summary_all.append(depth_summary)\n",
    "    filtered_max_variants.append(variant_info.filtered_max_variants)\n",
    "    \n",
    "    # Note that these replicates are named by old sample name\n",
    "    fig_file = os.path.join('figures', 'read_depth', 'replicates',\n",
    "                            '{}_depth_distrib.pdf'.format(variant_info.sample_name))\n",
    "    variant_info.plot_depth()\n",
    "    plt.savefig(fig_file)\n",
    "    plt.close()\n",
    "    \n",
    "    # Save processed output file\n",
    "    variant_info.output_processed_data(out_dir=processed_file_path, replicates=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save summary statistics for the replicate data\n",
    "\n",
    "# Save read depth summary results\n",
    "depth_output_file = os.path.join('results', 'replicates_full_depth_summary.tsv')\n",
    "depth_df = pd.concat(depth_summary_all, axis=1).fillna(0).astype(int).T.sort_index()\n",
    "depth_df.to_csv(depth_output_file, sep='\\t')\n",
    "\n",
    "# Save mutation count summary results\n",
    "mut_count_output_file = os.path.join('results', 'replicates_full_mutation_count_summary.tsv')\n",
    "mutational_counts_df = (\n",
    "    pd.concat(mutational_counts_all, axis=1).fillna(0).astype(int).T.sort_index()\n",
    "    )\n",
    "mutational_counts_df.to_csv(mut_count_output_file, sep='\\t')\n",
    "\n",
    "# Save functional genomics summary results\n",
    "func_count_output_file = os.path.join('results', 'replicates_full_functional_count_summary.tsv')\n",
    "functional_counts_df = (\n",
    "    pd.concat(functional_counts_all, axis=1).fillna(0).astype(int).T.sort_index()\n",
    "    )\n",
    "functional_counts_df.to_csv(func_count_output_file, sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "032-F5        7\n",
       "006-F5        6\n",
       "032-F0        6\n",
       "006-F0        5\n",
       "048-F0        5\n",
       "048-M1-F0     5\n",
       "008-M2-F0     4\n",
       "008-F0        4\n",
       "005-M         4\n",
       "001-F0        4\n",
       "008-M2-F5     4\n",
       "008-M1-F5     4\n",
       "048-F5        4\n",
       "048-M1-F5     4\n",
       "008-ORTH-M    4\n",
       "005-M-F0      4\n",
       "030-F5        4\n",
       "030-F0        4\n",
       "005-M-F5      3\n",
       "001-F5        3\n",
       "008-M1-F0     3\n",
       "008-ORTH      3\n",
       "040-F0        3\n",
       "008-F5        2\n",
       "040-F5        1\n",
       "004-M         1\n",
       "029-F5        1\n",
       "Name: sample_id, dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filtered_max_variants_df = pd.concat(filtered_max_variants)\n",
    "filtered_max_variants_df.sample_id.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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>Func.refGene</th>\n",
       "      <th>intergenic</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Chr</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>GL000220.1</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MT</th>\n",
       "      <td>92</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Func.refGene  intergenic\n",
       "Chr                     \n",
       "GL000220.1            10\n",
       "MT                    92"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Where are the max filtered variants\n",
    "pd.crosstab(filtered_max_variants_df.Chr, filtered_max_variants_df['Func.refGene'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Process functional filtration summary\n",
    "filter_count_output_file = os.path.join('results', 'replicates_filter_summary.tsv')\n",
    "filter_counts_df = pd.DataFrame(filter_info_all,\n",
    "                                columns=['sample_name', 'final_id', 'all_variant_count',\n",
    "                                         'filter_min_depth_count', 'filter_max_depth_count',\n",
    "                                         'filter_common_var_count','log_mut_count',\n",
    "                                         'COSMIC_count', 'unknown_maf']).sort_values(by='sample_name')\n",
    "\n",
    "filter_counts_df = (\n",
    "    filter_counts_df\n",
    "    .assign(base_sample = [x[0] for x in filter_counts_df['sample_name'].str.split('_')])\n",
    "    )\n",
    "filter_counts_df = (\n",
    "    filter_counts_df\n",
    "    .assign(lane = [x[2] for x in filter_counts_df['sample_name'].str.split('_')])\n",
    "    )\n",
    "\n",
    "filter_counts_df['log_mut_count'] = round(filter_counts_df['log_mut_count'], 2)\n",
    "\n",
    "filter_counts_df.to_csv(filter_count_output_file, sep='\\t', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>base_sample</th>\n",
       "      <th>lane</th>\n",
       "      <th>sample_name</th>\n",
       "      <th>final_id</th>\n",
       "      <th>log_mut_count</th>\n",
       "      <th>COSMIC_count</th>\n",
       "      <th>num_variants</th>\n",
       "      <th>filtration</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>317</th>\n",
       "      <td>030-F5</td>\n",
       "      <td>L002</td>\n",
       "      <td>030-F5_S6_L002_001</td>\n",
       "      <td>030-F5</td>\n",
       "      <td>3.34</td>\n",
       "      <td>33</td>\n",
       "      <td>filter_max_depth_count</td>\n",
       "      <td>2176</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>197</th>\n",
       "      <td>030-F5</td>\n",
       "      <td>L002</td>\n",
       "      <td>030-F5_S6_L002_001</td>\n",
       "      <td>030-F5</td>\n",
       "      <td>3.34</td>\n",
       "      <td>33</td>\n",
       "      <td>filter_min_depth_count</td>\n",
       "      <td>2177</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>319</th>\n",
       "      <td>030-F5</td>\n",
       "      <td>L004</td>\n",
       "      <td>030-F5_S6_L004_001</td>\n",
       "      <td>030-F5</td>\n",
       "      <td>3.35</td>\n",
       "      <td>21</td>\n",
       "      <td>filter_max_depth_count</td>\n",
       "      <td>2245</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    base_sample  lane         sample_name final_id  log_mut_count  \\\n",
       "317      030-F5  L002  030-F5_S6_L002_001   030-F5           3.34   \n",
       "197      030-F5  L002  030-F5_S6_L002_001   030-F5           3.34   \n",
       "319      030-F5  L004  030-F5_S6_L004_001   030-F5           3.35   \n",
       "\n",
       "     COSMIC_count            num_variants  filtration  \n",
       "317            33  filter_max_depth_count        2176  \n",
       "197            33  filter_min_depth_count        2177  \n",
       "319            21  filter_max_depth_count        2245  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filter_melt_df = (\n",
    "    filter_counts_df.melt(id_vars=['base_sample', 'lane', 'sample_name', 'final_id',\n",
    "                                   'log_mut_count', 'COSMIC_count'],\n",
    "                          value_vars=['all_variant_count', 'filter_min_depth_count',\n",
    "                                      'filter_max_depth_count', 'filter_common_var_count',\n",
    "                                      'unknown_maf'],\n",
    "                          var_name='num_variants', value_name='filtration')\n",
    "    )\n",
    "# Max and Min depth is nearly the same, filter max\n",
    "filter_melt_df = filter_melt_df.query('num_variants != \"unknown_maf\"')\n",
    "filter_melt_df = filter_melt_df.sort_values(by='filtration')\n",
    "filter_melt_df.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize summary statistics across replicates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f6247a52438>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<ggplot: (-9223363283098187965)>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reorder plotting variables\n",
    "filter_list = ['all_variant_count', 'filter_common_var_count',\n",
    "               'filter_min_depth_count', 'filter_max_depth_count']\n",
    "filter_list_cat = CategoricalDtype(categories=filter_list, ordered=True)\n",
    "filter_melt_df['num_variants_cat'] = (\n",
    "    filter_melt_df['num_variants'].astype(str).astype(filter_list_cat)\n",
    "    )\n",
    "\n",
    "p = (\n",
    "    gg.ggplot(filter_melt_df,\n",
    "              gg.aes(x='lane', y='filtration', fill='num_variants_cat')) +\n",
    "    gg.geom_bar(stat='identity', position='dodge') +\n",
    "    gg.facet_wrap('~ final_id') +\n",
    "    gg.scale_fill_manual(name='Filtration Step',\n",
    "                         values=['#1b9e77', '#d95f02', '#7570b3', '#e7298a'],\n",
    "                         labels=['All Variants',\n",
    "                                 'Common Variants',\n",
    "                                 'Depth (< {} reads)'.format(replicate_filter_min_depth_count),\n",
    "                                 'Depth (> {} reads)'.format(replicate_filter_max_depth_count)]) + \n",
    "    gg.xlab('Sample') +\n",
    "    gg.ylab('Final Number of Variants') +\n",
    "    gg.theme_bw() +\n",
    "    gg.theme(axis_text_x=gg.element_text(angle='90'),\n",
    "             axis_text=gg.element_text(size=8),\n",
    "             axis_title=gg.element_text(size=14))\n",
    "    )\n",
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/gway/anaconda3/envs/pdx-exomeseq-analysis/lib/python3.6/site-packages/plotnine/ggplot.py:688: UserWarning: Saving 6.5 x 5.5 in image.\n",
      "  from_inches(height, units), units))\n",
      "/home/gway/anaconda3/envs/pdx-exomeseq-analysis/lib/python3.6/site-packages/plotnine/ggplot.py:689: UserWarning: Filename: figures/replicates_filtration_results.pdf\n",
      "  warn('Filename: {}'.format(filename))\n"
     ]
    }
   ],
   "source": [
    "figure_file = os.path.join('figures', 'replicates_filtration_results.pdf')\n",
    "gg.ggsave(p, figure_file, height=5.5, width=6.5, dpi=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f624878b978>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<ggplot: (-9223363283097743279)>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = (\n",
    "    gg.ggplot(filter_counts_df,\n",
    "              gg.aes(x='lane', y='COSMIC_count', fill='filter_min_depth_count')) +\n",
    "    gg.geom_bar(stat='identity', position='dodge') +\n",
    "    gg.geom_text(gg.aes(y=10, label='log_mut_count'), size=5, colour='white') +\n",
    "    gg.scale_fill_gradient(low='blue', high='red', name='All Variants') + \n",
    "    gg.facet_wrap('~ final_id') +\n",
    "    gg.xlab('Lane') +\n",
    "    gg.ylab('Number of COSMIC Variants') +\n",
    "    gg.theme_bw() +\n",
    "    gg.theme(axis_text_x=gg.element_text(angle='90'),\n",
    "             axis_text=gg.element_text(size=8),\n",
    "             axis_title=gg.element_text(size=14))\n",
    "    )\n",
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/gway/anaconda3/envs/pdx-exomeseq-analysis/lib/python3.6/site-packages/plotnine/ggplot.py:688: UserWarning: Saving 6.5 x 5.5 in image.\n",
      "  from_inches(height, units), units))\n",
      "/home/gway/anaconda3/envs/pdx-exomeseq-analysis/lib/python3.6/site-packages/plotnine/ggplot.py:689: UserWarning: Filename: figures/replicates_cosmic_mutcount_results.pdf\n",
      "  warn('Filename: {}'.format(filename))\n"
     ]
    }
   ],
   "source": [
    "figure_file = os.path.join('figures', 'replicates_cosmic_mutcount_results.pdf')\n",
    "gg.ggsave(p, figure_file, height=5.5, width=6.5, dpi=500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Process Merged Files - These are the Final VCFs to Interpret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "filter_common_maf = 0.05\n",
    "merged_filter_min_depth_count = 15\n",
    "merged_filter_max_depth_count = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "results/annotated_merged_vcfs/019-F0.annotated.hg19_multianno.csv\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/gway/anaconda3/envs/pdx-exomeseq-analysis/lib/python3.6/site-packages/IPython/core/interactiveshell.py:2901: DtypeWarning: Columns (0) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  if self.run_code(code, result):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "results/annotated_merged_vcfs/KS30.annotated.hg19_multianno.csv\n",
      "results/annotated_vcfs_humanonly/004-primary.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/030-F0.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/001-F5.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/040-F5.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/004-F0.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/032-F5.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/008-F0.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/KS27.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/KS26.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/008-F5.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/019-F5.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/040-F0.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/KS29.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/005-F0.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/018-F5.annotated.hg19_multianno.csv\n",
      "results/annotated_vcfs_humanonly/005-primary.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/029-F0.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/029-F5.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/001-F0.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/004-F5.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/KS25.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/006-F0.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/KS28.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/032-F0.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/005-F5.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/018-F0.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/006-F5.annotated.hg19_multianno.csv\n",
      "results/annotated_merged_vcfs/030-F5.annotated.hg19_multianno.csv\n"
     ]
    }
   ],
   "source": [
    "# Process variant results\n",
    "variant_file_path = os.path.join('results', 'annotated_merged_vcfs')\n",
    "processed_file_path = os.path.join('results', 'processed_merged_vcfs')\n",
    "\n",
    "filter_info_all = []\n",
    "functional_counts_all = []\n",
    "mutational_counts_all = []\n",
    "depth_summary_all = []\n",
    "cosmic_dfs = []\n",
    "precosmic_filter_dfs = []\n",
    "\n",
    "for variant_file in os.listdir(variant_file_path):\n",
    "\n",
    "    if any(x in variant_file for x in ['004-primary', '005-primary']):\n",
    "        full_variant_file = os.path.join('results', 'annotated_vcfs_humanonly', variant_file)\n",
    "    else:\n",
    "        full_variant_file = os.path.join(variant_file_path, variant_file)\n",
    "    print(full_variant_file)\n",
    "\n",
    "    variant_info = VariantProcessor(variant_file=full_variant_file,\n",
    "                                    id_updater=id_updater,\n",
    "                                    filter_min_depth=merged_filter_min_depth_count,\n",
    "                                    filter_max_depth=merged_filter_max_depth_count,\n",
    "                                    filter_common_maf=filter_common_maf)\n",
    "\n",
    "    variant_info.filter_common_variation()\n",
    "    variant_info.filter_depth()\n",
    "\n",
    "    func_count, mut_count, depth_summary = variant_info.get_summary_statistics()\n",
    "    filter_info_all.append(variant_info.curate_filter_info())\n",
    "    \n",
    "    functional_counts_all.append(func_count)\n",
    "    mutational_counts_all.append(mut_count)\n",
    "    depth_summary_all.append(depth_summary)\n",
    "    \n",
    "    fig_file = os.path.join('figures', 'read_depth',\n",
    "                            '{}_depth_distrib.pdf'.format(variant_info.final_id))\n",
    "    variant_info.plot_depth()\n",
    "    plt.savefig(fig_file)\n",
    "    plt.close()\n",
    "    \n",
    "    # Save processed output file\n",
    "    variant_info.output_processed_data(out_dir=processed_file_path)\n",
    "    \n",
    "    # Build list of all cosmic variant dataframes\n",
    "    precosmic_filter_dfs.append(variant_info.variant_df)\n",
    "    cosmic_dfs.append(variant_info.cosmic_variants)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save read depth summary results\n",
    "depth_output_file = os.path.join('results', 'merged_full_depth_summary.tsv')\n",
    "depth_df = pd.concat(depth_summary_all, axis=1).fillna(0).astype(int).T.sort_index()\n",
    "depth_df.to_csv(depth_output_file, sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save mutation count summary results\n",
    "mut_count_output_file = os.path.join('results', 'merged_full_mutation_count_summary.tsv')\n",
    "mutational_counts_df = (\n",
    "    pd.concat(mutational_counts_all, axis=1).fillna(0).astype(int).T.sort_index()\n",
    "    )\n",
    "mutational_counts_df.to_csv(mut_count_output_file, sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save functional genomics summary results\n",
    "func_count_output_file = os.path.join('results', 'merged_full_functional_count_summary.tsv')\n",
    "functional_counts_df = (\n",
    "    pd.concat(functional_counts_all, axis=1).fillna(0).astype(int).T.sort_index()\n",
    "    )\n",
    "functional_counts_df.to_csv(func_count_output_file, sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "filter_count_output_file = os.path.join('results', 'merged_filter_summary.tsv')\n",
    "filter_counts_df = pd.DataFrame(filter_info_all,\n",
    "                                columns=['sample_name', 'final_id', 'all_variant_count',\n",
    "                                         'filter_min_depth_count', 'filter_max_depth_count',\n",
    "                                         'filter_common_var_count','log_mut_count',\n",
    "                                         'COSMIC_count', 'unknown_maf']).sort_values(by='sample_name')\n",
    "\n",
    "filter_counts_df['log_mut_count'] = round(filter_counts_df['log_mut_count'], 2)\n",
    "\n",
    "filter_counts_df.to_csv(filter_count_output_file, sep='\\t', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3116, 60)\n"
     ]
    }
   ],
   "source": [
    "# Generate a dataframe of all observed COSMIC variants\n",
    "cosmic_output_file = os.path.join('results', 'all_cosmic_variants.tsv')\n",
    "all_cosmic_dfs = pd.concat(cosmic_dfs, axis=0)\n",
    "print(all_cosmic_dfs.shape)\n",
    "all_cosmic_dfs.to_csv(cosmic_output_file, sep='\\t', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(680018, 60)\n"
     ]
    }
   ],
   "source": [
    "# Generate a dataframe of all variants pre-COSMIC filtering\n",
    "output_file = os.path.join('results', 'all_cosmic_prefiltered_variants.tsv')\n",
    "all_prefiltered_dfs = pd.concat(precosmic_filter_dfs, axis=0)\n",
    "print(all_prefiltered_dfs.shape)\n",
    "all_prefiltered_dfs.to_csv(output_file, sep='\\t', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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>sample_name</th>\n",
       "      <th>final_id</th>\n",
       "      <th>log_mut_count</th>\n",
       "      <th>COSMIC_count</th>\n",
       "      <th>num_variants</th>\n",
       "      <th>filtration</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>79</th>\n",
       "      <td>030-F5</td>\n",
       "      <td>030-F5</td>\n",
       "      <td>3.88</td>\n",
       "      <td>80</td>\n",
       "      <td>filter_max_depth_count</td>\n",
       "      <td>7660</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49</th>\n",
       "      <td>030-F5</td>\n",
       "      <td>030-F5</td>\n",
       "      <td>3.88</td>\n",
       "      <td>80</td>\n",
       "      <td>filter_min_depth_count</td>\n",
       "      <td>7661</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>82</th>\n",
       "      <td>040-F0</td>\n",
       "      <td>040-F0</td>\n",
       "      <td>4.08</td>\n",
       "      <td>78</td>\n",
       "      <td>filter_max_depth_count</td>\n",
       "      <td>12109</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>52</th>\n",
       "      <td>040-F0</td>\n",
       "      <td>040-F0</td>\n",
       "      <td>4.08</td>\n",
       "      <td>78</td>\n",
       "      <td>filter_min_depth_count</td>\n",
       "      <td>12110</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>78</th>\n",
       "      <td>030-F0</td>\n",
       "      <td>030-F0</td>\n",
       "      <td>4.12</td>\n",
       "      <td>81</td>\n",
       "      <td>filter_max_depth_count</td>\n",
       "      <td>13250</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sample_name final_id  log_mut_count  COSMIC_count            num_variants  \\\n",
       "79      030-F5   030-F5           3.88            80  filter_max_depth_count   \n",
       "49      030-F5   030-F5           3.88            80  filter_min_depth_count   \n",
       "82      040-F0   040-F0           4.08            78  filter_max_depth_count   \n",
       "52      040-F0   040-F0           4.08            78  filter_min_depth_count   \n",
       "78      030-F0   030-F0           4.12            81  filter_max_depth_count   \n",
       "\n",
       "    filtration  \n",
       "79        7660  \n",
       "49        7661  \n",
       "82       12109  \n",
       "52       12110  \n",
       "78       13250  "
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filter_melt_df = (\n",
    "    filter_counts_df.melt(id_vars=['sample_name', 'final_id',\n",
    "                                   'log_mut_count', 'COSMIC_count'],\n",
    "                          value_vars=['all_variant_count', 'filter_min_depth_count',\n",
    "                                      'filter_max_depth_count', 'filter_common_var_count',\n",
    "                                      'unknown_maf'],\n",
    "                          var_name='num_variants', value_name='filtration')\n",
    "    )\n",
    "\n",
    "# Max and Min depth is nearly the same, filter max\n",
    "filter_melt_df = filter_melt_df.query('num_variants != \"unknown_maf\"')\n",
    "filter_melt_df = filter_melt_df.sort_values(by='filtration')\n",
    "filter_melt_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize summary statistics for merged data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f623bca6a58>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<ggplot: (-9223363283094963782)>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reorder Plotting Variables\n",
    "filter_list = ['all_variant_count', 'filter_common_var_count',\n",
    "               'filter_min_depth_count', 'filter_max_depth_count']\n",
    "filter_list_cat = CategoricalDtype(categories=filter_list, ordered=True)\n",
    "filter_melt_df['num_variants_cat'] = (\n",
    "    filter_melt_df['num_variants'].astype(str).astype(filter_list_cat)\n",
    "    )\n",
    "\n",
    "p = (\n",
    "    gg.ggplot(filter_melt_df,\n",
    "              gg.aes(x='final_id', y='filtration', fill='num_variants_cat')) +\n",
    "    gg.geom_bar(stat='identity', position='dodge') +\n",
    "    gg.theme_bw() +\n",
    "    gg.scale_fill_manual(name='Filtration Step',\n",
    "                         values=['#1b9e77', '#d95f02', '#7570b3', '#e7298a'],\n",
    "                         labels=['All Variants',\n",
    "                                 'Common Variants',\n",
    "                                 'Depth (< {} reads)'.format(merged_filter_min_depth_count),\n",
    "                                 'Depth (> {} reads)'.format(merged_filter_max_depth_count)]) + \n",
    "    gg.xlab('Sample') +\n",
    "    gg.ylab('Final Number of Variants') +\n",
    "    gg.theme(axis_text_x=gg.element_text(angle='90'),\n",
    "             axis_text=gg.element_text(size=8),\n",
    "             axis_title=gg.element_text(size=14))\n",
    "    )\n",
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/gway/anaconda3/envs/pdx-exomeseq-analysis/lib/python3.6/site-packages/plotnine/ggplot.py:688: UserWarning: Saving 6.5 x 5.5 in image.\n",
      "  from_inches(height, units), units))\n",
      "/home/gway/anaconda3/envs/pdx-exomeseq-analysis/lib/python3.6/site-packages/plotnine/ggplot.py:689: UserWarning: Filename: figures/merged_filtration_results.pdf\n",
      "  warn('Filename: {}'.format(filename))\n"
     ]
    }
   ],
   "source": [
    "figure_file = os.path.join('figures', 'merged_filtration_results.pdf')\n",
    "gg.ggsave(p, figure_file, height=5.5, width=6.5, dpi=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f624e00d080>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<ggplot: (8753742382968)>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = (\n",
    "    gg.ggplot(filter_counts_df,\n",
    "              gg.aes(x='final_id', y='COSMIC_count', fill='filter_min_depth_count')) +\n",
    "    gg.geom_bar(stat='identity', position='dodge') +\n",
    "    # Note that the log mut count represents log10(total mutation count) in each sample\n",
    "    gg.geom_text(gg.aes(y=45, label='log_mut_count', angle=90), size=9, colour='white') +\n",
    "    gg.scale_fill_gradient(low='blue', high='red', name='All Variants') + \n",
    "    gg.xlab('Sample') +\n",
    "    gg.ylab('Number of COSMIC Variants') +\n",
    "    gg.theme_bw() +\n",
    "    gg.theme(axis_text_x=gg.element_text(angle='90'),\n",
    "             axis_text=gg.element_text(size=8),\n",
    "             axis_title=gg.element_text(size=14))\n",
    "    )\n",
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/gway/anaconda3/envs/pdx-exomeseq-analysis/lib/python3.6/site-packages/plotnine/ggplot.py:688: UserWarning: Saving 6.5 x 5.5 in image.\n",
      "  from_inches(height, units), units))\n",
      "/home/gway/anaconda3/envs/pdx-exomeseq-analysis/lib/python3.6/site-packages/plotnine/ggplot.py:689: UserWarning: Filename: figures/merged_cosmic_mutcount_results.pdf\n",
      "  warn('Filename: {}'.format(filename))\n"
     ]
    }
   ],
   "source": [
    "figure_file = os.path.join('figures', 'merged_cosmic_mutcount_results.pdf')\n",
    "gg.ggsave(p, figure_file, height=5.5, width=6.5, dpi=500)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:pdx-exomeseq-analysis]",
   "language": "python",
   "name": "conda-env-pdx-exomeseq-analysis-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}