Additional file 9 - Running MuTect on a dataset of 30 samples with the optimization of the LOD parameter¶
Fast and accurate mutation detection in whole genome sequences of multiple isogenic samples with IsoMut¶
O. Pipek, D. Ribli, J. Molnár, Á. Póti, M. Krzystanek, A. Bodor, G. E. Tusnády, Z. Szallasi, I. Csabai, and D. Szüts¶
MuTect somatic mutation calling pipeline with a tumor-normal pair and a Panel of Normal samples¶
- In depth discussion of the method used by MuTect can be found in the original article by Cibulskis et al. (http://www.nature.com/nbt/journal/v31/n3/full/nbt.2514.html).
- For a step-by-step description about the usage of the software, the guidelines of the following presentations were used: https://www.broadinstitute.org/gatk/guide/presentations?id=6007
- Other guides are also available here: https://www.broadinstitute.org/gatk/guide/
Details of the method:¶
- In the first step we used a tumor-normal pair and also many other normal samples (as the Panel of Normals) for SNV detection, as suggested by [https://www.broadinstitute.org/gatk/events/slides/1506/GATKwr8-S-3-Variant_calling_with_MuTect.pdf].
- As the default settings did not give sufficient results, the LOD parameter (which is related the quality of a mutation call) was tuned to decrease false positive rates.
Assessing the performance of the method:¶
- An ideal method would minimize false positives (all mutations in the control samples), while still maintaining high mutation rates in treated samples (even though these are not necessarily true positives!).
- These two values can to some extent describe the performance of a unique mutation detection method and can be used to also compare these. Also, by using these two values as reference, tunable parameters of any method can be optimized.
Loading modules¶
In [1]:
#load modules
import os
import subprocess
import time
import matplotlib
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import pandas as pd
#go to working directory
work_dir='/nagyvinyok/adat84/sotejedlik/ribli/dt40/method/gatk/mutect_pair_pon_wt_ko'
subprocess.call(['mkdir',work_dir])
os.chdir(work_dir)
Setting directories and paths¶
In [2]:
#gallus reference
galref="/home/ribli/input/index/gallus/complete/Gallus_gallus.Galgal4.74.dna.toplevel.fa"
input_dir='/nagyvinyok/adat83/sotejedlik/orsi/bam_all_links_methodpaper/'
output_dir=work_dir
Crating the file format necessary for running gatk¶
In [3]:
%%bash
java -jar /nagyvinyok/adat88/kozos/sotejedlik/usr/gatk/picard.jar \
CreateSequenceDictionary \
REFERENCE=/home/ribli/input/index/gallus/complete/Gallus_gallus.Galgal4.74.dna.toplevel.fa \
OUTPUT=/home/ribli/input/index/gallus/complete/Gallus_gallus.Galgal4.74.dna.toplevel.dict
Creating vcf files for each sample of the PoN¶
Defining a function to run the generation of vcf-s needed for PoN
Running the function
- It runs for around 12 hours per sample
In [5]:
def run_mutect_artif_detect(sample,input_dir,output_dir,ref_genome):
#input,output,log,scipt_file
sample_bam=input_dir+sample+'_RMdup_picard_realign.bam '
log=output_dir+'/'+sample+'.gatkVcf.log '
script_fname=sample+'gatk1'+'.sh'
#gatk command
cmd='time java -Xmx2g -jar /nagyvinyok/adat88/kozos/sotejedlik/usr/gatk/mutect-1.1.7.jar '
cmd+=' -T MuTect '
cmd+=' -R '+ ref_genome
cmd+=' -I:tumor '+ sample_bam
cmd+=' --artifact_detection_mode '
cmd+=' -vcf ' + sample + '.call_stats.vcf'
cmd+=' --coverage_file '+sample+'.coverage.wig.txt'
cmd+=' 2> '+ log
print cmd,'\n'
#write scriptfile
with open(script_fname,'w') as f:
f.write('#!/bin/bash\n')
f.write(cmd+'\n')
#submit script to sbatch
print subprocess.check_output(['sbatch','--mem','3000',script_fname],
stderr=subprocess.STDOUT),'\n'
#########################################################################
samples=['S01','S02','S03','S04','S05','S06','S07','S08',
'S09','S10','S11','S12','S13','S14','S15']
samples+=['S16','S17','S18','S19','S20','S21','S22','S23',
'S24','S25','S26','S27','S28','S29','S30']
for sample in samples:
run_mutect_artif_detect(sample,input_dir,output_dir,ref_genome=galref)
Checking for errors¶
In [14]:
%%bash
tail -n1 *Vcf.log
Combining vcf files into PoN¶
- a different PoN is used for the mutation detection of each sample
- running this in parallel on our system results in various errors:
- java i/o error
- malformed lines produced (that cause errors later when using them)
Defining function for the generation of PoN¶
The guidelines used described the PoN generation without using the --genotypemergeoption UNIQUIFY option. However, this resulted in the following error message:
- Duplicate sample names were discovered but no genotypemergeoption was supplied. To combine samples without merging specify --genotypemergeoption UNIQUIFY. Merging duplicate samples without specified priority is unsupported, but can be achieved by specifying --genotypemergeoption UNSORTED.
To overcome the issue, the --genotypemergeoption UNIQUIFY option was invoked.
In [ ]:
def run_mutect_cobine_into_pon(sample,samples,input_dir,ref_genome):
#input,output,log,scipt_file
output=sample+'_PoN.vcf'
log=sample+'.gatkCombine.log '
script_fname=sample+'_PoN_combine.sh'
#gatk command
cmd='time java -Xmx3g -jar /nagyvinyok/adat88/kozos/sotejedlik/usr/gatk/GenomeAnalysisTK.jar '
cmd+=' -T CombineVariants '
cmd+=' -R '+ ref_genome
for other_sample in samples:
if (other_sample != sample):
cmd+=' -V '+other_sample+'.call_stats.vcf'
cmd+=' -minN 2 '
cmd+=' --filteredrecordsmergetype KEEP_IF_ANY_UNFILTERED '
cmd+=' --filteredAreUncalled '
cmd+=' --genotypemergeoption UNIQUIFY '
cmd+=' -o ' + output
cmd+=' 2> '+ log
print cmd,'\n'
#write scriptfile
with open(script_fname,'w') as f:
f.write('#!/bin/bash\n')
f.write(cmd+'\n')
#submit script to sbatch
print subprocess.check_output(['sbatch','-C','jimgray83','--mem','3000',script_fname],
stderr=subprocess.STDOUT),'\n'
#########################################################################
samples=['S01','S02','S03','S04','S05','S06','S07','S08',
'S09','S10','S11','S12','S13','S14','S15']
samples+=['S16','S17','S18','S19','S20','S21','S22','S23',
'S24','S25','S26','S27','S28','S29','S30']
for sample in samples:
run_mutect_cobine_into_pon(sample,samples,input_dir,ref_genome=galref)
Checking for errors¶
In [5]:
%%bash
tail -n2 *Combine.log
Defining function for the execution of MuTect¶
In [ ]:
def run_mutect_w_pair_and_pon(sample,normal_sample,input_dir,ref_genome):
#input,output,log,scipt_file
normal_sample_bam=input_dir+normal_sample+'_RMdup_picard_realign.bam '
sample_bam=input_dir+sample+'_RMdup_picard_realign.bam '
pon_file= sample+'_PoN.vcf'
cov_file= sample+'_w_pair_and_PoN.coverage.wig.txt'
output= sample+'_w_pair_and_PoN.call_stats.txt'
log=sample+'.mutect_w_pair_and_PoN.log'
script_fname=sample+'_w_pair_and_PoN.sh'
#gatk command
cmd='time java -Xmx3g -jar /nagyvinyok/adat88/kozos/sotejedlik/usr/gatk/mutect-1.1.7.jar '
cmd+=' -T MuTect '
cmd+=' -R '+ ref_genome
cmd+=' -I:normal '+ normal_sample_bam
cmd+=' -I:tumor '+ sample_bam
cmd+=' --normal_panel '+ pon_file
cmd+=' --coverage_file ' + cov_file
cmd+=' -o ' + output
cmd+=' 2> '+ log
print cmd,'\n'
#write scriptfile
with open(script_fname,'w') as f:
f.write('#!/bin/bash\n')
f.write(cmd+'\n')
#submit script to sbatch
print subprocess.check_output(['sbatch','-C','jimgray83','--mem','3000',script_fname],
stderr=subprocess.STDOUT),'\n'
#########################################################################
samples= ['S01','S02','S03','S04','S05','S06','S07',
'S08','S09','S10','S11','S12','S13','S14','S15']
normal_samples=['S02','S01','S01','S01','S15','S15','S15',
'S15','S15','S15','S15','S15','S15','S15','S12']
samples+= ['S16','S17','S18','S19','S20','S21','S22','S23',
'S24','S25','S26','S27','S28','S29','S30']
normal_samples+= ['S18','S16','S16','S16','S21','S20','S20','S20',
'S20','S20','S20','S30','S20','S20','S27']
for sample,normal_sample in zip(samples,normal_samples):
run_mutect_w_pair_and_pon(sample,normal_sample,input_dir,ref_genome=galref)
Checking for errors¶
- For some samples, errors appeared in scaffolds, but as these parts of the genome are always excluded from our analysis, this does not present a real problem.
In [48]:
%%bash
tail -n2 *mutect_w_pair_and_PoN.log
Result:¶
Understanding the main statistics / fields¶
- Using the description here : http://gatkforums.broadinstitute.org/discussion/4231/what-is-the-output-of-mutect-and-how-should-i-interpret-it
Here are the definitions of some of the most prominent outputs in the call-stats file:¶
- contig: the contig location of this candidate
- position: the 1-based position of this candidate on the given contig
- ref_allele: the reference allele for this candidate
- alt_allele: the mutant (alternate) allele for this candidate
- tumor_name: name of the tumor as given on the command line, or extracted from the BAM
- normal_name: name of the normal as given on the command line, or extracted from the BAM
- score: for future development
- dbsnp_site: is this a dbsnp site as defined by the dbsnp bitmask supplied to the caller
- covered: was the site powered to detect a mutation (80% power for a 0.3 allelic fraction mutation)
- power: tumor_power * normal_power
- tumor_power: given the tumor sequencing depth, what is the power to detect a mutation at 0.3 allelic fraction
- normal_power: given the normal sequencing depth, what power did we have to detect (and reject) this as a germline variant
- total_pairs: total tumor and normal read depth which come from paired reads
- improper_pairs: number of reads which have abnormal pairing (orientation and distance)
- map_Q0_reads: total number of mapping quality zero reads in the tumor and normal at this locus
- init_t_lod: deprecated
- t_lod_fstar: CORE STATISTIC: Log of (likelihood tumor event is real / likelihood event is sequencing error )
- tumor_f: allelic fraction of this candidated based on read counts
- contaminant_fraction: estimate of contamination fraction used (supplied or defaulted)
- contaminant_lod: log likelihood of ( event is contamination / event is sequencing error )
- t_ref_count: count of reference alleles in tumor
- t_alt_count: count of alternate alleles in tumor
- t_ref_sum: sum of quality scores of reference alleles in tumor
- t_alt_sum: sum of quality scores of alternate alleles in tumor
- t_ins_count: count of insertion events at this locus in tumor
- t_del_count: count of deletion events at this locus in tumor
- normal_best_gt: most likely genotype in the normal
- init_n_lod: log likelihood of ( normal being reference / normal being altered )
- n_ref_count: count of reference alleles in normal
- n_alt_count: count of alternate alleles in normal
- n_ref_sum: sum of quality scores of reference alleles in normal
- n_alt_sum: sum of quality scores of alternate alleles in normal
- judgement: final judgement of site KEEP or REJECT (not enough evidence or artifact)
Loading results for further analysis¶
In [3]:
samples=['S01','S02','S03','S04','S05','S06','S07',
'S08','S09','S10','S11','S12','S13','S14','S15',
'S16','S17','S18','S19','S20','S21','S22','S23',
'S24','S25','S26','S27','S28','S29','S30']
for sample in samples:
subprocess.check_output('grep -v REJECT '+ sample+'_w_pair_and_PoN.call_stats.txt > ' +
sample+'_w_pair_and_PoN_no_REJECT.call_stats.txt',shell=True)
Filtering out scaffolds¶
In [5]:
chroms=set(map(str,range(1,28)+[32]) + ['W','Z'])
mut_outputs=[]
for sample in samples:
mut_outputs.append(pd.read_csv(+sample+'_w_pair_and_PoN_no_REJECT.call_stats.txt',sep='\t',header=1))
filt_idx= np.array([x in chroms for x in map(str,mut_outputs[-1]['contig']) ])
mut_outputs[-1]=mut_outputs[-1][filt_idx]
Plotting results with the default MuTect settings¶
- It can be seen that using the default settings, false positive mutations are present with very high numbers in control samples. Having one of the controls with the highest number of mutations in the dataset makes the results obtained insufficient to draw further biological conclusions.
- To improve the performance of MuTect, the LOD parameter was optimized below.
In [8]:
##define sample groups
control_idx=[0,4,13]+ [15,26,29]
weak_idx=[5,6,7]+[19,20,21]
strong_idx=[1,2,3,8,9,10,11,12,14]+[16,17,18,22,23,24,25,27,28]
def plot_muts(muts):
fig,ax=plt.subplots()
fig.set_size_inches(12,9)
#starting clones and controls
ax.bar(control_idx,muts[control_idx],
facecolor='dodgerblue',edgecolor='none',label='starting clone and controls')
#weak treatment
ax.bar(weak_idx,muts[weak_idx],
facecolor='salmon',edgecolor='none',label='weak mutagenic treatment')
#strong treatment
ax.bar(strong_idx,muts[strong_idx],
facecolor='lightgreen',edgecolor='none',label='strong mutagenic treatment')
#samples labels
ax.set_xticks(0.4+np.arange(len(samples)))
ax.set_xticklabels(samples,rotation='vertical',fontsize=14)
#axis, and legend
ax.set_xlabel(r'samples',fontsize=18)
ax.set_ylabel(r'Mutations detected',fontsize=18)
dump=ax.legend(loc='best',fancybox='true',fontsize=16)
In [9]:
muts=[]
for output in mut_outputs:
filt_idx= np.array([x in chroms for x in map(str,output['contig']) ])
muts.append(len(output[filt_idx]))
muts=np.array(muts)
plot_muts(muts)
Plotting The LOD tuning curves¶
In [12]:
#set cols
cols=['lightgreen' for i in xrange(30)]
for i in control_idx:
cols[i]='dodgerblue'
for i in weak_idx:
cols[i]='salmon'
#linscale
fig,ax=plt.subplots()
fig.set_size_inches(12,9)
for output,sample,col in zip(mut_outputs,samples,cols):
lod_vals=output.sort([u't_lod_fstar'])[u't_lod_fstar']
ax.plot(lod_vals,len(lod_vals)-np.arange(len(lod_vals)),c=col,lw=4,label='')
ax.set_xlabel(r'LOD-value threshold',fontsize=16)
ax.set_ylabel(r'Mutations found',fontsize=16)
ax.set_xlim(5,60)
ax.set_ylim(1,5e3)
ax.grid()
#dump=ax.legend(loc='upper right',fancybox='true',fontsize=16)
#logscale
fig,ax=plt.subplots()
fig.set_size_inches(12,9)
for output,sample,col in zip(mut_outputs,samples,cols):
lod_vals=output.sort([u't_lod_fstar'])[u't_lod_fstar']
ax.plot(lod_vals,len(lod_vals)-np.arange(len(lod_vals)),c=col,lw=4,label='')
ax.set_xlabel(r'LOD-value threshold',fontsize=16)
ax.set_ylabel(r'Mutations found',fontsize=16)
ax.set_xlim(5,60)
ax.set_ylim(1,5e3)
ax.set_yscale('log')
ax.grid()
#dump=ax.legend(loc='upper right',fancybox='true',fontsize=16)
Selecting an LOD threshold value that sufficiently decreases false positive rate, recalculating SNV counts¶
- According to the above tuning curves, an LOD threshold of around 20 would decrease false positive rates so that most control samples have fewer than 10 mutations, while treated samples have around 100-1000.
- The results filtered with this threshold can be seen below, which seem to satisfyingly separate samples based on their treatment (control / weak / strong).
In [13]:
muts=[]
for output in mut_outputs:
filt_idx= np.array([x in chroms for x in map(str,output['contig']) ])
filt_idx= filt_idx & ((output['t_lod_fstar']>20))
muts.append(len(output[filt_idx]))
muts=np.array(muts)
plot_muts(muts)
