_, use it env_varname = ""_"".join( [str(x).upper() for x in [self.config.name, self.name, item]] ) env_var = os.getenv(env_varname) return env_var or self.d[item] def items(self): return self.d.items() class Config(object): def __init__(self, name, filenames): self.name = name self.config = configparser.ConfigParser(inline_comment_prefixes=""#"") self.init_from_files(filenames) def init_from_files(self, filenames): self.config.read(filenames) self._read_sections() def read(self, filename): self.config.read(filename) self._read_sections() def _read_sections(self): for section in self.config.sections(): setattr(self, section, ConfigSection(self, self.config[section])) def sections(self): return self.config.sections() ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/multiprocessing.py",".py","3134","113","import sys import traceback from multiprocessing import ( Process, Queue, JoinableQueue, Lock, Value, cpu_count, ) from hatchet.utils import ProgressBar as pb class TaskHandler(Process): def __init__(self, worker, task_queue, result_queue, progress_bar): Process.__init__(self) self.worker = worker self.task_queue = task_queue self.result_queue = result_queue self.progress_bar = progress_bar def run(self): while True: task_i_and_args = self.task_queue.get() if task_i_and_args is None: self.task_queue.task_done() break else: task_i, args = task_i_and_args try: result = self.worker.work(*args) except Exception as e: typ, value, tb = sys.exc_info() result = RuntimeError(e).with_traceback(tb) # Traceback object is not preserved across multiprocessing; Save the traceback string as an attribute result.error = traceback.format_exception(typ, value, tb) if self.progress_bar is not None: self.progress_bar.progress(advance=True) self.result_queue.put((task_i, result)) self.task_queue.task_done() class Worker: def __init__(self): pass def work( self, *args, ): raise NotImplementedError def run(self, work, n_instances=None, show_progress=True): n_work = len(work) if n_instances is None: n_instances = min(cpu_count(), n_work) else: n_instances = min(n_instances, n_work) if show_progress: progress_bar = pb.ProgressBar( total=n_work, length=40, lock=Lock(), counter=Value(""i"", 0), verbose=True, ) else: progress_bar = None task_queue = JoinableQueue() for i, arg in enumerate(work): if isinstance(arg, tuple): task_queue.put((i, arg)) else: task_queue.put((i, tuple([arg]))) for _ in range(n_instances): task_queue.put(None) result_queue = Queue() handlers = [ TaskHandler(self, task_queue, result_queue, progress_bar) for _ in range(n_instances) ] for h in handlers: h.start() task_queue.join() try: results = [None] * n_work for work_i, result in [result_queue.get() for _ in range(n_work)]: if isinstance(result, Exception): error_string = """".join(getattr(result, ""error"", [])) raise result.__class__(f""WORK {work_i} FAILED\n\n{error_string}"") else: results[work_i] = result finally: task_queue.close() result_queue.close() for h in handlers: h.terminate() h.join() return results ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/CoordinateFinding.py",".py","2085","104","from math import floor from math import ceil lhg19 = [ -1, 249904550, 243199373, 198022430, 191535534, 180915260, 171115067, 159321559, 146440111, 141696573, 135534747, 135046619, 133851895, 115169878, 107349540, 102531392, 90354753, 81529607, 78081510, 59380841, 63025520, 48157577, 51304566, ] def extractChr(ref): return int("""".join([i for i in ref if i.isdigit()])) def findStart(bamfile, seq, least=0): L = 0 R = lhg19[extractChr(seq)] first = True while R - L > 1: if first: M = int(ceil(R * 0.01)) else: M = int(ceil((L + R) / 2)) count = bamfile.count(seq, L, M) # print ""[{}, {}] = {}"".format(L, M, count) if count > least: R = M else: L = M first = False if bamfile.count(seq, L, L) > least: return L else: return R def findEnd(bamfile, seq, least=0): L = 0 R = lhg19[extractChr(seq)] first = True while R - L > 1: if first: M = int(floor(R * 0.99)) else: M = int(floor((L + R) / 2)) count = bamfile.count(seq, M, R) # print ""[{}, {}] = {}"".format(M, R, count) if count > least: L = M else: R = M first = False if bamfile.count(seq, R, R) > least: return R else: return L def binChr(bamfile, sample, seq, size, start=0, end=0, least=-1): res = [] index = start if end == 0: end = lhg19[extractChr(seq)] while index < end: border = min(end, index + size) count = bamfile.count(seq, index, border) if count > least: res.append( { ""sample"": sample, ""chromosome"": extractChr(seq), ""start"": index, ""end"": (index + size), ""count"": count, } ) index += size return res ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/count_reads.py",".py","20917","636","import sys import os from multiprocessing import Pool import subprocess as sp import numpy as np import pandas as pd import gzip import subprocess import traceback from importlib.resources import path import hatchet.data from hatchet.utils.ArgParsing import parse_count_reads_args from hatchet.utils.Supporting import log, logArgs, error import hatchet.utils.TotalCounting as tc def main(args=None): log(msg=""# Parsing and checking input arguments\n"", level=""STEP"") args = parse_count_reads_args(args) logArgs(args, 80) bams = args[""bams""] names = args[""names""] tbams, tnames = zip(*sorted(zip(*(bams[1:], names[1:])), key=lambda x: x[1])) bams = [bams[0]] + list(tbams) names = [names[0]] + list(tnames) chromosomes = args[""chromosomes""] samtools = args[""samtools""] processes = args[""j""] outdir = args[""outdir""] mosdepth = args[""mosdepth""] tabix = args[""tabix""] readquality = args[""readquality""] if len(check_array_files(outdir, chromosomes)) == 0: log( msg=""# Found all array files, skipping to total read counting. \n"", level=""STEP"", ) else: if len(check_counts_files(outdir, chromosomes, names)) == 0: log( msg=""# Found all count files, skipping to forming arrays\n"", level=""STEP"", ) else: params = zip( np.repeat(chromosomes, len(bams)), [outdir] * len(bams) * len(chromosomes), [samtools] * len(bams) * len(chromosomes), bams * len(chromosomes), names * len(chromosomes), [readquality] * len(bams) * len(chromosomes), ) n_workers_samtools = min(processes, len(bams) * len(chromosomes)) with Pool( n_workers_samtools ) as p: # divide by 2 because each worker starts 2 processes p.map(count_chromosome_wrapper, params) n_workers_mosdepth = min(processes, len(bams)) # compute number of decompression threads to use for each call to mosdepth if processes > len(bams): base = min(int(processes / n_workers_mosdepth), 4) threads_per_task = [base] * len(bams) if base < 4: remainder = processes % n_workers_mosdepth i = 0 while remainder > 0: threads_per_task[i] += 1 i += 1 remainder -= 1 else: threads_per_task = [1] * len(bams) # Note: These function calls are the only section that uses mosdepth mosdepth_params = [ ( outdir, names[i], bams[i], threads_per_task[i], mosdepth, readquality, ) for i in range(len(bams)) ] with Pool(n_workers_mosdepth) as p: p.map(mosdepth_wrapper, mosdepth_params) if len(check_counts_files(outdir, chromosomes, names)) > 0: raise ValueError(error(""Missing some counts files!"")) ### Aggregate count files into count arrays for adaptive binning ### # (formerly formArray) use_chr = args[""use_chr""] n_workers = min(len(chromosomes), processes) # Read in centromere locations table with path(hatchet.data, f'{args[""refversion""]}.centromeres.txt') as centromeres: centromeres = pd.read_table( centromeres, header=None, names=[""CHR"", ""START"", ""END"", ""NAME"", ""gieStain""], ) chr2centro = {} for ch in centromeres.CHR.unique(): my_df = centromeres[centromeres.CHR == ch] assert (my_df.gieStain == ""acen"").all() # Each centromere should consist of 2 adjacent segments assert len(my_df == 2) assert my_df.START.max() == my_df.END.min() if use_chr: if ch.startswith(""chr""): chr2centro[ch] = my_df.START.min(), my_df.END.max() else: chr2centro[""chr"" + ch] = my_df.START.min(), my_df.END.max() else: if ch.startswith(""chr""): chr2centro[ch[3:]] = my_df.START.min(), my_df.END.max() else: chr2centro[ch] = my_df.START.min(), my_df.END.max() for ch in chromosomes: if ch not in chr2centro: raise ValueError( error( f""Chromosome {ch} not found in centromeres file. Inspect file provided as -C argument."" ) ) # Use Tabix to index per-position coverage bed files for each sample for name in names: perpos_file = os.path.join(outdir, name + "".per-base.bed.gz"") subprocess.run([tabix, ""-f"", perpos_file]) # form parameters for each worker params = [ ( outdir, names, ch, chr2centro[ch][0], chr2centro[ch][1], args[""baf_file""], tabix, ) for ch in chromosomes ] # dispatch workers with Pool(n_workers) as p: p.map(run_chromosome_wrapper, params) np.savetxt(os.path.join(outdir, ""samples.txt""), names, fmt=""%s"") if len(check_array_files(outdir, chromosomes)) > 0: raise ValueError(error(""Missing some output arrays!"")) else: log( msg=""# Array forming completed successfully, removing intermediate count files. \n"", level=""STEP"", ) [os.remove(f) for f in expected_counts_files(outdir, chromosomes, names)] totals_file = os.path.join(outdir, ""total.tsv"") if os.path.exists(totals_file): log(msg=""# Found total reads file, exiting. \n"", level=""STEP"") return else: # TODO: take -q option and pass in here log( msg=""# Counting total number of reads for normal and tumor samples\n"", level=""STEP"", ) total_counts = tc.tcount( samtools=samtools, samples=[(bams[i], names[i]) for i in range(len(names))], chromosomes=chromosomes, num_workers=processes, q=readquality, ) try: total = { name: sum(total_counts[name, chromosome] for chromosome in chromosomes) for name in names } except KeyError: raise KeyError( error( ""Either a chromosome or a sample has not been considered in the total counting!"" ) ) log( msg=""# Writing the total read counts for all samples in {}\n"".format( totals_file ), level=""STEP"", ) with open(totals_file, ""w"") as f: for name in names: f.write(""{}\t{}\n"".format(name, total[name])) def mosdepth_wrapper(params): run_mosdepth(*params) def run_mosdepth(outdir, sample_name, bam, threads, mosdepth, readquality): try: last_file = os.path.join(outdir, sample_name + "".per-base.bed.gz.csi"") if os.path.exists(last_file): log( f""Skipping mosdepth on sample {sample_name} (output file {last_file} exists)\n"", level=""STEP"", ) return log( f""Starting mosdepth on sample {sample_name} with {threads} threads\n"", level=""STEP"", ) sys.stderr.flush() md = sp.run( [ mosdepth, ""-t"", str(threads), ""-Q"", str(readquality), os.path.join(outdir, sample_name), bam, ] ) md.check_returncode() log(f""Done mosdepth on sample {sample_name}\n"", level=""STEP"") except Exception as e: log(""Exception in countPos: {}\n"".format(e), level=""ERROR"") raise e def count_chromosome( ch, outdir, samtools, bam, sample_name, readquality, compression_level=6 ): try: outfile = os.path.join(outdir, f""{sample_name}.{ch}.starts"") if os.path.exists(outfile): log( f""Skipping sample {sample_name} chromosome {ch} (output file exists)\n"", level=""STEP"", ) return log(f""Sample {sample_name} -- Starting chromosome {ch}\n"", level=""STEP"") sys.stderr.flush() # Get start positions st = sp.Popen( (samtools, ""view"", ""-q"", str(readquality), bam, ch), stdout=sp.PIPE ) cut = sp.Popen((""cut"", ""-f"", ""4""), stdin=st.stdout, stdout=sp.PIPE) gzip = sp.Popen( (""gzip"", ""-{}"".format(compression_level)), stdin=cut.stdout, stdout=open(outfile + "".gz"", ""w""), ) st.wait() cut.wait() gzip.wait() if st.returncode != 0: raise ValueError( ""samtools subprocess returned nonzero value: {}"".format(st.returncode) ) if cut.returncode != 0: raise ValueError( ""cut subprocess returned nonzero value: {}"".format(cut.returncode) ) log(f""Sample {sample_name} -- Done chromosome {ch}\n"", level=""STEP"") except Exception as e: log(""Exception in countPos: {}\n"".format(e), level=""ERROR"") raise e def count_chromosome_wrapper(param): count_chromosome(*param) def read_snps(baf_file, ch, all_names): """""" Read and validate SNP data for this patient (TSV table output from HATCHet deBAF.py). """""" all_names = all_names[ 1: ] # remove normal sample -- not looking for SNP counts from normal # Read in HATCHet BAF table all_snps = pd.read_table( baf_file, names=[""CHR"", ""POS"", ""SAMPLE"", ""REF"", ""ALT""], dtype={ ""CHR"": object, ""POS"": np.uint32, ""SAMPLE"": object, ""ALT"": np.uint32, ""REF"": np.uint32, }, ) # Keep only SNPs on this chromosome snps = all_snps[all_snps.CHR == ch].sort_values(by=[""POS"", ""SAMPLE""]) snps = snps.reset_index(drop=True) if len(snps) == 0: raise ValueError( error( f""Chromosome {ch} not found in SNPs file (chromosomes in file: {all_snps.CHR.unique()})"" ) ) n_samples = len(all_names) if n_samples != len(snps.SAMPLE.unique()): raise ValueError( error( f""Expected {n_samples} samples, found {len(snps.SAMPLE.unique())} samples in SNPs file."" ) ) if set(all_names) != set(snps.SAMPLE.unique()): raise ValueError( error( f""Expected sample names did not match sample names in SNPs file.\n\ Expected: {sorted(all_names)}\n Found:{sorted(snps.SAMPLE.unique())}"" ) ) # Add total counts column snpsv = snps.copy() snpsv[""TOTAL""] = snpsv.ALT + snpsv.REF # Create counts array and find SNPs that are not present in all samples snp_counts = snpsv.pivot(index=""POS"", columns=""SAMPLE"", values=""TOTAL"") missing_pos = snp_counts.isna().any(axis=1) # Remove SNPs that are absent in any sample snp_counts = snp_counts.dropna(axis=0) snpsv = snpsv[~snpsv.POS.isin(missing_pos[missing_pos].index)] # Pivot table for dataframe should match counts array and have no missing entries check_pivot = snpsv.pivot(index=""POS"", columns=""SAMPLE"", values=""TOTAL"") assert np.array_equal(check_pivot, snp_counts), ""SNP file reading failed"" assert not np.any(check_pivot.isna()), ""SNP file reading failed"" assert np.array_equal(all_names, list(snp_counts.columns)), ( all_names, list(snp_counts.columns), ) # make sure that sample order is the same return np.array(snp_counts.index), np.array(snp_counts), snpsv def form_counts_array( starts_files, perpos_files, thresholds, chromosome, tabix, chunksize=1e5 ): """""" NOTE: Assumes that starts_files[i] corresponds to the same sample as perpos_files[i] Parameters: starts_files: list of ..starts.gz files each containing a list of start positions perpos_files: list of .per-base.bed.gz files containing per-position coverage from mosdepth thresholds: list of potential bin start positions (thresholds between SNPs) chromosome: chromosome to extract read counts for Returns: x <2d> np.ndarray entry [i, 2j] contains the number of reads starting in (starts[i], starts[i + 1]) in sample j entry [i, 2j + 1] contains the number of reads covering position starts[i] in sample j """""" arr = np.zeros( (thresholds.shape[0] + 1, len(starts_files) * 2) ) # add one for the end of the chromosome for i in range(len(starts_files)): # populate starts in even entries fname = starts_files[i] if fname.endswith("".gz""): f = gzip.open(fname) else: f = open(fname) read_starts = [int(a) for a in gzip.open(fname, ""r"")] end = thresholds[0] j = 0 for idx in range(1, len(thresholds)): start = end end = thresholds[idx] my_count = 0 while j < len(read_starts) and read_starts[j] < end: assert read_starts[j] >= start my_count += 1 j += 1 arr[idx - 1, i * 2] = my_count arr[idx - 1, i * 2] += len(read_starts) - j f.close() for i in range(len(perpos_files)): # populate threshold coverage in odd entries fname = perpos_files[i] chr_sample_file = os.path.join(fname[:-3] + ""."" + chromosome) if not os.path.exists(chr_sample_file): with open(chr_sample_file, ""w"") as f: subprocess.run([tabix, fname, chromosome], stdout=f) with open(chr_sample_file, ""r"") as records: idx = 0 last_record = None for line in records: tokens = line.split() if len(tokens) == 4: start = int(tokens[1]) end = int(tokens[2]) nreads = int(tokens[3]) while idx < len(thresholds) and thresholds[idx] - 1 < end: assert thresholds[idx] - 1 >= start arr[idx, (2 * i) + 1] = nreads idx += 1 last_record = line if i == 0: # identify the (effective) chromosome end as the last well-formed record assert idx == len(thresholds) _, _, chr_end, end_reads = last_record.split() chr_end = int(chr_end) end_reads = int(end_reads) assert chr_end > thresholds[-1] assert len(thresholds) == len(arr) - 1 # add the chromosome end to thresholds thresholds = np.concatenate([thresholds, [chr_end]]) # count the number of reads covering the chromosome end arr[idx, 0] = end_reads if os.path.exists(chr_sample_file): os.remove(chr_sample_file) return arr, thresholds def get_chr_end(stem, all_names, chromosome): starts_files = [] for name in all_names: starts_files.append(os.path.join(stem, name + ""."" + chromosome + "".starts.gz"")) last_start = 0 for sfname in starts_files: zcat = subprocess.Popen((""zcat"", sfname), stdout=subprocess.PIPE) tail = subprocess.Popen( (""tail"", ""-1""), stdin=zcat.stdout, stdout=subprocess.PIPE ) my_last = int(tail.stdout.read().decode(""utf-8"").strip()) if my_last > last_start: last_start = my_last return last_start def run_chromosome( outdir, all_names, chromosome, centromere_start, centromere_end, baf_file, tabix, ): """""" Construct arrays that contain all counts needed to perform adaptive binning for a single chromosome (across all samples). """""" try: totals_out = os.path.join(outdir, f""{chromosome}.total.gz"") thresholds_out = os.path.join(outdir, f""{chromosome}.thresholds.gz"") if os.path.exists(totals_out) and os.path.exists(thresholds_out): log( msg=f""Output files already exist, skipping chromosome {chromosome}\n"", level=""INFO"", ) return log(msg=f""Loading chromosome {chromosome}\n"", level=""INFO"") # Per-position coverage bed files for each sample perpos_files = [ os.path.join(outdir, name + "".per-base.bed.gz"") for name in all_names ] # Identify the start-positions files for this chromosome starts_files = [] for name in all_names: starts_files.append( os.path.join(outdir, name + ""."" + chromosome + "".starts.gz"") ) log( msg=f""Reading SNPs file for chromosome {chromosome}\n"", level=""INFO"", ) # Load SNP positions and counts for this chromosome if chromosome.endswith(""X"") or chromosome.endswith(""Y""): log( msg=""Running on sex chromosome -- ignoring SNPs and min SNP reads\n"", level=""INFO"", ) # TODO: do this procedure only for XY last_start = get_chr_end(outdir, all_names, chromosome) positions = np.arange(5000, last_start, 5000) else: positions, _, _ = read_snps(baf_file, chromosome, all_names) thresholds = np.trunc( np.vstack([positions[:-1], positions[1:]]).mean(axis=0) ).astype(np.uint32) last_idx_p = np.argwhere(thresholds > centromere_start)[0][0] first_idx_q = np.argwhere(thresholds > centromere_end)[0][0] all_thresholds = np.concatenate( [ [1], thresholds[:last_idx_p], [centromere_start], [centromere_end], thresholds[first_idx_q:], ] ) log(msg=f""Loading counts for chromosome {chromosome}\n"", level=""INFO"") # Load read count arrays from file (also adds end of chromosome as a threshold) total_counts, complete_thresholds = form_counts_array( starts_files, perpos_files, all_thresholds, chromosome, tabix=tabix ) np.savetxt(totals_out, total_counts, fmt=""%d"") np.savetxt(thresholds_out, complete_thresholds, fmt=""%d"") log(msg=f""Done chromosome {chromosome}\n"", level=""INFO"") except Exception as e: print(f""Error in chromosome {chromosome}:"") print(e) traceback.print_exc() raise e def run_chromosome_wrapper(param): run_chromosome(*param) def expected_counts_files(dcounts, chrs, all_names): expected = [] for chr in chrs: for name in all_names: fname = os.path.join(dcounts, ""."".join([name, chr, ""starts.gz""])) expected.append(fname) # mosdepth output for name in all_names: fname = os.path.join(dcounts, name + "".mosdepth.global.dist.txt"") expected.append(fname) fname = os.path.join(dcounts, name + "".mosdepth.summary.txt"") expected.append(fname) fname = os.path.join(dcounts, name + "".per-base.bed.gz"") expected.append(fname) fname = os.path.join(dcounts, name + "".per-base.bed.gz.csi"") expected.append(fname) return expected def check_counts_files(dcounts, chrs, all_names): return [ a for a in expected_counts_files(dcounts, chrs, all_names) if not os.path.exists(a) ] def expected_arrays(darray, chrs): expected = [] # formArray (abin/. files)) fname = os.path.join(darray, ""samples.txt"") expected.append(fname) for ch in chrs: fname = os.path.join(darray, f""{ch}.total.gz"") expected.append(fname) fname = os.path.join(darray, f""{ch}.thresholds.gz"") expected.append(fname) return expected def check_array_files(darray, chrs): return [a for a in expected_arrays(darray, chrs) if not os.path.exists(a)] if __name__ == ""__main__"": main() ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/ArgParsing.py",".py","85045","2623","import sys import os.path from os.path import isfile, isdir import argparse import subprocess from hatchet.utils.Supporting import ( ensure, log, error, which, url_exists, bcolors, numericOrder, ) from hatchet import config, __version__ def parse_plot_bins_1d2d_args(args=None): """""" Parse command line arguments for auxiliary cluster plotting command (1D and 2D plot with matching colors and optional labeled centers) """""" description = """" parser = argparse.ArgumentParser( prog=""hatchet plot-cn"", description=description, formatter_class=argparse.RawTextHelpFormatter, ) parser.add_argument( ""-b"", ""--bbc"", help=""Filename for BBC table (e.g., bbc/bulk.bbc)"", required=True, type=str, ) parser.add_argument( ""-s"", ""--seg"", help=""Filename for SEG table (e.g., bbc/bulk.seg) optional but required to show cluster centers"", required=False, type=str, default=config.plot_bins_1d2d.seg, ) parser.add_argument( ""-O"", ""--outdir"", required=True, type=str, help=""Directory for output files"", ) parser.add_argument( ""--baflim"", required=False, type=str, help=( ""Axis limits for mirrored BAF as comma-separated values, e.g., '0,0.51' (default: None -- show full "" ""range of data)"" ), default=config.plot_bins_1d2d.baflim, ) parser.add_argument( ""--rdrlim"", required=False, type=str, help=( ""Axis limits for read-depth ratio as comma-separated values, e.g., '0,3' (default: None -- show full "" ""range of data)"" ), default=config.plot_bins_1d2d.fcnlim, ) parser.add_argument( ""--centers"", required=False, action=""store_true"", help=""Show cluster centers (requires SEG file provided via -s/--seg)"", default=config.plot_bins_1d2d.centers, ) parser.add_argument( ""--centromeres"", required=False, action=""store_true"", help=""Mark centromere locations with grey rectangles"", default=config.plot_bins_1d2d.centromeres, ) parser.add_argument( ""-a"", ""--alpha"", required=False, type=float, help=""Opacity alpha (default 1)"", default=config.plot_bins_1d2d.alpha, ) args = parser.parse_args(args) ensure(isfile(args.bbc), f""Input BBC file [{args.bbc}] not found."") ensure( (args.seg is None) or (isfile(args.seg)), f""Input SEG file [{args.seg}] not found."", ) if args.baflim is not None: tkns = args.baflim.split("","") try: minbaf = float(tkns[0].strip()) maxbaf = float(tkns[1].strip()) except ValueError: error( ""--baflim must be comma-separated float or integer values."", raise_exception=True, ) ensure(minbaf < maxbaf, ""Minimum BAF must be < maximum BAF."") else: minbaf = maxbaf = None if args.rdrlim is not None: tkns = args.rdrlim.split("","") try: minrdr = float(tkns[0].strip()) maxrdr = float(tkns[1].strip()) except ValueError: error( ""--rdrlim must be comma-separated float or integer values."", raise_exception=True, ) ensure(minrdr < maxrdr, ""Minimum RDR must be < maximum RDR."") else: minrdr = maxrdr = None return { ""bbc"": args.bbc, ""seg"": args.seg, ""outdir"": args.outdir, ""minbaf"": minbaf, ""maxbaf"": maxbaf, ""minrdr"": minrdr, ""maxrdr"": maxrdr, ""centers"": args.centers, ""centromeres"": args.centromeres, ""alpha"": args.alpha, } def parse_plot_cn_1d2d_args(args=None): """""" Parse command line arguments for auxiliary plotting command (1D and 2D plot with labeled copy states) """""" description = """" parser = argparse.ArgumentParser( prog=""hatchet plot-cn"", description=description, formatter_class=argparse.RawTextHelpFormatter, ) parser.add_argument( ""INPUT"", help=""Filename for BBC table (e.g., results/best.bbc.ucn)"" ) parser.add_argument( ""-O"", ""--outdir"", required=True, type=str, help=""Directory for output files"", ) parser.add_argument( ""--baflim"", required=False, type=str, help=( ""Axis limits for mirrored BAF values to show as comma-separated values, e.g., '0,0.51' (default: None "" ""-- show full range of data)"" ), default=config.plot_cn_1d2d.baflim, ) parser.add_argument( ""--fcnlim"", required=False, type=str, help=( ""Axis limits for fractional copy number values to show as comma-separated values, e.g., '0,3' (default: "" ""None -- show full range of data)"" ), default=config.plot_cn_1d2d.fcnlim, ) parser.add_argument( ""--centromeres"", required=False, action=""store_true"", help=""Mark centromere locations with grey rectangles"", default=config.plot_cn_1d2d.centromeres, ) parser.add_argument( ""--bysample"", required=False, action=""store_true"", help=""Write each sample to a separate file rather than combining all into 2 file"", default=config.plot_cn_1d2d.bysample, ) args = parser.parse_args(args) ensure(isfile(args.INPUT), f""Input file [{args.INPUT}] not found."") if args.baflim is not None: tkns = args.baflim.split("","") try: minbaf = float(tkns[0].strip()) maxbaf = float(tkns[1].strip()) except ValueError: error( ""--baflim must be comma-separated float or integer values."", raise_exception=True, ) else: minbaf = maxbaf = None if args.fcnlim is not None: tkns = args.fcnlim.split("","") try: minfcn = float(tkns[0].strip()) maxfcn = float(tkns[1].strip()) except ValueError: error( ""--fcnlim must be comma-separated float or integer values."", raise_exception=True, ) else: minfcn = maxfcn = None return { ""input"": args.INPUT, ""outdir"": args.outdir, ""minbaf"": minbaf, ""maxbaf"": maxbaf, ""minfcn"": minfcn, ""maxfcn"": maxfcn, ""bysample"": args.bysample, ""centromeres"": args.centromeres, } def parse_cluster_bins_args(args=None): """""" Parse command line arguments Returns: """""" description = ( ""Combine tumor bin counts, normal bin counts, and tumor allele counts to obtain the read-depth "" ""ratio and the mean B-allel frequency (BAF) of each bin. Optionally, the normal allele counts can "" ""be provided to add the BAF of each bin scaled by the normal BAF. The output is written on stdout."" ) parser = argparse.ArgumentParser( prog=""hatchet cluster-bins"", description=description, formatter_class=argparse.RawTextHelpFormatter, ) parser.add_argument( ""BBFILE"", help=( ""A BB file containing a line for each bin in each sample and the corresponding values of read-depth "" ""ratio and B-allele frequency (BAF)"" ), ) parser.add_argument( ""-o"", ""--outsegments"", required=False, default=config.cluster_bins.outsegments, type=str, help=""Output filename for the segments computed by clustering bins (default: stdout)"", ) parser.add_argument( ""-O"", ""--outbins"", required=False, default=config.cluster_bins.outbins, type=str, help=""Output filename for a BB file adding the clusters (default: stdout)"", ) parser.add_argument( ""-d"", ""--diploidbaf"", type=float, required=False, default=config.cluster_bins.diploidbaf, help=( ""Maximum diploid-BAF shift used to determine the largest copy-neutral cluster and to rescale all the "" ""cluster inside this threshold accordingly (default: 0.1)"" ), ) parser.add_argument( ""--minK"", type=int, required=False, default=config.cluster_bins.mink, help=f""Minimum number of clusters to infer (default = {config.cluster_bins.mink})"", ) parser.add_argument( ""--maxK"", type=int, required=False, default=config.cluster_bins.maxk, help=f""Maximum number of clusters to infer (default = {config.cluster_bins.maxk})"", ) parser.add_argument( ""--exactK"", type=int, required=False, default=config.cluster_bins.exactk, help=""Skip model selection and infer exactly this many clusters (default: None)"", ) parser.add_argument( ""-t"", ""--transmat"", type=str, required=False, default=config.cluster_bins.transmat, help=""Form of transition matrix to infer: fixed, diag (1-parameter), or full (default: diag)"", ) parser.add_argument( ""--tau"", type=float, required=False, default=config.cluster_bins.tau, help=f""Off-diagonal value for initializing transition matrix (default: {config.cluster_bins.tau})"", ) parser.add_argument( ""-c"", ""--covar"", type=str, required=False, default=config.cluster_bins.covar, help=""Form of covariance matrix: spherical, diag, full, or tied (default: diag)"", ) parser.add_argument( ""-x"", ""--decoding"", type=str, required=False, default=config.cluster_bins.decoding, help=""Decoding algorithm to use: map or viterbi (default: map)"", ) parser.add_argument( ""-s"", ""--selection"", type=str, required=False, default=config.cluster_bins.selection, help=""Number of HMM states selection criterion: bic or silhouette (default: bic)"", ) parser.add_argument( ""-R"", ""--restarts"", type=int, required=False, default=config.cluster_bins.restarts, help=""Number of restarts performed by the clustering to choose the best (default: 10)"", ) parser.add_argument( ""-S"", ""--subset"", required=False, default=config.cluster_bins.subset, type=str, nargs=""+"", help=( ""List of sample names to use as a subset of those included in binning"" ""(default: none, run on all samples)"" ), ) parser.add_argument( ""--allow_gaps"", action=""store_true"", required=False, default=config.cluster_bins.allow_gaps, help='Set this flag to allow gaps in chromosomes (each contiguous region is considered a separate ""arm"").', ) parser.add_argument( ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" ) args = parser.parse_args(args) ensure(isfile(args.BBFILE), ""The specified BB file does not exist!"") ensure( (args.diploidbaf is None) or (0.0 <= args.diploidbaf <= 0.5), ""The specified maximum for diploid-BAF shift must be a value in [0.0, 0.5]"", ) if args.exactK > 0: log( msg=f""WARNING: using fixed K (K={args.exactK}) will bypass model selection.\n"", level=""WARN"", ) ensure(args.minK >= 0, ""Min. number of clusters must be non-negative."") ensure(args.maxK >= 0, ""Max. number of clusters must be non-negative."") ensure( args.minK <= args.maxK, ""Min number of clusters must be smaller than max number of clusters."", ) if args.maxK == args.minK: log( msg=f""WARNING: minK = maxK = {args.minK}, so no model selection will be performed.\n"", level=""WARN"", ) valid_covars = (""spherical"", ""diag"", ""full"", ""tied"") ensure( args.covar in valid_covars, f""Invalid -c/--covar argument: {args.covar}. Valid values are {valid_covars}."", ) valid_decodings = (""map"", ""viterbi"") ensure( args.decoding in valid_decodings, f""Invalid -x/--decoding argument: {args.decoding}. Valid values are {valid_decodings}."", ) valid_selections = (""bic"", ""silhouette"") ensure( args.selection in valid_selections, f""Invalid -s/--selection argument: {args.selection}. Valid values are {valid_selections}."", ) valid_transmats = (""fixed"", ""diag"", ""free"") ensure( args.transmat in valid_transmats, f""Invalid -t/--transmat argument: {args.transmat}. Valid values are {valid_transmats}."", ) ensure(args.restarts >= 1, ""Number of restarts must be positive."") ensure(args.tau >= 0, ""Transition parameter --tau must be non-negative."") ensure( args.tau >= 6e-17, ""Transition parameter --tau must be at least 6e-17 to ensure numerical precision."", ) if args.subset is not None: import pandas as pd args.subset = args.subset.split() bb = pd.read_table(args.BBFILE) samples = bb.SAMPLE.unique() ensure( all([a in samples for a in args.subset]), 'Samples indicated in ""subset"" must be present in input BB file. BB file:' + f""{samples}, argument: {args.subset}"", ) return { ""bbfile"": args.BBFILE, ""diploidbaf"": args.diploidbaf, ""decoding"": args.decoding, ""selection"": args.selection, ""minK"": args.minK, ""maxK"": args.maxK, ""exactK"": args.exactK, ""covar"": args.covar, ""transmat"": args.transmat, ""tau"": args.tau, ""outsegments"": args.outsegments, ""outbins"": args.outbins, ""restarts"": args.restarts, ""subset"": args.subset, ""allow_gaps"": args.allow_gaps, } def parse_count_reads_args(args=None): description = ( ""Count the mapped sequencing reads in bins of fixed and given length, uniformly for a BAM file of "" ""a normal sample and one or more BAM files of tumor samples. This program supports both data from "" ""whole-genome sequencing (WGS) and whole-exome sequencing (WES), but the a BED file with targeted "" ""regions is required when considering WES."" ) parser = argparse.ArgumentParser( prog=""hatchet count-reads"", description=description ) parser.add_argument( ""-N"", ""--normal"", required=True, type=str, help=""BAM file corresponding to matched normal sample"", ) parser.add_argument( ""-T"", ""--tumor"", required=True, type=str, nargs=""+"", help=""BAM files corresponding to samples from the same tumor"", ) parser.add_argument( ""-b"", ""--baffile"", required=True, type=str, help=""1bed file containing SNP information from tumor samples (i.e., baf/bulk.1bed)"", ) parser.add_argument( ""-V"", ""--refversion"", required=True, type=str, help=""Version of reference genome used in BAM files"", ) parser.add_argument( ""-O"", ""--outdir"", required=True, type=str, help=""Directory for output files"", ) parser.add_argument( ""-S"", ""--samples"", required=False, default=config.count_reads.samples, type=str, nargs=""+"", help=( ""Sample names for each BAM, given in the same order where the normal name is first (default: inferred "" ""from file names)"" ), ) parser.add_argument( ""-st"", ""--samtools"", required=False, type=str, default=config.paths.samtools, help=""Path to samtools executable"", ) parser.add_argument( ""-md"", ""--mosdepth"", required=False, type=str, default=config.paths.mosdepth, help=""Path to mosdepth executable"", ) parser.add_argument( ""-tx"", ""--tabix"", required=False, type=str, default=config.paths.tabix, help=""Path to tabix executable"", ) parser.add_argument( ""-j"", ""--processes"", required=False, default=config.count_reads.processes, type=int, help=""Number of available parallel processes (default: 2)"", ) parser.add_argument( ""-q"", ""--readquality"", required=False, default=config.count_reads.readquality, type=int, help=( ""Minimum mapping quality for an aligned read to be considered (default: "", f""{config.count_reads.readquality})"", ), ) parser.add_argument( ""-i"", ""--intermediates"", required=False, action=""store_true"", default=config.count_reads.intermediates, help=""Produce intermediate counts files only and do not proceed to forming arrays (default: False)"", ) parser.add_argument( ""--chromosomes"", required=False, nargs=""*"", help=""One or more chromosomes to process (default: blank to process all chromosomes)"", ) args = parser.parse_args(args) # Parse BAM files, check their existence, and infer or parse the corresponding sample names bams = [args.normal] + args.tumor for bamfile in bams: ensure( isfile(bamfile), f""The specified tumor BAM file {bamfile} does not exist"", ) # also make sure the bam index files are present too for bamfile in bams: ensure( isfile(bamfile + "".bai"") or isfile(bamfile.replace("".bam"", "".bai"")), f""The specified tumor BAM file {bamfile} does not have an index file (bai)"", ) names = args.samples ensure( (names is None) or (len(bams) == len(names)), ""A sample name must be provided for each corresponding BAM: both for each normal sample and each tumor sample"", ) if names is None: names = [""normal""] for bamfile in bams[1:]: names.append(os.path.splitext(os.path.basename(bamfile))[0]) # In default mode, check the existence and compatibility of samtools and bcftools samtools = os.path.join(args.samtools, ""samtools"") ensure( which(samtools) is not None, ""samtools has not been found or is not executable."", ) # Extract the names of the chromosomes and check their consistency across the given BAM files and the reference chromosomes = extractChromosomes( samtools, [bams[0], ""normal""], [(x, """") for x in bams[1:]] ) if args.chromosomes: chromosomes = [c for c in chromosomes if c in args.chromosomes] # Check that chr notation is consistent across chromosomes using_chr = [a.startswith(""chr"") for a in chromosomes] if any(using_chr): ensure( all(using_chr), ""Some chromosomes use chr notation while others do not."", ) use_chr = True else: use_chr = False ver = args.refversion ensure( ver in (""hg19"", ""hg38""), ""Invalid reference genome version. Supported versions are hg38 and hg19."", ) ensure(os.path.exists(args.baffile), f""BAF file not found: {args.baffile}"") ensure( args.processes > 0, ""The number of parallel processes must be greater than 0"", ) ensure( os.path.exists(args.outdir), f""Output directory <{args.outdir}> not found!"", ) mosdepth = os.path.join(args.mosdepth, ""mosdepth"") tabix = os.path.join(args.tabix, ""tabix"") ensure( which(mosdepth) is not None, ( ""The mosdepth executable was not found or is not executable. Please install mosdepth (e.g., conda install "" ""-c bioconda mosdepth) and/or supply the path to the executable."" ), ) ensure( which(tabix) is not None, ( ""The tabix executable was not found or is not executable. Please install tabix (e.g., conda install -c "" ""bioconda tabix) and/or supply the path to the executable."" ), ) return { ""bams"": bams, ""names"": names, ""chromosomes"": chromosomes, ""samtools"": samtools, ""mosdepth"": mosdepth, ""tabix"": tabix, ""j"": args.processes, ""outdir"": args.outdir, ""use_chr"": use_chr, ""refversion"": ver, ""baf_file"": args.baffile, ""readquality"": args.readquality, } def parse_combine_counts_args(args=None): parser = argparse.ArgumentParser( description=""Perform adaptive binning, compute RDR and BAF for each bin, and produce a BB file."" ) parser.add_argument( ""-A"", ""--array"", type=str, required=True, help='Directory containing array files (output from ""count_reads"" command)', ) parser.add_argument( ""-t"", ""--totalcounts"", required=True, type=str, help=( 'Total read counts in the format ""SAMPLE\tCOUNT"" used to normalize by the different number of reads ' ""extracted from each sample"" ), ) parser.add_argument( ""-b"", ""--baffile"", required=True, type=str, help=""1bed file containing SNP information from tumor samples (i.e., baf/bulk.1bed)"", ) parser.add_argument( ""-r"", ""--referencefasta"", required=True, type=str, help=""path to the reference genome fasta file"", ) parser.add_argument( ""-o"", ""--outfile"", required=True, type=str, help=""Filename for output"" ) parser.add_argument( ""--msr"", type=int, help=f""Minimum SNP reads per bin (default {config.combine_counts.msr})"", default=config.combine_counts.msr, ) parser.add_argument( ""--mtr"", type=int, help=f""Minimum total reads per bin (default {config.combine_counts.mtr})"", default=config.combine_counts.mtr, ) parser.add_argument( ""-j"", ""--processes"", type=int, help=f""Number of parallel processes to use (default {config.combine_counts.processes})"", default=config.combine_counts.processes, ) parser.add_argument( ""-p"", ""--phase"", required=False, default=config.combine_counts.phase, type=str, help=""VCF file containing phasing for heterozygous germline SNPs"", ) parser.add_argument( ""-s"", ""--max_blocksize"", required=False, default=config.combine_counts.blocksize, type=int, help=f""Maximum size of phasing block (default {config.combine_counts.blocksize})"", ) parser.add_argument( ""-m"", ""--max_spb"", required=False, default=config.combine_counts.max_spb, type=int, help=f""Maximum number of SNPs per phasing block (default {config.combine_counts.max_spb})"", ) parser.add_argument( ""-a"", ""--alpha"", required=False, default=config.combine_counts.alpha, type=float, help=( ""Significance level for phase blocking adjacent SNPs. Higher means less trust in phasing. "" f""(default {config.combine_counts.alpha})"" ), ) parser.add_argument( ""--ss_em"", action=""store_true"", default=config.combine_counts.ss_em, required=False, help=""Use single-sample EM BAF inference (instead of multi-sample)"", ) parser.add_argument( ""-z"", ""--not_compressed"", action=""store_true"", default=config.combine_counts.not_compressed, required=False, help=""Non-compressed intermediate files"", ) parser.add_argument( ""-V"", ""--refversion"", required=True, type=str, help=""Version of reference genome used in BAM files"", ) args = parser.parse_args(args) ensure(os.path.exists(args.baffile), f""BAF file not found: {args.baffile}"") ensure( os.path.exists(args.referencefasta), f""Reference genome fasta file file not found: {args.referencefasta}"", ) if args.totalcounts is not None and not isfile(args.totalcounts): raise ValueError( error(""The specified file for total read counts does not exist!"") ) if args.phase == ""None"": args.phase = None ensure( (args.phase is None) or isfile(args.phase), ""The specified phasing file does not exist!"", ) ensure(args.max_blocksize > 0, ""The max_blocksize argument must be positive."") ensure(args.max_spb > 0, ""The max_snps_per_bin argument must be positive."") ensure( 0 <= args.alpha <= 1, ""The alpha argument must be between 0 and 1, inclusive."", ) ensure( os.path.exists(args.array), f""The provided array directory does not exist: {args.array}"", ) # pybedtools require 'bedtools' executable to be in PATH ensure( which(os.path.join(""bedtools"")) is not None, ( ""The bedtools executable was not found or is not executable. Please install bedtools (e.g., conda install "" '-c bioconda bedtools). pybedtools require ""bedtools"" executable to be in PATH.' ), ) namesfile = os.path.join(args.array, ""samples.txt"") ensure( os.path.exists(namesfile), ""Missing file containing sample names (1 per line): {namesfile}"", ) names = open(namesfile).read().split() chromosomes = set() for f in os.listdir(args.array): tkns = f.split(""."") if len(tkns) > 1 and (tkns[1] == ""thresholds"" or tkns[1] == ""total""): chromosomes.add(tkns[0]) chromosomes = sorted(chromosomes) for ch in chromosomes: if args.not_compressed: totals_arr = os.path.join(args.array, f""{ch}.total"") thresholds_arr = os.path.join(args.array, f""{ch}.thresholds"") else: totals_arr = os.path.join(args.array, f""{ch}.total.gz"") thresholds_arr = os.path.join(args.array, f""{ch}.thresholds.gz"") if not os.path.exists(totals_arr): raise ValueError(error(""Missing array file: {}"".format(totals_arr))) if not os.path.exists(thresholds_arr): raise ValueError(error(""Missing array file: {}"".format(thresholds_arr))) log(msg=f""Identified {len(chromosomes)} chromosomes.\n"", level=""INFO"") using_chr = [a.startswith(""chr"") for a in chromosomes] if any(using_chr): if not all(using_chr): raise ValueError( error(""Some starts files use 'chr' notation while others do not."") ) use_chr = True else: use_chr = False ensure(args.processes > 0, ""The number of jobs must be positive."") ensure( args.msr > 0, ""The minimum number of SNP-covering reads must be positive."", ) ensure(args.mtr > 0, ""The minimum number of total reads must be positive."") ver = args.refversion ensure( ver in (""hg19"", ""hg38""), ""Invalid reference genome version. Supported versions are hg38 and hg19."", ) outdir = os.sep.join(args.outfile.split(os.sep)[:-1]) ensure( os.path.exists(outdir), f""Directory for output file does not exist: <{outdir}>"", ) return { ""baffile"": args.baffile, ""outfile"": args.outfile, ""referencefasta"": args.referencefasta, ""sample_names"": names, ""min_snp_reads"": args.msr, ""min_total_reads"": args.mtr, ""use_chr"": use_chr, ""processes"": args.processes, ""chromosomes"": chromosomes, ""array"": args.array, ""totalcounts"": args.totalcounts, ""phase"": args.phase, ""blocksize"": args.max_blocksize, ""max_snps_per_block"": args.max_spb, ""test_alpha"": args.alpha, ""multisample"": not args.ss_em, ""ref_version"": ver, } def parse_genotype_snps_arguments(args=None): description = ""Genotype and call SNPs in a matched-normal sample."" parser = argparse.ArgumentParser( prog=""hatchet genotype-snps"", description=description ) parser.add_argument( ""-N"", ""--normal"", required=True, type=str, help=""BAM file corresponding to matched normal sample"", ) parser.add_argument( ""-r"", ""--reference"", required=True, type=str, help=""Human reference genome of BAMs"", ) parser.add_argument( ""-st"", ""--samtools"", required=False, default=config.paths.samtools, type=str, help=( 'Path to the directory to ""samtools"" executable, required in default mode (default: samtools is ' ""directly called as it is in user $PATH)"" ), ) parser.add_argument( ""-bt"", ""--bcftools"", required=False, default=config.paths.bcftools, type=str, help=( 'Path to the directory of ""bcftools"" executable, required in default mode (default: bcftools is ' ""directly called as it is in user $PATH)"" ), ) parser.add_argument( ""-R"", ""--snps"", required=False, default=config.genotype_snps.snps, type=str, help=( ""List of SNPs to consider in the normal sample (default: heterozygous SNPs are inferred from the normal "" ""sample)"" ), ) parser.add_argument( ""-j"", ""--processes"", required=False, default=config.genotype_snps.processes, type=int, help=""Number of available parallel processes (default: 2)"", ) parser.add_argument( ""-q"", ""--readquality"", required=False, default=config.genotype_snps.readquality, type=int, help=""Minimum mapping quality for an aligned read to be considered (default: 0)"", ) parser.add_argument( ""-Q"", ""--basequality"", required=False, default=config.genotype_snps.basequality, type=int, help=""Minimum base quality for a base to be considered (default: 11)"", ) parser.add_argument( ""-c"", ""--mincov"", required=False, default=config.genotype_snps.mincov, type=int, help=""Minimum coverage for SNPs to be considered (default: 0)"", ) parser.add_argument( ""-C"", ""--maxcov"", required=False, default=config.genotype_snps.maxcov, type=int, help=( ""Maximum coverage for SNPs to be considered (default: 1000, suggested: twice the values of expected "" ""average coverage to avoid aligning artefacts)"" ), ) parser.add_argument( ""-E"", ""--newbaq"", required=False, action=""store_true"", default=config.genotype_snps.newbaq, help=""Recompute alignment of reads on the fly during SNP calling (default: false)"", ) parser.add_argument( ""-o"", ""--outputsnps"", required=False, default=config.genotype_snps.outputsnps, type=str, help=""Output folder for SNPs separated by chromosome (default: ./)"", ) parser.add_argument( ""--chromosomes"", required=False, nargs=""*"", help=""One or more chromosomes to process (default: blank to process all chromosomes)"", ) parser.add_argument( ""-v"", ""--verbose"", action=""store_true"", default=config.genotype_snps.verbose, required=False, help=""Use verbose log messages"", ) parser.add_argument( ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" ) args = parser.parse_args(args) # Parse BAM files, check their existence, and infer or parse the corresponding sample names normalbaf = args.normal if not isfile(os.path.abspath(normalbaf)): raise ValueError(error(""The specified normal BAM file does not exist"")) normal = (os.path.abspath(normalbaf), ""Normal"") # In default mode, check the existence and compatibility of samtools and bcftools samtools = os.path.join(args.samtools, ""samtools"") bcftools = os.path.join(args.bcftools, ""bcftools"") ensure( which(samtools) is not None, ""samtools has not been found or is not executable!"", ) ensure( which(bcftools) is not None, ""bcftools has not been found or is not executable!"", ) # Check that SNP, reference, and region files exist when given in input ensure( isfile(args.reference), ""The provided file for human reference genome does not exist!"", ) ensure( (args.outputsnps is None) or (isdir(args.outputsnps)), ""The folder for output SNPs does not exist!"", ) if args.snps is not None and len(args.snps) < 2: args.snps = None if args.snps is not None and not (isfile(args.snps) or url_exists(args.snps)): error(""The provided list of SNPs does not exist!"", raise_exception=True) # if the input snps file is a bgzip compressed vcf file # and associated tabix file is not located in the same directory, report error if ( args.snps is not None and isfile(args.snps) and args.snps.endswith(""gz"") and not isfile(args.snps + "".tbi"") ): error( ""The provided list of SNPs is a bgzip compressed vcf file"" ""but the associated tabix file does not exist!"", raise_exception=True, ) # Extract the names of the chromosomes and check their consistency across the given BAM files and the reference chromosomes = extractChromosomes(samtools, normal, [], args.reference) if args.chromosomes: chromosomes = [c for c in chromosomes if c in args.chromosomes] ensure( args.processes > 0, ""The number of parallel processes must be greater than 0"", ) ensure(args.readquality >= 0, ""The read mapping quality must be positive"") ensure(args.basequality >= 0, ""The base quality quality must be positive"") ensure(args.mincov >= 0, ""The minimum-coverage value must be positive"") ensure(args.maxcov >= 0, ""The maximum-coverage value must be positive"") if args.verbose: log( msg='stderr of samtools and bcftools will be collected in the following file ""samtools.log""\n', level=""WARN"", ) with open(""samtools.log"", ""w"") as f: f.write("""") return { ""normal"": normal, ""chromosomes"": chromosomes, ""samtools"": samtools, ""bcftools"": bcftools, ""snps"": args.snps, ""reference"": args.reference, ""j"": args.processes, ""q"": args.readquality, ""Q"": args.basequality, ""E"": args.newbaq, ""mincov"": args.mincov, ""maxcov"": args.maxcov, ""outputsnps"": os.path.abspath(args.outputsnps), ""verbose"": args.verbose, } def parse_download_panel_arguments(args=None): description = ( ""Download and prepare files for phasing germline SNPs using a reference panel"" ) parser = argparse.ArgumentParser(description=description) parser.add_argument( ""-D"", ""--refpaneldir"", required=False, type=str, default=config.download_panel.refpaneldir, help=""Path to Reference Panel"", ) parser.add_argument( ""-R"", ""--refpanel"", default=config.download_panel.refpanel, required=False, type=str, help=( 'Reference Panel; specify ""1000GP_Phase3"" to automatically download and use the panel form the 1000 ' ""genomes project"" ), ) args = parser.parse_args(args) ensure( args.refpaneldir is not None, 'The command ""download_panel"" requires a path for the variable ""refpaneldir"".', ) return { ""refpanel"": args.refpanel, ""refpaneldir"": os.path.abspath(args.refpaneldir), } def parse_phase_snps_arguments(args=None): description = ""Phase germline SNPs using a reference panel"" parser = argparse.ArgumentParser(description=description) parser.add_argument( ""-D"", ""--refpaneldir"", required=False, type=str, default=config.download_panel.refpaneldir, help=""Path to Reference Panel"", ) parser.add_argument( ""-g"", ""--refgenome"", required=True, type=str, help=""Path to Reference genome used in BAM files"", ) parser.add_argument( ""-V"", ""--refversion"", required=True, type=str, help=""Version of reference genome used in BAM files"", ) parser.add_argument( ""-N"", ""--chrnotation"", required=False, action=""store_true"", help='Use this flag to indicate that chromosomes are named with ""chr"" (default: no ""chr"")', default=False, ) parser.add_argument( ""-o"", ""--outdir"", required=False, type=str, help=""Output folder for phased VCFs"", ) parser.add_argument( ""-L"", ""--snps"", required=True, type=str, nargs=""+"", help=""List of SNPs in the normal sample to phase"", ) parser.add_argument( ""-j"", ""--processes"", required=False, default=config.genotype_snps.processes, type=int, help=""Number of available parallel processes (default: 2)"", ) parser.add_argument( ""-si"", ""--shapeit"", required=False, type=str, default=config.paths.shapeit, help=""Path to shapeit executable (default: look in $PATH)"", ) parser.add_argument( ""-pc"", ""--picard"", required=False, type=str, default=config.paths.picard, help=""Path to picard executable or jar (default: look in $PATH)"", ) parser.add_argument( ""-bt"", ""--bcftools"", required=False, default=config.paths.bcftools, type=str, help='Path to the directory of ""bcftools"" executable (default: look in $PATH)', ) parser.add_argument( ""-bg"", ""--bgzip"", required=False, default=config.paths.bgzip, type=str, help='Path to the directory of ""bcftools"" executable (default: look in $PATH)', ) args = parser.parse_args(args) # add safety checks for custom ref panel # if args.refpanel != ""1000GP_Phase3"": bgzip = os.path.join(args.bgzip, ""bgzip"") if which(bgzip) is None: raise ValueError( error( ""The 'bgzip' executable was not found or is not executable. \ Please install bgzip and/or supply the path to the executable."" ) ) shapeit = os.path.join(args.shapeit, ""shapeit"") if which(shapeit) is None: raise ValueError( error( ""The 'shapeit' executable was not found or is not executable. \ Please install shapeit (e.g., conda install -c dranew shapeit) and/or supply the path to the executable."" ) ) # We may have access to a picard wrapper executable or picard.jar. Take care of both scenarios. picard_dir = args.picard picard_java_flags = config.phase_snps.picard_java_flags picard_bin_path = os.path.join(picard_dir, ""picard"") picard_jar_path = os.path.join(picard_dir, ""picard.jar"") if which(picard_bin_path) is not None: picard = f""{picard_bin_path} {picard_java_flags}"" elif os.path.exists(picard_jar_path): picard = f""java {picard_java_flags} -jar {picard_jar_path}"" else: error( ( ""Neither picard nor picard.jar were found in the given location. Please install picard"" ""(e.g., conda install -c bioconda picard) and/or supply the path to the executable"" "" or JAR file."" ), raise_exception=True, ) bcftools = os.path.join(args.bcftools, ""bcftools"") if which(bcftools) is None: raise ValueError(error(""bcftools has not been found or is not executable!"")) if args.refversion not in (""hg19"", ""hg38""): error( 'The reference genome version of your samples is not ""hg19"" or ""hg38"".', raise_exception=True, ) rpd = args.refpaneldir if not os.path.exists(os.path.join(rpd, ""1000GP_Phase3"", ""1000GP_Phase3.sample"")): error( ""Please download the 1000GP reference panel before proceeding"", raise_exception=True, ) # Check that SNP files exist when given in input snplists = {} for f in args.snps: if not isfile(f): raise ValueError( error(""The specified SNP file {} does not exist!"".format(f)) ) # use keys that correspond to chromosomes names used (below) snplists = { os.path.basename(f).split(""."")[0].replace(""chr"", """"): f for f in args.snps } # Get chromosome names from vcf file names, since they're named according to chromosome in SNPCaller # rename chromosomes if they have chr prefix; used to locate ref panel files! chromosomes = [ os.path.basename(snplists[i]).replace("".vcf.gz"", """").replace(""chr"", """") for i in snplists ] return { ""refpaneldir"": args.refpaneldir, ""j"": args.processes, ""chromosomes"": chromosomes, ""snps"": snplists, ""refvers"": args.refversion, ""chrnot"": args.chrnotation, ""refgenome"": args.refgenome, ""outdir"": os.path.abspath(args.outdir), ""shapeit"": shapeit, ""picard"": picard, ""bcftools"": bcftools, ""bgzip"": bgzip, } def parse_count_alleles_arguments(args=None): description = ( ""Count the A/B alleles from a matched-normal BAM file and multiple tumor BAM files in specified "" ""SNP positions or estimated heterozygous SNPs in the normal genome. This tool can be applied both "" ""to whole-genome sequencing (WGS) data or whole-exome sequencing (WES) data, but coding regions "" ""must be specified as a BED file in the case of WES."" ) parser = argparse.ArgumentParser( prog=""hatchet count-alleles"", description=description ) parser.add_argument( ""-N"", ""--normal"", required=True, type=str, help=""BAM file corresponding to matched normal sample"", ) parser.add_argument( ""-T"", ""--tumors"", required=True, type=str, nargs=""+"", help=""BAM files corresponding to samples from the same tumor"", ) parser.add_argument( ""-r"", ""--reference"", required=True, type=str, help=""Human reference genome of BAMs"", ) parser.add_argument( ""-L"", ""--snps"", required=True, type=str, nargs=""+"", help=""List of SNPs to consider in the normal sample"", ) parser.add_argument( ""-S"", ""--samples"", required=False, default=config.count_alleles.samples, type=str, nargs=""+"", help=""Sample names for each BAM (given in the same order where the normal name is first)"", ) parser.add_argument( ""-st"", ""--samtools"", required=False, default=config.paths.samtools, type=str, help=( 'Path to the directory to ""samtools"" executable, required in default mode (default: samtools is ' ""directly called as it is in user $PATH)"" ), ) parser.add_argument( ""-bt"", ""--bcftools"", required=False, default=config.paths.bcftools, type=str, help=( 'Path to the directory of ""bcftools"" executable, required in default mode (default: bcftools is ' ""directly called as it is in user $PATH)"" ), ) parser.add_argument( ""-j"", ""--processes"", required=False, default=config.count_alleles.processes, type=int, help=""Number of available parallel processes (default: 2)"", ) parser.add_argument( ""-q"", ""--readquality"", required=False, default=config.count_alleles.readquality, type=int, help=""Minimum mapping quality for an aligned read to be considered (default: 0)"", ) parser.add_argument( ""-Q"", ""--basequality"", required=False, default=config.count_alleles.basequality, type=int, help=""Minimum base quality for a base to be considered (default: 11)"", ) parser.add_argument( ""-U"", ""--snpquality"", required=False, default=config.count_alleles.snpquality, type=int, help=""Minimum SNP-variant quality, QUAL, for a variant to be considered (default: 11)"", ) parser.add_argument( ""-g"", ""--gamma"", required=False, default=config.count_alleles.gamma, type=float, help=""Level of confidence to determine heterozigosity of SNPs (default: 0.05)"", ) parser.add_argument( ""-b"", ""--maxshift"", required=False, default=config.count_alleles.maxshift, type=float, help=( ""Maximum allowed absolute difference of BAF from 0.5 for selected heterozygous SNPs in the normal "" ""sample (default: 0.5)"" ), ) parser.add_argument( ""-c"", ""--mincov"", required=False, default=config.count_alleles.mincov, type=int, help=""Minimum coverage for SNPs to be considered (default: 0)"", ) parser.add_argument( ""-C"", ""--maxcov"", required=False, default=config.count_alleles.maxcov, type=int, help=( ""Maximum coverage for SNPs to be considered (default: 1000, suggested: twice the values of expected "" ""average coverage to avoid aligning artefacts)"" ), ) parser.add_argument( ""-E"", ""--newbaq"", required=False, action=""store_true"", default=config.count_alleles.newbaq, help=""Recompute alignment of reads on the fly during SNP calling (default: false)"", ) parser.add_argument( ""-O"", ""--outputnormal"", required=False, default=config.count_alleles.outputnormal, type=str, help=""Filename of output for allele counts in the normal sample (default: standard output)"", ) parser.add_argument( ""-o"", ""--outputtumors"", required=False, default=config.count_alleles.outputtumors, type=str, help=""Output filename for allele counts in tumor samples (default: standard output)"", ) parser.add_argument( ""-l"", ""--outputsnps"", required=False, default=config.count_alleles.outputsnps, type=str, help=""Output directory for lists of selected SNPs (default: ./)"", ) parser.add_argument( ""--chromosomes"", required=False, nargs=""*"", help=""One or more chromosomes to process (default: blank to process all chromosomes)"", ) parser.add_argument( ""-v"", ""--verbose"", action=""store_true"", default=config.count_alleles.verbose, required=False, help=""Use verbose log messages"", ) parser.add_argument( ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" ) args = parser.parse_args(args) # Parse BAM files, check their existence, and infer or parse the corresponding sample names normalbaf = args.normal if not isfile(normalbaf): raise ValueError(error(""The specified normal BAM file does not exist"")) tumors = args.tumors for tumor in tumors: if not isfile(tumor): raise ValueError( error(f""The specified tumor BAM file does not exist: {tumor}"") ) names = args.samples ensure( (names is None) or ((len(tumors) + 1) == len(names)), ( ""A sample name must be provided for each corresponding BAM: both for each normal sample and each "", ""tumor sample"", ), ) samples = set() if names is None: normal = normalbaf, os.path.splitext(os.path.basename(normalbaf))[0] for tumor in tumors: samples.add((tumor, os.path.splitext(os.path.basename(tumor))[0])) else: normal = normalbaf, names[0] for i in range(len(tumors)): samples.add((tumors[i], names[i + 1])) # In default mode, check the existence and compatibility of samtools and bcftools samtools = os.path.join(args.samtools, ""samtools"") bcftools = os.path.join(args.bcftools, ""bcftools"") if which(samtools) is None: raise ValueError(error(""{}samtools has not been found or is not executable!{}"")) elif which(bcftools) is None: raise ValueError(error(""{}bcftools has not been found or is not executable!{}"")) # Check that SNP, reference, and region files exist when given in input snplists = {} for f in args.snps: if not isfile(f): raise ValueError( error(""The specified SNP file {} does not exist!"".format(f)) ) snplists = {os.path.basename(f).split(""."")[0]: f for f in args.snps} if not isfile(args.reference): raise ValueError( error(""The provided file for human reference genome does not exist!"") ) # Extract the names of the chromosomes and check their consistency across the given BAM files and the reference chromosomes = extractChromosomes(samtools, normal, samples, args.reference) if args.chromosomes: chromosomes = [c for c in chromosomes if c in args.chromosomes] snplists = {c: snplists.get(c, []) for c in chromosomes} ensure( args.processes > 0, ""The number of parallel processes must be greater than 0"", ) ensure(args.readquality >= 0, ""The read mapping quality must be positive"") ensure(args.basequality >= 0, ""The base quality quality must be positive"") ensure(0 <= args.gamma <= 1, ""Gamma must be a floating value between 0 and 1"") ensure( 0 <= args.maxshift <= 0.5, ""Max BAF shift must be a floating value between 0 and 0.5"", ) ensure(args.mincov >= 0, ""The minimum-coverage value must be positive"") ensure(args.maxcov >= 0, ""The maximum-coverage value must be positive"") ensure(args.snpquality >= 0, ""The QUAL value must be positive"") if args.verbose: log( msg='stderr of samtools and bcftools will be collected in the following file ""samtools.log""\n', level=""WARN"", ) with open(""samtools.log"", ""w"") as f: f.write("""") return { ""normal"": normal, ""samples"": samples, ""chromosomes"": chromosomes, ""samtools"": samtools, ""bcftools"": bcftools, ""snps"": snplists, ""reference"": args.reference, ""j"": args.processes, ""q"": args.readquality, ""Q"": args.basequality, ""qual"": args.snpquality, ""E"": args.newbaq, ""gamma"": args.gamma, ""maxshift"": args.maxshift, ""mincov"": args.mincov, ""maxcov"": args.maxcov, ""outputNormal"": args.outputnormal, ""outputTumors"": args.outputtumors, ""outputSnps"": args.outputsnps, ""verbose"": args.verbose, } def parse_count_reads_fw_arguments(args=None): description = ( ""Count the mapped sequencing reads in bins of fixed and given length, uniformly for a BAM file of "" ""a normal sample and one or more BAM files of tumor samples. This program supports both data from "" ""whole-genome sequencing (WGS) and whole-exome sequencing (WES), but the a BED file with targeted "" ""regions is required when considering WES."" ) parser = argparse.ArgumentParser( prog=""hatchet count-reads"", description=description ) parser.add_argument( ""-N"", ""--normal"", required=True, type=str, help=""BAM file corresponding to matched normal sample"", ) parser.add_argument( ""-T"", ""--tumors"", required=True, type=str, nargs=""+"", help=""BAM files corresponding to samples from the same tumor"", ) parser.add_argument( ""-b"", ""--size"", required=True, type=str, help='Size of the bins, specified as a full number or using the notations either ""kb"" or ""Mb""', ) parser.add_argument( ""-S"", ""--samples"", required=False, default=config.count_reads_fw.samples, type=str, nargs=""+"", help=( ""Sample names for each BAM, given in the same order where the normal name is first (default: inferred "" ""from file names)"" ), ) parser.add_argument( ""-st"", ""--samtools"", required=False, default=config.paths.samtools, type=str, help=( 'Path to the directory to ""samtools"" executable, required in default mode (default: samtools is ' ""directly called as it is in user $PATH)"" ), ) parser.add_argument( ""-r"", ""--regions"", required=False, default=config.count_reads_fw.regions, type=str, help=( 'BED file containing the a list of genomic regions to consider in the format ""CHR START END"", ' ""REQUIRED for WES data (default: none, consider entire genome)"" ), ) parser.add_argument( ""-g"", ""--reference"", required=False, default=config.paths.reference, type=str, help=( ""Reference genome, note that reference must be indexed and the dictionary must exist in the same "" ""directory with the same name and .dict extension"" ), ) parser.add_argument( ""-j"", ""--processes"", required=False, default=config.count_reads_fw.processes, type=int, help=""Number of available parallel processes (default: 2)"", ) parser.add_argument( ""-q"", ""--readquality"", required=False, default=config.count_reads_fw.readquality, type=int, help=( ""Minimum mapping quality for an aligned read to be considered "", f""(default: {config.count_reads_fw.readquality})"", ), ) parser.add_argument( ""-O"", ""--outputnormal"", required=False, default=config.count_reads_fw.outputnormal, type=str, help=""Filename of output for allele counts in the normal sample (default: standard output)"", ) parser.add_argument( ""-o"", ""--outputtumors"", required=False, default=config.count_reads_fw.outputtumors, type=str, help=""Output filename for allele counts in tumor samples (default: standard output)"", ) parser.add_argument( ""-t"", ""--outputtotal"", required=False, default=config.count_reads_fw.outputtotal, type=str, help='Output filename for total read counts in all tumor samples (default: ""total_read.counts"")', ) parser.add_argument( ""-v"", ""--verbose"", action=""store_true"", default=config.count_reads_fw.verbose, required=False, help=""Use verbose log messages"", ) parser.add_argument( ""--chromosomes"", required=False, nargs=""*"", help=""One or more chromosomes to process (default: blank to process all chromosomes)"", ) parser.add_argument( ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" ) args = parser.parse_args(args) # Parse BAM files, check their existence, and infer or parse the corresponding sample names normalbaf = args.normal ensure(isfile(normalbaf), ""The specified normal BAM file does not exist"") tumors = args.tumors for tumor in tumors: ensure( isfile(tumor), f""The specified tumor BAM file {tumor} does not exist"", ) names = args.samples ensure( names is None or (len(tumors) + 1) == len(names), ""A sample name must be provided for each corresponding BAM: both for each normal sample and each tumor sample"", ) samples = set() if names is None: normal = (normalbaf, os.path.splitext(os.path.basename(normalbaf))[0]) for tumor in tumors: samples.add((tumor, os.path.splitext(os.path.basename(tumor))[0])) else: normal = (normalbaf, names[0]) for i in range(len(tumors)): samples.add((tumors[i], names[i + 1])) # Check the region file ensure( args.regions is None or isfile(args.regions), ""The specified region file does not exist"", ) # In default mode, check the existence and compatibility of samtools and bcftools samtools = os.path.join(args.samtools, ""samtools"") if which(samtools) is None: raise ValueError(error(""samtools has not been found or is not executable!"")) # Check and parse the given size size = 0 try: if args.size[-2:] == ""kb"": size = int(args.size[:-2]) * 1000 elif args.size[-2:] == ""Mb"": size = int(args.size[:-2]) * 1000000 else: size = int(args.size) except (IndexError, ValueError): error( 'Size must be a number, optionally ending with either ""kb"" or ""Mb""!', raise_exception=True, ) # Check that either region file or available reference name are available ensure( any((args.reference, args.regions)), ( ""Please either provide a BED file of regions or specify a name of an available references for inferring "" ""maximum-chromosome lengths"", ), ) ensure( args.reference is None or isfile(args.reference), ""The specified reference genome does not exist!"", ) refdict = os.path.splitext(args.reference)[0] + "".dict"" ensure( args.reference is None or isfile(args.reference), ( ""The dictionary of the reference genome has not been found! Reference genome must be indexed and its "" ""dictionary must exist in the same directory with same name but extension .dict"" ), ) # Extract the names of the chromosomes and check their consistency across the given BAM files and the reference chromosomes = extractChromosomes(samtools, normal, samples) if args.chromosomes: chromosomes = [c for c in chromosomes if c in args.chromosomes] ensure( args.processes > 0, ""The number of parallel processes must be greater than 0"", ) ensure(args.readquality >= 0, ""The read mapping quality must be positive"") return { ""normal"": normal, ""samples"": samples, ""chromosomes"": chromosomes, ""samtools"": samtools, ""regions"": args.regions, ""size"": size, ""reference"": args.reference, ""refdict"": refdict, ""j"": args.processes, ""q"": args.readquality, ""outputNormal"": args.outputnormal, ""outputTumors"": args.outputtumors, ""outputTotal"": args.outputtotal, ""verbose"": args.verbose, } def parse_combine_counts_fw_args(args=None): parser = argparse.ArgumentParser( prog=""hatchet combine-counts"", description=( ""Combine tumor bin counts, normal bin counts, and tumor allele counts to obtain the read-depth "" ""ratio and the mean B-allel frequency (BAF) of each bin. Optionally, the normal allele counts "" ""can be provided to add the BAF of each bin scaled by the normal BAF. The output is written on "" ""stdout."" ), formatter_class=argparse.RawTextHelpFormatter, ) parser.add_argument( ""-c"", ""--normalbins"", required=True, type=str, help='Normal bin counts in the format ""SAMPLE\tCHR\tSTART\tEND\tCOUNT""', ) parser.add_argument( ""-C"", ""--tumorbins"", required=True, type=str, help='Tumor bin counts in the format ""SAMPLE\tCHR\tSTART\tEND\tCOUNT""', ) parser.add_argument( ""-B"", ""--tumorbafs"", required=True, type=str, help='Tumor allele counts in the format ""SAMPLE\tCHR\tPOS\tREF-COUNT\tALT-COUNT""', ) parser.add_argument( ""-p"", ""--phase"", required=False, default=config.combine_counts.phase, type=str, help='Phasing of heterozygous germline SNPs in the format ""CHR\tPOS\t""', ) parser.add_argument( ""-d"", ""--diploidbaf"", type=float, required=False, default=0.1, help=( ""Maximum diploid-BAF shift used to select the bins whose BAF should be normalized by the normal when "" ""normalbafs is given (default: 0.1)"" ), ) parser.add_argument( ""-l"", ""--blocklength"", required=False, default=config.combine_counts.blocksize, type=str, help=( 'Size of the haplotype blocks, specified as a full number or using the notations either ""kb"" or ""Mb"" ', ""(default: 50kb)"", ), ) parser.add_argument( ""-t"", ""--totalcounts"", required=False, default=None, type=str, help=( 'Total read counts in the format ""SAMPLE\tCOUNT"" used to normalize by the different number of reads ' ""extracted from each sample (default: none)"" ), ) parser.add_argument( ""-g"", ""--gamma"", type=float, required=False, default=0.05, help=( ""Confidence level used to determine if a bin is copy neutral with BAF of 0.5 in the BINOMIAL_TEST mode "" ""(default: 0.05)"" ), ) parser.add_argument( ""-e"", ""--seed"", type=int, required=False, default=0, help=""Random seed used for the normal distributions used in the clouds (default: 0)"", ) parser.add_argument( ""-v"", ""--verbose"", action=""store_true"", required=False, help=""Use verbose log messages"", ) parser.add_argument( ""-r"", ""--disablebar"", action=""store_true"", required=False, help=""Disable progress bar"", ) parser.add_argument( ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" ) args = parser.parse_args(args) ensure( isfile(args.normalbins), ""The specified file for normal bin counts does not exist!"", ) ensure( isfile(args.tumorbins), ""The specified file for tumor bin counts does not exist!"", ) ensure( isfile(args.normalbins), ""The specified file for normal bin counts does not exist!"", ) if args.phase == ""None"": # TODO - why do we need this? args.phase = None ensure( (args.phase is None) or (isfile(args.phase)), ""The specified file for phase does not exist!"", ) ensure( 0.0 <= args.diploidbaf <= 0.5, ""The specified maximum for diploid-BAF shift must be a value in [0.0, 0.5]"", ) ensure( (args.totalcounts is None) or (isfile(args.totalcounts)), ""The specified file for total read counts does not exist!"", ) ensure( 0.0 <= args.gamma <= 0.1, ""The specified gamma must be a value in [0.0, 0.1]"", ) ensure(args.seed >= 0, ""Seed parameter must be positive!"") args.blocklength = str(args.blocklength) try: if args.blocklength[-2:] == ""kb"": size = int(args.blocklength[:-2]) * 1000 elif args.blocklength[-2:] == ""Mb"": size = int(args.blocklength[:-2]) * 1000000 else: size = int(args.blocklength) except (IndexError, ValueError): error( 'Size must be a number, optionally ending with either ""kb"" or ""Mb""!', raise_exception=True, ) return { ""normalbins"": args.normalbins, ""tumorbins"": args.tumorbins, ""tumorbafs"": args.tumorbafs, ""phase"": args.phase, ""block"": size, ""diploidbaf"": args.diploidbaf, ""totalcounts"": args.totalcounts, ""gamma"": args.gamma, ""seed"": args.seed, ""verbose"": args.verbose, ""disable"": args.disablebar, } def parse_cluster_bins_gmm_args(args=None): parser = argparse.ArgumentParser( prog=""hatchet cluster-bins"", description=( ""Combine tumor bin counts, normal bin counts, and tumor allele counts to obtain the read-depth "" ""ratio and the mean B-allel frequency (BAF) of each bin. Optionally, the normal allele counts "" ""can be provided to add the BAF of each bin scaled by the normal BAF. The output is written on "" ""stdout."" ), formatter_class=argparse.RawTextHelpFormatter, ) parser.add_argument( ""BBFILE"", help=( ""A BB file containing a line for each bin in each sample and the corresponding values of read-depth "" ""ratio and B-allele frequency (BAF)"" ), ) parser.add_argument( ""-o"", ""--outsegments"", required=False, default=config.cluster_bins_gmm.outsegments, type=str, help=""Output filename for the segments computed by clustering bins (default: stdout)"", ) parser.add_argument( ""-O"", ""--outbins"", required=False, default=config.cluster_bins_gmm.outbins, type=str, help=""Output filename for a BB file adding the clusters (default: stdout)"", ) parser.add_argument( ""-d"", ""--diploidbaf"", type=float, required=False, default=config.cluster_bins_gmm.diploidbaf, help=( ""Maximum diploid-BAF shift used to determine the largest copy-neutral cluster and to rescale all the "" ""cluster inside this threshold accordingly (default: None, scaling is not performed)"" ), ) parser.add_argument( ""-tR"", ""--tolerancerdr"", type=float, required=False, default=config.cluster_bins_gmm.tolerancerdr, help=( ""Refine the clustering merging the clusters with this maximum difference in RDR values (default: None, "" ""gurobipy required)"" ), ) parser.add_argument( ""-tB"", ""--tolerancebaf"", type=float, required=False, default=config.cluster_bins_gmm.tolerancebaf, help=( ""Refine the clustering merging the clusters with this maximum difference in BAF values (default: None, "", ""gurobipy required)"", ), ) parser.add_argument( ""-u"", ""--bootclustering"", type=int, required=False, default=config.cluster_bins_gmm.bootclustering, help=( ""Number of points to add for bootstraping each bin to improve the clustering. Each point is generated "" ""by drawing its values from a normal distribution centered on the values of the bin. This can help the "" ""clustering when the input number of bins is low (default: 0)"" ), ) parser.add_argument( ""-dR"", ""--ratiodeviation"", type=float, required=False, default=config.cluster_bins_gmm.ratiodeviation, help=""Standard deviation of the read ratios used to generate the points in the clouds (default: 0.02)"", ) parser.add_argument( ""-dB"", ""--bafdeviation"", type=float, required=False, default=config.cluster_bins_gmm.bafdeviation, help=""Standard deviation of the BAFs used to generate the points in the clouds (default: 0.02)"", ) parser.add_argument( ""-e"", ""--seed"", type=int, required=False, default=config.cluster_bins_gmm.seed, help=""Random seed used for clustering AND the normal distributions used in the clouds (default: 0)"", ) parser.add_argument( ""-K"", ""--initclusters"", type=int, required=False, default=config.cluster_bins_gmm.initclusters, help=""The maximum number of clusters to infer (default: 50)"", ) parser.add_argument( ""-c"", ""--concentration"", type=float, required=False, default=config.cluster_bins_gmm.concentration, help=( ""Tuning parameter for clustering (concentration parameter for Dirichlet process prior). Higher favors "" ""more clusters, lower favors fewer clusters (default 0.02 = 1/K)."" ), ) parser.add_argument( ""-R"", ""--restarts"", type=int, required=False, default=config.cluster_bins_gmm.restarts, help=""Number of restarts performed by the clustering to choose the best (default: 10)"", ) parser.add_argument( ""-v"", ""--verbose"", action=""store_true"", default=config.cluster_bins_gmm.verbose, required=False, help=""Use verbose log messages"", ) parser.add_argument( ""--disablebar"", action=""store_true"", default=config.cluster_bins_gmm.disablebar, required=False, help=""Disable progress bar"", ) parser.add_argument( ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" ) args = parser.parse_args(args) ensure(isfile(args.BBFILE), ""The specified BB file does not exist!"") ensure( (args.diploidbaf is None) or (0.0 <= args.diploidbaf <= 0.5), ""The specified maximum for diploid-BAF shift must be a value in [0.0, 0.5]"", ) ensure(args.tolerancerdr >= 0, ""Tolerance-RDR parameter must be positive!"") ensure(args.tolerancebaf >= 0, ""Tolerance-BAF parameter must be positive!"") ensure(args.bootclustering >= 0, ""Bootclustering parameter must be positive!"") ensure(args.ratiodeviation >= 0, ""Ratio-deviation parameter must be positive!"") ensure(args.bafdeviation >= 0, ""BAF-deviation parameter must be positive!"") ensure(args.seed >= 0, ""Seed parameter must be positive!"") ensure(args.initclusters >= 0, ""Init-cluster parameter must be positive!"") ensure(args.concentration >= 0, ""Concentration parameter must be positive!"") ensure(args.restarts >= 1, ""Number of restarts must be positive!"") return { ""bbfile"": args.BBFILE, ""cloud"": args.bootclustering, ""diploidbaf"": args.diploidbaf, ""rdtol"": args.tolerancerdr, ""baftol"": args.tolerancebaf, ""ratiodeviation"": args.ratiodeviation, ""bafdeviation"": args.bafdeviation, ""seed"": args.seed, ""initclusters"": args.initclusters, ""concentration"": args.concentration, ""restarts"": args.restarts, ""verbose"": args.verbose, ""disable"": args.disablebar, ""outsegments"": args.outsegments, ""outbins"": args.outbins, } def parse_plot_bins_args(args=None): parser = argparse.ArgumentParser( prog=""hatchet plot-bins"", description=( ""Generate plots for read-depth ratio (RD), B-allele frequency (BAF), and clusters for genomic "", ""bins in multiple samples using .bb, .cbb, .seg files."", ), formatter_class=argparse.RawTextHelpFormatter, ) parser.add_argument(""INPUT"", help=""Input BBC file with RDR and BAF"") b, e = bcolors.BOLD, bcolors.ENDC parser.add_argument( ""-c"", ""--command"", required=False, type=str, default=config.plot_bins.command, help=( f""The command determining the plots to generate (default: all)\n\n\t{b}RD{e}: Plot the read-depth ratio "", f""(RD) values of the genomes for each sample.\n\n\t{b}CRD{e}: Plot the read-depth ratio (CRD) values of "", f""the genomes for each sample colored by corresponding cluster.\n\n\t{b}BAF{e}: Plot the B-allele "", f""frequency (BAF) values of the genomes for each sample.\n\n\t{b}CBAF{e}: Plot BAF values for each "", f""sample colored by corresponding cluster.\n\n\t{b}BB{e}: Plot jointly the values of read-depth ratio "", f""(RD) and B-allele frequency (BAF) for each bin in all samples and their density.\n\n\t{b}CBB{e}: Plot "", ""jointly the values of read-depth ratio (RD) and B-allele frequency (BAF) for each bin in all samples "", f""by coloring the bins depending on their cluster.\n\n\t{b}CLUSTER{e}: Plot jointly the values of "" f""read-depth ratio (RD) and B-allele frequency (BAF) for each cluster in all samples where the size of "", ""the markers is proportional to the number of bins."", ), ) parser.add_argument( ""-s"", ""--segfile"", required=False, type=str, default=config.plot_bins.segfile, help=""When the corresponding seg file is provided the clusters are also plotted (default: none)"", ) parser.add_argument( ""-m"", ""--colormap"", required=False, type=str, default=config.plot_bins.colormap, help=( ""Colormap to use for the colors in the plots, the available colormaps are the following "" ""{Set1, Set2, Paired, Dark2, tab10, tab20}"" ), ) parser.add_argument( ""-tC"", ""--chrthreshold"", required=False, type=int, default=config.plot_bins.chrthreshold, help=""Only covering at least this number of chromosomes are considered (default: None)"", ) parser.add_argument( ""-tS"", ""--sizethreshold"", required=False, type=float, default=config.plot_bins.sizethreshold, help=""Only covering at least this genome proportion (default: None)"", ) parser.add_argument( ""--resolution"", required=False, default=config.plot_bins.resolution, type=int, help=""Resolution of bins (default: bins are not merged)"", ) parser.add_argument( ""--xmin"", required=False, default=config.plot_bins.xmin, type=float, help=""Minimum value on x-axis for supported plots (default: inferred from data)"", ) parser.add_argument( ""--xmax"", required=False, default=config.plot_bins.xmax, type=float, help=""Maximum value on x-axis for supported plots (default: inferred from data)"", ) parser.add_argument( ""--ymin"", required=False, default=config.plot_bins.ymin, type=float, help=""Minimum value on y-axis for supported plots (default: inferred from data)"", ) parser.add_argument( ""--ymax"", required=False, default=config.plot_bins.ymax, type=float, help=""Maximum value on y-axis for supported plots (default: inferred from data)"", ) parser.add_argument( ""--figsize"", required=False, default=config.plot_bins.figsize, type=str, help='Size of the plotted figures in the form ""(X-SIZE, Y-SIZE)""', ) parser.add_argument( ""--markersize"", required=False, default=config.plot_bins.markersize, type=int, help=""Size of the markers (default: values inferred for each plot)"", ) parser.add_argument( ""--colwrap"", required=False, default=config.plot_bins.colwrap, type=int, help=""Wrapping the plots in this number of columnes (default: 2)"", ) parser.add_argument( ""--fontscale"", required=False, default=config.plot_bins.fontscale, type=float, help=""Font scale (default: 1)"", ) parser.add_argument( ""-x"", ""--rundir"", required=False, default=config.plot_bins.rundir, type=str, help=""Running dirrectory where output the results (default: current directory)"", ) parser.add_argument( ""--pdf"", action=""store_true"", default=config.plot_bins.pdf, required=False, help=""Output the bb_clustered figure in PDF format (default: PNG)"", ) parser.add_argument( ""--dpi"", required=False, default=config.plot_bins.dpi, type=int, help=""DPI of PNG images (default: 900)"", ) parser.add_argument( ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" ) args = parser.parse_args(args) ensure(isfile(args.INPUT), ""The specified BB file does not exist!"") ensure( args.command is None or args.command in ( ""RD"", ""CRD"", ""BAF"", ""CBAF"", ""BB"", ""CBB"", ""CLUSTER"", ), ""Unrecognized COMMAND!"", ) ensure( args.segfile is None or isfile(args.segfile), ""Specified seg-file does not exist!"", ) ensure( args.colormap in ( ""Set1"", ""Set2"", ""Set3"", ""Paired"", ""Accent"", ""Dark2"", ""tab10"", ""tab20"", ""husl"", ""hls"", ""muted"", ""colorblind"", ""Pastel1"", ""Pastel2"", ), ""Unrecognized colormap!"", ) ensure( args.resolution is None or args.resolution >= 1, ""Resolution must be greater than 1!"", ) ensure( args.chrthreshold is None or (0 <= args.chrthreshold <= 22), ""The chromosome threshold must be a integer in [0, 22]"", ) ensure(args.colwrap >= 1, ""Colwrap must be grater than 1!"") ensure(args.fontscale >= 0, ""Font scale must be positive!"") ensure( args.sizethreshold is None or (0 <= args.sizethreshold <= 1.0), ""The size threshold must be a real value in [0, 1]!"", ) if args.figsize is not None: try: parsed = args.figsize.strip().split("","") figsize = (float(parsed[0]), float(parsed[1])) except IndexError: error(""Wrong format of figsize!"", raise_exception=True) else: figsize = None ensure( isdir(args.rundir), ""Running directory either does not exists or is not a directory!"", ) return { ""input"": args.INPUT, ""command"": args.command, ""segfile"": args.segfile, ""ct"": args.chrthreshold, ""st"": args.sizethreshold, ""cmap"": args.colormap, ""resolution"": args.resolution, ""xmin"": args.xmin, ""xmax"": args.xmax, ""ymin"": args.ymin, ""ymax"": args.ymax, ""x"": args.rundir, ""figsize"": figsize, ""markersize"": args.markersize, ""colwrap"": args.colwrap, ""fontscale"": args.fontscale, ""pdf"": args.pdf, ""dpi"": args.dpi, } def extractChromosomes(samtools, normal, tumors, reference=None): """""" Parameters: samtools: path to samtools executable normal: tuple of (path to normal BAM file, string name) tumor: list of tuples (path to BAM file, string name) reference: path to FASTA file """""" # Read the names of sequences in normal BAM file normal_sq = getSQNames(samtools, normal[0]) # Extract only the names of chromosomes in standard formats chrm = set() no_chrm = set() for i in range(1, 23): if str(i) in normal_sq: no_chrm.add(str(i)) elif ""chr"" + str(i) in normal_sq: chrm.add(""chr"" + str(i)) else: sys.stderr.write( ( f""WARNING: a chromosome named either {i} or a variant of CHR{i} cannot be found in the normal "", ""BAM file\n"", ) ) for c in [""X"", ""Y""]: if c in normal_sq: no_chrm.add(c) elif ""chr"" + c in normal_sq: chrm.add(""chr"" + c) else: sys.stderr.write( ( f""WARNING: a chromosome named either {c} or a variant of CHR{c} cannot be found in the normal "", ""BAM file\n"", ) ) if len(chrm) == 0 and len(no_chrm) == 0: raise ValueError(""No chromosomes found in the normal BAM"") chromosomes = chrm if len(chrm) > len(no_chrm) else no_chrm # Check that chromosomes with the same names are present in each tumor BAM contain for tumor in tumors: tumor_sq = getSQNames(samtools, tumor[0]) if not chromosomes <= tumor_sq: sys.stderr.write( ""WARNING: chromosomes {} are not present in the tumor sample {}\n"".format( chromosomes - tumor_sq, tumor ) ) # Check consistency of chromosome names with the reference if reference is not None: stdout, stderr = subprocess.Popen( 'grep -e ""^>"" {}'.format(reference), stdout=subprocess.PIPE, shell=True, universal_newlines=True, ).communicate() if stderr is not None: raise ValueError(""Error in reading the reference: {}"".format(reference)) else: ref = set(c[1:].strip().split()[0] for c in stdout.strip().split(""\n"")) ensure( chromosomes <= ref, ( ""The given reference cannot be used because the chromosome names are inconsistent!\nChromosomes found "" f""in BAF files: {chromosomes}\nChromosomes with the same name found in reference genome: {ref}"", ), ) return sorted(list(chromosomes), key=numericOrder) def getSQNames(samtools, bamfile): header, stderr = subprocess.Popen( [samtools, ""view"", ""-H"", bamfile], stdout=subprocess.PIPE, shell=False, universal_newlines=True, ).communicate() if stderr is not None: raise ValueError( ""The header of the normal-sample BAM cannot be read with samtools!"" ) names = set() for line in header.strip().split(""\n""): line = line.split() if len(line) > 0 and line[0] == ""@SQ"": names.add(line[1].split("":"")[1].strip()) return names def parseRegions(region_file, chromosomes): res = {} for chro in chromosomes: res[chro] = [] nofound = set() with open(region_file, ""r"") as f: for line in f: split = line.strip().split() chro = split[0] if chro in chromosomes: res[chro].append((int(split[1]), int(split[2]))) else: nofound.add(chro) for c in nofound: log( msg=( f""The chromosome {c} present in the provided regions is non-autosome or is not present in the given "" ""BAM files\n"" ), level=""WARN"", ) for key in res: ensure( len(res[key]) != 0, f""The regions of chromosome {key} could not be determined."", ) res[key].sort(key=lambda x: x[0]) if not all( a[0] <= a[1] <= b[0] <= b[1] for a, b in zip(res[key], res[key][1:]) ): error( ( f""The regions provided for chromosome {key} are non-disjoint or a region start is greater than "", ""corresponding region end"", ), raise_exception=True, ) return res ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/combine_counts_fw.py",".py","17717","521","import sys import math import gzip from collections import defaultdict, deque import numpy as np import hatchet.utils.ProgressBar as pb import hatchet.utils.Supporting as sp from hatchet.utils.ArgParsing import parse_combine_counts_fw_args def main(args=None): sp.log(msg=""# Parsing and checking input arguments\n"", level=""STEP"") args = parse_combine_counts_fw_args(args) sp.logArgs(args, 80) np.random.seed(seed=args[""seed""]) sp.log( msg=""# Reading and checking the bin count files for computing read-depth ratios\n"", level=""STEP"", ) normalbins, tumorbins, chromosomes, normal, samples1 = readBINs( normalbins=args[""normalbins""], tumorbins=args[""tumorbins""] ) sp.log( msg=""# Reading and checking the allele count files for computing BAF\n"", level=""STEP"", ) tumorbafs, chromosomes2, samples2 = readBAFs(tumor=args[""tumorbafs""]) if samples1 != samples2: raise ValueError( sp.error( ""The names of tumor samples are different in bin counts and allele counts!"" ) ) else: samples = samples1 if args[""phase""] is not None: sp.log( msg=""# Reading phases of heterozygous germline SNPs\n"", level=""STEP"", ) phase = readPhase(args[""phase""]) else: phase = None totalcounts = None if args[""totalcounts""] is not None: sp.log( msg=""# Reading and checking the total read count files\n"", level=""STEP"", ) totalcounts = readTotalCounts( filename=args[""totalcounts""], samples=samples, normal=normal ) sp.log( msg=""# Combine the bin and allele counts to obtain BAF and RD for each bin\n"", level=""STEP"", ) result = combine( normalbins=normalbins, tumorbins=tumorbins, tumorbafs=tumorbafs, diploidbaf=args[""diploidbaf""], totalcounts=totalcounts, chromosomes=chromosomes, samples=samples, normal=normal, gamma=args[""gamma""], verbose=args[""verbose""], disable=args[""disable""], phase=phase, block=args[""block""], ) sys.stdout.write(""#CHR\tSTART\tEND\tSAMPLE\tRD\t#SNPS\tCOV\tALPHA\tBETA\tBAF\n"") nonzerobaf = lambda rk: all(sample[4] + sample[5] > 0 for sample in rk) result = {key: result[key] for key in result if nonzerobaf(result[key])} sexchroms = set([""X"", ""Y"", ""chrX"", ""chrY""]) for key in sorted( result, key=(lambda x: (sp.numericOrder(x[0]), int(x[1]), int(x[2]))) ): if key[0] in sexchroms: # skip sex chromosomes since there's no good way to handle them in this version continue for sample in sorted(result[key]): sys.stdout.write( ""{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\n"".format( key[0], key[1], key[2], sample[0], sample[1], sample[2], sample[3], sample[4], sample[5], sample[6], ) ) def combine( normalbins, tumorbins, tumorbafs, diploidbaf, totalcounts, chromosomes, samples, normal, gamma, verbose=False, disable=False, phase=None, block=None, ): res = {} ctumorbafs = {c: sorted(tumorbafs[c], key=(lambda x: x[1])) for c in tumorbafs} if not disable: progress_bar = pb.ProgressBar(total=len(tumorbins), length=40, verbose=verbose) for bi in sorted( tumorbins, key=(lambda x: (sp.numericOrder(x[0]), int(x[1]), int(x[2]))), ): if bi[0] in ctumorbafs: # Extract counts normal_count = normalbins[bi][1] tumor_counts = {x[0]: x[1] for x in tumorbins[bi]} # Extract overlapping SNPs: option 2 # tumorover = [x for x in ctumorbafs[bi[0]] if bi[1] <= x[1] <= bi[2]] # ctumorbafs[bi[0]] = [x for x in ctumorbafs[bi[0]] if x not in tumorover] tumorover = [] for i, x in enumerate(ctumorbafs[bi[0]]): if bi[1] <= x[1] <= bi[2]: tumorover.append(x) elif x[1] > bi[2]: ctumorbafs[bi[0]] = ctumorbafs[bi[0]][i:] break # Partition the overlapping SNPs by samples tpartition = { sample: [x for x in tumorover if x[0] == sample] for sample in samples } # Check the bin to be covered in each sample and non-zero count in normal if ( sum(len(tpartition[key]) != 0 for key in tpartition) == len(samples) and normal_count != 0 ): # Compute ratios ratios = { sample: float(tumor_counts[sample]) / float(normal_count) for sample in samples } # Compute normalizing factor by total number of reads if provided if totalcounts is not None: totalfactor = { sample: float(totalcounts[normal]) / float(totalcounts[sample]) for sample in samples } ratios = { sample: float(ratios[sample]) * float(totalfactor[sample]) for sample in samples } # Compute number of SNPs covering each bin and the average coverage snps = {sample: len(tpartition[sample]) for sample in samples} cov = { sample: float(sum(x[2] + x[3] for x in tpartition[sample])) / float(len(tpartition[sample])) for sample in samples } # Compute BAFs if phase is None: records = computeBAFs( partition=tpartition, diploidbaf=diploidbaf, samples=samples, ) else: records = computeBAFs( partition=tpartition, diploidbaf=diploidbaf, samples=samples, phase=phase[bi[0]], block=block, ) parsed = {record[0]: record for record in records} res[bi] = [ ( parsed[sample][0], ratios[sample], snps[sample], cov[sample], parsed[sample][1], parsed[sample][2], parsed[sample][3], ) for sample in samples ] else: if verbose and normal_count != 0: sp.log( msg=( f'The bin ({bi[1]}, {bi[2]}) in chromosomes ""{bi[0]}"" has been discarded because there ' ""are no covering SNPs in each tumor or normal sample\n"" ), level=""WARN"", ) elif verbose and normal_count == 0: sp.log( msg=( f'The bin ({bi[1]}, {bi[2]}) in chromosomes ""{bi[0]}"" has been discarded because normal ' ""read count is zero\n"" ), level=""WARN"", ) if not disable: progress_bar.progress( advance=True, msg=""Combine bin ({}, {}) in chromosome {}"".format(bi[1], bi[2], bi[0]), ) return res def computeBAFs(partition, samples, diploidbaf, phase=None, block=0): if phase is None: tpartition = partition else: select = lambda L, s: blocking( list(filter(lambda o: o[1] in phase, L)), s, phase, block ) tpartition = {sample: select(partition[sample], sample) for sample in samples} alphas = { sample: sum(int(min(x[2], x[3])) for x in tpartition[sample]) for sample in samples } betas = { sample: sum(int(max(x[2], x[3])) for x in tpartition[sample]) for sample in samples } mirrorbaf = { sample: (float(alphas[sample]) / float(alphas[sample] + betas[sample])) if (alphas[sample] + betas[sample]) > 0 else 0.5 for sample in samples } return [ (sample, alphas[sample], betas[sample], mirrorbaf[sample]) for sample in samples ] def blocking(L, sample, phase, blocksize): result = [] if len(L) == 0: return result que = deque(sorted(L, key=(lambda v: v[1]))) omap = {} for bk in range(min(o[1] for o in L), max(o[1] for o in L) + 1, blocksize): block = (sample, bk, 0, 0) while que and bk <= que[0][1] < bk + blocksize: o = que.popleft() if phase[o[1]] == ""0|1"": block = (sample, bk, block[2] + o[2], block[3] + o[3]) elif phase[o[1]] == ""1|0"": block = (sample, bk, block[2] + o[3], block[3] + o[2]) else: assert False, ""Found a wrong phase value"" omap[o] = bk if block[2] + block[3] > 0: result.append(block) return result def readBINs(normalbins, tumorbins): normalBINs = {} tumorBINs = {} normal = set() samples = set() normal_chr = set() tumor_chr = set() # Read normal bin counts with open(normalbins, ""r"") as f: for line in f: parsed = line.strip().split()[:5] normal_chr.add(parsed[0]) normal.add(parsed[3]) if (parsed[0], int(parsed[1]), int(parsed[2])) not in normalBINs: normalBINs[parsed[0], int(parsed[1]), int(parsed[2])] = ( parsed[3], int(parsed[4]), ) else: raise ValueError( sp.error( ""Found multiple lines for the same interval in the normal bin counts!"" ) ) # Check normal bin counts if len(normal) > 1: raise ValueError(sp.error(""Found multiple samples in normal bin counts!"")) prev_r = -1 prev_c = -1 for key in sorted( normalBINs, key=(lambda x: (sp.numericOrder(x[0]), int(x[1]), int(x[2]))), ): l, r = int(key[1]), int(key[2]) if l > r and prev_c == key[0]: raise ValueError( sp.error( ""Found an interval with START {} greater than END {} in normal bin counts!"".format( key[1], key[2] ) ) ) if l < prev_r and prev_c == key[0]: raise ValueError( sp.error( ( f""Found overlapping intervals one ending with {prev_r} and the next starting with {key[1]} in "" ""normal bin counts!"" ) ) ) prev_r = r prev_c = key[0] # Read tumor bin counts with open(tumorbins, ""r"") as f: for line in f: parsed = line.strip().split()[:5] tumor_chr.add(parsed[0]) samples.add(parsed[3]) try: tumorBINs[parsed[0], int(parsed[1]), int(parsed[2])].add( (parsed[3], int(parsed[4])) ) except KeyError: tumorBINs[parsed[0], int(parsed[1]), int(parsed[2])] = set() tumorBINs[parsed[0], int(parsed[1]), int(parsed[2])].add( (parsed[3], int(parsed[4])) ) # Check tumor bin counts prev_r = -1 prev_c = -1 num_samples = len(samples) for key in sorted( tumorBINs, key=(lambda x: (sp.numericOrder(x[0]), int(x[1]), int(x[2]))), ): l, r = int(key[1]), int(key[2]) if len(tumorBINs[key]) != num_samples: raise ValueError( sp.error( ""Found multiple lines for the same interval in the tumor bin counts!"" ) ) if l > r and prev_c == key[0]: raise ValueError( sp.error( ""Found an interval with START {} greater than END {} in tumor bin counts!"".format( key[1], key[2] ) ) ) if l < prev_r and prev_c == key[0]: raise ValueError( sp.error( ( f""Found overlapping intervals one ending with {prev_r} and the next starting with {key[1]} in "" ""tumor bin counts!"" ) ) ) prev_r = r prev_c = key[0] if normal_chr != tumor_chr: raise ValueError( sp.error(""The chromosomes in normal and tumor bin counts are different!"") ) if set(normalBINs) != set(tumorBINs): raise ValueError( sp.error(""The bins of the normal and tumor samples are different!"") ) chromosomes = sorted(list(normal_chr), key=sp.numericOrder) return normalBINs, tumorBINs, chromosomes, normal.pop(), samples def readBAFs(tumor): tumorBAFs = {} tumor_chr = set() # Read tumor bafs samples = set() with open(tumor, ""r"") as f: for line in f: parsed = line.strip().split()[:5] sample = parsed[2] chromosome = parsed[0] pos = int(parsed[1]) ref = int(parsed[3]) alt = int(parsed[4]) tumor_chr.add(chromosome) samples.add(sample) baf = float(min(ref, alt)) / float(ref + alt) if ref + alt > 0 else 0.5 try: tumorBAFs[chromosome].append((sample, pos, ref, alt, baf)) except KeyError: tumorBAFs[chromosome] = [(sample, pos, ref, alt, baf)] # Check tumor bafs for key in tumorBAFs: tumorBAFs[key].sort(key=(lambda x: x[1])) if len(tumorBAFs[key]) > len(set((x[0], x[1]) for x in tumorBAFs[key])): raise ValueError( sp.error(""A position is present multiple times in the tumor samples!"") ) chromosomes = sorted(list(tumor_chr), key=sp.numericOrder) return tumorBAFs, chromosomes, samples def readPhase(f): phased = defaultdict(lambda: dict()) if not f.endswith("".gz""): raise ValueError( ""Please make sure your phased VCF file is compressed with gzip with a .gz suffix"" ) with gzip.open(f, ""rt"") as i: for l in i: p = l.strip().split() if len(l) > 1 and p[0][0] != ""#"": zeroone = ""0|1"" in l onezero = ""1|0"" in l if zeroone or onezero: if zeroone and onezero: raise ValueError( ""Found a record in phased positions which contains both phases 0|1 and 1|0!"" ) if p[0] in phased[p[0]]: raise ValueError(""Found a duplicate phased position!"") phased[p[0]][int(p[1])] = ""0|1"" if zeroone else ""1|0"" return phased def splitBAF(baf, scale): BAF = float(baf) BAF = min(BAF, 1.0 - BAF) SUM = float(scale) roundings = [] roundings.append((int(math.floor(BAF * SUM)), int(math.floor((1.0 - BAF) * SUM)))) roundings.append((int(math.floor(BAF * SUM)), int(math.ceil((1.0 - BAF) * SUM)))) roundings.append((int(math.ceil(BAF * SUM)), int(math.floor((1.0 - BAF) * SUM)))) roundings.append((int(math.ceil(BAF * SUM)), int(math.ceil((1.0 - BAF) * SUM)))) roundings = [(int(min(a, b)), int(max(a, b))) for (a, b) in roundings] estimations = [ float(a) / float(a + b) if a + b > 0 else 1.0 for (a, b) in roundings ] diff = [abs(est - BAF) for est in estimations] best = np.argmin(diff) return roundings[best][0], roundings[best][1] def readTotalCounts(filename, samples, normal): normalfound = False counts = {} found = set() with open(filename, ""r"") as f: for line in f: parsed = line.strip().split() if parsed[0] in found: raise ValueError( sp.error( ""Found multiple total read counts for the same sample {}!"".format( parsed[0] ) ) ) if parsed[0] == normal: normalfound = True else: found.add(parsed[0]) counts[parsed[0]] = int(parsed[1]) if samples < found: raise ValueError( sp.error( ""Found total read counts for samples that are not present in the input!"" ) ) elif found < samples: raise ValueError( sp.error(""Missing total read counts for some samples present in the input!"") ) elif not normalfound: raise ValueError(sp.error(""Missing total read counts for normal sample!"")) else: return counts if __name__ == ""__main__"": main() ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/count_reads_fw.py",".py","6039","204","import sys import os.path import hatchet.utils.BAMBinning as bb import hatchet.utils.TotalCounting as tc import hatchet.utils.ArgParsing as ap from hatchet.utils.Supporting import log, close, error def main(args=None): log(msg=""# Parsing and checking input arguments\n"", level=""STEP"") args = ap.parse_count_reads_fw_arguments(args) logArgs(args, 80) if args[""regions""] is None: log( msg=""# Retrieving genomic regions to consider from maximum chromosome length\n"", level=""STEP"", ) regions = knownRegions(args[""refdict""], args[""chromosomes""]) else: log( msg=""# Checking the consistency of the given regions\n"", level=""STEP"", ) regions = ap.parseRegions(args[""regions""], args[""chromosomes""]) if args[""verbose""]: msg = ""regions: "" for c in args[""chromosomes""]: msg += "" {}: {}"".format(c, regions[c]) msg += ""\n"" log(msg=msg, level=""INFO"") log(msg=""# Binning and counting the normal sample\n"", level=""STEP"") normal_bins = bb.bin( samtools=args[""samtools""], samples=[args[""normal""]], chromosomes=args[""chromosomes""], num_workers=args[""j""], q=args[""q""], size=args[""size""], regions=regions, verbose=args[""verbose""], ) if not normal_bins: close(""No bins in the normal sample!\n"") log( msg=""# Writing the read counts for bins of normal sample\n"", level=""STEP"", ) handle = ( open(args[""outputNormal""], ""w"") if args[""outputNormal""] is not None else sys.stdout ) for c in args[""chromosomes""]: for samplename, chromosome, start, stop, n_reads in normal_bins[ args[""normal""][1], c ]: handle.write( ""\t"".join( [ str(chromosome), str(start), str(stop), samplename, str(n_reads), ] ) + ""\n"" ) if handle is not sys.stdout: handle.close() log(msg=""# Binning and counting the tumor samples\n"", level=""STEP"") tumor_bins = bb.bin( samtools=args[""samtools""], samples=args[""samples""], chromosomes=args[""chromosomes""], num_workers=args[""j""], q=args[""q""], size=args[""size""], regions=regions, verbose=args[""verbose""], ) if not tumor_bins: close(""No bins in the tumor samples!\n"") log( msg=""# Writing the read counts for bins of tumor samples\n"", level=""STEP"", ) handle = ( open(args[""outputTumors""], ""w"") if args[""outputTumors""] is not None else sys.stdout ) for sample in sorted(args[""samples""]): for c in args[""chromosomes""]: for samplename, chromosome, start, stop, n_reads in tumor_bins[ sample[1], c ]: handle.write( ""\t"".join( [ str(chromosome), str(start), str(stop), samplename, str(n_reads), ] ) + ""\n"" ) if handle is not sys.stdout: handle.close() log( msg=""# Counting total number of reads for normal and tumor samples\n"", level=""STEP"", ) total_counts = tc.tcount( samtools=args[""samtools""], samples=({args[""normal""]} | args[""samples""]), chromosomes=args[""chromosomes""], num_workers=args[""j""], q=args[""q""], verbose=args[""verbose""], ) try: total = { sample[1]: sum( total_counts[sample[1], chromosome] for chromosome in args[""chromosomes""] ) for sample in args[""samples""] } total[args[""normal""][1]] = sum( total_counts[args[""normal""][1], chromosome] for chromosome in args[""chromosomes""] ) except KeyError: raise KeyError( error( ""Either a chromosome or a sample has not been considered in the total counting!"" ) ) log( msg=""# Writing the total read counts for all samples in {}\n"".format( args[""outputTotal""] ), level=""STEP"", ) with open(args[""outputTotal""], ""w"") as f: f.write(""{}\t{}\n"".format(args[""normal""][1], total[args[""normal""][1]])) for sample in sorted(args[""samples""]): f.write(""{}\t{}\n"".format(sample[1], total[sample[1]])) def knownRegions(refdict, chromosomes): ends = {c: None for c in chromosomes} assert os.path.isfile(refdict) with open(refdict, ""r"") as i: for l in i: if ""@SQ"" in l: assert ""SN:"" in l and ""LN:"" in l c = l.split(""SN:"")[1].split()[0] if c in chromosomes: end = int(l.split(""LN:"")[1].split()[0]) ends[c] = end if None in ends.values(): log( msg=( ""The following chromosomes have not been found in the dictionary of the reference genome: "" ""\n\t{}"" ).format("","".join([c for c in ends if ends[c] is None])), level=""WARN"", ) res = {} for c in chromosomes: if ends[c] is None: raise ValueError( f""Length of chromosome {c} could not be determined. Are you using the correct reference genome?"" ) res[c] = [(0, ends[c])] return res def logArgs(args, width): text = ""\n"" for key in args: text += ""\t{}: {}\n"".format(key, args[key]) log(msg=text, level=""INFO"") if __name__ == ""__main__"": main() ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/commands.py",".py","818","37","# All supported HATCHet commands commands = ( ""count-reads"", ""count-reads-fw"", ""genotype-snps"", ""count-alleles"", ""combine-counts"", ""combine-counts-fw"", ""cluster-bins"", ""plot-bins"", ""compute-cn"", ""plot-cn"", ""run"", ""check"", ""download-panel"", ""phase-snps"", ""cluster-bins-gmm"", ""plot-cn-1d2d"", ""plot-bins-1d2d"", ) # Support for old command names as they've been used in earlier versions of HATCHet command_aliases = { ""binBAM"": ""count-reads-fw"", ""SNPCaller"": ""genotype-snps"", ""deBAF"": ""count-alleles"", ""comBBo"": ""combine-counts-fw"", ""cluBB"": ""cluster-bins-gmm"", ""BBot"": ""plot-bins"", ""solve"": ""compute-cn"", ""BBeval"": ""plot-cn"", ""PhasePrep"": ""download-panel"", ""Phase"": ""phase-snps"", ""check-solver"": ""check"", } ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/download_panel.py",".py","5817","155","import os import os.path import subprocess as pr import gzip import hatchet.utils.ArgParsing as ap from hatchet.utils.Supporting import log, logArgs, error, download, checksum from hatchet import config def main(args=None): log(msg=""# log notes\n"", level=""STEP"") args = ap.parse_download_panel_arguments(args) logArgs(args) os.makedirs(args[""refpaneldir""], exist_ok=True) # download reference panel, prepare files for liftover if args[""refpanel""] == ""1000GP_Phase3"": # download 1000GP ref panel download( url=config.urls.onekgp, dirpath=args[""refpaneldir""], sentinel_file=os.path.join(""1000GP_Phase3"", ""1000GP_Phase3.sample""), ) else: error( 'Currently, only the 1000 genome panel aligned to GRCh37 without ""chr"" prefix is supported\n', raise_exception=True, ) # download necessary liftover files; 1000GP in hg19 coordinates # if users aligned reads to the hg38 build, we need to liftover coordinates to the reference panel (hg38 -> hg19) # since the 1000GP panel is in hg19 coordinates, we need to download (1) hg19 genome and (2) chain files # for liftover via picard dwnld_refpanel_genome(path=args[""refpaneldir""]) dwnld_chains(dirpath=args[""refpaneldir""]) # if users aligned reads to the same reference genome as used in the reference panel, liftover isn't required, but # there could be different naming conventions of chromosomes, with or without the 'chr' prefix. The 1000GP reference # panel does NOT use 'chr' prefix, so input into shapeit also should not have this mk_rename_file(path=args[""refpaneldir""]) def dwnld_chains(dirpath): def mod_chain(infile, sample_chr, refpanel_index, sample_index): if sample_chr: name = infile.strip("".gz"").replace(""over"", ""chr"") else: name = infile.strip("".gz"").replace(""over"", ""no_chr"") with open(name, ""w"") as new: with gzip.open(infile, ""rt"") as f: for line in f: if line.startswith(""chain""): line = line.split() if not config.urls.refpanel_genome_chr_notation: line[refpanel_index] = line[refpanel_index].replace( ""chr"", """" ) if not sample_chr: line[sample_index] = line[sample_index].replace(""chr"", """") new.write("" "".join(line) + ""\n"") else: new.write(line) return name hg38tohg19 = download( url=config.urls.refpanel_hg38tohg19, dirpath=dirpath, overwrite=False, extract=False, ) hg19tohg38 = download( url=config.urls.refpanel_hg19tohg38, dirpath=dirpath, overwrite=False, extract=False, ) # make all necessary chain files to convert from hg38 (w/ or w/out chr notation) to hg19 (no chr notation), # and also to lift back over from hg19 (no chr notation) to hg38 (w/ or w/out chr notation). # modify chr notation of hg38ToHg19, ref panel chr in 7th field, sample chr in 2nd field mod_chain(hg38tohg19, sample_chr=True, refpanel_index=7, sample_index=2) mod_chain(hg38tohg19, sample_chr=False, refpanel_index=7, sample_index=2) # modify chr notation of hg19ToHg38, ref panel chr in 2nd field, sample chr in 7th field mod_chain(hg19tohg38, sample_chr=True, refpanel_index=2, sample_index=7) mod_chain(hg19tohg38, sample_chr=False, refpanel_index=2, sample_index=7) def dwnld_refpanel_genome(path): newref = os.path.join(path, ""hg19_no_chr.fa"") if not os.path.isfile(newref): # If the genome reference file used in other parts of HATCHet matches the one we want, use it reference_file = config.paths.reference if ( os.path.isfile(reference_file) and checksum(reference_file) == config.urls.refpanel_genome_checksum ): out = reference_file else: out = download(config.urls.refpanel_genome, dirpath=path, extract=False) _open, _mode = open, ""r"" if out.endswith(""gz""): _open, _mode = gzip.open, ""rt"" # change chr notation with open(newref, ""w"") as new: with _open(out, _mode) as f: for line in f: if line.startswith("">""): new.write(line.replace(""chr"", """")) else: new.write(line) # make dict file dict_file = newref.replace("".fa"", "".dict"") samtools = os.path.join(config.paths.samtools, ""samtools"") cmd = f""{samtools} dict {newref} > {dict_file}"" errname = os.path.join(path, ""samtools.log"") with open(errname, ""w"") as err: run = pr.run( cmd, stdout=err, stderr=err, shell=True, universal_newlines=True, ) if run.returncode != 0: raise ValueError( error( f""Samtools dict creation failed, please check errors in {errname}!"" ) ) else: os.remove(errname) return newref def mk_rename_file(path): # makes rename_chrs1.txt for removing ""chr"", rename_chrs2.txt for adding ""chr"" names = [os.path.join(path, f""rename_chrs{i}.txt"") for i in range(1, 3)] for i, n in enumerate(names): with open(n, ""w"") as f: for j in range(1, 23): f.write(f""chr{j} {j}\n"") if i == 0 else f.write(f""{j} chr{j}\n"") return names if __name__ == ""__main__"": main() ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/cluster_bins_gmm.py",".py","18400","549","import sys import math import numpy as np from collections import Counter from hatchet.utils.ArgParsing import parse_cluster_bins_gmm_args import hatchet.utils.Supporting as sp def main(args=None): sp.log(msg=""# Parsing and checking input arguments\n"", level=""STEP"") args = parse_cluster_bins_gmm_args(args) sp.logArgs(args, 80) sp.log(msg=""# Reading the combined BB file\n"", level=""STEP"") combo, samples = readBB(args[""bbfile""]) sp.log(msg=""# Format data to cluster\n"", level=""STEP"") points, bintoidx = getPoints(data=combo, samples=samples) clouds = None if args[""cloud""] > 0: sp.log(msg=""# Bootstrap each bin for clustering\n"", level=""STEP"") clouds = generateClouds( points=points, density=args[""cloud""], seed=args[""seed""], sdeven=args[""ratiodeviation""], sdodd=args[""bafdeviation""], ) sp.log( msg=""# Clustering bins by RD and BAF across tumor samples\n"", level=""STEP"", ) mus, sigmas, clusterAssignments, numPoints, numClusters = cluster( points=points, clouds=clouds, K=args[""initclusters""], concentration_prior=args[""concentration""], restarts=args[""restarts""], seed=args[""seed""], ) if args[""rdtol""] > 0.0 or args[""baftol""] > 0.0: sp.log(msg=""# Refining clustering using given tolerances\n"", level=""STEP"") before = len(set(clusterAssignments)) clusterAssignments, numClusters = refineClustering( combo=combo, assign=clusterAssignments, assignidx=bintoidx, samples=samples, rdtol=args[""rdtol""], baftol=args[""baftol""], ) sp.log( msg=""The number of clusters have been reduced from {} to {} with given tolerances\n"".format( before, numClusters ), level=""INFO"", ) clusterAssignments = reindex(clusterAssignments) sp.log(msg=""# Writing BBC output with resulting clusters\n"", level=""STEP"") if args[""outbins""] is None: outbins = sys.stdout else: outbins = open(args[""outbins""], ""w"") outbins.write( ""#CHR\tSTART\tEND\tSAMPLE\tRD\t#SNPS\tCOV\tALPHA\tBETA\tBAF\tCLUSTER\n"" ) for key in sorted( combo, key=(lambda x: (sp.numericOrder(x[0]), int(x[1]), int(x[2]))) ): for sample in sorted(combo[key]): outbins.write( ""{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\n"".format( key[0], key[1], key[2], sample[0], sample[1], sample[2], sample[3], sample[4], sample[5], sample[6], clusterAssignments[bintoidx[key]], ) ) if outbins is not sys.stdout: outbins.close() sp.log(msg=""# Segmenting bins\n"", level=""STEP"") clusters = { cluster: set( key for key in combo if clusterAssignments[bintoidx[key]] == cluster ) for cluster in set(clusterAssignments) } segments = segmentBins(bb=combo, clusters=clusters, samples=samples) if args[""diploidbaf""] is not None: sp.log( msg=( ""# Determining the largest cluster as diploid or tetraploid and rescaling all the clusters inside the "" ""threshold accordingly\n"" ), level=""STEP"", ) segments = scaleBAF( segments=segments, samples=samples, diploidbaf=args[""diploidbaf""] ) sp.log(msg=""# Writing REF output with resulting segments\n"", level=""STEP"") if args[""outsegments""] is None: outsegments = sys.stdout else: outsegments = open(args[""outsegments""], ""w"") outsegments.write(""#ID\tSAMPLE\t#BINS\tRD\t#SNPS\tCOV\tALPHA\tBETA\tBAF\n"") for key in sorted(segments): for sample in sorted(segments[key]): record = segments[key][sample] outsegments.write( ""{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\n"".format( key, sample, record[0], record[1], record[2], record[3], record[4], record[5], record[6], ) ) if outsegments is not sys.stdout: outsegments.close() def readBB(bbfile): read = {} samples = set() with open(bbfile, ""r"") as f: for line in f: if line[0] != ""#"": parsed = line.strip().split() chromosome = parsed[0] start = int(parsed[1]) end = int(parsed[2]) sample = parsed[3] rd = float(parsed[4]) snps = int(parsed[5]) cov = float(parsed[6]) alpha = int(parsed[7]) beta = int(parsed[8]) baf = float(parsed[9]) samples.add(sample) try: read[chromosome, start, end].append( (sample, rd, snps, cov, alpha, beta, baf) ) except KeyError: read[chromosome, start, end] = [ (sample, rd, snps, cov, alpha, beta, baf) ] nonzeroab = lambda rb: all(rec[4] + rec[5] > 0 for rec in rb) newread = {b: read[b] for b in read if nonzeroab(read[b])} diff = len(read.keys()) - len(newread.keys()) if diff > 0: sp.log( msg=""{} bins have been discarded because no covered by any SNP\n"".format( diff ), level=""WARN"", ) return newread, samples def getPoints(data, samples): idx = 0 points = [] bintoidx = {} for bi in sorted( data, key=(lambda x: (sp.numericOrder(x[0]), int(x[1]), int(x[2]))) ): partition = {} for x in data[bi]: if x[0] in partition: raise ValueError( sp.error( ""Found a bin ({}, {}) in chromosome {} defined multiple times for the same sample!"".format( bi[1], bi[2], bi[0] ) ) ) else: partition[x[0]] = [x[1], x[-1]] if len(partition) != len(samples): raise ValueError( sp.error( ""Found a bin ({}, {}) in chromosome {} that is not covered in all the samples!"".format( bi[1], bi[2], bi[0] ) ) ) points.append([e for sample in samples for e in partition[sample]]) bintoidx[bi] = idx idx += 1 return points, bintoidx def cluster(points, clouds=None, concentration_prior=None, K=100, restarts=10, seed=0): """""" Clusters a set of data points lying in an arbitrary number of clusters. Arguments: data (list of lists of floats): list of data points to be clustered. clouds (list or lists of floats, same second dimension as data): bootstrapped bins for clustering sampleName (string): The name of the input sample. concentration_prior (float): Tuning parameter for clustering, must be between 0 and 1. Used to determine concentration of points in clusters -- higher favors more clusters, lower favors fewer clusters. K (int): maximum number of clusters to infer restarts (int): number of initializations to try for GMM seed (int): random number generator seed for GMM Returns: mus (list of lists of floats): List of cluster means. sigmas (list of 2D lists of floats): List of cluster covariances. clusterAssignments (list of ints): The assignment of each interval to a cluster, where an entry j at index i means the ith interval has been assigned to the jth meta-interval. numPoints (list of ints): Number of points assigned to each cluster numClusters (int): The number of clusters. """""" from sklearn.mixture import BayesianGaussianMixture from collections import Counter sp.log( msg=""## Clustering with K={} and c={}...\n"".format(K, concentration_prior), level=""INFO"", ) total = list(points) if clouds is not None: total.extend(list(clouds)) npArray = np.array(total) gmm = BayesianGaussianMixture( n_components=K, n_init=restarts, weight_concentration_prior=concentration_prior, max_iter=int(1e6), random_state=seed, ) targetAssignments = gmm.fit_predict(npArray) targetAssignments = targetAssignments[: len(points)] mus = gmm.means_ sigmas = gmm.covariances_ cntr = Counter(targetAssignments) numPoints = [cntr[i] if i in cntr else 0 for i in range(K)] numClusters = len(cntr) return mus, sigmas, targetAssignments, numPoints, numClusters def refineClustering(combo, assign, assignidx, samples, rdtol, baftol): assignment = {b: assign[assignidx[b]] for b in combo} clusters = set(assignment[b] for b in assignment) size = {c: float(sum(c == assignment[b] for b in combo)) for c in clusters} getbaf = lambda c, p: float( sum(e[6] for b in combo for e in combo[b] if assignment[b] == c and e[0] == p) ) baf = {c: {p: getbaf(c, p) / size[c] for p in samples} for c in clusters} getrdr = lambda c, p: float( sum(e[1] for b in combo for e in combo[b] if assignment[b] == c and e[0] == p) ) rdr = {c: {p: getrdr(c, p) / size[c] for p in samples} for c in clusters} mbaf = lambda c: {p: baf[c][p] for p in samples} mrdr = lambda c: {p: rdr[c][p] for p in samples} merge = { c: {""BAF"": mbaf(c), ""RDR"": mrdr(c), ""SIZE"": size[c], ""CLUS"": {c}} for c in clusters } def mergable(m): checkrdr = lambda f, s: False not in set( abs(m[f][""RDR""][p] - m[s][""RDR""][p]) <= rdtol for p in samples ) checkbaf = lambda f, s: False not in set( abs(m[f][""BAF""][p] - m[s][""BAF""][p]) <= baftol for p in samples ) check = lambda f, s: checkrdr(f, s) and checkbaf(f, s) varrdr = lambda f, s: sum(abs(m[f][""RDR""][p] - m[s][""RDR""][p]) for p in samples) varbaf = lambda f, s: sum(abs(m[f][""BAF""][p] - m[s][""BAF""][p]) for p in samples) var = lambda f, s: varrdr(f, s) + varbaf(f, s) seq = sorted(m, key=(lambda x: m[x][""SIZE""])) for idx, f in enumerate(seq): opts = { s: var(f, s) for s in seq[idx + 1 :] for p in samples if s != f and check(f, s) } if len(opts) > 0: first = f break if len(opts) > 0: f = first return first, sp.argmin(opts) else: None m = mergable(merge) while m is not None: m1 = m[0] m2 = m[1] tot = float(merge[m1][""SIZE""] + merge[m2][""SIZE""]) newbaf = { p: float( merge[m1][""BAF""][p] * merge[m1][""SIZE""] + merge[m2][""BAF""][p] * merge[m2][""SIZE""] ) / tot for p in samples } newrdr = { p: float( merge[m1][""RDR""][p] * merge[m1][""SIZE""] + merge[m2][""RDR""][p] * merge[m2][""SIZE""] ) / tot for p in samples } newclu = merge[m1][""CLUS""] | merge[m2][""CLUS""] merge = {c: merge[c] for c in merge if c != m1 and c != m2} if len(merge) == 0: merge = {} merge[m1] = {""BAF"": newbaf, ""RDR"": newrdr, ""SIZE"": tot, ""CLUS"": newclu} m = mergable(merge) newassign = [-1 for i in range(len(assign))] for b in combo: get = [c for c in merge if assign[assignidx[b]] in merge[c][""CLUS""]] assert len(get) == 1 newassign[assignidx[b]] = get[0] assert -1 not in set(newassign) return newassign, len(merge) def generateClouds(points, density, seed, sdeven=0.02, sdodd=0.02): res = [] resappend = res.append for point in points: np.random.seed(seed=seed) for d in range(density): normal = np.random.normal newpoint = [ normal(point[i], sdeven) if i % 2 == 0 else normal(point[i], sdodd) for i in range(len(point)) ] resappend(newpoint) return res def segmentBins(bb, clusters, samples): sbb = {bi: {record[0]: record[1:] for record in bb[bi]} for bi in bb} nbins = { cluster: {sample: len(clusters[cluster]) for sample in samples} for cluster in clusters } rd = { cluster: { sample: float(sum(sbb[bi][sample][0] for bi in clusters[cluster])) / float(len(clusters[cluster])) for sample in samples } for cluster in clusters } nsnps = { cluster: { sample: sum(sbb[bi][sample][1] for bi in clusters[cluster]) for sample in samples } for cluster in clusters } cov = { cluster: { sample: float(sum(sbb[bi][sample][2] for bi in clusters[cluster])) / float(len(clusters[cluster])) for sample in samples } for cluster in clusters } return minSegmentBins(sbb, nbins, rd, nsnps, cov, clusters, samples) def minSegmentBins(sbb, nbins, rd, nsnps, cov, clusters, samples): alpha = { cluster: { sample: sum( min(sbb[bi][sample][3], sbb[bi][sample][4]) for bi in clusters[cluster] ) for sample in samples } for cluster in clusters } beta = { cluster: { sample: sum( max(sbb[bi][sample][3], sbb[bi][sample][4]) for bi in clusters[cluster] ) for sample in samples } for cluster in clusters } mean = { cluster: { sample: float(alpha[cluster][sample]) / float(alpha[cluster][sample] + beta[cluster][sample]) for sample in samples } for cluster in clusters } return { cluster: { sample: ( nbins[cluster][sample], rd[cluster][sample], nsnps[cluster][sample], cov[cluster][sample], alpha[cluster][sample], beta[cluster][sample], mean[cluster][sample], ) for sample in samples } for cluster in clusters } def scaleBAF(segments, samples, diploidbaf): diploid = -1 main = -1 for key in segments: if sum( (0.5 - segments[key][sample][-1]) <= diploidbaf for sample in samples ) == len(samples): sample = list(samples)[0] if main < segments[key][sample][0]: main = segments[key][sample][0] diploid = key if diploid == -1: raise ValueError( sp.error( ""No potential neutral cluster has been found within the given threshold {}!"".format( diploidbaf ) ) ) scalings = {sample: segments[diploid][sample][-1] for sample in samples} scale = ( lambda value, scale, diploidbaf: min((float(value) / float(scale)) * 0.5, 0.5) if (0.5 - value) <= diploidbaf and scale > 0 else value ) scaledBAF = { segment: { sample: scale(segments[segment][sample][-1], scalings[sample], diploidbaf) for sample in samples } for segment in segments } regulate = ( lambda record, baf: record[:-3] + splitBAF(baf, record[-3] + record[-2]) + (baf,) if record[-1] != baf else record ) return { segment: { sample: regulate(segments[segment][sample], scaledBAF[segment][sample]) for sample in samples } for segment in segments } def splitBAF(baf, scale): BAF = float(baf) BAF = min(BAF, 1.0 - BAF) SUM = float(scale) roundings = [] roundings.append((int(math.floor(BAF * SUM)), int(math.floor((1.0 - BAF) * SUM)))) roundings.append((int(math.floor(BAF * SUM)), int(math.ceil((1.0 - BAF) * SUM)))) roundings.append((int(math.ceil(BAF * SUM)), int(math.floor((1.0 - BAF) * SUM)))) roundings.append((int(math.ceil(BAF * SUM)), int(math.ceil((1.0 - BAF) * SUM)))) roundings = [(int(min(a, b)), int(max(a, b))) for (a, b) in roundings] estimations = [ float(a) / float(a + b) if a + b > 0 else 1.0 for (a, b) in roundings ] diff = [abs(est - BAF) for est in estimations] best = np.argmin(diff) return roundings[best][0], roundings[best][1] def roundAlphasBetas(baf, alpha, beta): BAF = float(baf) BAF = min(BAF, 1.0 - BAF) ALPHA = min(alpha, beta) BETA = max(alpha, beta) roundings = [] roundings.append((int(math.floor(ALPHA)), int(math.floor(BETA)))) roundings.append((int(math.floor(ALPHA)), int(math.ceil(BETA)))) roundings.append((int(math.ceil(ALPHA)), int(math.floor(BETA)))) roundings.append((int(math.ceil(ALPHA)), int(math.ceil(BETA)))) roundings = [(int(min(a, b)), int(max(a, b))) for (a, b) in roundings] estimations = [ float(a) / float(a + b) if a + b > 0 else 1.0 for (a, b) in roundings ] diff = [abs(est - BAF) for est in estimations] return roundings[np.argmin(diff)] def reindex(labels): """""" Given a list of labels, reindex them as integers from 1 to n_labels Also orders them in nonincreasing order of prevalence """""" old2new = {} j = 1 for i, _ in Counter(labels).most_common(): old2new[i] = j j += 1 old2newf = lambda x: old2new[x] return [old2newf(a) for a in labels] if __name__ == ""__main__"": main() ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/run.py",".py","13467","411","import sys from io import StringIO import os.path import glob import argparse from hatchet import config from hatchet.utils.count_reads import main as count_reads from hatchet.utils.count_reads_fw import main as count_reads_fw from hatchet.utils.genotype_snps import main as genotype_snps from hatchet.utils.count_alleles import main as count_alleles from hatchet.utils.combine_counts import main as combine_counts from hatchet.utils.combine_counts_fw import main as combine_counts_fw from hatchet.utils.cluster_bins_gmm import main as cluster_bins_gmm from hatchet.utils.cluster_bins import main as cluster_bins from hatchet.utils.plot_bins import main as plot_bins from hatchet.utils.plot_bins_1d2d import main as plot_bins_1d2d from hatchet.bin.HATCHet import main as hatchet_main from hatchet.utils.plot_cn import main as plot_cn from hatchet.utils.plot_cn_1d2d import main as plot_cn_1d2d from hatchet.utils.download_panel import main as download_panel from hatchet.utils.phase_snps import main as phase_snps from hatchet.utils.Supporting import log, error def main(args=None): parser = argparse.ArgumentParser( prog=""hatchet run"", description=""Run HATCHet pipeline"" ) parser.add_argument(""inifile"", help="".ini file for run configuration"") args = parser.parse_args(args) config.read(args.inifile) output = config.run.output output = output.rstrip(""/"") os.makedirs(output, exist_ok=True) try: chromosomes = [c for c in config.run.chromosomes.split()] except (KeyError, AttributeError): # if key is absent or is blank (None) chromosomes = [] # process all extra_args = [] try: if config.run.processes is not None: extra_args = [""-j"", str(config.run.processes)] except KeyError: pass # ---------------------------------------------------- if config.run.download_panel: if not config.download_panel.refpaneldir: raise ValueError( error( ( 'The step ""download_panel"" requires that the variable ""refpaneldir"" indicates the directory in ' ""which to store the reference panel."" ) ) ) download_panel( args=[ ""-D"", config.download_panel.refpaneldir, ""-R"", config.download_panel.refpanel, ] ) # ---------------------------------------------------- if config.run.genotype_snps: snps = """" if config.genotype_snps.snps: snps = config.genotype_snps.snps elif config.genotype_snps.reference_version: snps_mapping = { ( ""hg19"", True, ): ""https://ftp.ncbi.nih.gov/snp/organisms/human_9606_b151_GRCh37p13/VCF/GATK/00-All.vcf.gz"", ( ""hg19"", False, ): ""https://ftp.ncbi.nih.gov/snp/organisms/human_9606_b151_GRCh37p13/VCF/00-All.vcf.gz"", ( ""hg38"", True, ): ""https://ftp.ncbi.nih.gov/snp/organisms/human_9606_b151_GRCh38p7/VCF/GATK/00-All.vcf.gz"", ( ""hg38"", False, ): ""https://ftp.ncbi.nih.gov/snp/organisms/human_9606_b151_GRCh38p7/VCF/00-All.vcf.gz"", } if ( config.genotype_snps.reference_version, config.genotype_snps.chr_notation, ) not in snps_mapping: raise RuntimeError( ( ""Please specify valid values of reference_version and chr_notation. "" f""Valid pairs include: {snps_mapping.keys()}"" ) ) else: snps = snps_mapping[ config.genotype_snps.reference_version, config.genotype_snps.chr_notation, ] os.makedirs(f""{output}/snps"", exist_ok=True) genotype_snps( args=[ ""-N"", config.run.normal, ""-r"", config.run.reference, ""-R"", snps, ""-o"", f""{output}/snps/"", ""--chromosomes"", ] + ( chromosomes or [] ) # important to keep this as a list here to allow proper argparse parsing + extra_args ) # ---------------------------------------------------- if config.run.phase_snps: if len(glob.glob(f""{output}/snps/*.vcf.gz"")) == 0: raise ValueError( error( ( ""No SNP files were found for phasing. Are there any .vcf.gz files in the snps subdirectory of "" ""the output folder? Try running genotype_snps."" ) ) ) if not config.download_panel.refpaneldir: raise ValueError( error( ( 'The step ""phase_snps"" requires that the config variable ""download_panel.refpaneldir"" ' ""indicates the directory where the reference panel is located."" ) ) ) os.makedirs(f""{output}/phase"", exist_ok=True) phase_snps( args=[ ""-D"", config.download_panel.refpaneldir, ""-g"", config.run.reference, ""-V"", config.genotype_snps.reference_version, ""-o"", f""{output}/phase/"", ""-L"", ] + glob.glob(f""{output}/snps/*.vcf.gz"") + ([""-N""] if config.genotype_snps.chr_notation else []) + extra_args ) # ---------------------------------------------------- if config.run.count_alleles: os.makedirs(f""{output}/baf"", exist_ok=True) count_alleles( args=[""-N"", config.run.normal, ""-T""] + config.run.bams.split() + [""-S""] + (""normal "" + config.run.samples).split() + [""-r"", config.run.reference, ""-L""] + glob.glob(f""{output}/snps/*.vcf.gz"") + [ ""-O"", f""{output}/baf/normal.1bed"", ""-o"", f""{output}/baf/tumor.1bed"", ""-l"", f""{output}"", ""--chromosomes"", ] + ( chromosomes or [] ) # important to keep this as a list here to allow proper argparse parsing + extra_args ) if config.run.fixed_width is None or not config.run.fixed_width: # ---------------------------------------------------- # ---------------------------------------------------- # Variable-width/adaptive binning if config.run.count_reads: os.makedirs(f""{output}/rdr"", exist_ok=True) count_reads( args=[""-N"", config.run.normal, ""-T""] + config.run.bams.split() + [""-S""] + (""normal "" + config.run.samples).split() + [ ""-V"", config.genotype_snps.reference_version, ""-b"", f""{output}/baf/tumor.1bed"", ""-O"", f""{output}/rdr"", ""--chromosomes"", ] + ( chromosomes or [] ) # important to keep this as a list here to allow proper argparse parsing + extra_args ) # ---------------------------------------------------- if config.run.combine_counts: _stdout = sys.stdout sys.stdout = StringIO() os.makedirs(f""{output}/bb"", exist_ok=True) phasefile = f""{output}/phase/phased.vcf.gz"" args = [ ""-A"", f""{output}/rdr"", ""-b"", f""{output}/baf/tumor.1bed"", ""-t"", f""{output}/rdr/total.tsv"", ""-V"", config.genotype_snps.reference_version, ""-o"", f""{output}/bb/bulk.bb"", ""-r"", config.run.reference, ] + extra_args if os.path.exists(phasefile): log( msg=""Found phasing file, including phasing in binning process.\n"", level=""INFO"", ) args = [""-p"", f""{output}/phase/phased.vcf.gz""] + args else: log( msg=f""NO PHASING FILE FOUND at {phasefile}. Not including phasing in binning process.\n"", level=""INFO"", ) combine_counts(args) else: # ---------------------------------------------------- # ---------------------------------------------------- # Old fixed-width binning if config.run.count_reads: os.makedirs(f""{output}/rdr"", exist_ok=True) count_reads_fw( args=[ ""-N"", config.run.normal, ""-g"", config.run.reference, ""-T"", ] + config.run.bams.split() + [""-b"", config.count_reads_fw.size, ""-S""] + (""Normal "" + config.run.samples).split() + [ ""-O"", f""{output}/rdr/normal.1bed"", ""-o"", f""{output}/rdr/tumor.1bed"", ""-t"", f""{output}/rdr/total.tsv"", ""--chromosomes"", ] + ( chromosomes or [] ) # important to keep this as a list here to allow proper argparse parsing + extra_args ) # ---------------------------------------------------- if config.run.combine_counts: _stdout = sys.stdout sys.stdout = StringIO() combine_counts_fw( args=[ ""-c"", f""{output}/rdr/normal.1bed"", ""-C"", f""{output}/rdr/tumor.1bed"", ""-B"", f""{output}/baf/tumor.1bed"", ""-t"", f""{output}/rdr/total.tsv"", ] ) out = sys.stdout.getvalue() sys.stdout.close() sys.stdout = _stdout os.makedirs(f""{output}/bb"", exist_ok=True) with open(f""{output}/bb/bulk.bb"", ""w"") as f: f.write(out) if config.run.cluster_bins: os.makedirs(f""{output}/bbc"", exist_ok=True) if config.run.loc_clust: cluster_bins( args=[ f""{output}/bb/bulk.bb"", ""-o"", f""{output}/bbc/bulk.seg"", ""-O"", f""{output}/bbc/bulk.bbc"", ] ) else: cluster_bins_gmm( args=[ f""{output}/bb/bulk.bb"", ""-o"", f""{output}/bbc/bulk.seg"", ""-O"", f""{output}/bbc/bulk.bbc"", ] ) # ---------------------------------------------------- if config.run.plot_bins: os.makedirs(f""{output}/plots"", exist_ok=True) plot_bins( args=[ f""{output}/bbc/bulk.bbc"", ""--rundir"", f""{output}/plots"", ""--ymin"", ""0"", ""--ymax"", ""3"", ] ) os.makedirs(f""{output}/plots/1d2d"", exist_ok=True) plot_bins_1d2d( args=[ ""-b"", f""{output}/bbc/bulk.bbc"", ""-s"", f""{output}/bbc/bulk.seg"", ""--outdir"", f""{output}/plots/1d2d"", ""--centers"", ""--centromeres"", ] ) # ---------------------------------------------------- if config.run.compute_cn: os.makedirs(f""{output}/results"", exist_ok=True) hatchet_main( args=[""-x"", f""{output}/results"", ""-i"", f""{output}/bbc/bulk""] + extra_args ) # ---------------------------------------------------- if config.run.plot_cn: os.makedirs(f""{output}/summary"", exist_ok=True) plot_cn( args=[ f""{output}/results/best.bbc.ucn"", ""--rundir"", f""{output}/summary"", ] ) os.makedirs(f""{output}/summary/1d2d"", exist_ok=True) plot_cn_1d2d( args=[ f""{output}/results/best.bbc.ucn"", ""--outdir"", f""{output}/summary/1d2d"", ""--bysample"", ""--centromeres"", ] ) if __name__ == ""__main__"": main() ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/rd_gccorrect.py",".py","1859","55","import pandas as pd import statsmodels.formula.api as smf from pybedtools import BedTool def rd_gccorrect(bb, ref_genome): """""" Function to correct GC bias in read depth data for each sample. Parameters: - bb: DataFrame containing read depth data, including columns '#CHR', 'START', 'END', 'RD', 'SAMPLE' - ref_genome: File path to the reference genome in FASTA format Return type: DataFrame with corrected read depth data """""" bb[""CHR""] = bb[""#CHR""].str.replace(""chr"", """") bb = bb.sort_values(by=[""CHR"", ""START""]).reset_index(drop=True) # add GC content # ref_genome = '/n/fs/ragr-data/datasets/ref-genomes/GRCh38_10X/fasta/genome.fa' bb = bb.merge( BedTool.from_dataframe(bb[[""#CHR"", ""START"", ""END""]].drop_duplicates()) .nucleotide_content(fi=ref_genome) .to_dataframe(disable_auto_names=True) .rename( columns={ ""#1_usercol"": ""#CHR"", ""2_usercol"": ""START"", ""3_usercol"": ""END"", ""5_pct_gc"": ""GC"", } ) .astype({""#CHR"": str})[[""#CHR"", ""START"", ""END"", ""GC""]] ) # Correcting GC bias per sample gccorrect = bb.groupby(""SAMPLE"").apply( lambda D: smf.quantreg(""RD ~ GC + I(GC ** 2.0)"", data=D).fit(q=0.5) ) bb[""UNCORR_RD""] = bb[""RD""].copy() bb[""GCCORR""] = bb.groupby(""SAMPLE"")[""GC""].transform( lambda X: gccorrect[X.name].predict(X.to_frame(""GC"")).values ) bb[""RD""] = bb[""UNCORR_RD""] / bb[""GCCORR""].where( (bb[""GCCORR""] > 0) & ~pd.isnull(bb[""GCCORR""]), 1 ) bb[""RD""] = bb[""RD""] / bb.groupby(""SAMPLE"")[""RD""].transform(lambda X: X.mean()) print(bb.head(10)) bb = bb.sort_values(by=[""CHR"", ""START""]).reset_index(drop=True) # Drop the 'CHR' column bb.drop(columns=[""CHR""], inplace=True) return bb ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/ProgressBar.py",".py","2880","92","import sys import datetime import hatchet.utils.Supporting as sp class ProgressBar: def __init__( self, total, length, counter=0, verbose=False, decimals=1, fill=chr(9608), lock=None, prefix=""Progress:"", suffix=""Complete"", ): self.total = total self.length = length self.decimals = decimals self.fill = fill self.prefix = prefix self.suffix = suffix self.lock = lock self.counter = counter self.verbose = verbose def progress(self, advance=True, msg=""""): if self.lock is not None: self.progressLock(advance, msg) else: self.progressNoLock(advance, msg) def progressLock(self, advance=True, msg=""""): flush = sys.stderr.flush write = sys.stderr.write if advance: with self.counter.get_lock(): self.counter.value += 1 percent = (""{0:."" + str(self.decimals) + ""f}"").format( 100 * (self.counter.value / float(self.total)) ) filledLength = int(self.length * self.counter.value // self.total) bar = self.fill * filledLength + ""-"" * (self.length - filledLength) rewind = ""\x1b[2K\r"" result = ""%s%s%s |%s| %s%s%% %s%s"" % ( sp.bcolors.BBLUE, self.prefix, sp.bcolors.ENDC, bar, sp.bcolors.BBLUE, percent, self.suffix, sp.bcolors.ENDC, ) msg = ""[{:%Y-%b-%d %H:%M:%S}]"".format(datetime.datetime.now()) + msg if not self.verbose: toprint = ( rewind + result + "" %s[%s]%s"" % (sp.bcolors.BBLUE, msg, sp.bcolors.ENDC) ) else: toprint = rewind + sp.bcolors.BBLUE + msg + sp.bcolors.ENDC + ""\n"" + result with self.lock: write(toprint) flush() if self.counter.value == self.total: write(""\n"") flush() def progressNoLock(self, advance=True, msg=""""): flush = sys.stderr.flush write = sys.stderr.write if advance: self.counter += 1 percent = (""{0:."" + str(self.decimals) + ""f}"").format( 100 * (self.counter / float(self.total)) ) filledLength = int(self.length * self.counter // self.total) bar = self.fill * filledLength + ""-"" * (self.length - filledLength) rewind = ""\x1b[2K\r"" result = ""%s |%s| %s%% %s"" % (self.prefix, bar, percent, self.suffix) if not self.verbose: toprint = rewind + result + "" [%s]"" % (msg) else: toprint = rewind + msg + ""\n"" + result write(toprint) flush() if self.counter == self.total: write(""\n"") flush() ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/solve/ilp_subset.py",".py","43036","1088","import textwrap import math import numpy as np from pyomo import environ as pe from pyomo.opt import SolverStatus, TerminationCondition from hatchet.utils.solve.utils import Random class ILPSubset: def __init__(self, n, cn_max, d, mu, ampdel, copy_numbers, f_a, f_b, w, purities): # Each ILPSubset maintains its own data, so make a deep-copy of passed-in DataFrames f_a, f_b = f_a.copy(deep=True), f_b.copy(deep=True) assert f_a.shape == f_b.shape assert np.all(f_a.index == f_b.index) assert np.all(f_a.columns == f_b.columns) self.m, self.k = f_a.shape self.f_a = f_a self.f_b = f_b self.cluster_ids = f_a.index self.sample_ids = f_a.columns self.n = n self.cn_max = cn_max self.d = d self.mu = mu self.ampdel = ampdel self.copy_numbers = copy_numbers self.w = w self.purities = purities self.tol = 0.001 self.mode = ""FULL"" # Values we want to optimize for, as dataframes self.cA = [[np.nan for _ in range(self.n)] for _ in range(self.m)] self.cB = [[np.nan for _ in range(self.n)] for _ in range(self.m)] self.u = [[np.nan for _ in range(self.k)] for _ in range(self.n)] # Fixed values of cA/cB/u self._fixed_cA = [[np.nan for _ in range(n)] for _ in range(self.m)] self._fixed_cB = [[np.nan for _ in range(n)] for _ in range(self.m)] self._fixed_u = [[np.nan for _ in range(self.k)] for _ in range(self.n)] self.warmstart = False # set on hot_start() self.model = None # initialized on create_model() def __copy__(self): return ILPSubset( n=self.n, cn_max=self.cn_max, d=self.d, mu=self.mu, ampdel=self.ampdel, copy_numbers=self.copy_numbers, f_a=self.f_a, f_b=self.f_b, w=self.w, purities=self.purities, ) def __str__(self): # Pyomo pprint gives us too much information - too unwieldy for large models # This method is implemented to supply the bare-minimum but useful model information. if self.model is None: return """" else: return textwrap.dedent( f"""""" # ------------------------------------------ # Problem Information # ------------------------------------------ # Number of constraints: {self.model.nconstraints()} # Number of variables: {self.model.nvariables()} # ------------------------------------------ """""" ) @property def M(self): return math.floor(math.log2(self.cn_max)) + 1 @property def base(self): return min(2, len(self.copy_numbers)) @staticmethod def symmCoeff(i): return math.pow(i + 1, 1) @property def optimized_cA(self): if self.mode == ""UARCH"": return self._fixed_cA else: return self.cA @property def optimized_cB(self): if self.mode == ""UARCH"": return self._fixed_cB else: return self.cB @property def optimized_u(self): if self.mode == ""CARCH"": return self._fixed_u else: return self.u def create_model(self, pprint=False): m, n, k = self.m, self.n, self.k f_a, f_b = self.f_a, self.f_b cn_max = self.cn_max ampdel = self.ampdel copy_numbers = self.copy_numbers mode_t = self.mode d = self.d _M = self.M _base = self.base purities = self.purities model = pe.ConcreteModel() fA = {} fB = {} yA = {} yB = {} adA = {} adB = {} for _m in range(m): cluster_id = f_a.index[_m] # upper bound for solver ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) for _k in range(k): yA[(_m, _k)] = pe.Var(bounds=(0, np.inf), domain=pe.Reals) model.add_component(f""yA_{_m + 1}_{_k + 1}"", yA[(_m, _k)]) yB[(_m, _k)] = pe.Var(bounds=(0, np.inf), domain=pe.Reals) model.add_component(f""yB_{_m + 1}_{_k + 1}"", yB[(_m, _k)]) fA[(_m, _k)] = pe.Var(bounds=(0, ub), domain=pe.Reals) model.add_component(f""fA_{_m + 1}_{_k + 1}"", fA[(_m, _k)]) fB[(_m, _k)] = pe.Var(bounds=(0, ub), domain=pe.Reals) model.add_component(f""fB_{_m + 1}_{_k + 1}"", fB[(_m, _k)]) if mode_t in (""FULL"", ""CARCH""): for _m in range(m): cluster_id = f_a.index[_m] # upper bound for solver ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) for _n in range(n): self.cA[_m][_n] = pe.Var(bounds=(0, ub), domain=pe.Integers) model.add_component(f""cA_{_m + 1}_{_n + 1}"", self.cA[_m][_n]) self.cB[_m][_n] = pe.Var(bounds=(0, ub), domain=pe.Integers) model.add_component(f""cB_{_m + 1}_{_n + 1}"", self.cB[_m][_n]) if ampdel: for _m in range(m): cluster_id = f_a.index[_m] if cluster_id not in copy_numbers: adA[_m] = pe.Var(bounds=(0, 1), domain=pe.Binary) model.add_component(f""adA_{_m + 1}"", adA[_m]) adB[_m] = pe.Var(bounds=(0, 1), domain=pe.Binary) model.add_component(f""adB_{_m + 1}"", adB[_m]) bitcA = {} bitcB = {} if (mode_t == ""FULL"") or (d > 0 and mode_t == ""CARCH""): for _b in range(_M): for _m in range(m): for _n in range(n): bitcA[(_b, _m, _n)] = pe.Var(bounds=(0, 1), domain=pe.Binary) model.add_component( f""bitcA_{_b + 1}_{_m + 1}_{_n + 1}"", bitcA[(_b, _m, _n)], ) bitcB[(_b, _m, _n)] = pe.Var(bounds=(0, 1), domain=pe.Binary) model.add_component( f""bitcB_{_b + 1}_{_m + 1}_{_n + 1}"", bitcB[(_b, _m, _n)], ) if mode_t in (""FULL"", ""UARCH""): for _n in range(n): for _k in range(k): self.u[_n][_k] = pe.Var(bounds=(0, 1), domain=pe.Reals) model.add_component(f""u_{_n + 1}_{_k + 1}"", self.u[_n][_k]) vA = {} vB = {} if mode_t == ""FULL"": for _b in range(_M): for _m in range(m): for _n in range(n): for _k in range(k): vA[(_b, _m, _n, _k)] = pe.Var( bounds=(0, 1), domain=pe.Reals ) model.add_component( f""vA_{_b + 1}_{_m + 1}_{_n + 1}_{_k + 1}"", vA[(_b, _m, _n, _k)], ) vB[(_b, _m, _n, _k)] = pe.Var( bounds=(0, 1), domain=pe.Reals ) model.add_component( f""vB_{_b + 1}_{_m + 1}_{_n + 1}_{_k + 1}"", vB[(_b, _m, _n, _k)], ) x = {} if (mode_t in (""FULL"", ""UARCH"")) and (self.mu > 0): for _n in range(n): for _k in range(k): x[(_n, _k)] = pe.Var(domain=pe.Binary) model.add_component(f""x_{_n + 1}_{_k + 1}"", x[(_n, _k)]) # buildOptionalVariables z = {} if (mode_t in (""FULL"", ""CARCH"")) and d > 0: for _m in range(self.m): for _n in range(1, self.n): for _d in range(d): z[(_m, _n, _d)] = pe.Var(bounds=(0, 1), domain=pe.Binary) model.add_component( f""z_{_m + 1}_{_n + 1}_{_d + 1}"", z[(_m, _n, _d)] ) # CONSTRAINTS model.constraints = pe.ConstraintList() for _m in range(m): cluster_id = f_a.index[_m] f_a_values = f_a.loc[cluster_id].values f_b_values = f_b.loc[cluster_id].values for _k in range(k): _yA, _yB = yA[(_m, _k)], yB[(_m, _k)] _fA, _fB = fA[(_m, _k)], fB[(_m, _k)] model.constraints.add(float(f_a_values[_k]) - _fA <= _yA) model.constraints.add(_fA - float(f_a_values[_k]) <= _yA) model.constraints.add(float(f_b_values[_k]) - _fB <= _yB) model.constraints.add(_fB - float(f_b_values[_k]) <= _yB) if mode_t == ""FULL"": for _m in range(m): for _k in range(k): sum_a = 0 for _n in range(n): for _b in range(_M): sum_a += vA[(_b, _m, _n, _k)] * math.pow(2, _b) model.constraints.add( vA[(_b, _m, _n, _k)] <= bitcA[(_b, _m, _n)] ) model.constraints.add( vA[(_b, _m, _n, _k)] <= self.u[_n][_k] ) model.constraints.add( vA[(_b, _m, _n, _k)] >= bitcA[(_b, _m, _n)] + self.u[_n][_k] - 1 ) model.constraints.add(fA[(_m, _k)] == sum_a) for _m in range(m): for _k in range(k): sum_b = 0 for _n in range(n): for _b in range(_M): sum_b += vB[(_b, _m, _n, _k)] * math.pow(2, _b) model.constraints.add( vB[(_b, _m, _n, _k)] <= bitcB[(_b, _m, _n)] ) model.constraints.add( vB[(_b, _m, _n, _k)] <= self.u[_n][_k] ) model.constraints.add( vB[(_b, _m, _n, _k)] >= bitcB[(_b, _m, _n)] + self.u[_n][_k] - 1 ) model.constraints.add(fB[(_m, _k)] == sum_b) for _n in range(n): for _k in range(k): _sum = 0 for _m in range(m): for _b in range(_M): _sum += bitcA[(_b, _m, _n)] + bitcB[(_b, _m, _n)] model.constraints.add(_sum >= self.u[_n][_k]) if (mode_t == ""FULL"") or (d > 0 and mode_t == ""CARCH""): for _m in range(m): cluster_id = f_a.index[_m] # upper bound for solver ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) for _n in range(n): sum_a = 0 sum_b = 0 for _b in range(_M): sum_a += bitcA[(_b, _m, _n)] * math.pow(2, _b) sum_b += bitcB[(_b, _m, _n)] * math.pow(2, _b) model.constraints.add(self.cA[_m][_n] == sum_a) model.constraints.add(self.cB[_m][_n] == sum_b) model.constraints.add(self.cA[_m][_n] + self.cB[_m][_n] <= ub) # this is where we fix the purities if user provides purity values for (tumor) samples # in each sample s, clone 0 (healty & normal) should have the purity 1 - purity_s if mode_t in (""FULL"", ""UARCH"") and purities: for i, p in enumerate(purities): model.constraints.add(self.u[0][i] == 1 - p) if mode_t == ""CARCH"": # TODO: These loops can be collapsed once validation against C++ is complete for _m in range(m): for _k in range(k): _sumA = 0 _sumB = 0 for _n in range(n): if self._fixed_u[_n][_k] >= self.mu - self.tol: _sumA += self.cA[_m][_n] * self._fixed_u[_n][_k] _sumB += self.cB[_m][_n] * self._fixed_u[_n][_k] model.constraints.add(fA[(_m, _k)] == _sumA) model.constraints.add(fB[(_m, _k)] == _sumB) cluster_id = f_a.index[_m] # upper bound for solver ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) for _n in range(n): model.constraints.add(self.cA[_m][_n] + self.cB[_m][_n] <= ub) if mode_t in (""FULL"", ""CARCH""): for _m in range(m): model.constraints.add(self.cA[_m][0] == 1) model.constraints.add(self.cB[_m][0] == 1) cluster_id = self.cluster_ids[_m] # if the fraction of the cluster size is larger than or equal to 0.005 in the whole dataset # then its integer copy number cannot have (0,0) copy number if self.w[cluster_id] / sum(self.w) >= 0.005: for _n in range(1, n): model.constraints.add(self.cA[_m][_n] + self.cB[_m][_n] >= 1) if ampdel: for _m in range(m): cluster_id = f_a.index[_m] if cluster_id not in copy_numbers: for _n in range(1, n): model.constraints.add( self.cA[_m][_n] <= cn_max * adA[_m] + _base - _base * adA[_m] ) model.constraints.add(self.cA[_m][_n] >= _base * adA[_m]) model.constraints.add( self.cB[_m][_n] <= cn_max * adB[_m] + _base - _base * adB[_m] ) model.constraints.add(self.cB[_m][_n] >= _base * adB[_m]) if mode_t == ""UARCH"": # TODO: These loops can be collapsed once validation against C++ is complete for _m in range(m): for _k in range(k): _sumA = 0 _sumB = 0 for _n in range(n): _sumA += int(self._fixed_cA[_m][_n]) * self.u[_n][_k] _sumB += int(self._fixed_cB[_m][_n]) * self.u[_n][_k] model.constraints.add(fA[(_m, _k)] == _sumA) model.constraints.add(fB[(_m, _k)] == _sumB) if mode_t in (""FULL"", ""UARCH""): for _k in range(k): _sum = 0 for _n in range(n): _sum += self.u[_n][_k] model.constraints.add(_sum == 1) if (mode_t in (""FULL"", ""UARCH"")) and self.mu > 0: for _k in range(k): for _n in range(1, n): model.constraints.add(x[(_n, _k)] >= self.u[_n][_k]) model.constraints.add(self.u[_n][_k] >= self.mu * x[(_n, _k)]) # buildOptionalConstraints if (mode_t in (""FULL"", ""CARCH"")) and d > 0: for _m in range(self.m): for _n in range(1, self.n): _sum = 0 for _d in range(self.d): _sum += z[(_m, _n, _d)] model.constraints.add(_sum == 1) for _m in range(self.m): for _M in range(self.M): for _d in range(d): for _i in range(1, self.n - 1): for _j in range(1, self.n): model.constraints.add( bitcA[(_M, _m, _i)] - bitcA[(_M, _m, _j)] <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] ) model.constraints.add( bitcA[(_M, _m, _j)] - bitcA[(_M, _m, _i)] <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] ) model.constraints.add( bitcB[(_M, _m, _i)] - bitcB[(_M, _m, _j)] <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] ) model.constraints.add( bitcB[(_M, _m, _j)] - bitcB[(_M, _m, _i)] <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] ) for _m in range(self.m): for _d in range(d - 1): _sum_l = _sum_l1 = 0 for _n in range(1, self.n): _sum_l += z[(_m, _n, _d)] * self.symmCoeff(_n) _sum_l1 += z[(_m, _n, _d + 1)] * self.symmCoeff(_n) model.constraints.add(_sum_l <= _sum_l1) if mode_t in (""FULL"", ""CARCH""): self.build_symmetry_breaking(model) self.fix_given_cn(model) if mode_t == ""FULL"": self.hot_start() obj = 0 for _m in range(m): for _k in range(k): cluster_id = self.cluster_ids[_m] obj += (yA[(_m, _k)] + yB[(_m, _k)]) * self.w[cluster_id] model.obj = pe.Objective(expr=obj, sense=pe.minimize) self.model = model if pprint: print(str(self)) def build_symmetry_breaking(self, model): for i in range(1, self.n - 1): _sum1 = 0 _sum2 = 0 for _m in range(self.m): _symCoeff = self.symmCoeff(_m) _sum1 += self.cA[_m][i] * _symCoeff + self.cB[_m][i] * _symCoeff _sum2 += self.cA[_m][i] * _symCoeff + self.cB[_m][i] * _symCoeff model.constraints.add(_sum1 <= _sum2) def fix_given_cn(self, model): for _m in range(self.m): cluster_id = self.f_a.index[_m] if cluster_id in self.copy_numbers: _cnA, _cnB = self.copy_numbers[cluster_id] for _n in range(1, self.n): model.constraints.add(self.cA[_m][_n] == _cnA) model.constraints.add(self.cB[_m][_n] == _cnB) def first_hot_start(self): if self.d > 0: targetA = np.empty((self.m, self.d)) targetB = np.empty_like(targetA) for _m in range(self.m): targetA[_m, :] = np.random.choice( self.f_a.iloc[_m].values, self.d, replace=False ) targetB[_m, :] = np.random.choice( self.f_b.iloc[_m].values, self.d, replace=False ) targetA = targetA.round() targetB = targetB.round() else: targetA = np.round(self.f_a.values) targetB = np.round(self.f_b.values) hcA = np.zeros((self.m, self.n)) hcB = np.zeros((self.m, self.n)) for _m in range(self.m): cluster_id = self.f_a.index[_m] adA = 0 adB = 0 for _n in range(self.n): if _n == 0: hcA[_m][0] = 1 hcB[_m][0] = 1 else: if cluster_id in self.copy_numbers: hcA[_m][_n] = self.copy_numbers[cluster_id][0] hcB[_m][_n] = self.copy_numbers[cluster_id][1] else: mod = min(self.n, self.k) a = min(targetA[_m][_n % mod], self.cn_max) b = min(targetB[_m][_n % mod], self.cn_max) if self.ampdel: base = self.base if adA == 0 and a > base: adA = 1 if adA == 0 and a < base: adA = -1 if adB == 0 and b > base: adB = 1 if adB == 0 and b < base: adB = -1 a = max(a, base) if adA >= 0 else min(a, base) b = max(b, base) if adB >= 0 else min(b, base) if a + b > self.cn_max: a = self.cn_max - base b = self.cn_max - a if a + b <= self.cn_max: hcA[_m][_n] = a hcB[_m][_n] = b else: hcA[_m][_n] = a hcB[_m][_n] = max(self.cn_max - a, 0) assert hcA[_m][_n] + hcB[_m][_n] <= self.cn_max assert hcA[_m][_n] >= 0 assert hcB[_m][_n] >= 0 return hcA, hcB def hot_start(self, f_a=None, f_b=None): def get_rank(hcA, hcB): # m, n = hcA.shape m, n = len(hcA), len(hcA[0]) rank = np.zeros(n) rank[0] = -1 for _m in range(m): for _n in range(1, n): rank[_n] += hcA[_m][_n] * self.symmCoeff(_m) + hcB[_m][ _n ] * self.symmCoeff(_m) return rank if f_a is None and f_b is None: f_a, f_b = self.first_hot_start() rank = get_rank(f_a, f_b) rank_indices = np.argsort(rank) for _m in range(self.m): for _n in range(0, self.n): self.cA[_m][rank_indices[_n]].value = f_a[_m][_n] self.cB[_m][rank_indices[_n]].value = f_b[_m][_n] self.warmstart = True def fix_u(self, u): self._fixed_u[:] = u self.mode = ""CARCH"" # TODO: sanity checks in fixU def fix_c(self, cA, cB): self._fixed_cA = cA self._fixed_cB = cB self.mode = ""UARCH"" # TODO: sanity checks in fixC def build_random_u(self, random_seed=None): def _calculate_size_bubbles(mu): if mu <= 0.1: return 10 elif mu <= 0.15: return 6 elif mu <= 0.2: return 5 else: return 3 def _build_partition_vector(n, n_parts, size_bubbles, mu=0.03): """""" Return fractional components of n components as an ndarray of size n """""" # initialize all fractions to 0 result = np.zeros(n) # generate n_parts random positions from all available positions positions = np.random.choice(np.arange(n), n_parts, replace=False) bubbles = ( np.sort( np.random.choice( np.arange(1, size_bubbles), n_parts - 1, replace=False ) ) / size_bubbles ) _result = np.diff(bubbles, prepend=0, append=1) # set fractions at selected positions to successive difference between bubbles result[positions] = _result # for fractions that are within tol of mu, clamp them up to mu result[(mu - self.tol <= result) & (result < mu)] = mu return result size_bubbles = _calculate_size_bubbles(self.mu) U = np.empty((self.n, self.k)) with Random(random_seed): for _k in range(self.k): # Generate 2 random ints between [1, n] and take the max - biasing towards larger numbers _n0 = np.random.randint(1, self.n + 1) _n1 = np.random.randint(1, self.n + 1) n_parts = min( max(_n0, _n1), size_bubbles ) # no. of clones with non-zero proportion in the mix v = _build_partition_vector(self.n, n_parts, size_bubbles, mu=self.mu) U[:, _k] = v return U def run(self, solver_type=""gurobi"", timelimit=None, write_path=None): if solver_type == ""gurobipy"": solver = pe.SolverFactory(""gurobi"", solver_io=""python"") else: solver = pe.SolverFactory(solver_type) kwargs = {""report_timing"": False} if timelimit is not None: kwargs[""timelimit""] = int(timelimit) if solver.warm_start_capable(): kwargs[""warmstart""] = self.warmstart results = solver.solve(self.model, **kwargs) if ( (results.solver.status == SolverStatus.ok) and ( results.solver.termination_condition in ( TerminationCondition.optimal, TerminationCondition.feasible, ) ) or ( results.solver.status == SolverStatus.aborted and results.solver.termination_condition == TerminationCondition.maxTimeLimit ) ): pass else: return None if write_path is not None: self.model.write(write_path) return ( self.model.obj(), [[int(getattr(x, ""value"", x)) for x in row] for row in self.optimized_cA], [[int(getattr(x, ""value"", x)) for x in row] for row in self.optimized_cB], [[getattr(x, ""value"", x) for x in row] for row in self.optimized_u], self.cluster_ids, self.sample_ids, ) class ILPSubsetSplit(ILPSubset): def __init__( self, n, cn_max, d, mu, ampdel, copy_numbers, f_a, f_b, binsA, binsB, lengths, ): # Each ILPSubset maintains its own data, so make a deep-copy of passed-in DataFrames f_a, f_b = f_a.copy(deep=True), f_b.copy(deep=True) self.binsA = {k: v.copy(deep=True) for k, v in binsA.items()} self.binsB = {k: v.copy(deep=True) for k, v in binsB.items()} self.lengths = {k: np.copy(v) for k, v in lengths.items()} assert f_a.shape == f_b.shape assert np.all(f_a.index == f_b.index) assert np.all(f_a.columns == f_b.columns) self.m, self.k = f_a.shape self.f_a = f_a self.f_b = f_b self.cluster_ids = f_a.index self.sample_ids = f_a.columns self.n = n self.cn_max = cn_max self.d = d self.mu = mu self.ampdel = ampdel self.copy_numbers = copy_numbers self.tol = 0.001 self.mode = ""FULL"" # Values we want to optimize for, as dataframes self.cA = [[np.nan for _ in range(self.n)] for _ in range(self.m)] self.cB = [[np.nan for _ in range(self.n)] for _ in range(self.m)] self.u = [[np.nan for _ in range(self.k)] for _ in range(self.n)] # Fixed values of cA/cB/u self._fixed_cA = [[np.nan for _ in range(n)] for _ in range(self.m)] self._fixed_cB = [[np.nan for _ in range(n)] for _ in range(self.m)] self._fixed_u = [[np.nan for _ in range(self.k)] for _ in range(self.n)] self.warmstart = False # set on hot_start() self.model = None # initialized on create_model() def __copy__(self): return ILPSubsetSplit( n=self.n, cn_max=self.cn_max, d=self.d, mu=self.mu, ampdel=self.ampdel, copy_numbers=self.copy_numbers, f_a=self.f_a, f_b=self.f_b, binsA=self.binsA, binsB=self.binsB, lengths=self.lengths, ) def create_model(self, pprint=False): m, n, k = self.m, self.n, self.k f_a = self.f_a cn_max = self.cn_max ampdel = self.ampdel copy_numbers = self.copy_numbers mode_t = self.mode d = self.d _M = self.M _base = self.base model = pe.ConcreteModel() fA = {} fB = {} yA = {} yB = {} adA = {} adB = {} for _m in range(m): cluster_id = f_a.index[_m] # upper bound for solver ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) for _k in range(k): fA[(_m, _k)] = pe.Var(bounds=(0, ub), domain=pe.Reals) model.add_component(f""fA_{_m + 1}_{_k + 1}"", fA[(_m, _k)]) fB[(_m, _k)] = pe.Var(bounds=(0, ub), domain=pe.Reals) model.add_component(f""fB_{_m + 1}_{_k + 1}"", fB[(_m, _k)]) # Need an objective function term for each bin for absolute vlaue for _i in range(len(self.binsA[cluster_id])): yA[(_m, _k, _i)] = pe.Var(bounds=(0, np.inf), domain=pe.Reals) model.add_component( f""yA_{_m + 1}_{_k + 1}_{_i + 1}"", yA[(_m, _k, _i)] ) yB[(_m, _k, _i)] = pe.Var(bounds=(0, np.inf), domain=pe.Reals) model.add_component( f""yB_{_m + 1}_{_k + 1}_{_i + 1}"", yB[(_m, _k, _i)] ) if mode_t in (""FULL"", ""CARCH""): for _m in range(m): cluster_id = f_a.index[_m] # upper bound for solver ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) for _n in range(n): self.cA[_m][_n] = pe.Var(bounds=(0, ub), domain=pe.Integers) model.add_component(f""cA_{_m + 1}_{_n + 1}"", self.cA[_m][_n]) self.cB[_m][_n] = pe.Var(bounds=(0, ub), domain=pe.Integers) model.add_component(f""cB_{_m + 1}_{_n + 1}"", self.cB[_m][_n]) if ampdel: for _m in range(m): cluster_id = f_a.index[_m] if cluster_id not in copy_numbers: adA[_m] = pe.Var(bounds=(0, 1), domain=pe.Binary) model.add_component(f""adA_{_m + 1}"", adA[_m]) adB[_m] = pe.Var(bounds=(0, 1), domain=pe.Binary) model.add_component(f""adB_{_m + 1}"", adB[_m]) bitcA = {} bitcB = {} if (mode_t == ""FULL"") or (d > 0 and mode_t == ""CARCH""): for _b in range(_M): for _m in range(m): for _n in range(n): bitcA[(_b, _m, _n)] = pe.Var(bounds=(0, 1), domain=pe.Binary) model.add_component( f""bitcA_{_b + 1}_{_m + 1}_{_n + 1}"", bitcA[(_b, _m, _n)], ) bitcB[(_b, _m, _n)] = pe.Var(bounds=(0, 1), domain=pe.Binary) model.add_component( f""bitcB_{_b + 1}_{_m + 1}_{_n + 1}"", bitcB[(_b, _m, _n)], ) if mode_t in (""FULL"", ""UARCH""): for _n in range(n): for _k in range(k): self.u[_n][_k] = pe.Var(bounds=(0, 1), domain=pe.Reals) model.add_component(f""u_{_n + 1}_{_k + 1}"", self.u[_n][_k]) vA = {} vB = {} if mode_t == ""FULL"": for _b in range(_M): for _m in range(m): for _n in range(n): for _k in range(k): vA[(_b, _m, _n, _k)] = pe.Var( bounds=(0, 1), domain=pe.Reals ) model.add_component( f""vA_{_b + 1}_{_m + 1}_{_n + 1}_{_k + 1}"", vA[(_b, _m, _n, _k)], ) vB[(_b, _m, _n, _k)] = pe.Var( bounds=(0, 1), domain=pe.Reals ) model.add_component( f""vB_{_b + 1}_{_m + 1}_{_n + 1}_{_k + 1}"", vB[(_b, _m, _n, _k)], ) x = {} if (mode_t in (""FULL"", ""UARCH"")) and (self.mu > 0): for _n in range(n): for _k in range(k): x[(_n, _k)] = pe.Var(domain=pe.Binary) model.add_component(f""x_{_n + 1}_{_k + 1}"", x[(_n, _k)]) # buildOptionalVariables z = {} if (mode_t in (""FULL"", ""CARCH"")) and d > 0: for _m in range(self.m): for _n in range(1, self.n): for _d in range(d): z[(_m, _n, _d)] = pe.Var(bounds=(0, 1), domain=pe.Binary) model.add_component( f""z_{_m + 1}_{_n + 1}_{_d + 1}"", z[(_m, _n, _d)] ) # CONSTRAINTS model.constraints = pe.ConstraintList() for _m in range(m): cluster_id = f_a.index[_m] f_a_values = self.binsA[cluster_id].values f_b_values = self.binsB[cluster_id].values for _k in range(k): _fA, _fB = fA[(_m, _k)], fB[(_m, _k)] for _i in range(f_a_values.shape[0]): _yA, _yB = yA[(_m, _k, _i)], yB[(_m, _k, _i)] # Instead of 1 term per inferred CN, use all values in bin model.constraints.add(f_a_values[_i, _k] - _fA <= _yA) model.constraints.add(_fA - f_a_values[_i, _k] <= _yA) # model.constraints.add(myA >= _yA) model.constraints.add(f_b_values[_i, _k] - _fB <= _yB) model.constraints.add(_fB - f_b_values[_i, _k] <= _yB) # model.constraints.add(myB >= _yB) if mode_t == ""FULL"": for _m in range(m): for _k in range(k): sum_a = 0 for _n in range(n): for _b in range(_M): sum_a += vA[(_b, _m, _n, _k)] * math.pow(2, _b) model.constraints.add( vA[(_b, _m, _n, _k)] <= bitcA[(_b, _m, _n)] ) model.constraints.add( vA[(_b, _m, _n, _k)] <= self.u[_n][_k] ) model.constraints.add( vA[(_b, _m, _n, _k)] >= bitcA[(_b, _m, _n)] + self.u[_n][_k] - 1 ) model.constraints.add(fA[(_m, _k)] == sum_a) for _m in range(m): for _k in range(k): sum_b = 0 for _n in range(n): for _b in range(_M): sum_b += vB[(_b, _m, _n, _k)] * math.pow(2, _b) model.constraints.add( vB[(_b, _m, _n, _k)] <= bitcB[(_b, _m, _n)] ) model.constraints.add( vB[(_b, _m, _n, _k)] <= self.u[_n][_k] ) model.constraints.add( vB[(_b, _m, _n, _k)] >= bitcB[(_b, _m, _n)] + self.u[_n][_k] - 1 ) model.constraints.add(fB[(_m, _k)] == sum_b) for _n in range(n): for _k in range(k): _sum = 0 for _m in range(m): for _b in range(_M): _sum += bitcA[(_b, _m, _n)] + bitcB[(_b, _m, _n)] model.constraints.add(_sum >= self.u[_n][_k]) if (mode_t == ""FULL"") or (d > 0 and mode_t == ""CARCH""): for _m in range(m): cluster_id = f_a.index[_m] # upper bound for solver ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) for _n in range(n): sum_a = 0 sum_b = 0 for _b in range(_M): sum_a += bitcA[(_b, _m, _n)] * math.pow(2, _b) sum_b += bitcB[(_b, _m, _n)] * math.pow(2, _b) model.constraints.add(self.cA[_m][_n] == sum_a) model.constraints.add(self.cB[_m][_n] == sum_b) model.constraints.add(self.cA[_m][_n] + self.cB[_m][_n] <= ub) if mode_t == ""CARCH"": # TODO: These loops can be collapsed once validation against C++ is complete for _m in range(m): for _k in range(k): _sumA = 0 _sumB = 0 for _n in range(n): if self._fixed_u[_n][_k] >= self.mu - self.tol: _sumA += self.cA[_m][_n] * self._fixed_u[_n][_k] _sumB += self.cB[_m][_n] * self._fixed_u[_n][_k] model.constraints.add(fA[(_m, _k)] == _sumA) model.constraints.add(fB[(_m, _k)] == _sumB) cluster_id = f_a.index[_m] # upper bound for solver ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) for _n in range(n): model.constraints.add(self.cA[_m][_n] + self.cB[_m][_n] <= ub) if mode_t in (""FULL"", ""CARCH""): for _m in range(m): model.constraints.add(self.cA[_m][0] == 1) model.constraints.add(self.cB[_m][0] == 1) if ampdel: for _m in range(m): cluster_id = f_a.index[_m] if cluster_id not in copy_numbers: for _n in range(1, n): model.constraints.add( self.cA[_m][_n] <= cn_max * adA[_m] + _base - _base * adA[_m] ) model.constraints.add(self.cA[_m][_n] >= _base * adA[_m]) model.constraints.add( self.cB[_m][_n] <= cn_max * adB[_m] + _base - _base * adB[_m] ) model.constraints.add(self.cB[_m][_n] >= _base * adB[_m]) if mode_t == ""UARCH"": # TODO: These loops can be collapsed once validation against C++ is complete for _m in range(m): for _k in range(k): _sumA = 0 _sumB = 0 for _n in range(n): _sumA += int(self._fixed_cA[_m][_n]) * self.u[_n][_k] _sumB += int(self._fixed_cB[_m][_n]) * self.u[_n][_k] model.constraints.add(fA[(_m, _k)] == _sumA) model.constraints.add(fB[(_m, _k)] == _sumB) if mode_t in (""FULL"", ""UARCH""): for _k in range(k): _sum = 0 for _n in range(n): _sum += self.u[_n][_k] model.constraints.add(_sum == 1) if (mode_t in (""FULL"", ""UARCH"")) and self.mu > 0: for _k in range(k): for _n in range(1, n): model.constraints.add(x[(_n, _k)] >= self.u[_n][_k]) model.constraints.add(self.u[_n][_k] >= self.mu * x[(_n, _k)]) # buildOptionalConstraints if (mode_t in (""FULL"", ""CARCH"")) and d > 0: for _m in range(self.m): for _n in range(1, self.n): _sum = 0 for _d in range(self.d): _sum += z[(_m, _n, _d)] model.constraints.add(_sum == 1) for _m in range(self.m): for _M in range(self.M): for _d in range(d): for _i in range(1, self.n - 1): for _j in range(1, self.n): model.constraints.add( bitcA[(_M, _m, _i)] - bitcA[(_M, _m, _j)] <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] ) model.constraints.add( bitcA[(_M, _m, _j)] - bitcA[(_M, _m, _i)] <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] ) model.constraints.add( bitcB[(_M, _m, _i)] - bitcB[(_M, _m, _j)] <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] ) model.constraints.add( bitcB[(_M, _m, _j)] - bitcB[(_M, _m, _i)] <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] ) for _m in range(self.m): for _d in range(d - 1): _sum_l = _sum_l1 = 0 for _n in range(1, self.n): _sum_l += z[(_m, _n, _d)] * self.symmCoeff(_n) _sum_l1 += z[(_m, _n, _d + 1)] * self.symmCoeff(_n) model.constraints.add(_sum_l <= _sum_l1) if mode_t in (""FULL"", ""CARCH""): self.build_symmetry_breaking(model) self.fix_given_cn(model) if mode_t == ""FULL"": self.hot_start() obj = 0 for _m in range(m): cluster_id = self.cluster_ids[_m] n_bins = len(self.binsA[cluster_id]) for _k in range(k): for _i in range(n_bins): obj += (yA[(_m, _k, _i)] + yB[(_m, _k, _i)]) * self.lengths[ cluster_id ][_i] model.obj = pe.Objective(expr=obj, sense=pe.minimize) self.model = model if pprint: print(str(self)) ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/solve/cd.py",".py","5007","169","from copy import copy from concurrent.futures import ProcessPoolExecutor, as_completed from hatchet.utils.solve.ilp_subset import ILPSubset, ILPSubsetSplit from hatchet.utils.solve.utils import Random class Worker: def __init__(self, ilp, solver): self.ilp = ilp self.solver_type = solver def run( self, cA, cB, u, max_iters, max_convergence_iters, tol=0.001, timelimit=None, ): _iters = _convergence_iters = 0 _u = u _cA, _cB = cA, cB # first hot-start values while (_iters < max_iters) and (_convergence_iters < max_convergence_iters): carch = copy(self.ilp) carch.fix_u(_u) carch.create_model() carch.hot_start(_cA, _cB) carch_results = carch.run(self.solver_type, timelimit=timelimit) if carch_results is None: return None _obj_c, _cA, _cB, _, _, _ = carch_results uarch = copy(self.ilp) uarch.fix_c(_cA, _cB) uarch.create_model() uarch_results = uarch.run(self.solver_type, timelimit=timelimit) if uarch_results is None: return None _obj_u, _, _, _u, _, _ = uarch_results delta = abs(_obj_c - _obj_u) if delta < tol: _convergence_iters += 1 else: _convergence_iters = 0 _iters += 1 return _obj_u, _cA, _cB, _u # Top-level 'work' function that can be pickled for multiprocessing def _work(cd, u, solver_type, max_iters, max_convergence_iters, timelimit): worker = Worker(cd.ilp, solver_type) return worker.run( cd.hcA, cd.hcB, u, max_iters=max_iters, max_convergence_iters=max_convergence_iters, timelimit=timelimit, ) class CoordinateDescent: def __init__(self, f_a, f_b, n, mu, d, cn_max, cn, w, purities, ampdel=True): # ilp attribute used here as a convenient storage container for properties self.ilp = ILPSubset( n=n, cn_max=cn_max, d=d, mu=mu, ampdel=ampdel, copy_numbers=cn, f_a=f_a, f_b=f_b, w=w, purities=purities, ) # Building the model here is not strictly necessary, as, during execution, # self.carch and c.uarch will copy self.ilp and create+run those models. # However, we do so here simply so we can print out some diagnostic information once for the user. self.ilp.create_model(pprint=True) self.hcA, self.hcB = self.ilp.first_hot_start() self.seeds = None def run( self, solver_type=""gurobi"", max_iters=10, max_convergence_iters=2, n_seed=400, j=8, random_seed=None, timelimit=None, ): with Random(random_seed): seeds = [self.ilp.build_random_u() for _ in range(n_seed)] result = {} # obj. value => (cA, cB, u) mapping to_do = [] with ProcessPoolExecutor(max_workers=min(j, n_seed)) as executor: for u in seeds: future = executor.submit( _work, self, u, solver_type, max_iters, max_convergence_iters, timelimit, ) to_do.append(future) for future in as_completed(to_do): results = future.result() if results is not None: obj, cA, cB, u = results result[obj] = cA, cB, u if not result: raise RuntimeError(""Not a single feasible solution found!"") best = min(result) return (best,) + result[best] + (self.ilp.cluster_ids, self.ilp.sample_ids) class CoordinateDescentSplit(CoordinateDescent): def __init__( self, f_a, f_b, n, mu, d, cn_max, cn, binsA, binsB, lengths, ampdel=True, ): # ilp attribute used here as a convenient storage container for properties self.ilp = ILPSubsetSplit( n=n, cn_max=cn_max, d=d, mu=mu, ampdel=ampdel, copy_numbers=cn, f_a=f_a, f_b=f_b, binsA=binsA, binsB=binsB, lengths=lengths, ) # Building the model here is not strictly necessary, as, during execution, # self.carch and c.uarch will copy self.ilp and create+run those models. # However, we do so here simply so we can print out some diagnostic information once for the user. self.ilp.create_model(pprint=True) self.hcA, self.hcB = self.ilp.first_hot_start() self.seeds = None ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/solve/__init__.py",".py","9369","306","import os import numpy as np import pandas as pd from pyomo import environ as pe from collections import OrderedDict from hatchet.utils.solve.ilp_subset import ILPSubset, ILPSubsetSplit from hatchet.utils.solve.cd import CoordinateDescent, CoordinateDescentSplit from hatchet.utils.solve.utils import parse_clonal, scale_rdr from hatchet import config import hatchet.utils.Supporting as sp def solver_available(solver=None): solver = solver or config.compute_cn.solver if solver == ""cpp"": return os.getenv(""GRB_LICENSE_FILE"") is not None elif solver == ""gurobipy"": return pe.SolverFactory(""gurobi"", solver_io=""python"").available( exception_flag=False ) return pe.SolverFactory(solver).available(exception_flag=False) def solve( clonal, bbc_file, seg_file, n, solver=""gurobi"", solve_mode=""cd"", d=-1, cn_max=-1, mu=0.01, diploid_threshold=0.1, ampdel=True, n_seed=400, n_worker=8, random_seed=None, max_iters=None, timelimit=None, binwise=False, purities=None, ): assert solve_mode in (""ilp"", ""cd"", ""both""), ""Unrecognized solve_mode"" assert solver_available(solver), f""Solver {solver} not available or not licensed"" if max_iters is None: max_iters = 10 df = pd.read_csv(seg_file, sep=""\t"") df = df.sort_values([""#ID"", ""SAMPLE""]) bbc = pd.read_table(bbc_file) bbc = bbc.sort_values(by=[""#CHR"", ""START"", ""SAMPLE""]) # sanity-check sample_ids = np.sort(df[""SAMPLE""].unique()) for _cluster_id, _df in df.groupby(""#ID""): _sample_ids = _df[""SAMPLE""].values if not np.all(_sample_ids == sample_ids): raise ValueError( f""Sample IDs for cluster {_cluster_id} do not match {sample_ids}"" ) rdr = df.pivot(index=""#ID"", columns=""SAMPLE"", values=""RD"") baf = df.pivot(index=""#ID"", columns=""SAMPLE"", values=""BAF"") bins = {} # cluster_id => no. of bins for cluster_id, _df in df.groupby(""#ID""): if len(_df[""#BINS""].unique()) != 1: raise ValueError( f""Bin sizes for cluster {cluster_id} across tumor samples are not identical!"" ) bins[cluster_id] = _df.iloc[0][""#BINS""] bins = pd.Series(bins) weights = 100 * bins / sum(bins) if clonal is None: _candidate_cluster_ids = np.all(rdr > 0.5 - diploid_threshold, axis=1) if not np.any(_candidate_cluster_ids): raise RuntimeError( f""Unable to determine cluster with diploid RDR threshold {diploid_threshold}"" ) dipoid_cluster_id = (_candidate_cluster_ids * weights).idxmax() copy_numbers = {dipoid_cluster_id: (1, 1)} else: copy_numbers = parse_clonal(clonal) gamma = scale_rdr(rdr, copy_numbers) sp.log( msg=""Computed scaling factor gamma = \n"" + str(gamma) + ""\n"", level=""INFO"", ) rdr = rdr * gamma f_b = rdr * baf f_a = rdr - f_b if not binwise: if solve_mode == ""ilp"": ilp = ILPSubset( n, cn_max, d=d, mu=mu, ampdel=ampdel, copy_numbers=copy_numbers, f_a=f_a, f_b=f_b, w=weights, purities=purities, ) ilp.create_model(pprint=True) return ilp.run(solver_type=solver, timelimit=timelimit) elif solve_mode == ""cd"": cd = CoordinateDescent( f_a=f_a, f_b=f_b, n=n, mu=mu, d=d, cn_max=cn_max, w=weights, ampdel=ampdel, cn=copy_numbers, purities=purities, ) return cd.run( solver_type=solver, max_iters=max_iters, n_seed=n_seed, j=n_worker, random_seed=random_seed, timelimit=timelimit, ) else: cd = CoordinateDescent( f_a=f_a, f_b=f_b, n=n, mu=mu, d=d, cn_max=cn_max, w=weights, ampdel=ampdel, cn=copy_numbers, purities=purities, ) _, cA, cB, _, _, _ = cd.run( solver_type=solver, max_iters=max_iters, n_seed=n_seed, j=n_worker, random_seed=random_seed, timelimit=timelimit, ) ilp = ILPSubset( n, cn_max, d=d, mu=mu, ampdel=ampdel, copy_numbers=copy_numbers, f_a=f_a, f_b=f_b, w=weights, purities=purities, ) ilp.create_model() ilp.hot_start(cA, cB) return ilp.run(solver_type=solver, timelimit=timelimit) else: bins = OrderedDict() # cluster_id => RDR for cluster for cluster_id, _df in df.groupby(""#ID""): if len(_df[""#BINS""].unique()) != 1: raise ValueError( f""Bin sizes for cluster {cluster_id} across tumor samples are not identical!"" ) my_bbc = bbc[bbc.CLUSTER == cluster_id] if _df.iloc[0][""#BINS""] * len(_df) != len( my_bbc ): # seg file should have 1 row per sample raise ValueError( f""BBC and SEG files describe inconsisitent # bins for cluster {cluster_id}!"" ) bins[cluster_id] = my_bbc.RD binned_length = ( bbc[bbc.SAMPLE == bbc.iloc[0].SAMPLE].END - bbc[bbc.SAMPLE == bbc.iloc[0].SAMPLE].START ).sum() bins_rdr = { k: my_df.pivot(index=[""#CHR"", ""START""], columns=""SAMPLE"", values=""RD"") for k, my_df in bbc.groupby(""CLUSTER"") } bins_baf = { k: my_df.pivot(index=[""#CHR"", ""START""], columns=""SAMPLE"", values=""BAF"") for k, my_df in bbc.groupby(""CLUSTER"") } bins_length = { k: ( ( my_df.pivot(index=[""#CHR"", ""START""], columns=""SAMPLE"", values=""END"") - my_df.pivot( index=[""#CHR"", ""START""], columns=""SAMPLE"", values=""START"", ) ).values[:, 0] * 100 ) / binned_length for k, my_df in bbc.groupby(""CLUSTER"") } binsA = {} binsB = {} for k in bins_rdr.keys(): bins_rdr[k] = bins_rdr[k] * gamma binsB[k] = bins_rdr[k] * bins_baf[k] binsA[k] = bins_rdr[k] - binsB[k] if solve_mode == ""ilp"": ilp = ILPSubsetSplit( n, cn_max, d=d, mu=mu, ampdel=ampdel, copy_numbers=copy_numbers, f_a=f_a, f_b=f_b, binsA=binsA, binsB=binsB, lengths=bins_length, purities=purities, ) ilp.create_model(pprint=True) return ilp.run(solver_type=solver, timelimit=timelimit) elif solve_mode == ""cd"": cd = CoordinateDescentSplit( f_a=f_a, f_b=f_b, n=n, mu=mu, d=d, cn_max=cn_max, ampdel=ampdel, cn=copy_numbers, binsA=binsA, binsB=binsB, lengths=bins_length, ) return cd.run( solver_type=solver, max_iters=max_iters, n_seed=n_seed, j=n_worker, random_seed=random_seed, timelimit=timelimit, ) else: cd = CoordinateDescentSplit( f_a=f_a, f_b=f_b, n=n, mu=mu, d=d, cn_max=cn_max, ampdel=ampdel, cn=copy_numbers, binsA=binsA, binsB=binsB, lengths=bins_length, ) _, cA, cB, _, _, _ = cd.run( solver_type=solver, max_iters=max_iters, n_seed=n_seed, j=n_worker, random_seed=random_seed, timelimit=timelimit, ) ilp = ILPSubsetSplit( n, cn_max, d=d, mu=mu, ampdel=ampdel, copy_numbers=copy_numbers, f_a=f_a, f_b=f_b, cn=copy_numbers, binsA=binsA, binsB=binsB, lengths=bins_length, ) ilp.create_model() ilp.hot_start(cA, cB) return ilp.run(solver_type=solver, timelimit=timelimit) ","Python" "Allele","raphael-group/hatchet","src/hatchet/utils/solve/utils.py",".py","7185","182","from collections import OrderedDict import numpy as np import pandas as pd # A list of random states, used as a stack random_states = [] class Random: """""" A context manager that pushes a random seed to the stack for reproducible results, and pops it on exit. """""" def __init__(self, seed=None): self.seed = seed def __enter__(self): if self.seed is not None: # Push current state on stack random_states.append(np.random.get_state()) new_state = np.random.RandomState(self.seed) np.random.set_state(new_state.get_state()) def __exit__(self, *args): if self.seed is not None: np.random.set_state(random_states.pop()) def parse_clonal(clonal): copy_numbers = OrderedDict() # dict from cluster_id => (cn_a, cn_b) 2-tuple clonal_parts = clonal.split("","") n_clonal_parts = len(clonal_parts) for i, c in enumerate(clonal_parts): cluster_id, cn_a, cn_b = [int(_c) for _c in c.split("":"")] # The first two clonal clusters (used for scaling) MUST have different total copy numbers if i == 1: _first_cn_a, _first_cn_b = list(copy_numbers.values())[0] if _first_cn_a + _first_cn_b == cn_a + cn_b: raise ValueError( ( ""When >= 2 clonal copy numbers are given, the first two must be different in the two segmental "" ""clusters"" ) ) cn_total = cn_a + cn_b if (cn_total == 2) and (n_clonal_parts > 1): # warnings.warn('Please specify a single cluster when CN_A+CN_B=2') # TODO: The C++ implementation generates a warning corresponding to the above # This is suppressed by default, which is what we do here for now. pass if cluster_id in copy_numbers: raise ValueError(""Already encountered cluster_id ="", str(cluster_id)) copy_numbers[cluster_id] = cn_a, cn_b return copy_numbers def scale_rdr(rdr, copy_numbers, purity_tol=0.05): assert len(copy_numbers) >= 1 if len(copy_numbers) == 1: diploid_cluster_id = list(copy_numbers.keys())[0] diploid_rdr = rdr.loc[diploid_cluster_id] scale = 2 / diploid_rdr else: # Use the first two copy-number specifications to determine scaling factors # Note the reversed assignment order to conform to C++ behavior - check with Simone! cluster_id_2, cluster_id_1 = tuple(copy_numbers.keys())[:2] # TODO rdr_1, rdr_2 = rdr.loc[cluster_id_1], rdr.loc[cluster_id_2] cn_sum_1, cn_sum_2 = ( sum(copy_numbers[cluster_id_1]), sum(copy_numbers[cluster_id_2]), ) purity = 2 * (rdr_1 - rdr_2) / ((2 - cn_sum_2) * rdr_1 - (2 - cn_sum_1) * rdr_2) purity[(1 <= purity) & (purity <= 1 + purity_tol)] = 1 purity[(-purity_tol <= purity) & (purity <= 0)] = 0 scale = (2 - (2 - cn_sum_1) * purity) / rdr_1 assert np.all((0 <= purity) & (purity <= 1) & (scale >= 0)), ""scaling failed"" return scale def segmentation( cA, cB, u, cluster_ids, sample_ids, bbc_file, bbc_out_file=None, seg_out_file=None, ): df = pd.read_csv(bbc_file, sep=""\t"") # Chromosomes may or may not have chr notation - force a string dtype anyway df[""#CHR""] = df[""#CHR""].astype(str) # TODO: The legacy C++ implementation interprets the 'coverage' column as an int df[""COV""] = df[""COV""].astype(int) n_clone = len(cA[0]) cA = pd.DataFrame(cA, index=cluster_ids, columns=range(n_clone)) cB = pd.DataFrame(cB, index=cluster_ids, columns=range(n_clone)) u = pd.DataFrame(u, index=range(n_clone), columns=sample_ids) # Make (n_sample, n_clone) in shape; easier to merge later u = u.T # copy-numbers represented as | strings cN = cA.astype(str) + ""|"" + cB.astype(str) cN.columns = [""cn_normal""] + [f""cn_clone{i}"" for i in range(1, n_clone)] # Merge in copy-number + proportion information to our original Dataframe df = df.merge(cN, left_on=""CLUSTER"", right_index=True) u.columns = [""u_normal""] + [f""u_clone{i}"" for i in range(1, n_clone)] df = df.merge(u, left_on=""SAMPLE"", right_index=True) # Sorting the values by start/end position critical for merging contiguous # segments with identical copy numbers later on df = df.sort_values([""#CHR"", ""START"", ""END"", ""SAMPLE""]) df = df.reset_index(drop=True) # last 2*n_clone columns names = [cn_normal, u_normal, cn_clone1, u_clone1, cn_clone2, ...] extra_columns = [col for sublist in zip(cN.columns, u.columns) for col in sublist] all_columns = df.columns.values[: -2 * n_clone].tolist() + extra_columns if bbc_out_file is not None: # rearrange columns for easy comparison to legacy files df = df[all_columns] df.to_csv(bbc_out_file, sep=""\t"", index=False) if seg_out_file is not None: # create a new column that will use to store the contiguous segment number (1-indexed) df[""segment""] = 0 # all column names with cnA|cnB information (normal + clones) cN_column_names = cN.columns.tolist() # create a new column with all cnA|cnB strings joined as a single column df[""all_copy_numbers""] = df[cN_column_names].apply( lambda x: "","".join(x), axis=1 ) _first_sample_name = df[""SAMPLE""].iloc[0] # Grouping by consecutive identical values # See https://towardsdatascience.com/pandas-dataframe-group-by-consecutive-same-values-128913875dba group_name_to_indices = df.groupby( ( # Find indices where we see the first sample name AND (df[""SAMPLE""] == _first_sample_name) & ( # The chromosome changed values from the previous row OR # any of the copy-numbers changed from the previous row OR # the START changed from the END in the previous row (df[""#CHR""] != df[""#CHR""].shift()) | (df[""all_copy_numbers""] != df[""all_copy_numbers""].shift()) | (df[""START""] != df[""END""].shift()) ) ).cumsum(), # cumulative sum increments whenever a True is encountered, thus creating a series of monotonically # increasing values we can use as segment numbers sort=False, ).indices # 'indices' of a Pandas GroupBy object gives us a mapping from the group 'name' # (numbers starting from 1) -> indices in the Dataframe for group_name, indices in group_name_to_indices.items(): df.loc[indices, ""segment""] = group_name aggregation_rules = { ""#CHR"": ""first"", ""START"": ""min"", ""END"": ""max"", ""SAMPLE"": ""first"", } aggregation_rules.update({c: ""first"" for c in extra_columns}) df = df.groupby([""segment"", ""SAMPLE""]).agg(aggregation_rules) df.to_csv(seg_out_file, sep=""\t"", index=False) ","Python" "Allele","raphael-group/hatchet","src/hatchet/data/__init__.py",".py","0","0","","Python" "Allele","raphael-group/hatchet","examples/demo-WES/demo-wes.md",".md","12879","145","# Demo for WES data from a cancer patient : ex: set ft=markdown ;:<<'```shell' # **NOTE**: this demo has not yet been updated for version 1.0 of HATCHet which includes variable-width binning, phasing, and locality-aware clustering. The following HATCHet's demo represents a guided example starting from WES (whole-exome sequencing) data from 2 samples of the same patient. WES data are an interesting case to consider as they are typically characterize by a larger variance, especially for RDR. For simplicity, the demo starts from a BB file `demo-wes.bb` (included in this demo at `examples/demo-WES/`) which contains the RDR and BAF of every genomic bin and, therefore, we assume that the preliminary steps (i.e. count-reads, count-alleles, and combine-counts) have already been executed by running standard configuration for WES data (bin size of 250kb through -b 250kb of count-reads, and the allele counts for germline heterozygous SNPs have been selected between 30 and 400 through `-c 30 -C 400` of `count-alleles` as the average coverage is 180x). ## Requirements and set up The demo requires that HATCHet has been successfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: ```shell PY=""python3"" # This is the full path to the version of PYTHON3 which contains the required `hatchet` module. When this corresponds to the standard version, the user can keep the given value of `python3` :<<'```shell' # Ignore this line ``` The following paths are consequently obtained to point to the required components of HATCHet ```shell CLUSTERBINS=""${PY} -m hatchet cluster-bins"" PLOTBINS=""${PY} -m hatchet plot-bins"" INFER=""${PY} -m hatchet compute-cn"" PLOTCN=""${PY} -m hatchet plot-cn"" :<<'```shell' # Ignore this line ``` We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands ```shell set -e set -o xtrace PS4='[\t]' :<<'```shell' # Ignore this line ``` ## Global clustering The first main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: ```shell ${CLUSTERBINS} demo-wes.bb -o demo-wes.seg -O demo-wes.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 :<<'```shell' # Ignore this line ``` For different type of data it is essential to assess the quality of the clustering because this is performed by a Dirichlet process and it is affected by varying degrees of noise. This assesment is particularly important in the case of WES data where the variance is higher than expected, especially for RDR; in fact we often observe that the clusters are much wider in terms of RDR (x-axis) and tend to have a *disc* shape rather than the expected *oval* shape. To do this, we use `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data, and produce the cluster plot using the `CBB` command. To help we use the following options: - `--xmin 0` and `--xmax 2` allow to zoom in and to focus the figure on the same RDR (y-axis) range for every sample. - `-tS 0.005` asks to plot only the clusters which cover at least the `0.5%` of the genome. This is useful to clean the figure and focus on the main components. To trace all steps, we also move the figure to `tR015-cbb.pdf`. ```shell ${PLOTBINS} -c CBB demo-wes.bbc --ymin 0 --ymax 2 -tS 0.005 mv bb_clustered.png tR015-cbb.png :<<'```shell' # Ignore this line ``` We thus obtain the following clustering: ![Bad clustering with default values](tR015-cbb.png) We can easily notice that the clustering is not ideal and is clearly overfitting the data by choosing too many distinct clusters; in fact we notice the presence of many different clusters that are extremely close and have identical BAF in every sample. For example, orange/light blue/light orange clusters and purple/red clusters exhibit a very typical pattern of ""striped"" clusters which are always adjacent clusters which appear to be part of a wider cluster. A good condition to assess the quality of the clustering is to assess that every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. Since Dirichlet clustering is not ad-hoc for this application, it can often result in overclustering. For this reason, cluster-bins additionally provides a procedure to merge clusters which are very likely to be part of a single cluster. However this procedure requires two maximum thresholds for doing this, one is the maximum shift for RDR (`-tR 0.15`) and one is the maximum shift for BAF (`-tB 0.03`). The default values allow to work with most of the datasets, however datasets of high variance, e.g. in the case of WES data, require to tune these parameters. In our example as in most WES datasets, BAF is pretty well estimated and the clusters exhibit small variance on the y-axis, accordingly, the default value `-tB 0.03` is therefore good. Instead, RDR appears to have much higher variance; in fact, the clusters that are always adjacent span much more than 0.15 of RDR in the x-axis. Therefore, by looking at the plot, we can see that a value of `-tR 0.5` fit much better the noise of RDR in our data and we repeat the clustering with this value. ```shell ${CLUSTERBINS} demo-wes.bb -o demo-wes.seg -O demo-wes.bbc -e 12 -tB 0.03 -tR 0.5 -d 0.08 :<<'```shell' # Ignore this line ``` We assess again the clustering using `plot-bins` as before. ```shell ${PLOTBINS} -c CBB demo-wes.bbc --ymin 0 --ymax 2 -tS 0.005 mv bb_clustered.png cbb.png :<<'```shell' # Ignore this line ``` We thus obtain the following clustering: ![Better clustering with default values](cbb.png) In this clustering the previously-described condition is met and all the different clusters are clearly distinct in at least one sample. ## hatchet's step In the last step we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. We apply the last step with default parameters and, for simplicity of this demo, we apply only few changes: - As the dataset has high variance and noise (see clustering), we consider a minimum clone proportion `-u` slightly higher than the default value, i.e. `6%`. We do this because we cannot infer tumor clones with very low proportions when there is high noise and because potential clones inferred with very low proportions may simply be the result of overfitting. In fact, when using values of `-u` smaller than `6%` we obtain solutions with clone proporions identical to the minimum value of `-u`; this is the recommended criterion to determine the need of increasing the value of `-u`. Interestingly, we can observe the same overfitting sign when we consider too high values of the minimum clone proportion, for example `-u 0.1`. This happens because the value is too high to fit the given data. As such, it is always important to choose the minimum value which provides ""non-overfitting"" results, i.e. results where the clone proportions are not identical to the minimum. When this is not possible, as in very noisy datasets, we reccommend to either tune the clustering or keeping very low values of the minimum clone proportion, as HATCHet is still able to recover the main clonal composition even in the presence of mninor overfitting. - We limit the number of clones to 6 for simplicity of this demo and because it is a reasonable value for CNAs when consider only few samples from the same patient. - We only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. ```shell ${INFER} -i demo-wes -n2,6 -p 100 -v 2 -u 0.06 -r 12 -eD 6 -eT 12 -l 0.5 |& tee hatchet.log :<<'```shell' # Ignore this line ``` We obtain the following summary of results: ## Scores approximating second derivative for diploid results ## Diploid with 2 clones - OBJ: 25.198649 - score: -0.0948974010472 ## Diploid with 3 clones - OBJ: 15.247768 - score: -0.093570025792 ## Diploid with 4 clones - OBJ: 7.79973 - score: 0.183873549872 ## Diploid with 5 clones - OBJ: 5.42398 - score: 0.071621041522 ## Diploid with 6 clones - OBJ: 4.16034 - score: -0.0670271645544 ## Scores approximating second derivative for tetraploid results ## Tetraploid with 2 clones - OBJ: 54.70041 - score: -0.258478300254 ## Tetraploid with 3 clones - OBJ: 24.151418 - score: 0.0574235848181 ## Tetraploid with 4 clones - OBJ: 13.46257 - score: 0.208505877387 ## Tetraploid with 5 clones - OBJ: 10.311379 - score: 0.0136705311613 ## Tetraploid with 6 clones - OBJ: 8.038751 - score: -0.0795999933666 # The chosen diploid solution has 4 clones with OBJ: 7.79973 and score: 0.183873549872 ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn # The chosen tetraploid solution has 4 clones with OBJ: 13.46257 and score: 0.208505877387 ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn # The chosen solution is diploid with 4 clones and is written in ./best.bbc.ucn and ./best.seg.ucn HATCHet predicts the presence of 4 clones in the 3 tumor samples with no WGD and, especially, predicts that each sample contains two distinct tumor clones while sharing one of this. As there are inferred tumor clones with small clone proportions, there are only 2 samples, and the objective function does not significantly decrease after the chosen number of clones, there is no need to investigate the results of HATCHet by increasing the sensitivity with lower values of `-l`. However, the user could investigate the results of HATCHet when considering a lower sensitivity to small CNAs by considering higher values of `-l`, e.g. `-l 0.6` or `-l 0.8`; this choice would be indeed motivated by the high noise of the dataset. ## Analyzing inferred results Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. As WES data have fewer point covering the genome, we slightly change the resolution of the plots by asking to obtain genomic regions merging fewer genomic bins through `-rC 10 -rG 1`. As such, we run `plot-cn` as follows ```shell ${PLOTCN} best.bbc.ucn -rC 10 -rG 1 exit $? ``` First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: ### SAMPLE: WESDemo2 -- PURITY: 0.7534724 -- PLOIDY: 1.84640419971 -- CLASSIFICATION: DIPLOID ### SAMPLE: WESDemo1 -- PURITY: 0.9283579 -- PLOIDY: 1.90711595733 -- CLASSIFICATION: DIPLOID Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly important. The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). ![intratumor-clones-totalcn.pdf](totalcn.png) Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. ![intratumor-clones-allelecn.pdf](allelecn.png) The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. ![intratumor-clones-allelecn.pdf](profiles.png) The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. ","Markdown" "Allele","raphael-group/hatchet","examples/demo-WES/demo-wes.sh",".sh","12879","145","# Demo for WES data from a cancer patient : ex: set ft=markdown ;:<<'```shell' # **NOTE**: this demo has not yet been updated for version 1.0 of HATCHet which includes variable-width binning, phasing, and locality-aware clustering. The following HATCHet's demo represents a guided example starting from WES (whole-exome sequencing) data from 2 samples of the same patient. WES data are an interesting case to consider as they are typically characterize by a larger variance, especially for RDR. For simplicity, the demo starts from a BB file `demo-wes.bb` (included in this demo at `examples/demo-WES/`) which contains the RDR and BAF of every genomic bin and, therefore, we assume that the preliminary steps (i.e. count-reads, count-alleles, and combine-counts) have already been executed by running standard configuration for WES data (bin size of 250kb through -b 250kb of count-reads, and the allele counts for germline heterozygous SNPs have been selected between 30 and 400 through `-c 30 -C 400` of `count-alleles` as the average coverage is 180x). ## Requirements and set up The demo requires that HATCHet has been successfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: ```shell PY=""python3"" # This is the full path to the version of PYTHON3 which contains the required `hatchet` module. When this corresponds to the standard version, the user can keep the given value of `python3` :<<'```shell' # Ignore this line ``` The following paths are consequently obtained to point to the required components of HATCHet ```shell CLUSTERBINS=""${PY} -m hatchet cluster-bins"" PLOTBINS=""${PY} -m hatchet plot-bins"" INFER=""${PY} -m hatchet compute-cn"" PLOTCN=""${PY} -m hatchet plot-cn"" :<<'```shell' # Ignore this line ``` We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands ```shell set -e set -o xtrace PS4='[\t]' :<<'```shell' # Ignore this line ``` ## Global clustering The first main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: ```shell ${CLUSTERBINS} demo-wes.bb -o demo-wes.seg -O demo-wes.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 :<<'```shell' # Ignore this line ``` For different type of data it is essential to assess the quality of the clustering because this is performed by a Dirichlet process and it is affected by varying degrees of noise. This assesment is particularly important in the case of WES data where the variance is higher than expected, especially for RDR; in fact we often observe that the clusters are much wider in terms of RDR (x-axis) and tend to have a *disc* shape rather than the expected *oval* shape. To do this, we use `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data, and produce the cluster plot using the `CBB` command. To help we use the following options: - `--xmin 0` and `--xmax 2` allow to zoom in and to focus the figure on the same RDR (y-axis) range for every sample. - `-tS 0.005` asks to plot only the clusters which cover at least the `0.5%` of the genome. This is useful to clean the figure and focus on the main components. To trace all steps, we also move the figure to `tR015-cbb.pdf`. ```shell ${PLOTBINS} -c CBB demo-wes.bbc --ymin 0 --ymax 2 -tS 0.005 mv bb_clustered.png tR015-cbb.png :<<'```shell' # Ignore this line ``` We thus obtain the following clustering: ![Bad clustering with default values](tR015-cbb.png) We can easily notice that the clustering is not ideal and is clearly overfitting the data by choosing too many distinct clusters; in fact we notice the presence of many different clusters that are extremely close and have identical BAF in every sample. For example, orange/light blue/light orange clusters and purple/red clusters exhibit a very typical pattern of ""striped"" clusters which are always adjacent clusters which appear to be part of a wider cluster. A good condition to assess the quality of the clustering is to assess that every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. Since Dirichlet clustering is not ad-hoc for this application, it can often result in overclustering. For this reason, cluster-bins additionally provides a procedure to merge clusters which are very likely to be part of a single cluster. However this procedure requires two maximum thresholds for doing this, one is the maximum shift for RDR (`-tR 0.15`) and one is the maximum shift for BAF (`-tB 0.03`). The default values allow to work with most of the datasets, however datasets of high variance, e.g. in the case of WES data, require to tune these parameters. In our example as in most WES datasets, BAF is pretty well estimated and the clusters exhibit small variance on the y-axis, accordingly, the default value `-tB 0.03` is therefore good. Instead, RDR appears to have much higher variance; in fact, the clusters that are always adjacent span much more than 0.15 of RDR in the x-axis. Therefore, by looking at the plot, we can see that a value of `-tR 0.5` fit much better the noise of RDR in our data and we repeat the clustering with this value. ```shell ${CLUSTERBINS} demo-wes.bb -o demo-wes.seg -O demo-wes.bbc -e 12 -tB 0.03 -tR 0.5 -d 0.08 :<<'```shell' # Ignore this line ``` We assess again the clustering using `plot-bins` as before. ```shell ${PLOTBINS} -c CBB demo-wes.bbc --ymin 0 --ymax 2 -tS 0.005 mv bb_clustered.png cbb.png :<<'```shell' # Ignore this line ``` We thus obtain the following clustering: ![Better clustering with default values](cbb.png) In this clustering the previously-described condition is met and all the different clusters are clearly distinct in at least one sample. ## hatchet's step In the last step we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. We apply the last step with default parameters and, for simplicity of this demo, we apply only few changes: - As the dataset has high variance and noise (see clustering), we consider a minimum clone proportion `-u` slightly higher than the default value, i.e. `6%`. We do this because we cannot infer tumor clones with very low proportions when there is high noise and because potential clones inferred with very low proportions may simply be the result of overfitting. In fact, when using values of `-u` smaller than `6%` we obtain solutions with clone proporions identical to the minimum value of `-u`; this is the recommended criterion to determine the need of increasing the value of `-u`. Interestingly, we can observe the same overfitting sign when we consider too high values of the minimum clone proportion, for example `-u 0.1`. This happens because the value is too high to fit the given data. As such, it is always important to choose the minimum value which provides ""non-overfitting"" results, i.e. results where the clone proportions are not identical to the minimum. When this is not possible, as in very noisy datasets, we reccommend to either tune the clustering or keeping very low values of the minimum clone proportion, as HATCHet is still able to recover the main clonal composition even in the presence of mninor overfitting. - We limit the number of clones to 6 for simplicity of this demo and because it is a reasonable value for CNAs when consider only few samples from the same patient. - We only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. ```shell ${INFER} -i demo-wes -n2,6 -p 100 -v 2 -u 0.06 -r 12 -eD 6 -eT 12 -l 0.5 |& tee hatchet.log :<<'```shell' # Ignore this line ``` We obtain the following summary of results: ## Scores approximating second derivative for diploid results ## Diploid with 2 clones - OBJ: 25.198649 - score: -0.0948974010472 ## Diploid with 3 clones - OBJ: 15.247768 - score: -0.093570025792 ## Diploid with 4 clones - OBJ: 7.79973 - score: 0.183873549872 ## Diploid with 5 clones - OBJ: 5.42398 - score: 0.071621041522 ## Diploid with 6 clones - OBJ: 4.16034 - score: -0.0670271645544 ## Scores approximating second derivative for tetraploid results ## Tetraploid with 2 clones - OBJ: 54.70041 - score: -0.258478300254 ## Tetraploid with 3 clones - OBJ: 24.151418 - score: 0.0574235848181 ## Tetraploid with 4 clones - OBJ: 13.46257 - score: 0.208505877387 ## Tetraploid with 5 clones - OBJ: 10.311379 - score: 0.0136705311613 ## Tetraploid with 6 clones - OBJ: 8.038751 - score: -0.0795999933666 # The chosen diploid solution has 4 clones with OBJ: 7.79973 and score: 0.183873549872 ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn # The chosen tetraploid solution has 4 clones with OBJ: 13.46257 and score: 0.208505877387 ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn # The chosen solution is diploid with 4 clones and is written in ./best.bbc.ucn and ./best.seg.ucn HATCHet predicts the presence of 4 clones in the 3 tumor samples with no WGD and, especially, predicts that each sample contains two distinct tumor clones while sharing one of this. As there are inferred tumor clones with small clone proportions, there are only 2 samples, and the objective function does not significantly decrease after the chosen number of clones, there is no need to investigate the results of HATCHet by increasing the sensitivity with lower values of `-l`. However, the user could investigate the results of HATCHet when considering a lower sensitivity to small CNAs by considering higher values of `-l`, e.g. `-l 0.6` or `-l 0.8`; this choice would be indeed motivated by the high noise of the dataset. ## Analyzing inferred results Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. As WES data have fewer point covering the genome, we slightly change the resolution of the plots by asking to obtain genomic regions merging fewer genomic bins through `-rC 10 -rG 1`. As such, we run `plot-cn` as follows ```shell ${PLOTCN} best.bbc.ucn -rC 10 -rG 1 exit $? ``` First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: ### SAMPLE: WESDemo2 -- PURITY: 0.7534724 -- PLOIDY: 1.84640419971 -- CLASSIFICATION: DIPLOID ### SAMPLE: WESDemo1 -- PURITY: 0.9283579 -- PLOIDY: 1.90711595733 -- CLASSIFICATION: DIPLOID Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly important. The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). ![intratumor-clones-totalcn.pdf](totalcn.png) Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. ![intratumor-clones-allelecn.pdf](allelecn.png) The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. ![intratumor-clones-allelecn.pdf](profiles.png) The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. ","Shell" "Allele","raphael-group/hatchet","examples/demo-WGS-sim/demo-wgs-sim.md",".md","9051","130","# Demo for standard WGS data : ex: set ft=markdown ;:<<'```shell' # **NOTE**: this demo has not yet been updated for version 1.0 of HATCHet which includes variable-width binning, phasing, and locality-aware clustering. The following HATCHet's demo represents a guided example starting from WGS (whole-genome sequencing) data from 3 simulated samples obtained from the same tumor. This represents an exemplary case of executing HATCHet on a typical dataset with standard noise. For simplicity, the demo starts from a BB file `demo-WGS-sim.bb` (included in this demo at `examples/demo-WGS-sim/`) which contains the RDR and BAF of every genomic bin and, therefore, we assume that the preliminary steps (i.e. count-reads, count-alleles, and combine-counts) have already been executed by running standard configuration for WGS data (bin size of 50kb through -b 50kb of count-reads, and the allele counts for germline heterozygous SNPs have been selected between 3 and 200 through `-c 3 -C 200`). Specifically, the tumor is composed of 2 tumor clones (clone0 and clone1) and a normal diploid clone (normal). The clonal composition of every sample is described in the following table: | Name | Proportion of normal clone | Proporion of clone0 | Proportion of clone1 | |------|----------------------------|---------------------|----------------------| | `bulk_035clone1_06clone0_005normal` | `5%` | `60%` | `35%` | | `bulk_055clone1_04clone0_005normal` | `5%` | `40%` | `55%` | | `bulk_08clone1_Noneclone0_02normal` | `20%` | Not present | `80%` | ## Requirements and set up The demo requires that HATCHet has been successfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: ```shell PY=""python3"" # This id the full path to the version of PYTHON3 which contains the required `hatchet` module. When this corresponds to the standard version, the user can keep the given value of `python3` :<<'```shell' # Ignore this line ``` The following paths are consequently obtained to point to the required components of HATCHet ```shell CLUSTERBINS=""${PY} -m hatchet cluster-bins"" PLOTBINS=""${PY} -m hatchet plot-bins"" INFER=""${PY} -m hatchet compute-cn"" PLOTCN=""${PY} -m hatchet plot-cn"" :<<'```shell' # Ignore this line ``` We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands ```shell set -e set -o xtrace PS4='[\t]' :<<'```shell' # Ignore this line ``` ## Global clustering The first main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: ```shell ${CLUSTERBINS} demo-wgs-sim.bb -o demo-wgs-sim.seg -O demo-wgs-sim.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 :<<'```shell' # Ignore this line ``` To assess the quality of the clustering we generate the cluster plot using the `CBB` command of `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data. For simplicity, we also use the following options - `--colwrap 3` allows to have the 3 plots of the 3 samples on the same figure row - `-tS 0.01` asks to plot only the clusters which cover at least the `1%` of the genome. This is useful to clean the figure and focus on the main components. ```shell ${PLOTBINS} -c CBB demo-wgs-sim.bbc --colwrap 3 -tS 0.01 :<<'```shell' # Ignore this line ``` We thus obtain the following clustering: ![CBB](cbb.png) We can easily notice that the clustering is good and not tuning is needed as every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. ## hatchet's step Next we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. We apply the last step with default parameters and, for simplicity of this demo, we consider 8 clones, which can be easily considered by HATCHet in this case, and we only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. ```shell ${INFER} -i demo-wgs-sim -n2,8 -p 100 -v 2 -u 0.03 -r 12 -eD 6 -eT 12 -l 0.5 |& tee hatchet.log :<<'```shell' # Ignore this line ``` We obtain the following summary of results: ## Scores approximating second derivative for diploid results ## Diploid with 2 clones - OBJ: 66.884758 - score: -0.17739731674 ## Diploid with 3 clones - OBJ: 34.954154 - score: -0.0216588755513 ## Diploid with 4 clones - OBJ: 17.510067 - score: 0.0555719383474 ## Diploid with 5 clones - OBJ: 9.744628 - score: 0.186776250313 ## Diploid with 6 clones - OBJ: 7.243104 - score: 0.0839737725603 ## Diploid with 7 clones - OBJ: 5.991972 - score: 0.0538665194051 ## Diploid with 8 clones - OBJ: 5.27972 - score: -0.181132288335 ## Scores approximating second derivative for tetraploid results ## Tetraploid with 2 clones - OBJ: 81.216417 - score: -0.415141225696 ## Tetraploid with 3 clones - OBJ: 23.135209 - score: 0.169099207187 ## Tetraploid with 4 clones - OBJ: 15.47975 - score: 0.0653131702741 ## Tetraploid with 5 clones - OBJ: 11.36852 - score: 0.0682096876804 ## Tetraploid with 6 clones - OBJ: 9.124625 - score: 0.0411292123085 ## Tetraploid with 7 clones - OBJ: 7.698914 - score: 0.0753487410723 ## Tetraploid with 8 clones - OBJ: 7.076072 - score: -0.219100018522 # The chosen diploid solution has 5 clones with OBJ: 9.744628 and score: 0.186776250313 ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn # The chosen tetraploid solution has 3 clones with OBJ: 23.135209 and score: 0.169099207187 ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn # The chosen solution is tetraploid with 3 clones and is written in ./best.bbc.ucn and ./best.seg.ucn HATCHet predicts the presence of 3 clones in the 3 tumor samples and, especially, predicts that 2 samples contains two distinct tumor clones, according to the true clonal composition. ## Analyzing inferred results Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. We run `plot-cn` as follows ```shell ${PLOTCN} best.bbc.ucn exit $? ``` First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: ### SAMPLE: bulk_08clone1_Noneclone0_02normal -- PURITY: 0.799477 -- PLOIDY: 3.07107541299 -- CLASSIFICATION: TETRAPLOID ### SAMPLE: bulk_035clone1_06clone0_005normal -- PURITY: 0.95065 -- PLOIDY: 3.37447061915 -- CLASSIFICATION: TETRAPLOID ### SAMPLE: bulk_055clone1_04clone0_005normal -- PURITY: 0.95048 -- PLOIDY: 3.27575289096 -- CLASSIFICATION: TETRAPLOID Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly interesting. The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). ![intratumor-clones-totalcn.pdf](totalcn.png) Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. ![intratumor-clones-allelecn.pdf](allelecn.png) The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. ![intratumor-clones-allelecn.pdf](profiles.png) The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. ","Markdown" "Allele","raphael-group/hatchet","examples/demo-WGS-sim/demo-wgs-sim.sh",".sh","9051","130","# Demo for standard WGS data : ex: set ft=markdown ;:<<'```shell' # **NOTE**: this demo has not yet been updated for version 1.0 of HATCHet which includes variable-width binning, phasing, and locality-aware clustering. The following HATCHet's demo represents a guided example starting from WGS (whole-genome sequencing) data from 3 simulated samples obtained from the same tumor. This represents an exemplary case of executing HATCHet on a typical dataset with standard noise. For simplicity, the demo starts from a BB file `demo-WGS-sim.bb` (included in this demo at `examples/demo-WGS-sim/`) which contains the RDR and BAF of every genomic bin and, therefore, we assume that the preliminary steps (i.e. count-reads, count-alleles, and combine-counts) have already been executed by running standard configuration for WGS data (bin size of 50kb through -b 50kb of count-reads, and the allele counts for germline heterozygous SNPs have been selected between 3 and 200 through `-c 3 -C 200`). Specifically, the tumor is composed of 2 tumor clones (clone0 and clone1) and a normal diploid clone (normal). The clonal composition of every sample is described in the following table: | Name | Proportion of normal clone | Proporion of clone0 | Proportion of clone1 | |------|----------------------------|---------------------|----------------------| | `bulk_035clone1_06clone0_005normal` | `5%` | `60%` | `35%` | | `bulk_055clone1_04clone0_005normal` | `5%` | `40%` | `55%` | | `bulk_08clone1_Noneclone0_02normal` | `20%` | Not present | `80%` | ## Requirements and set up The demo requires that HATCHet has been successfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: ```shell PY=""python3"" # This id the full path to the version of PYTHON3 which contains the required `hatchet` module. When this corresponds to the standard version, the user can keep the given value of `python3` :<<'```shell' # Ignore this line ``` The following paths are consequently obtained to point to the required components of HATCHet ```shell CLUSTERBINS=""${PY} -m hatchet cluster-bins"" PLOTBINS=""${PY} -m hatchet plot-bins"" INFER=""${PY} -m hatchet compute-cn"" PLOTCN=""${PY} -m hatchet plot-cn"" :<<'```shell' # Ignore this line ``` We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands ```shell set -e set -o xtrace PS4='[\t]' :<<'```shell' # Ignore this line ``` ## Global clustering The first main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: ```shell ${CLUSTERBINS} demo-wgs-sim.bb -o demo-wgs-sim.seg -O demo-wgs-sim.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 :<<'```shell' # Ignore this line ``` To assess the quality of the clustering we generate the cluster plot using the `CBB` command of `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data. For simplicity, we also use the following options - `--colwrap 3` allows to have the 3 plots of the 3 samples on the same figure row - `-tS 0.01` asks to plot only the clusters which cover at least the `1%` of the genome. This is useful to clean the figure and focus on the main components. ```shell ${PLOTBINS} -c CBB demo-wgs-sim.bbc --colwrap 3 -tS 0.01 :<<'```shell' # Ignore this line ``` We thus obtain the following clustering: ![CBB](cbb.png) We can easily notice that the clustering is good and not tuning is needed as every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. ## hatchet's step Next we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. We apply the last step with default parameters and, for simplicity of this demo, we consider 8 clones, which can be easily considered by HATCHet in this case, and we only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. ```shell ${INFER} -i demo-wgs-sim -n2,8 -p 100 -v 2 -u 0.03 -r 12 -eD 6 -eT 12 -l 0.5 |& tee hatchet.log :<<'```shell' # Ignore this line ``` We obtain the following summary of results: ## Scores approximating second derivative for diploid results ## Diploid with 2 clones - OBJ: 66.884758 - score: -0.17739731674 ## Diploid with 3 clones - OBJ: 34.954154 - score: -0.0216588755513 ## Diploid with 4 clones - OBJ: 17.510067 - score: 0.0555719383474 ## Diploid with 5 clones - OBJ: 9.744628 - score: 0.186776250313 ## Diploid with 6 clones - OBJ: 7.243104 - score: 0.0839737725603 ## Diploid with 7 clones - OBJ: 5.991972 - score: 0.0538665194051 ## Diploid with 8 clones - OBJ: 5.27972 - score: -0.181132288335 ## Scores approximating second derivative for tetraploid results ## Tetraploid with 2 clones - OBJ: 81.216417 - score: -0.415141225696 ## Tetraploid with 3 clones - OBJ: 23.135209 - score: 0.169099207187 ## Tetraploid with 4 clones - OBJ: 15.47975 - score: 0.0653131702741 ## Tetraploid with 5 clones - OBJ: 11.36852 - score: 0.0682096876804 ## Tetraploid with 6 clones - OBJ: 9.124625 - score: 0.0411292123085 ## Tetraploid with 7 clones - OBJ: 7.698914 - score: 0.0753487410723 ## Tetraploid with 8 clones - OBJ: 7.076072 - score: -0.219100018522 # The chosen diploid solution has 5 clones with OBJ: 9.744628 and score: 0.186776250313 ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn # The chosen tetraploid solution has 3 clones with OBJ: 23.135209 and score: 0.169099207187 ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn # The chosen solution is tetraploid with 3 clones and is written in ./best.bbc.ucn and ./best.seg.ucn HATCHet predicts the presence of 3 clones in the 3 tumor samples and, especially, predicts that 2 samples contains two distinct tumor clones, according to the true clonal composition. ## Analyzing inferred results Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. We run `plot-cn` as follows ```shell ${PLOTCN} best.bbc.ucn exit $? ``` First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: ### SAMPLE: bulk_08clone1_Noneclone0_02normal -- PURITY: 0.799477 -- PLOIDY: 3.07107541299 -- CLASSIFICATION: TETRAPLOID ### SAMPLE: bulk_035clone1_06clone0_005normal -- PURITY: 0.95065 -- PLOIDY: 3.37447061915 -- CLASSIFICATION: TETRAPLOID ### SAMPLE: bulk_055clone1_04clone0_005normal -- PURITY: 0.95048 -- PLOIDY: 3.27575289096 -- CLASSIFICATION: TETRAPLOID Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly interesting. The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). ![intratumor-clones-totalcn.pdf](totalcn.png) Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. ![intratumor-clones-allelecn.pdf](allelecn.png) The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. ![intratumor-clones-allelecn.pdf](profiles.png) The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. ","Shell" "Allele","raphael-group/hatchet","examples/demo-complete/demo-complete.md",".md","6003","146","# Demo complete for the entire HATCHet pipeline : ex: set ft=markdown ;:<<'```shell' # The following HATCHet demo represents a guided example of the complete HATCHet pipeline starting from an exemplary dataset of tumour and matched normal [BAM files](https://doi.org/10.5281/zenodo.4046906) publicly available. From this directory, simply run this file through BASH as a standard script to run the complete demo. The demo can also be considered as a guided example of a complete execution and is correspondingly commented. ## Requirements and set up The demo requires that HATCHet has been succesfully installed in the current python environment. Please make sure that you can succesfully run the required dependencies `samtools`, `bcftools`, `tabix`, and `mosdepth`. The demo includes the downloading of all the required files and will terminate in <20 minutes on machine with minimum requirements satisfied. We guarantee that the running directory in the same directory of the demo and we remove previous results. ```shell cd $( cd ""$(dirname ""$0"")"" >/dev/null 2>&1 ; pwd -P ) rm -rf rdr/ baf/ snps/ bb/ bbc/ plots/ results/ summary/ :<<'```shell' # Ignore this line ``` We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands ```shell set -e set -o xtrace PS4='[\t]' :<<'```shell' # Ignore this line ``` ## Downloading of data The demo automatically downloads the required tumor and matched-normal BAM files in `data` folder. ```shell # Creating data folder mkdir -p data # Downloading matched-normal BAM file echo ""Downloading matched-normal BAM file from Zenodo, please be patient as downloading time may vary."" curl -L 'https://zenodo.org/record/4046906/files/normal.bam?download=1' > data/normal.bam curl -L 'https://zenodo.org/record/4046906/files/normal.bam.bai?download=1' > data/normal.bam.bai # Downloading BAM file of tumor sample 1 echo ""Downloading BAM file of tumor sample 1 from Zenodo, please be patient as downloading time may vary."" curl -L 'https://zenodo.org/record/4046906/files/bulk_03clone1_06clone0_01normal.sorted.bam?download=1' > data/bulk_03clone1_06clone0_01normal.sorted.bam curl -L 'https://zenodo.org/record/4046906/files/bulk_03clone1_06clone0_01normal.sorted.bam.bai?download=1' > data/bulk_03clone1_06clone0_01normal.sorted.bam.bai # Downloading BAM file of tumor sample 2 echo ""Downloading BAM file of tumor sample 2 from Zenodo, please be patient as downloading time may vary."" curl -L 'https://zenodo.org/record/4046906/files/bulk_08clone1_Noneclone0_02normal.sorted.bam?download=1' > data/bulk_08clone1_Noneclone0_02normal.sorted.bam curl -L 'https://zenodo.org/record/4046906/files/bulk_08clone1_Noneclone0_02normal.sorted.bam.bai?download=1' > data/bulk_08clone1_Noneclone0_02normal.sorted.bam.bai # Downloading BAM file of tumor sample 3 echo ""Downloading BAM file of tumor sample 3 from Zenodo, please be patient as downloading time may vary."" curl -L 'https://zenodo.org/record/4046906/files/bulk_Noneclone1_09clone0_01normal.sorted.bam?download=1' > data/bulk_Noneclone1_09clone0_01normal.sorted.bam curl -L 'https://zenodo.org/record/4046906/files/bulk_Noneclone1_09clone0_01normal.sorted.bam.bai?download=1' > data/bulk_Noneclone1_09clone0_01normal.sorted.bam.bai :<<'```shell' # Ignore this line ``` Next the corresponding reference genome is downloaded and unpacked ```shell echo ""Downloading human reference genome, please be patient as downloading time may vary."" curl -L https://hgdownload.soe.ucsc.edu/goldenPath/hg19/bigZips/hg19.fa.gz | gzip -d > data/hg19.fa samtools faidx data/hg19.fa samtools dict data/hg19.fa > data/hg19.dict :<<'```shell' # Ignore this line ``` ## Configuring the HATCHet's execution We follow the template of the HATCHet's [script](../../doc/doc_fullpipeline.md#fullpipelineandtutorial). 1. We specify the correct path to the reference genome and the output folder, and other required flags ```shell echo '[run]' > hatchet.ini echo 'genotype_snps=True' >> hatchet.ini echo 'count_alleles=True' >> hatchet.ini echo 'count_reads=True' >> hatchet.ini echo 'combine_counts=True' >> hatchet.ini echo 'cluster_bins=True' >> hatchet.ini echo 'plot_bins=True' >> hatchet.ini echo 'compute_cn=True' >> hatchet.ini echo 'plot_cn=True' >> hatchet.ini echo 'reference=data/hg19.fa' >> hatchet.ini echo 'output=output/' >> hatchet.ini j=$(grep -c ^processor /proc/cpuinfo) processes=""processes=${j}"" echo $processes >> hatchet.ini echo 'chromosomes=""chr22""' >> hatchet.ini :<<'```shell' # Ignore this line ``` 2. We specify the path to the matched-normal BAM files ```shell echo 'normal=data/normal.bam' >> hatchet.ini :<<'```shell' # Ignore this line ``` 3. We specify the list of paths to the tumor BAM files and corresponding names ```shell echo 'bams=data/bulk_03clone1_06clone0_01normal.sorted.bam data/bulk_08clone1_Noneclone0_02normal.sorted.bam data/bulk_Noneclone1_09clone0_01normal.sorted.bam' >> hatchet.ini echo 'samples=TumorSample1 TumorSample2 TumorSample3' >> hatchet.ini :<<'```shell' # Ignore this line ``` 4. We specify the min/max coverage for the genotpe_snps step ```shell echo '[genotype_snps]' >> hatchet.ini echo 'mincov=8' >> hatchet.ini echo 'maxcov=300' >> hatchet.ini :<<'```shell' # Ignore this line ``` 5. We specify the reference genome and chr notation ```shell echo 'reference_version=hg19' >> hatchet.ini echo 'chr_notation=True' >> hatchet.ini :<<'```shell' # Ignore this line ``` 6. We specify mincov/maxcov for the count_alleles step ```shell echo '[count_alleles]' >> hatchet.ini echo 'mincov=8' >> hatchet.ini echo 'maxcov=300' >> hatchet.ini :<<'```shell' # Ignore this line ``` 7. We specify the minimum number of total and SNP-covering reads in each bin for the combine_counts step ```shell echo '[combine_counts]' >> hatchet.ini echo 'msr=3000' >> hatchet.ini echo 'mtr=5000' >> hatchet.ini :<<'```shell' # Ignore this line ``` ## Running HATCHet ```shell python -m hatchet run hatchet.ini exit $? ``` ","Markdown" "Allele","raphael-group/hatchet","examples/demo-complete/demo-complete.sh",".sh","6003","146","# Demo complete for the entire HATCHet pipeline : ex: set ft=markdown ;:<<'```shell' # The following HATCHet demo represents a guided example of the complete HATCHet pipeline starting from an exemplary dataset of tumour and matched normal [BAM files](https://doi.org/10.5281/zenodo.4046906) publicly available. From this directory, simply run this file through BASH as a standard script to run the complete demo. The demo can also be considered as a guided example of a complete execution and is correspondingly commented. ## Requirements and set up The demo requires that HATCHet has been succesfully installed in the current python environment. Please make sure that you can succesfully run the required dependencies `samtools`, `bcftools`, `tabix`, and `mosdepth`. The demo includes the downloading of all the required files and will terminate in <20 minutes on machine with minimum requirements satisfied. We guarantee that the running directory in the same directory of the demo and we remove previous results. ```shell cd $( cd ""$(dirname ""$0"")"" >/dev/null 2>&1 ; pwd -P ) rm -rf rdr/ baf/ snps/ bb/ bbc/ plots/ results/ summary/ :<<'```shell' # Ignore this line ``` We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands ```shell set -e set -o xtrace PS4='[\t]' :<<'```shell' # Ignore this line ``` ## Downloading of data The demo automatically downloads the required tumor and matched-normal BAM files in `data` folder. ```shell # Creating data folder mkdir -p data # Downloading matched-normal BAM file echo ""Downloading matched-normal BAM file from Zenodo, please be patient as downloading time may vary."" curl -L 'https://zenodo.org/record/4046906/files/normal.bam?download=1' > data/normal.bam curl -L 'https://zenodo.org/record/4046906/files/normal.bam.bai?download=1' > data/normal.bam.bai # Downloading BAM file of tumor sample 1 echo ""Downloading BAM file of tumor sample 1 from Zenodo, please be patient as downloading time may vary."" curl -L 'https://zenodo.org/record/4046906/files/bulk_03clone1_06clone0_01normal.sorted.bam?download=1' > data/bulk_03clone1_06clone0_01normal.sorted.bam curl -L 'https://zenodo.org/record/4046906/files/bulk_03clone1_06clone0_01normal.sorted.bam.bai?download=1' > data/bulk_03clone1_06clone0_01normal.sorted.bam.bai # Downloading BAM file of tumor sample 2 echo ""Downloading BAM file of tumor sample 2 from Zenodo, please be patient as downloading time may vary."" curl -L 'https://zenodo.org/record/4046906/files/bulk_08clone1_Noneclone0_02normal.sorted.bam?download=1' > data/bulk_08clone1_Noneclone0_02normal.sorted.bam curl -L 'https://zenodo.org/record/4046906/files/bulk_08clone1_Noneclone0_02normal.sorted.bam.bai?download=1' > data/bulk_08clone1_Noneclone0_02normal.sorted.bam.bai # Downloading BAM file of tumor sample 3 echo ""Downloading BAM file of tumor sample 3 from Zenodo, please be patient as downloading time may vary."" curl -L 'https://zenodo.org/record/4046906/files/bulk_Noneclone1_09clone0_01normal.sorted.bam?download=1' > data/bulk_Noneclone1_09clone0_01normal.sorted.bam curl -L 'https://zenodo.org/record/4046906/files/bulk_Noneclone1_09clone0_01normal.sorted.bam.bai?download=1' > data/bulk_Noneclone1_09clone0_01normal.sorted.bam.bai :<<'```shell' # Ignore this line ``` Next the corresponding reference genome is downloaded and unpacked ```shell echo ""Downloading human reference genome, please be patient as downloading time may vary."" curl -L https://hgdownload.soe.ucsc.edu/goldenPath/hg19/bigZips/hg19.fa.gz | gzip -d > data/hg19.fa samtools faidx data/hg19.fa samtools dict data/hg19.fa > data/hg19.dict :<<'```shell' # Ignore this line ``` ## Configuring the HATCHet's execution We follow the template of the HATCHet's [script](../../doc/doc_fullpipeline.md#fullpipelineandtutorial). 1. We specify the correct path to the reference genome and the output folder, and other required flags ```shell echo '[run]' > hatchet.ini echo 'genotype_snps=True' >> hatchet.ini echo 'count_alleles=True' >> hatchet.ini echo 'count_reads=True' >> hatchet.ini echo 'combine_counts=True' >> hatchet.ini echo 'cluster_bins=True' >> hatchet.ini echo 'plot_bins=True' >> hatchet.ini echo 'compute_cn=True' >> hatchet.ini echo 'plot_cn=True' >> hatchet.ini echo 'reference=data/hg19.fa' >> hatchet.ini echo 'output=output/' >> hatchet.ini j=$(grep -c ^processor /proc/cpuinfo) processes=""processes=${j}"" echo $processes >> hatchet.ini echo 'chromosomes=""chr22""' >> hatchet.ini :<<'```shell' # Ignore this line ``` 2. We specify the path to the matched-normal BAM files ```shell echo 'normal=data/normal.bam' >> hatchet.ini :<<'```shell' # Ignore this line ``` 3. We specify the list of paths to the tumor BAM files and corresponding names ```shell echo 'bams=data/bulk_03clone1_06clone0_01normal.sorted.bam data/bulk_08clone1_Noneclone0_02normal.sorted.bam data/bulk_Noneclone1_09clone0_01normal.sorted.bam' >> hatchet.ini echo 'samples=TumorSample1 TumorSample2 TumorSample3' >> hatchet.ini :<<'```shell' # Ignore this line ``` 4. We specify the min/max coverage for the genotpe_snps step ```shell echo '[genotype_snps]' >> hatchet.ini echo 'mincov=8' >> hatchet.ini echo 'maxcov=300' >> hatchet.ini :<<'```shell' # Ignore this line ``` 5. We specify the reference genome and chr notation ```shell echo 'reference_version=hg19' >> hatchet.ini echo 'chr_notation=True' >> hatchet.ini :<<'```shell' # Ignore this line ``` 6. We specify mincov/maxcov for the count_alleles step ```shell echo '[count_alleles]' >> hatchet.ini echo 'mincov=8' >> hatchet.ini echo 'maxcov=300' >> hatchet.ini :<<'```shell' # Ignore this line ``` 7. We specify the minimum number of total and SNP-covering reads in each bin for the combine_counts step ```shell echo '[combine_counts]' >> hatchet.ini echo 'msr=3000' >> hatchet.ini echo 'mtr=5000' >> hatchet.ini :<<'```shell' # Ignore this line ``` ## Running HATCHet ```shell python -m hatchet run hatchet.ini exit $? ``` ","Shell" "Allele","raphael-group/hatchet","examples/demo-WGS-cancer/demo-wgs-cancer.md",".md","14175","172","# Demo for WGS data from a cancer patient : ex: set ft=markdown ;:<<'```shell' # **NOTE**: this demo has not yet been updated for version 1.0 of HATCHet which includes variable-width binning, phasing, and locality-aware clustering. The following HATCHet's demo represents a guided example starting from WGS (whole-genome sequencing) data from 3 samples (A12-A, A12-C, and A12-D) of metastatic patient A12, previously published in (Gundem et al., Nature, 2015)). For simplicity, the demo starts from a BB file `demo-wgs-cancer.bb` (included in this demo at `examples/demo-WGS-cancer/`) which contains the RDR and BAF of every genomic bin and, therefore, we assume that the preliminary steps (i.e. `count-reads`, `count-alleles`, and `combine-counts`) have already been executed by running standard configuration for WGS data (bin size of 50kb through -b 50kb of count-reads, and the allele counts for germline heterozygous SNPs have been selected between 3 and 200 through `-c 3 -C 200`). ## Requirements and set up The demo requires that HATCHet has been successfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: ```shell PY=""python3"" # This id the full path to the version of PYTHON3 which contains the required `hatchet` module. When this corresponds to the standard version, the user can keep the given value of `python3` :<<'```shell' # Ignore this line ``` The following paths are consequently obtained to point to the required components of HATCHet ```shell CLUSTERBINS=""${PY} -m hatchet cluster-bins"" PLOTBINS=""${PY} -m hatchet plot-bins"" INFER=""${PY} -m hatchet compute-cn"" PLOTCN=""${PY} -m hatchet plot-cn"" :<<'```shell' # Ignore this line ``` We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands ```shell set -e set -o xtrace PS4='[\t]' :<<'```shell' # Ignore this line ``` ## Global clustering The first main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: ```shell ${CLUSTERBINS} demo-wgs-cancer.bb -o demo-wgs-cancer.seg -O demo-wgs-cancer.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 :<<'```shell' # Ignore this line ``` For different type of data it is essential to assess the quality of the clustering because this is performed by a Dirichlet process and it is affected by varying degrees of noise. To do this, we use `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data, and produce the cluster plot using the `CBB` command. To help we use the following options: - `--xmin 0.5` and `--xmax 4` allow to zoom in and to focus the figure on the same RDR (x-axis) range for every sample. - `--colwrap 3` allows to have the 3 plots of the 3 samples on the same figure row - `-tS 0.005` asks to plot only the clusters which cover at least the `0.5%` of the genome. This is useful to clean the figure and focus on the main components. To trace all steps, we also move the figure to `tR015-cbb.pdf`. ```shell ${PLOTBINS} -c CBB demo-wgs-cancer.bbc --ymin 0.5 --ymax 4 --colwrap 3 -tS 0.005 mv bb_clustered.png tR015-cbb.png :<<'```shell' # Ignore this line ``` We thus obtain the following clustering: ![Bad clustering with default values](tR015-cbb.png) We can easily notice that the clustering is not ideal and is clearly overfitting the data by choosing too many distinct clusters; in fact we notice the presence of many different clusters that are extremely close and have identical BAF in every sample, e.g. light blue/dark blue/light orange/dark grey clusters or orange/purple clusters or pink/light gray clusters are always adjacent clusters which appear to be part of wider cluster. A good condition to assess the quality of the clustering is to assess that every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. Since Dirichlet clustering is not ad-hoc for this application, it can often result in overclustering. For this reason, cluster-bins additionally provides a procedure to merge clusters which are very likely to be part of a single cluster. However this procedure requires two maximum thresholds for doing this, one is the maximum shift for RDR (`-tR 0.15`) and one is the maximum shift for BAF (`-tB 0.03`). The default values allow to work with most of the datasets, however datasets of high variance require to tune these parameters. In our example, while the BAF of the clusters appears to be consistent with the default threshold, RDR appears to have much higher variance; in fact, the clusters that are always adjacent span much more than 0.15 of RDR in the x-axis. Therefore, by looking at the plot, we can see that a value of `-tR 0.5` fit much better the noise of RDR in our data and we repeat the clustering with this value. ```shell ${CLUSTERBINS} demo-wgs-cancer.bb -o demo-wgs-cancer.seg -O demo-wgs-cancer.bbc -e 12 -tB 0.03 -tR 0.5 -d 0.08 :<<'```shell' # Ignore this line ``` We assess again the clustering using `plot-bins` as before. ```shell ${PLOTBINS} -c CBB demo-wgs-cancer.bbc --ymin 0.5 --ymax 4 --colwrap 3 -tS 0.008 mv bb_clustered.png cbb.png :<<'```shell' # Ignore this line ``` We thus obtain the following clustering: ![Better clustering with default values](tR05-cbb.png) In this clustering the previously-described condition is met and all the different clusters are clearly distinct in at least one sample. ## hatchet's step In the last step we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. We apply the last step with default parameters and, for simplicity of this demo, we apply only few changes: - As the dataset has high variance and noise (see clustering), we consider a minimum clone proportion `-u` slightly higher than the default value, i.e. `10%`. We do this because we cannot infer tumor clones with very low proportions when there is high noise and because potential clones inferred with very low proportions may simply be the result of overfitting. In fact, when using values of `-u` smaller than `10%` we obtain solutions with clone proporions identical to the minimum value of `-u`; this is the recommended criterion to determine the need of increasing the value of `-u`. - We limit the number of clones to 6 for simplicity of this demo and because it is a reasonable value for CNAs when consider only few samples from the same patient. - We only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. ```shell ${INFER} -i demo-wgs-cancer -n2,6 -p 100 -v 2 -u 0.1 -r 12 -eD 6 -eT 12 -l 0.5 |& tee hatchet.log :<<'```shell' # Ignore this line ``` We obtain the following summary of results: ## Scores approximating second derivative for diploid results ## Diploid with 2 clones - OBJ: 32.903145 - score: -0.320298393968 ## Diploid with 3 clones - OBJ: 12.493377 - score: 0.0653576290862 ## Diploid with 4 clones - OBJ: 7.063226 - score: 0.216430182885 ## Diploid with 5 clones - OBJ: 5.521944 - score: 0.0291809338181 ## Diploid with 6 clones - OBJ: 4.478124 - score: -0.11096874579 ## Scores approximating second derivative for tetraploid results ## Tetraploid with 2 clones - OBJ: 50.187684 - score: -0.351848788241 ## Tetraploid with 3 clones - OBJ: 17.472903 - score: 0.0803178784888 ## Tetraploid with 4 clones - OBJ: 10.139838 - score: 0.162808688228 ## Tetraploid with 5 clones - OBJ: 7.535183 - score: 0.0254150864857 ## Tetraploid with 6 clones - OBJ: 5.791102 - score: -0.0685416532021 # The chosen diploid solution has 4 clones with OBJ: 7.063226 and score: 0.216430182885 ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn # The chosen tetraploid solution has 4 clones with OBJ: 10.139838 and score: 0.162808688228 ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn # The chosen solution is diploid with 4 clones and is written in ./best.bbc.ucn and ./best.seg.ucn HATCHet predicts the presence of 4 clones in the 3 tumor samples and, especially, predicts that 2 samples (A12-C and A12-D) contains two distinct tumor clones. While HATCHet accurately recovers the major tumor clones distinguished by larger CNAs, HATCHet may miss small or minor CNAs, especially CNAs that are only present in a unique sample or in low proportions. Investigating the presence of unique or low proporions clones is particularly interesting in this patient because the high noise and variance make more difficult distinguishing variations in the clusters between those due to either noise or presence of different clones. To investigate the presence of minor or low-proportions clones, we re-run the `hatchet` step by increasing the sensitivity of HATCHet; we do this by decreasing the value of the limit `-l` from the default of `0.5` to `0.2`. Remember that the value that control the sensivity `-l` must be in `[0, 1]` and the default value is `0.5`; in particular, lower values incrase the sensitivty of HATCHet by exploring solutions with more clones and the presence of small CNAs, whereas higher values decrease the sensitivity. We thus re-run the `hatchet` step as follows: ```shell ${INFER} -i demo-wgs-cancer -n2,6 -p 100 -v 2 -u 0.1 -r 12 -eD 6 -eT 12 -l 0.2 |& tee hatchet.log :<<'```shell' # Ignore this line ``` We obtain the following summary of results. ## Scores approximating second derivative for diploid results ## Diploid with 2 clones - OBJ: 32.903145 - score: -0.420298393968 ## Diploid with 3 clones - OBJ: 12.493377 - score: -0.234642370914 ## Diploid with 4 clones - OBJ: 7.063226 - score: -0.0182121880285 ## Diploid with 5 clones - OBJ: 5.521944 - score: 0.0109687457895 ## Diploid with 6 clones - OBJ: 4.478124 - score: -0.11096874579 ## Scores approximating second derivative for tetraploid results ## Tetraploid with 2 clones - OBJ: 50.187684 - score: -0.451848788241 ## Tetraploid with 3 clones - OBJ: 17.472903 - score: -0.219682121511 ## Tetraploid with 4 clones - OBJ: 10.139838 - score: -0.0568734332836 ## Tetraploid with 5 clones - OBJ: 7.535183 - score: -0.0314583467979 ## Tetraploid with 6 clones - OBJ: 5.791102 - score: -0.1 # The chosen diploid solution has 5 clones with OBJ: 5.521944 and score: 0.0109687457895 ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn # The chosen tetraploid solution has 5 clones with OBJ: 7.535183 and score: -0.0314583467979 ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn # The chosen solution is diploid with 5 clones and is written in ./best.bbc.ucn and ./best.seg.ucn HATCHet indeed finds an additional tumor clone which is unique to sample A12-D and has some small and specific CNAs which are only present in this sample. This conclude the inference and the final results containing clone and allele-specific copy numbers are available for every bin in `best.bbc.ucn` and for segments in a compact format in `best.seg.ucn`. ## Analyzing inferred results Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. We run `plot-cn` as follows ```shell ${PLOTCN} best.bbc.ucn exit $? ``` First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: ### SAMPLE: A12-D -- PURITY: 0.820847 -- PLOIDY: 2.13676481963 -- CLASSIFICATION: DIPLOID ### SAMPLE: A12-C -- PURITY: 0.771882 -- PLOIDY: 2.07266027371 -- CLASSIFICATION: DIPLOID ### SAMPLE: A12-A -- PURITY: 0.779084 -- PLOIDY: 2.09771617784 -- CLASSIFICATION: DIPLOID Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly important. The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). ![intratumor-clones-totalcn.pdf](totalcn.png) Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. ![intratumor-clones-allelecn.pdf](allelecn.png) The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. ![intratumor-clones-allelecn.pdf](profiles.png) The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. ","Markdown" "Allele","raphael-group/hatchet","examples/demo-WGS-cancer/demo-wgs-cancer.sh",".sh","14175","172","# Demo for WGS data from a cancer patient : ex: set ft=markdown ;:<<'```shell' # **NOTE**: this demo has not yet been updated for version 1.0 of HATCHet which includes variable-width binning, phasing, and locality-aware clustering. The following HATCHet's demo represents a guided example starting from WGS (whole-genome sequencing) data from 3 samples (A12-A, A12-C, and A12-D) of metastatic patient A12, previously published in (Gundem et al., Nature, 2015)). For simplicity, the demo starts from a BB file `demo-wgs-cancer.bb` (included in this demo at `examples/demo-WGS-cancer/`) which contains the RDR and BAF of every genomic bin and, therefore, we assume that the preliminary steps (i.e. `count-reads`, `count-alleles`, and `combine-counts`) have already been executed by running standard configuration for WGS data (bin size of 50kb through -b 50kb of count-reads, and the allele counts for germline heterozygous SNPs have been selected between 3 and 200 through `-c 3 -C 200`). ## Requirements and set up The demo requires that HATCHet has been successfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: ```shell PY=""python3"" # This id the full path to the version of PYTHON3 which contains the required `hatchet` module. When this corresponds to the standard version, the user can keep the given value of `python3` :<<'```shell' # Ignore this line ``` The following paths are consequently obtained to point to the required components of HATCHet ```shell CLUSTERBINS=""${PY} -m hatchet cluster-bins"" PLOTBINS=""${PY} -m hatchet plot-bins"" INFER=""${PY} -m hatchet compute-cn"" PLOTCN=""${PY} -m hatchet plot-cn"" :<<'```shell' # Ignore this line ``` We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands ```shell set -e set -o xtrace PS4='[\t]' :<<'```shell' # Ignore this line ``` ## Global clustering The first main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: ```shell ${CLUSTERBINS} demo-wgs-cancer.bb -o demo-wgs-cancer.seg -O demo-wgs-cancer.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 :<<'```shell' # Ignore this line ``` For different type of data it is essential to assess the quality of the clustering because this is performed by a Dirichlet process and it is affected by varying degrees of noise. To do this, we use `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data, and produce the cluster plot using the `CBB` command. To help we use the following options: - `--xmin 0.5` and `--xmax 4` allow to zoom in and to focus the figure on the same RDR (x-axis) range for every sample. - `--colwrap 3` allows to have the 3 plots of the 3 samples on the same figure row - `-tS 0.005` asks to plot only the clusters which cover at least the `0.5%` of the genome. This is useful to clean the figure and focus on the main components. To trace all steps, we also move the figure to `tR015-cbb.pdf`. ```shell ${PLOTBINS} -c CBB demo-wgs-cancer.bbc --ymin 0.5 --ymax 4 --colwrap 3 -tS 0.005 mv bb_clustered.png tR015-cbb.png :<<'```shell' # Ignore this line ``` We thus obtain the following clustering: ![Bad clustering with default values](tR015-cbb.png) We can easily notice that the clustering is not ideal and is clearly overfitting the data by choosing too many distinct clusters; in fact we notice the presence of many different clusters that are extremely close and have identical BAF in every sample, e.g. light blue/dark blue/light orange/dark grey clusters or orange/purple clusters or pink/light gray clusters are always adjacent clusters which appear to be part of wider cluster. A good condition to assess the quality of the clustering is to assess that every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. Since Dirichlet clustering is not ad-hoc for this application, it can often result in overclustering. For this reason, cluster-bins additionally provides a procedure to merge clusters which are very likely to be part of a single cluster. However this procedure requires two maximum thresholds for doing this, one is the maximum shift for RDR (`-tR 0.15`) and one is the maximum shift for BAF (`-tB 0.03`). The default values allow to work with most of the datasets, however datasets of high variance require to tune these parameters. In our example, while the BAF of the clusters appears to be consistent with the default threshold, RDR appears to have much higher variance; in fact, the clusters that are always adjacent span much more than 0.15 of RDR in the x-axis. Therefore, by looking at the plot, we can see that a value of `-tR 0.5` fit much better the noise of RDR in our data and we repeat the clustering with this value. ```shell ${CLUSTERBINS} demo-wgs-cancer.bb -o demo-wgs-cancer.seg -O demo-wgs-cancer.bbc -e 12 -tB 0.03 -tR 0.5 -d 0.08 :<<'```shell' # Ignore this line ``` We assess again the clustering using `plot-bins` as before. ```shell ${PLOTBINS} -c CBB demo-wgs-cancer.bbc --ymin 0.5 --ymax 4 --colwrap 3 -tS 0.008 mv bb_clustered.png cbb.png :<<'```shell' # Ignore this line ``` We thus obtain the following clustering: ![Better clustering with default values](tR05-cbb.png) In this clustering the previously-described condition is met and all the different clusters are clearly distinct in at least one sample. ## hatchet's step In the last step we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. We apply the last step with default parameters and, for simplicity of this demo, we apply only few changes: - As the dataset has high variance and noise (see clustering), we consider a minimum clone proportion `-u` slightly higher than the default value, i.e. `10%`. We do this because we cannot infer tumor clones with very low proportions when there is high noise and because potential clones inferred with very low proportions may simply be the result of overfitting. In fact, when using values of `-u` smaller than `10%` we obtain solutions with clone proporions identical to the minimum value of `-u`; this is the recommended criterion to determine the need of increasing the value of `-u`. - We limit the number of clones to 6 for simplicity of this demo and because it is a reasonable value for CNAs when consider only few samples from the same patient. - We only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. ```shell ${INFER} -i demo-wgs-cancer -n2,6 -p 100 -v 2 -u 0.1 -r 12 -eD 6 -eT 12 -l 0.5 |& tee hatchet.log :<<'```shell' # Ignore this line ``` We obtain the following summary of results: ## Scores approximating second derivative for diploid results ## Diploid with 2 clones - OBJ: 32.903145 - score: -0.320298393968 ## Diploid with 3 clones - OBJ: 12.493377 - score: 0.0653576290862 ## Diploid with 4 clones - OBJ: 7.063226 - score: 0.216430182885 ## Diploid with 5 clones - OBJ: 5.521944 - score: 0.0291809338181 ## Diploid with 6 clones - OBJ: 4.478124 - score: -0.11096874579 ## Scores approximating second derivative for tetraploid results ## Tetraploid with 2 clones - OBJ: 50.187684 - score: -0.351848788241 ## Tetraploid with 3 clones - OBJ: 17.472903 - score: 0.0803178784888 ## Tetraploid with 4 clones - OBJ: 10.139838 - score: 0.162808688228 ## Tetraploid with 5 clones - OBJ: 7.535183 - score: 0.0254150864857 ## Tetraploid with 6 clones - OBJ: 5.791102 - score: -0.0685416532021 # The chosen diploid solution has 4 clones with OBJ: 7.063226 and score: 0.216430182885 ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn # The chosen tetraploid solution has 4 clones with OBJ: 10.139838 and score: 0.162808688228 ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn # The chosen solution is diploid with 4 clones and is written in ./best.bbc.ucn and ./best.seg.ucn HATCHet predicts the presence of 4 clones in the 3 tumor samples and, especially, predicts that 2 samples (A12-C and A12-D) contains two distinct tumor clones. While HATCHet accurately recovers the major tumor clones distinguished by larger CNAs, HATCHet may miss small or minor CNAs, especially CNAs that are only present in a unique sample or in low proportions. Investigating the presence of unique or low proporions clones is particularly interesting in this patient because the high noise and variance make more difficult distinguishing variations in the clusters between those due to either noise or presence of different clones. To investigate the presence of minor or low-proportions clones, we re-run the `hatchet` step by increasing the sensitivity of HATCHet; we do this by decreasing the value of the limit `-l` from the default of `0.5` to `0.2`. Remember that the value that control the sensivity `-l` must be in `[0, 1]` and the default value is `0.5`; in particular, lower values incrase the sensitivty of HATCHet by exploring solutions with more clones and the presence of small CNAs, whereas higher values decrease the sensitivity. We thus re-run the `hatchet` step as follows: ```shell ${INFER} -i demo-wgs-cancer -n2,6 -p 100 -v 2 -u 0.1 -r 12 -eD 6 -eT 12 -l 0.2 |& tee hatchet.log :<<'```shell' # Ignore this line ``` We obtain the following summary of results. ## Scores approximating second derivative for diploid results ## Diploid with 2 clones - OBJ: 32.903145 - score: -0.420298393968 ## Diploid with 3 clones - OBJ: 12.493377 - score: -0.234642370914 ## Diploid with 4 clones - OBJ: 7.063226 - score: -0.0182121880285 ## Diploid with 5 clones - OBJ: 5.521944 - score: 0.0109687457895 ## Diploid with 6 clones - OBJ: 4.478124 - score: -0.11096874579 ## Scores approximating second derivative for tetraploid results ## Tetraploid with 2 clones - OBJ: 50.187684 - score: -0.451848788241 ## Tetraploid with 3 clones - OBJ: 17.472903 - score: -0.219682121511 ## Tetraploid with 4 clones - OBJ: 10.139838 - score: -0.0568734332836 ## Tetraploid with 5 clones - OBJ: 7.535183 - score: -0.0314583467979 ## Tetraploid with 6 clones - OBJ: 5.791102 - score: -0.1 # The chosen diploid solution has 5 clones with OBJ: 5.521944 and score: 0.0109687457895 ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn # The chosen tetraploid solution has 5 clones with OBJ: 7.535183 and score: -0.0314583467979 ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn # The chosen solution is diploid with 5 clones and is written in ./best.bbc.ucn and ./best.seg.ucn HATCHet indeed finds an additional tumor clone which is unique to sample A12-D and has some small and specific CNAs which are only present in this sample. This conclude the inference and the final results containing clone and allele-specific copy numbers are available for every bin in `best.bbc.ucn` and for segments in a compact format in `best.seg.ucn`. ## Analyzing inferred results Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. We run `plot-cn` as follows ```shell ${PLOTCN} best.bbc.ucn exit $? ``` First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: ### SAMPLE: A12-D -- PURITY: 0.820847 -- PLOIDY: 2.13676481963 -- CLASSIFICATION: DIPLOID ### SAMPLE: A12-C -- PURITY: 0.771882 -- PLOIDY: 2.07266027371 -- CLASSIFICATION: DIPLOID ### SAMPLE: A12-A -- PURITY: 0.779084 -- PLOIDY: 2.09771617784 -- CLASSIFICATION: DIPLOID Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly important. The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). ![intratumor-clones-totalcn.pdf](totalcn.png) Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. ![intratumor-clones-allelecn.pdf](allelecn.png) The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. ![intratumor-clones-allelecn.pdf](profiles.png) The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. ","Shell" "Allele","raphael-group/hatchet","docs/buildDocs.sh",".sh","1230","47","#!/bin/bash # Adapted from: # https://tech.michaelaltfield.net/2020/07/18/sphinx-rtd-github-pages-1/ set -x pwd ls -lah export SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct) ####################### # Update GitHub Pages # ####################### git config --global user.name ""${GITHUB_ACTOR}"" git config --global user.email ""${GITHUB_ACTOR}@users.noreply.github.com"" docroot=`mktemp -d` rsync -av ""docs/build/html/"" ""${docroot}/"" pushd ""${docroot}"" # don't bother maintaining history; just generate fresh git init git remote add deploy ""https://token:${GITHUB_TOKEN}@github.com/${GITHUB_REPOSITORY}.git"" git checkout -b gh-pages # Add README cat > README.md <= 4.8.1, or Clang). As long as you have a recent version of GCC or Clang installed, `setuptools` should automatically be able to download a recent version of `cmake` and compile the Hatchet code into a working package. The installation process can be broken down into the following steps: 1. **Get [Gurobi](http://www.gurobi.com/)** (v9.0.2) The coordinate-method applied by HATCHet is based on several integer linear programming (ILP) formulations. Gurobi is a commercial ILP solver with two licensing options: (1) a single-host license where the license is tied to a single computer and (2) a network license for use in a compute cluster (using a license server in the cluster). Both options are freely and [easily available](http://www.gurobi.com/academia/academia-center) for users in academia. [Download](https://www.gurobi.com/downloads/gurobi-optimizer-eula) Gurobi for your specific platform. 2. **Set GUROBI_HOME environment variable** ```shell $ export GUROBI_HOME=/path/to/gurobi902 ``` Set `GUROBI_HOME` to where you download Gurobi. Here `XXX` is the 3-digit version of gurobi. 3. **Build Gurobi** ```shell $ cd ""${GUROBI_HOME}"" $ cd linux64/src/build/ $ make $ cp libgurobi_c++.a ../../lib ``` Substitute `mac64` for `linux64` if using the Mac OSX platform. 4. **Create a new venv/conda environment for Hatchet** `Hatchet` is a Python 3 package. Unless you want to compile/install it in your default Python 3 environment, you will want to create either a new Conda environment for Python 3 and activate it: ``` conda create --name hatchet python=3.8 conda activate hatchet ``` or use `virtualenv` through `pip`: ``` python3 -m pip virtualenv env source env/bin/activate ``` 5. **Install basic packages** It is **highly recommended** that you upgrade your `pip` and `setuptools` versions to the latest, using: ```shell pip install -U pip pip install -U setuptools ``` 6. **Build and install HATCHet** Execute the following commands from the root of HATCHet's repository. ```shell $ pip install . ``` **NOTE**: If you experience a failure of compilation with an error message like: ``` _undefined reference to symbol 'pthread_create@@GLIBC_2.2.5'_. ``` you may need to set `CXXFLAGS` to `-pthread` before invoking the command: ```shell $ CXXFLAGS=-pthread pip install . ``` When the compilation process fails or when the environment has special requirements, you may have to manually specify the required paths to Gurobi by following the [detailed intructions](doc_compilation.md). 7. **Install required utilities** For reading BAM files, read counting, allele counting, and SNP calling, you need to install [SAMtools, BCFtools, and tabix](http://www.htslib.org/doc/) as well as [mosdepth](https://github.com/brentp/mosdepth). If you want to perform reference-based phasing, you must also install [shapeit](https://mathgen.stats.ox.ac.uk/genetics_software/shapeit/shapeit.html), [picard](https://broadinstitute.github.io/picard/), and [bgzip](http://www.htslib.org/doc/). The easiest way to install these is via `conda`, as all are available from the `bioconda` channel (except `shapeit` which is available from channel `dranew`). #### Compiling HATCHet *without* the built-in Gurobi optimizer If you wish to use an alternate ILP optimizer, then you do not need a C++ compiler. In this case, set the `HATCHET_BUILD_NOEXT` environment variable to `1` (using `export HATCHET_BUILD_NOEXT=1`), set the environment variable `HATCHET_COMPUTE_CN_SOLVER` to a Pyomo-supported solver (see the [Using a different Pyomo-supported solver](README.html#usingasolver_other) section of the README for more details) and proceed directly to step (4) above. ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_phase_snps.md",".md","3978","46","# phase-snps **Note:** To run this step, you must first run [*download-panel*](doc_download_panel.html) to download the reference-based phasing panel, and specify its location via the argument `-D, --refpaneldir`. The `download-panel` command only needs to be run once per system. This step of HATCHet phases genotypes found in VCF files. It automatically takes care of differences in coordinates if the user has aligned their reads to a version of the reference genome (e.g. hg38) that is different from the version used in the reference panel (e.g. hg19 for the 1000 genomes project), using the liftover utility within Picard. Once genotypes are lifted over and phased, we again perform one last liftover to the coordinates of the genome used for alignment. Liftover is skipped if the version of the reference genome used for alignments corresponds to the same version used in the reference panel. Lastly, in order to account for differences in naming conventions for chromosomes, with or without the ""chr"" prefix, we also add or remove these prefixes so that chromosome names correspond to those used in the reference panel (without ""chr"" for the 1000 genomes project hg19 panel). ## Input `phase-snps` takes one or more VCF files containing heterozygous SNP positions as input, specified using `-L, --snps`. These are typically produced by [`genotype_snps`](doc_genotype_snps.md). The following parameters are required to specify and describe the input data: | Name | Description | Usage | |------|-------------|-------| | `-L`, `--snps` | A list of VCF files to phase, one per chromosome | Specify a list using a path along with a wildcard, e.g. /path/to/snps/*.vcf.gz | | `-D`, `--refpaneldir` | Path to the Reference Panel | This is the location where the 1000 genome project reference panel will be downloaded | | `-g`, `--refgenome` | Path to the reference genome used to align reads | Path should include the filename | | `-V`, `--refversion` | Version of reference genome used to align reads | Specify the human reference genome used for aligning reads; hg19 or hg38 | | `-N`, `--chrnotation` | Chromosome names contain ""chr"" (e.g., ""chr1"" instead of ""1"") | Set this flag if and only if your BAM files/reference genome include ""chr"" in chromosome names | | `-o`, `--outdir` | Output folder for phased VCFs | Specify a path or relative path | ## Output The following files will be placed in the directory indicated by `-o, --outdir`: | Name | Description | |------|-------------| | phased.vcf.gz | VCF file containing phased genotypes for all chromosomes | | phased.log | Table showing how many SNPs were present before and after phasing; SNPs may be lost in the process due to various reasons, e.g. they were not present in the reference panel so there is no information to phase them | | *_alignments.log | Log files from the shapeit phasing program, one per chromosome | ## Main Parameters If HATCHet is installed via `conda`, the dependencies (`shapeit`, `picard`, `bcftools`, and `bgzip`) should be installed automatically and available on the PATH. You can verify that these dependencies are available by running [the check command](doc_check.md), i.e., `hatchet check`. If HATCHet is installed from source, you may need to install them youself (i.e., via `conda` or from source) and/or specify their locations using the following arguments: | Name | Description | Usage | |------|-------------|-------| | `-j`, `--processes` | Number of parallel jobs | Parallel jobs independently phase VCF files, which are split up by chromosome | | `-si`, `--shapeit` | Path to the `shapeit` executable | `shapeit` is required to run this command | | `-pc`, `--picard` | Path to the `picard` executable or JAR file | `picard` is required to run this command | | `-bt`, `--bcftools` | Path to the `bcftools` executable | `bcftools` is required to run this command | | `-bg`, `--bgzip` | Path to the `bgzip` executable | `bgzip` is required to run this command | ","Markdown" "Allele","raphael-group/hatchet","docs/source/recommendation_runtime.md",".md","637","8","# Improve running time This section includes a collection of several tips for improving the overall running time. ## 1. SNP calling from known database HATCHet allows to provide to count-alleles a list of known germline SNPs. This allows to significantly improve the performance. However, running count-alleles without this list (as by default behaviour) results in count-alleles calling germline SNPs along the whole genome and identifying more SNPs (especially including private and rare germline SNPs), which could result in a higher total number of SNPs improving quality of BAF estimations. The user can consider this trade-off. ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_plot_bins_1d2d.md",".md","3194","55","# plot-bins-1d2d This step produces alternate plots that show bins in terms of their computed read-depth ratios (RDR), B-allele frequencies (BAF), and cluster assignments. These plots show bins colored by cluster, where the color is consistent between the ""2D"" (RDR x BAF) view and the ""1D"" (genomic location x RDR/BAF) view. These plots should be used to review the clustering and tune clustering parameters. When `plot_bins = True` is indicated in `hatchet.ini`, both this command and the command [plot-bins](doc_plot_bins.md) will be run. ---------------------- ## Input plot-bins considers two different inputs which are tab-separated files, one is mandatory and the other is optional (required to show cluster centers): 1. A file of clustered genomic bins, specified with the flag `-b, --bbc` and with the following fields. | Field | Description | |-------|-------------| | `CHR` | Name of a chromosome | | `START` | Starting genomic position of a genomic bin in `CHR` | | `END` | Ending genomic position of a genomic bin in `CHR` | | `SAMPLE` | Name of a tumor sample | | `RD` | RDR of the bin in `SAMPLE` | | `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | | `COV` | Average coverage in the bin in `SAMPLE` | | `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | | `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | | `BAF` | BAF of the bin in `SAMPLE` | | `CLUSTER` | The name of the corresponding cluster of the bin in `SAMPLE` | 2. A file of clusters, which is required only by commands and it is specified through the flag `-s`, `--segfile`. The file has the following fields. | Field | Description | |-------|-------------| | `ID` | The name of a cluster | | `SAMPLE` | The name of a sample | | `#BINS` | The number of bins included in `ID` | | `RD` | The RDR of the cluster `ID` in `SAMPLE` | | `#SNPS` | The total number of SNPs in the cluster `ID` | | `COV` | The average coverage in the cluster `ID` | | `ALPHA` | The alpha parameter of the binomial model for the BAF of the cluster `ID` | | `BETA` | The beta parameter of the binomial model for the BAF of the cluster `ID` | | `BAF` | The BAF of the cluster `ID` in `SAMPLE` | ## Parameters | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-O`, `--outdir` | Output directory | Directory in which output plots will be stored | """" (current directory) | | `--baflim` | Axis limits for mirrored BAF | Specify limits as comma-separated values, e.g., '0,0.51' | None (determined by extremes of data) | | `--rdrlim` | Axis limits for read-depth ratio | Specify limits as comma-separated values, e.g., '0,3' | None (determined by extremes of data) | | `--centers` | Show cluster centers | Requires SEG file provided via `-s, --seg`. Enable by including this flag. | False | | `--centromeres` | Mark centromere locations with grey rectangles | Enable by including this flag. | False | | `-a, --alpha` | Opacity value for scatterplots | Valid values are (0, 1]. Smaller values make points more transparent. | 1 | ","Markdown" "Allele","raphael-group/hatchet","docs/source/recommendation_inference.md",".md","18276","127","# Analyze HATCHet's inference The main component of HATCHet ([compute-cn](doc_compute_cn.md) step) performs three major tasks: (1) explicit estimation of fractional copy numbers, (2) inference of allele and clone-specific copy numbers, and (3) joint prediction of number of clones and whole-genome duplication. In the following, we guide the user in the interpration of HATCHet's inference, we explain how to perform quality control to guarantee the best-quality results, and we describe how the user can control and tune some of the parameters to obtain the best-fitting results. In fact, it is important to assess the quality of the results from each of these steps to guarantee the best-quality results, especially when considering datasets with high noise or special features. 1. [Estimation of fractional copy numbers](#estimation) 2. [Inference of allele and clone-specific copy numbers](#inference) 3. [Joint selection of number of clones and whole-genome duplication](#joint) 4. [Quality control and suspicious cases](#quality) ## 1. Estimation of fractional copy numbers HATCHet estimates the fractional copy numbers for all segments by identifying 1 or 2 tumor clonal clusters (i.e, a cluster which have the same CNA in all tumor clones). First, HATCHet selects only some of the clusters as potential clonal clusters and, next, it aims to find consistent combinations of clonal clusters. #### Selecting potential clonal clusters HATCHet selects potential clonal clusters as sufficiently large clusters; the list of the selected clusters is reported in the LOG of the `HATCHet` step starting with line `# Selected clusters`. This list reports the cluster size and the corresponding pairs of values (RDR, BAF) in each sample (alphabetically sorted) and, therefore, can be easily used to map these clusters to the `bb_clustered.pdf` figure generated by the command `CBB` of `plot-bins` or the `plot-bins-1d2d` command. For example, we have the following: # Selected clusters: 11, 10, 12, 15, 21, 22, 23 ## Features of selected clusters: ## 11: SIZE= 169350000.0 #CHRS= 6 (RDR, BAF)= (0.98300155842, 0.0717476641159)-(0.70901452517, 0.0218274427111)-(0.793836783391, 0.0201025034921) ## 10: SIZE= 31250000.0 #CHRS= 2 (RDR, BAF)= (1.26230102783, 0.5)-(0.993581127953, 0.39042851007)-(1.08735153846, 0.411521706019) ## 12: SIZE= 187400000.0 #CHRS= 8 (RDR, BAF)= (1.54296926478, 0.399215013858)-(1.28029494725, 0.494771052557)-(1.38353348068, 0.415539785049) ## 15: SIZE= 57450000.0 #CHRS= 2 (RDR, BAF)= (0.70122709154, 0.406572560257)-(0.96296886062, 0.419918229626)-(0.869811018537, 0.415889001548) ## 21: SIZE= 73000000.0 #CHRS= 1 (RDR, BAF)= (0.982893169988, 0.350795164506)-(0.88867098782, 0.410185588799)-(0.917182445956, 0.415596024012) ## 22: SIZE= 71600000.0 #CHRS= 1 (RDR, BAF)= (0.982359985531, 0.350709236531)-(1.2496122809, 0.497653731887)-(1.16543827292, 0.496215824202) ## 23: SIZE= 106150000.0 #CHRS= 10 (RDR, BAF)= (0.701788866503, 0.100467817792)-(0.602518459603, 0.0254102909342)-(0.621971921092, 0.0253841073015) The size of the clusters that are considered is defined by the parameter `-ts` which defines the minimum fraction of the genome that needs to be covered by a potential clonal cluster. To deal with special or noisy datasets, the user can either decrease the value of this threshold (e.g. `-ts 0.001`, 0.1% fraction of the genome) to include clusters which have been erroneously excluded or increase the value of this threshold (e.g. `-ts 0.03`, 3% fraction of the genome) to exclude noisy clusters. Including all the most significant clusters is crucial to guarantee a correct identification of the clonal clusters and their copy numbers. For example, assume to have the following clusters: ## 0: SIZE= 498 #CHRS= 22 (RDR, BAF)= (1.0, 0.5) ## 1: SIZE= 497 #CHRS= 22 (RDR, BAF)= (0.7, 0.25) ## 2: SIZE= 5 #CHRS= 10 (RDR, BAF)= (1.0, 0.00) When using the default value of `-ts 0.008`, the cluster `2` will be excluded as it is covering a fraction of the genome smaller than the given threshold; as a consequence, the other cluster `1` appears to be the one with maximum shift of BAF and, therefore, with a copy-number state equal for example to (2, 0) (i.e. a loss-of-heterozygosity, LOH). However, assuming `2` is not due to noise but is providing true information, `2` should be the one with maximum shift of BAF and with a state (2, 0) corresponding to a LOH. Therefore, the user should identify the absence of cluster `2` by using the `bb_clustered.pdf` figure generated by command CBB of `plot-bins` and use a lower threshold `-ts 0.005` to include it. #### Identifying combinations of clonal clusters HATCHet chooses the largest combination of consistent clonal clusters to obtain the needed clonal cluster and to estimate the fractional copy numbers, when assuming the occurrence of a WGD. The combinations considered by HATCHet are reported in the LOG of the `HATCHet` step, after the inferences with the absence of a WGD (`# Running diploid`) and starting with line `# Finding clonal clusters and their copy numbers`. Each combination (also called pattern) is reported by first specifying the total size of the involved clusters and next the copy number state of each cluster. For example, we have the following: # Finding clonal clusters and their copy numbers ## Found pattern of size 1080892751.0: {'8': (2, 1), '28': (3, 2), '50': (2, 2), '29': (4, 2), '23': (2, 0)} ## Found pattern of size 906528933.0: {'60': (2, 1), '12': (3, 2), '50': (2, 2)} ## Found pattern of size 712147541.0: {'11': (2, 0), '50': (2, 2)} ## Found pattern of size 835497541.0: {'23': (2, 0), '28': (3, 2), '50': (2, 2), '29': (4, 2), '21': (2, 1)} ## Found pattern of size 886592751.0: {'8': (2, 0), '28': (4, 2), '50': (2, 2)} ## Chosen pattern of size 1080892751.0: {'8': (2, 1), '28': (3, 2), '50': (2, 2), '29': (4, 2), '23': (2, 0)} There are two parameters which control the identification of these patterns, which are `-tR`, i.e. RDR threshold, and `-tB`, i.e. BAF threshold. These thresholds are considered as the maximum allowed errors when estimating the clonal clusters. As such, the user can either decrease the thresholds (e.g. `-ts 0.03` and `-ts 0.02`) to consider more stringent constraints especially in low-noise datasets where subclonality can be accurately identified, or increase the thresholds (e.g. `-ts 0.15` and `-ts 0.05`) to accomodate the higher noise in certain datasets. The user can use the `bb_clustered.pdf` figure produced by the command `CBB` of `plot-bins` to assess the identified clonal cluster. For example, in the following case ## 0: SIZE= 498 #CHRS= 22 (RDR, BAF)= (1.0, 0.5) ## 1: SIZE= 497 #CHRS= 22 (RDR, BAF)= (0.7, 0.25) ## 2: SIZE= 5 #CHRS= 10 (RDR, BAF)= (1.0, 0.00) The users can easily see that the following pattern would be suspicious and wrong: ## Chosen pattern of size 995: {`0` : (2, 2), `1` : (2, 0)} because in the `bb_clustered.pdf` figure there is another clear cluster `2` which have a significantly higher shift in the BAF and, therefore, `1` cannot have a state `(2, 0)` which would correspond to the highest shift of BAF. ## 2. Inference of allele and clone-specific copy numbers HATCHet infers allele and clone-specific copy numbers by first assuming the absence of a WGD (`# Running diploid`) and, next, by assuming the presence of a WGD (`# Running tetraploid`). In each of the two cases, HATCHet considers an increasing number of clones (including the normal diploid clone). Typically, the interval starts from 2 (i.e. 1 tumor clone) up to 6-8 clones which is the typical maximum number of clones in terms of CNAs; however, the user can consider larger numbers, especially when suspecting the presence of more clones, by controlling the parameter `-n`, e.g. typical intervals are `-n 2,6`, `-n 2,8`, `-n 2,10`, `-n 2,12`, ... #### Maximum copy numbers and minimum clone proportion For each assumpotion and number of clones, HATCHet infers allele and clone-specific copy-numbers by using two main parameters, the *maximum copy numbers (`-eD` and `-eT`)* and the *minimum clone proportion (`-u`)*. These parameters are very important to constrain the solution space depending on the needs of the user, in particular the minimum clone proportion `-u` is particularly important to deal with noisy datasets and we reccomend the user to follow the criterion described here below: - **Maximum copy numbers (`-eD` and `-eT`)**: these values define the maximum value of the total copy number when assuming the absence of a WGD (`-eD`) and the presence of a WGD (`-eT`). By default the value of these parameters is `0` meaning that these values are inferred from the estimated fractional copy numbers. However, we recommend the user to try to use common values, especially in the first attempts, (e.g. 5, 6, 8 for `-eD` and 8, 10, 12 for `eT`) to constraint the searching space and avoid that noisy clusters introduce outlying values. - **Minimum clone proportion `-u`**: this value defines the minimum clone proportion for the inferred tumor clones. Default values are pretty small, e.g. 0.03 or 0.05, and allow to infer tumor clones present in small proportions. However, the power of the inference and the capability of inferring tumor clones with small proportions strongly depend on the noise of the data. As such, especially for noisy and special datasets it is very important that the user considers higher values when possible, e.g. 0.1-0.15. We reccomend to consider the following criterion to avoid overfitting and find the best fitting value for `-u`: **start from very small minimum clone proprtions and increase the value whenever the inferred solutions contain clones with clone proportions equal to this threshold**. ## 3. Joint selection of number of clones and whole-genome duplication For each number of clones N, the related copy numbers are computed by HATCHet and placed in two output files: - A `BBC-UCN` file which adds to the input `BBC` file the copy-number state and proportion inferred for each clone (the normal clone is always the first). The file is named `results.diploid.nN.bbc.ucn.tsv` or `results.tetraploid.nN.bbc.ucn.tsv` for the solutions obtained when considering the absence or presence of a WGD, respectively. - A `SEG-UCN` file which combines neighboring bins with the same copy-number states into segments and for each segment it reports the copy-number state and proportion of each clone. The file is named `results.diploid.nN.seg.ucn.tsv` or `results.tetraploid.nN.seg.ucn.tsv` for the solutions obtained when considering the absence or presence of a WGD, respectively. HATCHet selects the best solution under each of the two assumptions through a model selection criterion; as such, it copies the best diploid solutions to the files `chosen.diploid.bbc.ucn` and `chosen.diploid.seg.ucn`, and the best tetraploid solution to the two files `chosen.tetraploid.bbc.ucn` and `chosen.tetraploid.seg.ucn`. Each choice is based on the value of an elbow function (called `score`) computed for each number of clones. This value approximates the second derivative of the factorization objective function (called `OBJ`) and the choice is based on the maximum score; as such **the best number of clones is chosen as the number which significantly improves the objective function with respect to lower number of clones but no significant subsequent improvements are observed with increasing number of clones**. All these values are summarized in the LOG of the HATCHet step by firts summarizing the values for diploid solutions and next those of tetraploid solutions, e.g. ## Scores approximating second derivative for diploid results ## Diploid with 2 clones - OBJ: 66.804147 - score: -0.176997273837 ## Diploid with 3 clones - OBJ: 34.938751 - score: -0.020688175766 ## Diploid with 4 clones - OBJ: 17.550243 - score: 0.0543991087813 ## Diploid with 5 clones - OBJ: 9.77046 - score: 0.203750740655 ## Diploid with 6 clones - OBJ: 7.430087 - score: 0.0541415395045 ## Diploid with 7 clones - OBJ: 6.052593 - score: 0.0380373822927 ## Diploid with 8 clones - OBJ: 5.160703 - score: -0.152643321631 ## Scores approximating second derivative for tetraploid results ## Tetraploid with 2 clones - OBJ: 81.064423 - score: -0.414934454045 ## Tetraploid with 3 clones - OBJ: 23.108674 - score: 0.172765083795 ## Tetraploid with 4 clones - OBJ: 15.546709 - score: 0.103011062784 ## Tetraploid with 5 clones - OBJ: 12.060766 - score: 0.023008690139 ## Tetraploid with 6 clones - OBJ: 9.633957 - score: 0.0339979959232 ## Tetraploid with 7 clones - OBJ: 8.022994 - score: 0.104757566866 ## Tetraploid with 8 clones - OBJ: 7.521881 - score: -0.237540399507 The user should analyze the scores as HATCHet provides the following two parameters (controlling different hypotheses) to investigate alternative solutions with also high scores: - **Sensitivity to small CNAs `-l`**: this parameter controls the sensitivity of HATCHet to small CNAs, whose typical values are 0.5-0.6. The user should decrease this value, e.g. 0.2-0.3, to investigate solutions with more clones and smaller CNAs, while it should increase the value, e.g. 1.0-1.5, to give more confidence to large CNAs and less to small CNAs. - **Confidence in a single tumor clone `-g`**: this parameter controls the confidence in the presence of a single tumor clone, whose typical values are 0.2-0.3. The user should increase the value to increase the confidence, e.g. 0.4-0.5, in the presence of a single tumor clone, while lower values, e.g. 0.0-0.1, decrease the confidenze and favor the presence of more clones. The value should be increase especially in 2 cases: (1) when the score of 2 clones is particularly high with or without a WGD (e.g. a value close to 0.0), and especially (2) when the score of 2 clones is significantly higher with a WGD than the score of 2 clones without a WGD; the latter may indeed indicate the presence of a single tetraploid clone. The final best solution, according to prediction of the presence or absence of a WGD, is made based on a trade-off between the number of clones and WGD; more specifically, the diploid solution is chosen when it has the same or lower number of clones than the tetraploid solution, otherwise the tetraploid solution is chosen. ## 4. Quality control and suspicious cases It is very important that the user verifies the results in different steps to guarantee the best-quality results, more specifically: - User can assess the validity of the chosen clonal cluster using the `bb_clustered.pdf` figure produced by the command `CBB` of `plot-bins` and comparing the list of selected potential clonal clusters. - User can assess the inferred copy numbers by analyzing the inferred maximum values and the inferred clone proportions which define the tumor clonal composition. - User can assess the joint inference of number of clones and WGD by analyzing the values of the objective function and the related scores. There are some typical suspicious and warning cases that the user can identify from the analysis of the LOG of the `HATCHet` step: - Many diploid solutions have high scores. - Objective function of tetraploid solutions (i.e. with WGD) does not almost decrease/vary when increasing the number of clones. Even if this can occur because a single tetraploid tumor clone is present, this typically occurrs when the heuristic of HATCHet failed to identify a correct clonal cluster. This case is even more suspicious when the chosen number of diploid clones is much higher or when the objective function of tetraploid solutions is hugely higher that those of diploid solutions. - Inferred clone proportions are identical to the minimum clone proportion `-u` and tumor clones are present in all samples with very small proportions. Also, higher maximum copy numbers are needed when these result in much lower objective functions. - Huge difference between the number of clones inferred with and without a WGD, especially when the chosen diploid solution has a much lower number of clones than the chosen tetraploid solution. - Objective function that keeps decreasing significantly and objective function with very small values. - Score of 2 clones with a WGD is much higher then score of 2 clones without a WGD. This typically requires to increase the single-clone confidence of HATCHet `-g` to investigate the presence of a single tumor clone. The user can consider the following parameters to investigate alternative solutions and better fitting: - Sensitivity `-l` controls how much the variance of data and clusters influence the choice of the number of clones. The user should **increase the sensitivity (by decreasing the value of `-l` to 0.4, or 0.45, 0.5, or 0.3) when having high-purity or low variance samples** to better investigate multiple solutions, especially when there are multiple solutions with higher scores (and especially when there are many diploid solutions with high scores) and when considering small CNAs. Conversely, the user should **decrease the sensitivity (by increasing -l to 0.6, 0.8, 1.0)** when considering low-purity or high-variance samples. - Minimum clone proportion `-u`, we suggest to increase this value whenever obtaing solutions with clone proportions idetical to `-u` or clones present in all samples with very small proportions. - Maximum copy numbers, both standard values and those inferred from fractional copy numbers (by providing `-eD 0 -eT 0`) should be investigated. - `-g` controls the confidence in the presence of a single tumor clone. - Higher values of `-tR` and `-tR` allow to increase the thresholds for the inferred clonal clusters in case of high noise in the data, while lower values allow to decrease error in case of low noise data. - `-ts` determines a thresholds for the clusters to consider as potential clonal clusters, higher values allow to improve accuracy while lower values include more information especially when small CNAs are present. ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_count_alleles.md",".md","5587","64","# count-alleles Given one or more BAM files and lists of heterozygous SNP positions, this step of HATCHet counts the number of reads covering both the alleles of each identified heterozgyous SNP in every tumor sample. ## Input count-alleles takes in input sorted and indexed BAM files for multiple tumor samples from the same patient, a sorted and index BAM file from a matched-normal sample, and a indexed human reference genome. | Name | Description | Usage | |------|-------------|-------| | `-T`, `--tumors` | A white-space separated list of sorted-indexed BAM files | The tumor samples from the same patient that are jointly analyzed by HATCHet | | `-N`, `--normal` | A sorted-indexed BAM file | The matched normal sample for the same patient | | `-L`, `--snps` | VCF files | One or more files listing heterozygous SNP positions | | `-r`, `--reference` | A FASTA file | The human reference genome used for germline variant calling | ## Output count-alleles produces three tab-separated files: the first contains the read counts for every genomic bin in every tumor sample, the second contains the read counts for every genomic bin the matched-normal sample, and the third contains a list of the genomic positions that have been identified as germline heterozygous SNPs in the matched-normal sample. | Name | Description | Format | |------|-------------|--------| | `-O`, `--outputnormal` | The output file for the read counts from matched-normal sample | `#SAMPLE CHR POS REF_COUNT ALT_COUNT` | | `-o`, `--outputtumors` | The output file for the read counts from the tumor samples | `#SAMPLE CHR POS REF_COUNT ALT_COUNT` | | `-l`, `--outputsnps` | the output directory for the list of identified heterozygous germline SNPs | `#CHR POS` | The format fields are described in the following. | Field | Description | |-------|-------------| | `SAMPLE` | Name of a sample | | `CHR` | Name of the chromosome | | `POS` | Genomic position in `CHR` | | `REF_COUNT` | Number of reads harboring reference allele in `POS` | | `ALT_COUNT` | Number of reads harboring alternate allele in `POS` | ## Main parameters count-alleles has some main parameters; the main values of these parameters allow to deal with most of datasets, but their values can be changed or tuned to accommodate the features of special datasets. | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-S`, `--samples` | White-space separater list of a names | The first name is used for the matched-normal sample, while the others are for the tumor samples and they match the same order of the corresponding BAM files | File names are used | | `-st`, `--samtools` | Path to `bin` directory of SAMtools | The path to this direcoty needs to be specified when it is not included in `$PATH` | Path is expected in the enviroment variable `$PATH` | | `-bt`, `--bcftools` | Path to `bin` directory of BCFtools | The path to this direcoty needs to be specified when it is not included in `$PATH` | Path is expected in the enviroment variable `$PATH` | | `-c`, `--mincov` | Minimum coverage | Minimum number of reads that have to cover a variant to be called, the value can be increased when considering a dataset with high depth (>60x) | 8 | | `-C`, `--maxcov` | Maximum coverage | Maximum number of reads that have to cover a variant to be called, the typically suggested value should be twice higher than expected coverage to avoid sequencing and mapping artifacts | 300 | | `-j`, `--processes` | Number of parallele jobs | Parallel jobs are used to consider the chromosomes in different samples on parallel. The higher the number the better the running time | 22 | ## Optional parameters count-alleles has some optional parameters; changes in the default values of these parameters are not expected to have a significant impact but they can be tuned to better fit the given data. | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-v`, `--verbose` | Verbose logging flag | When enabled, count-alleles outputs a verbose log of the executiong | Not used | | `-g`, `--gamma` | Level of confidence for selecting germline heterozygous SNPs | This value is the level of confidence used for the binomial model used to assess whether a called SNPs is in fact germline heterozygous | 0.05 | | `-q`, `--readquality` | Threshold for phred-score quality of sequencing reads | The value can be either decreased (e.g. 10) or increased (e.g. 30) to adjust the filtering of sequencing reads | 20 | | `-Q`, `--basequality` | Threshold for phred-score quality of sequenced nucleotide bases | The value can be either decreased (e.g. 10) or increased (e.g. 30) to adjust the filtering of sequenced nucleotide bases | 20 | | `-U`, `--snpquality` | Threshold for phred-score quality of called variants | The value can be either decreased (e.g. 10) or increased (e.g. 30) to adjust the filtering of called variants | 20 | | `-L`, `--snps` | Path to file of SNPs in the format `#CHR POS` | When provided, only the included genomic positions will be considered for calling germline SNPs. Using well-known lists (e.g. dbSNP) help to significantly speed up this step | Not used, SNPs are called across all genome | | `-E`,`--newbaq` | Flag to enable `newbaq` veafute of SAMtools | When selected, the user asks SAMtools to recompute alignment of reads on the fly during SNP calling | Not used | | `-b`, `--maxshift` | Maximum BAF difference from 0.5 | When used, only SNPs with an absolute difference between the BAF and 0.5 below the maximum are selected | Not used | ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_count_reads_fw.md",".md","1966","31","# count-reads-fw NOTE: This function (formerly called `comBBo`) uses the legacy fixed-width binning described in the HATCHet paper. We recommend using [`count-reads`](doc_count_reads.md) and [`combine-counts`](doc_combine-counts.md) which apply an adaptive binning scheme to ensure that each genomic bin has comparable BAF signal. This step of HATCHet splits the human reference genome into fixed-width bins (i.e., small genomic regions), and computes the number of sequencing reads aligned to each bin from every given tumor samples and from the matched normal sample. ## Input count-reads-fw takes in input sorted and indexed BAM files for multiple tumor samples from the same patient, a sorted and index BAM file from a matched-normal sample, and a indexed human reference genome. | Name | Description | Usage | |------|-------------|-------| | `-T`, `--tumors` | A white-space separated list of sorted-indexed BAM files for tumor samples | The tumor samples from the same patient that are jointly analyzed by HATCHet | | `-N`, `--normal` | A sorted-indexed BAM file for matched-normal sample | The matched normal sample for the same patient | | `-r`, `--reference` | A FASTA file | The human reference genome used for germline variant calling | ## Output count-reads-fw produces three tab-separated files: the first contains the read counts for every genomic bin in every tumor sample (raw counts not normalized), the second contains the read counts for every genomic bin the matched-normal sample (raw counts not normalized), and the third contains a list of the genomic positions that have been identified as germline heterozygous SNPs in the matched-normal sample. | Name | Description | |------|-------------| | `-O`, `--outputnormal` | The output file for the read counts from matched-normal sample | | `-o`, `--outputtumors` | The output file for the read counts from the tumor samples | ## Main parameters count-reads-fw ## Optional parameters ","Markdown" "Allele","raphael-group/hatchet","docs/source/recommendation_datatype.md",".md","4090","16","# Analyze different type of data The default values in the complete pipeline of HATCHet are typically used for analyzing whole-genome sequencing (WGS) data. However, when considering different type of data, as those from whole-exome sequencing (WES) data, users should adjust some of the parameters due to the different features of this kind of data. More specifically, there are 4 main points to consider when analyzing WES data: - *Bin sizes*. One can use the plots from [plot-bins](https://github.com/raphael-group/hatchet/blob/master/doc/doc_plot_bins.html) to test different parameters (`--mtr` and `--msr` for variable-width, bin size for fixed width) and inspect the amount of variance and/or the separation between apparent clusters. * **Variable-width** Having a sufficient number of germline SNPs is needed to have good estimations with low variances for RDR and, especially, for the B-allele frequency (BAF) of each bin. Variable-width binning attempts to account for this by adjusting bin widths to ensure enough total and SNP-covering reads in each bin. You can tune the average bin width using the `--msr` (min. SNP-covering reads, default 5000) and `--mtr` (min. total reads, default 5000) parameters to `combine-counts`. Generally, `--msr` is more important because a bin with enough SNP-covering reads to get a good BAF estimate will almost certainly have enough total reads to get a good RDR estimate. Increasing these parameters produces larger bins (on average) with lower variance, while decreasing these values produces smaller bins (on average) with higher variance. * **Fixed-width (legacy)** While a size of 50kb is standard for CNA analysis when considering whole-genome sequencing (WGS) data, data from whole-exome sequencing (WES) generally require to use large bin sizes in order to guarantee that each bin contains a sufficient number of heterozygous germline SNPs. As such, more appropriate bin sizes to consider may be 200kb or 250k when analyzing WES data; even larger bin sizes, e.g. `500kb`, may be needed for noisy WES data. - *Read-count thresholds*. As suggested in the GATK best practices, `count-alleles` requires two parameters -c (the minimum coverage for SNPs) and -C (the maximum coverage for SNPs) to reliably call SNPs and exclude those in regions with artifacts. GATK suggests to consider a value of -C that is at least twice larger than the average coverage and -c should be large enough to exclude non-sequenced regions. For example, `-c 6` and `-C 300` are values previously used for WGS data whose coverage is typically between 30x and 90x. However, WES data are generally characterized by a much larger average coverage and thus require larger values, e.g. `-c 20` and `-C 600`. These values are also very usefule to discard off-target regions. In any case, the user should ideally pick values according to the considered data. - *Bootstrapping for clustering*. (legacy `cluster-bins-gmm` only) Occasionally, WES may have very few points and much less data points than WGS. Only in these special cases with very few data points, the global clustering of cluster-bins-gmm may generally benefit from the integrated bootstrapping approach. This approach allow to generate a certain number of synthetic bins from the real ones to increase the power of the clustering. For example, the following cluster-bins-gmm parameters `-u 20 -dR 0.002 -dB 0.002` allow to activate the bootstraping which introduces 20 synthetic bins for each real bin with low variances. - *Bias in balanced BAF.* Depending on the data type (WGS vs. WES) and the sequencing coverage, the argument `-d, --diploidbaf` in `cluster-bins`/`cluster-bins-gmm` may need to be adjusted to match the observed BAF bias. This threshold should be set so that the centroids of cluster(s) with BAF closest to 0.5 are included in the range [0.5 - `d`, 0.5] and other clusters with apparently different BAF are excluded. - *Genomic regions*. Provide a BED file defining the sequenced genomic regions when this is available. This helps to speed up the process. ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_cluster_bins.md",".md","5071","71","# cluster-bins This step globally clusters genomic bins along the entire genome and jointly across tumor samples. `cluster-bins` clusters bins while also taking into account their locations on the genome to preferentially form clusters that correspond to contiguous genomic segments on chromosome arms. The input/output files for `cluster-bins` are exactly the same as those for `cluster-bins-gmm`. ## Input `cluster-bins` takes in input a tab-separated file with the following fields. | Field | Description | |-------|-------------| | `CHR` | Name of a chromosome | | `START` | Starting genomic position of a genomic bin in `CHR` | | `END` | Ending genomic position of a genomic bin in `CHR` | | `SAMPLE` | Name of a tumor sample | | `RD` | RDR of the bin in `SAMPLE` | | `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | | `COV` | Average coverage in the bin in `SAMPLE` | | `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | | `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | | `BAF` | BAF of the bin in `SAMPLE` | The fields `#SNPS`, `COV`, `ALPHA`, and `BETA` are currently deprecated and their values are ignored. ## Output `cluster-bins` produces two tab-separated files: 1. A file of clustered genomic bins, specified by the flag `-O`, `--outbins`. The tab separated file has the same fields as the input plus a last field `CLUSTER` which specifies the name of the corresponding cluster. 2. A file of clustered genomic bins, specified by the flag `-o`, `--outsegments`. The tab separated file has the following fields. | Field | Description | |-------|-------------| | `ID` | The name of a cluster | | `SAMPLE` | The name of a sample | | `#BINS` | The number of bins included in `ID` | | `RD` | The RDR of the cluster `ID` in `SAMPLE` | | `#SNPS` | The total number of SNPs in the cluster `ID` | | `COV` | The average coverage in the cluster `ID` | | `ALPHA` | The alpha parameter of the binomial model for the BAF of the cluster `ID` | | `BETA` | The beta parameter of the binomial model for the BAF of the cluster `ID` | | `BAF` | The BAF of the cluster `ID` in `SAMPLE` | ## Main parameters 1. `cluster-bins` has a parameter `-d`, `--diploidbaf` that specifies the maximum expected shift from 0.5 the BAF of a balanced cluster (i.e., diploid with copy-number state (1, 1) or tetraploid with copy-number state (2, 2)). This threshold is used to correct bias in the BAF of these balanced clusters. The default value of this parameter (0.1) is often sufficient, but the most appropriate value will vary depending on noise and coverage. In general, this value should be set to include only those clusters that are closest to 0.5 -- for example, if some clusters have centroids near 0.47 and others have centroids near 0.42, this parameter should be set to 0.035 or 0.04. To determine the best setting for this value, please check the plots produced by `plot-bins` and the centroid values described `bbc/bulk.seg` (output from this command). 2. By default, `cluster-bins` takes as input a minimum number of clusters (`--minK`, default `2`) and maximum number of clusters (`--maxK`, default `30`), and chooses the number `K` of clusters in this closed interval that maximizes the silhoutette score. Users can also specify an exact number of clusters (`--exactK`) to infer, which skips the model selection step. 3. Other options are available to change aspects of the Gaussian Hidden Markov model (GHMM) that is used by `cluster-bins`: | Name | Description | Usage | Default | |------|-------------|-------|---------| | `--tau` | Off-diagonal value for initializing transition matrix | must be `<= 1/(K-1)` | `1e-6` | | `-t`, `--transmat` | Type of transition matrix to infer | `fixed` (to off-diagonal = tau), `diag` (all diagonal elements are equal, all off-diagonal elements are equal) or `full` (freely varying) | `diag` | | `-c`, `--covar` | Type of covariance matrix to infer | options described in [hmmlearn documentation](https://hmmlearn.readthedocs.io/en/latest/api.html#hmmlearn.hmm.GaussianHMM) | `diag` | | `-x`, `--decoding` | Decoding algorithm to use to infer final estimates of states | `map` for MAP inference, `viterbi` for Viterbi algorithm | `map` | Particularly, `tau` controls the balance between global information (RDR and BAf across samples) and local information (assigning adjacent bins to the same cluster): smaller values of `tau` put more weight on *local* information, and larger values of `tau` put more weight on *global* information. It may be appropriate to reduce `tau` by several orders of magnitude for noisier or lower-coverage datasets. ## Optional parameters | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-R`, `--restarts` | Number of restarts (initializations) | For each K, the HMM is initialized randomly this many times and the solution with the highest log-likelihood is kept | 10 | ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_check.md",".md","1124","24","# check This command of HATCHet verifies that dependencies that are unique to specific parts of HATCHet are correctly installed. The relevant commands with dependencies are `count-reads`, `phase-snps`, and `compute-cn`. All checks can be run simultaneously via `hatchet check`, or an individual command can be checked via, e.g., `hatchet check compute-cn`. The check for `compute-cn` runs the step on a set of small data files (.bbc/.seg) pre-packaged with HATCHet, and is a quick way to verify if your solver is working correctly. If you are unable to run this command, it likely indicates a licensing issue with default (Gurobi) solver. To use alternative solvers, see the [Using a different Pyomo-supported solver](README.html#usingasolver_other) section of the README for more details. ## Input This command takes no inputs. ## Output This command produces debugging output from the solver as well as other dependency checks. For `compute-cn`, look for the message towards the end of the output: ``` # Your current solver ... seems to be working correctly ``` to verify if your selected solver works correctly. ","Markdown" "Allele","raphael-group/hatchet","docs/source/recommendation_clustering.md",".md","3523","31","# Analyze global clustering The global clustering performed along the genome and jointly across samples is a crucial feature of HATCHet and the quality of the final results is strongly affected by the quality of the clustering. This global clustering is performed by HATCHet's component `cluster-bins`, whose default values are suitable for many datasets. However, for ideal results on specific datasets these parameters may need to be modified. The module `cluster-bins` incorporates genomic position to improve clustering using a Gaussian hidden Markov model (GHMM), as opposed to the position-agnostic Gaussian mixture model (GMM) used in `cluster-bins-gmm` and described in the original HATCHet publication. This page describes how to tune the parameters of `cluster-bins` -- for recommendations on `cluster-bins-gmm`, see [this page](recommendation_old_clustering.md) instead. The user should validate the results of the clustering, especially in noisy or suspicious cases, through the cluster figures produced by [plot-bins](doc_plot_bins.html) and [plot-bins-1d2d](doc_plot_bins_1d2d.html). More specifically, we suggest the following criteria to evaluate the clustering: 1. Every pair of clusters should be clearly distinct in terms of RDR or BAF in at least one sample, and 2. Each cluster should contain regions with similar values of RDR and BAF in all samples `cluster-bins` offers several parameters that can be used to tune the clustering. ## Number of clusters By default, `cluster-bins` tries several possible values for the number `K` of clusters and selects the one that maximizes the silhouette score. In practice, this tends to *underestimate* the number of clusters that are visually apparent. This can be modified by 1. Setting the parameters `--minK` and `--maxK` which specify the minimum and maximum number of clusters to consider, or 2. Setting the parameter `--exactK` to fix the number of clusters to a given value. ## Model parameters Some parameters of the model can be tuned to change the clustering. The most useful one is the value `--tau`, which corresponds to the probability of transitioning between different copy-number states (i.e., the initial value for off-diagonal entries in the transition matrix). In practice, `tau` controls the balance between global information (RDR and BAf across samples) and local information (assigning adjacent bins to the same cluster): smaller values of `tau` put more weight on *local* information, and larger values of `tau` put more weight on *global* information. It may be appropriate to reduce `tau` by several orders of magnitude for noisier or lower-coverage datasets, as in this case the global RDR/BAF values are less reliable. Other parameters (below) are available to change the structure of the model, although in practice I have not found them particularly helpful in tuning the clustering. | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-t`, `--transmat` | Type of transition matrix to infer | `fixed` (to off-diagonal = tau), `diag` (all diagonal elements are equal, all off-diagonal elements are equal) or `full` (freely varying) | `diag` | | `-c`, `--covar` | Type of covariance matrix to infer | options described in [hmmlearn documentation](https://hmmlearn.readthedocs.io/en/latest/api.html#hmmlearn.hmm.GaussianHMM) | `diag` | | `-x`, `--decoding` | Decoding algorithm to use to infer final estimates of states | `map` for MAP inference, `viterbi` for Viterbi algorithm | `map` | ","Markdown" "Allele","raphael-group/hatchet","docs/source/recommendation_old_clustering.md",".md","4769","27","# Analyze global clustering **Note**: this page describes recommendations for tuning the older clustering module `cluster-bins-gmm`. We recommend using the locality-aware clustering module [`cluster-bins`](doc_cluster_bins.md) instead. The global clustering performed along the genome and jointly across samples is a crucial feature of HATCHet and the quality of the final results is affected by the quality of the clustering. In particular, the global clustering is performed by HATCHet's component `cluster-bins-gmm`, whose default values for the main parameters allow to deal with most of the datasets. However, noisy or special datasets need tuning of these parameters, especially because the current version of `cluster-bins-gmm` uses [scikit-learn](https://scikit-learn.org/stable/modules/generated/sklearn.mixture.BayesianGaussianMixture.html), an external implementation of a GMM with a Dirichlet process prior which is not specifically designed for sequencing data. Therefore, the user needs to validate the results and improve it to obtain best-quality results, especially when considering noisy and special datasets. The user should validate the results of the clustering, especially in noisy or suspicious cases, through the cluster figure produced by the [command CBB of plot-bins](doc_plot_bins.md) and as explained in the available [demos](https://github.com/raphael-group/hatchet#demos). More specifically, we suggest to consider the following criterion to validate the clustering: **Every pair of clusters needs to be clearly distinct in terms of RDR or BAF in at least one sample and each cluster only contains regions with similar values of RDR and BAF in all samples**. `cluster-bins-gmm` offers two sets of parameters that the user can tune to improve the result of the clustering: (1) `cluster-bins-gmm`-specific and (2) sklearn-specific parameters. ### `cluster-bins-gmm`-specific parameters `cluster-bins-gmm` provides two specific parameters that can be used to improve the results of the global clustering: - `-tR` threshold defines a RDR tolerance (default value is `-tR 0.15`) - `-tB` threshold defines a BAF tolerance (default value is `-tB 0.04`) These tolerances are used to merge any pair of clusters which have differences in terms of RDR and BAF always lower than the given thresholds across all samples. Intuitively these two thresolds are used to draw a rectangle (with `tR` width and `tB` height in every RDR-BAF plots) around every cluster in every sample. If two clusters are in the same rectangle in every sample, they are merged. As such, the user can estimate the RDR and BAF as the values of the thresholds by using the heat figure produced by the [command BB of plot-bins](doc_plot_bins.md). In particular, higher values allow to merge more clusters, avoid overfitting, and accomodate higher noise and variances, while smaller values allow to avoid overclustering. For example, clusters which have a disc/long shape, i.e. high variance of RDR as in the [cancer WGS demo](https://github.com/raphael-group/hatchet/blob/master/examples/demo-WGS-cancer/demo-wgs-cancer.sh) or [WES demo](https://github.com/raphael-group/hatchet/blob/master/examples/demo-WES/demo-wes.sh), will require a higher value of `tR`, e.g. `-tR 0.3` or `-tR 0.4`. ### `sklearn`-specific parameters `cluster-bins-gmm` additionally provide 3 parameters which allow to directly control the clustering computed by the scikit-learn Gaussian Mixture Model: - `-R`: number of restarts (default is `-R 10`) which controls the number of restarts allows the method to escape local optima. While a lower number of restarts improves the running time of `cluster-bins-gmm` process, a higher number allows it to consider more solutions and choose a better clustering. - `-K`: this value provides the maximum possible number of clusters (default is `-K 50`). Scikit-learn tends to infer close to this maximum number `K` of clusters, so if you have relatively simple data with few apparent clusters you may want to lower `K`. - `-c`: this value (default `1`) determines the model's relative confidence in many even clusters (large `c`) vs. an uneven distribution of points into clusters, potentially with fewer than `K` components (small `c`). For experts, this is the concentration parameter for the Dirichlet process prior. Reducing this value by many orders of magnitude (e.g., `-c 0.001` or `-c 0.00001`) may enable scikit-learn to infer fewer than `K` clusters. Note that that these clustering parameters determine the clustering *before* the merging heuristic described above is applied; if you are unsure which set of parameters to tune, consider turning off the merging heuristic (i.e., setting `-tR 0 -tB 0`) to inspect the clustering without merging. ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_combine_counts.md",".md","5918","81","# combine-counts This step constructs variable-length bins that ensure that each bin has at least some number (`--msr`) of SNP-covering reads and at least some number (`--mtr`) of total reads per bin. Then, it combines the read counts and the allele counts for the identified germline SNPs to compute the read-depth ratio (RDR) and B-allele frequency (BAF) of every genomic bin. ## Input `combine-counts` takes in input the output from `count-reads` (i.e., two gzipped files `ch.total.gz` and `ch.thresholds.gz` for each chromosome `ch`, ). Use the `-A, --array` argument to specify a directory containing these input files. It also requires (specified by the flag `-b`, `--baffile`) a tab-separated file specifying the allele counts for heterzygous germline SNPs from all tumor samples. The tab separated file would typically be produced by the `count-alleles` command and has the following fields: | Field | Description | |-------|-------------| | `CHR` | Name of a chromosome | | `POS` | Genomic position corresponding to a heterozygous germline in `CHR` | | `SAMPLE` | Name of a tumor sample | | `REF_COUNT` | Count of reads covering `POS` with reference allele | | `ALT_COUNT` | Count of reads covering `POS` with alternate allele | Finally, `combine-counts` requires a TSV file (`-t, --totalcounts`) specifying the total number of reads aligned in each sample (also typically produced by `count-reads`). In summary, **the following arguments are required to specify input**: | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-A`, `--array` | Directory containing intermediate files | Typically populated by `count-reads`. For each chromosome `ch`, this directory should contain files `ch.total.gz` and `ch.thresholds.gz` (as well as `samples.txt` indicating sample names) | | | `-b, --baffile` | Tab-separated file with allele counts | Typically produced by `count-alleles`. See description above. | | | `-t, --totalcounts` | Tab-separated file with total aligned reads for each sample | Typically produced by `count-reads`. | | | `-V, --refversion` | Reference genome version | Either ""hg19"" or ""hg38"". This argument is used to select which centromere locations to use. | ## Output combine-counts produces a tab-separated file (`-o, --outfile`) with the following fields. | Field | Description | |-------|-------------| | `CHR` | Name of a chromosome | | `START` | Starting genomic position of a genomic bin in `CHR` | | `END` | Ending genomic position of a genomic bin in `CHR` | | `SAMPLE` | Name of a tumor sample | | `RD` | RDR of the bin in `SAMPLE` (corrected by the total reads in `SAMPLE` vs. the total reads in the matched normal sample) | | `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | | `COV` | Average coverage in the bin in `SAMPLE` | | `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | | `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | | `BAF` | BAF of the bin in `SAMPLE` | | `TOTAL_READS` | Total number of reads in the bin in `SAMPLE` | | `NORMAL_READS` | Total number of reads in the bin in the matched normal sample | | `CORRECTED_READS` | Total number of reads in the bin in `SAMPLE`, corrected by the total reads in `SAMPLE` vs. the total reads in matched normal. | Currently, it produces one such file that excludes sex chromosomes (for use in HATCHet), and one that includes sex chromosomes (for future use). ## Main parameters combine-counts has some main parameters; the main values of these parameters allow to deal with most of datasets, but their values can be changed or tuned to accommodate the features of special datasets. | Name | Description | Usage | Default | |------|-------------|-------|---------| | `--msr` | Minimum SNP-covering reads for each bin | Each bin constructed by this command must have at least this many reads covering heterozygous SNPs in each sample | 5000 | | `--mtr` | Minimum total reads for each bin | Each bin constructed by this command must have at least this many total reads in each sample | 5000 | ## Phasing parameters A phased VCF file must be given via argument `-p, --phase` to apply reference-based phasing. The remaining parameters control the degree to which the phasing information is used. | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-p`, `--phase` | vcf.gz with phasing for all het. SNPs | File containing phasing data for germline SNPs, typically `phased.vcf.gz` if using the HATCHet pipeline. | None (no phasing is performed) | | `-s`, `--blocksize` | Maximum phasing block size | Maximum distance (in bp) between a pair of SNPs included in the same phasing block (ignored if `-p, --phase` is not used) | 25000 | | `-m`, `--max_spb` | Maximum number of SNPs per phased block | No more than this many SNPs can be included in the same phasing block (included to minimize phasing errors in high-LD regions) | 10 | | `-a`, `--alpha` | Significance threshold to allow adjacent SNPs to be merged | If adjacent SNPs have significantly different BAFs (at this significance level) after taking the phasing into account, they are not merged a priori. Higher means less trust in phasing. | 0.1 | ## Other optional parameters | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-j`, `--processes` | Number of parallel processes to use (default 1) | | 1 | | `-z, --not_compressed` | Indicates that intermediate files are not compressed | For compatibility with legacy versions of previous step -- set this flag if your `.total` and `.thresholds` files are plaintext rather than gzipped. | | ## Example usage `hatchet combine-counts -b baf/bulk.1bed -o abin/bulk.bb -j 24 -V hg19 -A array -t array/total.tsv -V hg19` ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_fullpipeline.md",".md","10371","87","## Full pipeline and tutorial We provide example [BASH scripts](script/README.md) that implement the entire pipeline of HATCHet. This script and its usage are described in detailed in a guided [tutorial](doc_runhatchet.md). The user can simply use the script for every execution of HATCHet on different data by copying the script inside the running directory and changing the corresponding paths of the required data and dependencies at the beginning of the script, as described in the guided [tutorial](doc_runhatchet.md). ## Demos Each demo is an example and guided execution of HATCHet on a dataset included in the corresponding demo's folder of this repository (inside `examples`). The demos are meant to illustrate how the user should apply HATCHet on different datasets characterized by different features, noise, and kind of data. In fact, the default parameters of HATCHet allow to successfully analyze most of the datasets but some of these may be characterized by special features or higher-than-expected variance of the data. Understanding the functioning of HATCHet, assessing the quality of the results, and tuning the few parameters needed to fit the unique features of the considered data thus become crucial to guarantee to always obtain the best-quality results. These are the goals of these demos. More specifically, each demo is simultaneously a guided description of the entire example and a BASH script, which can be directly executed to run the complete demo after setting the few required paths at the beginning of the file. As such, the user can both read the guided description as a web page and run the same script to execute the demo. At this time the following demos are available (more demos will be added in the near future): | Demo | Description | |------|-------------| | [demo-complete](examples/demo-complete/demo-complete.html) | A demo of the complete HATCHet pipeline starting from an example dataset of tumour and matched normal BAM files | | [demo-wgs-sim](examples/demo-WGS-sim/demo-wgs-sim.html) | A demo on a typical WGS (whole-genome sequencing) multi-sample dataset with standard noise and variance of the data | | [demo-wgs-cancer](examples/demo-WGS-cancer/demo-wgs-cancer.html) | A demo on a cancer WGS (whole-genome sequencing) multi-sample dataset with high noise and variance of the data | | [demo-wes](examples/demo-WES/demo-wes.html) | A demo on a cancer WES (whole-exome sequencing) multi-sample dataset, which is typycally characterized by very high variance of RDR | ## Custom pipelines The repository includes custom pipelines which have been designed to adapt the complete pipeline of HATCHet to special conditions or to integrate the processed data produced by other pipelines. Each custom pipeline is a variation of the main HATCHet's pipeline, we thus recommend the user to always first carefully understand the main [BASH script](script/README.md) through the corresponding guided [tutorial](doc_runhatchet.md) and to carefully understand the provided [demos](#demos) to properly apply HATCHet for best-quality results. Each custom pipeline also includes a specific demo which represent a guided and executable example on example data. | Name | Description | Script | Demo | Variations | |------|-------------|--------|------|------------| | GATK4-CNV | Custom pipeline for segmented files from GATK4 CNV pipeline | [custom-gatk4-cnv.sh](custom-gatk4-cnv.sh) | [demo-gatk4-cnv.sh](custom/GATK4-CNV/demo-gatk4-cnv.html) | This custom pipeline takes the input the segmented files which already contain the estimated RDR and BAF. As such, the first pre-processing steps of HATCHet (`count-reads`, `count-alleles`, and `combine-counts`) are not needed; for this reason, the following depdencies SAMtools and BCFtools and the following required data, human reference genome, matched-normal sample, and BAM files, are not needed in this case. | ## Detailed steps The full pipeline of HATCHet is composed of 9 sequential steps (and an additional dependency-checking command), starting from the required input data. The description of each step also includes the details of the corresponding input/output that are especially useful when one wants to replace or change some of the steps in the pipeline while guaranteeing the correct functioning of HATCHet. Each step `` of HATCHet can be run with the following command within a HATCHet conda environment: ```shell hatchet ``` **Note**: This version of HATCHet uses variable-width bins to ensure that each bin has comparable B-allele frequency (BAF) signal from heterogeneous germline SNPs and to account for sequencing coverage. To run the older versions of HATCHet with fixed-width bins, use [*count-reads-fw*](doc_count_reads_fw.html) (formerly binBAM) instead of *count-reads* and [*combine-counts-fw*](doc_combine_counts_fw.html) (formerly comBBo) instead of *combine-counts*. If you are using the `run` command, set `fixed_width = True` under the `[run]` header in your `.ini` file. Additionally, this version of HATCHet uses a new locality-aware clustering module that incorporates local information along the genome. This replaces the previous GMM-based clustering (command named cluBB). Users can still use GMM-based clustering if they wish by setting `loc-clust` to `False` under the `[run]` header in `hatchet.ini`, or by running [*cluster-bins-gmm*](doc_cluster_bins_gmm.md) directly. *Older versions of HATCHet used different names for these steps. The `Old Name` column lists those names.* | Order | Step | Old Name | Description | |-------|------|----------|-------------| | (1) | [*genotype-snps*](doc_genotype_snps.html) | deBAF | This step calls heterozygous germline SNPs from the matched-normal sample. | | (2) | [*count-alleles*](doc_count_alleles.html) | deBAF | This step counts the number of reads covering both the alleles of each identified heterozgyous SNP in every tumor sample. | | (3) | [*count-reads*](doc_count_reads.html) | N/A | This step splits the human reference genome into very small regions (representing candidate bins) according to germline SNP positions, and counts the number of total reads aligned to each region in each of the tumor samples and in the matched normal sample. | | (4) | [*phase-snps*](doc_phase_snps.html) | N/A | This **optional** step uses reference-based phasing to group together germline SNPs that are likely on the same haplotype. This improves the quality of BAF estimates for balanced regions of the genome. | | (5) | [*combine-counts*](doc_combine_counts.html) | N/A | This step constructs genomic bins with variable sizes, and combines the read counts and the allele counts for the identified germline SNPs to compute the read-depth ratio (RDR) and B-allele frequency (BAF) of every genomic bin. | | (6) | [*cluster-bins*](doc_cluster_bins.html) | N/A | This step globally clusters genomic bins along the entire genome and jointly across tumor samples while incorporating local information. | | (7) | [*plot-bins*](doc_plot_bins.html) | BBot | This **optional** step produces informative plots concerning the computed RDRs, BAFs, and clusters. The information produced by this step are important to validate the compute clusters of genomic regions. When this step is enabled in the `.ini` file, [plot-bins-1d2d](doc_plot_bins_1d2d.html) is run as well to generate additional plots. | | (8) | [*compute-cn*](doc_compute_cn.html) | hatchet | This step computes allele-specific fractional copy numbers, solves a constrained distance-based simultaneous factorization to compute allele and clone-specific copy numbers and clone proportions, and deploys a model-selection criterion select the number of clone by explicitly considering the trade-off between subclonal copy-number aberrations and whole-genome duplication. | | (9) | [*plot-cn*](doc_plot_cn.html) | BBeval | This **optional** step analyzes the inferred copy-number states and clone proportions and produces informative plots jointly considering all samples from the same patient. In addition, this step can also combine results obtained for different patients and perform integrative analysis. When this step is enabled in the `.ini` file, [plot-cn-1d2d](doc_plot_cn_1d2d.html) is run as well to generate additional plots. | | (10) | [*check*](doc_check.html) | check-solver | This **optional** step is a quick way to verify if your solver and other 3rd party dependencies are working correctly. It checks for the presence of several dependencies and tests `compute_cn` on a set of small data files pre-packaged. | ## Recommendations and quality control All the components of HATCHet's pipeline use some basic parameters that allow to deal with data characterized by different features. The default values of these parameters allow one to succesfully apply HATCHet on most datasets. However, special or noisy datasets may require to tune some parameters. The user can deal with these cases by following the recommendations reported here, reading the descriptions of the various steps, and using the informative plots to verify the results. In the following guides and recommentations, we guide the user in the interpration of HATCHet's inference, we explain how to perform quality control to guarantee the best-quality results, and we describe how the user can control and tune some of the parameters to obtain the best-fitting results. We thus split the recommendations into distinct topics with dedicated descriptions. | Recommendation | Description | |----------------|-------------| | [Analyze HATCHet inference](recommendation_inference.html) | Interpret HATCHet's inference, quality and error control, and investigate alternative solutions. | | [Analyze global clustering](recommendation_clustering.html) | Interprent global clustering, quality and error control, and parameter tuning | | [Analyze different type of data](recommendation_datatype.html) | Tuning parameters to better analyzing different type of data as those from WES | | [Improve running time](recommendation_runtime.html)| Tips for improving running time of the whole pipeline | ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_count_reads.md",".md","3819","47","# count-reads This step of HATCHet uses the locations of heterozygous SNPs (called by `count-alleles`) to identify candidate bin thresholds between SNPs. Then, it counts the total number of reads in each sample between each set of candidate thresholds for use in constructing variable-length bins. ## Input `count-reads` takes in input sorted and indexed BAM files for multiple tumor samples from the same patient, a sorted and index BAM file from a matched-normal sample, an indexed human reference genome, and a 1bed file containing SNP information for this individual (output from `count-alleles` command, normally `baf/bulk.1bed`). | Name | Description | Usage | |------|-------------|-------| | `-T`, `--tumors` | A white-space separated list of sorted-indexed BAM files for tumor samples | The tumor samples from the same patient that are jointly analyzed by HATCHet | | `-N`, `--normal` | A sorted-indexed BAM file for matched-normal sample | The matched normal sample for the same patient | | `-b`, `--baffile` | A 1bed file containing locations of heterozygous germline SNPs | Typically, a user would run `count-alleles` to obtain this file. | | `-V`, `--refversion` | Reference genome version (hg19 or hg38 supported) | | ## Output `count-reads` writes all output files to a given output directory. For each chromosome `chr`, count-reads produces two gzipped files needed to construct adaptive bins: `chr.threhsolds.gz` and `chr.total.gz`. `count-reads` also produces a tab-separated file `total.tsv` containing the total number of reads in each sample, and a text file `samples.txt` containing the list of sample names. | Name | Description | |------|-------------| | `-O`, `--outdir` | Output directory | Directory in which output will be written to (must already exist before running `count-reads`) ## Main parameters | Name | Description | Usage | |------|-------------|-------| | `-V`, `--refversion` | Reference genome version (""hg19"" or ""hg38"" supported) | | ## Optional parameters | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-S`, `--samples` | White-space separater list of a names | The first name is used for the matched-normal sample, while the others are for the tumor samples and they match the same order of the corresponding BAM files | File names are used | | `-j`, `--processes` | Number of parallel jobs | Parallel jobs are used to consider the chromosomed in different samples in parallel. The higher the number the better the running time (up to 22 * n_samples) | 22 | | `-st`, `--samtools` | Path to `bin` directory of SAMtools | The path to this direcoty needs to be specified when it is not included in `$PATH` | Path is expected in the enviroment variable `$PATH` | | `-md`, `--mosdepth` | Path to the `mosdepth` executable | The path to this executable needs to be specified when it is not included in `$PATH` | None (expected on `PATH`) | | `-tx`, `--tabix` | Path to the `tabix` executable | The path to this executable needs to be specified when it is not included in `$PATH` | None (expected on `PATH`) | | `-q`, `--readquality` | Minimum mapping quality (MAPQ) for a read to be counted | Values range from 0 to 41, see alignment documentation for details | 11 | | `-i`, `--intermediates` | Keep intermediate files | Retain intermediate files (read starts and per-position coverage) that are used to compute arrays for binning | False (these files are deleted, subsequent arrays are retained instead) | ## Example usage Given samtools, mosdepth, and tabix are on the PATH, the referenced files are in the current directory, and the intended output directory `array` is present: `hatchet count-reads -T first_sample.bam second_sample.bam -N normal_sample.bam -S normal tumor1 tumor2 -V hg19 -j 24 -O array -b baf/bulk.1bed` ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_plot_bins.md",".md","8217","124","# plot-bins This step produces informative plots concerning the computed RDRs, BAFs, and clusters. The information produced by this step are important to validate the compute clusters of genomic regions and help to tune the parameters for better deal with special datasets. plot-bins produces different plots which need to be specified by different commands and require different input. When `plot_bins = True` is indicated in `hatchet.ini`, the command [`plot-bins-1d2d`](doc_plot_bins_1d2d.md) will also be run. This command produces alternate plots in which bins are colored by cluster and colors match across samples between the 2D cluster view and 1D genomic view. ## Input plot-bins considers two different inputs which are tab-separated files, one is mandatory and the other is only required for certain command: 1. A file of clustered genomic bins, specified without any flag and with the following fields. | Field | Description | |-------|-------------| | `CHR` | Name of a chromosome | | `START` | Starting genomic position of a genomic bin in `CHR` | | `END` | Ending genomic position of a genomic bin in `CHR` | | `SAMPLE` | Name of a tumor sample | | `RD` | RDR of the bin in `SAMPLE` | | `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | | `COV` | Average coverage in the bin in `SAMPLE` | | `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | | `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | | `BAF` | BAF of the bin in `SAMPLE` | | `CLUSTER` | The name of the corresponding cluster of the bin in `SAMPLE` | 2. A file of clusters, which is required only by commands and it is specified through the flag `-s`, `--segfile`. The file has the following fields. | Field | Description | |-------|-------------| | `ID` | The name of a cluster | | `SAMPLE` | The name of a sample | | `#BINS` | The number of bins included in `ID` | | `RD` | The RDR of the cluster `ID` in `SAMPLE` | | `#SNPS` | The total number of SNPs in the cluster `ID` | | `COV` | The average coverage in the cluster `ID` | | `ALPHA` | The alpha parameter of the binomial model for the BAF of the cluster `ID` | | `BETA` | The beta parameter of the binomial model for the BAF of the cluster `ID` | | `BAF` | The BAF of the cluster `ID` in `SAMPLE` | ## Commands A command must be specified using the flag `-c`, `--command` and every command is described in the following together with an example of the corresponding plot. ### RD The command generates a scatter plot describing the RDR of every genomic bin in the different samples. For every genomic bin sorted by chromosome and by genomic positions, a point is plotted with the correspondig value of RDR and colored by a color identifying the corresponding sample. python -m hatchet plot-bins A12.bbc -c RD -m Set1 --figsize 9,2.5 --markersize 1 --ymax 8 --ymin 0 ![](example_rd.png ""Example of RDR plot from the output of RD command"") *** ### BAF The command generates a scatter plot describing the BAF of every genomic bin in the different samples. For every genomic bin sorted by chromosome and by genomic positions, a point is plotted with the correspondig value of RDR and colored by a color identifying the corresponding sample. python -m hatchet plot-bins A12.bbc -c BAF -m Set1 --figsize 9,2.5 --markersize 1 --ymax 8 --ymin 0 ![](example_baf.png ""Example of RDR plot from the output of RD command"") *** ### BB The command generates a series of 2d-scatter plots where x-axis corresponds to the mirrored BAF and the y-axis corresponds to RDR. More specifically, a plot is generated for every sample and every point is drawn according to the corresponding values of RDR and BAF. The points are colored according to their density from blue (low density) to dark red (high density). python -m hatchet plot-bins A12.bbc -c BB --figsize 8,6 --markersize 1 --xmax 3.5 --xmin 0.5 *** ### CBB The command generates a series of 2d-scatter plots where x-axis corresponds to the mirrored BAF and the y-axis corresponds to RDR. More specifically, a plot is generated for every sample and every point is drawn according to the corresponding values of RDR and BAF. The points are colored according to the clusters computed by HATCHet. Remember that a cluster contains all the genomic regions that have the same copy-number state in every clone. python -m hatchet plot-bins A12.bbc -c CBB --figsize 4,1.1 -m tab20 --markersize 1 --xmax 3.5 --xmin 0.5 --colwrap 3 -tS 0.005 *** ### CRDR The command generates a series of 2d-scatter plots where x-axis corresponds to the RDR and to bins sorted by chromosome and positions. More specifically, a plot is generated for every sample and every point is drawn according to the corresponding values of RDR. The points are colored according to the clusters computed by HATCHet. Remember that a cluster contains all the genomic regions that have the same copy-number state in every clone. python -m hatchet plot-bins A12.bbc -c CRD -m tab20 --figsize 9,2.5 --markersize 1 --ymax 8 --ymin 0 ![](example_crdr.png ""Example of cluster plot from the output of CRDR command"") *** ### CBAF The command generates a series of 2d-scatter plots where x-axis corresponds to the BAF and to bins sorted by chromosome and positions. More specifically, a plot is generated for every sample and every point is drawn according to the corresponding values of BAF. The points are colored according to the clusters computed by HATCHet. Remember that a cluster contains all the genomic regions that have the same copy-number state in every clone. python -m hatchet plot-bins A12.bbc -c CBAF -m tab20 --figsize 9,2.5 --markersize 1 --ymax 8 --ymin 0 ![](example_cbaf.png ""Example of cluster plot from the output of CBAF command"") *** ### Parameters | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-tC`, `--chrthreshold` | Threshold of chromosomes | A threshold can be specified to select to plot only genomic regions belonging to clusters that cover at least the specified number of chomosomes | 0, no threshold | | `-tS`, `--sizethreshold` | Threshold of size | A threshold can be specified to select to plot only genomic regions belonging to clusters that cover at least the specified fraction of the genome | 0, no threshold | | `--xmin` | Minimum x-value of plot | The value can be specified to fix the minimum value of x-axis of the plot | None | | `--xmax` | Maximum x-value of plot | The value can be specified to fix the maximum value of x-axis of the plot | None | | `--ymin` | Minimum y-value of plot | The value can be specified to fix the minimum value of y-axis of the plot | None | | `--ymax` | Maximum y-value of plot | The value can be specified to fix the maximum value of y-axis of the plot | None | | `--figsize` | Figure size in the format ""(X, Y)"" | The parameter is used to change the figure size. The meaning and scale of X and Y depend on the different plot so one needs to try different values. | Automatic values | | `--markersize` | Size of the markers | The value is used to scale the size of the point markers | Automatic value | | `-m`, `--colormap` | Name of the colormap to use | The following colormaps are available: {Set1, Set2, Paired, Dark2, tab10, and tab20} | tab20 | | `--resolution` | Number of bins to merge | This feature allows plot-bins to merge multiple bins into segments whose copy numbers will be chosen by majority. This features allows to change the resolution of the plot. | 0, bins are not merged | | `--colwrap` | Number of plots per each column | This value determines the maximum number of plots for multiple samples to print on the same row | 2 | | `--fontscale` | Scale for font size | The value is used to scale the font size | 1 | | `-s`, `--segfile` | Path to cluter file | The cluster file, containing estimated values of RDR and BAF for each cluster in every sample is only required by `CLUSTER` command | None | | `-x`, `--rundir` | Path to running directory | The running directory where output the results | Current directory | ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_compute_cn.md",".md","12986","143","# compute-cn This step infers allele-specific copy numbers for each tumor clone as well as the mixture proportions of the tumor clones in each sample. It consists of the following components: 1. Compute allele-specific fractional copy numbers. 2. Solve a constrained distance-based simultaneous factorization to compute allele and clone-specific copy numbers and clone proportions. 3. Deploy a model-selection criterion to select the number of clones by explicitly considering the trade-off between subclonal copy-number aberrations and whole-genome duplication. The step offers some parameters to control each of these features. ## Input This step requires in input two tab-separated files that must have the same prefix `${PRE}` and the only difference is the extension: 1. The name of the first file must be `${PRE}.bbc` and is a tab-separated file describing the RDR and BAF of clustered genomic bins with the following fields | Field | Description | |-------|-------------| | `CHR` | Name of a chromosome | | `START` | Starting genomic position of a genomic bin in `CHR` | | `END` | Ending genomic position of a genomic bin in `CHR` | | `SAMPLE` | Name of a tumor sample | | `RD` | RDR of the bin in `SAMPLE` | | `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | | `COV` | Average coverage in the bin in `SAMPLE` | | `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | | `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | | `BAF` | BAF of the bin in `SAMPLE` | | `CLUSTER` | The name of a cluster | 2. The name of the second file must be `${PRE}.seg` and is a tab-separated file describing the RDR and BAF of clusters of genomic regions with the following fields | Field | Description | |-------|-------------| | `ID` | The name of a cluster | | `SAMPLE` | The name of a sample | | `#BINS` | The number of bins included in `ID` | | `RD` | The RDR of the cluster `ID` in `SAMPLE` | | `#SNPS` | The total number of SNPs in the cluster `ID` | | `COV` | The average coverage in the cluster `ID` | | `ALPHA` | The alpha parameter of the binomial model for the BAF of the cluster `ID` | | `BETA` | The beta parameter of the binomial model for the BAF of the cluster `ID` | | `BAF` | The BAF of the cluster `ID` in `SAMPLE` | ## Output This step produces 2 files, a BBC result file and a SEG result file, for every considered number of clones and for both the assumption of the presence and absence of a WGD. For every considered number of clones `${N}` and assuming `${P}` is either equal to `diploid` or `tetraploid`, the steps generates a pair of files as follows: 1. The first BBC file has the following name `results.${P}.n${N}.bbc.ucn.tsv` and is a copy of the BBC input file with `2 (${N} + 1)` additional fields according to the following: | Field | Description | |-------|-------------| | ... | ... | | `cn_normal` | The copy number state of the normal diploid clone equal to 1|1 | | `u_normal` | The normal admixture of the normal diploid cells in the corresponding sample | | `cn_clone${n}` | The copy number state of the `${n}` tumor clone in the format A|B where `A` and `B` are the two allele-specific copy numbers of the corresponding genomic bin | | `u_clone${n}` | The clone proportion of the `${n}` tumor clone in the corresponding sample | 2. The second SEG file has the following name `results.${P}.n${N}.seg.ucn.tsv` and is a file of genomic segments with the following fields: | Field | Description | |-------|-------------| | `CHR` | The name of a chromosome | | `START` | The genomic position that starts the corresponding genomic segment | | `END` | The genomic position that ends the corresponding genomic segment | | `SAMPLE` | The name of a sample | | `cn_normal` | The copy number state of the normal diploid clone equal to 1|1 | | `u_normal` | The normal admixture of the normal diploid cells in the corresponding sample | | `cn_clone${n}` | The copy number state of the `${n}` tumor clone in the format A|B where `A` and `B` are the two allele-specific copy numbers of the corresponding genomic bin | | `u_clone${n}` | The clone proportion of the `${n}` tumor clone in the corresponding sample | In addition, the two files for the best solution assuming both the absence or presence of a WGD are copied in the files `chosen.diploid.bbc.ucn`, `chosen.diploid.seg.ucn` and `chosen.tetraploid.bbc.ucn`, `chosen.tetraploid.seg.ucn`, respectively. Last, hatchet copies the best solution according to the prediction of WGD in the two files `best.bbc.ucn` and `best.seg.ucn`. ## Fractional copy numbers The first feature of hatchet is the explicit estimation of allele-specific fractional copy numbers. hatchet performs this estimation based on rigorous criterion stating that allele-specific fractional copy numbers can be obtained from RDR and BAF of clusters of genomic regions. More specifically, the criterion states that: - when there is no WGD, the identification of the diploid cluster with copy-number state (1, 1) is sufficient - when there is a WGD, the identification of the tetraploid cluster with copy-number state (2, 2) and of a second clonal cluster with a copy-number state (A, B) in all tumor clones are sufficient. As such, hatchet identifies a heuristic to identifies the required clusters and copy-number states. This heuristic can be controlled by the following parameters: | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-c`, `--clonal` | The required clusters and corresponding copy number states | User can directly specifies the required clusters and the corresponding copy number states to compute the allele-specific fractional copy number states. These must be speficied in the format `IDX-1:A-1:B-1, ..., IDX-M:A-M:B-M` where `IDX-S` is the name of cluster `S` and `(A-S, B-S)` is the corresponding copy-number state. Moreover, user can specify addittional clusters and copy numbers beyond the required ones. The copy-numbers for these clusters will be fixed during the computation. This can be an usefule feature for especially noisy datasets. | None | | `-ts`, `--minsize` | Threshold for size of clusters | The minimum size of the clusters to consider for the heuristic that identifies clonal clusters. The non-selected clusters will not be considered as potential tumor-clonal clusters. The threshold must be expressed as a fraction of the entire genome. | 0.02, e.g. `2%` of genome | | `-tc`, `--minchrs` | Threshold for number of chromosomes | The minimum number of chromosomes covered by the clusters to consider for the heuristic that identifies clonal clusters. The non-selected clusters will not be considered as potential tumor-clonal clusters. | 1 | | `-td`, `--maxneutralshift` | Maximum BAF shift allowed for diploid cluster | The maximum expected shift from 0.5 for BAF for a diploid or tetraploid cluster (i.e. with copy-number states (1, 1) or (2, 2)). This threshold is used for two goals to identify the diploid or tetraploid cluster. | 0.1 | | `-tR`, `--toleranceRDR` | Maximum RDR tolerance | The maximum RDR tolerance used by the heuristic when estimating the position of all clonal clusters | 0.04 | | `-tB`, `--toleranceBAF` | Maximum BAF tolerance | The maximum BAF tolerance used by the heuristic when estimating the position of all clonal clusters | 0.03 | | `--merge` | Activate merging of clusters | When activated, the heuristic will merge together clusters that appear to have the same values of RDR and BAF, according to the values below. This procedure can help the heuristic by refining the clustering and merging clusters that are likely to have the same copy-number states and unlikely to be clonal. | False, not used | | `-mR`, `--mergeRDR` | RDR merging threhsold | The maximum difference in RDR considered by the merging procedure | 0 | | `-mB`, `--mergeBAF` | BAF merging threhsold | The maximum difference in BAF considered by the merging procedure | 0 | ## Simultaneous factorization The second feature corresponds to the simultaneous factorization of allele-specific copt numbers and clone proportions. hatchet solves a constrained and distance-based variant of the factorization that can be controlled by the following parameters. | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-n`, `--clones` | Interval for number of clones | User can specify the minimum and maximum number of clones to consider | `""2,8""` | | `-eD`, `--diploidcmax` | Maximum copy number with no WGD | The value of maximum copy number that is considered when assuming no WGD. When `0`-value is specified the maximum copy number is directly inferred from the data by rounding the maximum fractional copy number | 8 | | `-eT`, `--tetraploidcmax` | Maximum copy number with a WGD | The value of maximum copy number that is considered when assuming there is a WGD. When `0`-value is specified the maximum copy number is directly inferred from the data by rounding the maximum fractional copy number | 8 | | `-u`, `--minprop` | Minimum clone proportion | In every sample, each clone either is non present (clone proportion equal to 0.0) or has a clone proportion higher than this threshold | 0.03 | | `-f`, `--noampdel` | Activate clone evolutionary contraints | User can decide whether to enable or not constrained about the evolution of tumor clones. These constrained force each allele to be either amplified or deleted across all tumor clones | Activated | | `-d`, `--cnstates` | Maximum number of distinct copy-number states per cluster | When enabled, the maximum number of distinct copy-number states per cluster is fixed. This option is deprecated | Not used | HATCHet implements two methods to solve the constrained and distance-based simultaneous factorization: (1) a integer-linear programming (ILP) and (2) a coordinate-descent method (CD). These methods can be combined in 3 different modes: - (0) CD + ILP: the solution found by CD is used to start the ILP. As such, ILP attempts to improve the solution found by CD. - (1) ILP only - (2) CD only The mode can be specified through the flag `--mode` whose default is mode 2. In addition, the solving methods can be controlled by the following parameters. | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-j`, `--jobs` | Number of parallel jobs | Every job will run on parallel a different seed of the CD algorithm and all the jobs can be used for solving the ILP | Number of available processes on machine | | `-p`, `--seeds` | Number of CD seeds | Number of random restarts executed by the CD algorithm. In general, the higher the number of restarts, the better the result | 400 | | `-r`, `--randomseed` | Seed for random generator | Every execution started from the same seed have a deterministic behaviour and can be exactly replicated | None, random seed | | `-s`, `--timelimit` | Time limit | The time limit, expressed in seconds, is imposed to every step of the CD algorithm or to the whole ILP | None | | `-m`, `--timelimit` | Memory limit | The memory limit, expressed in megabytes, is imposed to every step of the CD algorithm or to the whole ILP. The execution will not be interrupted when reaching the threshold but disk is used | None | | `--maxiterations` | Maximum number of iteration per seed | This number is imposed as the maximum number of iterations executed for every restart of the CD algorithm | 40 | | `--diploid` | Assume no WGD | When enabled, HATCHet assumes the absence of a WGD | Not used | | `--tetraloid` | Assume a WGD | When enabled, HATCHet assumes the occurrence of a WGD | Not used | ## Model selection This steps have two main parameters to control the model-selection criterion: | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-l`, `--limitinc` | Sensitivity level | The sensitivity level is used to control the confidence in evaluating the presence of tumor clones characterized by small CNAs. By decreasing the value of the sensitivity, HATCHet is more sensible to the presence of small CNAs and small clusters or with small shifts in RDR/BAF are more likely considered as the signal of an additional tumor clone. The possible values of this parameter are between 1.0 and 0.0 and specifically corresponds to an upper bound for the left relative improvement of the objective function. | None, reasonable values to use can be 0.6, 0.5, 0.4, 0.3, 0.2, ... according to the values of the objective function. | | `-g`, `--ghostprop` | Confidence in the presence of a single tumor clone | This value expresses the confidence of HATCHet when evaluating the presence of a single tumor clone. The higher the value the more likely the presence of a single clone is considered | 0.2 | ## Additional parameters ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_combine_counts_fw.md",".md","5234","76","# combine-counts-fw NOTE: This function (formerly called `comBBo`) uses the legacy fixed-width binning described in the HATCHet paper. We recommend using [`count-reads`](doc_count_reads.md) and [`combine-counts`](doc_combine-counts.md) which apply an adaptive binning scheme to ensure that each genomic bin has comparable BAF signal. This step combines the read counts and the allele counts for the identified germline SNPs to compute the read-depth ratio (RDR) and B-allele frequency (BAF) of every genomic bin. ## Input combine-counts-fw takes in input three tab-separate files: 1. A file of read counts for genomic bins obtained from the matched-normal sample, specified by the flag `-c`, `--normalbins`. The tab separated file has the following fields. | Field | Description | |-------|-------------| | `SAMPLE` | Name of the matched-normal sample | | `CHR` | Name of a chromosome | | `START` | Starting genomic position of a genomic bin in `CHR` | | `END` | Ending genomic position of a genomic bin in `CHR` | | `COUNT` | Count of sequencing reads in the corresponding bin | 2. A file of read counts for genomic bins obtained from all the tumor samples, specified by the flag `-C`, `--tumorbins`. The tab separated file has the following fields. | Field | Description | |-------|-------------| | `SAMPLE` | Name of a tumor sample | | `CHR` | Name of a chromosome | | `START` | Starting genomic position of a genomic bin in `CHR` | | `END` | Ending genomic position of a genomic bin in `CHR` | | `COUNT` | Count of sequencing reads in the corresponding bin | 3. A file of allele counts for heterozygous germline SNPs obtained from all the tumor samples, specified by the flag `-B`, `--tumorbafs`. The tab separated file has the following fields. | Field | Description | |-------|-------------| | `SAMPLE` | Name of a tumor sample | | `CHR` | Name of a chromosome | | `POS` | Genomic position corresponding to a heterozygous germline in `CHR` | | `REF_COUNT` | Count of reads covering `POS` with reference allele | | `ALT_COUNT` | Count of reads covering `POS` with alternate allele | ## Output combine-counts-fw produces a tab-separated file with the following fields. | Field | Description | |-------|-------------| | `CHR` | Name of a chromosome | | `START` | Starting genomic position of a genomic bin in `CHR` | | `END` | Ending genomic position of a genomic bin in `CHR` | | `SAMPLE` | Name of a tumor sample | | `RD` | RDR of the bin in `SAMPLE` | | `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | | `COV` | Average coverage in the bin in `SAMPLE` | | `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | | `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | | `BAF` | BAF of the bin in `SAMPLE` | ## Main parameters combine-counts has some main parameters; the main values of these parameters allow to deal with most of datasets, but their values can be changed or tuned to accommodate the features of special datasets. | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-d`, `--diploidbaf` | Maximum expected shift from 0.5 for BAF of diploid or tetraploid clusters | The maximum shift is used to identify all the potential clusters with base states (1, 1) or (2, 2). The value depends on the variance in the data (related to noise and coverage); generally, higher variance requires a higher shift. Information provided by plot-bins can help to decide this value in special datasets. | 0.08 (other typically suggested values are 0.1-0.11 for higher variance and 0.06 for low variance) | ## Optional parameters | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-v`, `--verbose` | Verbose logging flag | When enabled, combine-counts outputs a verbose log of the executiong | Not used | | `-r`, `--disablebar` | Disabling progress-bar flag | When enabled, the output progress bar is disabled | Not used | | `-b`, `--normalbafs` | File of allele counts for SNPs in matched-normal sample | When provided, combine-counts attempts to correct the estimated BAF using the variance in matched-normal sample. | Not used (deprecated) | | `-d`, `--diploidbaf` | Maximum expected shift from 0.5 for BAF of diploid or tetraploid clusters | The maximum shift is used to identify potential potential bins with base states (1, 1) or (2, 2) whose BAF needs to be corrected. The value depends on the variance in the data (related to noise and coverage); generally, higher variance requires a higher shift. Information provided by plot-bins can help to decide this value in special datasets. | 0.08 (other typically suggested values are 0.1-0.11 for higher variance and 0.06 for low variance) | | `-t`, `--totalcounts` | File of total read counts | When provided, the total read counts are used to normalize the read counts from the corresponding sample | Not used (deprecated) | | `-m`, `--mode` | Mode used to estimate BAFs | Different modes are provided to combine to combine the allele counts of SNPs | The counts from the allele with minor count are combined (deprecated) | ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_cluster_bins_gmm.md",".md","6933","86","# cluster-bins-gmm This step globally clusters genomic bins along the entire genome and jointly across tumor samples, and estimate the corresponding values of RDR and BAF for every cluster in every sample. cluster-bins-gmm uses a non-parametric Gaussian mixture model (GMM) (scikit-learn implementation) for clustering; the main parameters can be tuned for dealing with special datasets, especially those with high variance or low tumor purity (see [Main Parameters](#main-parameters) below). ## Input cluster-bins-gmm takes in input a tab-separated file with the following fields. | Field | Description | |-------|-------------| | `CHR` | Name of a chromosome | | `START` | Starting genomic position of a genomic bin in `CHR` | | `END` | Ending genomic position of a genomic bin in `CHR` | | `SAMPLE` | Name of a tumor sample | | `RD` | RDR of the bin in `SAMPLE` | | `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | | `COV` | Average coverage in the bin in `SAMPLE` | | `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | | `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | | `BAF` | BAF of the bin in `SAMPLE` | The fields `#SNPS`, `COV`, `ALPHA`, and `BETA` are currently deprecated and their values are ignored. ## Output cluster-bins-gmm produces two tab-separated files: 1. A file of clustered genomic bins, specified by the flag `-O`, `--outbins`. The tab separated file has the same fields as the input plus a last field `CLUSTER` which specifies the name of the corresponding cluster. 2. A file of clustered genomic bins, specified by the flag `-o`, `--outsegments`. The tab separated file has the following fields. | Field | Description | |-------|-------------| | `ID` | The name of a cluster | | `SAMPLE` | The name of a sample | | `#BINS` | The number of bins included in `ID` | | `RD` | The RDR of the cluster `ID` in `SAMPLE` | | `#SNPS` | The total number of SNPs in the cluster `ID` | | `COV` | The average coverage in the cluster `ID` | | `ALPHA` | The alpha parameter of the binomial model for the BAF of the cluster `ID` | | `BETA` | The beta parameter of the binomial model for the BAF of the cluster `ID` | | `BAF` | The BAF of the cluster `ID` in `SAMPLE` | ## Main parameters cluster-bins-gmm has 4 main features with some main parameters that allow to improve the clustering. 1. cluster-bins-gmm has a parameter `-d`, `--diploidbaf` that specifies the maximum expected shift from 0.5 for BAF for a diploid or tetraploid cluster (i.e. with copy-number states (1, 1) or (2, 2)). This threshold is used for two goals: (1) To identify the diploid or tetraploid cluster which is used to correct the estimated BAF of potentially biased clusters. (2) To identify potentially biased clusters. The default value of this parameter (0.1) is typically sufficient for most of the datasets, but its value can be changed or tuned to accommodate the features of special datasets. In particular, the value of this threshold depends on the variance in the data (related to noise and coverage); generally, higher variance requires a higher shift. Information provided by plot-bins can be crucial to decide whether one needs to change this value in special datasets. 2. cluster-bins-gmm has some main parameters to control the clustering; the default values for most of these parameters allow to deal with most of datasets, but their values can be changed or tuned to accommodate the features of special datasets. plot-bins provides informative plots that can be used to assess the quality of the clustering and evaluate the need of changing some parameters for special datasets. If your clusters do not appear to be cohesive, try lowering the maximum number of clusters (`-K`) which will force cluster-bins-gmm to infer fewer clusters. | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-K`, `--initclusters` | Maximum number of clusters | The parameter specifies the maximum number of clusters to infer, i.e., the maximum number of GMM components | 50 | | `-c`, `--concentration` | Concentration parameter for clustering | This parameter determines how much confidence the GMM has in different types of clusterings. Higher values (e.g., 10 or 100) favor fewer clusters, and smaller values (e.g., 0.01 or 0.001) favor more clusters. For experts, this is the alpha parameter for the Dirichlet process prior. | 1/K | 3. cluster-bins-gmm offers a bootstraping approach that allows a succesfull clustering even when there is a limited number genomic bins that are considred. The bootstraping approach generates sinthetic (i.e. used only for clustering) bins based on the data of the given bins. The bootstraping is controlled by the following parameters. | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-u`, `--bootclustering` | Number of sinthetic bins to generate | Sinthetic bins can be generated based on the RDR and BAF of given bins and are added only to the clustering to improve it when the total number of bins is low (e.g. when considering data from WES) | 0, not used | | `-dR`,`--ratiodeviation` | Standard deviation for generate RDR of sinthetic bins | The parameter affects the variance of the generated data, this value can be estimated from given bins and plot-bins generates informative plots to do this | 0.02 | | `-dB`,`--bafdeviation` | Standard deviation for generate BAF of sinthetic bins | The parameter affects the variance of the generated data, this value can be estimated from given bins and plot-bins generates informative plots to do this | 0.02 | | `-s`, `--seed` | Random seed | The value is used to seed the random generation of RDR and BAF of synthetic bins | 0 | 4. cluster-bins-gmm offers a basic iterative process to merge clusters according to given tolerances. This feature can be used to refine the results of the GMM clustering and merge distinct clusters that are not sufficiently distinguished. This process can be controlled by the following parameters. | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-tR`, `--tolerancerdr` | Tolerance for RDR | The value is used to determine when two clusters should be merged in terms of RDR | 0.0, merging is not performed | | `-tB`, `--tolerancebaf` | Tolerance for BAF | The value is used to determine when two clusters should be merged in terms of BAF | 0.0, merging is not performed | ## Optional parameters | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-v`, `--verbose` | Verbose logging flag | When enabled, combine-counts outputs a verbose log of the executiong | Not used | | `-r`, `--disablebar` | Disabling progress-bar flag | When enabled, the output progress bar is disabled | Not used | ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_plot_cn.md",".md","9226","143","# plot-cn This step analyzes the inferred copy-number states and clone proportions and produces informative plots jointly considering all samples from the same patient. In addition, this step can also combine results obtained for different patients and perform integrative analysis. plot-cn produces several informative plots concerning the copy-number states and proportions for the inferred clones from multiple tumor samples of a patient. In additionl, plot-cn can also produce some informative plots to compare the solutions obtained on different patients. When `plot_cn = True` is indicated in `hatchet.ini`, the command [`plot-cn-1d2d`](plot_cn_1d2d.md) will also be run. This command produces alternate plots in which bins are colored by cluster and colors match across samples between the 2D cluster view and 1D genomic view. In addition, these plots show the expected positions of the assigned copy-number states as labeled points in the 2D plots and black bars in the 1D plots. ## Input plot-cn considers in input one or more tab-separated files. Each of these files contains the inferred copy-number states and clone proportions for clustered genomic bins and has the following format: | Field | Description | |-------|-------------| | `CHR` | Name of a chromosome | | `START` | Starting genomic position of a genomic bin in `CHR` | | `END` | Ending genomic position of a genomic bin in `CHR` | | `SAMPLE` | Name of a tumor sample | | `RD` | RDR of the bin in `SAMPLE` | | `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | | `COV` | Average coverage in the bin in `SAMPLE` | | `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | | `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | | `BAF` | BAF of the bin in `SAMPLE` | | `CLUSTER` | The name of the corresponding cluster of the bin in `SAMPLE` | | `cn_normal` | The copy number state of the normal diploid clone equal to 1|1 | | `u_normal` | The normal admixture of the normal diploid cells in the corresponding sample | | `cn_clone${n}` | The copy number state of the `${n}` tumor clone in the format A|B where `A` and `B` are the two allele-specific copy numbers of the corresponding genomic bin | | `u_clone${n}` | The clone proportion of the `${n}` tumor clone in the corresponding sample | When a single file is speicified, the input is given directly and plot-cn runs in single-patient mode. When multiple files are speicified, the files are given in a white-space separated list of filenames between ""..."" and plot-cn runs in multi-patient mode. ## Parameters | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-x`, `--rundir` | Outpud directory | Directory where the output files are generated | Current directory | | `-n`, `--patientnames` | Names of the patients | White-space separated list of patient names is used when running in multi-patient mode | Inferred from file names | | `-u`, `--minu` | Minimum CNA proportion | A minimum CNA proportion that is used as a minimum threshold to exclude CNA present in lower proportions from the plot | 0.2 | | `-e`, `--threshold` | Tumor ploidy threshold for WGD/no WGD | This is the value of tumor ploidy which is used to determine either the absence or presence of a WGD which determine the basic copy number equal to either 2 or 4 | 3.0 | | `-b`, `--baseCN` | Base copy number | Force base copy number to be equal to this value for determining the grey colors on plots | None, inferred tumor ploidy | | `-sC`, `--figsizeclones` | Size of tumor-clone plots | The size should be given in the format `(X-SIZE, Y-SIZE)` | `(12, 3)` | | `-sP`, `--figsizecn` | Size of copy-number plots | The size should be given in the format `(X-SIZE, Y-SIZE)` | `(16, 4)` | | `-sG`, `--figsizegrid` | Size of grid plots | The size should be given in the format `(X-SIZE, Y-SIZE)` | `(20, 10)` | | `-rC`, `--resolutionclones` | Resolution for tumor-clone plots | Number of bins that are merged together when plotting tumor-clone profiles | 100 | | `-rP`, `--resolutioncn` | Resolution for copy-number plots | Number of bins that are merged together when plotting copy-number profiles | 500 | | `-rG`, `--resolutiongrid` | Resolution for grid plots | Number of bins that are merged together for grid plots | 100 | | `--ymax` | Maximum value in y-axis | Fix the maximum y-axis value | Automatically inferred | | `--ymin` | Minimum value in y-axis | Fix the minimum y-axis value | Automatically inferred | | `--clonepalette` | Name of color palette | Color palette to use for coloring tumor clones among the ones available, including `Set1, Set2, Set3, Paired` | `Set1` | | `--linkage` | Linkage method | The linkage method to use for the clustering of the rows in grdin and tumor-clone plots, including \{single, complete, average, weighted, centroid, median, ward\} from SciPy | single | ## Single-patient (intra-tumor) In the following, we report an example of all the plots produced in single-patient mode obtained by running the following command: python plot_cn.py A12.bbc.ucn -sG ""(16,4)"" *** ### Total copy numbers of tumor clones The total copy number for every genomic region, sorted across chromosomes, with a color identifiying each tumor clone. When the total copy numbers of different clones overlap the same value, the corresponding bars are slightly shifted. ![](intratumor-clones-totalcn.png ""intratumor-clones-totalcn"") *** ### Allele-specific copy numbers of tumor clones The allele-specific copy number for every genomic region, sorted across chromosomes, with a color identifiying each tumor clone. The A-allele is represented in the top part and the B-allele in the bottom part (the negative sign should be ignored). When the allele-specific copy numbers of different clones overlap the same value, the corresponding bars are slightly shifted. ![](intratumor-clones-allelecn.png ""intratumor-clones-allelecn"") *** ### Proportions of total copy numbers per sample For each sample, the proportions across the different total copy numbers are represented for every genomic region. ![](intratumor-copynumber-totalcn-0.png ""intratumor-copynumber-totalcn-0"") ![](intratumor-copynumber-totalcn-1.png ""intratumor-copynumber-totalcn-1"") ![](intratumor-copynumber-totalcn-2.png ""intratumor-copynumber-totalcn-2"") *** ### Proportions of allele-specific copy numbers per sample For each sample, the proportions across the different allele-specific copy numbers are represented for every genomic region. The proportions of A-specific copy numbers are represented in the top part of the plot with positive values, while the proportions of B-specific copy numbers are represented in the bottom part of the plot with negative values. ![](intratumor-copynumber-allelecn-0.png ""intratumor-copynumber-allelecn-0"") ![](intratumor-copynumber-allelecn-1.png ""intratumor-copynumber-allelecn-1"") ![](intratumor-copynumber-allelecn-2.png ""intratumor-copynumber-allelecn-2"") *** ### Copy-number profiles of tumor clones Every row of the main grid corresponds to a tumor clone and the total copy number for each genomic region is represented, such that the regions are sorted across the crhomosomes represented on the top as alternating gray boxes. A heatmap in the left side of the figure represents the clone proprtions across every sample (columns). Also, on the left-most side of the figure a dendogram represents a clustering of the tumor clones. ![](intratumor-profiles.png ""intratumor-profiles"") *** ### Reduced copy-number profiles of tumor clones Every row of the main grid corresponds to a tumor clone and the corredponsing reduced total copy number for each genomic region is represented, such that the regions are sorted across the crhomosomes represented on the top as alternating gray boxes. More specifically, a region is classified as: - 0 when the total copy number is equal to the base - -1 when it corresponds to a deletion (total copy number lower than base) - 1 when it corresponds to an amplification (total copy number higher than base). A heatmap in the left side of the figure represents the clone proprtions across every sample (columns). Also, on the left-most side of the figure a dendogram represents a clustering of the tumor clones. ![](intratumor-profilesreduced.png ""intratumor-profilesreduced"") *** ### Mixture profiles of tumor samples Every row of the main grid corresponds to a tumor sample and the corredponsing reduced-fractional copy number for each genomic region is represented, such that the regions are sorted across the crhomosomes represented on the top as alternating gray boxes. More specifically, the fractional copy number are computed from the mixed profiles. A heatmap in the left side of the figure represents the clone proprtions across every sample (columns). Also, on the left-most side of the figure a dendogram represents a clustering of the tumor samples. ![](intratumor-mixtures.png ""intratumor-mixtures"") *** ### Subclonality This plot is not currently functioning properly. *** ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_genotype_snps.md",".md","3310","43","# genotype-snps Given the normal BAM file, this step of HATCHet identifies heterozygous germline SNP positions. The user can restrict candidate positions to a given list (e.g., dbSNP) using the `-R, --snps` argument. ## Input genotype-snps takes in input a sorted and index BAM file from a matched-normal sample and an indexed human reference genome (preferrably the same version as was used for alignment). | Name | Description | Usage | |------|-------------|-------| | `-N`, `--normal` | A sorted-indexed BAM file | The matched normal sample | | `-r`, `--reference` | A FASTA file | The human reference genome used for germline variant calling | ## Output genotype-snps produces a tab-separated VCF file for each chromosome which contains a list of the genomic positions that have been identified as germline heterozygous SNPs in the matched-normal sample. | Name | Description | Format | |------|-------------|--------| | `-l`, `--outputsnps` | the output file for the list of identified heterozygous germline SNPs | `#CHR POS` | ## Main parameters | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-R`, `--snps` | VCF files | Optional list of candidate SNP positions to consider | None* | | `-st`, `--samtools` | Path to `bin` directory of SAMtools | The path to this direcoty needs to be specified when it is not included in `$PATH` | Path is expected in the enviroment variable `$PATH` | | `-bt`, `--bcftools` | Path to `bin` directory of BCFtools | The path to this direcoty needs to be specified when it is not included in `$PATH` | Path is expected in the enviroment variable `$PATH` | | `-c`, `--mincov` | Minimum coverage | Minimum number of reads that have to cover a variant to be called, the value can be increased when considering a dataset with high depth (>60x) | 0 | | `-C`, `--maxcov` | Maximum coverage | Maximum number of reads that have to cover a variant to be called, the typically suggested value should be twice higher than expected coverage to avoid sequencing and mapping artifacts | 1000 | | `-j`, `--processes` | Number of parallel jobs | Parallel jobs are used to consider the chromosomes in different samples on parallel. The higher the number the better the running time | 2 | *When run as a standalone module, the no SNP list is used by default. When run as part of `hatchet run` and no `--snps` argument is supplied, the correct version of dbSNP is automatically downloaded and used to call SNPs. ## Optional parameters | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-v`, `--verbose` | Verbose logging flag | When enabled, count-alleles outputs a verbose log of the executiong | Not used | | `-q`, `--readquality` | Threshold for phred-score quality of sequencing reads | The value can be either decreased (e.g. 10) or increased (e.g. 30) to adjust the filtering of sequencing reads | 0 | | `-Q`, `--basequality` | Threshold for phred-score quality of sequenced nucleotide bases | The value can be either decreased (e.g. 10) or increased (e.g. 30) to adjust the filtering of sequenced nucleotide bases | 11 | | `-E`,`--newbaq` | Flag to enable `newbaq` veafute of SAMtools | When selected, the user asks SAMtools to recompute alignment of reads on the fly during SNP calling | Not used | ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_compilation.md",".md","1697","34","# Detailed compilation To perform the compilation, execute the following commands from the root of HATCHet's repository. ```shell $ mkdir build $ cd build/ $ ccmake .. $ make ``` HATCHet's compilation process attempts to automatically find the following Gurobi's paths. | Name | Path | Comment | |------|------|---------| | `GUROBI_CPP_LIB` | `/to/gurobiXXX/YY/lib/libgurobi_c++.a` |

`/to/gurobi` is the path to Gurobi's home, typically `/opt/gurobiXXX` for linux and `/Library/gurobiXXX` for mac
`XXX` is the Gurobi full version, e.g. 702 or 751
`YY` depends on os, typically `linux64` for linux or `mac64` for mac

| | `GUROBI_INCLUDE_DIR` | `/to/gurobiXXX/YY/include` |

`/to/gurobi` is the path to Gurobi's home
`XXX` is the Gurobi full version
`YY` depends on os

| | `GUROBI_LIB` | `/to/gurobiXXX/YY/lib/libgurobiZZ.QQ` |

`/to/gurobiXXX` is the path to Gurobi's home
`XXX` is the Gurobi full version
`YY` depends on os
`ZZ` are typically the first 2 numbers of `XXX`
`QQ` is typically `so` but becomes `dylib` for MAC version since version 8.10

| If the automatic compilation fails to find the Gurobi's paths, these need to be specified directly. First, user needs to verify the existence of each of these 3 files. Next, user can specify these paths directly by either using ```shell $ ccmake .. ``` or by directly running `CMake` with proper flags as following ```shell $ cmake .. \ -DGUROBI_CPP_LIB=/to/gurobiXXX/YY/lib/libgurobi_c++.a \ -DGUROBI_INCLUDE_DIR=/to/gurobiXXX/YY/include \ -DGUROBI_LIB=/to/gurobiXXX/YY/lib/libgurobiZZ.QQ ``` ","Markdown" "Allele","raphael-group/hatchet","docs/source/conf.py",".py","3429","112","#!/usr/bin/env python3 # -*- coding: utf-8 -*- # # BSS documentation build configuration file, created by # sphinx-quickstart on Tue May 1 10:26:43 2018. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # import os import sys import sphinx_rtd_theme sys.path.insert(0, os.path.abspath(""../src"")) import hatchet # noqa: E402 # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. # # needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ ""sphinx.ext.autodoc"", ""sphinx.ext.mathjax"", ""sphinxcontrib.bibtex"", ""numpydoc"", ""recommonmark"", ""sphinx_markdown_tables"", ] # Add any paths that contain templates here, relative to this directory. templates_path = [""_templates""] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # # source_suffix = ['.rst', '.md'] # source_suffix = '.rst' # Extra file to copy over to the build directory html_extra_path = [ ""../../script/hatchet.ini"", ""../../custom/GATK4-CNV/sample1.GATK4.CNV.seg"", ""../../custom/GATK4-CNV/sample2.GATK4.CNV.seg"", ""../../custom/GATK4-CNV/custom-gatk4-cnv.sh"", ] # The master toctree document. master_doc = ""index"" # General information about the project. project = ""HATCHet"" copyright = ""2021, Princeton University"" author = ""Simone Zaccaria"" # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = hatchet.__version__ # The full version, including alpha/beta/rc tags. release = version # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # # This is also used if you do content translation via gettext catalogs. # Usually you set ""language"" from the command line for these cases. language = None # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This patterns also effect to html_static_path and html_extra_path exclude_patterns = [] # The name of the Pygments (syntax highlighting) style to use. pygments_style = ""sphinx"" # If true, `todo` and `todoList` produce output, else they produce nothing. todo_include_todos = False # -- Options for HTML output ---------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # html_theme = ""sphinx_rtd_theme"" html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] # -- Options for HTMLHelp output ------------------------------------------ # Output file base name for HTML help builder. htmlhelp_basename = ""hatchet"" autoclass_content = ""both"" ","Python" "Allele","raphael-group/hatchet","docs/source/doc_runhatchet.md",".md","13663","196","# Tutorial This tutorial illustrates how to use the complete pipeline through the `hatchet run` command, along with the configuration [hatchet.ini](hatchet.ini) file that stores all the variables the user needs to specify. The tutorial is subdivided into some subsections and each of these describes sequential parts of the full pipeline: 1. [Preliminaries](#preliminaries) 2. [genotype-snps](#genotype-snps) 3. [count-alleles](#count-alleles) 4. [count-reads](#count-reads) 5. [combine-counts](#combine-counts) 6. [cluster-bins](#cluster-bins) 7. [plot-bins](#plot-bins) 8. [compute-cn](#compute-cn) 9. [plot-cn](#plot-cn) We suggest you make a copy of the configuration file, place it into the designated running directory, and follow the tutorial. ## Preliminaries The following variables, specified in [hatchet.ini](hatchet.ini), should be changed according to the user's data: ```shell # Path to reference genome - make sure you have also generated the reference dictionary as /path/to/reference.dict reference = ""/path/to/reference.fa"" normal = ""/path/to/normal.bam"" # Space-delimited list of tumor BAM locations bams = ""/path/to/tumor1.bam /path/to/tumor2.bam"" # Space-delimited list of tumor names samples = ""Primary Met"" ``` Each of these are explained further below. *** ```shell reference = ""/path/to/reference.fa"" reference_version = """" chr_notation = True ``` First, you need to specify the full path to the human reference genome with the variable `reference`, along with the specific version of this reference with the `reference_version` variable, which may be ""hg19"" or ""hg38"". This reference version is used to select a list of known germline SNPs to genotype samples. Lastly, the `chr_notation` must be set to true/false depending on whether or not the chromosomes in your reference are prefixed with ""chr"". *** ```shell normal = ""/path/to/normal.bam"" bams = ""/path/to/tumor1.bam /path/to/tumor2.bam"" samples = ""Primary Met"" ``` Next, you need to specify the full paths to the required input data: 1. `normal` is the full path to the BAM file of matched-normal samples 2. `bams` is a white-space separated list of the BAM files for the multiple tumor samples from the considered patient. The variable `samples` is also a white-space separated list of tumor sample names (specified in the same order as the BAM files in `bams`), and these names are used in the plots produced by HATCHet. *** ```shell mincov = 8 maxcov = 300 ``` Both `mincov` and `maxcov` specify the minimum and maximum sequencing depth for considering germline snps. For samples that have undergone whole-genome sequencing with depths >30X, values around 8 and 300 should be reasonable for the minimum and maximum, respectively. For samples in which only the exome was sequenced to ~100X, then values around 20 and 1000 should be fine for the minimum and maximum, respectively. *** ## genotype-snps ```shell python3 -m hatchet genotype-snps -N ${NORMAL} -r ${REF} -j ${J} -c ${MINREADS} -C ${MAXREADS} \ -R ${LIST} -o ${SNP} |& tee ${BAF}bafs.log ``` genotype-snps genotypes germline SNPs from the matched-normal sample `${NORMAL}`, using positions of known germline variation specified by the file in `${LIST}`. If this parameter is omitted, heterozygous SNPs are inferred from the normal sample. As mentioned above, SNPs are only considered for downstream analysis if they have a minimum and maximum sequencing depth of `${MINREADS}` and `${MAXREADs}`, respectively. GATK best practices suggest that the maximum should be at least twice the expected average coverage to avoid mapping artifacts. Observe that WES generally requires higher thresholds (e.g. 100 and 3000). Also, an increasing in the minimum threshold allow to improve the quality of the estimated BAF (computed in the next step), while a decreasing it allows us to consider more SNPs. ## [count-alleles](doc_count_alleles.html) ```shell python3 -m hatchet count-alleles -N ${NORMAL} -T ${BAMS} -S ${ALLNAMES} -r ${REF} \ -j ${J} -c ${MINREADS} -C ${MAXREADS} -L ${SNP}*.vcf.gz \ -O ${BAF}normal.1bed -o ${BAF}tumor.1bed |& tee ${BAF}bafs.log ``` count-alleles uses these germline SNPs from genotype-snps (specified in the list `${SNP}*.vcf.gz`) and computes the corresponding allele counts from all tumor samples `${BAMS}`. As for all steps in this pipeline, the same reference genome used for the BAM files has to be specified by `${REF}`. Minimum and maximum thresholds for the read counts of germline SNPs are again specified with `${MINREADS}` and `${MAXREADS}`. Several simple parameters are also specified including: number of parallel threads, output filenames, and the log filename of this step. ## [count-reads](doc_count_reads.html) ```shell python3 -m hatchet count-reads -N ${NORMAL} -T ${BAMS} -S ${ALLNAMES} -b ${BAF}tumor.1bed \ -j ${J} -O ${RDR}normal.1bed -O {RDR} -V {REF_VERSION} |& tee ${RDR}bins.log ``` `count-reads` identifies candidate bin thresholds using the SNPs identified by `count_alleles` (in `${BAF}tumor.1bed `), and counts the number of reads in each tumor sample `${BAMS}` as well as in the normal sample `{$NORMAL}` that fall within each interval as well as the number of reads overlapping each threshold. It uses the centromere locations corresponding the the reference genome version `${REF_VERSION}` (hg19 or hg38) to avoid constructing bins that overlap centromeres. This step produces a gzip-compressed file for each chromosome and each sample in the `${RDR}` directory, as well as an ordered list `${RDR}samples.txt` of sample labels. It also counts the total reads in each of the BAM files and writes it to `${RDR}total.tsv`. Other simple parameters are also specified including number of parallel threads, output filenames, and the log filename of this step. ## [combine-counts](doc_combine_counts.html) ```shell python3 -m hatchet combine-counts -A ${RDR} -t ${RDR}total.tsv -b {BAF}tumor.1bed -o #{BB}bulk.bb \ --msr ${msr} --mtr ${mtr} -j ${J} \ -p ${PHASE} -s ${max_blocksize} -m {max_spb} -a {alpha} # optional phasing args ``` combine-counts constructs genomic bins such that in all samples, each bin has at least `${msr}` SNP-covering reads and at least `${mtr}` total reads. Bins will not have the same width, but using this rule each bin will have comparable RDR and BAF signals for the following clustering steps. The BAF for each bin and the relative phase of all SNPs in the bin are inferred via EM, and the RDR for each bin is computed fom the read count files in the `${RDR}` folder. After this computation, RDR values are normalized using the total reads in each sample (from `${RDR}total.tsv`). As with other HATCHet commands, `-j ${J}` controls the number of parallel processes. See the [script](script/README.md) directory for a guide on how to run HATCHet with phasing. If a phased VCF file is supplied via `-p, --phase ${PHASE}` (e.g., `-p phase/phased.vcf.gz`), SNPs are merged into blocks before BAF inference. Each block contains at most `${max_spb}` such that no two SNPs in the same block are further apart than `${max_blocksize}`, and such that no two adjacent SNPs have significantly different marginal BAF estimates (at significance level `${alpha}` -- higher `${alpha}` corresponds to less trust in the phasing results). Then, blocks are passed to the EM which determines the relative phase of each block. ## [cluster-bins](doc_cluster_bins.html) ```shell python3 -m hatchet cluster-bins ${BB}bulk.bb -o ${BBC}bulk.seg -O ${BBC}bulk.bbc \ -minK 5 -maxK 10 -tau 0.0001 -d 0.08 ``` cluster-bins globally clusters genomic bins based on RDR and BAF (specified in a BB file `${BB}bulk.bb`) jointly along the genome and across all tumor samples. This *locality-aware* clustering takes into account the contiguity of bins along the genome to inform the clustering. The main parameters are as follows: - The maximum expected BAF shift `-d` for a balanced cluster, here set to `0.08`. This parameter should be as small as possible while still including the clusters with the closest BAF to 0.5. - Parameters `minK` and `maxK` which specify the minimum and maximum (respectively) of clusters to consider. Alternatively, one can specify `exactK` to fix the number of clusters at a given value. - Parameter `tau` which controls the trade-off between local and global information: lower `tau` puts more weight on *local* information (i.e., adjacent bins on each chromosome arm) while higher `tau` puts more weight on *global* information (i.e., RDR and BAF values). The plots from `plot-bins` are helpful to evaluate clusterings and tune parameters. Other parameters are used to specify the output files containing the cluster information (`${BBC}bulk.seg`) and the clustered genomic bins (`${BBC}bulk.bbc`). ## [plot-bins](doc_plot_bins.html) ```shell cd ${PLO} python3 -m hatchet plot-bins -c RD --figsize 6,3 ../${BBC}bulk.bbc python3 -m hatchet plot-bins -c CRD --figsize 6,3 ../${BBC}bulk.bbc python3 -m hatchet plot-bins -c BAF --figsize 6,3 ../${BBC}bulk.bbc python3 -m hatchet plot-bins -c BB ../${BBC}bulk.bbc python3 -m hatchet plot-bins -c CBB ../${BBC}bulk.bbc -tS 0.01 ``` plot-bins produces informative plots which are described [here](doc_plot_bins.md). Many of these plots can be very useful to assess the performance of the various steps of HATCHet, especially in the case of noisy datasets. ## [compute-cn](doc_compute_cn.html) ```shell cd ../${RES} python3 -m hatchet compute-cn -i ../${BBC}bulk -n2,6 -p 400 -u 0.03 \ -r ${RANDOM} -j ${J} -eD 6 -eT 12 -g 0.35 \ -l 0.6 &> >(tee >(grep -v Progress > hatchet.log)) ``` compute-cn computes the fractional copy numbers, factorizes these into allele and clone-specific copy numbers and clone proportions, and applies a model-selection step to jointly infer the number of clones and predict a whole-genome duplication (WGD). This step requires the common prefix `${BBC}bulk` of the cluster and clustered bins files. Some basic parameter include: - the interval `2,6` specifying the minimum and maximum number of clones which can be increased as much as wanted. User can start to use this interval and increasing if the number of clones appear to be higher or close to the maximum. - the number of restarts `400` for the coordinate-descent method. This value is typically enough to obtain a good solution close to the optimum, however an increase in this value allows to improve the search of a solution. This can be useful when observing a number of clusters significantly higher than usual. - Random initializing seed with `${RANDOM}`. - Number of parallel threads `${J}` There are also some important parameters which need to be tuned for special or noisy datasets. The details of these parameters are the following: - Maximum copy number without a WGD `-eD` and with a WGD `-eT`. The specified values are typically enough to obtain the copy numbers of large CNAs. While higher values increase the number of reasonable solutions, the values can be increased to investigate the presence of large genomic regions with higher copy numbers. In particular, when the value `0` is specified, then the maximum copy numbers are automatically chosen from the fractional copynumbers. - Minimum clone proportion `-u`. The value depends on the power to identify tumor clones present in samples at low tumor proportions. The default value is reasonable for most of the datasets, but datasets with high noise may need higher values to avoid overfitting. We thus suggest, especially in these special cases, to repeat the hatchet step by considering increasing values of this parameter up to a maximum or until clone proportions are different from this threshold. - Two parameters are used to control the elbow method during model selection to choose the best solution. The user should repeat this step with different values of these parameters, especially when one wants to investigate the presence of a single tumor clone or the presence of more tumor clones with small different CNAs and small clone proportions. These two parameters are the following: - Confidence in the presence of a single tumor clone `g`. This value determines the confidence in having a single tumor clone in several of the given samples. The user can investigate the hypothesis that a single tumor clone is present by increasing the confidence, e.g. using values of `0.4, 0.5, ...`. Vice versa, the confidence is lowered by decreasing these values. For example, one can do that to investigate the presence of tumor clones with small CNAs or small proportions. - Sensitivity `l`. This value determines the sensitivity of the method. Lower values correspond to higher sensitivities which allow to consider solutions with a higher number of clones. The user can decrease this value for investigating the presence of more tumor clones, especially tumor clones with small different CNAs or present in small proportions. ## [plot-cn](doc_plot_cn.html) ```shell cd ../${SUM} python3 -m hatchet plot-cn ../${RES}/best.bbc.ucn ``` plot-cn produces informative and summary plots for the inferred results. Examples and details of these plots are reported [here](doc_plot_cn.md). ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_download_panel.md",".md","2287","31","# download-panel This step of HATCHet downloads the 1000 genomes reference panel to phase germline mutations. It also downloads and creates other files necessary for phasing when the user has aligned their reads to a version of the human reference genome that is not the same as the version used in the 1000 genomes project (which was hg19, with no 'chr' prefix preceding chromosome names). **Note:** This step requires access to the internet in order to download files. This step only needs to be run once per system. ## Input `download-panel` takes no input files and the following options: | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-D`, `--refpaneldir` | Path to the Reference Panel | This is the location where the 1000 genome project reference panel will be downloaded | None | `-R`, `--refpanel` | Reference Panel to use; only 1000 genomes project currently supported | specify ""1000GP_Phase3"" to automatically download and use the panel from the 1000 genomes project | ""1000GP_Phase3"" ## Output download-panel populates the directory `-D, --refpaneldir` with several files for phasing germline SNPs, and for performing liftover in situations when the reference genome used to align sequencing reads is different from the reference genome version used in the reference panel. | Name | Description | |------|-------------| | 1000GP_Phase3 | Directory containing reference panel of haplotypes for phasing mutations, in HAP/LEGEND/SAMPLE format | | hg19_no_chr.fa | hg19 reference genome, chromosomes named without ""chr"" prefix | | hg19_no_chr.dict | Sequence dictionary for the hg19 reference genome | | hg38ToHg19.chr.chain | Chain file for liftover, going from hg38 to hg19 coordinates | | hg38ToHg19.no_chr.chain | Chain file for liftover, going from hg38 to hg19 coordinates, where hg38 chromosomes are named without ""chr"" prefix | | hg19ToHg38.chr.chain | Chain file for liftover, going from hg19 to hg38 | | hg19ToHg38.no_chr.chain | Chain file for liftover, going form hg19 to hg38, where hg38 chromosomes are named without ""chr"" prefix | | rename_chrs1.txt | File for renaming chromosomes with bcftools, removing the ""chr"" prefix | | rename_chrs2.txt | File for renaming chromosomes with bcftools, adding the ""chr"" prefix | ","Markdown" "Allele","raphael-group/hatchet","docs/source/doc_plot_cn_1d2d.md",".md","3386","42","# plot-cn-1d2d This step produces alternate plots that show bins in terms of their computed read-depth ratios (RDR), B-allele frequencies (BAF), and assigned copy-number states. These plots show bins colored by cluster, where the color is consistent between the ""2D"" (RDR x BAF) view and the ""1D"" (genomic location x RDR/BAF) view. Additionally, the labeled points in the 2D plots and the black bars in the 1D plots show the *expected* positions of the assigned copy-number states (determined by the mixture proportions and fractional copy number scaling). These indicators can be used to evaluate the consistency of the HATCHet solution. When `plot_cn = True` is indicated in `hatchet.ini`, both this command and the command [plot-cn](doc_plot_cn.md) will be run. These plots should be used to review the results of the copy-number assignment step [compute_cn](doc_compute_cn.md) and tune its parameters. They are most useful when there are few samples - when there are many samples, the visualizations from `plot-cn` may be more interpretable. ## Input plot-bins requires a single tab-separated file as input. This file (e.g., `best.bbc.ucn`, `results.diploid.n3.bbc.ucn.tsv`, ...) is typically produced by [compute_cn](doc_compute_cn.md) and contains the following fields: | Field | Description | |-------|-------------| | `CHR` | Name of a chromosome | | `START` | Starting genomic position of a genomic bin in `CHR` | | `END` | Ending genomic position of a genomic bin in `CHR` | | `SAMPLE` | Name of a tumor sample | | `RD` | RDR of the bin in `SAMPLE` | | `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | | `COV` | Average coverage in the bin in `SAMPLE` | | `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | | `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | | `BAF` | BAF of the bin in `SAMPLE` | | `CLUSTER` | The name of the corresponding cluster of the bin in `SAMPLE` | | `cn_normal` | The copy number state of the normal diploid clone equal to 1|1 | | `u_normal` | The normal admixture of the normal diploid cells in the corresponding sample | | `cn_clone${n}` | The copy number state of the `${n}` tumor clone in the format A|B where `A` and `B` are the two allele-specific copy numbers of the corresponding genomic bin | | `u_clone${n}` | The clone proportion of the `${n}` tumor clone in the corresponding sample | ## Parameters | Name | Description | Usage | Default | |------|-------------|-------|---------| | `-O`, `--outdir` | Output directory | Directory in which output plots will be stored | """" (current directory) | | `--baflim` | Axis limits for mirrored BAF | Specify limits as comma-separated values, e.g., '0,0.51' | None (determined by extremes of data) | | `--fcnlim` | Axis limits for fractional copy numbers | Specify limits as comma-separated values, e.g., '0,3' | None (determined by extremes of data) | | `--centromeres` | Mark centromere locations with grey rectangles | Enable by including this flag with no argument. | False | | `--bysample` | Split plots into distinct sample-specific files (instead of grouping all 1D plots together and all 2D plots together) | Enable by including this flag with no argument. | False | ","Markdown" "Allele","raphael-group/hatchet","tests/test_steps.py",".py","8580","330","import sys from io import StringIO import pytest import os import glob import gzip import hashlib from mock import patch import shutil import pickle import pandas as pd from pandas.testing import assert_frame_equal from hatchet import config from hatchet.utils import ArgParsing from hatchet.utils.count_reads_fw import main as count_reads from hatchet.utils.genotype_snps import main as genotype_snps from hatchet.utils.count_alleles import counting from hatchet.utils.combine_counts_fw import main as combine_counts from hatchet.utils.cluster_bins_gmm import main as cluster_bins_gmm from hatchet.utils.plot_bins import main as plot_bins from hatchet.bin.HATCHet import main as main from hatchet.utils.plot_cn import main as plot_cn from hatchet.utils.solve import solver_available this_dir = os.path.dirname(__file__) @pytest.fixture(scope=""module"") def bams(): bam_directory = config.tests.bam_directory normal_bam = os.path.join(bam_directory, ""normal.bam"") if not os.path.exists(normal_bam): pytest.skip( ""File not found: {}"".format(os.path.join(bam_directory, ""normal.bam"")) ) tumor_bams = sorted( [ f for f in glob.glob(bam_directory + ""/*.bam"") if os.path.basename(f) != ""normal.bam"" ] ) if not tumor_bams: pytest.skip(""No tumor bams found in {}"".format(bam_directory)) return normal_bam, tumor_bams @pytest.fixture(scope=""module"") def normal_snps(): with open(f""{this_dir}/data/fw/snps/normal_snps.pik"", ""rb"") as f: return pickle.load(f) @pytest.fixture(scope=""module"") def output_folder(): out = os.path.join(this_dir, ""out"") shutil.rmtree(out, ignore_errors=True) for sub_folder in ( ""bin"", ""snps"", ""baf"", ""bb"", ""bbc"", ""plots"", ""results"", ""evaluation"", ""analysis"", ): os.makedirs(os.path.join(out, sub_folder)) return out @pytest.mark.skipif(not config.paths.reference, reason=""paths.reference not set"") @patch(""hatchet.utils.ArgParsing.extractChromosomes"", return_value=[""chr22""]) @patch( ""hatchet.utils.count_reads_fw.knownRegions"", return_value={""chr22"": [(30256931, 32622323)]}, ) def test_count_reads(_mock0, _mock1, bams, output_folder): normal_bam, tumor_bams = bams count_reads( args=[""-N"", normal_bam, ""-T""] + tumor_bams + [ ""-b"", ""50kb"", ""-st"", config.paths.samtools, ""-S"", ""Normal"", ""Tumor1"", ""Tumor2"", ""Tumor3"", ""-g"", config.paths.reference, ""-j"", ""12"", ""-q"", ""11"", ""-O"", os.path.join(output_folder, ""bin/normal.1bed""), ""-o"", os.path.join(output_folder, ""bin/bulk.1bed""), ""-v"", ] ) df1 = pd.read_csv(f""{output_folder}/bin/normal.1bed"", sep=""\t"") df2 = pd.read_csv(f""{this_dir}/data/fw/bin/normal.1bed"", sep=""\t"") assert_frame_equal(df1, df2) df1 = pd.read_csv(f""{output_folder}/bin/bulk.1bed"", sep=""\t"") df2 = pd.read_csv(f""{this_dir}/data/fw/bin/bulk.1bed"", sep=""\t"") assert_frame_equal(df1, df2) @pytest.mark.skipif(not config.paths.reference, reason=""paths.reference not set"") @patch( ""hatchet.utils.ArgParsing.extractChromosomes"", return_value=[""chr22:30256931-32622323""], ) def test_genotype_snps(_mock1, bams, output_folder): normal_bam, _ = bams genotype_snps( args=[ ""-N"", normal_bam, ""-r"", config.paths.reference, ""-c"", ""0"", # min reads ""-C"", ""300"", # max reads ""-o"", f""{output_folder}/snps"", ""-st"", config.paths.samtools, ""-bt"", config.paths.bcftools, ""-j"", ""12"", ] ) with gzip.open(f""{output_folder}/snps/chr22:30256931-32622323.vcf.gz"", ""rb"") as f: # ignore commented lines since these may have timestamps and software version numbers etc. lines = ""\n"".join( [ line for line in f.read().decode(""utf8"").split(""\n"") if not line.startswith(""#"") ] ) assert ( hashlib.md5(lines.encode(""utf8"")).hexdigest() == ""3d81c51d21c22334ce1fc069cb005328"" ) @patch( ""hatchet.utils.ArgParsing.extractChromosomes"", return_value=[""chr22:30256931-32622323""], ) def test_count_alleles_normal_snps(_mock1, bams, normal_snps, output_folder): normal_bam, tumor_bams = bams args = ( [""-N"", normal_bam, ""-T""] + tumor_bams + [ ""-S"", ""Normal"", ""Tumor1"", ""Tumor2"", ""Tumor3"", ""-r"", config.paths.reference, ""-j"", ""12"", ""-q"", ""3"", ""-Q"", ""3"", ""-U"", ""3"", ""-c"", ""8"", ""-C"", ""300"", ""-O"", f""{output_folder}/baf/normal.1bed"", ""-o"", f""{output_folder}/baf/bulk.1bed"", ""-L"", f""{this_dir}/data/fw/snps/chr22:30256931-32622323.vcf.gz"", ] ) args = ArgParsing.parse_count_alleles_arguments(args) snps = counting( bcftools=args[""bcftools""], reference=args[""reference""], samples=[args[""normal""]], chromosomes=args[""chromosomes""], num_workers=args[""j""], snplist=args[""snps""], q=args[""q""], Q=args[""Q""], mincov=args[""mincov""], dp=args[""maxcov""], E=args[""E""], verbose=False, outdir=args[""outputSnps""], ) assert snps == normal_snps def test_combine_counts(output_folder): _stdout = sys.stdout sys.stdout = StringIO() combine_counts( args=[ ""-c"", f""{this_dir}/data/fw/bin/normal.1bed"", ""-C"", f""{this_dir}/data/fw/bin/bulk.1bed"", ""-B"", f""{this_dir}/data/fw/baf/bulk.1bed"", ""-e"", ""12"", ] ) out = sys.stdout.getvalue() sys.stdout.close() sys.stdout = _stdout with open(f""{this_dir}/data/fw/bb/bulk.bb"", ""r"") as f: assert out == f.read() def test_cluster_bins_gmm(output_folder): cluster_bins_gmm( args=[ f""{this_dir}/data/fw/bb/bulk.bb"", ""-o"", f""{output_folder}/bbc/bulk.seg"", ""-O"", f""{output_folder}/bbc/bulk.bbc"", ""-e"", ""22171"", # random seed ""-tB"", ""0.04"", ""-tR"", ""0.15"", ""-d"", ""0.4"", ""-K"", ""20"", ] ) df1 = pd.read_csv(f""{output_folder}/bbc/bulk.seg"", sep=""\t"") df2 = pd.read_csv(f""{this_dir}/data/fw/bbc/bulk.seg"", sep=""\t"") assert_frame_equal(df1, df2) def test_plot_bins(output_folder): # We simply check if we're able to run plot_bins without exceptions plot_bins( args=[ os.path.join(f""{this_dir}/data/fw/bbc/bulk.bbc""), ""--rundir"", os.path.join(output_folder, ""plots""), ] ) def test_compute_cn(output_folder): if solver_available(): main( args=[ ""-x"", f""{output_folder}/results"", ""-i"", f""{this_dir}/data/fw/bbc/bulk"", ""-n2"", ""-p"", ""100"", ""-v"", ""3"", ""-u"", ""0.03"", ""-r"", ""6700"", # random seed ""-j"", ""8"", ""-eD"", ""6"", ""-eT"", ""12"", ""-g"", ""0.35"", ""-l"", ""0.6"", ] ) df1 = pd.read_csv(f""{output_folder}/results/best.bbc.ucn"", sep=""\t"") df2 = pd.read_csv(f""{this_dir}/data/fw/results/best.bbc.ucn"", sep=""\t"") assert_frame_equal(df1, df2) def test_plot_cn(output_folder): # We simply check if we're able to run plot_cn without exceptions plot_cn( args=[ f""{this_dir}/data/fw/results/best.bbc.ucn"", ""--rundir"", f""{output_folder}/evaluation"", ] ) ","Python" "Allele","raphael-group/hatchet","tests/test_steps_vw.py",".py","6665","217","import os import glob from mock import patch import shutil import pandas as pd from pandas.testing import assert_frame_equal from numpy.testing import assert_array_equal import numpy as np import pytest from hatchet import config from hatchet.utils.count_reads import main as count_reads from hatchet.utils.cluster_bins import main as cluster_bins from hatchet.utils.combine_counts import main as combine_counts this_dir = os.path.dirname(__file__) @pytest.fixture(scope=""module"") def bams(): bam_directory = config.tests.bam_directory normal_bam = os.path.join(bam_directory, ""normal.bam"") if not os.path.exists(normal_bam): pytest.skip(""File not found: {}/{}"".format(bam_directory, normal_bam)) tumor_bams = sorted( [ f for f in glob.glob(bam_directory + ""/*.bam"") if os.path.basename(f) != ""normal.bam"" ] ) if not tumor_bams: pytest.skip(""No tumor bams found in {}"".format(bam_directory)) return normal_bam, tumor_bams @pytest.fixture(scope=""module"") def output_folder(): out = os.path.join(this_dir, ""out"", ""vw"") shutil.rmtree(out, ignore_errors=True) for sub_folder in [""rdr"", ""bb"", ""bbc""]: os.makedirs(os.path.join(out, sub_folder)) return out @patch(""hatchet.utils.ArgParsing.extractChromosomes"", return_value=[""chr22""]) def test_count_reads(_, bams, output_folder): normal_bam, tumor_bams = bams count_reads( args=[""-N"", normal_bam, ""-T""] + tumor_bams + [ ""-st"", config.paths.samtools, ""-S"", ""Normal"", ""Tumor1"", ""Tumor2"", ""Tumor3"", ""-j"", ""1"", ""-b"", os.path.join(this_dir, ""data"", ""vw"", ""baf"", ""bulk.1bed""), ""-O"", os.path.join(output_folder, ""rdr""), ""-V"", ""hg19"", ] ) arr1 = np.loadtxt(os.path.join(output_folder, ""rdr"", ""chr22.thresholds.gz"")) arr2 = np.loadtxt(os.path.join(output_folder, ""rdr"", ""chr22.total.gz"")) arr3 = [l for l in open(os.path.join(output_folder, ""rdr"", ""samples.txt""), ""r"")] arr4 = pd.read_table(os.path.join(output_folder, ""rdr"", ""total.tsv"")) truth1 = np.loadtxt( os.path.join(this_dir, ""data"", ""vw"", ""rdr"", ""chr22.thresholds.gz"") ) truth2 = np.loadtxt(os.path.join(this_dir, ""data"", ""vw"", ""rdr"", ""chr22.total.gz"")) truth3 = [ l for l in open(os.path.join(this_dir, ""data"", ""vw"", ""rdr"", ""samples.txt""), ""r"") ] truth4 = pd.read_table(os.path.join(this_dir, ""data"", ""vw"", ""rdr"", ""total.tsv"")) assert_array_equal(arr1, truth1) assert_array_equal(arr2, truth2) assert len(arr3) == len(truth3) and all( [arr3[i] == truth3[i] for i in range(len(truth3))] ) assert_frame_equal(arr4, truth4) @pytest.mark.skipif(not config.paths.reference, reason=""paths.reference not set"") @patch(""hatchet.utils.ArgParsing.extractChromosomes"", return_value=[""chr22""]) def test_combine_counts(_, output_folder): # Test without phasing combine_counts( args=[ ""-A"", os.path.join(this_dir, ""data"", ""vw"", ""rdr""), ""-t"", os.path.join(this_dir, ""data"", ""vw"", ""rdr"", ""total.tsv""), ""-j"", ""1"", ""-b"", os.path.join(this_dir, ""data"", ""vw"", ""baf"", ""bulk.1bed""), ""-o"", os.path.join(output_folder, ""bb"", ""bulk_nophase.bb""), ""-r"", config.paths.reference, ""-V"", ""hg19"", ] ) df1 = pd.read_csv(os.path.join(output_folder, ""bb"", ""bulk_nophase.bb""), sep=""\t"") df2 = pd.read_csv( os.path.join(this_dir, ""data"", ""vw"", ""bb"", ""bulk_nophase.bb""), sep=""\t"" ) assert_frame_equal(df1, df2) @pytest.mark.skipif(not config.paths.reference, reason=""paths.reference not set"") @patch(""hatchet.utils.ArgParsing.extractChromosomes"", return_value=[""chr22""]) def test_combine_counts_phasing(_, output_folder): # Test with phasing combine_counts( args=[ ""-A"", os.path.join(this_dir, ""data"", ""vw"", ""rdr""), ""-t"", os.path.join(this_dir, ""data"", ""vw"", ""rdr"", ""total.tsv""), ""-j"", ""1"", ""-b"", os.path.join(this_dir, ""data"", ""vw"", ""baf"", ""bulk.1bed""), ""-o"", os.path.join(output_folder, ""bb"", ""bulk_yesphase.bb""), ""-V"", ""hg19"", ""-r"", config.paths.reference, ""-p"", os.path.join(this_dir, ""data"", ""vw"", ""phase"", ""phased.vcf.gz""), ] ) df3 = pd.read_csv(os.path.join(output_folder, ""bb"", ""bulk_yesphase.bb""), sep=""\t"") df4 = pd.read_csv( os.path.join(this_dir, ""data"", ""vw"", ""bb"", ""bulk_yesphase.bb""), sep=""\t"", ) assert_frame_equal(df3, df4) def test_cluster_bins(output_folder): cluster_bins( args=[ f""{this_dir}/data/fw/bb/bulk.bb"", ""-o"", f""{output_folder}/bbc/bulk.seg"", ""-O"", f""{output_folder}/bbc/bulk.bbc"", ""--transmat"", ""diag"", ""--covar"", ""diag"", ""--minK"", ""2"", ""--maxK"", ""10"", ] ) seg1 = pd.read_csv(os.path.join(output_folder, ""bbc"", ""bulk.seg""), sep=""\t"") bbc1 = pd.read_csv(os.path.join(output_folder, ""bbc"", ""bulk.bbc""), sep=""\t"") seg2 = pd.read_csv( os.path.join(this_dir, ""data"", ""vw"", ""bbc"", ""bulk.seg""), sep=""\t"" ) bbc2 = pd.read_csv( os.path.join(this_dir, ""data"", ""vw"", ""bbc"", ""bulk.bbc""), sep=""\t"" ) assert_frame_equal(seg1, seg2) assert_frame_equal(bbc1, bbc2) def test_cluster_bins_singleton(output_folder): cluster_bins( args=[ f""{this_dir}/data/fw/bb/bulk.bb"", ""-o"", f""{output_folder}/bbc/bulk_onecl.seg"", ""-O"", f""{output_folder}/bbc/bulk_onecl.bbc"", ""--transmat"", ""diag"", ""--covar"", ""diag"", ""--exactK"", ""1"", ] ) seg1 = pd.read_csv(os.path.join(output_folder, ""bbc"", ""bulk_onecl.seg""), sep=""\t"") bbc1 = pd.read_csv(os.path.join(output_folder, ""bbc"", ""bulk_onecl.bbc""), sep=""\t"") seg2 = pd.read_csv( os.path.join(this_dir, ""data"", ""vw"", ""bbc"", ""bulk_onecl.seg""), sep=""\t"" ) bbc2 = pd.read_csv( os.path.join(this_dir, ""data"", ""vw"", ""bbc"", ""bulk_onecl.bbc""), sep=""\t"" ) assert_frame_equal(seg1, seg2) assert_frame_equal(bbc1, bbc2) ","Python" "Allele","raphael-group/hatchet","tests/test_config.py",".py","104","6","from hatchet import config def test_config_reference(): assert config.paths.reference is not None ","Python" "Allele","raphael-group/hatchet","tests/test_phase.py",".py","1341","55","import pytest import os from mock import patch import shutil import pandas as pd from pandas.testing import assert_frame_equal import hatchet # noqa: F401 from hatchet import config from hatchet.utils.phase_snps import main as phase_snps from hatchet.utils.download_panel import main as download_panel this_dir = os.path.dirname(__file__) @pytest.fixture(scope=""module"") def output_folder(): out = os.path.join(this_dir, ""out"", ""vw"", ""phase"") shutil.rmtree(out, ignore_errors=True) os.makedirs(out, exist_ok=True) return out @patch(""hatchet.utils.ArgParsing.extractChromosomes"", return_value=[""chr22""]) def test_script(_, output_folder): download_panel( args=[ ""-R"", ""1000GP_Phase3"", ] ) phase_snps( args=[ ""-g"", config.paths.reference, ""-V"", ""hg19"", ""-N"", ""-o"", os.path.join(output_folder, ""phase""), ""-L"", os.path.join(this_dir, ""data"", ""vw"", ""snps"", ""chr22.vcf.gz""), ] ) df1 = pd.read_table( os.path.join(output_folder, ""phase"", ""phased.vcf.gz""), comment=""#"" ) df2 = pd.read_table( os.path.join(this_dir, ""data"", ""vw"", ""phase"", ""phased.vcf.gz""), comment=""#"", ) assert_frame_equal(df1, df2) ","Python" "Allele","raphael-group/hatchet","tests/test_solver.py",".py","5229","222","import os import subprocess import pytest import pandas as pd from pandas.testing import assert_frame_equal import hatchet from hatchet.bin.HATCHet import main as main from hatchet import config from hatchet.utils.solve import solver_available this_dir = os.path.dirname(__file__) DATA_FOLDER = os.path.join(this_dir, ""data"", ""fw"") SOLVE = os.path.join(os.path.dirname(hatchet.__file__), ""solve"") @pytest.fixture(scope=""module"") def output_folder(): out = os.path.join(this_dir, ""out"", ""solver"") os.makedirs(out, exist_ok=True) return out @pytest.mark.skipif( os.getenv(""GRB_LICENSE_FILE"") is None, reason=""No license for Gurobi found"" ) def test_solve_binary(): cmd = [SOLVE, os.path.join(DATA_FOLDER, ""bulk"")] # -M 1 for ILP solve mode cmd.extend( [_x for _x in ""-f -e 6 -p 400 -u 0.03 -r 6700 -M 1 -v 2 -c 5:1:1 -n 2"".split()] ) print("" "".join(cmd)) p = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, ) p.communicate() assert p.returncode == 0 @pytest.mark.skipif( os.getenv(""GRB_LICENSE_FILE"") is None, reason=""No license for Gurobi found"" ) def test_solve_command_cpp(output_folder): old_value = config.compute_cn.solver config.compute_cn.solver = ""cpp"" main( args=[ ""-x"", os.path.join(output_folder), ""-i"", os.path.join(this_dir, ""data/fw/bulk""), ""-n2"", ""-p"", ""400"", ""-v"", ""3"", ""-u"", ""0.03"", ""--mode"", ""1"", ""-r"", ""6700"", ""-j"", ""8"", ""-eD"", ""6"", ""-eT"", ""12"", ""-g"", ""0.35"", ""-l"", ""0.6"", ] ) df1 = pd.read_csv(os.path.join(output_folder, ""best.bbc.ucn""), sep=""\t"") df2 = pd.read_csv(os.path.join(this_dir, ""data"", ""fw"", ""best.bbc.ucn""), sep=""\t"") assert_frame_equal(df1, df2) config.compute_cn.solver = old_value @pytest.mark.skipif( not solver_available(""gurobipy""), reason=""gurobipy solver not available for pyomo"", ) def test_solve_command_gurobipy(output_folder): old_value = config.compute_cn.solver config.compute_cn.solver = ""gurobipy"" main( args=[ ""-x"", os.path.join(output_folder), ""-i"", os.path.join(this_dir, ""data/fw/bulk""), ""-n2"", ""-p"", ""400"", ""-v"", ""3"", ""-u"", ""0.03"", ""--mode"", ""1"", ""-r"", ""6700"", ""-j"", ""8"", ""-eD"", ""6"", ""-eT"", ""12"", ""-g"", ""0.35"", ""-l"", ""0.6"", ] ) df1 = pd.read_csv(os.path.join(output_folder, ""best.bbc.ucn""), sep=""\t"") df2 = pd.read_csv(os.path.join(this_dir, ""data"", ""fw"", ""best.bbc.ucn""), sep=""\t"") assert_frame_equal(df1, df2) config.compute_cn.solver = old_value @pytest.mark.skipif( not solver_available(""gurobi""), reason=""gurobi solver not available for pyomo"", ) def test_solve_command_gurobi(output_folder): old_value = config.compute_cn.solver config.compute_cn.solver = ""gurobi"" main( args=[ ""-x"", os.path.join(output_folder), ""-i"", os.path.join(this_dir, ""data/fw/bulk""), ""-n2"", ""-p"", ""400"", ""-v"", ""3"", ""-u"", ""0.03"", ""--mode"", ""1"", ""-r"", ""6700"", ""-j"", ""8"", ""-eD"", ""6"", ""-eT"", ""12"", ""-g"", ""0.35"", ""-l"", ""0.6"", ] ) df1 = pd.read_csv(os.path.join(output_folder, ""best.bbc.ucn""), sep=""\t"") df2 = pd.read_csv(os.path.join(this_dir, ""data"", ""fw"", ""best.bbc.ucn""), sep=""\t"") assert_frame_equal(df1, df2) config.compute_cn.solver = old_value @pytest.mark.skipif( not solver_available(""cbc""), reason=""cbc solver not available for pyomo"" ) def test_solve_command_cbc(output_folder): old_value = config.compute_cn.solver config.compute_cn.solver = ""cbc"" main( args=[ ""-x"", os.path.join(output_folder), ""-i"", os.path.join(this_dir, ""data/fw/bulk""), ""-n2"", ""-p"", ""400"", ""-v"", ""3"", ""-u"", ""0.03"", ""--mode"", ""1"", ""-r"", ""6700"", ""-j"", ""8"", ""-eD"", ""6"", ""-eT"", ""12"", ""-g"", ""0.35"", ""-l"", ""0.6"", ] ) df1 = pd.read_csv(os.path.join(output_folder, ""best.bbc.ucn""), sep=""\t"") df2 = pd.read_csv(os.path.join(this_dir, ""data"", ""fw"", ""best.bbc.ucn""), sep=""\t"") assert_frame_equal(df1, df2) config.compute_cn.solver = old_value ","Python" "Allele","ZhaotongL/MVMR-cML","LICENSE.md",".md","1071","22","# MIT License Copyright (c) 2023 Zhaotong Lin Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ","Markdown" "Allele","ZhaotongL/MVMR-cML","src/RcppExports.cpp",".cpp","3675","64","// Generated by using Rcpp::compileAttributes() -> do not edit by hand // Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 #include #include using namespace Rcpp; #ifdef RCPP_USE_GLOBAL_ROSTREAM Rcpp::Rostream& Rcpp::Rcout = Rcpp::Rcpp_cout_get(); Rcpp::Rostream& Rcpp::Rcerr = Rcpp::Rcpp_cerr_get(); #endif // MVmr_cML Rcpp::List MVmr_cML(const arma::mat& b_exp, const arma::mat& b_out, const arma::mat& se_bx, const Rcpp::List& Sig_inv_l, const unsigned int n, Rcpp::NumericVector K_vec, const unsigned int random_start, const unsigned int maxit, const double thres); RcppExport SEXP _MVMRcML_MVmr_cML(SEXP b_expSEXP, SEXP b_outSEXP, SEXP se_bxSEXP, SEXP Sig_inv_lSEXP, SEXP nSEXP, SEXP K_vecSEXP, SEXP random_startSEXP, SEXP maxitSEXP, SEXP thresSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const arma::mat& >::type b_exp(b_expSEXP); Rcpp::traits::input_parameter< const arma::mat& >::type b_out(b_outSEXP); Rcpp::traits::input_parameter< const arma::mat& >::type se_bx(se_bxSEXP); Rcpp::traits::input_parameter< const Rcpp::List& >::type Sig_inv_l(Sig_inv_lSEXP); Rcpp::traits::input_parameter< const unsigned int >::type n(nSEXP); Rcpp::traits::input_parameter< Rcpp::NumericVector >::type K_vec(K_vecSEXP); Rcpp::traits::input_parameter< const unsigned int >::type random_start(random_startSEXP); Rcpp::traits::input_parameter< const unsigned int >::type maxit(maxitSEXP); Rcpp::traits::input_parameter< const double >::type thres(thresSEXP); rcpp_result_gen = Rcpp::wrap(MVmr_cML(b_exp, b_out, se_bx, Sig_inv_l, n, K_vec, random_start, maxit, thres)); return rcpp_result_gen; END_RCPP } // MVmr_cML_DP Rcpp::List MVmr_cML_DP(const arma::mat& b_exp, const arma::mat& b_out, const arma::mat& se_bx, const Rcpp::List& Sig_inv_l, const unsigned int n, Rcpp::NumericVector K_vec, const unsigned int random_start, const unsigned int num_pert, const unsigned int maxit, const double thres); RcppExport SEXP _MVMRcML_MVmr_cML_DP(SEXP b_expSEXP, SEXP b_outSEXP, SEXP se_bxSEXP, SEXP Sig_inv_lSEXP, SEXP nSEXP, SEXP K_vecSEXP, SEXP random_startSEXP, SEXP num_pertSEXP, SEXP maxitSEXP, SEXP thresSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const arma::mat& >::type b_exp(b_expSEXP); Rcpp::traits::input_parameter< const arma::mat& >::type b_out(b_outSEXP); Rcpp::traits::input_parameter< const arma::mat& >::type se_bx(se_bxSEXP); Rcpp::traits::input_parameter< const Rcpp::List& >::type Sig_inv_l(Sig_inv_lSEXP); Rcpp::traits::input_parameter< const unsigned int >::type n(nSEXP); Rcpp::traits::input_parameter< Rcpp::NumericVector >::type K_vec(K_vecSEXP); Rcpp::traits::input_parameter< const unsigned int >::type random_start(random_startSEXP); Rcpp::traits::input_parameter< const unsigned int >::type num_pert(num_pertSEXP); Rcpp::traits::input_parameter< const unsigned int >::type maxit(maxitSEXP); Rcpp::traits::input_parameter< const double >::type thres(thresSEXP); rcpp_result_gen = Rcpp::wrap(MVmr_cML_DP(b_exp, b_out, se_bx, Sig_inv_l, n, K_vec, random_start, num_pert, maxit, thres)); return rcpp_result_gen; END_RCPP } static const R_CallMethodDef CallEntries[] = { {""_MVMRcML_MVmr_cML"", (DL_FUNC) &_MVMRcML_MVmr_cML, 9}, {""_MVMRcML_MVmr_cML_DP"", (DL_FUNC) &_MVMRcML_MVmr_cML_DP, 10}, {NULL, NULL, 0} }; RcppExport void R_init_MVMRcML(DllInfo *dll) { R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); R_useDynamicSymbols(dll, FALSE); } ","C++" "Allele","ZhaotongL/MVMR-cML","src/mvmr.cpp",".cpp","14380","374","#include // [[Rcpp::depends(RcppArmadillo)]] // [[Rcpp::plugins(openmp)]] using namespace Rcpp; using namespace arma; double l_i_c(const arma::vec& b_exp_i, const arma::vec& b_out_i, const arma::mat& Sig_inv_i, const arma::vec& b_t_i, const arma::vec& theta_t, const arma::vec& r_vec_t_i) { arma::vec beta = arma::join_vert(b_exp_i, b_out_i); arma::vec bvec = arma::join_vert(b_t_i, dot(theta_t, b_t_i) + r_vec_t_i); double l = - 1.0/2.0 * arma::as_scalar((beta-bvec).t() * Sig_inv_i * (beta-bvec)); return l; } double loglik_c(const arma::mat& b_exp, const arma::mat& b_out, const Rcpp::List& Sig_inv_l, const arma::mat& b_t, const arma::vec& theta_t, const arma::vec& r_vec_t){ int p = b_exp.n_rows; arma::vec l_i_vec(p); for(unsigned int i=0; i < p; ++i){ l_i_vec(i) = l_i_c(b_exp.row(i).t(),b_out.row(i), Sig_inv_l[i],b_t.row(i).t(),theta_t,r_vec_t.row(i)); } double l = sum(l_i_vec); return l; } Rcpp::List WK_func(const Rcpp::List& Sig_inv_l) { const int p = Sig_inv_l.length(), L = as(Sig_inv_l[0]).n_rows; arma::mat WK1mat(p,L); arma::vec WK1vec(p); for(unsigned int i = 0; i < p; i++){ WK1mat.row(i) = as(Sig_inv_l[i]).row(L-1); WK1vec(i) = as(Sig_inv_l[i])(L-1,L-1); } return Rcpp::List::create(Rcpp::Named(""WK1vec"") = WK1vec, Rcpp::Named(""WK1mat"") = WK1mat); } arma::mat mvrnormArma(int n, arma::vec mu, arma::mat sigma) { int ncols = sigma.n_cols; arma::mat Y = arma::randn(n, ncols); return arma::repmat(mu, 1, n).t() + Y * arma::chol(sigma); } Rcpp::List MVcML_estimate_c(const arma::mat& b_exp, const arma::mat& b_out, const Rcpp::List& Sig_inv_l, const arma::vec& WK1vec, const arma::mat& WK1mat, const unsigned int K, const arma::vec& initial_theta, const arma::mat& initial_mu, const unsigned int maxit = 100, const double thres = 1e-4) { // initialize const int p = b_exp.n_rows, k = b_exp.n_cols; arma::vec theta = initial_theta, theta_old = theta -1; arma::mat mu_vec = initial_mu; arma::vec v_importance(p), v_bg(p), beta_star_i, B; arma::mat r_t(p,1); arma::mat A, temp, beta_star; unsigned int ite_ind; // for (ite_ind = 0; ite_ind < maxit && sum(abs(theta - theta_old)) > thres; ++ite_ind){ theta_old = theta; if (K > 0) { A = arma::eye(p,p); A.diag() = 1 / WK1vec; beta_star = arma::join_horiz(b_exp-mu_vec,b_out-(mu_vec * theta)); temp = WK1mat * beta_star.t(); B = temp.diag(); r_t = A * B; for(unsigned int i = 0; i < p; ++i){ double l_r = l_i_c(b_exp.row(i).t(), b_out.row(i), Sig_inv_l[i], mu_vec.row(i).t(), theta, r_t.row(i)); double l_r0 = l_i_c(b_exp.row(i).t(), b_out.row(i), Sig_inv_l[i], mu_vec.row(i).t(), theta, zeros(1,1)); v_importance(i) = l_r-l_r0; } arma::uvec nonzero_bg_ind = sort_index(v_importance, ""descend""); v_bg = arma::zeros(p); v_bg(nonzero_bg_ind.head(K)) = r_t(nonzero_bg_ind.head(K)); } else{ v_bg = arma::zeros(p); } arma::mat theta_cp = theta * theta.t(); for(unsigned int i = 0; i < p; ++i){ beta_star_i = arma::join_vert(b_exp.row(i).t(), b_out.row(i) - v_bg.row(i)); arma::mat W_i = Sig_inv_l[i]; B = W_i.rows(0, k-1) * beta_star_i + arma::as_scalar(W_i.row(k) * beta_star_i) * theta; A = W_i(span(0,k-1), span(0,k-1)) + arma::as_scalar(W_i(k,k)) * theta_cp + W_i(span(0,k-1),k) * theta.t() + theta * W_i(k,span(0,k-1)); mu_vec.row(i) = solve(A,B).t(); } A = zeros(k,k); B = zeros(k); for(unsigned int i = 0; i < p; ++i){ arma::mat W_i = Sig_inv_l[i]; A = A + arma::as_scalar(W_i(k,k)) * mu_vec.row(i).t() * mu_vec.row(i); beta_star_i = arma::join_vert(b_exp.row(i).t()-mu_vec.row(i).t(),b_out.row(i)-v_bg.row(i)); B = B + arma::as_scalar(W_i.row(k) * beta_star_i) * mu_vec.row(i).t(); } theta = solve(A,B); } bool Conv = (ite_ind >= maxit); double Neg_l = -loglik_c(b_exp,b_out,Sig_inv_l,mu_vec, theta,v_bg); return Rcpp::List::create(Rcpp::Named(""theta"") = theta, Rcpp::Named(""b_vec"") = mu_vec, Rcpp::Named(""r_vec"") = v_bg, Rcpp::Named(""l"") = Neg_l, Rcpp::Named(""Converge"") = Conv); } Rcpp::List MVcML_estimate_random_c(const arma::mat& b_exp, const arma::mat& b_out, const arma::mat& se_bx, const Rcpp::List& Sig_inv_l, const arma::vec& WK1vec, const arma::mat& WK1mat, const unsigned int K, const unsigned int n, const unsigned int random_start = 1, const unsigned int maxit = 100, const double thres = 1e-4) { // min_theta_range = min(b_out/b_exp) // max_theta_range = max(b_out/b_exp) // initialize const int p = b_exp.n_rows, k = b_exp.n_cols; arma::mat theta_v_RandomCandidate(k,random_start), invalid_RandomCandidate(p,random_start); arma::vec l_v_RandomCandidate(random_start), Conv_v_RandomCandidate(random_start); arma::vec initial_theta(k); arma::mat initial_mu(p,k); for(unsigned int random_ind = 0; random_ind < random_start; ++random_ind) { if(random_ind == 0) { initial_theta = zeros(k); // initial_mu = zeros(p,k); initial_mu = b_exp; } else { initial_theta = runif(k, -0.5, 0.5); // TO-DO: option to change initial value for theta arma::mat b_rand; b_rand = Rcpp::rnorm(p*k,0.0,1.0); b_rand.reshape(size(b_exp)); initial_mu = b_exp + b_rand % se_bx; // initial_mu = zeros(p,k); } Rcpp::List MLE_result = MVcML_estimate_c(b_exp,b_out, Sig_inv_l,WK1vec,WK1mat, K,initial_theta, initial_mu, maxit, thres); double Neg_l = -loglik_c(b_exp,b_out,Sig_inv_l,MLE_result[""b_vec""], MLE_result[""theta""],MLE_result[""r_vec""]); theta_v_RandomCandidate.col(random_ind) = as(MLE_result[""theta""]); l_v_RandomCandidate(random_ind) = Neg_l; Conv_v_RandomCandidate(random_ind) = as(MLE_result[""Converge""]); invalid_RandomCandidate.col(random_ind) = as(MLE_result[""r_vec""]); } uvec q1 = find(Conv_v_RandomCandidate == 0); if (q1.n_elem == 0){ return Rcpp::List::create(Rcpp::Named(""Converge"") = 1); } int min_neg_l = l_v_RandomCandidate(q1).eval().index_min(); arma::vec theta_est = theta_v_RandomCandidate.cols(q1).eval().col(min_neg_l); double l_est = (l_v_RandomCandidate(q1).eval())(min_neg_l); arma::vec r_est = invalid_RandomCandidate.cols(q1).eval().col(min_neg_l); return Rcpp::List::create(Rcpp::Named(""theta"") = theta_est, Rcpp::Named(""l"") = l_est, Rcpp::Named(""r_vec"") = r_est, Rcpp::Named(""Converge"") = 0); } //' MVMRcML method with BIC selection //' //' This is the main function of MVMR-cML. //' //' @param b_exp A m*L matrix of SNP effects on the exposure variable. //' @param b_out A m*1 matrix of SNP effects on the outcome variable. //' @param se_bx A m*L matrix of standard errors of \code{b_exp}. //' @param Sig_inv_l A list of the inverse of m covariance matrices, generated by \code{invcov_mvmr()}. //' @param n The smallest sample size of the L+1 GWAS dataset. //' @param K_vec Sets of candidate K's, the constraint parameter representing number of invalid IVs. //' @param random_start Number of random start points, default is 1. //' @param maxit Maximum number of iterations for each optimization, default is 100. //' @param thres Threshold for convergence criterion. //' //' @import Rcpp //' @import RcppArmadillo //' @return A list //' \describe{ //' \item{BIC_theta}{Estimated causal effect from MVMR-cML-BIC} //' \item{BIC_invalid}{Invalid IVs selected by MVMR-cML-BIC} //' \item{K_vec}{K_vec to be searched from} //' \item{Converge}{0 if converge; 1 otherwise} //' \item{BIC_vec}{BIC vector corresponding to K_vec} //' } //' //' @export // [[Rcpp::export]] Rcpp::List MVmr_cML(const arma::mat& b_exp, const arma::mat& b_out, const arma::mat& se_bx, const Rcpp::List& Sig_inv_l, const unsigned int n, Rcpp::NumericVector K_vec = Rcpp::NumericVector::create(), const unsigned int random_start = 1, const unsigned int maxit = 100, const double thres = 1e-4) { //initialize const int p = b_exp.n_rows, L = b_exp.n_cols; arma::vec K_vec1; if(K_vec.size() == 0){ K_vec1 = linspace(0, p - L - 1, p - L); }else{ K_vec1 = as(K_vec); } arma::vec WK1vec = as(WK_func(Sig_inv_l)[""WK1vec""]); arma::mat WK1mat = as(WK_func(Sig_inv_l)[""WK1mat""]); const int K_vec_len = K_vec1.n_elem; arma::mat rand_theta(L,K_vec_len), invalid_mat(p,K_vec_len); arma::vec rand_l(K_vec_len), Conv_l(K_vec_len), BIC_vec; for(unsigned int i=0; i < K_vec_len; ++i) { int K_value = K_vec1(i); Rcpp::List rand_res = MVcML_estimate_random_c(b_exp,b_out,se_bx,Sig_inv_l, WK1vec, WK1mat, K_value, n, random_start, maxit,thres); if(as(rand_res[""Converge""]) == 1){ Conv_l(i) = 1; continue; } rand_theta.col(i) = as(rand_res[""theta""]); rand_l(i)= rand_res[""l""]; Conv_l(i) = 0; invalid_mat.col(i) = as(rand_res[""r_vec""]); } uvec q1 = find(Conv_l == 0); if(q1.n_elem==0){ return Rcpp::List::create(Rcpp::Named(""Converge"") = 1); } BIC_vec = log(n) * K_vec1(q1) + 2 * rand_l(q1); // cML-BIC unsigned int min_ind = BIC_vec.index_min(); uvec BIC_invalid = arma::find(invalid_mat.cols(q1).eval().col(min_ind)); arma::vec BIC_theta = rand_theta.cols(q1).eval().col(min_ind); Rcpp::List res; res[""BIC_theta""] = BIC_theta; res[""BIC_invalid""] = BIC_invalid + 1; res[""l_vec""] = rand_l; res[""K_vec""] = K_vec1; res[""theta_vec""] = rand_theta; res[""Conv_vec""] = Conv_l; res[""Converge""] = 0; res[""BIC_vec""] = BIC_vec; return res; } //' MVMRcML method with Data Perturbation //' //' This is the main function of MVMR-cML. //' //' @param b_exp A m*L matrix of SNP effects on the exposure variable. //' @param b_out A m*1 matrix of SNP effects on the outcome variable. //' @param se_bx A m*L matrix of standard errors of \code{b_exp}. //' @param Sig_inv_l A list of the inverse of m covariance matrices, generated by \code{invcov_mvmr()}. //' @param n The smallest sample size of the L+1 GWAS dataset. //' @param K_vec Sets of candidate K's, the constraint parameter representing number of invalid IVs. //' @param random_start Number of random start points, default is 1. //' @param num_pert Number of perturbation, default is 100. //' @param maxit Maximum number of iterations for each optimization, default is 100. //' @param thres Threshold for convergence criterion. //' //' @import Rcpp //' @import RcppArmadillo //' @return A list //' \describe{ //' \item{BIC_theta}{Estimated causal effect from MVMR-cML-BIC} //' \item{BIC_invalid}{Invalid IVs selected by MVMR-cML-BIC} //' \item{BIC_DP_theta}{Estimated causal effect from MVMR-cML-DP } //' \item{BIC_DP_se}{Estimate standard error for \code{BIC_DP_theta}} //' \item{eff_DP_B}{Data perturbation with successful convergence} //' } //' //' @export // [[Rcpp::export]] Rcpp::List MVmr_cML_DP(const arma::mat& b_exp, const arma::mat& b_out, const arma::mat& se_bx, const Rcpp::List& Sig_inv_l, const unsigned int n, Rcpp::NumericVector K_vec = Rcpp::NumericVector::create(), const unsigned int random_start = 1, const unsigned int num_pert = 100, const unsigned int maxit = 100, const double thres = 1e-4) { //initialize const int p = b_exp.n_rows, L = b_exp.n_cols; arma::vec K_vec1; arma::mat theta_v(L,num_pert); Rcpp::List cML_res = MVmr_cML(b_exp, b_out, se_bx, Sig_inv_l, n, K_vec, random_start, maxit, thres); arma::mat b_exp_new(size(b_exp)), b_out_new(size(b_out)); arma::vec theta_b, Conv_v(num_pert); for(unsigned int pt_ind = 0; pt_ind < num_pert; ++pt_ind) { for(unsigned int i = 0; i < p; ++i) { arma::mat sig = arma::inv(as(Sig_inv_l[i])); arma::mat epis = mvrnormArma(1, zeros(L+1), sig); b_exp_new.row(i) = b_exp.row(i) + epis.head_cols(L); b_out_new.row(i) = b_out.row(i) + epis.col(L); } Rcpp::List cML_res_b = MVmr_cML(b_exp_new, b_out_new, se_bx, Sig_inv_l, n, K_vec, random_start, maxit, thres); if(as(cML_res_b[""Converge""])==1){ Conv_v(pt_ind) = 1; continue; } theta_b = as(cML_res_b[""BIC_theta""]); theta_v.col(pt_ind) = theta_b; Conv_v(pt_ind) = 0; } uvec q1 = find(Conv_v == 0); // cML-BIC-DP arma::vec BIC_DP_theta = mean(theta_v.cols(q1).eval(), 1); arma::vec BIC_DP_se = stddev(theta_v.cols(q1).eval(), 0, 1); Rcpp::List res; res[""BIC_theta""] = cML_res[""BIC_theta""]; res[""BIC_invalid""] = cML_res[""BIC_invalid""]; res[""BIC_DP_theta""] = BIC_DP_theta; res[""BIC_DP_se""] = BIC_DP_se; res[""eff_DP_B""] = q1.n_elem; return res; } // You can include R code blocks in C++ files processed with sourceCpp // (useful for testing and development). The R code will be automatically // run after the compilation. ","C++" "Allele","ZhaotongL/MVMR-cML","R/MVMRcML.R",".R","2671","75","#' Profile likelihood of valid IVs #' #' calculate the profile likelihood of valid IVs up to a constant #' #' @keywords internal #' pl <- function(x,b_exp_v,b_out_v,Sig_inv_v){ k = ncol(b_exp_v) m_valid = length(b_out_v) pll = 0 for(i in 1:m_valid){ W = Sig_inv_v[[i]] b_exp_i = b_exp_v[i,] b_out_i = b_out_v[i] beta = c(b_exp_i,b_out_i) B = W[-(k+1),] %*% beta + c(W[(k+1),] %*% beta) * x A = W[-(k+1),-(k+1)] + W[-(k+1),k+1] %*% t(x) + x %*% t(W[k+1,-(k+1)]) + W[k+1,k+1] * x %*% t(x) bhat_xi = solve(A) %*% B b_i = c(bhat_xi,t(bhat_xi) %*% x) pll = pll -1/2 * t(b_i) %*% W %*% b_i + t(beta) %*% W %*% b_i } return(-pll) } #' Generate the list of inverse of covariance matrices used in \code{MVMR-cML-DP} #' #' @param se_bx A m*L matrix of standard errors of SNP-exposure association #' @param se_by A vector of standard errors of SNP-outcome association #' @param rho_mat A (L+1)\eqn{\times}(L+1) correlation matrix among the L exposures and the outcome, note that the upper-left L\eqn{\times}L submatrix corresponding to the L exposures. #' @return A list of inverse of covariance matrices with respect to each genetic variant, retaining the ordering in \code{se_bx} #' #' @export #' invcov_mvmr <- function(se_bx, se_by, rho_mat){ Sig_l = Sig_inv_l = list() m = nrow(se_bx) for(i in 1:m){ Sig = rho_mat*crossprod(t(c(se_bx[i,],se_by[i]))) Sig_l[[i]] = Sig Sig_inv_l[[i]] = solve(Sig) } return(Sig_inv_l) } #' Standard error estimate for MVMR-cML-BIC #' #' This is based on the profile likelihood of the set of valid IVs, which is not robust to uncertainty in model selection. #' #' @param b_exp A matrix of SNP effects on the exposure variable. #' @param b_out A vector of SNP effects on the outcome variable. #' @param Sig_inv_l A list of inverse of covariance matrix. #' @param theta A vector of final estimates of causal effect of each exposure by MVMR-cML-BIC obtained from \code{MVmr_cML_DP}. #' @param zero_ind A vector of the index of valid IVs. #' @param r_vec A vector of estimated horizontal pleiotropic effects. #' #' #' @import numDeriv #' @return A vector #' #' @export #' MVcML_SdTheta <- function(b_exp,b_out,Sig_inv_l,theta,zero_ind,r_vec=NULL){ if(!is.null(r_vec)){ zero_ind = which(r_vec==0) } H = hessian(pl,x=theta,b_exp_v = b_exp[zero_ind,,drop=FALSE], b_out_v=b_out[zero_ind],Sig_inv_v =Sig_inv_l[zero_ind]) se_theta = sqrt(diag(solve(H))) # ores = optim(theta,pl,method = 'BFGS',b_exp_v=b_exp[zero_ind,],b_out_v=b_out[zero_ind],Sig_inv_v= Sig_inv_l[zero_ind], # hessian = TRUE) # sqrt(diag(solve(ores$hessian))) return(se_theta) } ","R" "Allele","ZhaotongL/MVMR-cML","R/RcppExports.R",".R","3033","65","# Generated by using Rcpp::compileAttributes() -> do not edit by hand # Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 #' MVMRcML method with BIC selection #' #' This is the main function of MVMR-cML. #' #' @param b_exp A m*L matrix of SNP effects on the exposure variable. #' @param b_out A m*1 matrix of SNP effects on the outcome variable. #' @param se_bx A m*L matrix of standard errors of \code{b_exp}. #' @param Sig_inv_l A list of the inverse of m covariance matrices, generated by \code{invcov_mvmr()}. #' @param n The smallest sample size of the L+1 GWAS dataset. #' @param K_vec Sets of candidate K's, the constraint parameter representing number of invalid IVs. #' @param random_start Number of random start points, default is 1. #' @param maxit Maximum number of iterations for each optimization, default is 100. #' @param thres Threshold for convergence criterion. #' #' @import Rcpp #' @import RcppArmadillo #' @return A list #' \describe{ #' \item{BIC_theta}{Estimated causal effect from MVMR-cML-BIC} #' \item{BIC_invalid}{Invalid IVs selected by MVMR-cML-BIC} #' \item{K_vec}{K_vec to be searched from} #' \item{Converge}{0 if converge; 1 otherwise} #' \item{BIC_vec}{BIC vector corresponding to K_vec} #' } #' #' @export MVmr_cML <- function(b_exp, b_out, se_bx, Sig_inv_l, n, K_vec = as.numeric( c()), random_start = 1L, maxit = 100L, thres = 1e-4) { .Call('_MVMRcML_MVmr_cML', PACKAGE = 'MVMRcML', b_exp, b_out, se_bx, Sig_inv_l, n, K_vec, random_start, maxit, thres) } #' MVMRcML method with Data Perturbation #' #' This is the main function of MVMR-cML. #' #' @param b_exp A m*L matrix of SNP effects on the exposure variable. #' @param b_out A m*1 matrix of SNP effects on the outcome variable. #' @param se_bx A m*L matrix of standard errors of \code{b_exp}. #' @param Sig_inv_l A list of the inverse of m covariance matrices, generated by \code{invcov_mvmr()}. #' @param n The smallest sample size of the L+1 GWAS dataset. #' @param K_vec Sets of candidate K's, the constraint parameter representing number of invalid IVs. #' @param random_start Number of random start points, default is 1. #' @param num_pert Number of perturbation, default is 100. #' @param maxit Maximum number of iterations for each optimization, default is 100. #' @param thres Threshold for convergence criterion. #' #' @import Rcpp #' @import RcppArmadillo #' @return A list #' \describe{ #' \item{BIC_theta}{Estimated causal effect from MVMR-cML-BIC} #' \item{BIC_invalid}{Invalid IVs selected by MVMR-cML-BIC} #' \item{BIC_DP_theta}{Estimated causal effect from MVMR-cML-DP } #' \item{BIC_DP_se}{Estimate standard error for \code{BIC_DP_theta}} #' \item{eff_DP_B}{Data perturbation with successful convergence} #' } #' #' @export MVmr_cML_DP <- function(b_exp, b_out, se_bx, Sig_inv_l, n, K_vec = as.numeric( c()), random_start = 1L, num_pert = 100L, maxit = 100L, thres = 1e-4) { .Call('_MVMRcML_MVmr_cML_DP', PACKAGE = 'MVMRcML', b_exp, b_out, se_bx, Sig_inv_l, n, K_vec, random_start, num_pert, maxit, thres) } ","R" "Allele","Sendrowski/fastDFE","CITATION.md",".md","443","14","```bibtex @article{fastdfe, author = {Sendrowski, Janek and Bataillon, Thomas}, title = {fastDFE: fast and flexible inference of the distribution of fitness effects}, journal = {Molecular Biology and Evolution}, publisher = {Oxford University Press}, pages = {msae070}, year = {2024}, month = {04}, issn = {1537-1719}, doi = {10.1093/molbev/msae070}, url = {https://doi.org/10.1093/molbev/msae070} } ```","Markdown" "Allele","Sendrowski/fastDFE","testing/test_optimization.py",".py","19052","574","import logging from typing import Literal, List import matplotlib.pyplot as plt import numpy as np from numpy import testing from fastdfe.optimization import pack_params, unpack_params, flatten_dict, unflatten_dict, filter_dict, Optimization, \ merge_dicts, correct_values, to_symlog, from_symlog, scale_bound, scale_value, unscale_value, unscale_bound, \ check_bounds, perturb_value, collapse_fixed_to_mean, collapse_fixed from testing import TestCase class OptimizationTestCase(TestCase): """""" Test the Optimization class. """""" def test_pack_unpack_restores_dict(self): """""" Check whether the parameters can be restored from packed format. """""" params = { 'all': {'S_d': -400.0, 'b': 0.4, 'p_b': 0.02, 'S_b': 4.0, 'eps': 0.05}, 'sub': {'S_d': -399.0, 'b': 0.39, 'p_b': 0.12, 'S_b': 4.1, 'eps': 0.02}, } restored = unpack_params(pack_params(params), params) self.assertDictEqual(params, restored) def test_flatten_dict(self): """""" Test that flatten_dict works as expected. """""" d = {'a': 1, 'b': {'c': 2, 'd': {'e': 3}}} expected = {'a': 1, 'b.c': 2, 'b.d.e': 3} assert flatten_dict(d) == expected d = {'a': {'b': {'c': 1}}} expected = {'a.b.c': 1} assert flatten_dict(d) == expected def test_unflatten_dict(self): """""" Test that unflatten_dict works as expected. """""" d = {'a': 1, 'b.c': 2, 'b.d.e': 3} expected = {'a': 1, 'b': {'c': 2, 'd': {'e': 3}}} assert unflatten_dict(d) == expected d = {'a.b.c': 1} expected = {'a': {'b': {'c': 1}}} assert unflatten_dict(d) == expected def test_flatten_unflatten_dict(self): """""" Test that flatten_dict and unflatten_dict are inverse operations. """""" d = {'a': 1, 'b': {'c': 2, 'd': {'e': 3}}} expected = d flattened = flatten_dict(d) unflattened = unflatten_dict(flattened) assert unflattened == expected def test_filter_dict(self): """""" Test that filter_dict works as expected. """""" d = {'a': 1, 'b': {'c': 2, 'd': {'e': 3, 'f': {'g': 4}}}, 'c': {'g': 1, 'b': 2}} keys = ['a', 'c'] expected = {'a': 1, 'b': {'c': 2}} assert filter_dict(d, keys) == expected def test_sample_x0_nested_dict(self): """""" Test that sample_x0 works as expected when the initial parameters are a nested dict. """""" x0 = {'a': 1, 'b': {'c': 2, 'd': 4}} o = Optimization( bounds={'a': (2, 2), 'b': (0, 0), 'c': (-1, -1), 'd': (4, 4)}, scales={'a': 'lin', 'b': 'lin', 'c': 'lin', 'd': 'lin'}, param_names=['a', 'b', 'c', 'd'] ) sample = o.sample_x0(x0) expected = {'a': 2.0, 'b': {'c': -1.0, 'd': 4.0}} assert sample == expected def test_merge_dicts(self): """""" Test that merge_dicts works as expected. """""" dict1 = {'a': 1, 'b': {'c': 2, 'd': 3}} dict2 = {'b': {'d': 4, 'e': 5}, 'f': 6} expected_result = {'a': 1, 'b': {'c': 2, 'd': 4, 'e': 5}, 'f': 6} assert merge_dicts(dict1, dict2) == expected_result dict3 = {'a': {'b': 1, 'c': {'d': 2, 'e': {'f': 3}}}} dict4 = {'a': {'b': 4, 'c': {'d': 5, 'e': {'g': 6}}}} expected_result2 = {'a': {'b': 4, 'c': {'d': 5, 'e': {'f': 3, 'g': 6}}}} assert merge_dicts(dict3, dict4) == expected_result2 dict5 = {'a': 1, 'b': {'c': 2}} dict6 = {'b': {'c': 3}, 'd': 4} expected_result3 = {'a': 1, 'b': {'c': 3}, 'd': 4} assert merge_dicts(dict5, dict6) == expected_result3 dict7 = {'a': 1} dict8 = {'b': 2} expected_result4 = {'a': 1, 'b': 2} assert merge_dicts(dict7, dict8) == expected_result4 def test_positive_bounds(self): """""" Test that ValueError is raised when bounds are positive. """""" bounds = (1, 10) scale = 'lin' for _ in range(100): sample = Optimization.sample_value(bounds, scale) self.assertGreaterEqual(sample, bounds[0]) self.assertLessEqual(sample, bounds[1]) def test_negative_bounds(self): """""" Test that ValueError is raised when bounds are negative. """""" bounds = (-10, -1) scale = 'lin' for _ in range(100): sample = Optimization.sample_value(bounds, scale) self.assertGreaterEqual(sample, bounds[0]) self.assertLessEqual(sample, bounds[1]) def test_mixed_bounds(self): """""" Test that ValueError is raised when bounds are mixed. """""" bounds = (-5, 5) scale = 'lin' for _ in range(100): sample = Optimization.sample_value(bounds, scale) self.assertGreaterEqual(sample, bounds[0]) self.assertLessEqual(sample, bounds[1]) def test_positive_bounds_log_scale(self): """""" Test that ValueError is raised when bounds are positive and scale is log. """""" bounds = (1, 10) scale = 'log' for _ in range(100): sample = Optimization.sample_value(bounds, scale) self.assertGreaterEqual(sample, bounds[0]) self.assertLessEqual(sample, bounds[1]) def test_negative_bounds_log_scale(self): """""" Test that ValueError is raised when bounds are negative and scale is log. """""" bounds = (-10, -1) scale = 'log' for _ in range(100): sample = Optimization.sample_value(bounds, scale) self.assertGreaterEqual(sample, bounds[0]) self.assertLessEqual(sample, bounds[1]) def test_mixed_bounds_log_scale(self): """""" Test that ValueError is raised when bounds are mixed and scale is log. """""" bounds = (-5, 5) scale = 'log' with self.assertRaises(ValueError): Optimization.sample_value(bounds, scale) def test_correct_values_no_changes(self): """""" Test that values are not changed when they are within bounds. """""" params = {""a.a"": 2, ""a.b"": 5, ""a.c"": 10} bounds = {""a"": (1, 3), ""b"": (4, 6), ""c"": (8, 12)} scales = {""a"": ""lin"", ""b"": ""lin"", ""c"": ""lin""} expected = params.copy() actual = correct_values(params, bounds, scales) self.assertEqual(expected, actual) def test_correct_values_corrections(self): """""" Test that values are corrected when they are out of bounds. """""" params = {""a.a"": 0, ""a.b"": 7, ""a.c"": 20} bounds = {""a"": (1, 3), ""b"": (4, 6), ""c"": (8, 12)} scales = {""a"": ""lin"", ""b"": ""lin"", ""c"": ""lin""} expected = {""a.a"": 1, ""a.b"": 6, ""a.c"": 12} actual = correct_values(params, bounds, scales) self.assertEqual(expected, actual) def test_correct_values_threshold_warning(self): """""" Test that a warning is raised when the threshold is exceeded. """""" params = {""a.a"": 0, ""a.b"": 7, ""a.c"": 20} bounds = {""a"": (1, 3), ""b"": (4, 6), ""c"": (8, 12)} scales = {""a"": ""lin"", ""b"": ""lin"", ""c"": ""lin""} with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe')): correct_values(params, bounds, scales, warn=True, threshold=0.05) def test_symlog_scale(self): """""" Test the symlog scale. """""" testing.assert_almost_equal(4, from_symlog(to_symlog(4))) testing.assert_almost_equal(-4, from_symlog(to_symlog(-4))) y = np.array([to_symlog(x) for x in range(-100, 100)]) # check that the sequence is strictly increasing self.assert_strictly_increasing(y) # plot the sequence plt.plot(y) plt.show() def assert_strictly_increasing(self, y: np.ndarray): """""" Check that the sequence is strictly increasing. :raises AssertionError: if the sequence is not strictly increasing """""" if not np.all(np.diff(y) > 0): raise AssertionError(""The sequence is not strictly increasing."") def test_convert_bound(self): """""" Test the conversion of bounds to the various scales. """""" testing.assert_almost_equal( scale_bound((-10, 10), 'lin'), (-10, 10) ) testing.assert_almost_equal( scale_bound((0.1, 10), 'log'), (-1, 1) ) symlog_bounds = (-2.0043213737826426, 2.0043213737826426) bounds = (0.1, 10) testing.assert_almost_equal( scale_bound(bounds, 'symlog'), symlog_bounds ) x = np.linspace(*symlog_bounds, 100) y = np.array([from_symlog(i, linthresh=bounds[0]) for i in x]) # check that the sequence is strictly increasing self.assert_strictly_increasing(y) plt.plot(x, y) plt.show() def test_scale_value_inverse(self): """""" Make sure that scaling and then unscaling a value returns the original value. """""" # Test parameters test_values = np.array([-1e4, -1e2, -1e0, 1e0, 1e2, 1e4]) # only used to define linthresh bounds = np.array([ (-1e5, -1e-5), (-1e3, -1e-3), (-1e1, -1e-1), (1e-1, 1e1), (1e-3, 1e3), (1e-5, 1e5) ]) scales: List[Literal['lin', 'log', 'symlog']] = ['lin', 'log', 'symlog'] tolerance = 1e-10 for scale in scales: for value, bound in zip(test_values, bounds): if scale == 'symlog' and bound[1] < 0: # doesn't work for negative bounds continue # Scale and then unscale the value scaled_value = scale_value(value, bound, scale) unscaled_value = unscale_value(scaled_value, bound, scale) # Check if the original value and unscaled_value are close within the tolerance assert np.isclose(value, unscaled_value, atol=tolerance, rtol=0) def test_scale_bounds_inverse(self): """""" Make sure that scaling and then unscaling bounds returns the original bounds. """""" # Test parameters test_bounds = [(1e-5, 1e6), (1e-1, 1e4), (1e-3, 1e1)] scales: List[Literal['lin', 'log', 'symlog']] = ['lin', 'log', 'symlog'] for scale in scales: for bounds in test_bounds: # Scale and then unscale the bounds scaled_bounds = scale_bound(bounds, scale) unscaled_bounds = unscale_bound(scaled_bounds, scale, linthresh=bounds[0]) # Check if the original bounds and unscaled_bounds are close within the tolerance assert np.allclose(bounds, unscaled_bounds, atol=1e-7, rtol=0) def test_scale_bounds_raises_error(self): """""" Test that scale_bounds raises an error when the bounds or the scale are not valid. """""" with self.assertRaises(ValueError): scale_bound((-1, 1), 'log') with self.assertRaises(ValueError): scale_bound((0, 1), 'log') with self.assertRaises(ValueError): scale_bound((-1, 1), 'symlog') with self.assertRaises(ValueError): scale_bound((1, 2), 'foo') def test_plot_scaled_values(self): """""" Test plotting the scaled values within the untransformed bounds for the different scales. """""" bounds = dict( lin=(-10, 10), log=(0.1, 10), symlog=(0.001, 10) ) fig, axes = plt.subplots(1, 3, figsize=(15, 5)) scale: Literal['lin', 'log', 'symlog'] for i, scale in enumerate(['lin', 'log', 'symlog']): bounds_scaled = scale_bound(bounds[scale], scale) x_scaled = [unscale_value(x, bounds=bounds[scale], scale=scale) for x in np.linspace(*bounds_scaled, 100)] y_scaled = np.array([scale_value(x, bounds=bounds[scale], scale=scale) for x in x_scaled]) x_unscaled = np.linspace(*unscale_bound(bounds_scaled, scale=scale, linthresh=bounds[scale][0]), 100) y_unscaled = np.array([unscale_value(i, bounds=bounds[scale], scale=scale) for i in y_scaled]) axes[i].plot(x_unscaled, y_unscaled, label=scale) axes[i].set_title(scale) plt.show() def test_sample_value_symlog_scale(self): """""" Sample a value from the symlog scale. """""" y = [Optimization.sample_value(scale='symlog', bounds=(0.1, 10)) for _ in range(10000)] plt.hist(y, bins=50) plt.show() # check that we both have positive and negative values assert np.any(np.array(y) > 0) and np.any(np.array(y) < 0) def test_check_bounds_linear(self): """""" Test that check_bounds works as expected for linear scale. """""" bounds = dict( param1=(1, 10), param2=(1, 10), param3=(-10, -1), param4=(-10, -1), param5=(-10, -1), ) params = dict( param1=1.1, param2=1.005, param3=-9.9, param4=-9.995, param5=11, ) fixed_params = {} percentile = 1 lower, upper = check_bounds(bounds, params, fixed_params, percentile, scale='lin') self.assertEqual(['param2', 'param4'], list(lower.keys())) self.assertEqual(['param5'], list(upper.keys())) def test_check_bounds_log(self): """""" Test that check_bounds works as expected for log scale. """""" bounds = dict( param1=(1, 10), param2=(1, 10), param3=(-10, -1), param4=(-10, -1), param5=(-1, 1), param6=(-1, 1), param7=(-1, 1), param8=(-1, 1), ) params = dict( param1=1.1, param2=1.005, param3=-9.9, param4=-9.995, param5=0, param6=0.99, param7=-0.99, param8=0.1, ) fixed_params = {} percentile = 1 lower, upper = check_bounds(bounds, params, fixed_params, percentile, scale='log') self.assertEqual(['param2'], list(lower.keys())) # param7 doesn't work for log scale self.assertEqual(['param6', 'param8'], list(upper.keys())) def test_perturb_value(self): """""" Test the perturb_value function. """""" rng = np.random.default_rng(seed=42) bounds = (1, 10) value = 5 perturbed_values = [perturb_value(value, bounds, rng) for _ in range(100)] self.assertGreaterEqual(np.std(perturbed_values), 0.3) def test_perturb_value_near_bounds(self): """""" Test the perturb_value function when the value is near the bounds. """""" rng = np.random.default_rng(seed=42) bounds = (1, 10) value_low = 1.1 value_high = 9.9 perturbed_values_low = np.array([perturb_value(value_low, bounds, rng) for _ in range(100)]) perturbed_values_high = np.array([perturb_value(value_high, bounds, rng) for _ in range(100)]) self.assertGreaterEqual(np.std(perturbed_values_low), 0.03) self.assertGreaterEqual(np.std(perturbed_values_high), 0.3) # make sure that perturbed values are within bounds self.assertTrue(np.all((perturbed_values_low >= bounds[0]) & (perturbed_values_low <= bounds[1]))) self.assertTrue(np.all((perturbed_values_high >= bounds[0]) & (perturbed_values_high <= bounds[1]))) def test_perturb_params(self): """""" Test the perturb_params function. """""" rng = np.random.default_rng(seed=42) bounds = { 'param1': (1, 10), 'param2': (1, 10), 'param3': (-10, -1), } params = { 'param1': 5, 'param2': 9, 'param3': -5, } for i in range(10): perturbed_params = flatten_dict(Optimization.perturb_params(params, bounds, rng)) for key in params.keys(): self.assertNotEqual(params[key], perturbed_params[key]) self.assertGreaterEqual(perturbed_params[key], bounds[key][0]) self.assertLessEqual(perturbed_params[key], bounds[key][1]) def test_collapse_fixed_to_mean(self): """""" Test the collapse_fixed_to_mean function. """""" self.assertDictEqual( collapse_fixed_to_mean( { 'pendula': {'eps': 0, 'h': 0.6, 'p_b': 0, 'S_b': 1}, 'pubescens': {'eps': 0, 'h': 0.5, 'p_b': 0, 'S_b': 1} }, types=['pendula', 'pubescens'] ), {'all': {'eps': 0, 'h': 0.55, 'p_b': 0, 'S_b': 1}} ) self.assertDictEqual( collapse_fixed_to_mean( { 'all': {'b': 1}, 'pendula': {'eps': 0, 'h': 0.6, 'p_b': 0, 'S_b': 1}, 'pubescens': {'eps': 0, 'h': 0.5, 'p_b': 0, 'S_b': 1} }, types=['pendula', 'pubescens'] ), {'all': {'eps': 0, 'h': 0.55, 'p_b': 0, 'S_b': 1, 'b': 1}} ) def test_collapse_fixed(self): """""" Test the collapse_fixed function. """""" self.assertDictEqual( collapse_fixed(dict( all=dict(h=0.5), pendula=dict(S_b=0.5, p_b=0, S_d=-100), pubescens=dict(S_b=0.5, p_b=0.1, b=0.3)), types=['pendula', 'pubescens'] ), dict(all=dict(h=0.5, S_b=0.5), pendula=dict(S_d=-100, p_b=0), pubescens=dict(b=0.3, p_b=0.1)) ) self.assertDictEqual( collapse_fixed(dict( all=dict(h=0.5, S_b=0.5), pendula=dict(p_b=0, S_d=-100), pubescens=dict(p_b=0.1, b=0.3), foo=dict(bar=1)), types=['pendula', 'pubescens'] ), dict( all=dict(h=0.5, S_b=0.5), pendula=dict(S_d=-100, p_b=0), pubescens=dict(b=0.3, p_b=0.1), foo=dict(bar=1) ) ) self.assertDictEqual( collapse_fixed(dict( all=dict(h=0.5, S_b=0.5), pendula=dict(p_b=0, S_d=-100), pubescens=dict(p_b=0.1, b=0.3), foo=dict(bar=1)), types=[] ), dict( all=dict(h=0.5, S_b=0.5), pendula=dict(p_b=0, S_d=-100), pubescens=dict(p_b=0.1, b=0.3), foo=dict(bar=1), ) ) ","Python" "Allele","Sendrowski/fastDFE","testing/test_filtration.py",".py","19072","462","from functools import cached_property from typing import List from unittest.mock import Mock import numpy as np import fastdfe as fd from fastdfe.io_handlers import count_sites from testing import TestCase class FiltrationTestCase(TestCase): """""" Test the filterer and filtration classes. """""" @staticmethod def test_filter_snp_filtration(): """""" Test the SNP filtration. """""" f = fd.Filterer( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", output='scratch/test_filter_snp_filtration.vcf', filtrations=[fd.SNPFiltration()], ) f.filter() # assert no sites were filtered assert f.n_filtered == 2 # assert number of sites is the same assert count_sites(f.vcf) == count_sites(f.output) + f.n_filtered def test_snp_filtration_use_sample_mask_from_parser_if_specified(self): """""" Make sure the SNP filtration uses the sample mask from the parser. """""" f = fd.SNPFiltration( use_parser=True, ) p = fd.Parser( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", filtrations=[f], n=10, include_samples=['ASP01', 'ASP02', 'ASP03'], ) p._setup() self.assertEqual(3, sum(p._samples_mask)) np.testing.assert_array_equal(f._samples_mask, p._samples_mask) def test_snp_filtration_dont_use_sample_mask_from_parser_if_specified(self): """""" Make sure the SNP filtration doesn't use the sample mask from the parser. """""" f = fd.SNPFiltration( use_parser=False, ) p = fd.Parser( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", filtrations=[f], n=10, include_samples=['ASP01', 'ASP02', 'ASP03'], ) p._setup() self.assertEqual(3, sum(p._samples_mask)) self.assertEqual(None, f._samples_mask) def test_snp_filtration_include(self): """""" Make sure the SNP filtration uses the sample mask from the parser. """""" f = fd.SNPFiltration( include_samples=['ASP01', 'ASP02', 'ASP03'] ) filterer = fd.Filterer( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", output='scratch/test_snp_filtration_include.vcf', filtrations=[f], ) filterer._setup() self.assertEqual(3, sum(f._samples_mask)) self.assertEqual(377, len(f._samples_mask)) @staticmethod def test_filter_no_poly_allelic_filtration(): """""" Test the no poly-allelic filtration. """""" f = fd.Filterer( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", output='scratch/test_filter_no_poly_allelic_filtration.vcf', filtrations=[fd.PolyAllelicFiltration()], ) f.filter() # assert no sites were filtered assert f.n_filtered == 0 # assert number of sites is the same assert count_sites(f.vcf) == count_sites(f.output) @staticmethod def test_annotator_load_vcf_from_url(): """""" Test the annotator loading a VCF from a URL. """""" f = fd.Filterer( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", output='scratch/test_annotator_load_vcf_from_url.vcf', filtrations=[fd.PolyAllelicFiltration()] ) f.filter() # assert number of sites is the same assert f.n_sites == 10000 assert f.n_filtered == 0 @staticmethod def test_deviant_outgroup_filtration(): """""" Test the annotator loading a VCF from a URL. """""" f = fd.Filterer( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_deviant_outgroup_filtration.vcf', filtrations=[fd.DeviantOutgroupFiltration(outgroups=[""ERR2103730"", ""ERR2103731""])] ) f.filter() # assert number of sites is the same assert f.n_sites == 10000 assert f.n_filtered == 510 @staticmethod def test_deviant_outgroup_filtration_single_site(): """""" Test the annotator loading a VCF from a URL. """""" from cyvcf2 import Variant mock_variant = Mock(spec=Variant) # test case 1: variant is not an SNP mock_variant.is_snp = False filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1'], ingroups=['ingroup1']) filter_obj.samples = np.array(['ingroup1', 'outgroup1']) filter_obj._create_masks() assert filter_obj.filter_site(mock_variant) # expect True as the variant is not SNP # test case 2: variant is an SNP, strict mode is enabled and no outgroup sample is present mock_variant.is_snp = True filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1'], ingroups=['ingroup1'], strict_mode=True) filter_obj.samples = np.array(['ingroup1', 'outgroup1']) filter_obj._create_masks() mock_variant.gt_bases = np.array(['A/A', './.']) assert not filter_obj.filter_site(mock_variant) # expect False as no outgroup sample is present # test case 3: variant is an SNP, strict mode is disabled and no outgroup sample is present filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1'], ingroups=['ingroup1'], strict_mode=False) filter_obj.samples = np.array(['ingroup1', 'outgroup1']) filter_obj._create_masks() mock_variant.gt_bases = np.array(['A/A', './.']) assert filter_obj.filter_site(mock_variant) # # expect True as strict mode off and no outgroup sample present # test case 4: variant is an SNP and outgroup base is different from ingroup base filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1'], ingroups=['ingroup1']) filter_obj.samples = np.array(['ingroup1', 'outgroup1']) filter_obj._create_masks() mock_variant.gt_bases = np.array(['A/A', 'T/T']) assert not filter_obj.filter_site(mock_variant) # expect False as outgroup base is different from ingroup base # test case 5: variant is an SNP and outgroup base is same as ingroup base filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1'], ingroups=['ingroup1']) filter_obj.samples = np.array(['ingroup1', 'outgroup1']) filter_obj._create_masks() mock_variant.gt_bases = np.array(['A/A', 'A/A']) assert filter_obj.filter_site(mock_variant) # expect True as outgroup base is same as ingroup base # test case 6: multiple ingroups and outgroups with matching major bases mock_variant = Mock(spec=Variant) mock_variant.is_snp = True filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1', 'outgroup2'], ingroups=['ingroup1', 'ingroup2']) filter_obj.samples = np.array(['ingroup1', 'ingroup2', 'outgroup1', 'outgroup2']) filter_obj._create_masks() mock_variant.gt_bases = np.array(['A/A', 'A/T', 'A/A', 'A/G']) assert filter_obj.filter_site(mock_variant) # expect True as major base 'A' is common in ingroup and outgroup # test case 7: multiple ingroups and outgroups with differing major bases mock_variant = Mock(spec=Variant) mock_variant.is_snp = True filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1', 'outgroup2'], ingroups=['ingroup1', 'ingroup2']) filter_obj.samples = np.array(['ingroup1', 'ingroup2', 'outgroup1', 'outgroup2']) filter_obj._create_masks() mock_variant.gt_bases = np.array(['A/A', 'A/T', 'T/T', 'T/G']) assert not filter_obj.filter_site(mock_variant) # expect False as major base 'A' in ingroup and 'T' in outgroup # test case 8: make sure we retain mono-allelic sites if retain_monomorphic is True mock_variant = Mock(spec=Variant) mock_variant.is_snp = False filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1', 'outgroup2'], ingroups=['ingroup1', 'ingroup2'], retain_monomorphic=True) filter_obj.samples = np.array(['ingroup1', 'ingroup2', 'outgroup1', 'outgroup2']) filter_obj._create_masks() mock_variant.gt_bases = np.array(['A/A', 'A/A', 'T/T', 'T/T']) assert filter_obj.filter_site(mock_variant) # expect True as major base 'A' in ingroup and 'T' in outgroup # test case 9: make sure we don't retain mono-allelic sites if retain_monomorphic is False mock_variant = Mock(spec=Variant) mock_variant.is_snp = False filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1', 'outgroup2'], ingroups=['ingroup1', 'ingroup2'], retain_monomorphic=False) filter_obj.samples = np.array(['ingroup1', 'ingroup2', 'outgroup1', 'outgroup2']) filter_obj._create_masks() mock_variant.gt_bases = np.array(['A/A', 'A/A', 'T/T', 'T/T']) assert not filter_obj.filter_site(mock_variant) # expect False as major base 'A' in ingroup and 'T' in outgroup @staticmethod def test_existing_outgroup_filtration_single_site_1_missing(): """""" Test the existing outgroup filtration. """""" from cyvcf2 import Variant # test case 1: variants has one fully defined outgroup sample mock_variant = Mock(spec=Variant) filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1']) filter_obj.samples = np.array(['ingroup1', 'outgroup1']) filter_obj._create_mask() mock_variant.gt_bases = np.array(['A/A', 'T/T']) assert filter_obj.filter_site(mock_variant) # test case 2: variants has one missing outgroup sample mock_variant = Mock(spec=Variant) filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1']) filter_obj.samples = np.array(['ingroup1', 'outgroup1']) filter_obj._create_mask() mock_variant.gt_bases = np.array(['A/A', './.']) assert not filter_obj.filter_site(mock_variant) # test case 3: variants has one fully defined outgroup sample and one missing outgroup sample mock_variant = Mock(spec=Variant) filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1', 'outgroup2']) filter_obj.samples = np.array(['outgroup1', 'ingroup1', 'outgroup2']) filter_obj._create_mask() mock_variant.gt_bases = np.array(['./.', 'A/A', 'T/T']) assert not filter_obj.filter_site(mock_variant) # test case 4: variants has one outgroup sample with one missing allele mock_variant = Mock(spec=Variant) filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1']) filter_obj.samples = np.array(['ingroup1', 'outgroup1']) filter_obj._create_mask() mock_variant.gt_bases = np.array(['A/A', 'T/.']) assert filter_obj.filter_site(mock_variant) # test case 5: variants has three outgroup samples with one missing allele each mock_variant = Mock(spec=Variant) filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1', 'outgroup2', 'outgroup3']) filter_obj.samples = np.array(['ingroup1', 'outgroup1', 'outgroup2', 'outgroup3']) filter_obj._create_mask() mock_variant.gt_bases = np.array(['A/A', 'T/.', 'T/.', 'T/.']) assert filter_obj.filter_site(mock_variant) @staticmethod def test_existing_outgroup_filtration_with_varied_n_missing(): """""" Test the existing outgroup filtration with shuffled masks, extra unused samples, and ingroups. """""" from cyvcf2 import Variant # test case 6: n=2, one missing outgroup, extra unused sample -> should pass mock_variant = Mock(spec=Variant) filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup2', 'outgroup3'], n_missing=2) filter_obj.samples = np.array(['unused1', 'ingroup1', 'outgroup2', 'outgroup3', 'unused2']) filter_obj._create_mask() mock_variant.gt_bases = np.array(['A/A', 'C/C', './.', 'T/T', 'G/G']) assert filter_obj.filter_site(mock_variant) # test case 7: n=2, exactly two outgroups missing, shuffled sample order -> should fail mock_variant = Mock(spec=Variant) filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup3', 'outgroup1'], n_missing=2) filter_obj.samples = np.array(['ingroup1', 'outgroup3', 'unused1', 'outgroup1', 'unused2']) filter_obj._create_mask() mock_variant.gt_bases = np.array(['A/A', './.', 'G/G', './.', 'T/T']) assert not filter_obj.filter_site(mock_variant) # test case 8: n=3, two missing outgroups, extra ingroup sample -> should pass mock_variant = Mock(spec=Variant) filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1', 'outgroup2', 'outgroup3'], n_missing=3) filter_obj.samples = np.array(['ingroup1', 'outgroup1', 'ingroup2', 'outgroup2', 'outgroup3']) filter_obj._create_mask() mock_variant.gt_bases = np.array(['A/A', './.', 'C/C', './.', 'T/T']) assert filter_obj.filter_site(mock_variant) # test case 9: n=3, exactly three outgroups missing -> should fail mock_variant = Mock(spec=Variant) filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1', 'outgroup2', 'outgroup3'], n_missing=3) filter_obj.samples = np.array(['outgroup1', 'ingroup1', 'outgroup2', 'outgroup3', 'unused1']) filter_obj._create_mask() mock_variant.gt_bases = np.array(['./.', 'A/A', './.', './.', 'G/G']) assert not filter_obj.filter_site(mock_variant) # test case 10: n=3, mixed missing and defined outgroups, with unused samples -> should pass mock_variant = Mock(spec=Variant) filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1', 'outgroup2', 'outgroup3'], n_missing=3) filter_obj.samples = np.array(['unused1', 'outgroup1', 'ingroup1', 'outgroup2', 'unused2', 'outgroup3']) filter_obj._create_mask() mock_variant.gt_bases = np.array(['G/G', './.', 'A/A', 'T/T', 'C/C', './.']) assert filter_obj.filter_site(mock_variant) @staticmethod def test_snp_filtration(): """""" Test the SNP filtration. """""" f = fd.SNPFiltration() assert not f.filter_site(variant=Mock(is_snp=False)) assert f.filter_site(variant=Mock(is_snp=True)) @staticmethod def test_snv_filtration(): """""" Test the SNV filtration. """""" f = fd.SNVFiltration() assert not f.filter_site(variant=Mock(REF='AG', ALT=['A', 'G'])) assert f.filter_site(variant=Mock(REF='A', ALT=['G'])) assert f.filter_site(variant=Mock(REF='A', ALT=['G', 'C'])) assert not f.filter_site(variant=Mock(REF='A', ALT=['GA'])) assert f.filter_site(variant=Mock(REF='A', ALT=['G', 'C', 'T'])) @staticmethod def test_no_poly_allelic_filtration(): """""" Test the no poly-allelic filtration. """""" f = fd.PolyAllelicFiltration() assert not f.filter_site(variant=Mock(ALT=['T', 'G'])) assert not f.filter_site(variant=Mock(ALT=['T', 'G', 'C'])) assert f.filter_site(variant=Mock(ALT=['T'])) assert f.filter_site(variant=Mock(ALT=[])) def test_coding_sequence_filtration_raises_error_if_no_fasta_given(self): """""" Test the coding sequence filtration. """""" with self.assertRaises(ValueError) as error: f = fd.Filterer( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", output='scratch/test_coding_sequence_filtration.vcf', filtrations=[fd.CodingSequenceFiltration()], ) f.filter() print(error) @staticmethod def test_coding_sequence_filtration(): """""" Test the coding sequence filtration. """""" f = fd.Filterer( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", output='scratch/test_coding_sequence_filtration.vcf', gff=""resources/genome/betula/genome.gff"", filtrations=[fd.CodingSequenceFiltration()], ) f.filter() # assert no sites were filtered assert f.n_filtered == 6434 # assert number of sites is the same assert count_sites(f.vcf) - f.n_filtered == count_sites(f.output) @staticmethod def test_existing_outgroup_filtration(): """""" Test the existing outgroup filtration. """""" f = fd.Filterer( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_existing_outgroup_filtration.vcf', filtrations=[fd.ExistingOutgroupFiltration(outgroups=[""ERR2103730"", ""ERR2103731""])] ) f.filter() # assert number of sites is the same assert f.n_sites == 10000 assert f.n_filtered == 3638 @staticmethod def test_biased_gc_conversion_filtration(): """""" Test the SNV filtration. """""" f = fd.BiasedGCConversionFiltration() class VariantMock: """""" Mock the variant class. """""" def __init__(self, REF: str, ALT: List[str]): self.REF = REF self.ALT = ALT @cached_property def is_snp(self): """""" :return: """""" return len(self.ALT) == 0 or self.REF != self.ALT[0] assert f.filter_site(variant=VariantMock(REF='A', ALT=['A'])) assert f.filter_site(variant=VariantMock(REF='T', ALT=['T'])) assert f.filter_site(variant=VariantMock(REF='T', ALT=[])) assert not f.filter_site(variant=VariantMock(REF='A', ALT=['G'])) assert not f.filter_site(variant=VariantMock(REF='G', ALT=['A'])) assert not f.filter_site(variant=VariantMock(REF='C', ALT=['T'])) assert not f.filter_site(variant=VariantMock(REF='T', ALT=['G'])) assert f.filter_site(variant=VariantMock(REF='C', ALT=['G'])) assert f.filter_site(variant=VariantMock(REF='G', ALT=['C'])) assert f.filter_site(variant=VariantMock(REF='A', ALT=['T'])) assert f.filter_site(variant=VariantMock(REF='T', ALT=['A'])) def test_contig_filtration(self): """""" Test the contig filtration. """""" f = fd.ContigFiltration(contigs=['chr1']) self.assertTrue(f.filter_site(variant=Mock(CHROM='chr1'))) self.assertFalse(f.filter_site(variant=Mock(CHROM='chr2'))) ","Python" "Allele","Sendrowski/fastDFE","testing/test_joint_inference.py",".py","30621","866","import matplotlib.pyplot as plt import numpy as np import pytest from pandas._testing import assert_frame_equal import fastdfe as fd from fastdfe import JointInference, Config, SharedParams, Covariate, Spectra from fastdfe.optimization import flatten_dict from testing.test_base_inference import InferenceTestCase class JointInferenceTestCase(InferenceTestCase): """""" Test the JointInference class. """""" config_file = ""testing/cache/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml"" maxDiff = None def test_run_and_restore_from_file(self): """""" Test that joint inference can be restored from file. """""" inference = JointInference.from_config_file( ""resources/configs/shared/covariates_Sd_fixed_params/config.yaml"" ) inference.run() out = ""scratch/test_restore_from_file.json"" inference.to_file(out) inference2 = JointInference.from_file(out) self.assertEqualObjects(inference, inference2) def test_recreate_from_config(self): """""" Test whether inference can be recreated from config. """""" inf = JointInference.from_config_file(self.config_file) inf2 = JointInference.from_config(inf.create_config()) self.assertEqualObjects(inf, inf2, ignore_keys=['fixed_params']) def test_perform_lrt_shared(self): """""" Test that the perform_lrt_shared method works. """""" inference = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/shared_example_2/serialized.json"" ) # inference.evaluate_likelihood(inference.params_mle) # inference.marginal_inferences['example_1'].evaluate_likelihood( # dict(all=inference.params_mle['example_1'])) assert inference.perform_lrt_shared() < 1 np.testing.assert_array_equal(inference.get_shared_param_names(), ['S_d']) def test_perform_lrt_covariates_no_covariates_raises_error(self): """""" Test that the perform_lrt_covariates method works. """""" inference = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/shared_example_1/serialized.json"" ) with pytest.raises(ValueError): inference.perform_lrt_covariates() @pytest.mark.slow def test_perform_lrt_covariates(self): """""" Test that the perform_lrt_covariates method works. """""" inf = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" ) inf.n_bootstraps = 2 assert inf.perform_lrt_covariates() < 1 def test_no_shared_params(self): """""" Test that the perform_lrt_covariates method works. """""" # create inference object inf = JointInference( sfs_neut=Spectra(dict( pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] )), sfs_sel=Spectra(dict( pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] )), fixed_params=dict(all=dict(h=0.5)), do_bootstrap=False, parallelize=False, n_bootstraps=2, n_runs=1 ) inf.run() inf.plot_discretized() self.assertEqual(inf.get_shared_param_names(), []) def test_perform_lrt_covariates_two_samples(self): """""" Test that the perform_lrt_covariates method works. """""" # create inference object inf = JointInference( sfs_neut=Spectra(dict( pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] )), sfs_sel=Spectra(dict( pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] )), fixed_params=dict(all=dict(eps=0, p_b=0, S_b=1, h=0.5)), do_bootstrap=True, n_bootstraps=2, n_runs=1, covariates=[Covariate(param='S_d', values=dict(pendula=0.3, pubescens=0.6))] ) assert inf.perform_lrt_covariates() < 1 def test_plot_inferred_parameters_boxplot(self): """""" Test that the plot_inferred_parameters_boxplot method works. """""" inference = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/shared_example_2/serialized.json"" ) inference.bootstrap(6) inference.plot_inferred_parameters_boxplot() def test_plot_inferred_parameters(self): """""" Test that the plot_inferred_parameters_boxplot method works. """""" inference = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/shared_example_2/serialized.json"" ) inference.bootstrap(2) inference.plot_inferred_parameters() def test_plot_all_without_bootstraps(self): """""" Test that the plot_all method works. """""" inference = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" ) inference.plot_all() def test_plot_all_with_bootstraps(self): """""" Test that the plot_all method works. """""" inference = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" ) inference.bootstrap(2) inference.plot_all() @staticmethod def test_plot_covariate(): """""" Test the plot_covariate method. """""" inference = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" ) inference.plot_covariate() pass @staticmethod def test_plot_not_showing_types(): """""" Test the plot_covariate method. """""" inference = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" ) inference.plot_covariate(show_types=False) pass @staticmethod def test_plot_covariate_bootstrap(): """""" Test the plot_covariate method. """""" inference = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" ) inference.bootstrap(2) inference.plot_covariate() pass @staticmethod def test_plot_discretized_without_showing_marginals(): """""" Test the plot_discretized method """""" inference = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" ) inference.plot_discretized(show_marginals=False) pass def test_evaluate_likelihood_same_as_mle_results(self): """""" Check that evaluating the loss function at the MLE results yields the same likelihood as the one reported. """""" # rerun inference to make sure we don't have platform-specific differences inference = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/shared_example_1/serialized.json"" ) # make sure joint likelihood is almost the same self.assertAlmostEqual(inference.evaluate_likelihood(inference.params_mle), inference.likelihood) for t in inference.types: # make sure marginal likelihoods are the same self.assertAlmostEqual(inference.marginal_inferences[t].evaluate_likelihood( dict(all=inference.marginal_inferences[t].params_mle)), inference.marginal_inferences[t].likelihood) # make sure joint likelihoods are not the same as when evaluated individually assert inference.joint_inferences[t].evaluate_likelihood( dict(all=inference.joint_inferences[t].params_mle)) != inference.joint_inferences[t].likelihood # make sure all joint likelihoods coincide with likelihood of joint inference assert inference.joint_inferences[t].likelihood == inference.likelihood def test_fixed_parameters(self): """""" Test whether fixed parameters are correctly set. """""" config = Config.from_file( ""testing/cache/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml"" ) # define fixed parameters config.data['fixed_params'] = dict( all=dict(eps=0.123, h=0.5), example_1=dict(b=1.234), example_2=dict(b=1.132), pendula=dict(S_b=10.1) ) # define fixed parameters config.data['shared_params'] = [ SharedParams(types='all', params=['S_d', 'p_b']) ] inf = JointInference.from_config(config) inf.run() params_mle = inf.params_mle fixed = { 'all': {'eps': 0.123, 'h': 0.5}, 'example_1': {'eps': 0.123, 'h': 0.5, 'b': 1.234}, 'example_2': {'eps': 0.123, 'h': 0.5, 'b': 1.132}, 'example_3': {'eps': 0.123, 'h': 0.5}, 'pendula': {'eps': 0.123, 'h': 0.5, 'S_b': 10.1}, 'pubescens': {'eps': 0.123, 'h': 0.5}, } assert inf.marginal_inferences['all'].optimization.fixed_params == flatten_dict(dict(all=fixed['all'])) # check that eps is fixed for all types for t in inf.types: assert inf.marginal_inferences[t].optimization.fixed_params == flatten_dict(dict(all=fixed[t])) assert inf.joint_inferences[t].optimization.fixed_params == flatten_dict(dict(all=fixed[t])) assert params_mle[t]['eps'] == config.data['fixed_params']['all']['eps'] # check that b is fixed for example_1 and example_2, but not for the others assert params_mle['example_1']['b'] == config.data['fixed_params']['example_1']['b'] assert params_mle['example_2']['b'] == config.data['fixed_params']['example_2']['b'] assert params_mle['example_3']['b'] != config.data['x0']['all']['b'] assert params_mle['example_3']['b'] != config.data['fixed_params']['example_1']['b'] assert params_mle['example_3']['b'] != config.data['fixed_params']['example_2']['b'] assert params_mle['pendula']['b'] != config.data['x0']['all']['b'] assert params_mle['pubescens']['b'] != config.data['x0']['all']['b'] # check that S_b is fixed for pendula, but not for the others self.assertAlmostEqual(params_mle['pendula']['S_b'], config.data['fixed_params']['pendula']['S_b']) assert params_mle['pubescens']['S_b'] != config.data['x0']['all']['S_b'] def test_shared_same_parameter_twice_among_different_types(self): """""" Test sharing a parameter twice among different types. """""" config = Config.from_file( ""testing/cache/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml"" ) config.update( fixed_params={'all': dict(S_b=1, eps=0, p_b=0, h=0.5)}, shared_params=[ SharedParams(types=['example_1', 'example_2'], params=['b']), SharedParams(types=['pendula', 'pubescens'], params=['b']) ], n_bootstraps=2, do_bootstraps=True, n_runs=1 ) inf = JointInference.from_config(config) inf.run() # check that b is shared between example_1 and example_2 assert inf.params_mle['example_1']['b'] == inf.params_mle['example_2']['b'] # check that b is shared between pendula and pubescens assert inf.params_mle['pendula']['b'] == inf.params_mle['pubescens']['b'] # check that b is not shared between example_1 and pendula assert inf.params_mle['example_1']['b'] != inf.params_mle['pendula']['b'] def test_fixed_parameters_cannot_be_shared(self): """""" Test that trying to shared fixed parameters raises an error. """""" config = Config.from_file( ""testing/cache/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml"" ) # define fixed parameters config.data['fixed_params'] = dict( example_1=dict(b=1.234), ) # define fixed parameters config.data['shared_params'] = [ SharedParams(types=['example_1'], params=['S_d', 'p_b', 'b']) ] with pytest.raises(ValueError): JointInference.from_config(config) @pytest.mark.slow def test_compare_nested_models(self): """""" Test nested model comparison. """""" inf = JointInference.from_config_file( ""resources/configs/shared/covariates_Sd_fixed_params/config.yaml"" ) P, inferences = inf.compare_nested_models() assert inferences['full.anc'].get_n_optimized() == 18 assert inferences['full.anc'].marginal_inferences['all'].get_n_optimized() == 5 assert inferences['full.no_anc'].get_n_optimized() == 13 assert inferences['full.no_anc'].marginal_inferences['all'].get_n_optimized() == 4 assert inferences['dele.anc'].get_n_optimized() == 8 assert inferences['dele.anc'].marginal_inferences['all'].get_n_optimized() == 3 assert inferences['dele.no_anc'].get_n_optimized() == 3 assert inferences['dele.no_anc'].marginal_inferences['all'].get_n_optimized() == 2 def test_get_n_optimized(self): """""" Test get number of parameters to be optimized. """""" inf = JointInference.from_config_file( ""resources/configs/shared/covariates_Sd_fixed_params/config.yaml"" ) assert inf.get_n_optimized() == 11 inf = JointInference.from_config_file( ""resources/configs/shared/covariates_Sd_example_1/config.yaml"" ) assert inf.get_n_optimized() == 18 inf = JointInference.from_config_file( ""resources/configs/shared/covariates_dummy_example_1/config.yaml"" ) assert inf.get_n_optimized() == 19 def test_non_existing_shared_param_raises_error(self): """""" Test that trying to share a non-existing parameter raises an error. """""" config = Config.from_file( ""testing/cache/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml"" ) # define shared parameters config.data['shared_params'] = [ SharedParams(types=['example_1'], params=['b', 'foo', 'bar']) ] with pytest.raises(ValueError): JointInference.from_config(config) def test_non_existing_covariate_raises_error(self): """""" Test that trying to share a non-existing parameter raises an error. """""" config = Config.from_file( ""testing/cache/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml"" ) types = ['pendula', 'pubescens', 'example_1', 'example_2', 'example_3'] # define shared parameters config.data['covariates'] = [ Covariate(values={t: 1 for t in types}, param='foo') ] with pytest.raises(ValueError): JointInference.from_config(config) def test_covariate_random_covariates(self): """""" Check that random covariates are not significant. """""" # parse SFS spectra = Spectra.from_file(""resources/SFS/betula/pendula/degeneracy_ref_base_tutorial.csv"") # create inference object inf = JointInference( sfs_neut=spectra[['neutral.*']].merge_groups(1), sfs_sel=spectra[['selected.*']].merge_groups(1), covariates=[Covariate(param='S_d', values=dict(A=1, C=2, T=3, G=4))], fixed_params={'all': dict(S_b=1, eps=0, h=0.5)}, parallelize=True, do_bootstrap=True, n_bootstraps=2 ) # run inference inf.run() inf_no_cov = inf.run_joint_without_covariates() p = inf.perform_lrt_covariates() inf.plot_inferred_parameters() # the test should be non-significant as we chose random covariates assert p > 0.05 @pytest.mark.slow def test_covariates_strong_correlation(self): """""" Check that strong correlation between covariates is detected as significant. """""" # parse SFS spectra = Spectra.from_file(""resources/SFS/betula/pendula/degeneracy_ref_base_tutorial.csv"") # create inference object inf = JointInference( sfs_neut=spectra[['neutral.*']].merge_groups(1), sfs_sel=spectra[['selected.*']].merge_groups(1), covariates=[Covariate(param='S_d', values=dict(A=-100000, C=-2045, T=-60504, G=-5024))], fixed_params={'all': dict(S_b=1, eps=0, p_b=0, h=0.5)}, parallelize=True, do_bootstrap=True, n_bootstraps=100, n_runs=20 ) # run inference inf.run() inf_no_cov = inf.run_joint_without_covariates() p = inf.perform_lrt_covariates() inf.plot_inferred_parameters() # we expect 'c0' to be close to 1 # self.assertAlmostEqual(inf.params_mle['T']['c0'], 1, places=2) # the test should be more or less significant as we chose good covariates assert p < 0.15 def test_covariates_plot_inferred_parameters(self): """""" Check that covariates are plotted correctly. """""" # parse SFS spectra = Spectra.from_file(""resources/SFS/betula/pendula/degeneracy_ref_base_tutorial.csv"") # create inference object inf = JointInference( sfs_neut=spectra[['neutral.*']].merge_groups(1), sfs_sel=spectra[['selected.*']].merge_groups(1), covariates=[Covariate(param='S_d', values=dict(A=-100000, C=-2045, T=-60504, G=-5024))], fixed_params={'all': dict(S_b=1, eps=0, p_b=0, h=0.5)}, parallelize=True, do_bootstrap=True, n_runs=10, n_bootstraps=2 ) inf.plot_inferred_parameters() def test_get_discretized_errors_with_bootstraps(self): """""" Get the discretized DFE errors. """""" inference = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/shared_example_2/serialized.json"" ) inference.bootstrap(2) res = inference.get_discretized() def test_get_discretized_errors_no_bootstraps(self): """""" Get the discretized DFE errors. """""" inference = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/shared_example_1/serialized.json"" ) values, errors = inference.get_discretized() # check that all errors are None for err in errors.values(): assert err is None def test_joint_inference_with_folded_spectra(self): """""" Test that joint inference works with folded spectra. """""" # neutral SFS for two types sfs_neut = Spectra(dict( pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] )).fold() # selected SFS for two types sfs_sel = Spectra(dict( pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] )).fold() # create inference object inf = JointInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, shared_params=[SharedParams(types=[""pendula"", ""pubescens""], params=[""eps"", ""S_d""])], fixed_params={'all': dict(h=0.5)}, do_bootstrap=True, n_bootstraps=2 ) # run inference inf.run() # assert that all inferences are folded assert inf.folded assert np.array([v.folded for v in inf.get_inferences().values()]).all() inf.plot_discretized() inf.plot_sfs_comparison() def test_joint_inference_types_with_dots_throws_error(self): """""" Test that joint inference with types containing dots throws an error. """""" # neutral SFS for two types sfs_neut = Spectra({ 'pendula.foo': [177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], 'pubescens.bar.foo': [172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] }) # selected SFS for two types sfs_sel = Spectra({ 'pendula.foo': [797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], 'pubescens.bar.foo': [791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] }) # create inference object with pytest.raises(ValueError): JointInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, fixed_params={'all': dict(eps=0, h=0.5)}, shared_params=[SharedParams(types=[""pendula.foo"", ""pubescens.bar.foo""], params=[""S_d"", ""S_b"", ""p_b""])], do_bootstrap=True ) def test_spectra_with_disparate_types_throws_error(self): """""" Test that joint inference with types containing dots throws an error. """""" # neutral SFS for two types sfs_neut = Spectra({ 'pendula': [177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], 'pubescens': [172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] }) # selected SFS for two types sfs_sel = Spectra({ 'pendula': [797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], 'pubescens.bar.foo': [791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] }) # create inference object with pytest.raises(ValueError): JointInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, fixed_params={'all': dict(eps=0, h=0.5)}, shared_params=[SharedParams(types=[""pendula"", ""pubescens.bar.foo""], params=[""S_d"", ""S_b"", ""p_b""])], do_bootstrap=True ) @staticmethod @pytest.mark.slow def test_manuscript_example(): """""" Test the example in the manuscript. Note the warning on a large residual for the joint inference is not unusual as the fit to each component SFS naturally is worse when sharing parameters. """""" config = fd.Config.from_file(""resources/configs/arabidopsis/covariates_example.yaml"") inf = fd.JointInference.from_config(config) inf.run() # get p-value for covariate significance p = inf.perform_lrt_covariates() _, axs = plt.subplots(1, 2, figsize=(10.5, 3.5)) p_str = f""p = {p:.1e}"" if p >= 1e-100 else ""p < 1e-100"" inf.plot_covariate(ax=axs[0], xlabel='RSA', show=False) inf.plot_discretized( title=f""DFE comparison, "" + p_str, ax=axs[1], show_marginals=False, show=True ) pass @pytest.mark.skip(""Only works with variable h"") def test_alternative_optimizer(self): """""" Test for alternative optimizer. """""" config = fd.Config.from_file( ""resources/configs/shared/covariates_Sd_fixed_params/config.yaml"" ).update( do_bootstrap=True, n_bootstraps=1, method_mle='Powell' ) inf = fd.JointInference.from_config(config) inf.run() self.assertTrue(hasattr(inf.result, 'direc')) self.assertTrue(hasattr(inf.bootstrap_results[0], 'direc')) self.assertTrue(hasattr(inf.marginal_inferences['all'].result, 'direc')) self.assertTrue(hasattr(inf.marginal_inferences['example_1'].bootstrap_results[0], 'direc')) def test_raise_error_n_above_400(self): """""" Test whether an error is raised when sample size is above 400. """""" with self.assertRaises(ValueError) as context: fd.JointInference( sfs_neut=fd.Spectrum.standard_kingman(401, n_monomorphic=10000).to_spectra(), sfs_sel=fd.Spectrum.standard_kingman(401, n_monomorphic=10000).to_spectra() ) print(context.exception) def test_bootstrap_n_retries(self): """""" Test whether bootstrapping with retries works as expected. """""" config = fd.Config.from_file( ""resources/configs/shared/covariates_Sd_fixed_params/config.yaml"" ).update( n_bootstrap_retries=3, parallelize=True, n_bootstraps=3, do_bootstrap=True ) inf = fd.JointInference.from_config(config) inf.run() for inf in list(inf.marginal_inferences.values()) + [inf]: self.assertEqual(3, len(inf.bootstraps.likelihoods_runs.iloc[0])) self.assertEqual(3, len(inf.bootstraps.x0_runs.iloc[0])) self.assertGreater(inf.bootstraps.likelihoods_std.mean(), 0) def test_get_alpha(self): """""" Test get_alpha method. """""" inf = JointInference.from_file( ""testing/cache/fastdfe/templates/shared/shared_example_1/serialized.json"" ) alpha = inf.get_alpha() # assert keys are present for t in inf.types: assert t in alpha def test_seeded_inference_is_deterministic_non_parallelized(self): """""" Check that inference is deterministic when seeded and not parallelized. """""" config = fd.Config.from_file(self.config_file) config.update( seed=0, do_bootstrap=True, parallelize=False, n_bootstraps=2 ) inf = fd.JointInference.from_config(config) inf.run() inf2 = fd.JointInference.from_config(config) inf2.run() self.assertEqual(inf.params_mle, inf2.params_mle) assert_frame_equal(inf.bootstraps, inf2.bootstraps) def test_seeded_inference_is_deterministic_parallelized(self): """""" Check that seeded inference is deterministic when parallelized. """""" config = fd.Config.from_file(self.config_file) config.update( seed=0, do_bootstrap=True, parallelize=True, n_bootstraps=2 ) inference = fd.JointInference.from_config(config) inference.run() inference2 = fd.JointInference.from_config(config) inference2.run() self.assertEqual(inference.params_mle, inference2.params_mle) assert_frame_equal(inference.bootstraps, inference2.bootstraps) def test_joint_different_fixed_h(self): """""" Test joint inference with different fixed h values. """""" inf = JointInference( sfs_neut=Spectra(dict( pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], pendula2=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], )), sfs_sel=Spectra(dict( pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], pendula2=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], )), fixed_params=dict(all=dict(eps=0, S_b=1, p_b=0), pendula=dict(h=0.2), pendula2=dict(h=0.8)), shared_params=[SharedParams(types='all', params=['b'])], intervals_del=(-1.0e+8, -1.0e-5, 100), intervals_ben=(1.0e-5, 1.0e4, 100), intervals_h=(0, 1, 11), do_bootstrap=False, parallelize=True, n_runs=10 ) inf.run() # make sure that h values are correctly held fixed self.assertEqual(0.2, inf.params_mle['pendula']['h']) self.assertEqual(0.8, inf.params_mle['pendula2']['h']) self.assertEqual(0.2, inf.joint_inferences['pendula'].params_mle['h']) self.assertEqual(0.8, inf.joint_inferences['pendula2'].params_mle['h']) self.assertEqual(0.2, inf.marginal_inferences['pendula'].params_mle['h']) self.assertEqual(0.8, inf.marginal_inferences['pendula2'].params_mle['h']) inf.plot_discretized() # make sure that the DFE for h=0.2 is shifted towards more deleterious mutations for both marginals and joints discretized = inf.get_discretized()[0] self.assertGreater(discretized[""marginal.pendula""][0], discretized[""marginal.pendula2""][0]) self.assertGreater(discretized[""joint.pendula""][0], discretized[""joint.pendula2""][0]) def test_joint_optimized_different_h(self): """""" Test joint inference with different optimized h values. """""" inf = JointInference( sfs_neut=Spectra(dict( pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] )), sfs_sel=Spectra(dict( pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] )), fixed_params=dict(all=dict(eps=0, S_b=1, p_b=0)), shared_params=[SharedParams(types='all', params=['b', 'S_d'])], intervals_del=(-1.0e+8, -1.0e-5, 100), intervals_ben=(1.0e-5, 1.0e4, 100), intervals_h=(0, 1, 11), do_bootstrap=False, parallelize=True, n_runs=10 ) inf.run() self.assertNotEqual(inf.params_mle['pendula']['h'], inf.params_mle['pubescens']['h']) self.assertNotEqual( inf.joint_inferences['pendula'].params_mle['h'], inf.joint_inferences['pubescens'].params_mle['h'] ) ","Python" "Allele","Sendrowski/fastDFE","testing/test_parser.py",".py","43725","1335","import logging import dadi import fastdfe as fd import numpy as np import pandas as pd import pytest from fastdfe.io_handlers import get_called_bases from unittest.mock import Mock from testing import TestCase class ParserTestCase(TestCase): """""" Test parser. """""" @staticmethod def test_parse_sfs_compare_subsample_modes(): """""" Compare the sfs for probabilistic vs random subsampling. """""" for n in [19, 20]: p1 = fd.Parser( vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', n=n, stratifications=[], subsample_mode='probabilistic', max_sites=10000 ) sfs = p1.parse().all p2 = fd.Parser( vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', n=n, stratifications=[], subsample_mode='random', max_sites=10000, seed=2 ) sfs2 = p2.parse().all fd.Spectra.from_spectra(dict( probabilistic=sfs, random=sfs2 )).plot() diff_rel = np.abs(sfs.data - sfs2.data) / sfs2.data assert sfs.data.min() > 0 assert sfs2.data.min() > 0 assert diff_rel.mean() < 0.2 @staticmethod def test_parse_sfs_compare_probabilistic_with_dadi(): """""" Compare the parsed sfs with results from dadi. """""" p1 = fd.Parser( vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', n=20, stratifications=[], subsample_mode='probabilistic' ) sfs = p1.parse().all data_dict = dadi.Misc.make_data_dict_vcf( 'resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', 'resources/genome/betula/pops_dadi.txt' ) sfs2 = dadi.Spectrum.from_data_dict(data_dict, ['pop0'], [20], polarized=True) assert np.abs(sfs.data.sum() - sfs2.data.sum()) < 1e-08 diff_rel = np.abs(sfs.data - sfs2.data) / sfs2.data # used to be 1e-12 but dadi was updated assert diff_rel.max() < 1e-3 @staticmethod @pytest.mark.slow def test_compare_sfs_with_dadi_full_set(): """""" Compare the sfs from dadi with the one from the data. """""" p = fd.Parser( vcf='resources/genome/betula/biallelic.polarized.vcf.gz', n=20, stratifications=[], seed=2 ) sfs = p.parse().all data_dict = dadi.Misc.make_data_dict_vcf( 'resources/genome/betula/biallelic.polarized.vcf.gz', 'resources/genome/betula/pops_dadi.txt' ) sfs_dadi = dadi.Spectrum.from_data_dict(data_dict, ['pop0'], [20], polarized=True) diff_rel = np.abs(sfs.to_numpy() - sfs_dadi.data) / sfs_dadi.data s = fd.Spectra(dict( native=sfs.to_numpy(), dadi=sfs_dadi.data )) s.plot() # rather similar given number of sites and subsamples assert diff_rel[sfs_dadi.data != 0].max() < 0.1 @staticmethod def test_degeneracy_stratification(): """""" Test the degeneracy stratification. """""" p = fd.Parser( vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', n=20, stratifications=[fd.DegeneracyStratification()] ) sfs = p.parse() sfs.plot() # assert total number of sites assert sfs.all.data.sum() == 10000 - p.n_skipped # assert that all types are a subset of the stratification assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) @staticmethod def test_contig_stratification_dataset(): """""" Test the degeneracy stratification. """""" p = fd.Parser( vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', n=20, stratifications=[fd.ContigStratification()] ) sfs = p.parse() sfs.plot() # assert total number of sites assert np.round(sfs.all.data.sum()) == 10000 - p.n_skipped # assert that all types are a subset of the stratification assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) def test_contig_stratification(self): """""" Test the contig stratification. """""" s = fd.ContigStratification(['contig1', 'contig2']) self.assertEqual(s.get_types(), ['contig1', 'contig2']) self.assertNotEqual(s.get_types(), ['contig1', 'contig3']) self.assertEqual(s.get_type(Mock(CHROM='contig1')), 'contig1') self.assertNotEqual(s.get_type(Mock(CHROM='contig1')), 'contig2') def test_random_stratification(self): """""" Test the RandomStratification class. """""" # Test with 3 bins and fixed seed s = fd.RandomStratification(n_bins=3, seed=42) # Ensure all bin types are generated correctly self.assertEqual(s.get_types(), ['bin0', 'bin1', 'bin2']) # Ensure random assignment produces valid bins mock_variant = Mock() bin = s.get_type(mock_variant) self.assertIn(bin, ['bin0', 'bin1', 'bin2']) # Test reproducibility: two instances with the same seed should match s2 = fd.RandomStratification(n_bins=3, seed=42) self.assertEqual(bin, s2.get_type(mock_variant)) # Test with only 1 bin (should always return ""bin1"") s_single_bin = fd.RandomStratification(n_bins=1, seed=42) self.assertEqual(s_single_bin.get_type(mock_variant), 'bin0') # Test invalid num_bins (should raise ValueError) with self.assertRaises(ValueError): fd.RandomStratification(n_bins=0) @staticmethod def test_chunked_stratification(): """""" Test the degeneracy stratification. """""" n_chunks = 7 s = fd.ChunkedStratification(n_chunks=n_chunks) p = fd.Parser( vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', n=20, stratifications=[s] ) sfs = p.parse() sfs.plot() # assert total number of sites assert np.round(sfs.all.data.sum()) == 10000 - p.n_skipped assert s.n_valid == 10000 - p.n_skipped assert len(sfs.types) == n_chunks # assert that all types are a subset of the stratification assert set(sfs.types).issubset(set(s.get_types())) @pytest.mark.slow def test_vep_stratification(self): """""" Test the VEP for human chr21. """""" p = fd.Parser( vcf='snakemake/results/vcf/sapiens/chr21.vep.vcf.gz', n=20, stratifications=[fd.VEPStratification()] ) sfs = p.parse() sfs.plot() # assert that all types are a subset of the stratification assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) def test_vep_stratification_subset(self): """""" Test the synonymy stratification for a small subset of Betula spp. """""" p = fd.Parser( vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', n=20, max_sites=1000, stratifications=[fd.VEPStratification()] ) sfs = p.parse() sfs.plot() # assert that we have all types self.assertEqual(set(sfs.types), set(p.stratifications[0].get_types())) @pytest.mark.slow def test_snpeff_stratification(self): """""" Test the synonymy stratification against SNPEFF for human chr21. """""" p = fd.Parser( vcf='snakemake/results/vcf/sapiens/chr21.snpeff.vcf.gz', n=20, stratifications=[fd.SnpEffStratification()] ) sfs = p.parse() sfs.plot() # assert that all types are a subset of the stratification assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) @staticmethod def test_base_transition_stratification(): """""" Test the base transition stratification. """""" p = fd.Parser( vcf='resources/genome/betula/all.polarized.subset.10000.vcf.gz', n=20, stratifications=[fd.BaseTransitionStratification()] ) sfs = p.parse() sfs.plot() # assert total number of sites assert sfs.all.data.sum() == 10000 - p.n_skipped # assert that all types are a subset of the stratification assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) @staticmethod def test_transition_transversion_stratification(): """""" Test the transition transversion stratification. """""" p = fd.Parser( vcf='resources/genome/betula/all.polarized.subset.10000.vcf.gz', n=20, stratifications=[fd.TransitionTransversionStratification()] ) sfs = p.parse() sfs.plot() # assert total number of sites assert np.round(sfs.all.data.sum()) == 10000 - p.n_skipped # assert that all types are a subset of the stratification assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) @staticmethod def test_base_context_stratification(): """""" Test the base context stratification. """""" p = fd.Parser( vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', n=20, stratifications=[fd.BaseContextStratification(fasta='resources/genome/betula/genome.subset.20.fasta')] ) sfs = p.parse() sfs.plot() # assert total number of sites assert sfs.all.data.sum() == 10000 - p.n_skipped # assert that all types are a subset of the stratification assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) @staticmethod def test_reference_base_stratification(): """""" Test the reference base stratification. """""" p = fd.Parser( vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', n=20, stratifications=[fd.AncestralBaseStratification()] ) sfs = p.parse() sfs.plot() # assert total number of sites assert np.round(sfs.all.data.sum()) == 10000 - p.n_skipped # assert that all types are a subset of the stratification assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) def test_parse_vcf_chr21_test(self): """""" Parse human chr21 test VCF file. """""" p = fd.Parser( vcf=""resources/genome/sapiens/chr21_test.vcf.gz"", gff=""resources/genome/sapiens/hg38.sorted.gtf.gz"", fasta=""http://hgdownload.soe.ucsc.edu/goldenPath/hg38/chromosomes/chr21.fa.gz"", n=20, annotations=[ fd.DegeneracyAnnotation(), fd.MaximumParsimonyAncestralAnnotation() ], filtrations=[ fd.CodingSequenceFiltration() ], stratifications=[fd.DegeneracyStratification()], max_sites=100000 ) sfs = p.parse() self.assertEqual(np.round(sfs.all.data.sum()), 6) def test_parse_betula_vcf_biallelic_infer_monomorphic_subset(self): """""" Parse a subset of the VCF file of Betula spp. """""" p = fd.Parser( vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", fasta=""resources/genome/betula/genome.subset.20.fasta"", gff=""resources/genome/betula/genome.gff.gz"", target_site_counter=fd.TargetSiteCounter( n_samples=1000000, n_target_sites=100000 ), n=20, max_sites=10000, annotations=[ fd.DegeneracyAnnotation(), fd.MaximumParsimonyAncestralAnnotation() ], filtrations=[ fd.CodingSequenceFiltration() ], stratifications=[fd.DegeneracyStratification()] ) sfs = p.parse() self.assertEqual(sfs.n_sites.sum(), 100000) # assert fixed number of target sites # self.assertAlmostEqual(sfs['neutral'].n_sites, 18897.233850, places=5) # self.assertAlmostEqual(sfs['selected'].n_sites, 81102.766149, places=5) def test_filter_out_all_raises_warning(self): """""" Test that filtering out all sites logs a warning. """""" p = fd.Parser( vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", n=20, filtrations=[fd.AllFiltration()] ) with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe')): p.parse() @staticmethod def test_parser_no_stratifications(): """""" Test that filtering out all sites logs a warning. """""" p = fd.Parser( vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", n=20, stratifications=[] ) sfs = p.parse() assert 'all' in sfs.types @staticmethod def test_parse_betula_vcf(): """""" Parse the VCF file of Betula spp. """""" p = fd.Parser( vcf=""resources/genome/betula/all.polarized.subset.10000.vcf.gz"", fasta=""resources/genome/betula/genome.subset.20.fasta"", gff=""resources/genome/betula/genome.gff.gz"", n=20, annotations=[ fd.DegeneracyAnnotation(), fd.MaximumParsimonyAncestralAnnotation() ], filtrations=[ fd.CodingSequenceFiltration() ], stratifications=[fd.DegeneracyStratification()] ) sfs = p.parse() pass def test_parse_betula_vcf_degeneracy_vs_synonymy(self): """""" Parse the VCF file of Betula spp. """""" p = fd.Parser( vcf=""resources/genome/betula/all.polarized.subset.10000.vcf.gz"", fasta=""resources/genome/betula/genome.subset.20.fasta"", gff=""resources/genome/betula/genome.gff.gz"", n=20, annotations=[ fd.DegeneracyAnnotation(), fd.SynonymyAnnotation() ], filtrations=[ fd.CodingSequenceFiltration() ], stratifications=[ fd.DegeneracyStratification(), fd.SynonymyStratification() ] ) sfs = p.parse() # make sure we only have equivalent types self.assertEqual(set(sfs.data.columns), {'neutral.neutral', 'selected.selected'}) @pytest.mark.slow def test_parse_betula_complete_vcf_biallelic_synonymy(self): """""" Parse the VCF file of Betula spp. """""" p = fd.Parser( vcf=""resources/genome/betula/biallelic.polarized.vcf.gz"", fasta=""resources/genome/betula/genome.fasta"", gff=""resources/genome/betula/genome.gff.gz"", n=10, annotations=[ fd.SynonymyAnnotation() ], filtrations=[ fd.CodingSequenceFiltration() ], stratifications=[fd.SynonymyStratification()] ) sfs = p.parse() sfs.plot() @pytest.mark.slow def test_parse_betula_complete_from_remote(self): """""" Parse the VCF file of Betula spp. using remote files. """""" parsers = [] spectra = [] for outgroups in [[""ERR2103730""], [""ERR2103730"", ""ERR2103731""]]: p = fd.Parser( vcf=""https://github.com/Sendrowski/fastDFE/blob/dev/resources/"" ""genome/betula/biallelic.polarized.subset.50000.vcf.gz?raw=true"", fasta=""https://github.com/Sendrowski/fastDFE/blob/dev/resources/"" ""genome/betula/genome.subset.1000.fasta.gz?raw=true"", gff=""https://github.com/Sendrowski/fastDFE/blob/dev/resources/"" ""genome/betula/genome.gff.gz?raw=true"", n=10, subsample_mode='random', annotations=[ fd.DegeneracyAnnotation(), fd.MaximumLikelihoodAncestralAnnotation( n_ingroups=10, outgroups=outgroups, subsample_mode='random' ) ], filtrations=[ fd.CodingSequenceFiltration(), fd.ExistingOutgroupFiltration(outgroups=outgroups) ], stratifications=[fd.DegeneracyStratification()], max_sites=10000 ) sfs = p.parse() sfs.plot() parsers.append(p) spectra.append(sfs) # noinspection all # using two outgroups produces bad results as the two outgroups are too close to each other site_info = dict( one_outgroup=pd.DataFrame(parsers[0].annotations[1].get_inferred_site_info()), two_outgroups=pd.DataFrame(parsers[1].annotations[1].get_inferred_site_info()) ) pass @pytest.mark.slow def test_parse_betula_compare_monomorphic_vcf_with_inferred_monomorphic_betula(self): """""" Parse the VCF file of Betula spp. """""" p = fd.Parser( vcf=""resources/genome/betula/all.polarized.vcf.gz"", fasta=""resources/genome/betula/genome.fasta"", gff=""resources/genome/betula/genome.gff.gz"", target_site_counter=None, # max_sites=100000, n=20, annotations=[fd.DegeneracyAnnotation()], filtrations=[fd.CodingSequenceFiltration()], stratifications=[fd.DegeneracyStratification()] ) sfs = p.parse() p2 = fd.Parser( vcf=""resources/genome/betula/biallelic.polarized.vcf.gz"", fasta=""resources/genome/betula/genome.fasta"", gff=""resources/genome/betula/genome.gff.gz"", target_site_counter=fd.TargetSiteCounter( n_samples=100000, n_target_sites=sfs.n_sites.sum() ), # max_sites=100000, n=20, annotations=[fd.DegeneracyAnnotation()], filtrations=[fd.CodingSequenceFiltration()], stratifications=[fd.DegeneracyStratification()] ) sfs2 = p2.parse() infs = [] for spectra in [sfs, sfs2]: inf = fd.BaseInference( sfs_neut=spectra['neutral'], sfs_sel=spectra['selected'], do_bootstrap=True, model=fd.DiscreteFractionalParametrization(), ) inf.run() infs.append(inf) # the ratio of neutral to selected sites should be the same # but is about 0.225 for monomorphic VCF and 0.29 for inferred monomorphic sites fd.Inference.plot_discretized(infs, labels=['monomorphic', 'inferred']) pass @pytest.mark.slow def test_parse_betula_compare_monomorphic_vcf_with_inferred_monomorphic_betula_same_vcf(self): """""" Parse the VCF file of Betula spp. """""" p = fd.Parser( vcf=""resources/genome/betula/all.polarized.vcf.gz"", fasta=""resources/genome/betula/genome.fasta"", gff=""resources/genome/betula/genome.gff.gz"", target_site_counter=None, max_sites=100000, n=20, annotations=[fd.DegeneracyAnnotation()], filtrations=[fd.CodingSequenceFiltration()], stratifications=[fd.DegeneracyStratification()] ) sfs = p.parse() p2 = fd.Parser( vcf=""resources/genome/betula/all.polarized.vcf.gz"", fasta=""resources/genome/betula/genome.fasta"", gff=""resources/genome/betula/genome.gff.gz"", target_site_counter=fd.TargetSiteCounter( n_samples=1000000, n_target_sites=sfs.n_sites.sum() ), max_sites=100000, n=20, annotations=[fd.DegeneracyAnnotation()], filtrations=[fd.SNPFiltration(), fd.CodingSequenceFiltration()], stratifications=[fd.DegeneracyStratification()] ) sfs2 = p2.parse() infs = [] for spectra in [sfs, sfs2]: inf = fd.BaseInference( sfs_neut=spectra['neutral'], sfs_sel=spectra['selected'], do_bootstrap=True, model=fd.DiscreteFractionalParametrization(), parallelize=True ) inf.run() infs.append(inf) fd.Inference.plot_discretized(infs, labels=['monomorphic', 'inferred']) # calculate ratio of neutral to selected sites r1 = sfs['neutral'].data[0] / sfs['selected'].data[0] r2 = sfs2['neutral'].data[0] / sfs2['selected'].data[0] # make sure that the ratio is similar self.assertTrue(abs(r1 - r2) < 0.01) pass @pytest.mark.slow def test_parse_betula_complete_vcf_including_monomorphic(self): """""" Parse the VCF file of Betula spp. """""" p = fd.Parser( vcf=""resources/genome/betula/all.polarized.vcf.gz"", fasta=""resources/genome/betula/genome.fasta"", gff=""resources/genome/betula/genome.gff.gz"", n=20, annotations=[ fd.DegeneracyAnnotation() ], filtrations=[ fd.CodingSequenceFiltration() ], stratifications=[fd.DegeneracyStratification()] ) sfs = p.parse() sfs.plot() pass @staticmethod @pytest.mark.slow def test_parse_human_chr21_from_online_resources(): """""" Parse the VCF for human chr21 file using remote files. """""" # parse selected and neutral SFS from human chromosome 1 p = fd.Parser( vcf=""https://ngs.sanger.ac.uk/production/hgdp/hgdp_wgs.20190516/"" ""hgdp_wgs.20190516.full.chr21.vcf.gz"", fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"", gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", aliases=dict(chr21=['21']), n=8, target_site_counter=fd.TargetSiteCounter( n_samples=1000000, n_target_sites=fd.Annotation.count_target_sites( ""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"" )['21'] ), annotations=[ fd.DegeneracyAnnotation() ], filtrations=[ fd.SNPFiltration(), fd.CodingSequenceFiltration() ], stratifications=[fd.DegeneracyStratification()], info_ancestral='AA_ensembl', skip_non_polarized=True ) sfs = p.parse() sfs.plot() pass def test_target_site_counter_no_fasta(self): """""" Make sure an error is raised when not FASTA file is specified """""" p = fd.Parser( n=10, vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", target_site_counter=fd.TargetSiteCounter( n_target_sites=40000 ), max_sites=10 ) with self.assertRaises(ValueError): p.parse() pass def test_target_site_counter_betula(self): """""" Test whether the monomorphic site counter works on the Betula data. """""" p = fd.Parser( vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", fasta=""resources/genome/betula/genome.subset.20.fasta"", gff=""resources/genome/betula/genome.gff.gz"", max_sites=10000, n=10, target_site_counter=fd.TargetSiteCounter( n_target_sites=40000, n_samples=10000 ), annotations=[ fd.DegeneracyAnnotation() ], stratifications=[fd.DegeneracyStratification()] ) # set log level to DEBUG p.target_site_counter._logger.setLevel(logging.DEBUG) sfs = p.parse() # make sure that the sum of the target sites is correct self.assertEqual(sfs.n_sites.sum(), p.target_site_counter.n_target_sites) # assert that 3 contigs were parsed self.assertEqual(3, len(p._contig_bounds)) def test_target_site_counter_update_target_sites_target_sites_lower_than_polymorphic_raises_warning(self): """""" Test updating the target sites for different spectra. """""" c = fd.TargetSiteCounter( n_target_sites=1000, n_samples=10000 ) # assign a polymorphic SFS to the target site counter c._sfs_polymorphic = fd.Spectra(dict( neutral=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], selected=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] )) with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe.TargetSiteCounter')) as warning: c._update_target_sites(fd.Spectra(dict( # an SFS, decreasing sequence neutral=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], selected=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794] ))) print(warning[1][0]) def test_target_site_counter_update_target_sites_target_sites_no_monomorphic_raises_warning(self): """""" Test updating the target sites for different spectra. """""" c = fd.TargetSiteCounter( n_target_sites=100000, n_samples=10000 ) # assign a polymorphic SFS to the target site counter c._sfs_polymorphic = fd.Spectra(dict( neutral=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], selected=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] )) with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe.TargetSiteCounter')) as warning: c._update_target_sites(fd.Spectra(dict( # an SFS, decreasing sequence neutral=[0, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], selected=[0, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794] ))) print(warning[1][0]) def test_target_site_counter_update_target_sites_sum_coincides_with_given_target_sites(self): """""" Test updating the target sites for different spectra. """""" c = fd.TargetSiteCounter( n_target_sites=100000, n_samples=10000 ) # assign a polymorphic SFS to the target site counter c._sfs_polymorphic = fd.Spectra(dict( neutral=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], selected=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] )) sfs1 = fd.Spectra(dict( neutral=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], selected=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794] )) sfs2 = c._update_target_sites(sfs1) # make sure that the sum of the target sites is the same self.assertEqual(sfs2.n_sites.sum(), 100000) # make sure ratio of neutral to selected is the same self.assertEqual( sfs1.data.loc[0, 'neutral'] / sfs1.data.loc[0, 'selected'], sfs2.data.loc[0, 'neutral'] / sfs2.data.loc[0, 'selected'] ) def test_target_site_counter_update_target_sites_more_entries_sum_coincides_with_given_target_sites(self): """""" Test updating the target sites for different spectra. """""" c = fd.TargetSiteCounter( n_target_sites=100000, n_samples=10000 ) # assign a polymorphic SFS to the target site counter c._sfs_polymorphic = fd.Spectra({ 'type1.neutral': [0, 0, 0, 0, 0, 0], 'type1.selected': [0, 0, 0, 0, 0, 0], 'type2.neutral': [0, 0, 0, 0, 0, 0], 'type2.selected': [0, 0, 0, 0, 0, 0] }) sfs1 = fd.Spectra({ 'type1.neutral': [177130, 997, 441, 228, 156, 117], 'type1.selected': [797939, 1329, 499, 265, 162, 104], 'type2.neutral': [144430, 114, 83, 105, 109, 652], 'type2.selected': [797939, 117, 90, 94, 119, 794] }) sfs2 = c._update_target_sites(sfs1) # make sure that the sum of the target sites is the same self.assertEqual(sfs2.n_sites.sum(), 100000) @pytest.mark.slow def test_betula_biallelic_dfe_for_different_n_target_sites(self): """""" Test the DFE estimation for different numbers of target sites. """""" n_target_sites = [1000, 10000, 100000, 1000000, 10000000] parsers = [] # parsers spectra = fd.Spectra({}) # spectra inferences = [] # inferences for i, n in enumerate(n_target_sites): p = fd.Parser( vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", fasta=""resources/genome/betula/genome.subset.20.fasta"", gff=""resources/genome/betula/genome.gff.gz"", max_sites=10000, n=10, target_site_counter=fd.TargetSiteCounter( n_target_sites=n, n_samples=100000 ), annotations=[ fd.DegeneracyAnnotation() ], stratifications=[fd.DegeneracyStratification()], filtrations=[fd.SNPFiltration()] ) sfs = p.parse() inf = fd.BaseInference( sfs_neut=sfs['neutral'], sfs_sel=sfs['selected'], do_bootstrap=True, model=fd.DiscreteFractionalParametrization() ) inf.run() parsers.append(p) inferences.append(inf) spectra += sfs.prefix(str(n)) spectra.plot() # very similar results for all n_target_sites fd.Inference.plot_discretized(inferences, labels=list(map(str, n_target_sites))) self.assertTrue((np.array([inf.bootstraps.mean() for inf in inferences]).var(axis=0) < 1e-1).all()) pass @pytest.mark.slow def test_betula_compare_dfe_across_different_samples_sizes_n(self): """""" Test the DFE estimation for different sample sizes. """""" sample_sizes = [5, 10, 15, 20, 25, 30] parsers = [] # parsers spectra = fd.Spectra({}) # spectra inferences = [] # inferences for i, n in enumerate(sample_sizes): p = fd.Parser( vcf=""resources/genome/betula/all.polarized.vcf.gz"", fasta=""resources/genome/betula/genome.fasta"", gff=""resources/genome/betula/genome.gff.gz"", # max_sites=1000000, n=n, annotations=[ fd.DegeneracyAnnotation() ], stratifications=[fd.DegeneracyStratification()] ) sfs = p.parse() inf = fd.BaseInference( sfs_neut=sfs['neutral'], sfs_sel=sfs['selected'], do_bootstrap=True, model=fd.DiscreteFractionalParametrization() ) inf.run() parsers.append(p) inferences.append(inf) spectra += sfs.prefix(str(n)) spectra.plot(use_subplots=True) fd.Inference.plot_discretized(inferences, labels=[f""n={n}"" for n in sample_sizes]) fd.Inference.plot_inferred_parameters(inferences, labels=[f""n={n}"" for n in sample_sizes], scale='lin') @pytest.mark.skip(reason=""takes too long"") def test_human_chr1_compare_dfe_across_different_samples_sizes_n(self): """""" Test the DFE estimation for different sample sizes. """""" sample_sizes = [5, 10, 15, 20, 25, 30] parsers = [] # parsers spectra = fd.Spectra({}) # spectra inferences = [] # inferences for i, n in enumerate(sample_sizes): p = fd.Parser( vcf=""https://ngs.sanger.ac.uk/production/hgdp/hgdp_wgs.20190516/"" ""hgdp_wgs.20190516.full.chr1.vcf.gz"", fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" ""dna/Homo_sapiens.GRCh38.dna.chromosome.1.fa.gz"", gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" ""Homo_sapiens.GRCh38.109.chromosome.1.gff3.gz"", aliases=dict(chr1=['1']), n=n, target_site_counter=fd.TargetSiteCounter( n_samples=100000, n_target_sites=fd.Annotation.count_target_sites( file=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" ""Homo_sapiens.GRCh38.109.chromosome.1.gff3.gz"" )['1'] ), annotations=[ fd.DegeneracyAnnotation() ], filtrations=[ fd.CodingSequenceFiltration(), fd.SNPFiltration() ], stratifications=[fd.DegeneracyStratification()], info_ancestral='AA_ensembl' ) sfs = p.parse() inf = fd.BaseInference( sfs_neut=sfs['neutral'], sfs_sel=sfs['selected'], do_bootstrap=True, model=fd.DiscreteFractionalParametrization() ) inf.run() parsers.append(p) inferences.append(inf) spectra += sfs.prefix(str(n)) spectra.plot(use_subplots=True) fd.Inference.plot_discretized(inferences, labels=[f""n={n}"" for n in sample_sizes]) fd.Inference.plot_inferred_parameters(inferences, labels=[f""n={n}"" for n in sample_sizes], scale='lin') pass def test_parser_betula_include_samples(self): """""" Test that the parser includes only the samples that are given in the include_samples parameter. """""" p = fd.Parser( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", n=20, include_samples=['ASP01', 'ASP02', 'ASP03'] ) p._setup() self.assertEqual(np.sum(p._samples_mask), 3) def test_parser_betula_include_all_samples(self): """""" Test that the parser includes all samples if the include_samples parameter is not given. """""" p = fd.Parser( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", n=20 ) p._setup() self.assertEqual(np.sum(p._samples_mask), 377) def test_parser_betula_exclude_two_samples(self): """""" Test that the parser excludes the samples that are given in the exclude_samples parameter. """""" p = fd.Parser( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", n=20, exclude_samples=['ASP01', 'ASP02'] ) p._setup() self.assertEqual(np.sum(p._samples_mask), 375) def test_parser_betula_include_exclude(self): """""" Test that both include and exclude samples work together. """""" p = fd.Parser( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", n=20, include_samples=['ASP01', 'ASP02', 'ASP03'], exclude_samples=['ASP02'] ) p._setup() self.assertEqual(np.sum(p._samples_mask), 2) @staticmethod def test_get_called_genotypes(): """""" Test the get_called_genotypes function. """""" result = get_called_bases([""A|T"", ""C/T"", "".|G""]) expected = np.array(['A', 'T', 'C', 'T', 'G']) np.testing.assert_array_equal(result, expected) @staticmethod @pytest.mark.slow def test_manuscript_example(): """""" Test the example from the manuscript. """""" basepath = (""https://github.com/Sendrowski/fastDFE/"" ""blob/master/resources/genome/betula/"") # instantiate parser p = fd.Parser( n=8, # SFS sample size vcf=(basepath + ""biallelic.with_outgroups."" ""subset.50000.vcf.gz?raw=true""), fasta=basepath + ""genome.subset.1000.fasta.gz?raw=true"", gff=basepath + ""genome.gff.gz?raw=true"", target_site_counter=fd.TargetSiteCounter( n_target_sites=350000 # total number of target sites ), annotations=[ fd.DegeneracyAnnotation(), # determine degeneracy fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""] # use one outgroup ) ], stratifications=[fd.DegeneracyStratification()] ) # obtain SFS spectra: fd.Spectra = p.parse() spectra.plot() def test_count_target_sites_remove_overlaps(self): """""" Test the count_target_sites function with removing overlaps. """""" sites_overlaps = fd.Annotation.count_target_sites('resources/genome/betula/genome.gff.gz', remove_overlaps=True) sites = fd.Annotation.count_target_sites('resources/genome/betula/genome.gff.gz', remove_overlaps=False) for config in sites.keys(): self.assertLessEqual(sites_overlaps[config], sites[config]) def test_invalid_subsample_model_raises_value_error(self): """""" Test that an invalid subsample model raises a ValueError. """""" with self.assertRaises(ValueError): fd.Parser( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", n=20, subsample_mode='invalid' ) def test_probabilistic_polarization_no_aa_prob_tags_same_result_random_subsampling(self): """""" Make sure that probabilistic polarization without AA probability tags yields the same result as without. The used VCF files don't contain AA probability tags. """""" for n in [9, 10]: p1 = fd.Parser( vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", polarize_probabilistically=True, subsample_mode='random', max_sites=1000, n=n ) sfs_prob = p1.parse() p2 = fd.Parser( vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", polarize_probabilistically=False, subsample_mode='random', max_sites=1000, n=n ) sfs_fixed = p2.parse() spectra = fd.Spectra(dict( prob=sfs_prob.all, fixed=sfs_fixed.all )) spectra.plot() self.assertGreater(sfs_prob.all.data.sum(), 0) np.testing.assert_array_equal(sfs_prob.all.data, sfs_fixed.all.data) def test_probabilistic_polarization_no_aa_prob_tags_same_result_probabilistic_subsampling(self): """""" Make sure that probabilistic polarization without AA probability tags yields the same result as without. The used VCF files don't contain AA probability tags. """""" for n in [9, 10]: p1 = fd.Parser( vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", polarize_probabilistically=True, subsample_mode='probabilistic', max_sites=100, n=n ) sfs_prob = p1.parse() p2 = fd.Parser( vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", polarize_probabilistically=False, subsample_mode='probabilistic', max_sites=100, n=n ) sfs_fixed = p2.parse() spectra = fd.Spectra(dict( prob=sfs_prob.all, fixed=sfs_fixed.all )) spectra.plot() self.assertGreater(sfs_prob.all.data.sum(), 0) np.testing.assert_array_equal(sfs_prob.all.data, sfs_fixed.all.data) def test_compare_probabilistic_polarization_vs_fixed_random_subsampling(self): """""" Compare probabilistic polarization with fixed polarization. """""" for n in [19, 20]: p1 = fd.Parser( vcf=""resources/genome/sapiens/hgdp.anc.deg.vcf.gz"", polarize_probabilistically=True, subsample_mode='random', max_sites=10000, n=n ) sfs_prob = p1.parse() p2 = fd.Parser( vcf=""resources/genome/sapiens/hgdp.anc.deg.vcf.gz"", polarize_probabilistically=False, subsample_mode='random', max_sites=10000, n=n ) sfs_fixed = p2.parse() spectra = fd.Spectra(dict( prob=sfs_prob.all, fixed=sfs_fixed.all )) spectra.plot() # mean relative difference much lower than threshold for most bins self.assertLess(np.abs((sfs_prob.all.data - sfs_fixed.all.data) / sfs_fixed.all.data).mean(), 0.3) def test_compare_probabilistic_polarization_vs_fixed_probabilistic_subsampling(self): """""" Compare probabilistic polarization with fixed polarization. """""" for n in [19, 20]: p1 = fd.Parser( vcf=""resources/genome/sapiens/hgdp.anc.deg.vcf.gz"", polarize_probabilistically=True, max_sites=10000, n=n ) sfs_prob = p1.parse() p2 = fd.Parser( vcf=""resources/genome/sapiens/hgdp.anc.deg.vcf.gz"", polarize_probabilistically=False, max_sites=10000, n=n ) sfs_fixed = p2.parse() spectra = fd.Spectra(dict( prob=sfs_prob.all, fixed=sfs_fixed.all )) spectra.plot() # mean relative difference much lower than threshold for most bins self.assertLess(np.abs((sfs_prob.all.data - sfs_fixed.all.data) / sfs_fixed.all.data).mean(), 0.12) ","Python" "Allele","Sendrowski/fastDFE","testing/test_annotation.py",".py","127238","3439","import itertools import logging import os import tempfile from collections import defaultdict from hashlib import md5 from typing import Literal, cast, Tuple from unittest.mock import MagicMock, PropertyMock, patch, Mock import numpy as np import pandas as pd import pytest from matplotlib import pyplot as plt from matplotlib.collections import PathCollection from numpy import testing from pandas.testing import assert_frame_equal import fastdfe as fd from fastdfe.annotation import _ESTSFSAncestralAnnotation, base_indices, SiteConfig, SiteInfo from fastdfe.io_handlers import count_sites, GFFHandler, get_called_bases, DummyVariant from testing import TestCase class AnnotationTestCase(TestCase): """""" Test the annotators. """""" @staticmethod def test_maximum_parsimony_annotation_annotate_site(): """""" Test the maximum parsimony annotation for a single site. """""" # test data cases = [ dict( ingroups=[""sample1"", ""sample2""], samples=[""sample1"", ""sample2"", ""sample3""], gt_bases=np.array([""A/A"", ""A/G"", ""G/G""]), expected=""A"" ), dict( ingroups=[""sample1"", ""sample2""], samples=[""sample1"", ""sample2"", ""sample3""], gt_bases=np.array([""./."", ""C/C"", ""C/C""]), expected=""C"" ), dict( ingroups=[""sample1"", ""sample2""], samples=[""sample1"", ""sample2"", ""sample3""], gt_bases=np.array([""T/T"", ""./."", ""./.""]), expected=""T"" ), dict( ingroups=[""sample1"", ""sample2""], samples=[""sample1"", ""sample2"", ""sample3""], gt_bases=np.array([""./."", ""./."", ""./.""]), expected=""."" ) ] # mock Annotator mock_annotator = MagicMock() type(mock_annotator).info_ancestral = PropertyMock(return_value=""AA"") for test_case in cases: annotation = fd.MaximumParsimonyAncestralAnnotation(samples=test_case[""ingroups""]) annotation._handler = mock_annotator # mock the VCF reader with samples mock_reader = MagicMock() mock_reader.samples = test_case[""samples""] annotation.reader = mock_reader # create ingroup mask annotation.samples_mask = np.isin(annotation.reader.samples, annotation.samples) # mock variant with a dictionary for INFO mock_variant = MagicMock() mock_variant.gt_bases = test_case[""gt_bases""] mock_variant.INFO = {} # run the method annotation.annotate_site(mock_variant) # check if the result matches the expectation assert mock_variant.INFO[annotation._handler.info_ancestral] == test_case[""expected""] def test_maximum_parsimony_annotation_get_ancestral(self): """""" Test the _get_ancestral method. """""" from cyvcf2 import Variant ann = fd.MaximumParsimonyAncestralAnnotation # check that reference is used for dummy variants self.assertEqual('A', ann._get_ancestral(DummyVariant(ref='A', pos=1, chrom=""1""), mask=np.array([]))) # check that only allele is used for monomorphic sites variant = Mock(spec=Variant) variant.is_snp = False variant.REF = 'A' variant.gt_bases = np.array(['G/G', 'A/A']) self.assertEqual('G', ann._get_ancestral(variant, mask=np.array([True, False]))) # check that only allele is used for non-SNPs only if it is a valid base variant = Mock(spec=Variant) variant.is_snp = False variant.REF = 'A' variant.gt_bases = np.array(['GAT/GAT', 'A/A']) self.assertEqual('.', ann._get_ancestral(variant, mask=np.array([True, False]))) # check that only allele is used for non-SNPs only if reference is a valid base variant = Mock(spec=Variant) variant.is_snp = False variant.REF = 'GAT' variant.gt_bases = np.array(['A/A', 'A/A']) self.assertEqual('.', ann._get_ancestral(variant, mask=np.array([True, False]))) # make sure we can pass site without any ingroup calls variant = Mock(spec=Variant) variant.is_snp = False variant.gt_bases = np.array(['./.', './.']) self.assertEqual('.', ann._get_ancestral(variant, mask=np.array([False, True]))) # check that the major allele is used for biallelic sites variant = Mock(spec=Variant) variant.is_snp = True variant.gt_bases = np.array(['A/A', 'G/G', 'G/G']) self.assertEqual('G', ann._get_ancestral(variant, mask=np.array([True, True, True]))) def test_maximum_parsimony_annotation_betula(self): """""" Test the maximum parsimony annotator with the betula dataset. """""" ann = fd.Annotator( vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', output='scratch/test_maximum_parsimony_annotation.vcf', annotations=[fd.MaximumParsimonyAncestralAnnotation()], max_sites=10000 ) ann.annotate() fd.Parser(ann.output, n=20, info_ancestral='BB').parse().plot() # assert number of sites is the same self.assertEqual(10000, count_sites(ann.output)) @staticmethod def test_degeneracy_annotation_human_test_genome(): """""" Test the degeneracy annotator on a small human genome. """""" deg = fd.DegeneracyAnnotation() vcf = ""resources/genome/sapiens/chr21_test.vcf.gz"" ann = fd.Annotator( vcf=vcf, output='scratch/test_degeneracy_annotation_human_test_genome.vcf', fasta=""http://hgdownload.soe.ucsc.edu/goldenPath/hg38/chromosomes/chr21.fa.gz"", gff=""resources/genome/sapiens/hg38.sorted.gtf.gz"", annotations=[deg], ) ann.annotate() # assert number of sites is the same assert count_sites(vcf) == count_sites(ann.output) # assert number of annotated sites and total number of sites assert deg.n_annotated == 7 assert ann.n_sites == 1517 @staticmethod def test_degeneracy_annotation_human_test_genome_uncached(): """""" Test the degeneracy annotator on a small human genome. """""" deg = fd.DegeneracyAnnotation() vcf = ""resources/genome/sapiens/chr21_test.vcf.gz"" ann = fd.Annotator( vcf=vcf, output='scratch/test_degeneracy_annotation_human_test_genome.vcf', fasta=""http://hgdownload.soe.ucsc.edu/goldenPath/hg38/chromosomes/chr21.fa.gz"", gff=""resources/genome/sapiens/hg38.sorted.gtf.gz"", annotations=[deg], cache=False ) ann.annotate() # assert number of sites is the same assert count_sites(vcf) == count_sites(ann.output) # assert number of annotated sites and total number of sites assert deg.n_annotated == 7 assert ann.n_sites == 1517 @staticmethod def test_degeneracy_annotation_human_test_genome_remote_fasta_gzipped(): """""" Test the degeneracy annotator on a small human genome with a remote gzipped fasta file. """""" deg = fd.DegeneracyAnnotation() vcf = ""resources/genome/sapiens/chr21_test.vcf.gz"" ann = fd.Annotator( vcf=vcf, output='scratch/test_degeneracy_annotation_human_test_genome_remote_fasta_gzipped.vcf', fasta=""http://hgdownload.soe.ucsc.edu/goldenPath/hg38/chromosomes/chr21.fa.gz"", gff=""resources/genome/sapiens/hg38.sorted.gtf.gz"", annotations=[deg], ) ann.annotate() # assert number of annotated sites and total number of sites assert deg.n_annotated == 7 assert ann.n_sites == 1517 @staticmethod def test_degeneracy_annotation_betula_subset(): """""" Test the degeneracy annotator. """""" vcf = ""resources/genome/betula/all.subset.100000.vcf.gz"" ann = fd.Annotator( vcf=vcf, output='scratch/test_degeneracy_annotation_betula_subset.vcf', fasta=""resources/genome/betula/genome.subset.20.fasta"", gff=""resources/genome/betula/genome.gff.gz"", annotations=[ fd.DegeneracyAnnotation() ], ) ann.annotate() # assert number of sites is the same assert count_sites(vcf) == count_sites(ann.output) @staticmethod def test_annotator_load_vcf_from_url(): """""" Test the annotator loading a VCF from a URL. """""" ann = fd.Annotator( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", fasta=""resources/genome/betula/genome.subset.20.fasta"", gff=""resources/genome/betula/genome.gff.gz"", output='scratch/test_annotator_load_vcf_from_url.vcf', annotations=[ fd.DegeneracyAnnotation() ], ) ann.annotate() # assert number of sites is the same assert ann.n_sites == 10000 assert count_sites(ann.output) == 10000 @staticmethod def test_compare_synonymy_annotation_with_vep_betula(): """""" Compare the synonymy annotation with VEP for the betula dataset. """""" syn = fd.SynonymyAnnotation() ann = fd.Annotator( vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", output='scratch/test_compare_synonymy_annotation_with_vep_betula.vcf', fasta=""resources/genome/betula/genome.subset.20.fasta"", gff=""resources/genome/betula/genome.gff.gz"", annotations=[syn], ) ann.annotate() assert syn.n_vep_comparisons == 3566 assert len(syn.vep_mismatches) == 0 @pytest.mark.slow def test_compare_synonymy_annotation_with_vep_human_chr21(self): """""" Compare the synonymy annotation with VEP for human chromosome 21. """""" syn = fd.SynonymyAnnotation() ann = fd.Annotator( vcf=""snakemake/results/vcf/sapiens/chr21.vep.vcf.gz"", output=""scratch/test_compare_synonymy_annotation_with_vep_human_chr21.vcf"", fasta=""resources/genome/sapiens/chr21.fasta"", gff=""resources/genome/sapiens/chr21.sorted.gff3"", aliases=dict(chr21=['21']), annotations=[syn] ) ann.annotate() assert syn.n_vep_comparisons == 9804 assert len(syn.vep_mismatches) == 42 @pytest.mark.slow def test_compare_synonymy_annotation_with_snpeff_human_chr21(self): """""" Compare the synonymy annotation with snpEff for human chromosome 21. """""" syn = fd.SynonymyAnnotation() ann = fd.Annotator( vcf=""snakemake/results/vcf/sapiens/chr21.snpeff.vcf.gz"", output=""scratch/test_compare_synonymy_annotation_with_snpeff_human_chr21.vcf"", fasta=""resources/genome/sapiens/chr21.fasta"", gff=""resources/genome/sapiens/hg38.sorted.gtf.gz"", aliases=dict(chr21=['21']), annotations=[syn] ) ann.annotate() assert syn.n_snpeff_comparisons == 11240 assert len(syn.snpeff_mismatches) == 233 @pytest.mark.slow def test_compare_synonymy_annotation_with_vep_hgdp_chr21(self): """""" Compare the synonymy annotation with VEP for HGDP chromosome 21. """""" syn = fd.SynonymyAnnotation() ann = fd.Annotator( vcf=""snakemake/results/vcf/hgdp/21/opts.vep.vcf.gz"", output=""scratch/test_compare_synonymy_annotation_with_vep_hgdp_chr21.vcf"", fasta=""snakemake/results/fasta/hgdp/21.fasta.gz"", gff=""snakemake/results/gff/hgdp/21.gff3.gz"", aliases=dict(chr21=['21']), annotations=[syn] ) ann.annotate() assert syn.n_vep_comparisons == 6010 assert len(syn.vep_mismatches) == 40 def test_get_degeneracy(self): """""" Test the get_degeneracy function. """""" # List of test cases. Each case is a tuple (codon, pos, expected_degeneracy). test_cases = [ ('ATG', 0, 0), # Codon for Methionine (Start), non-degenerate ('ATG', 1, 0), # Codon for Methionine (Start), non-degenerate ('ATG', 2, 0), # Codon for Methionine (Start), non-degenerate ('TGG', 0, 0), # Codon for Tryptophan, non-degenerate ('TGG', 1, 0), # Codon for Tryptophan, non-degenerate ('TGG', 2, 0), # Codon for Tryptophan, non-degenerate ('GCT', 0, 0), # Codon for Alanine, non-degenerate ('GCT', 1, 0), # Codon for Alanine, non-degenerate ('GCT', 2, 4), # Codon for Alanine, 4-fold degenerate ('CGT', 0, 0), # Codon for Arginine, non-degenerate ('CGT', 1, 0), # Codon for Arginine, non-degenerate ('CGT', 2, 4), # Codon for Arginine, 4-fold degenerate ('ACT', 0, 0), # Codon for Threonine, non-degenerate ('ACT', 1, 0), # Codon for Threonine, non-degenerate ('ACT', 2, 4), # Codon for Threonine, 4-fold degenerate ('GAT', 0, 0), # Codon for Aspartic Acid, non-degenerate ('GAT', 1, 0), # Codon for Aspartic Acid, non-degenerate ('GAT', 2, 2), # Codon for Aspartic Acid, 4-fold degenerate ] for codon, pos, expected in test_cases: degeneracy = fd.DegeneracyAnnotation._get_degeneracy(codon, pos) self.assertEqual(degeneracy, expected) def test_is_synonymous(self): # List of test cases. Each case is a tuple (codon1, codon2, expected_result). test_cases = [ ('ATG', 'ATG', True), # Same codons are always synonymous ('GCT', 'GCC', True), # Both code for Alanine ('GCT', 'GTT', False), # GCT codes for Alanine, GTT codes for Valine ('TAA', 'TAG', True), # Both are stop codons ('TAA', 'ATG', False), # TAA is a stop codon, ATG codes for Methionine ('CGT', 'CGG', True), # Both code for Arginine ('GAT', 'GAC', True), # Both code for Aspartic Acid ('TTT', 'TTC', True), # Both code for Phenylalanine ('AAA', 'AAG', True), # Both code for Lysine ('CAA', 'CAG', True), # Both code for Glutamine ('AAT', 'AAC', True), # Both code for Asparagine ('GAA', 'GAG', True), # Both code for Glutamic Acid ('AGA', 'AGG', True), # Both code for Arginine ('CTT', 'CTC', True), # Both code for Leucine ('TAT', 'TAC', True), # Both code for Tyrosine ('CGT', 'AGT', False), # CGT codes for Arginine, AGT codes for Serine ('GGT', 'GCT', False), # GGT codes for Glycine, GCT codes for Alanine ('GAT', 'GGT', False), # GAT codes for Aspartic Acid, GGT codes for Glycine ('AAA', 'AGA', False), # AAA codes for Lysine, AGA codes for Arginine ('CAA', 'GAA', False), # CAA codes for Glutamine, GAA codes for Glutamic Acid ('AAT', 'ACT', False), # AAT codes for Asparagine, ACT codes for Threonine ('GAA', 'GGA', False), # GAA codes for Glutamic Acid, GGA codes for Glycine ('AGA', 'ACA', False), # AGA codes for Arginine, ACA codes for Threonine ('CTT', 'CCT', False), # CTT codes for Leucine, CCT codes for Proline ('TAT', 'TGT', False), # TAT codes for Tyrosine, TGT codes for Cysteine ] for codon1, codon2, expected in test_cases: with self.subTest(codon1=codon1, codon2=codon2): synonymy = fd.SynonymyAnnotation.is_synonymous(codon1, codon2) self.assertEqual(synonymy, expected) @staticmethod def test_count_target_sites(): """""" Test the count_target_sites function. """""" # Define a mock dataframe to be returned by _load_cds mock_df = pd.DataFrame({ 'seqid': ['chr1', 'chr1', 'chr2', 'chr2', 'chr2'], 'start': [1, 100, 1, 100, 200], 'end': [10, 200, 50, 150, 250] }) # We'll patch the _load_cds function to return our mock dataframe with patch.object(GFFHandler, ""_load_cds"", return_value=mock_df): result = GFFHandler(""mock_file.gff"")._count_target_sites() # Our expected result is the sum of the differences between end and start for each 'seqid' expected_result = { 'chr1': (200 - 100 + 1) + (10 - 1 + 1), 'chr2': (50 - 1 + 1) + (150 - 100 + 1) + (250 - 200 + 1) } assert result == expected_result def test_count_target_sites_betula_gff_all_contigs(self): """""" Test the count_target_sites function on the Betula gff file. """""" gff = ""resources/genome/betula/genome.gff.gz"" target_sites = fd.Annotation.count_target_sites(gff) self.assertEqual(3273, len(target_sites)) self.assertEqual(337816, target_sites['Contig0']) def test_count_target_sites_betula_gff_some_contigs(self): """""" Test the count_target_sites function on the Betula gff file. """""" gff = ""resources/genome/betula/genome.gff.gz"" target_sites = fd.Annotation.count_target_sites(gff, contigs=['Contig0', 'Contig10']) self.assertEqual(2, len(target_sites)) self.assertEqual(337816, target_sites['Contig0']) self.assertEqual(4992, target_sites['Contig10']) def test_aliases_empty_dict(self): """""" Test aliases when no aliases are given. """""" contig_aliases = {} expected_mappings = {} expected_aliases_expanded = {} mappings, aliases_expanded = fd.FileHandler._expand_aliases(contig_aliases) self.assertEqual(mappings, expected_mappings) self.assertEqual(aliases_expanded, expected_aliases_expanded) def test_aliases_single_contig(self): """""" Test aliases when a single contig is given. """""" contig_aliases = {'chr1': ['1']} expected_mappings = {'chr1': 'chr1', '1': 'chr1'} expected_aliases_expanded = {'chr1': ['1', 'chr1']} mappings, aliases_expanded = fd.FileHandler._expand_aliases(contig_aliases) self.assertEqual(mappings, expected_mappings) self.assertEqual(aliases_expanded, expected_aliases_expanded) def test_aliases_multiple_contigs(self): """""" Test aliases when multiple contigs are given. """""" contig_aliases = {'chr1': ['1'], 'chr2': ['2']} expected_mappings = {'chr1': 'chr1', '1': 'chr1', 'chr2': 'chr2', '2': 'chr2'} expected_aliases_expanded = {'chr1': ['1', 'chr1'], 'chr2': ['2', 'chr2']} mappings, aliases_expanded = fd.FileHandler._expand_aliases(contig_aliases) self.assertEqual(mappings, expected_mappings) self.assertEqual(aliases_expanded, expected_aliases_expanded) def test_aliases_multiple_aliases(self): """""" Test aliases when multiple aliases are given for a single contig. """""" contig_aliases = {'chr1': ['1', 'one']} expected_mappings = {'chr1': 'chr1', '1': 'chr1', 'one': 'chr1'} expected_aliases_expanded = {'chr1': ['1', 'one', 'chr1']} mappings, aliases_expanded = fd.FileHandler._expand_aliases(contig_aliases) self.assertEqual(mappings, expected_mappings) self.assertEqual(aliases_expanded, expected_aliases_expanded) def test_degeneracy_annotation_get_degeneracy_table(self): """""" Test the get_degeneracy_table method. """""" t = fd.DegeneracyAnnotation._get_degeneracy_table() self.assertEqual(64, len(t)) self.assertEqual(t['AAA'], '002') self.assertEqual(t['GCT'], '004') class MaximumLikelihoodAncestralAnnotationTestCase(TestCase): """""" Test the MaximumLikelihoodAncestralAnnotation class. """""" @staticmethod def compare_with_est_sfs( anc: fd.MaximumLikelihoodAncestralAnnotation, cache: str = None ) -> Tuple[_ESTSFSAncestralAnnotation, pd.DataFrame]: """""" Compare the results of the MaximumLikelihoodAncestralAnnotation class with the results of EST-SFS. :param anc: An instance of the MaximumLikelihoodAncestralAnnotation class. :param cache: The cache file to use for the EST-SFS results if any. """""" if cache is not None and os.path.exists(cache): est_sfs = _ESTSFSAncestralAnnotation.from_file(cache) fd.logger.info(f""Loading EST-SFS results from cache: {cache}"") else: est_sfs = _ESTSFSAncestralAnnotation(anc) if anc.prior is None: binary = ""resources/EST-SFS/cmake-build-debug/EST_SFS_no_prior"" else: binary = ""resources/EST-SFS/cmake-build-debug/EST_SFS_with_prior"" est_sfs.infer(binary=binary) if cache is not None: est_sfs.to_file(cache) fd.logger.info(f""Caching EST-SFS results to: {cache}"") # get site information site_info = pd.DataFrame([s.__dict__ for s in anc.get_inferred_site_info()]) # prefix columns site_info.columns = ['native.' + col for col in site_info.columns] # add EST-SFS results to site information site_info['est_sfs.config'] = est_sfs.probs.config.to_list() site_info['est_sfs.p_major_ancestral'] = est_sfs.probs.prob.to_list() return est_sfs, site_info def test_negative_lower_bounds_raises_value_error(self): """""" Test that a ValueError is raised when the lower bound of a parameter is negative. """""" with self.assertRaises(ValueError): fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_runs=3, n_ingroups=5, model=fd.JCSubstitutionModel(bounds=dict(k=(-1, 1))) ) def test_get_p_tree_one_outgroup(self): """""" Test the get_p_tree function with one outgroup. """""" params = dict( k=2, K0=0.5 ) model = fd.K2SubstitutionModel() for base, outgroup_base in itertools.product(range(4), range(4)): p = fd.MaximumLikelihoodAncestralAnnotation.get_p_tree( base=base, n_outgroups=1, internal_nodes=[], outgroup_bases=[outgroup_base], model=model, params=dict( k=2, K0=0.5 ) ) p_expected = model._get_prob( b1=base, b2=outgroup_base, i=0, params=params ) self.assertEqual(p, p_expected) def test_get_p_tree_two_outgroups(self): """""" Test the get_p_tree function with two outgroups. """""" params = dict( k=2, K0=0.5, K1=0.25, K2=0.125 ) model = fd.K2SubstitutionModel() for base, outgroup_base1, outgroup_base2, internal_node in itertools.product(range(4), repeat=4): p = fd.MaximumLikelihoodAncestralAnnotation.get_p_tree( base=base, n_outgroups=2, internal_nodes=[internal_node], outgroup_bases=[outgroup_base1, outgroup_base2], params=params, model=model ) p_expected = (model._get_prob(base, internal_node, 0, params) * model._get_prob(internal_node, outgroup_base1, 1, params) * model._get_prob(internal_node, outgroup_base2, 2, params)) self.assertEqual(p, p_expected) def test_get_p_site_three_outgroups(self): """""" Test the get_p_site function with three outgroups. """""" params = dict( k=2, K0=0.5, K1=0.25, K2=0.125, K3=0.0625, K4=0.03125 ) model = fd.K2SubstitutionModel() for base, out1, out2, out3, int_node1, int_node2 in itertools.product(range(4), repeat=6): p = fd.MaximumLikelihoodAncestralAnnotation.get_p_tree( base=base, n_outgroups=3, internal_nodes=[int_node1, int_node2], outgroup_bases=[out1, out2, out3], model=model, params=dict( k=2, K0=0.5, K1=0.25, K2=0.125, K3=0.0625, K4=0.03125 ) ) p_expected = (model._get_prob(base, int_node1, 0, params) * model._get_prob(int_node1, out1, 1, params) * model._get_prob(int_node1, int_node2, 2, params) * model._get_prob(int_node2, out2, 3, params) * model._get_prob(int_node2, out3, 4, params)) self.assertEqual(p, p_expected) def test_fixed_params_different_branch_rates(self): """""" Test the MaximumLikelihoodAncestralAnnotation class with fixed parameters and different branch rates. """""" anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=""resources/EST-SFS/test-data.txt"", n_runs=10, parallelize=False, model=fd.K2SubstitutionModel(fixed_params=dict(k=2, K0=0.5, K2=0.125)) ) anc.infer() self.assertEqual(anc.params_mle['k'], 2) self.assertEqual(anc.params_mle['K0'], 0.5) self.assertEqual(anc.params_mle['K2'], 0.125) self.assertNotEqual(anc.params_mle['K1'], 0.5) self.assertNotEqual(anc.params_mle['K3'], 0.125) def test_fixed_params_same_branch_rates(self): """""" Test the MaximumLikelihoodAncestralAnnotation class with fixed parameters and same branch rates. """""" anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=""resources/EST-SFS/test-data.txt"", n_runs=10, parallelize=True, model=fd.K2SubstitutionModel(fixed_params=dict(k=2, K=0.5), pool_branch_rates=True) ) anc.infer() self.assertEqual(anc.params_mle['k'], 2) self.assertEqual(anc.params_mle['K'], 0.5) @staticmethod def test_expected_ancestral_alleles_fixed_branch_rate_inferred_site_info_kingman_prior(): """""" Test the expected ancestral alleles with fixed branch rates and inferred site information. """""" configs = [ dict(n_major=15, major_base='A', minor_base='C', outgroup_bases=['A', '.', '.'], ancestral_expected='A'), dict(n_major=15, major_base='G', minor_base=None, outgroup_bases=['G', '.', '.'], ancestral_expected='G'), dict(n_major=15, major_base='C', minor_base='A', outgroup_bases=['.', '.', '.'], ancestral_expected='C'), dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['A', 'T', '.'], ancestral_expected='A'), dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['T', 'A', '.'], ancestral_expected='A'), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['T', 'C', 'C'], ancestral_expected='T'), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['G', '.', '.'], ancestral_expected='T'), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T', '.'], ancestral_expected='T'), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['T', 'C', 'C'], ancestral_expected='T'), dict(n_major=15, major_base='G', minor_base=None, outgroup_bases=['A', 'C', 'T'], ancestral_expected='G'), dict(n_major=15, major_base=None, minor_base=None, outgroup_bases=['A', 'C', 'T'], ancestral_expected='.'), dict(n_major=15, major_base=None, minor_base=None, outgroup_bases=['.', '.', '.'], ancestral_expected='.'), # this is counterintuitive, but we can only consider bases that are present in the ingroup dict(n_major=15, major_base='A', minor_base=None, outgroup_bases=['T', 'T', '.'], ancestral_expected='A'), dict(n_major=15, major_base='A', minor_base=None, outgroup_bases=['T', 'T', 'T'], ancestral_expected='A'), # this works because 'T' is present in the ingroup dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['T', 'T', 'T'], ancestral_expected='T'), dict(n_major=20, major_base='A', minor_base='T', outgroup_bases=['T', 'T', 'T'], ancestral_expected='T'), # this again doesn't work because 'T' is not present in the ingroup dict(n_major=15, major_base='A', minor_base='G', outgroup_bases=['T', 'T', 'T'], ancestral_expected='A'), ] anc = fd.MaximumLikelihoodAncestralAnnotation.from_data( n_major=[c['n_major'] for c in configs], major_base=[c['major_base'] for c in configs], minor_base=[c['minor_base'] for c in configs], outgroup_bases=[c['outgroup_bases'] for c in configs], n_ingroups=20, prior=fd.KingmanPolarizationPrior(allow_divergence=True), model=fd.JCSubstitutionModel(pool_branch_rates=True, fixed_params=dict(K=0.1)), parallelize=False ) anc.infer() summary = pd.DataFrame([s.__dict__ for s in anc.get_inferred_site_info()]) summary['expected'] = [c['ancestral_expected'] for c in configs] testing.assert_array_equal(summary.major_ancestral.values, summary.expected.values) def test_raises_error_when_zero_outgroups_given(self): """""" Test that an error is raised when zero outgroups are given. """""" with self.assertRaises(ValueError): fd.MaximumLikelihoodAncestralAnnotation( outgroups=[], n_ingroups=10 ) def test_outgroup_not_found_raises_error(self): """""" Test that an error is raised when an outgroup is not found. """""" with self.assertRaises(ValueError) as context: anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""blabla""], n_ingroups=10 ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_outgroup_not_found_raises_error.vcf', annotations=[anc], max_sites=10 ) ann.annotate() # Print the caught error message print(""Caught error: "" + str(context.exception)) def test_more_ingroups_than_ingroup_samples_raises_warning(self): """""" Test that a warning is raised when more ingroups are specified than ingroup samples are present. """""" with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe')): anc = fd.MaximumLikelihoodAncestralAnnotation( ingroups=[""ASP04"", ""ASP05""], outgroups=[""ERR2103730"", ""ERR2103731""], n_ingroups=5 ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_fewer_ingroups_than_ingroup_samples_raises_warning.vcf', annotations=[anc], max_sites=10 ) ann.annotate() @staticmethod def test_explicitly_specified_present_samples_raises_no_error(): """""" Test that an error is raised when an outgroup is not found. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( ingroups=[""ASP04"", ""ASP05""], outgroups=[""ERR2103730"", ""ERR2103731""], n_ingroups=2 ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_explicitly_specified_present_samples_raises_no_error.vcf', annotations=[anc], max_sites=10 ) ann.annotate() def test_exclude_ingroups_no_implicit_ingroups(self): """""" Test that the exclude parameter works. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( exclude=[""ASP04"", ""ASP05"", ""ASP06""], outgroups=[""ERR2103730"", ""ERR2103731""], n_ingroups=2, ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_explicitly_specified_present_samples_raises_no_error.vcf', annotations=[anc], max_sites=10 ) ann.annotate() self.assertEqual(anc._ingroup_mask.sum(), 374) def test_exclude_ingroups_no_explicit_ingroups(self): """""" Test that the exclude parameter works. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( ingroups=[""ASP01"", ""ASP02"", ""ASP03"", ""ASP04"", ""ASP05"", ""ASP06""], exclude=[""ASP04"", ""ASP05"", ""ASP06""], outgroups=[""ERR2103730"", ""ERR2103731""], n_ingroups=2, ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_explicitly_specified_present_samples_raises_no_error.vcf', annotations=[anc], max_sites=10 ) ann.annotate() self.assertEqual(anc._ingroup_mask.sum(), 3) def test_get_likelihood_outgroup_ancestral_allele_annotation(self): """""" Test the get_likelihood function. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_ingroups=10, prior=None ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_get_likelihood_outgroup_ancestral_allele_annotation.vcf', annotations=[anc], max_sites=10000 ) ann.annotate() self.assertEqual(anc.evaluate_likelihood(anc.params_mle), anc.likelihood) @pytest.mark.slow def test_run_inference_full_betula_dataset(self): """""" Test the get_likelihood function. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_ingroups=10, prior=None, model=fd.K2SubstitutionModel(), parallelize=True ) ann = fd.Annotator( vcf=""resources/genome/betula/biallelic.with_outgroups.vcf.gz"", output='scratch/test_get_likelihood_full_betula_dataset.vcf', annotations=[anc], max_sites=100000 ) ann.annotate() anc.to_est_sfs(""resources/EST-SFS/test-betula-biallelic-100000.txt"") self.assertEqual(anc.evaluate_likelihood(anc.params_mle), anc.likelihood) @staticmethod def test_from_est_sfs_est_sfs_sample_dataset(): """""" Test the from_est_sfs function with the est-sfs sample dataset. """""" anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=""resources/EST-SFS/test-data.txt"", model=fd.JCSubstitutionModel(), n_runs=10, prior=fd.AdaptivePolarizationPrior(), parallelize=True ) # evaluate a ML estimates of EST-SFS ll = anc.evaluate_likelihood(dict( K0=0.000000, K1=0.061141, K2=0.000000, K3=0.019841, K4=0.019863 )) pass def test_from_est_sfs_input_valid_probs(self): """""" Test that the probabilities are between 0 and 1 when using a prior. """""" anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=""resources/EST-SFS/test-data.txt"", model=fd.JCSubstitutionModel(pool_branch_rates=True), n_runs=10, prior=fd.KingmanPolarizationPrior(), parallelize=False ) anc.infer() self.assertTrue(anc.configs.p_major_ancestral.between(0, 1).all()) @staticmethod def test_from_est_sfs_varied_chunk_sizes(): """""" Test that the chunked and non-chunked versions of the from_est_sfs function return the same results across multiple chunk sizes. """""" test_sizes = [1, 2, 5, 11, 30] reference_chunk_size = 100 # Create a DataFrame using the reference_chunk_size anc_reference = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=""resources/EST-SFS/test-data.txt"", chunk_size=reference_chunk_size ) df_reference = anc_reference.configs.sort_values( by=['n_major', 'major_base', 'minor_base', 'outgroup_bases'] ).reset_index(drop=True).sort_index(axis=1) for chunk_size in test_sizes: anc_test = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=""resources/EST-SFS/test-data.txt"", chunk_size=chunk_size ) df_test = anc_test.configs.sort_values( by=['n_major', 'major_base', 'minor_base', 'outgroup_bases'] ).reset_index(drop=True).sort_index(axis=1) assert_frame_equal(df_reference, df_test, check_dtype=False) def test_to_est_sfs_test_data_no_poly_allelic(self): """""" Test the to_est_sfs function. """""" file_in = ""resources/EST-SFS/test-data-no-poly-allelic.txt"" file_out = ""scratch/test_to_est_sfs.txt"" anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=file_in, model=fd.JCSubstitutionModel(pool_branch_rates=True), n_runs=10, prior=fd.AdaptivePolarizationPrior(), parallelize=False ) anc.to_est_sfs(file_out) # compare files with open(file_in, 'r') as f1, open(file_out, 'r') as f2: for line1, line2 in zip(f1, f2): self.assertEqual(line1.strip(), line2.strip()) def test_to_est_sfs_betula_biallelic(self): """""" Test the to_est_sfs function. """""" file_in = ""resources/EST-SFS/test-betula-biallelic-10000.txt"" file_out = ""scratch/test_to_est_sfs_betula_biallelic_10000.txt"" anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=file_in, model=fd.JCSubstitutionModel(pool_branch_rates=True), n_runs=10, prior=fd.AdaptivePolarizationPrior(), parallelize=False ) anc.to_est_sfs(file_out) # compare files with open(file_in, 'r') as f1, open(file_out, 'r') as f2: for i, (line1, line2) in enumerate(zip(f1, f2)): self.assertEqual(line1.strip(), line2.strip()) def test_parallelize_unequal_likelihoods(self): """""" Test that the parallelize function works correctly when the likelihoods are not equal. """""" anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=""resources/EST-SFS/test-data.txt"", n_runs=10, parallelize=True ) anc.infer() self.assertFalse(np.all(anc.likelihoods[0] == anc.likelihoods)) def test_get_observed_transition_transversion_ratio(self): """""" Test that the get_observed_transition_transversion_ratio function works as expected. """""" anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=""resources/EST-SFS/test-data.txt"", n_runs=10, parallelize=True ) r = anc.get_observed_transition_transversion_ratio() self.assertEqual(r, 8 / 3) def test_K2_model_not_fix_transition_transversion_ratio(self): """""" Test that not fixing the transition transversion ratio in the K2 model works as expected. """""" anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=""resources/EST-SFS/test-data.txt"", n_runs=10, parallelize=True, model=fd.K2SubstitutionModel(fix_transition_transversion_ratio=False) ) self.assertTrue('k' not in anc.model.fixed_params) def test_K2_model_fix_transition_transversion_ratio(self): """""" Test that fixing the transition transversion ratio in the K2 model works as expected. """""" anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=""resources/EST-SFS/test-data.txt"", n_runs=10, parallelize=True, model=fd.K2SubstitutionModel(fix_transition_transversion_ratio=True) ) self.assertEqual(anc.model.fixed_params['k'], anc.get_observed_transition_transversion_ratio()) def test_from_data_chunked(self): """""" Test that the from_data function produces the expected results. """""" anc = fd.MaximumLikelihoodAncestralAnnotation.from_data( n_major=[13, 15, 17, 11], major_base=['A', 'C', 'G', 'T'], minor_base=['C', 'G', 'T', 'A'], outgroup_bases=[['A', 'C'], ['G', 'G'], ['G', 'G'], ['A', 'A']], n_ingroups=20 ) cols = ['n_major', 'major_base', 'minor_base', 'outgroup_bases', 'sites', 'multiplicity'] self.assertDictEqual(anc.configs[cols].to_dict(), { 'major_base': {0: 0, 1: 1, 2: 2, 3: 3}, 'minor_base': {0: 1, 1: 2, 2: 3, 3: 0}, 'outgroup_bases': {0: (0, 1), 1: (2, 2), 2: (2, 2), 3: (0, 0)}, 'n_major': {0: 13, 1: 15, 2: 17, 3: 11}, 'sites': {0: [0], 1: [1], 2: [2], 3: [3]}, 'multiplicity': {0: 1, 1: 1, 2: 1, 3: 1}, }) def test_upper_bounds_larger_than_lower_bounds_raises_value_error(self): """""" Test that a ValueError is raised when the lower bound of a parameter is negative. """""" with self.assertRaises(ValueError) as context: fd.JCSubstitutionModel(bounds=dict(K=(10, 9))) # Print the caught error message print(""Caught error: "" + str(context.exception)) def test_zero_lower_bound_raises_value_error(self): """""" Test that a ValueError is raised when the lower bound of a parameter is zero. """""" with self.assertRaises(ValueError) as context: fd.JCSubstitutionModel(bounds=dict(K=(0, 9))) # Print the caught error message print(""Caught error: "" + str(context.exception)) @pytest.mark.slow def test_papio_thorough_two_outgroups(self): """""" Test the MLEAncestralAlleleAnnotation class on the Papio vcf file. """""" samples = pd.read_csv(""resources/genome/papio/metadata.csv"") anc = fd.MaximumLikelihoodAncestralAnnotation( ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), outgroups=[ samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') ], n_runs=10, n_ingroups=10, parallelize=True, prior=fd.KingmanPolarizationPrior(), confidence_threshold=0, max_sites=10000 ) ann = fd.Annotator( vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", output='scratch/test_papio_thorough_two_outgroups.vcf', annotations=[anc], max_sites=10000 ) ann.annotate() self.assertTrue(anc.is_monotonic()) pass @pytest.mark.slow def test_papio_thorough_three_outgroups(self): """""" Test the MLEAncestralAlleleAnnotation class on the Papio vcf file. """""" samples = pd.read_csv(""resources/genome/papio/metadata.csv"") anc = fd.MaximumLikelihoodAncestralAnnotation( ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), outgroups=[ samples[samples.C_origin == 'Anubis, Ethiopia'].iloc[0].PGDP_ID, samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') ], n_runs=10, n_ingroups=10, parallelize=True, prior=fd.KingmanPolarizationPrior(), confidence_threshold=0, max_sites=10000, subsample_mode='random' ) ann = fd.Annotator( vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", output='scratch/test_papio_thorough_three_outgroups.vcf', annotations=[anc], max_sites=10000 ) # mismatches mostly occur where we are not very confident in the ancestral allele ann.annotate() anc2, site_info = self.compare_with_est_sfs( anc=anc, cache=""testing/cache/est-sfs/test_papio_thorough_three_outgroups.json"" ) diff_params = np.array(list(anc2.params_mle.values())) / np.array(list(anc.params_mle.values())) # mle estimates are very similar self.assertTrue(np.all(((0.6 < diff_params) & (diff_params < 1.5)) | (diff_params == 0))) self.assertTrue(anc.is_monotonic()) pass @pytest.mark.slow def test_papio_thorough_three_outgroups_adaptive_prior(self): """""" Test the MLEAncestralAlleleAnnotation class on the Papio vcf file. """""" samples = pd.read_csv(""resources/genome/papio/metadata.csv"") anc = fd.MaximumLikelihoodAncestralAnnotation( ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), outgroups=[ samples[samples.C_origin == 'Anubis, Ethiopia'].iloc[0].PGDP_ID, samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') ], n_runs=10, n_ingroups=10, parallelize=True, prior=fd.AdaptivePolarizationPrior(), confidence_threshold=0, max_sites=10000 ) ann = fd.Annotator( vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", output='scratch/test_papio_thorough_three_outgroups.vcf', annotations=[anc], max_sites=10000 ) # mismatches mostly occur where we are not very confident in the ancestral allele ann.annotate() self.assertTrue(anc.is_monotonic()) pass @pytest.mark.skip(""Too slow"") def test_papio_thorough_four_outgroups(self): """""" Test the MLEAncestralAlleleAnnotation class on the Papio vcf file. """""" samples = pd.read_csv(""resources/genome/papio/metadata.csv"") anc = fd.MaximumLikelihoodAncestralAnnotation( ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), outgroups=[ samples[samples.C_origin == 'Anubis, Ethiopia'].iloc[0].PGDP_ID, samples[samples.Species == 'hamadryas'].iloc[0].PGDP_ID.replace('Sci_', ''), samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') ], n_runs=10, n_ingroups=10, parallelize=True, prior=fd.KingmanPolarizationPrior(), confidence_threshold=0, max_sites=10000 ) ann = fd.Annotator( vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", output='scratch/test_papio_thorough_four_outgroups.vcf', annotations=[anc], max_sites=10000 ) # mismatches mostly occur where we are not very confident in the ancestral allele ann.annotate() self.assertTrue(anc.is_monotonic()) pass @pytest.mark.slow def test_betula_thorough_two_outgroups(self): """""" Test the MLEAncestralAlleleAnnotation class on the betula vcf file. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_runs=50, n_ingroups=10, parallelize=True, prior=fd.KingmanPolarizationPrior() ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.vcf.gz"", output='scratch/test_betula_thorough.vcf', annotations=[anc], max_sites=100000 ) ann.annotate() anc.evaluate_likelihood(anc.params_mle) anc.plot_likelihoods() # the two outgroup have a very similar divergence from the ingroup # self.assertTrue(anc._is_monotonic()) pass @pytest.mark.slow def test_betula_thorough_one_outgroup(self): """""" Test the MLEAncestralAlleleAnnotation class on the betula vcf file. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], n_runs=50, n_ingroups=10, parallelize=True, prior=fd.KingmanPolarizationPrior() ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.vcf.gz"", output='scratch/test_betula_thorough.vcf', annotations=[anc], max_sites=100000 ) ann.annotate() anc.evaluate_likelihood(anc.params_mle) anc.plot_likelihoods() self.assertTrue(anc.is_monotonic()) pass @staticmethod def test_betula_K2_model(): """""" Test the MLEAncestralAlleleAnnotation class on the betula vcf file. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_runs=10, n_ingroups=5, model=fd.K2SubstitutionModel(), prior=fd.KingmanPolarizationPrior() ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_betula_use_prior_K2_model.vcf', annotations=[anc], max_sites=1000 ) ann.annotate() pass @staticmethod def test_betula_JC_model(): """""" Test the MLEAncestralAlleleAnnotation class on the betula vcf file. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_runs=3, n_ingroups=5, model=fd.JCSubstitutionModel(), prior=fd.KingmanPolarizationPrior() ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_betula_use_prior_JC_model.vcf', annotations=[anc], max_sites=1000 ) ann.annotate() pass @staticmethod def test_betula_no_prior(): """""" Test the MLEAncestralAlleleAnnotation class on the betula vcf file. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_runs=3, n_ingroups=5, prior=None ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_betula_not_use_prior.vcf', annotations=[anc], max_sites=1000 ) ann.annotate() anc.plot_likelihoods() @staticmethod def test_adhoc_ancestral_annotation_random_subsampling_betula(): """""" Test the AdhocAncestralAnnotation class on the betula vcf file. """""" anc = fd.annotation.AdHocAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_ingroups=5, subsample_mode='random' ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_betula_not_use_prior.vcf', annotations=[anc], max_sites=1000 ) ann.annotate() @staticmethod def test_adhoc_ancestral_annotation_probabilistic_subsampling_betula(): """""" Test the AdhocAncestralAnnotation class on the betula vcf file. """""" anc = fd.annotation.AdHocAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_ingroups=5, subsample_mode='probabilistic' ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_betula_not_use_prior.vcf', annotations=[anc], max_sites=1000 ) ann.annotate() @staticmethod def test_n_target_sites_without_fasta_raises_error(): """""" Test that an error is raised when the number of target sites is specified without a fasta file specified. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_runs=3, n_ingroups=5, prior=None, n_target_sites=1000000 ) ann = fd.Annotator( vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_betula_not_use_prior.vcf', annotations=[anc], max_sites=1000 ) with pytest.raises(ValueError) as context: ann.annotate() # Print the caught error message print(context) @staticmethod def test_n_target_sites_lower_than_n_biallelic_raises_error(): """""" Test that an error is raised when the number of target sites is lower than the number of biallelic sites. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_runs=3, n_ingroups=5, prior=None, n_target_sites=10 ) ann = fd.Annotator( vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", fasta=""resources/genome/betula/genome.subset.20.fasta"", output='scratch/test_betula_not_use_prior.vcf', annotations=[anc], max_sites=1000 ) with pytest.raises(ValueError) as context: ann.annotate() # Print the caught error message print(context) def test_n_target_sites_copied_from_target_site_counter_if_specified(self): """""" Test that the n_target_sites parameter is copied from the target_site_counter if it is specified. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_runs=3, n_ingroups=5, prior=None, n_target_sites=100 ) p = fd.Parser( n=10, vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", fasta=""resources/genome/betula/genome.subset.20.fasta"", annotations=[anc], max_sites=10, target_site_counter=fd.TargetSiteCounter( n_target_sites=100, n_samples=1000 ) ) p.parse() self.assertEqual(anc.n_target_sites, p.target_site_counter.n_target_sites) @staticmethod def test_n_target_sites(): """""" Test the n_target_sites parameter. """""" max_sites = 1000 anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], n_runs=3, n_ingroups=5, prior=None, n_target_sites=10000 ) ann = fd.Annotator( vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", output='scratch/test_betula_not_use_prior.vcf', annotations=[anc], max_sites=max_sites, fasta=""resources/genome/betula/genome.subset.20.fasta"" ) ann.annotate() @staticmethod def test_priors_betula_dataset(): """""" Test the EST-SFS wrapper. """""" annotations = [] priors = [fd.KingmanPolarizationPrior(), fd.AdaptivePolarizationPrior()] fig, ax = plt.subplots(1) for i, prior in enumerate(priors): anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=""resources/EST-SFS/test-betula-biallelic-10000.txt"", model=fd.K2SubstitutionModel(), n_runs=10, prior=prior, parallelize=True ) anc.infer() # touch p_polarization to make sure it is calculated _ = anc.p_polarization anc.prior.plot(ax=ax, show=False) annotations.append(anc) # set legend labels ax.legend([p.__class__.__name__ for p in priors]) # set alpha for child in ax.get_children(): if isinstance(child, PathCollection): child.set_alpha(0.5) plt.show() pass @staticmethod @pytest.mark.slow def test_compute_priors_from_betula_vcf_odd_even_number_of_ingroups(): """""" Test the EST-SFS wrapper. """""" annotators = [] priors = [fd.KingmanPolarizationPrior(), fd.AdaptivePolarizationPrior()] n_ingroups = [10, 11] fig, ax = plt.subplots(4, figsize=(10, 10)) for i, (prior, n_ingroup) in enumerate(itertools.product(priors, n_ingroups)): anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_ingroups=n_ingroup, prior=prior ) ann = fd.Annotator( vcf=""resources/genome/betula/all.with_outgroups.vcf.gz"", output='scratch/test_fewer_ingroups_than_ingroup_samples_raises_error_{i}.vcf', max_sites=100000, annotations=[anc] ) ann.annotate() anc.prior.plot(ax=ax[i], show=False) # set title ax[i].set_title(f""n_ingroups = {n_ingroup}, prior = {prior.__class__.__name__}"") annotators.append(anc) plt.show() pass def test_compare_with_est_sfs_betula(self): """""" Compare MLE params and site probabilities with EST-SFS using the betula dataset. """""" cases = [ dict( prior=None, model=fd.JCSubstitutionModel(), tol_params=0.1, tol_sites=0.04, outgroups=[""ERR2103730""], vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"" ), dict( prior=None, model=fd.JCSubstitutionModel(), tol_params=1.3, tol_sites=0.04, outgroups=[""ERR2103730"", ""ERR2103731""], vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"" ), dict( prior=None, model=fd.JCSubstitutionModel(), tol_params=0.8, tol_sites=0.04, outgroups=[""ERR2103730"", ""ERR2103731""], vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"" ), dict( prior=None, model=fd.K2SubstitutionModel(), tol_params=0.8, tol_sites=0.04, outgroups=[""ERR2103730"", ""ERR2103731""], vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"" ), dict( prior=None, model=fd.JCSubstitutionModel(), tol_params=0.1, tol_sites=0.04, outgroups=[""ERR2103730""], vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"" ), dict( prior=None, model=fd.K2SubstitutionModel(), tol_params=0.3, tol_sites=0.04, outgroups=[""ERR2103730""], vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"" ) ] annotators = [] diffs_params = [] diffs_sites = [] n_ingroups = 11 # run inference for i, case in enumerate(cases): anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=case['outgroups'], n_ingroups=n_ingroups, prior=case['prior'], model=case['model'], subsample_mode='random' ) ann = fd.Annotator( vcf=case['vcf'], output='scratch/dummy.vcf', annotations=[anc] ) # set up to infer branch rates ann._setup() hash_str = md5(str(case | {'model': case['model'].__class__.__name__}).encode()).hexdigest()[:8] anc2, site_info = self.compare_with_est_sfs( anc=anc, cache=f'testing/cache/est-sfs/test_betula_{hash_str}.json' ) params_mle = np.array([[anc.params_mle[k], anc2.params_mle[k]] for k in anc.params_mle]) diff_params = np.abs(params_mle[:, 0] - params_mle[:, 1]) / params_mle[:, 1] # exclude sites where the major is fixed in the ingroup subsample site_info = site_info[site_info['native.n_major'] != n_ingroups] diff_sites = np.abs(site_info['native.p_major_ancestral'] - site_info['est_sfs.p_major_ancestral']) annotators.append(ann) diffs_params.append(diff_params) diffs_sites.append(diff_sites) diffs_params_max = [d.max() for d in diffs_params] diffs_params_tol = [case['tol_params'] for case in cases] diffs_sites_mean = [d.mean() for d in diffs_sites] diffs_sites_tol = [case['tol_sites'] for case in cases] self.assertTrue((diffs_params_max < diffs_params_tol).all()) self.assertTrue((diffs_sites_mean < diffs_sites_tol).all()) pass def test_compare_with_est_sfs_test_set(self): """""" Compare MLE params and site probabilities with EST-SFS using the EST-SFS test dataset. """""" for model in [fd.JCSubstitutionModel(), fd.K2SubstitutionModel()]: anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=""resources/EST-SFS/test-data-no-poly-allelic.txt"", model=model, n_runs=10, prior=None, parallelize=True ) anc.infer() est_sfs, site_info = self.compare_with_est_sfs( anc=anc, cache=f'testing/cache/est-sfs/test-data-no-poly-allelic-{model.__class__.__name__}.json' ) params_native = anc.params_mle params_wrapper = est_sfs.params_mle likelihoods_native = anc.likelihoods likelihoods_wrapper = est_sfs.likelihoods testing.assert_almost_equal( list(params_native.values()), list(params_wrapper.values()), decimal=3 ) testing.assert_almost_equal( site_info['native.p_major_ancestral'].values, site_info['est_sfs.p_major_ancestral'].values, decimal=5 ) pass @staticmethod def test_get_outgroup_bases(): """""" Test the _get_outgroup_bases function. """""" genotypes = np.array([""A|T"", ""./T"", ""C|G"", "".|."", ""T/T"", ""A|."", ""N|G"", ""A|N""]) n_outgroups = 8 result = fd.MaximumLikelihoodAncestralAnnotation._get_outgroup_bases(genotypes, n_outgroups) np.testing.assert_array_equal(result, np.array(['A', 'T', 'C', '.', 'T', 'A', 'G', 'A'])) def test_get_base_index(self): """""" Test the get_base_index function. """""" bases = np.array(['A', 'C', 'G', 'T', 'N']) expected = np.array([0, 1, 2, 3, -1]) result = fd.MaximumLikelihoodAncestralAnnotation.get_base_index(bases) np.testing.assert_array_equal(result, expected) for base in bases: self.assertEqual( fd.MaximumLikelihoodAncestralAnnotation.get_base_index(base), ['A', 'C', 'G', 'T'].index(base) if base in ['A', 'C', 'G', 'T'] else -1 ) def test_get_base_string(self): """""" Test the get_base_string function. """""" bases = np.array([0, 1, 2, 3, -1]) expected = np.array(['A', 'C', 'G', 'T', '.']) result = fd.MaximumLikelihoodAncestralAnnotation.get_base_string(bases) np.testing.assert_array_equal(result, expected) for base in bases: self.assertEqual( fd.MaximumLikelihoodAncestralAnnotation.get_base_string(base), ['A', 'C', 'G', 'T', '.'][base] ) def test_ad_hoc_annotation(self): """""" Test the ad hoc annotation. """""" configs = [ dict(n_major=15, major_base='A', minor_base='C', outgroup_bases=['A'], ancestral_expected='A'), dict(n_major=15, major_base='G', minor_base=None, outgroup_bases=['G'], ancestral_expected='G'), dict(n_major=15, major_base='C', minor_base='A', outgroup_bases=[], ancestral_expected='C'), dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['A', 'T'], ancestral_expected='A'), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['T', 'C', 'C'], ancestral_expected='C'), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['G'], ancestral_expected='T'), dict(n_major=15, major_base='G', minor_base=None, outgroup_bases=['A', 'C', 'T'], ancestral_expected='G'), dict(n_major=15, major_base=None, minor_base=None, outgroup_bases=['A', 'C', 'T'], ancestral_expected='A'), dict(n_major=15, major_base='A', minor_base=None, outgroup_bases=['T', 'T', 'T'], ancestral_expected='T'), dict(n_major=15, major_base='A', minor_base=None, outgroup_bases=['T', 'T'], ancestral_expected='T'), dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['T', 'T', 'T'], ancestral_expected='T'), dict(n_major=15, major_base='A', minor_base='G', outgroup_bases=['T', 'T', 'T'], ancestral_expected='T'), ] for i, config in enumerate(configs): site_config = fd.annotation.SiteConfig( n_major=config['n_major'], major_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['major_base']), minor_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['minor_base']), outgroup_bases=fd.MaximumLikelihoodAncestralAnnotation.get_base_index( np.array(config['outgroup_bases']) ) ) site_info = fd.annotation.AdHocAncestralAnnotation._get_site_info(site_config) self.assertEqual(site_info['ancestral_base'], config['ancestral_expected']) def test_p_config(self): """""" Test the p_config function. """""" configs = [ dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T'], p_larger='equal'), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['.', '.'], p_larger='equal'), dict(n_major=15, major_base='A', minor_base='C', outgroup_bases=['A'], p_larger='major'), dict(n_major=15, major_base='G', minor_base=None, outgroup_bases=['G'], p_larger='major'), dict(n_major=15, major_base='C', minor_base='A', outgroup_bases=[], p_larger='equal'), dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['A', 'T'], p_larger='major'), dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['T', 'A'], p_larger='equal'), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['T', 'C', 'C'], p_larger='major'), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T', 'C'], p_larger='minor'), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['G'], p_larger='equal'), dict(n_major=15, major_base='G', minor_base=None, outgroup_bases=['A', 'C', 'T'], p_larger='major'), dict(n_major=15, major_base=None, minor_base=None, outgroup_bases=['A', 'C', 'T'], p_larger='equal'), dict(n_major=15, major_base='A', minor_base=None, outgroup_bases=['T', 'T', 'T'], p_larger='major'), dict(n_major=15, major_base='A', minor_base=None, outgroup_bases=['T', 'T'], p_larger='major'), dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['T', 'T', 'T'], p_larger='minor'), dict(n_major=15, major_base='A', minor_base='G', outgroup_bases=['T', 'T', 'T'], p_larger='equal'), dict(n_major=15, major_base='G', minor_base='C', outgroup_bases=['.', 'C'], p_larger='minor'), ] for i, config in enumerate(configs): probs = {} for name, focal_base in zip(['major', 'minor'], [fd.annotation.BaseType.MAJOR, fd.annotation.BaseType.MINOR]): probs[name] = fd.MaximumLikelihoodAncestralAnnotation.get_p_config( config=fd.annotation.SiteConfig( n_major=config['n_major'], major_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['major_base']), minor_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['minor_base']), outgroup_bases=fd.MaximumLikelihoodAncestralAnnotation.get_base_index( np.array(config['outgroup_bases']) ) ), base_type=focal_base, params=dict(K=0.2), model=fd.JCSubstitutionModel(pool_branch_rates=True) ) if config['p_larger'] == 'major': self.assertGreater(probs['major'], probs['minor']) elif config['p_larger'] == 'minor': self.assertLess(probs['major'], probs['minor']) elif config['p_larger'] == 'equal': self.assertAlmostEqual(probs['major'], probs['minor'], places=10) pass @staticmethod def test_ancestral_first_inner_node(): """""" Test the p_config function. """""" configs = pd.DataFrame([ dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T', 'C'], expected=['C']), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T', 'T'], expected=['C']), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T', 'T', 'T', 'T'], expected=['C']), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T'], expected=['C', 'T']), dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['.', '.'], expected=['C', 'T']), dict(n_major=15, major_base='A', minor_base='C', outgroup_bases=['A', '.'], expected=['A']), dict(n_major=15, major_base='C', minor_base='A', outgroup_bases=['A', '.'], expected=['A']), dict(n_major=15, major_base='A', minor_base='C', outgroup_bases=['.', 'A'], expected=['A']), dict(n_major=15, major_base='C', minor_base='A', outgroup_bases=['.', 'A'], expected=['A']), dict(n_major=15, major_base='C', minor_base='A', outgroup_bases=['C', 'A'], expected=['A', 'C']), dict(n_major=15, major_base='A', minor_base='C', outgroup_bases=['C', 'A'], expected=['A', 'C']), dict(n_major=19, major_base='C', minor_base='A', outgroup_bases=['.', 'A'], expected=['A']), ]) for i, config in configs.iterrows(): site = SiteConfig( n_major=config['n_major'], major_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['major_base']), minor_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['minor_base']), outgroup_bases=fd.MaximumLikelihoodAncestralAnnotation.get_base_index( np.array(config['outgroup_bases']) ) ) anc = fd.MaximumLikelihoodAncestralAnnotation.from_data( n_major=[site.n_major], major_base=[site.major_base], minor_base=[site.minor_base], outgroup_bases=[[0 for _ in site.outgroup_bases]], n_ingroups=20, prior=fd.KingmanPolarizationPrior(), model=fd.JCSubstitutionModel(pool_branch_rates=True, fixed_params=dict(K=0.2)), pass_indices=True ) # dummy inference, all parameters are fixed anc.infer() site_info = anc._get_site_info([site]) probs = np.array(list(site_info.p_bases_first_node.values())) is_max = np.where(np.isclose(probs, np.max(probs)))[0] max_bases = np.array(list(site_info.p_bases_first_node.keys()))[is_max] np.testing.assert_array_equal(sorted(max_bases), sorted(config['expected'])) pass def test_infer_variants_without_setup_raises_runtime_error(self): """""" Test that an error is raised when the infer function is called without setup. """""" with self.assertRaises(RuntimeError): anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], n_ingroups=10, prior=None ) anc.infer() def test_parse_variant(self): """""" Test that the annotation parses a mocked variant correctly. """""" from cyvcf2 import Variant # create a mocked annotation anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730"", ""ERR2103731""], ingroups=[""ASP04"", ""ASP05"", ""ASP06"", ""ASP07""], n_ingroups=8, prior=None, subsample_mode='random' ) # create a mocked variant variant = Mock(spec=Variant) variant.REF = ""A"" variant.ALT = [""T""] variant.is_snp = True anc._prepare_masks([""ASP04"", ""ASP05"", ""ASP06"", ""ASP07"", ""ERR2103730"", ""ERR2103731""]) variant.gt_bases = np.array([""A|A"", ""T|T"", ""A|T"", ""T|T"", ""T|T"", ""T|T""]) # parse the mocked variant site = anc._parse_variant(variant)[0] self.assertEqual(site.n_major, 5) self.assertEqual(site.major_base, base_indices['T']) self.assertEqual(site.minor_base, base_indices['A']) def test_parse_variant_minor_allele_zero_frequency_but_contained_in_ingroup(self): """""" Test that the annotation parses a mocked variant correctly when the minor allele has zero frequency but is contained in the ingroup. """""" from cyvcf2 import Variant # create a mocked annotation anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], ingroups=[""ASP04"", ""ASP05"", ""ASP06"", ""ASP07""], n_ingroups=4, prior=None, subsample_mode='random' ) # create a mocked variant variant = Mock(spec=Variant) variant.REF = ""A"" variant.ALT = [""T""] variant.is_snp = True anc._prepare_masks([""ASP04"", ""ASP05"", ""ASP06"", ""ASP07"", ""ERR2103730""]) variant.gt_bases = np.array([""A|T"", ""T|T"", ""T|T"", ""T|T"", ""T|A""]) # parse the mocked variant site = anc._parse_variant(variant)[0] self.assertEqual(site.n_major, 4) self.assertEqual(site.major_base, base_indices['T']) self.assertEqual(site.minor_base, base_indices['A']) def test_parse_variant_minor_allele_zero_frequency_but_contained_in_outgroup(self): """""" Test that the annotation parses a mocked variant correctly when the minor allele has zero frequency but is contained in the outgroup only. """""" from cyvcf2 import Variant # create a mocked annotation anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], ingroups=[""ASP04"", ""ASP05"", ""ASP06"", ""ASP07""], n_ingroups=4, prior=None, subsample_mode='random' ) # create a mocked variant variant = Mock(spec=Variant) variant.REF = ""A"" variant.ALT = [""T""] variant.is_snp = True anc._prepare_masks([""ASP04"", ""ASP05"", ""ASP06"", ""ASP07"", ""ERR2103730""]) variant.gt_bases = np.array([""T|T"", ""T|T"", ""T|T"", ""T|T"", ""T|A""]) # parse the mocked variant site = anc._parse_variant(variant)[0] self.assertEqual(site.n_major, 4) self.assertEqual(site.major_base, base_indices['T']) self.assertEqual(site.minor_base, base_indices['A']) def test_parse_variant_too_few_ingroups_error(self): """""" Test that an error is raised when the number of ingroups is less than the number of samples. """""" from cyvcf2 import Variant # create a mocked annotation anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], ingroups=[""ASP04"", ""ASP05"", ""ASP06""], n_ingroups=8, prior=None, subsample_mode='random' ) # create a mocked variant variant = Mock(spec=Variant) variant.REF = ""A"" variant.ALT = [""T""] variant.is_snp = True anc._prepare_masks([""ASP04"", ""ASP05"", ""ASP06"", ""ERR2103730""]) variant.gt_bases = np.array([""T|T"", ""T|A"", ""T|T"", ""T|A""]) with self.assertRaises(fd.annotation._TooFewIngroupsSiteError): anc._parse_variant(variant) def test_parse_variant_poly_allelic_error(self): """""" Test that an error is raised when the variant is poly-allelic. """""" from cyvcf2 import Variant # create a mocked annotation anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], ingroups=[""ASP04"", ""ASP05"", ""ASP06"", ""ASP07""], n_ingroups=8, prior=None, subsample_mode='random' ) # create a mocked variant variant = Mock(spec=Variant) variant.REF = ""A"" variant.ALT = [""T"", ""C""] variant.is_snp = True anc._prepare_masks([""ASP04"", ""ASP05"", ""ASP06"", ""ASP07"", ""ERR2103730""]) variant.gt_bases = np.array([""T|T"", ""T|A"", ""T|T"", ""T|A"", ""T|C""]) with self.assertRaises(fd.annotation._PolyAllelicSiteError): anc._parse_variant(variant) def test_parse_variance_probabilistic_subsampling(self): """""" Test the parse_variance function with probabilistic subsampling. """""" from cyvcf2 import Variant # create a mocked annotation anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], ingroups=[""ASP04"", ""ASP05"", ""ASP06"", ""ASP07""], n_ingroups=5, prior=None, subsample_mode='probabilistic' ) # create a mocked variant variant = Mock(spec=Variant) variant.REF = ""A"" variant.ALT = [""T""] variant.is_snp = True anc._prepare_masks([""ASP04"", ""ASP05"", ""ASP06"", ""ASP07"", ""ERR2103730""]) variant.gt_bases = np.array([""T|T"", ""T|A"", ""T|T"", ""T|A"", ""T|T""]) # parse the mocked variant sites = anc._parse_variant(variant) self.assertAlmostEqual(1, sum([site.multiplicity for site in sites])) self.assertEqual({s.n_major for s in sites}, {3, 4, 5}) @staticmethod def test_plot_tree_no_outgroup(): """""" Test the plot_tree function. """""" SiteInfo( n_major=15, major_base='T', minor_base='C', outgroup_bases=[], rate_params=dict() ).plot_tree() @staticmethod def test_plot_tree_one_outgroup(): """""" Test the plot_tree function. """""" SiteInfo( n_major=15, major_base='T', minor_base='C', outgroup_bases=['C'], rate_params=dict(K0=0.05, K1=0.3) ).plot_tree() @staticmethod def test_plot_tree_two_outgroups(): """""" Test the plot_tree function. """""" SiteInfo( n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T'], rate_params=dict(K0=0.05, K1=0.3, K2=0.1) ).plot_tree() @staticmethod def test_plot_tree_three_outgroups(): """""" Test the plot_tree function. """""" SiteInfo( n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T', 'C'], rate_params=dict(K0=0.05, K1=0.3, K2=0.1, K3=0.4, K4=0.2) ).plot_tree() @staticmethod def test_plot_tree_three_outgroups_pooled_rate_params(): """""" Test the plot_tree function. """""" SiteInfo( n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T', 'C'], rate_params=dict(K=0.05) ).plot_tree() def test_maximum_likelihood_annotation_annotate_site(self): """""" Test the maximum parsimony annotation for a single site. """""" # test cases cases = [ # minor allele 'G' but supported by outgroup dict( ingroups=[""sample1"", ""sample2""], outgroups=[""sample3""], samples=[""sample1"", ""sample2"", ""sample3""], gt_bases=np.array([""A/A"", ""A/G"", ""G/G""]), expected=""G"", confidence_threshold=0, n_ingroups=4, prior=None ), # minor allele 'G', supported by outgroup, but not with enough confidence dict( ingroups=[""sample1"", ""sample2""], outgroups=[""sample3""], samples=[""sample1"", ""sample2"", ""sample3""], gt_bases=np.array([""A/A"", ""A/G"", ""G/G""]), expected=""."", confidence_threshold=1, n_ingroups=4, prior=None ), # minor allele 'G', supported by outgroup, but not enough ingroup samples dict( ingroups=[""sample1"", ""sample2""], outgroups=[""sample3""], samples=[""sample1"", ""sample2"", ""sample3""], gt_bases=np.array([""A/A"", ""A/G"", ""G/G""]), expected=""."", confidence_threshold=0, n_ingroups=5, prior=None ), # monomorphic site with outgroup information dict( ingroups=[""sample1"", ""sample2""], outgroups=[""sample3""], samples=[""sample1"", ""sample2"", ""sample3""], gt_bases=np.array([""./."", ""C/C"", ""C/C""]), expected=""C"", n_ingroups=2, confidence_threshold=0, prior=None ), # monomorphic site with no outgroup information dict( ingroups=[""sample1"", ""sample2""], outgroups=[""sample3""], samples=[""sample1"", ""sample2"", ""sample3""], gt_bases=np.array([""T/T"", ""./."", ""./.""]), expected=""T"", n_ingroups=2, confidence_threshold=0, prior=None ), # site without any calls dict( ingroups=[""sample1"", ""sample2""], outgroups=[""sample3""], samples=[""sample1"", ""sample2"", ""sample3""], gt_bases=np.array([""./."", ""./."", ""./.""]), expected=""."", n_ingroups=2, confidence_threshold=0, prior=None ), # poly-allelic site dict( ingroups=[""sample1"", ""sample2""], outgroups=[""sample3""], samples=[""sample1"", ""sample2"", ""sample3""], gt_bases=np.array([""A/A"", ""./."", ""G/T""]), expected=""."", n_ingroups=2, confidence_threshold=0, prior=None ), # poly-allelic site dict( ingroups=[""sample1"", ""sample2""], outgroups=[""sample3""], samples=[""sample1"", ""sample2"", ""sample3""], gt_bases=np.array([""A/T"", ""G/."", ""T/T""]), expected=""."", n_ingroups=3, confidence_threshold=0, prior=None ), ] # mock Annotator mock_annotator = MagicMock() type(mock_annotator).info_ancestral = PropertyMock(return_value=""AA"") for i, test_case in enumerate(cases): # create with dummy input and just fix branch rates ann = fd.MaximumLikelihoodAncestralAnnotation.from_data( n_major=[0], major_base=['A'], minor_base=['T'], outgroup_bases=[['A']], n_ingroups=test_case[""n_ingroups""], model=fd.JCSubstitutionModel(pool_branch_rates=True, fixed_params=dict(K=0.1)), prior=test_case[""prior""], confidence_threshold=test_case[""confidence_threshold""] ) ann.outgroups = test_case[""outgroups""] ann.ingroups = test_case[""ingroups""] ann._handler = mock_annotator # prepare masks ann._prepare_masks(test_case[""samples""]) # infer branch rates (which has no effect) ann.infer() # mock variant with a dictionary for INFO variant = MagicMock() variant.gt_bases = test_case[""gt_bases""] variant.INFO = {} variant.is_snp = len(set(get_called_bases(variant.gt_bases))) > 1 variant.REF = 'A' # doesn't matter what the reference is, but it needs to be a valid base # run the method ann.annotate_site(variant) # check if the result matches the expectation self.assertEqual(variant.INFO[ann._handler.info_ancestral], test_case[""expected""]) def test_is_confident(self): """""" Test the is_confident method. """""" self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0, 0.1)) self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0, 0.5)) self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0, 0.9)) self.assertEqual(False, fd.MaximumLikelihoodAncestralAnnotation._is_confident(1, 0.1)) self.assertEqual(False, fd.MaximumLikelihoodAncestralAnnotation._is_confident(1, 0.5)) self.assertEqual(False, fd.MaximumLikelihoodAncestralAnnotation._is_confident(1, 0.9)) self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.1)) self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.2)) self.assertEqual(False, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.3)) self.assertEqual(False, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.5)) self.assertEqual(False, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.7)) self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.8)) self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.9)) @staticmethod def test_get_outgroup_divergence_one_outgroup(): """""" Test the get_outgroup_divergence method with one outgroup. """""" # create a mocked annotation anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""outgroup1""], ingroups=[""ingroup1"", ""ingroup2"", ""ingroup3"", ""ingroup4""], n_ingroups=8, prior=None ) anc.params_mle = { 'K0': 0.05 } testing.assert_array_equal([0.05], anc.get_outgroup_divergence()) @staticmethod def test_get_outgroup_divergence_two_outgroups(): """""" Test the get_outgroup_divergence method with two outgroups. """""" # create a mocked annotation anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""outgroup1"", ""outgroup2""], ingroups=[""ingroup1"", ""ingroup2"", ""ingroup3"", ""ingroup4""], n_ingroups=8, prior=None ) anc.params_mle = { 'K0': 0.05, 'K1': 0.1, 'K2': 0.2 } testing.assert_array_almost_equal([0.15, 0.25], anc.get_outgroup_divergence()) @staticmethod def test_get_outgroup_divergence_three_outgroups(): """""" Test the get_outgroup_divergence method with three outgroups. """""" # create a mocked annotation anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""outgroup1"", ""outgroup2"", ""outgroup3""], ingroups=[""ingroup1"", ""ingroup2"", ""ingroup3"", ""ingroup4""], n_ingroups=8, prior=None ) anc.params_mle = { 'K0': 0.05, 'K1': 0.1, 'K2': 0.13, 'K3': 0.3, 'K4': 0.4 } testing.assert_array_almost_equal([0.15, 0.48, 0.58], anc.get_outgroup_divergence()) @staticmethod @pytest.mark.slow def test_betula_different_confidence_thresholds(): """""" Test the SFS for different ancestral allele annotation confidence thresholds. """""" spectra = {} for threshold in [0, 0.5, 0.9]: p = fd.Parser( vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", n=10, annotations=[ fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], exclude=[""ERR2103731""], n_ingroups=20, confidence_threshold=threshold, ) ] ) sfs = p.parse() spectra[str(threshold)] = sfs.all # we have fewer derived alleles for higher confidence thresholds fd.Spectra.from_spectra(spectra).plot() pass @pytest.mark.slow def test_papio_sfs_for_different_number_of_outgroups(self): """""" Test the SFS for different numbers of outgroups. """""" spectra, parsers = {}, {} samples = pd.read_csv(""resources/genome/papio/metadata.csv"") outgroups = [ # samples[samples.C_origin == 'Anubis, Ethiopia'].iloc[0].PGDP_ID, samples[samples.Species == 'hamadryas'].iloc[0].PGDP_ID.replace('Sci_', ''), samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') ] for n_outgroups in [1, 2, 3]: p = fd.Parser( vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", n=8, max_sites=10000, annotations=[ fd.MaximumLikelihoodAncestralAnnotation( ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), outgroups=outgroups[-n_outgroups:], n_runs=10, n_ingroups=10, parallelize=True, prior=fd.KingmanPolarizationPrior(), confidence_threshold=0 ) ] ) sfs = p.parse() spectra[f""{n_outgroups}_outgroups""] = sfs.all parsers[f""{n_outgroups}_outgroups""] = p s = fd.Spectra.from_spectra(spectra) s.plot() # make sure total number of sites is the same np.testing.assert_almost_equal(s.n_sites, [s.n_sites[0]] * 3) # The number of polymorphic sites is very similar as it should # If only one outgroup is used, there is a slight over-representation of high-frequency derived alleles pass @pytest.mark.slow def test_papio_sfs_for_different_subsample_size(self): """""" Test the SFS for different subsample sizes. """""" spectra, parsers = {}, {} samples = pd.read_csv(""resources/genome/papio/metadata.csv"") for n_ingroups in [5, 10, 20, 40]: p = fd.Parser( vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", n=8, max_sites=10000, annotations=[ fd.MaximumLikelihoodAncestralAnnotation( ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), outgroups=[ samples[samples.Species == 'hamadryas'].iloc[0].PGDP_ID.replace('Sci_', ''), samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') ], n_runs=10, n_ingroups=n_ingroups, parallelize=True, prior=fd.KingmanPolarizationPrior(), confidence_threshold=0, ) ] ) sfs = p.parse() spectra[f""{n_ingroups}_ingroups""] = sfs.all parsers[f""{n_ingroups}_ingroups""] = p # looks rather similar really fd.Spectra.from_spectra(spectra).plot() pass @pytest.mark.slow def test_papio_sfs_for_different_priors(self): """""" Test the SFS for different priors. """""" spectra, parsers = {}, {} samples = pd.read_csv(""resources/genome/papio/metadata.csv"") priors = { 'none': None, 'Kingman': fd.KingmanPolarizationPrior(), 'Adaptive': fd.AdaptivePolarizationPrior(), } for name, prior in priors.items(): p = fd.Parser( vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", n=8, max_sites=10000, annotations=[ fd.MaximumLikelihoodAncestralAnnotation( ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), outgroups=[ samples[samples.Species == 'hamadryas'].iloc[0].PGDP_ID.replace('Sci_', ''), samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), # samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') ], n_runs=10, n_ingroups=20, parallelize=True, prior=prior, confidence_threshold=0, ) ] ) sfs = p.parse() spectra[name] = sfs.all parsers[name] = p # slightly more high-frequency derived alleles without prior, which is expected fd.Spectra.from_spectra(spectra).plot() pass def test_add_monomorphic_site_counts(self): """""" Test the add_monomorphic_site_counts method. """""" vcfs = [ 'resources/genome/betula/biallelic.with_outgroups.subset.50000.vcf.gz', 'resources/genome/betula/all.with_outgroups.subset.200000.vcf.gz', ] n_sites_vcf = 100 bases = dict(A=123, C=654, G=87, T=98) n_sites_total = n_sites_vcf + sum(bases.values()) for vcf in vcfs: a = fd.MaximumLikelihoodAncestralAnnotation._from_vcf( file=vcf, outgroups=[""ERR2103730"", ""ERR2103731""], n_ingroups=20, confidence_threshold=0, prior=fd.KingmanPolarizationPrior(), max_sites=n_sites_vcf ) configs = a._add_monomorphic_sites(bases) self.assertEqual(n_sites_vcf, a.configs.multiplicity.sum()) self.assertEqual(n_sites_vcf, a.n_sites) self.assertEqual(n_sites_total, int(configs.multiplicity.sum())) # self.assertEqual(n_sites_total, len(configs.sites.sum())) # self.assertEqual(n_sites_total, len(np.unique(configs.sites.sum()))) pass @pytest.mark.slow def test_betula_est_sfs_biallelic_vs_monomorphic_compare_rates(self): """""" Test the SFS for dataset including monomorphic sites vs. dataset without monomorphic sites using EST-SFS. """""" anc, anc2 = {}, {} vcfs = { 'biallelic': ""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", 'all': ""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"" } for key, vcf in vcfs.items(): a = fd.MaximumLikelihoodAncestralAnnotation._from_vcf( file=vcf, outgroups=[""ERR2103730""], exclude=[""ERR2103731""], n_ingroups=20, confidence_threshold=0, prior=fd.KingmanPolarizationPrior() ) a.infer() a2 = fd.annotation._ESTSFSAncestralAnnotation(a) a2.infer(binary=""resources/EST-SFS/cmake-build-debug/EST_SFS_with_prior"") anc[key] = a anc2[key] = a2 # we have markedly different rates when including monomorphic sites, also for kappa pass @pytest.mark.slow def test_betula_same_estimates_when_sampling_monomorphic_sites_from_fasta(self): """""" Test that we get the same estimates when sampling monomorphic sites from a fasta file instead of a VCF. """""" configs = [ dict( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", outgroups=[""ERR2103730""], tolerance=0.15 ), dict( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", outgroups=[""ERR2103730"", ""ERR2103731""], tolerance=0.12 ) ] for config in configs: p1 = fd.Parser( n=10, vcf=config['vcf'], annotations=[ fd.MaximumLikelihoodAncestralAnnotation( outgroups=config['outgroups'], n_ingroups=20, ) ] ) sfs = p1.parse() f = fd.Filterer( vcf=config['vcf'], output=tempfile.NamedTemporaryFile(delete=False, suffix='.vcf').name, filtrations=[fd.SNPFiltration()] ) f.filter() p2 = fd.Parser( n=10, fasta=""resources/genome/betula/genome.subset.20.fasta"", vcf=f.output, annotations=[ fd.MaximumLikelihoodAncestralAnnotation( outgroups=config['outgroups'], n_ingroups=20, n_target_sites=int(sfs.all.n_sites), ) ] ) p2.parse() # noinspection all params_mle = np.concatenate([ [list(p1.annotations[0].params_mle.values())], [list(p2.annotations[0].params_mle.values())] ]) # we have markedly different rates when including monomorphic sites max_rel_diff = np.max(np.abs(np.diff(params_mle, axis=0) / params_mle[:-1, :])) self.assertGreater(config['tolerance'], max_rel_diff) @pytest.mark.slow def test_sfs_for_different_datasets(self): """""" Compare the SFS for different datasets. """""" max_sites = 10000 spectra, parsers = {}, {} # determine using n = 10 from betula dataset target_site_multiplier = 7.23 papio = pd.read_csv(""resources/genome/papio/metadata.csv"") datasets = dict( anubis_one_outgroup=dict( vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", fasta=""resources/genome/papio/Papio_anubis.fasta"", outgroups=[ papio[papio.Species == 'hamadryas'].iloc[0].PGDP_ID.replace('Sci_', '') ], ingroups=list(papio[papio.C_origin == 'Anubis, Tanzania']['PGDP_ID']), prior=fd.KingmanPolarizationPrior(), n_target_sites=100000, aliases=dict(chr1=['CM001491.2']) ), anubis_one_distant_outgroup=dict( vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", fasta=""resources/genome/papio/Papio_anubis.fasta"", outgroups=[ papio[papio.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') ], ingroups=list(papio[papio.C_origin == 'Anubis, Tanzania']['PGDP_ID']), prior=fd.KingmanPolarizationPrior(), n_target_sites=max_sites * target_site_multiplier, aliases=dict(chr1=['CM001491.2']) ), anubis_two_outgroups=dict( vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", fasta=""resources/genome/papio/Papio_anubis.fasta"", outgroups=[ papio[papio.Species == 'hamadryas'].iloc[0].PGDP_ID.replace('Sci_', ''), papio[papio.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), ], ingroups=list(papio[papio.C_origin == 'Anubis, Tanzania']['PGDP_ID']), prior=fd.KingmanPolarizationPrior(), n_target_sites=max_sites * target_site_multiplier, aliases=dict(chr1=['CM001491.2']) ), pendula_one_outgroup=dict( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", outgroups=[""ERR2103730""], ingroups=pd.read_csv(""resources/genome/betula/sample_sets/pendula.args"", header=None)[0].tolist(), prior=fd.KingmanPolarizationPrior() ), pendula_one_outgroup_biallelic=dict( vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", fasta=""resources/genome/betula/genome.subset.20.fasta"", outgroups=[""ERR2103730""], ingroups=pd.read_csv(""resources/genome/betula/sample_sets/pendula.args"", header=None)[0].tolist(), prior=fd.KingmanPolarizationPrior(), n_target_sites=max_sites * target_site_multiplier ), pubescens_one_outgroup=dict( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", outgroups=[""ERR2103730""], ingroups=pd.read_csv(""resources/genome/betula/sample_sets/pubescens.args"", header=None)[0].tolist(), prior=fd.KingmanPolarizationPrior() ), betula_one_outgroup=dict( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", outgroups=[""ERR2103730""], exclude=[""ERR2103731""], prior=fd.KingmanPolarizationPrior() ), betula_two_outgroups=dict( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", outgroups=[""ERR2103730"", ""ERR2103731""], exclude=[], prior=fd.KingmanPolarizationPrior() ), betula_one_outgroup_no_prior=dict( vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", outgroups=[""ERR2103730""], exclude=[""ERR2103731""], prior=None ), ) for dataset, config in datasets.items(): p = fd.Parser( vcf=config['vcf'], fasta=config['fasta'] if 'fasta' in config else None, aliases=config['aliases'] if 'aliases' in config else {}, n=10, annotations=[ fd.MaximumLikelihoodAncestralAnnotation( outgroups=config['outgroups'], ingroups=config['ingroups'] if 'ingroups' in config else None, exclude=config['exclude'] if 'exclude' in config else [], n_ingroups=20, prior=config['prior'], n_target_sites=config['n_target_sites'] if 'n_target_sites' in config else None, ) ] ) sfs = p.parse() spectra[dataset] = sfs.all parsers[dataset] = p s = fd.Spectra.from_spectra(spectra) # normalize by number of singletons s.data /= s.data.iloc[1] s.plot() pass def test_compare_p_major_ancestral_high_vs_log_branch_rates(self): """""" Compare the p_major_ancestral for high vs. log branch rates. """""" configs = dict( default=dict(n_major=19, major_base='T', minor_base='C', outgroup_bases=['C']), ) params = dict( low=dict(k=1, K0=0.03), high=dict(k=1, K0=0.3), ) site_info = defaultdict(dict) for config_name, config in configs.items(): for param_name, param in params.items(): site = SiteConfig( n_major=config['n_major'], major_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['major_base']), minor_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['minor_base']), outgroup_bases=fd.MaximumLikelihoodAncestralAnnotation.get_base_index( np.array(config['outgroup_bases']) ) ) anc = fd.MaximumLikelihoodAncestralAnnotation.from_data( n_major=[site.n_major], major_base=[site.major_base], minor_base=[site.minor_base], outgroup_bases=[[0 for _ in site.outgroup_bases]], n_ingroups=20, prior=fd.KingmanPolarizationPrior(), model=fd.JCSubstitutionModel(fixed_params=param), pass_indices=True ) # dummy inference, all parameters are fixed anc.infer() site_info[(config_name, param_name)] = anc._get_site_info([site]).__dict__ site_info = pd.DataFrame.from_dict(site_info) self.assertLess( site_info.loc['p_major_ancestral', ('default', 'low')], site_info.loc['p_major_ancestral', ('default', 'high')] ) self.assertGreater(np.diff(site_info.loc['p_major_ancestral'])[0], 0.5) def test_compare_random_vs_probabilistic_subsampling(self): """""" Compare MLE params and ancestral allele probabilities with random vs. probabilistic subsampling. """""" from cyvcf2 import VCF parsers, spectra = {}, {} modes = ['probabilistic', 'random'] for mode in modes: p = fd.Parser( vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", n=10, max_sites=1000, annotations=[ fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], exclude=[""ERR2103731""], n_ingroups=20, subsample_mode=cast(Literal['random', 'probabilistic'], mode) ) ] ) self.assertEqual(p.annotations[0].subsample_mode, mode) sfs = p.parse() parsers[str(mode)] = p spectra[str(mode)] = sfs.all fd.Spectra.from_spectra(spectra).plot() params_mle = np.array([list(parsers[mode].annotations[0].params_mle.values()) for mode in modes]) diff_rel = np.abs(np.diff(params_mle, axis=0) / params_mle[0]) self.assertLess(diff_rel.max(), 0.03) annotations = [parsers[mode].annotations[0] for mode in modes] vcf = VCF(""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"") mismatches = 0 for i in range(600): site = next(vcf) # get the site info for both annotations site_info = [ann._get_site_info(ann._parse_variant(site)) for ann in annotations] # make sure the major and minor allele probabilities are the same # This is because they're independent of the actual allele frequency # given the major allele is the same if site_info[0].major_base == site_info[1].major_base: self.assertLess(np.abs(site_info[0].p_minor - site_info[1].p_minor), 0.01) self.assertLess(np.abs(site_info[0].p_major - site_info[1].p_major), 0.01) # this is not true for all sites, but it is for the first 600 self.assertLess(np.abs(site_info[0].p_major_ancestral - site_info[1].p_major_ancestral), 0.3) else: mismatches += 1 self.assertLess(mismatches, 6) @staticmethod def test_plot_configs(): """""" Compare random vs. probabilistic subsampling. """""" a = fd.MaximumLikelihoodAncestralAnnotation._from_vcf( file=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", outgroups=[""ERR2103730""], exclude=[""ERR2103731""], max_sites=1000, n_ingroups=20, subsample_mode='probabilistic', ) a.get_folded_spectra(groups=[]).plot() a.get_folded_spectra(groups=['major_base']).plot() a.get_folded_spectra(groups=['major_base', 'minor_base']).plot() a.get_folded_spectra(groups=['major_base', 'minor_base', 'outgroup_bases']).plot() def test_compare_folded_sfs_random_vs_probabilistic_subsampling(self): """""" Compare folded SFS random vs. probabilistic subsampling. """""" spectra = {} for mode in ['probabilistic', 'random']: a = fd.MaximumLikelihoodAncestralAnnotation._from_vcf( file=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", outgroups=[""ERR2103730""], exclude=[""ERR2103731""], max_sites=2000, n_ingroups=10, subsample_mode=cast(Literal['random', 'probabilistic'], mode) ) spectra[mode] = a.get_folded_spectra(groups=[]).all fd.Spectra.from_spectra(spectra).plot() diff = ((spectra['random'].data - spectra['probabilistic'].data) / (spectra['random'].data + spectra['probabilistic'].data)) # less for larger number of sites self.assertLess(np.abs(diff[~np.isnan(diff)]).max(), 0.25) @staticmethod def test_get_folded_spectra_random_vs_probabilistic_subsampling(): """""" Test the get_folded_spectra method for random vs. probabilistic subsampling and different groups. """""" for mode in ['probabilistic', 'random']: a = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], exclude=[""ERR2103731""], n_ingroups=20, subsample_mode=cast(Literal['random', 'probabilistic'], mode), ) p = fd.Parser( vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", n=10, max_sites=1000, annotations=[a] ) sfs = p.parse() a.get_folded_spectra(groups=[]).plot() a.get_folded_spectra(groups=['major_base']).plot(use_subplots=True) a.get_folded_spectra(groups=['major_base', 'minor_base']).plot(use_subplots=True) def test_subsample_site_convergence(self): """""" Test that random subsampling of sites converges to the probabilistic results. """""" genotypes = np.array(['A'] * 20 + ['T'] * 25) rng = np.random.default_rng() for n in [10, 11]: random = np.zeros((3, 100000), dtype=object) for i in range(random.shape[1]): random[:, i] = np.array(fd.MaximumLikelihoodAncestralAnnotation._subsample_site( mode='random', n=n, samples=genotypes, rng=rng ))[:, 0] probabilistic = np.array(fd.MaximumLikelihoodAncestralAnnotation._subsample_site( mode='probabilistic', n=n, samples=genotypes, rng=rng )) df = pd.DataFrame( random.T, columns=['major_base', 'n_major', 'multiplicity'] ) # change dtypes df = df.astype({'n_major': int, 'multiplicity': int, 'major_base': str}) # take T always to be major allele if n % 2 == 0: df.loc[(df['major_base'] == 'A') & (df['n_major'] == n // 2), 'major_base'] = 'T' grouped = df.groupby(['major_base', 'n_major']).aggregate(sum) random_binned = np.zeros((3, n + 1), dtype=object) for i, prob in enumerate(probabilistic.T): index = (prob[0], int(prob[1])) p = 0 if index in grouped.index: p = grouped.loc[index].multiplicity / random.shape[1] random_binned[:, i] = list(index) + [p] diff = np.abs(random_binned[2].astype(float) - probabilistic[2].astype(float)) self.assertLess(diff.max(), 0.01) @staticmethod def test_subsample_monomorphic_site_probabilistically(): """""" Test that probabilistic subsampling of monomorphic sites works. """""" genotypes = np.array(['A'] * 20) results = [] for mode in ['probabilistic', 'random']: results.append(np.array(fd.MaximumLikelihoodAncestralAnnotation._subsample_site( mode=mode, n=10, samples=genotypes, rng=np.random.default_rng() ))) np.testing.assert_array_equal(results[0], results[1]) @staticmethod def test_fixed_result(): """""" Test the maximum likelihood ancestral annotation for a fixed result. """""" max_sites = 1000 anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], exclude=[""ERR2103731""], n_runs=10, n_ingroups=20, model=fd.K2SubstitutionModel(), prior=fd.KingmanPolarizationPrior(), n_target_sites=7 * max_sites ) p = fd.Parser( vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", fasta=""resources/genome/betula/genome.subset.20.fasta"", n=10, max_sites=max_sites, annotations=[anc] ) sfs = p.parse() sfs.plot() np.testing.assert_almost_equal( [860.7, 81.3, 21.4, 10.9, 6.5, 3.8, 2.5, 2.3, 2.8, 3.5, 3.3], sfs.all.data, decimal=1 ) @staticmethod @pytest.mark.skip('For profiling only') def test_profiling(): """""" Profile the maximum likelihood ancestral annotation. """""" max_sites = 1000 anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], exclude=[""ERR2103731""], n_runs=10, n_ingroups=10, model=fd.K2SubstitutionModel(), prior=fd.KingmanPolarizationPrior(), n_target_sites=7 * max_sites ) p = fd.Parser( vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", fasta=""resources/genome/betula/genome.subset.20.fasta"", n=10, max_sites=max_sites, annotations=[anc] ) sfs = p.parse() def test_raises_warning_on_few_monomorphic_sites(self): """""" Test that a warning is raised when there are few monomorphic sites. """""" max_sites = 1000 anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], exclude=[""ERR2103731""], n_runs=10, n_ingroups=10, model=fd.K2SubstitutionModel(), prior=fd.KingmanPolarizationPrior() ) p = fd.Parser( vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", n=10, max_sites=max_sites, annotations=[anc] ) # this should log a warning with self.assertLogs(level='WARNING', logger=anc._logger): p.parse() @staticmethod def test_compare_priors_random_vs_probabilistic_subsampling(): """""" Compare priors with random vs. probabilistic subsampling. """""" for prior in [fd.AdaptivePolarizationPrior(), fd.KingmanPolarizationPrior()]: for mode in ['probabilistic', 'random']: a = fd.MaximumLikelihoodAncestralAnnotation._from_vcf( file=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", outgroups=[""ERR2103730""], exclude=[""ERR2103731""], max_sites=1000, n_ingroups=20, subsample_mode=cast(Literal['random', 'probabilistic'], mode), prior=prior ) a.infer() # much more stable with probabilistic subsampling a.prior.plot(title=f""{prior.__class__.__name__} - {mode}"") @pytest.mark.slow def test_compare_parsed_sfs_random_vs_probabilistic_subsampling_thorough(self): """""" Compare parsed SFS of random vs. probabilistic subsampling. """""" max_sites = 10000 spectra, parsers = {}, {} for mode in ['probabilistic', 'random']: a = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], exclude=[""ERR2103731""], max_sites=max_sites, n_ingroups=20, n_target_sites=7 * max_sites, subsample_mode=cast(Literal['random', 'probabilistic'], mode) ) parsers[mode] = fd.Parser( vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", fasta=""resources/genome/betula/genome.subset.20.fasta"", n=20, max_sites=max_sites, annotations=[a] ) spectra[mode] = parsers[mode].parse().all fd.Spectra.from_spectra(spectra).plot() diff_rel_sfs = np.abs(np.diff([s.data for s in spectra.values()], axis=0)[0] / spectra['random'].data) self.assertLess(diff_rel_sfs[:-1].max(), 0.15) params_mle = np.array([list(p.annotations[0].params_mle.values()) for p in parsers.values()]) diff_ref_params = np.abs(params_mle[0] - params_mle[1]) / params_mle[0] self.assertLess(diff_ref_params.max(), 0.01) def test_serialization_from_est_sfs(self): """""" Test serializing and deserializing an annotation using from_est_sfs. """""" anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( file=""resources/EST-SFS/test-betula-biallelic-10000.txt"", n_runs=1 ) anc.infer() anc.to_file(""scratch/test_serialization_from_est_sfs.json"") anc2 = fd.MaximumLikelihoodAncestralAnnotation.from_file(""scratch/test_serialization_from_est_sfs.json"") self.assertEqual(anc.params_mle, anc2.params_mle) def test_serialization_with_annotator(self): """""" Test serializing and deserializing an annotation using the Annotator. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], exclude=[""ERR2103731""], n_ingroups=20, prior=fd.KingmanPolarizationPrior(), n_runs=1 ) a = fd.Annotator( vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", output=""scratch/test_serialization_with_annotator.vcf"", annotations=[anc], max_sites=100 ) a.annotate() anc.to_file(""scratch/test_serialization_with_annotator.json"") anc2 = fd.MaximumLikelihoodAncestralAnnotation.from_file(""scratch/test_serialization_with_annotator.json"") self.assertEqual(anc.params_mle, anc2.params_mle) def test_default_prior_kingman(self): """""" Test the default prior is the Kingman polarization prior. """""" a = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], exclude=[""ERR2103731""], n_ingroups=20 ) self.assertIsInstance(a.prior, fd.KingmanPolarizationPrior) def test_pass_none_as_prior_means_no_prior(self): """""" Test that passing None as prior means no prior. """""" a = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], exclude=[""ERR2103731""], n_ingroups=20, prior=None ) self.assertIsNone(a.prior) def test_betula_validate_prob_aa_field(self): """""" Test the MLEAncestralAlleleAnnotation class on the betula vcf file. """""" anc = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], n_runs=1, n_ingroups=5, max_sites=100, n_target_sites=100000, model=fd.JCSubstitutionModel() ) ann = fd.Annotator( vcf=""resources/genome/betula/biallelic.with_outgroups.vcf.gz"", fasta=""resources/genome/betula/genome.fasta"", output='scratch/test_betula_validate_prob_aa_field.vcf', annotations=[anc], max_sites=100 ) _annotate_site = anc.annotate_site probs = [] def annotate_site(variant): _annotate_site(variant) probs.append(variant.INFO['AA_prob']) return variant anc.annotate_site = annotate_site ann.annotate() # make sure all probabilities are greater than 0.5 self.assertGreater(min(probs), 0.5) def test_n_samples_target_sites_argument(self): """""" Test that the n_samples_target_sites is properly extrapolated to n_target_sites """""" n_target_sites = 100000 max_sites = 100 anc, ann = {}, {} for n_samples in [10 ** 3, 10 ** 4, 10 ** 5, 10 ** 6]: anc[n_samples] = fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], n_runs=1, n_ingroups=5, max_sites=max_sites, n_target_sites=n_target_sites, n_samples_target_sites=n_samples, model=fd.JCSubstitutionModel(), adjust_target_sites=False ) ann[n_samples] = fd.Annotator( vcf=""resources/genome/betula/biallelic.with_outgroups.vcf.gz"", fasta=""resources/genome/betula/genome.fasta"", output='scratch/test_n_samples_target_sites_argument.vcf', annotations=[anc[n_samples]], max_sites=max_sites ) ann[n_samples].annotate() self.assertEqual(anc[n_samples].n_sites, n_target_sites) counts = np.array([list(v._monomorphic_samples.values()) for k, v in anc.items()]) / n_target_sites self.assertLessEqual(np.max(np.var(counts, axis=0)), 1e-4) ","Python" "Allele","Sendrowski/fastDFE","testing/test_covariates.py",".py","1165","42","from typing import Dict from fastdfe.optimization import Covariate from testing import TestCase class CovariateTestCase(TestCase): """""" Test the Covariate class. """""" def custom_apply_callback(self, covariate: float, type: str, params: Dict[str, float]) -> Dict[str, float]: """""" :param covariate: :param type: :param params: :return: """""" modified = params.copy() if ""a"" in params: modified[""a""] *= covariate * 2 return modified def test_default_callbacks(self): covariate = Covariate(param=""a"", values={""all"": 2}) params = {""a"": 1, ""b"": 3} modified_params = covariate.apply(covariate=2, type=""all"", params=params) self.assertEqual(modified_params, {""a"": 5, ""b"": 3}) def test_custom_callbacks(self): covariate = Covariate( param=""a"", values={""all"": 2}, callback=self.custom_apply_callback ) params = {""a"": 1, ""b"": 3} modified_params = covariate.apply(covariate=2, type=""all"", params=params) self.assertEqual(modified_params, {""a"": 4, ""b"": 3}) ","Python" "Allele","Sendrowski/fastDFE","testing/test_parametrization.py",".py","16088","542","import numpy as np from matplotlib import pyplot as plt import fastdfe as fd from fastdfe import GammaExpParametrization, BaseInference, Config from fastdfe.visualization import Visualization from fastdfe.discretization import Discretization from fastdfe.parametrization import DiscreteParametrization, GammaDiscreteParametrization, \ DisplacedGammaParametrization, DiscreteFractionalParametrization from testing import TestCase class ParametrizationTestCase(TestCase): """""" Test the parametrization classes. """""" n = 20 config_file = ""testing/cache/configs/pendula_C_full_anc/config.yaml"" def test_compare_exact_vs_empirical_cdf_gamma_exp(self): """""" Compare exact vs empirical CDF for GammaExpParametrization. """""" p = GammaExpParametrization() params = GammaExpParametrization.x0 d = Discretization( n=self.n, intervals_ben=(1e-15, 100, 1000), intervals_del=(-100000, -1e-15, 1000) ) d1 = np.cumsum(p.get_pdf(**params)(d.s) * d.interval_sizes) d2 = p.get_cdf(**params)(d.s) plt.plot(d.s, d1, alpha=0.5, label='empirical CDF') plt.plot(d.s, d2, alpha=0.5, label='exact CDF') plt.legend() plt.show() plt.title('GammaExpParametrization') diff = np.max(np.abs(d1 - d2)) assert diff < 0.005 def test_compare_exact_vs_empirical_cdf_gamma_exp_low_shape(self): """""" Compare exact vs empirical CDF for GammaExpParametrization for low shape parameter. """""" p = GammaExpParametrization() d = Discretization( n=self.n, intervals_ben=(1e-15, 100, 1000), intervals_del=(-100000, -1e-15, 1000) ) params = { 'S_d': -37572.964129977896, 'b': 3.8866779746119997, 'p_b': 0.19204516636691807, 'S_b': 0.0001 } d1 = np.cumsum(p.get_pdf(**params)(d.s) * d.interval_sizes) d2 = p.get_cdf(**params)(d.s) plt.plot(d.s, d1, alpha=0.5, label='empirical CDF') plt.plot(d.s, d2, alpha=0.5, label='exact CDF') plt.title(p.__class__.__name__) plt.legend() plt.show() diff = np.max(np.abs(d1 - d2)) assert diff < 0.009 def test_compare_pdf_vs_discretized_cdf_gamma_exp(self): """""" Compare PDF vs discretized CDF for GammaExpParametrization. """""" p = GammaExpParametrization() d = Discretization( n=self.n, intervals_ben=(1e-15, 100, 1000), intervals_del=(-100000, -1e-15, 1000) ) params = { 'S_d': -37572.964129977896, 'b': 3.8866779746119997, 'p_b': 0.19204516636691807, 'S_b': 0.0001 } d1 = p.get_pdf(**params)(d.s) * d.interval_sizes d2 = p._discretize(params, d.bins) plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='exact PDF') plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='empirical PDF') plt.title(p.__class__.__name__) plt.legend() plt.show() diff = np.max(np.abs(d1 - d2)) assert diff < 1e-4 def test_compare_exact_vs_empirical_cdf_discretized_parametrization(self): """""" Compare exact vs empirical CDF for DiscreteParametrization """""" p = DiscreteParametrization() d = Discretization( n=self.n, intervals_ben=(1e-2, 1000, 1000), intervals_del=(-1000000, -1e-2, 1000) ) """""" d.bins = p.intervals[1:-1] d.s, d.interval_sizes = get_midpoints_and_spacing(d.bins) d.n_intervals = len(d.interval_sizes) """""" params = {'S1': 0.25, 'S2': 0.35, 'S3': 0.2, 'S4': 0.1, 'S5': 0.05, 'S6': 0.05} d1 = np.cumsum(p.get_pdf(**params)(d.s) * d.interval_sizes) d2 = p.get_cdf(**params)(d.s) plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='empirical CDF') plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='exact CDF') plt.title(p.__class__.__name__) plt.legend() plt.show() assert np.max(np.abs(d1 - d2)) < 0.005 def test_compare_pdf_vs_discretized_cdf_discretized_parametrization(self): """""" Compare PDF vs discretized CDF for DiscreteParametrization. """""" p = DiscreteParametrization() d = Discretization( n=self.n, intervals_ben=(1e-2, 1000, 1000), intervals_del=(-1000000, -1e-2, 1000) ) """""" d.bins = p.intervals[1:-1] d.s, d.interval_sizes = get_midpoints_and_spacing(d.bins) d.n_intervals = len(d.interval_sizes) """""" params = {'S1': 0.25, 'S2': 0.35, 'S3': 0.2, 'S4': 0.1, 'S5': 0.05, 'S6': 0.05} d1 = p.get_pdf(**params)(d.s) d2 = p._discretize(params, d.bins) / d.interval_sizes plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='exact PDF') plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='empirical PDF') plt.title(p.__class__.__name__) plt.legend() plt.show() assert np.max(np.abs(d1 - d2)[d.s != 0]) < 1e-12 def test_compare_exact_vs_empirical_cdf_discretized_fractional_parametrization(self): """""" Compare exact vs empirical CDF for DiscreteParametrization """""" p = DiscreteFractionalParametrization() d = Discretization( n=self.n, intervals_ben=(1e-2, 1000, 1000), intervals_del=(-1000000, -1e-2, 1000) ) params = {'S1': 0.5, 'S2': 0.5, 'S3': 0.5, 'S4': 0.9, 'S5': 0.3} d1 = np.cumsum(p.get_pdf(**params)(d.s) * d.interval_sizes) d2 = p.get_cdf(**params)(d.s) plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='empirical CDF') plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='exact CDF') plt.title(p.__class__.__name__) plt.legend() plt.show() assert np.max(np.abs(d1 - d2)) < 0.005 def test_compare_pdf_vs_discretized_cdf_discretized_fractional_parametrization(self): """""" Compare PDF vs discretized CDF for DiscreteParametrization. """""" p = DiscreteFractionalParametrization() d = Discretization( n=self.n, intervals_ben=(1e-2, 1000, 1000), intervals_del=(-1000000, -1e-2, 1000) ) params = {'S1': 0.5, 'S2': 0.5, 'S3': 0.5, 'S4': 0.9, 'S5': 0.3} d1 = p.get_pdf(**params)(d.s) d2 = p._discretize(params, d.bins) / d.interval_sizes plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='exact PDF') plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='empirical PDF') plt.title(p.__class__.__name__) plt.legend() plt.show() assert np.max(np.abs(d1 - d2)[d.s != 0]) < 1e-12 def test_compare_exact_vs_empirical_cdf_gamma_discrete(self): """""" Compare exact vs empirical CDF for GammaDiscreteParametrization. """""" p = GammaDiscreteParametrization() params = GammaDiscreteParametrization.x0 d = Discretization( n=self.n, intervals_ben=(1e-15, 100, 1000), intervals_del=(-100000, -1e-15, 1000) ) d1 = np.cumsum(p.get_pdf(**params)(d.s) * d.interval_sizes) d2 = p.get_cdf(**params)(d.s) plt.plot(d.s, d1, alpha=0.5, label='empirical CDF') plt.plot(d.s, d2, alpha=0.5, label='exact CDF') plt.title(p.__class__.__name__) plt.legend() plt.show() diff = np.max(np.abs(d1 - d2)) assert diff < 0.05 def test_compare_pdf_vs_discretized_cdf_gamma_discrete(self): """""" Compare PDF vs discretized CDF for GammaDiscreteParametrization. """""" p = GammaDiscreteParametrization() d = Discretization( n=self.n, intervals_ben=(1e-15, 100, 1000), intervals_del=(-100000, -1e-15, 1000) ) params = GammaDiscreteParametrization.x0 d1 = p.get_pdf(**params)(d.s) * d.interval_sizes d2 = p._discretize(params, d.bins) plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='exact PDF') plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='empirical PDF') plt.title(p.__class__.__name__) plt.legend() plt.show() diff = np.max(np.abs(d1 - d2)) # discrete CDF produces a large point mass assert diff < 0.001 def test_compare_exact_vs_empirical_cdf_displaced_gamma(self): """""" Compare exact vs empirical CDF for DisplacedGammaParametrization. """""" p = DisplacedGammaParametrization() params = DisplacedGammaParametrization.x0 d = Discretization( n=self.n, intervals_ben=(1e-15, 100, 1000), intervals_del=(-100000, -1e-15, 1000) ) d1 = np.cumsum(p.get_pdf(**params)(d.s) * d.interval_sizes) d2 = p.get_cdf(**params)(d.s) plt.plot(d.s, d1, alpha=0.5, label='empirical CDF') plt.plot(d.s, d2, alpha=0.5, label='exact CDF') plt.title(p.__class__.__name__) plt.legend() plt.show() diff = np.max(np.abs(d1 - d2)) assert diff < 0.05 def test_compare_pdf_vs_discretized_cdf_displaced_gamma(self): """""" Compare PDF vs discretized CDF for DisplacedGammaParametrization. """""" p = DisplacedGammaParametrization() d = Discretization( n=self.n, intervals_ben=(1e-15, 100, 1000), intervals_del=(-100000, -1e-15, 1000) ) params = DisplacedGammaParametrization.x0 d1 = p.get_pdf(**params)(d.s) * d.interval_sizes d2 = p._discretize(params, d.bins) plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='exact PDF') plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='empirical PDF') plt.title(p.__class__.__name__) plt.legend() plt.show() diff = np.max(np.abs(d1 - d2)) # discrete CDF produces a large point mass assert diff < 2e-4 def test_run_inference_discrete_parametrization(self): """""" Test that inference runs without error for DiscreteParametrization. """""" config = Config.from_file(self.config_file) config.update( model=DiscreteParametrization(), do_bootstrap=True, parallelize=False ) inf = BaseInference.from_config(config) inf.run() inf.plot_continuous() inf.plot_discretized() def test_run_inference_discrete_fractional_parametrization(self): """""" Test that inference runs without error for DiscreteParametrization. """""" config = Config.from_file(self.config_file) config.update( model=DiscreteFractionalParametrization(), do_bootstrap=True, parallelize=False ) inf = BaseInference.from_config(config) inf.run() inf.plot_continuous() inf.plot_discretized() def test_run_inference_gamma_exp_parametrization(self): """""" Test that inference runs without error for GammaExpParametrization. """""" config = Config.from_file(self.config_file) config.update( model=GammaExpParametrization(), do_bootstrap=True, parallelize=False ) inf = BaseInference.from_config(config) inf.run() inf.plot_continuous() inf.plot_discretized() def test_run_inference_gamma_discrete_parametrization(self): """""" Test that inference runs without error for GammaDiscreteParametrization. """""" config = Config.from_file(self.config_file) config.update( model=GammaDiscreteParametrization(), do_bootstrap=True, parallelize=False ) inf = BaseInference.from_config(config) inf.run() inf.plot_continuous() inf.plot_discretized() def test_run_inference_displaced_gamma_parametrization(self): """""" Test that inference runs without error for DisplacedGammaParametrization. """""" config = Config.from_file(self.config_file) config.update( model=DisplacedGammaParametrization(), do_bootstrap=True, parallelize=False ) inf = BaseInference.from_config(config) inf.run() inf.plot_continuous() inf.plot_discretized() def test_plot_pdf(self): """""" Test that plotting the PDF works. """""" model = GammaExpParametrization() Visualization.plot_pdf(model, model.x0, s=np.linspace(-100, 100, 1000)) def test_plot_cdf(self): """""" Test that plotting the CDF works. """""" model = GammaExpParametrization() Visualization.plot_cdf(model, model.x0, s=np.linspace(-100, 100, 1000)) def test_to_nominal_to_fractional_are_inverse_functions(self): """""" Test that to_nominal and to_fractional are inverse functions. """""" params = {'S1': 0.5, 'S2': 0.5, 'S3': 0.5, 'S4': 0.9, 'S5': 0.3} p = DiscreteFractionalParametrization() observed = p.to_fractional(p.to_nominal(params)) observed.pop('S6') assert observed == params def test_plot_parametrization(self): """""" Test that plotting the parametrization works. """""" GammaExpParametrization().plot( params=GammaExpParametrization.x0 ) def test_deleterious_submodel_discrete_parametrization(self): """""" Test that deleterious submodel works for DiscreteParametrization. """""" for inv in [ np.array([-100000, -100, -10, -1, 0, 1, 1000]), np.array([-100000, -1, 0, 1, 10, 1000]) ]: p = DiscreteFractionalParametrization(intervals=inv) y = p.get_pdf( **(p.x0 | p.submodels['dele']) )(np.linspace(0.00001, 1000, 100)) self.assertEqual(np.sum(y), 0) y = p.get_pdf( **(p.x0) )(np.linspace(0.00001, 1000, 100)) self.assertGreater(np.sum(y), 0) def test_dfe_cdf_pdf(self): """""" Test that DFE CDF works for all parametrizations. """""" p = GammaExpParametrization() dfe = p.freeze(p.x0) s = np.linspace(*p.bounds['S_d'], 1000) y1 = p.get_cdf(**p.x0)(s) y2 = dfe.cdf(s) np.testing.assert_array_equal(y1, y2) y1 = p.get_pdf(**p.x0)(s) y2 = dfe.pdf(s) np.testing.assert_array_equal(y1, y2) def test_custom_bounds(self): """""" Test that custom bounds work as expected. """""" self.assertDictEqual( GammaExpParametrization(bounds=dict(p_b=(0.1, 0.9))).bounds, GammaExpParametrization.bounds | dict(p_b=(0.1, 0.9)) ) # make sure original class variable is not modified self.assertTupleEqual( GammaExpParametrization.bounds['p_b'], (0.0, 0.5) ) self.assertTupleEqual( DiscreteParametrization(bounds=dict(S1=(0.1, 0.9))).bounds['S1'], (0.1, 0.9) ) self.assertTupleEqual( DiscreteParametrization().bounds['S1'], (0.0, 1.0) ) def test_dfe_serialization(self): """""" Test that DFE serialization works for all parametrizations. """""" dfe = GammaExpParametrization().freeze(GammaExpParametrization.x0) dfe.to_file(""scratch/gamma_exp_dfe.json"") dfe2 = fd.DFE.from_file(""scratch/gamma_exp_dfe.json"") self.assertDictEqual(dfe.params, dfe2.params) ","Python" "Allele","Sendrowski/fastDFE","testing/__init__.py",".py","1891","75",""""""" Initialization for the testing module. """""" import logging import os import sys from pathlib import Path from unittest import TestCase as BaseTestCase import matplotlib import numpy as np import pytest from matplotlib import pyplot as plt def prioritize_installed_packages(): """""" This function prioritizes installed packages over local packages. """""" # Get the current working directory cwd = str(Path().resolve()) # Check if the current working directory is in sys.path if cwd in sys.path: # Remove the current working directory from sys.path sys.path = [p for p in sys.path if p != cwd] # Append the current working directory to the end of sys.path sys.path.append(cwd) # run before importing fastdfe prioritize_installed_packages() import fastdfe logger = logging.getLogger('fastdfe') logger.info(sys.version) logger.info(f""Running tests for {fastdfe.__file__}"") logger.info(f""fastdfe version: {fastdfe.__version__}"") # only show plots when running in PyCharm if 'PYCHARM_HOSTED' not in os.environ: matplotlib.use('Agg') #fastdfe.Settings.disable_pbar = True #logger.setLevel(logging.WARNING) else: logger.setLevel(logging.INFO) # check for PARALLELIZE environment variable if 'PARALLELIZE' in os.environ and os.environ['PARALLELIZE'].lower() == 'false': fastdfe.Settings.parallelize = False logger.info(""Parallelization disabled."") # create scratch directory if it doesn't exist if not os.path.exists('scratch'): os.makedirs('scratch') class TestCase(BaseTestCase): @pytest.fixture(autouse=True) def cleanup(self): """""" """""" yield plt.close('all') @staticmethod def rel_diff(a, b, eps=1e-12): """""" Compute the relative difference between a and b. """""" return np.abs(a - b) / (np.abs(a) + np.abs(b) + eps) ","Python" "Allele","Sendrowski/fastDFE","testing/test_simulation.py",".py","16397","466",""""""" Test the Simulation class. """""" import re from itertools import product import numpy as np import pytest from matplotlib import pyplot as plt import fastdfe as fd from testing import TestCase def expand(template, **wildcards): """""" Generate combinations of strings with placeholders. """""" keys, values = zip(*wildcards.items()) combinations = product(*values) return [template.format(**dict(zip(keys, combo))) for combo in combinations] class SLiMTestCase(TestCase): """""" Test results against cached SLiM results. """""" # configs for testing against cached slim results configs_slim = expand( # deleterious DFE ""testing/cache/slim/n_replicate=1/n_chunks={n_chunks}/g=1e4/L={L}/mu={mu}/r=1e-7/N=1e3/s_b={s_b}/b={b}/s_d={s_d}/p_b={p_b}/n={n}/{folded}/sfs.csv"", n_chunks=[100], L=[""1e7""], mu=[""1e-8""], s_b=[""1e-9""], b=[3, 1, 0.3], s_d=[""3e-3"", ""3e-2"", ""3e-1""], p_b=[0], folded=[""folded"", ""unfolded""], n=[20, 100] ) + expand( # full DFE ""testing/cache/slim/n_replicate=1/n_chunks={n_chunks}/g=1e4/L={L}/mu={mu}/r=1e-7/N=1e3/s_b={s_b}/b={b}/s_d={s_d}/p_b={p_b}/n={n}/{folded}/sfs.csv"", n_chunks=[40], L=[""1e7""], mu=[""1e-8""], s_b=[""1e-4"", ""1e-3""], b=[0.4], s_d=[""1e-1"", ""1e0""], p_b=[0.01, 0.05], folded=[""folded"", ""unfolded""], n=[20, 100] ) + expand( ""testing/cache/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/{params}/n={n}/dominance_{h}/unfolded/sfs.csv"", h=np.round(np.linspace(0.1, 1, 10), 1), params=[ ""s_b=1e-3/b=0.3/s_d=3e-1/p_b=0.00"", ""s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00"", ""s_b=1e-2/b=0.1/s_d=3e-1/p_b=0.01"", ""s_b=1e-3/b=0.3/s_d=3e-2/p_b=0.05"" ], n=[20, 100] ) + expand( ""testing/cache/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-6/N=1e3/{params}/n={n}/dominance_0.0/unfolded/sfs.csv"", params=[ ""s_b=1e-3/b=0.3/s_d=3e-1/p_b=0.00"", ""s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00"", ""s_b=1e-2/b=0.1/s_d=3e-1/p_b=0.01"", ""s_b=1e-3/b=0.3/s_d=3e-2/p_b=0.05"" ], n=[20, 100] ) + expand( ""testing/cache/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-6/N=1e3/{params}/n={n}/dominance_function_{k}/unfolded/sfs.csv"", k=[0.1, 1, 10, 100], params=[ ""s_b=1e-3/b=0.3/s_d=3e-1/p_b=0.00"", ""s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00"", ""s_b=1e-2/b=0.1/s_d=3e-1/p_b=0.01"", ""s_b=1e-3/b=0.3/s_d=3e-2/p_b=0.05"" ], n=[20] ) def test_compare_against_slim(self): """""" Test parameters of inferred DFE against ground-truth from SLiM simulations. """""" cached = {} for file_path in self.configs_slim: spectra = fd.Spectra.from_file(file_path) params = {} for p in ['s_b', 's_d', 'b', 'p_b', 'mu', 'n']: # match parameter values match = re.search(rf""\b{p}=([\d.e+-]+)"", file_path) if match: params[p] = float(match.group(1)) if match := re.search(r""dominance_([\d.]+)"", file_path): params['h'] = float(match.group(1)) Ne = spectra['neutral'].theta / (4 * params['mu']) params['S_b'] = 4 * Ne * params['s_b'] params['S_d'] = -4 * Ne * params['s_d'] model = fd.GammaExpParametrization() model.bounds['S_b'] = (1e-10, 100) sim = fd.Simulation( params=params, sfs_neut=spectra['neutral'], model=model, intervals_del=(-1.0e+8, -1.0e-5, 100), intervals_ben=(1.0e-5, 1.0e4, 100) ) # cache discretization if sim.discretization in cached: sim.discretization = cached[sim.discretization] else: cached[sim.discretization] = sim.discretization sfs_sel = sim.run() comp = fd.Spectra(dict(slim=spectra['selected'], fastdfe=sfs_sel)) diff_rel = (comp['slim'].data[:-1] - comp['fastdfe'].data[:-1]) / comp['slim'].data[:-1] # exclude bins with few counts due to large variance diff_rel[comp['slim'].data[:-1] < 20] = 0 # compute root mean squared error diff = np.sqrt((diff_rel ** 2).mean()) tol = 0.16 # 0.125 with default discretization bins if diff < tol: fd.logger.info(f""{diff:.3f} < {tol} for {params}"") else: fd.logger.fatal(f""{diff:.3f} >= {tol} for {params}"") self.assertLess(diff, tol) class SimulationTestCase(TestCase): """""" Test the Simulation class. """""" def test_get_neutral_sfs(self): """""" Test the get_neutral_sfs method. """""" theta = 1e-4 n_sites = 1e8 n = 10 sfs = fd.Simulation.get_neutral_sfs(theta=theta, n_sites=n_sites, n=n) self.assertAlmostEqual(sfs.n_sites, n_sites) self.assertAlmostEqual(sfs.n, n) self.assertAlmostEqual(sfs.theta, theta) np.testing.assert_array_almost_equal(sfs.data[1:-1], [theta * n_sites / i for i in range(1, 10)]) self.assertAlmostEqual(sfs.data[0], n_sites - sum(sfs.data[1:])) self.assertAlmostEqual(sfs.data[-1], 0) def test_get_neutral_sfs_with_demography(self): """""" Test the get_neutral_sfs method with demography. """""" theta = 1e-4 n_sites = 1e8 n = 10 r = [0.98, 1.21, 0.87, 1.43, 0.92, 1.32, 0.99, 1.12, 0.95] sfs = fd.Simulation.get_neutral_sfs(theta=theta, n_sites=n_sites, n=n, r=r) self.assertAlmostEqual(sfs.n_sites, n_sites) self.assertAlmostEqual(sfs.n, n) # nuisance parameters affect mutation rate self.assertAlmostEqual(sfs.theta, theta, delta=1e-5) np.testing.assert_array_almost_equal(sfs.data[1:-1], [theta * n_sites / i * r[i - 1] for i in range(1, 10)]) self.assertAlmostEqual(sfs.data[0], n_sites - sum(sfs.data[1:])) self.assertAlmostEqual(sfs.data[-1], 0) def test_get_neutral_sfs_wrong_length_r(self): """""" Test the get_neutral_sfs method with wrong length r. """""" theta = 1e-4 n_sites = 1e8 n = 10 r = [1] * 10 with self.assertRaises(ValueError) as e: fd.Simulation.get_neutral_sfs(theta=theta, n_sites=n_sites, n=n, r=r) print(e.exception) def test_recover_result_full_dfe_no_demography(self): """""" Test that the simulated result can be recovered by inference. """""" # very deleterious DFEs were difficult to recover sim = fd.Simulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), params=dict(S_d=-300, b=1, p_b=0.05, S_b=0.1) ) sfs_sel = sim.run() inf = fd.BaseInference( sfs_sel=sfs_sel, sfs_neut=sim.sfs_neut, discretization=sim.discretization, fixed_params=dict(all=dict(eps=0, h=0.5)), do_bootstrap=True, n_bootstraps=100, parallelize=True ) inf.run() self.assertAlmostEqual(sim.n_sites, inf.sfs_sel.n_sites, delta=1e-6) self.assertAlmostEqual(sim.n_sites, inf.sfs_neut.n_sites) self.assertAlmostEqual(sim.theta, inf.sfs_neut.theta) for key in sim.params: self.assertAlmostEqual(inf.params_mle[key], sim.params[key], delta=np.abs(sim.params[key]) / 500) mean = inf.bootstraps.select_dtypes(""number"").mean() self.assertAlmostEqual(mean['S_d'], sim.params['S_d'], delta=np.abs(sim.params['S_d']) / 10) self.assertAlmostEqual(mean['b'], sim.params['b'], delta=np.abs(sim.params['b']) / 10) self.assertAlmostEqual(mean['p_b'], sim.params['p_b'], delta=np.abs(sim.params['p_b']) / 8) self.assertAlmostEqual(mean['S_b'], sim.params['S_b'], delta=np.abs(sim.params['S_b']) * 3) self.assertAlmostEqual(mean['eps'], 0, delta=1e-3) def test_recover_result_full_dfe_with_demography(self): """""" Test that the simulated result can be recovered by inference. """""" sim = fd.Simulation( sfs_neut=fd.Simulation.get_neutral_sfs( n=20, n_sites=1e8, theta=1e-4, r=[0.98, 1.21, 0.87, 1.43, 0.92, 1.32, 0.99, 1.12, 0.95, 1.21, 0.87, 1.43, 0.92, 0.99, 1.12, 0.95, 1.21, 0.87, 1.43] ), params=dict(S_d=-300, b=1, p_b=0.05, S_b=0.1) ) sfs_sel = sim.run() inf = fd.BaseInference( sfs_sel=sfs_sel, sfs_neut=sim.sfs_neut, discretization=sim.discretization, fixed_params=dict(all=dict(eps=0, h=0.5)), do_bootstrap=True, n_bootstraps=100, parallelize=True ) inf.run() self.assertAlmostEqual(sim.n_sites, inf.sfs_sel.n_sites, delta=1e-6) self.assertAlmostEqual(sim.n_sites, inf.sfs_neut.n_sites) self.assertAlmostEqual(sim.theta, inf.sfs_neut.theta) for key in sim.params: self.assertAlmostEqual(inf.params_mle[key], sim.params[key], delta=np.abs(sim.params[key]) / 100) mean = inf.bootstraps.select_dtypes(""number"").mean() self.assertAlmostEqual(mean['S_d'], sim.params['S_d'], delta=np.abs(sim.params['S_d']) / 8) self.assertAlmostEqual(mean['b'], sim.params['b'], delta=np.abs(sim.params['b']) / 10) self.assertAlmostEqual(mean['p_b'], sim.params['p_b'], delta=np.abs(sim.params['p_b']) / 5) self.assertAlmostEqual(mean['S_b'], sim.params['S_b'], delta=np.abs(sim.params['S_b']) * 3) self.assertAlmostEqual(inf.bootstraps['eps'].mean(), 0, delta=1e-3) def test_recover_result_deleterious_dfe_no_demography(self): """""" Test that the simulated result can be recovered by inference. """""" sim = fd.Simulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), params=dict(S_d=-300, b=1, p_b=0, S_b=0.1) ) sfs_sel = sim.run() inf = fd.BaseInference( sfs_sel=sfs_sel, sfs_neut=sim.sfs_neut, discretization=sim.discretization, fixed_params=dict(all=dict(p_b=0, S_b=0.1, h=0.5, eps=0)), do_bootstrap=True, n_bootstraps=100, parallelize=True ) inf.run() self.assertAlmostEqual(sim.n_sites, inf.sfs_sel.n_sites) self.assertAlmostEqual(sim.n_sites, inf.sfs_neut.n_sites) self.assertAlmostEqual(sim.theta, inf.sfs_neut.theta) for key in sim.params: self.assertAlmostEqual(inf.params_mle[key], sim.params[key], delta=np.abs(sim.params[key]) / 1000) self.assertAlmostEqual(inf.bootstraps['S_d'].mean(), sim.params['S_d'], delta=10) self.assertAlmostEqual(inf.bootstraps['b'].mean(), sim.params['b'], delta=0.1) self.assertAlmostEqual(inf.bootstraps['eps'].mean(), 0, delta=1e-3) self.assertAlmostEqual(inf.bootstraps['p_b'].mean(), 0) self.assertAlmostEqual(inf.bootstraps['S_b'].mean(), 0.1) def test_usage_example_simulation_class(self): """""" Test the usage example of the Simulation class. """""" import fastdfe as fd # create simulation object by specifying neutral SFS and DFE sim = fd.Simulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), params=dict(S_d=-300, b=0.3, p_b=0.1, S_b=0.1), model=fd.GammaExpParametrization() ) # perform the simulation sfs_sel = sim.run() # plot SFS sfs_sel.plot() def test_parameter_out_of_bounds(self): """""" Test that the simulation of a neutral DFE with the Wright-Fisher model is correct. """""" with self.assertRaises(ValueError) as e: fd.Simulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=10, n_sites=1e8, theta=1e-4), params=dict(S_d=0, b=1, p_b=0, S_b=1), ) print(e.exception) def test_wright_fisher_simulation_sample_cdf(self): """""" Test that the sample_cdf method of the Wright-Fisher model is correct. """""" sim = fd.simulation.WrightFisherSimulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), params=dict(S_d=-300, b=10, p_b=0.1, S_b=50), ) samples = sim._sample_cdf(n=1000) ax = plt.gca() ax.hist(samples, bins=100, density=True, alpha=0.5) x = np.linspace(-1000, 300, 1000) ax.plot(x, sim.model.get_pdf(**sim.params)(x), color='red') ax.set_xlim(-1000, 300) plt.show() self.assertAlmostEqual(samples.mean(), -300 * 0.9 + 50 * 0.1, delta=10) def test_simulation_wright_fisher_usage_example(self): """""" Test the usage example of the WrightFisherSimulation class. """""" # create simulation object by specifying neutral SFS and DFE sim = fd.simulation.WrightFisherSimulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=int(1e7), theta=1e-4), params=dict(S_d=-300, b=0.3, p_b=0.1, S_b=0.1), model=fd.GammaExpParametrization(), pop_size=100, n_generations=500 ) # perform the simulation sfs_sel = sim.run() # plot SFS sfs_sel.plot() @pytest.mark.skip(reason=""takes too long for reasonable values"") def test_simulation_against_wright_fisher_neutral(self): """""" Test that the simulation of a neutral DFE with the Wright-Fisher model is correct. """""" sim = fd.simulation.WrightFisherSimulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=10, n_sites=1e8, theta=1e-6), params=dict(S_d=-1e-100, b=1, p_b=0, S_b=1), n_generations=1000, pop_size=100 ) sfs_sel = sim.run() sfs_sel.plot() self.assertAlmostEqual(sfs_sel.n_sites, sim.sfs_neut.n_sites) self.assertAlmostEqual(sfs_sel.n, sim.sfs_neut.n) self.assertAlmostEqual(sfs_sel.theta, sim.sfs_neut.theta) fd.Spectra(dict(neutral=sim.sfs_neut, selected=sfs_sel)).plot() np.testing.assert_array_almost_equal(sfs_sel.data, sim.sfs_neut.data) @pytest.mark.skip(reason=""takes too long for reasonable values"") def test_simulation_against_wright_fisher_deleterious(self): """""" Test that the simulation of a neutral DFE with the Wright-Fisher model is correct. """""" fd.logger.setLevel('DEBUG') sim = fd.simulation.WrightFisherSimulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=10, n_sites=1e8, theta=1e-6), params=dict(S_d=-100, b=1, p_b=0, S_b=1), n_generations=100, pop_size=100 ) sfs_sel = sim.run() sfs_sel.plot() def test_get_alpha(self): """""" Test the get_alpha method. """""" alphas = [] for h in np.linspace(0, 1, 11): sim = fd.Simulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), params=dict(S_d=-300, b=0.3, p_b=0.05, S_b=0.1, h=h) ) alphas.append(sim.get_alpha()) # make sure order is ascending self.assertTrue(np.all(np.diff(alphas) >= 0)) self.assertEqual(fd.Simulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), params=dict(S_d=-300, b=0.3, p_b=0, S_b=0.1, h=h) ).get_alpha(), 0) self.assertAlmostEqual(fd.Simulation( model=fd.GammaExpParametrization(bounds=dict(p_b=(0, 1))), sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), params=dict(S_d=-300, b=0.3, p_b=1, S_b=0.1, h=h) ).get_alpha(), 1, delta=1e-3) ","Python" "Allele","Sendrowski/fastDFE","testing/test_bootstrap.py",".py","3876","127","import numpy as np from scipy import stats from fastdfe.bootstrap import Bootstrap from testing import TestCase class BootstrapTestCase(TestCase): """""" Test the Bootstrap class. """""" def test_ci_percentile(self): x = np.arange(100) cis = Bootstrap.get_ci_percentile(x, 0.05) assert cis == (5, 95) def test_ci_bca(self): x = np.arange(100) cis = Bootstrap.get_ci_bca(x, 50, 0.05) assert cis == (5, 95) @staticmethod def get_cis(ci_level, values): """""" :param ci_level: :param values: :return: """""" # calculate the sample mean and standard error sample_mean = np.mean(values) standard_error = np.std(values) # determine the z-score for the chosen confidence level z_score = stats.norm.ppf(1 - ci_level) # calculate the margin of error margin_of_error = z_score * standard_error # calculate the confidence interval lower_bound = sample_mean - margin_of_error upper_bound = sample_mean + margin_of_error return lower_bound, upper_bound def compare_cis(self, values): """""" :param values: """""" # set the confidence level ci_level = 0.05 # create synthetic data original = np.mean(values) lower_bound, upper_bound = self.get_cis(ci_level, values) # calculate errors and confidence intervals using the get_errors function _, errors_perc, cis_perc = Bootstrap.get_errors([original], np.array([values]).T, ci_level, 'percentile') _, errors_bca, cis_bca = Bootstrap.get_errors([original], np.array([values]).T, ci_level, 'bca') assert np.abs(lower_bound - cis_perc[0][0]) / lower_bound < 0.005 assert np.abs(upper_bound - cis_perc[1][0]) / upper_bound < 0.005 assert np.abs(lower_bound - cis_bca[0][0]) / lower_bound < 0.005 assert np.abs(upper_bound - cis_bca[1][0]) / upper_bound < 0.005 def test_get_errors_percentile_positive(self): """""" Test the get_errors function for positive values. """""" np.random.seed(42) self.compare_cis(np.random.normal(5, 2, size=100000)) def test_get_errors_percentile_negative(self): """""" Test the get_errors function for negative values. """""" np.random.seed(42) self.compare_cis(-np.random.normal(5, 2, size=100000)) def test_get_errors_percentile_positive_and_negative(self): """""" Test the get_errors function for positive and negative values. """""" np.random.seed(42) self.compare_cis(np.random.normal(0, 2, size=100000)) def test_get_bounds_from_quantile_is_nan_return_nones(self): """""" Test get_bounds_from_quantile when data is nan. """""" bounds = Bootstrap.get_bounds_from_quantile([2, 2, 2], np.nan, np.nan, 3) self.assertEqual(tuple(bounds), (None, None)) def test_get_ci_percentile_invalid_a_raises_value_error(self): """""" Test get_ci_percentile when a is invalid. """""" with self.assertRaises(ValueError): Bootstrap.get_ci_percentile([1, 2, 3], 1.1) with self.assertRaises(ValueError): Bootstrap.get_ci_percentile([1, 2, 3], -0.1) def test_get_errors_invalid_bootstrap_type_raises_not_implemented_error(self): """""" Test get_errors when bootstrap_type is invalid. """""" with self.assertRaises(NotImplementedError): Bootstrap.get_errors([1, 2, 3], np.array([[1, 2, 3]]), bootstrap_type='invalid') def test_get_ci_bca_no_data_return_zeros(self): """""" Test get_ci_bca when bootstraps is empty. """""" bounds = Bootstrap.get_ci_bca([], 1, 0.05) self.assertEqual(bounds, [0, 0]) ","Python" "Allele","Sendrowski/fastDFE","testing/test_base_inference.py",".py","49322","1400","import copy import logging import resource import time from abc import ABC from unittest import mock import matplotlib.pyplot as plt import numpy as np import pandas as pd import pytest from numpy.random._generator import Generator from pandas.testing import assert_frame_equal from scipy.optimize import OptimizeResult import fastdfe as fd from fastdfe.discretization import Discretization from fastdfe.polydfe import PolyDFE from testing import TestCase class InferenceTestCase(TestCase, ABC): """""" Test inference. """""" def assertEqualObjects(self, obj1: object, obj2: object, ignore_keys=[]): """""" Compare objects, recursively comparing their attributes. :param obj1: First object :param obj2: Second object :param ignore_keys: Keys to ignore """""" ignore_keys += ['_logger'] if not hasattr(obj1, '__dict__'): self.assertEqual(obj1, obj2) else: d1 = obj1.__dict__ d2 = obj2.__dict__ for (key1, value1), (key2, value2) in zip(d1.items(), d2.items()): if key1 in ignore_keys: pass elif isinstance(value1, OptimizeResult): pass elif isinstance(value1, dict): self.assertEqual(value1.keys(), value2.keys()) for k in value1.keys(): self.assertEqualObjects(value1[k], value2[k], ignore_keys=ignore_keys) elif isinstance(value1, (int, float, str, bool, tuple, list, type(None), np.bool_)): self.assertEqual(value1, value2) elif isinstance(value1, np.ndarray): np.testing.assert_equal(value1, value2) elif isinstance(value1, pd.DataFrame): pd.testing.assert_frame_equal(value1.reset_index(drop=True), value2.reset_index(drop=True)) elif isinstance(value1, Generator): pass elif isinstance(value1, fd.Spectrum): np.testing.assert_equal(value1.to_list(), value2.to_list()) elif isinstance(value1, object): self.assertEqualObjects(value1, value2, ignore_keys=ignore_keys) else: raise AssertionError('Some objects were not compared.') class PolyDFETestCase(InferenceTestCase): """""" Test results against cached PolyDFE results. """""" # configs for testing against cached polydfe results configs_polydfe = [ 'pendula_C_full_bootstrapped_100', 'pendula_C_full_anc_bootstrapped_100', 'pendula_C_deleterious_bootstrapped_100', 'pendula_C_deleterious_anc_bootstrapped_100', 'pubescens_C_full_bootstrapped_100', 'pubescens_C_full_anc_bootstrapped_100', 'pubescens_C_deleterious_bootstrapped_100', 'pubescens_C_deleterious_anc_bootstrapped_100', 'example_1_C_full_bootstrapped_100', 'example_1_C_full_anc_bootstrapped_100', # 'example_1_C_deleterious_bootstrapped_100' # polydfe does not finish in this case 'example_1_C_deleterious_anc_bootstrapped_100', 'example_2_C_full_bootstrapped_100', 'example_2_C_full_anc_bootstrapped_100', 'example_2_C_deleterious_bootstrapped_100', 'example_2_C_deleterious_anc_bootstrapped_100', 'example_3_C_full_bootstrapped_100', 'example_3_C_full_anc_bootstrapped_100', 'example_3_C_deleterious_bootstrapped_100', 'example_3_C_deleterious_anc_bootstrapped_100' ] def compare_with_polydfe(self, config: str): """""" Test whether the results are similar to those of PolyDFE. """""" conf = fd.Config.from_file(f""testing/cache/configs/{config}/config.yaml"") conf.data['fixed_params']['all']['h'] = 0.5 inf_polydfe = PolyDFE.from_file(f""testing/cache/polydfe/{config}/serialized.json"") inf_fastdfe = fd.BaseInference.from_config(conf) inf_fastdfe.run() # compare discretized DFE dfe_fastdfe = inf_fastdfe.get_discretized() dfe_polydfe = inf_polydfe.get_discretized() ci_fastdfe = np.array([dfe_fastdfe[0] - dfe_fastdfe[1][0], dfe_fastdfe[0] + dfe_fastdfe[1][1]]) ci_polydfe = np.array([dfe_polydfe[0] - dfe_polydfe[1][0], dfe_polydfe[0] + dfe_polydfe[1][1]]) plt.clf() _, axs = plt.subplots(1, 2, figsize=(10, 4)) inf_fastdfe.plot_discretized(ax=axs[0], show=False, title='fastdfe') inf_polydfe.plot_discretized(ax=axs[1], show=True, title='polydfe') # assert that the confidence intervals almost overlap assert np.all(ci_fastdfe[0] <= ci_polydfe[1] + 0.05) assert np.all(ci_polydfe[0] <= ci_fastdfe[1] + 0.05) @staticmethod def generate_compare_with_polydfe(config: str) -> callable: """""" Generate test for comparing with PolyDFE. """""" def compare_with_polydfe(self): """""" Compare with PolyDFE. :param self: Self """""" self.compare_with_polydfe(config) return compare_with_polydfe # dynamically generate tests for config in configs_polydfe: locals()[f'test_compare_with_polydfe_{config}'] = generate_compare_with_polydfe(config) class BaseInferenceTestCase(InferenceTestCase): """""" Test BaseInference. """""" config_file = ""testing/cache/configs/pendula_C_full_anc/config.yaml"" serialized = ""testing/cache/fastdfe/pendula_C_full_anc/serialized.json"" def test_run_inference_from_config_parallelized(self): """""" Run inference from config file. """""" config = fd.Config.from_file(self.config_file) config.update(parallelize=True) inf = fd.BaseInference.from_config(config) inf.run() # make sure the likelihood is the maximum of the runs self.assertEqual(inf.likelihood, inf.runs.likelihood.max()) def test_run_inference_from_config_not_parallelized(self): """""" Run inference from config file. """""" config = fd.Config.from_file(self.config_file) config.update(parallelize=False) inf = fd.BaseInference.from_config(config) inf.run() # make sure the likelihood is the maximum of the runs self.assertEqual(inf.likelihood, inf.runs.likelihood.max()) def test_seeded_inference_is_deterministic_non_parallelized(self): """""" Check that inference is deterministic when seeded and not parallelized. """""" config = fd.Config.from_file(self.config_file) config.update( seed=0, do_bootstrap=True, parallelize=False, n_bootstraps=2 ) inf = fd.BaseInference.from_config(config) inf.run() inf2 = fd.BaseInference.from_config(config) inf2.run() self.assertEqual(inf.params_mle, inf2.params_mle) assert_frame_equal(inf.bootstraps, inf2.bootstraps) def test_seeded_inference_is_deterministic_parallelized(self): """""" Check that seeded inference is deterministic when parallelized. """""" config = fd.Config.from_file(self.config_file) config.update( seed=0, do_bootstrap=True, parallelize=True, n_bootstraps=2 ) inference = fd.BaseInference.from_config(config) inference.run() inference2 = fd.BaseInference.from_config(config) inference2.run() self.assertEqual(inference.params_mle, inference2.params_mle) assert_frame_equal(inference.bootstraps, inference2.bootstraps) def test_compare_inference_with_log_scales_vs_lin_scales(self): """""" Compare inference with log scales vs linear scales. """""" config = fd.Config.from_file(self.config_file) model = fd.GammaExpParametrization() model.scales = dict( S_d='log', b='log', p_b='lin', S_b='log' ) config.update( model=model, do_bootstrap=True ) inference_log = fd.BaseInference.from_config(config) inference_log.run() model = copy.copy(model) model.scales = dict( S_d='lin', b='lin', p_b='lin', S_b='lin' ) config.update(model=model) inference_lin = fd.BaseInference.from_config(config) inference_lin.run() fig, axs = plt.subplots(1, 2, figsize=(10, 5)) inference_lin.plot_discretized(ax=axs[0], show=False) inference_log.plot_discretized(ax=axs[1], show=False) axs[0].set_title('Linear scales') axs[1].set_title('Log scales') plt.tight_layout() plt.show() # get confidence intervals cis_lin = inference_lin.get_stats_discretized()[2] cis_log = inference_log.get_stats_discretized()[2] # assert that the confidence intervals overlap assert np.all(cis_lin[0] < cis_log[1]) assert np.all(cis_log[0] < cis_lin[1]) # likelihood on log scales should be better assert inference_log.likelihood > inference_lin.likelihood assert inference_log.bootstraps.likelihood.mean() > inference_lin.bootstraps.likelihood.mean() # standard deviation of bootstrapped likelihoods should be lower on log scales assert inference_log.bootstraps.likelihoods_std.mean() * 2 < inference_lin.bootstraps.likelihoods_std.mean() def test_compare_inference_with_log_scales_vs_lin_scales_tutorial(self): """""" Compare inference with log scales vs linear scales. """""" model = fd.GammaExpParametrization() model.scales = dict( S_d='log', b='log', p_b='lin', S_b='log' ) inference_log = fd.BaseInference( sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), fixed_params=dict(all=dict(h=0.5)), model=model, do_bootstrap=True, n_runs=10 ) inference_log.run() model = fd.GammaExpParametrization() model.scales = dict( S_d='lin', b='lin', p_b='lin', S_b='lin' ) inference_lin = fd.BaseInference( sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), fixed_params=dict(all=dict(h=0.5)), model=model, do_bootstrap=True, n_runs=10 ) inference_lin.run() fig, axs = plt.subplots(1, 2, figsize=(10, 5)) inference_lin.plot_discretized(ax=axs[0], show=False) inference_log.plot_discretized(ax=axs[1], show=False) axs[0].set_title('Linear scales') axs[1].set_title('Log scales') plt.tight_layout() plt.show() # get confidence intervals cis_lin = inference_lin.get_stats_discretized()[1] cis_log = inference_log.get_stats_discretized()[1] # assert that the confidence intervals overlap # assert np.all(cis_lin[0] < cis_log[1]) # assert np.all(cis_log[0] < cis_lin[1]) # likelihood on log scales should be better assert inference_log.likelihood > inference_lin.likelihood # standard deviation of bootstrapped likelihoods should be lower on log scales assert inference_log.bootstraps.likelihoods_std.mean() * 100 < inference_lin.bootstraps.likelihoods_std.mean() def test_restore_serialized_inference(self): """""" Check whether Inference can properly be serialized and restored. """""" inference = fd.BaseInference.from_config_file(self.config_file) inference.run() serialized = 'scratch/test_serialize_inference.json' inference.to_file(serialized) inference_restored = fd.BaseInference.from_file(serialized) # self.assertEqual(inference.to_json(), inference_restored.to_json()) self.assertEqualObjects(inference, inference_restored) def test_inference_run_bootstrap(self): """""" Run bootstrap on inference. """""" # unserialize inference = fd.BaseInference.from_file(self.serialized) # make sure the likelihoods of the different runs are cached self.assertEqual(len(inference.likelihoods), inference.n_runs) self.assertIsNone(inference.bootstraps) inference.bootstrap(2, parallelize=False) self.assertIsNotNone(inference.bootstraps) # make sure the likelihoods of the different runs are not overwritten self.assertEqual(len(inference.likelihoods), inference.n_runs) def test_evaluate_likelihood_same_as_mle_results(self): """""" Check that evaluating the loss function at the MLE result yields the same likelihood as the one reported. """""" # unserialize inference = fd.BaseInference.from_file(self.serialized) self.assertAlmostEqual(inference.evaluate_likelihood(dict(all=inference.params_mle)), inference.likelihood) def test_visualize_inference_without_bootstraps(self): """""" Plot everything possible. """""" config = fd.Config.from_file(self.config_file) config.update( do_bootstrap=False ) inference = fd.BaseInference.from_config(config) inference.plot_all() inference.plot_bucket_sizes() def test_visualize_inference_with_bootstraps(self): """""" Plot everything possible. """""" config = fd.Config.from_file(self.config_file) config.update( do_bootstrap=True ) inference = fd.BaseInference.from_config(config) inference.plot_all() inference.plot_bucket_sizes() def test_plot_likelihoods(self): """""" Plot likelihoods. """""" # unserialize inference = fd.BaseInference.from_file(self.serialized) inference.plot_likelihoods() def test_plot_interval_density(self): """""" Plot likelihoods. """""" # unserialize inference = fd.BaseInference.from_file(self.serialized) inference.plot_interval_density() def test_plot_inferred_parameters(self): """""" Plot inferred parameters. """""" # unserialize inference = fd.BaseInference.from_file(self.serialized) inference.plot_inferred_parameters() def test_plot_inferred_parameters_boxplot(self): """""" Plot inferred parameters. """""" # unserialize inference = fd.BaseInference.from_file(self.serialized) inference.bootstrap(6) inference.plot_inferred_parameters_boxplot() def test_plot_observed_sfs(self): """""" Plot likelihoods. """""" # unserialize inference = fd.BaseInference.from_file(self.serialized) inference.plot_observed_sfs() def test_plot_provide_axes(self): """""" Plot likelihoods. """""" # unserialize inference = fd.BaseInference.from_file(self.serialized) _, axs = plt.subplots(ncols=2) inference.plot_interval_density(show=False, ax=axs[0]) inference.plot_interval_density(ax=axs[1]) def test_visualize_inference_bootstrap(self): """""" Plot everything possible. """""" # unserialize inference = fd.BaseInference.from_file(self.serialized) # bootstrap inference.bootstrap(2) inference.plot_all() def test_perform_bootstrap_without_running(self): """""" Perform bootstrap before having run the main inference. """""" # unserialize inference = fd.BaseInference.from_config_file(self.config_file) # bootstrap inference.bootstrap(2) def test_compare_nested_with_bootstrap(self): """""" Compare nested likelihoods. """""" # unserialize inference = fd.BaseInference.from_config_file(self.config_file) inference.compare_nested_models() inference.plot_nested_models() inference.plot_nested_models(remove_empty=True) inference.plot_nested_models(transpose=True) def test_compare_nested_different_parametrizations_raises_error(self): """""" Make sure that comparing nested likelihoods with different parametrizations raises an error. """""" config1 = fd.Config.from_file(self.config_file) config1.update(model=fd.GammaExpParametrization()) inf1 = fd.BaseInference.from_config(config1) config2 = fd.Config.from_file(self.config_file) config2.update(model=fd.DiscreteParametrization()) inf2 = fd.BaseInference.from_config(config2) with self.assertRaises(ValueError): inf1.compare_nested(inf2) def test_compare_nested_different_fixed_params_raises_error(self): """""" Make sure that comparing nested likelihoods with different fixed parameters raises an error. """""" config1 = fd.Config.from_file(self.config_file) config1.update(fixed_params=dict(all=dict(S_b=1, p_b=0))) inf1 = fd.BaseInference.from_config(config1) config2 = fd.Config.from_file(self.config_file) config2.update(fixed_params=dict(all=dict(S_b=1, eps=0))) inf2 = fd.BaseInference.from_config(config2) with self.assertRaises(ValueError): inf1.compare_nested(inf2) def test_compare_nested_valid_comparison_1df(self): """""" Make sure that comparing nested models with the same parametrization works as expected. """""" config1 = fd.Config.from_file(self.config_file) config1.update(fixed_params=dict(all=dict(S_b=1, p_b=0, h=0.5)), do_bootstrap=False) inf1 = fd.BaseInference.from_config(config1) inf1.run() config2 = fd.Config.from_file(self.config_file) config2.update(fixed_params=dict(all=dict(S_b=1, h=0.5)), do_bootstrap=False) inf2 = fd.BaseInference.from_config(config2) inf2.run() assert 0 < inf1.compare_nested(inf2) < 1 def test_compare_nested_valid_automatic_run(self): """""" Make sure that comparing nested models with the same parametrization works as expected. """""" config1 = fd.Config.from_file(self.config_file) config1.update(fixed_params=dict(all=dict(S_b=1, p_b=0, h=0.5)), do_bootstrap=False) inf1 = fd.BaseInference.from_config(config1) config2 = fd.Config.from_file(self.config_file) config2.update(fixed_params=dict(all=dict(S_b=1, h=0.5)), do_bootstrap=False) inf2 = fd.BaseInference.from_config(config2) assert 0 < inf1.compare_nested(inf2) < 1 def test_lrt_components(self): """""" Check whether the weights and degrees of freedom of the components are computed correctly. """""" inf = fd.BaseInference.from_config_file(self.config_file) # test weights np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=1, m=0)[0], [1]) np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=1, m=1)[0], [0.5, 0.5]) np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=2, m=1)[0], [0.5, 0.5]) np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=2, m=2)[0], [0.25, 0.5, 0.25]) np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=2, m=0)[0], [1]) np.testing.assert_array_equal( inf._lrt_components(ll_simple=50, ll_complex=51, df=3, m=3)[0], [0.125, 0.375, 0.375, 0.125] ) np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=3, m=2)[0], [0.25, 0.5, 0.25]) np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=3, m=0)[0], [1]) # test degrees of freedom of components np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=1, m=0)[2], [1]) np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=1, m=1)[2], [0, 1]) np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=2, m=1)[2], [1, 2]) np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=2, m=2)[2], [0, 1, 2]) np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=2, m=0)[2], [2]) np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=3, m=3)[2], [0, 1, 2, 3]) np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=3, m=2)[2], [1, 2, 3]) np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=3, m=0)[2], [3]) def test_is_nested(self): """""" Check whether the is_nested method works as expected. """""" config1 = fd.Config.from_file(self.config_file).update(fixed_params={}) config2 = copy.deepcopy(config1).update(fixed_params={}, model=fd.DiscreteParametrization()) config3 = copy.deepcopy(config1).update(fixed_params=dict(all=dict(eps=0))) config4 = copy.deepcopy(config1).update(fixed_params=dict(all=dict(eps=0, S_b=1))) config5 = copy.deepcopy(config1).update(fixed_params=dict(all=dict(eps=0)), model=fd.DiscreteParametrization()) def is_nested(simple: fd.Config, complex: fd.Config) -> bool: return fd.BaseInference.from_config(simple)._is_nested(fd.BaseInference.from_config(complex)) self.assertFalse(is_nested(simple=config1, complex=config2)) self.assertFalse(is_nested(simple=config2, complex=config1)) self.assertFalse(is_nested(simple=config1, complex=config1)) self.assertFalse(is_nested(simple=config1, complex=config3)) self.assertTrue(is_nested(simple=config3, complex=config1)) self.assertTrue(is_nested(simple=config4, complex=config1)) self.assertTrue(is_nested(simple=config4, complex=config3)) self.assertFalse(is_nested(simple=config3, complex=config4)) self.assertFalse(is_nested(simple=config3, complex=config5)) self.assertFalse(is_nested(simple=config5, complex=config1)) def test_plot_nested_model_comparison_without_running(self): """""" Perform nested model comparison before having run the main inference. We just make sure this triggers a run. """""" # unserialize inference = fd.BaseInference.from_config_file(self.config_file) inference.plot_nested_models() def test_plot_nested_model_comparison_different_parametrizations(self): """""" Perform nested model comparison before having run the main inference. We just make sure this triggers a run. """""" parametrizations = [ fd.GammaExpParametrization(), fd.DisplacedGammaParametrization(), fd.DiscreteParametrization(), fd.DiscreteFractionalParametrization(), fd.GammaDiscreteParametrization() ] for p in parametrizations: config = fd.Config.from_file(self.config_file).update( model=p, do_bootstrap=True, n_bootstraps=2, n_runs=1, fixed_params=dict(all=dict(h=0.5)) ) # unserialize inference = fd.BaseInference.from_config(config) inference.plot_nested_models(title=p.__class__.__name__) def test_recreate_from_config(self): """""" Test whether inference can be recreated from config. """""" inf = fd.BaseInference.from_config_file(self.config_file) inf2 = fd.BaseInference.from_config(inf.create_config()) self.assertEqualObjects(inf, inf2) def test_cached_result(self): """""" Test inference against cached result. """""" inf = fd.BaseInference.from_file(self.serialized) inf2 = fd.BaseInference.from_config(inf.create_config()) inf2.run() inf_params_mle = np.array(list((inf.params_mle | {'h': 0.5}).values())) inf2_params_mle = np.array(list(inf2.params_mle.values())) diff = np.abs(inf_params_mle - inf2_params_mle) / (inf_params_mle + 1e-10) # compare MLE parameters self.assertLess(diff.max(), 1e-3) def test_run_if_necessary_wrapper_triggers_run(self): """""" Test whether the run_if_necessary wrapper triggers a run if the inference has not been run yet. """""" inference = fd.BaseInference.from_config_file(self.config_file) with mock.patch.object(fd.BaseInference, 'run', side_effect=Exception()) as mock_run: try: inference.plot_inferred_parameters(show=False) except Exception: pass mock_run.assert_called_once() def test_run_if_necessary_wrapper_not_triggers_run(self): """""" Test whether the run_if_necessary wrapper does not trigger a run if the inference has already been run. """""" inference = fd.BaseInference.from_file(self.serialized) with mock.patch.object(fd.BaseInference, 'run') as mock_run: inference.plot_inferred_parameters(show=False) mock_run.assert_not_called() def test_run_with_sfs_neut_zero_entry(self): """""" Test whether inference can be run with a neutral SFS that has a zero entry. """""" config = fd.Config.from_file(self.config_file) # set neutral SFS entry to zero sfs = config.data['sfs_neut']['all'].to_list() sfs[3] = 0 sfs = fd.Spectrum(sfs) config.data['sfs_neut'] = fd.Spectra.from_spectrum(sfs) inference = fd.BaseInference.from_config(config) inference.run() # here both the nuisance parameters and epsilon cause the high number of high-frequency variants inference.plot_sfs_comparison() inference.plot_discretized() def test_run_with_sfs_sel_zero_entry(self): """""" Test whether inference can be run with a selected SFS that has a zero entry. """""" config = fd.Config.from_file(self.config_file) # set selected SFS entry to zero sfs = config.data['sfs_sel']['all'].to_list() sfs[3] = 0 sfs = fd.Spectrum(sfs) config.data['sfs_sel'] = fd.Spectra.from_spectrum(sfs) inference = fd.BaseInference.from_config(config) inference.run() # this looks as expected, i.e. we reduce the overall distance between the modelled and observed SFS inference.plot_sfs_comparison() inference.plot_discretized() def test_run_with_both_sfs_zero_entry(self): """""" Test whether inference can be run with both SFS that have a zero entry. """""" config = fd.Config.from_file(self.config_file) # set neutral SFS entry to zero sfs = config.data['sfs_neut']['all'].to_list() sfs[3] = 0 sfs = fd.Spectrum(sfs) config.data['sfs_neut'] = fd.Spectra.from_spectrum(sfs) # set selected SFS entry to zero sfs = config.data['sfs_sel']['all'].to_list() sfs[3] = 0 sfs = fd.Spectrum(sfs) config.data['sfs_sel'] = fd.Spectra.from_spectrum(sfs) inference = fd.BaseInference.from_config(config) inference.run() # the nuisance parameters cause the zero entry in the modelled SFS inference.plot_sfs_comparison() inference.plot_discretized() def test_fixed_parameters(self): """""" Test whether fixed parameters are correctly set. """""" config = fd.Config.from_file(self.config_file) config.data['fixed_params'] = dict(all=dict(b=1.123, eps=0.123, h=0.5)) inference = fd.BaseInference.from_config(config) inference.run() assert inference.params_mle['b'] == config.data['fixed_params']['all']['b'] assert inference.params_mle['eps'] == config.data['fixed_params']['all']['eps'] assert inference.params_mle['S_b'] != config.data['x0']['all']['S_b'] assert inference.params_mle['S_d'] != config.data['x0']['all']['S_d'] assert inference.params_mle['p_b'] != config.data['x0']['all']['p_b'] def test_get_n_optimized(self): """""" Test get number of parameters to be optimized """""" config = fd.Config.from_file(self.config_file) assert fd.BaseInference.from_config(config).get_n_optimized() == 5 config.data['fixed_params'] = dict(all=dict(S_b=1, p_b=0, h=0.5)) assert fd.BaseInference.from_config(config).get_n_optimized() == 3 def test_non_existing_fixed_param_raises_error(self): """""" Test that a non-existing fixed parameter raises an error. """""" config = fd.Config.from_file(self.config_file) config.data['fixed_params'] = dict(all=dict(S_b=1, p_b=0, foo=1)) with self.assertRaises(ValueError): fd.BaseInference.from_config(config) def test_get_discretized_errors_with_bootstraps(self): """""" Get the discretized DFE errors. """""" inference = fd.BaseInference.from_file(self.serialized) inference.bootstrap() res = inference.get_discretized() def test_get_discretized_errors_no_bootstraps(self): """""" Get the discretized DFE errors. """""" inference = fd.BaseInference.from_file(self.serialized) values, errors = inference.get_discretized() assert errors is None def test_spectrum_with_zero_monomorphic_counts_throws_error(self): """""" Test whether a spectrum with zero monomorphic counts throws an error. """""" sfs_neut = fd.Spectrum([0, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]) sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]) with self.assertRaises(ValueError): fd.BaseInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, ) def test_spectrum_with_few_monomorphic_counts_raises_warning(self): """""" Test whether a spectrum with zero monomorphic counts throws an error. """""" sfs_neut = fd.Spectrum([1000, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]) sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]) with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe')): fd.BaseInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, ) @staticmethod def test_adjust_polarization(): """""" Test whether polarization is adjusted correctly. """""" counts_list = [np.array([1, 2, 3, 4, 5]), np.array([2, 3, 5, 7, 11])] eps_list = [0, 0.1, 0.5, 1] expected_counts_list = [ [ np.array([1, 2, 3, 4, 5]), np.array([1.4, 2.2, 3.0, 3.8, 4.6]), np.array([3.0, 3.0, 3.0, 3.0, 3.0]), np.array([5, 4, 3, 2, 1]) ], [ np.array([2, 3, 5, 7, 11]), np.array([2.9, 3.4, 5, 6.6, 10.1]), np.array([6.5, 5.0, 5.0, 5.0, 6.5]), np.array([11, 7, 5, 3, 2]) ] ] for i, counts in enumerate(counts_list): for j, eps in enumerate(eps_list): adjusted_counts = fd.BaseInference._adjust_polarization(counts, eps) assert np.isclose(np.sum(counts), np.sum(adjusted_counts)) assert np.allclose(adjusted_counts, expected_counts_list[i][j]) def test_estimating_full_dfe_with_folded_sfs_raises_warning(self): """""" Test whether estimating the full DFE with a folded SFS raises a warning. """""" sfs_neut = fd.Spectrum([1, 1, 0, 0]) sfs_sel = fd.Spectrum([1, 1, 0, 0]) with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe')): fd.BaseInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, ) @staticmethod def test_folded_inference_even_sample_size(): """""" Test folded inference with even sample size. """""" sfs_neut = fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]).fold() sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]).fold() inf = fd.BaseInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, fixed_params=dict(all=dict(S_b=1, p_b=0, h=0.5)), do_bootstrap=False, ) inf.plot_discretized() @staticmethod def test_folded_inference_odd_sample_size(): """""" Test folded inference with odd sample size. """""" sfs_neut = fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 652]).fold() sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 794]).fold() inf = fd.BaseInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, fixed_params=dict(all=dict(S_b=1, p_b=0, h=0.5)), do_bootstrap=False, ) inf.plot_discretized() pass def test_sample_data_fixed_result(self): """""" Test against fixed result. """""" sfs_neut = fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]) sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]) inf = fd.BaseInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, fixed_params=dict(all=dict(h=0.5)), do_bootstrap=False, ) inf.run() expected = { 'S_d': -9868.141535, 'b': 0.150810, 'eps': 0.006854, 'p_b': 0.0 } self.assertAlmostEqual(inf.params_mle['S_d'], expected['S_d'], delta=2) self.assertAlmostEqual(inf.params_mle['b'], expected['b'], delta=1e-2) self.assertAlmostEqual(inf.params_mle['eps'], expected['eps'], delta=1e-3) self.assertAlmostEqual(inf.params_mle['p_b'], expected['p_b'], delta=1e-4) def test_base_inference_l2_loss_type(self): """""" Test whether the L2 loss type is correctly set. """""" sfs_neut = fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]) sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]) inf = fd.BaseInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, fixed_params=dict(all=dict(h=0.5)), loss_type='L2', do_bootstrap=True, n_bootstraps=5 ) inf.run() @staticmethod def test_few_polymorphic_sites_raises_no_error(): """""" Test whether a spectrum with few polymorphic sites raises no error. """""" inf = fd.BaseInference( sfs_neut=fd.Spectrum([1243, 0, 0, 1, 0, 0, 0]), sfs_sel=fd.Spectrum([12421, 0, 0, 0, 0, 1, 0]), do_bootstrap=False, ) # There are sometimes problems with the optimization for spectra like these, # but this should be nothing to worry about inf.run() inf.plot_discretized() pass def test_no_polymorphic_sites_raises_error(self): """""" Test whether a spectrum with zero monomorphic counts throws an error. """""" with self.assertRaises(ValueError) as context: fd.BaseInference( sfs_neut=fd.Spectrum([1243, 0, 0, 0, 0, 0, 0]), sfs_sel=fd.Spectrum([12421, 0, 0, 0, 0, 0, 0]), ) print(context.exception) def test_different_sfs_sample_sizes_raises_error(self): """""" Test whether a spectrum with zero monomorphic counts throws an error. """""" with self.assertRaises(ValueError) as context: fd.BaseInference( sfs_neut=fd.Spectrum([1000, 4, 2, 1]), sfs_sel=fd.Spectrum([1000, 4, 2, 1, 0]) ) print(context.exception) @staticmethod def test_spectra_with_fractional_counts(): """""" Test whether a spectrum with fractional counts works as expected. """""" sfs_neut = fd.Spectrum([177130.4, 997.3, 441.2, 228.1, 156.45, 117.2, 114.9, 83.12, 105.453, 109.1, 652.05]) sfs_sel = fd.Spectrum([797939.4, 1329.3, 499.2, 265.1, 162.12, 104.2, 117.9, 90.12, 94.453, 119.1, 794.05]) inf_float = fd.BaseInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, fixed_params=dict(all=dict(h=0.5)), do_bootstrap=False, ) inf_float.run() inf_int = fd.BaseInference( sfs_neut=fd.Spectrum(sfs_neut.data.astype(int)), sfs_sel=fd.Spectrum(sfs_sel.data.astype(int)), fixed_params=dict(all=dict(h=0.5)), do_bootstrap=False, ) inf_int.run() fd.Inference.plot_discretized([inf_float, inf_int], labels=['float', 'int']) assert np.abs((inf_float.params_mle['S_d'] - inf_int.params_mle['S_d']) / inf_float.params_mle['S_d']) < 1e-2 assert np.abs((inf_float.params_mle['b'] - inf_int.params_mle['b']) / inf_float.params_mle['b']) < 1e-2 @staticmethod def test_manuscript_example(): """""" Test the example from the manuscript. """""" # create inference object inf = fd.BaseInference( sfs_neut=fd.Spectrum([66200, 410, 120, 60, 42, 43, 52, 65, 0]), sfs_sel=fd.Spectrum([281937, 600, 180, 87, 51, 43, 49, 61, 0]), model=fd.GammaExpParametrization(), # the model to use n_runs=10, # number of optimization runs n_bootstraps=100, # number of bootstrap replicates do_bootstrap=True ) # create subplots axs = plt.subplots(2, 2, figsize=(11, 7))[1].flatten() # plot results types = ['neutral', 'selected'] inf.plot_sfs_comparison(ax=axs[0], show=False, sfs_types=types) inf.plot_sfs_comparison(ax=axs[1], show=False, colors=['C1', 'C5']) inf.plot_inferred_parameters(ax=axs[2], show=False) inf.plot_discretized(ax=axs[3], show=True) def test_infer_no_selection(self): """""" Test whether we infer a mostly neutral DFE when there is no selection. """""" sfs = fd.Spectrum.standard_kingman(10, n_monomorphic=100) # use different scalings which should not affect the result for m in [1, 10, 0.1, sfs]: inf = fd.BaseInference( sfs_neut=sfs * m, sfs_sel=sfs * m, fixed_params=dict(all=dict(h=0.5)), do_bootstrap=False, seed=42, model=fd.DiscreteFractionalParametrization( intervals=np.array([-100000, -0.1, 0.1, 10000]) ) ) inf.run() # check that DFE is very neutral self.assertAlmostEqual(1, inf.get_discretized(intervals=np.array([-100000, -0.1, 0.1, 10000]))[0][1]) def test_infer_strongly_beneficial_selection_target_sites(self): """""" Test whether we infer a strongly beneficial DFE when there is strong selection. """""" # use different mutational target sizes inf = fd.BaseInference( sfs_neut=fd.Spectrum.standard_kingman(10, n_monomorphic=100), sfs_sel=fd.Spectrum.standard_kingman(10, n_monomorphic=10), fixed_params=dict(all=dict(h=0.5)), do_bootstrap=False, seed=42 ) inf.run() # check that DFE is very weakly beneficial self.assertGreaterEqual(inf.get_discretized()[0][-1], 0.4) def test_infer_strongly_deleterious_selection_target_sites(self): """""" Test whether we infer a strongly deleterious DFE when there is strong selection. """""" # use different mutational target sizes inf = fd.BaseInference( sfs_neut=fd.Spectrum.standard_kingman(10, n_monomorphic=100), sfs_sel=fd.Spectrum.standard_kingman(10, n_monomorphic=1000), fixed_params=dict(all=dict(h=0.5)), do_bootstrap=False, seed=42 ) inf.run() # check that DFE is very strongly deleterious self.assertGreaterEqual(inf.get_discretized()[0][0], 0.8) def test_infer_deleterious_selection_sfs_shape(self): """""" Test whether we infer a deleterious DFE when there is selection. """""" n = 10 sfs_neut = fd.Spectrum.standard_kingman(n, n_monomorphic=100) sfs_sel = fd.Spectrum.from_polymorphic( Discretization(n=n).get_counts_semidominant_regularized(-10 * np.ones(n - 1), np.arange(1, n)) ) sfs_sel.data[0] = 100 # use different mutational target sizes inf = fd.BaseInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, fixed_params=dict(all=dict(h=0.5)), do_bootstrap=False, seed=42 ) inf.run() # check that DFE is very deleterious self.assertAlmostEqual(1, inf.get_discretized(np.array([-np.inf, -1, np.inf]))[0][0]) def test_alternative_optimizer(self): """""" Test whether using an alternative optimizer works as expected. """""" config = fd.Config.from_file(self.config_file) inf_default = fd.BaseInference.from_config(config) inf_default.run() inf_alt = fd.BaseInference.from_config(config.update(method_mle='TNC')) inf_alt.run() def test_raise_error_n_above_400(self): """""" Test whether an error is raised when sample size is above 400. """""" with self.assertRaises(ValueError) as context: fd.BaseInference( sfs_neut=fd.Spectrum.standard_kingman(401, n_monomorphic=10000), sfs_sel=fd.Spectrum.standard_kingman(401, n_monomorphic=10000) ) print(context.exception) def test_bootstrap_n_retries(self): """""" Test whether bootstrapping with retries works as expected. """""" config = fd.Config.from_file(self.config_file).update( n_bootstrap_retries=3, parallelize=True, n_bootstraps=3, do_bootstrap=True ) inf = fd.BaseInference.from_config(config) inf.run() self.assertEqual(3, len(inf.bootstraps.likelihoods_runs.iloc[0])) self.assertEqual(3, len(inf.bootstraps.x0_runs.iloc[0])) self.assertGreater(inf.bootstraps.likelihoods_std.mean(), 0) # make sure that the best likelihood per bootstrap is equal to the maximum over runs self.assertTrue(np.all(inf.bootstraps.likelihoods_runs.apply(max) == inf.bootstraps.likelihood)) def test_infer_dfe_with_fixed_h_low_memory_consumption(self): """""" Make sure memory consumption is low for default settings. """""" for h in [0, 0.5, 1]: inf = fd.BaseInference( sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), fixed_params={'all': {'h': h, 'S_b': 1, 'p_b': 0, 'eps': 0}}, parallelize=True, do_bootstrap=True, n_bootstraps=10, n_runs=10 ) inf.run() mem_gb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024 ** 3 self.assertLess(mem_gb, 1) self.assertEqual(inf.params_mle['h'], h) def test_infer_h(self): """""" Test inference of h parameter. """""" inf = fd.BaseInference( sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1.0e+8, -1.0e-5, 100), intervals_h=(0, 1, 11), fixed_params={'all': {'S_b': 1, 'p_b': 0, 'eps': 0}}, parallelize=False, do_bootstrap=True, n_bootstraps=50, n_runs=10 ) inf.run() inf.plot_discretized() mem_gb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024 ** 3 self.assertLess(mem_gb, 1) self.assertGreater(inf.bootstraps.h.std(), 0) def test_infer_h_custom_callback(self): """""" Test inference of h parameter. """""" inf = fd.BaseInference( sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1.0e+8, -1.0e-5, 100), h_callback=lambda h, S: 0.4 * np.exp(-h * abs(S)), intervals_h=(0, 1, 11), fixed_params={'all': {'S_b': 1, 'p_b': 0, 'eps': 0}}, bounds={ 'S_d': (-100000.0, -0.01), 'b': (0.01, 10), 'p_b': (0, 0.5), 'S_b': (0.0001, 100), 'eps': (0, 0.15), 'h': (0, 100) }, parallelize=False, do_bootstrap=True, n_bootstraps=50, n_runs=10 ) inf.run() inf.plot_discretized() pass def test_compare_nested_h_parameter(self): """""" Test nested model comparison when h is optimized in one model and fixed in the other. """""" inf1 = fd.BaseInference( sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1.0e+8, -1.0e-5, 100), intervals_h=(0, 1, 11), fixed_params={'all': {'S_b': 1, 'p_b': 0, 'eps': 0}}, parallelize=True, do_bootstrap=True, n_runs=5, n_bootstraps=20 ) inf1.run() inf2 = fd.BaseInference.from_config( inf1.create_config().update( fixed_params={'all': {'S_b': 1, 'p_b': 0, 'eps': 0, 'h': 0.5}} ) ) inf2.run() p = inf2.compare_nested(inf1) self.assertTrue(0 < p < 1) def test_get_dfe_and_plot(self): """""" Test get DFE method. """""" inf = fd.BaseInference.from_file(self.serialized) inf.get_dfe().plot() inf.bootstrap(parallelize=False, n_samples=10) inf.get_dfe().plot() inf.get_dfe().get_bootstrap_dfes()[1].plot() @pytest.mark.skip(reason=""Not a real test."") def test_runtime_sequential_vs_parallel(self): """""" Test whether parallelization speeds up inference. This doesn't seem to be true currently on osx-arm64 at least. """""" inf_seq = fd.BaseInference( sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), parallelize=False, do_bootstrap=True ) start_time = time.time() inf_seq.run() seq_time = time.time() - start_time inf_par = fd.BaseInference( sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), parallelize=True, do_bootstrap=True ) start_time = time.time() inf_par.run() par_time = time.time() - start_time self.assertLess(par_time, seq_time) def test_serialize_inference_result(self): """""" Test whether inference results can be serialized and unserialized correctly. """""" inf = fd.BaseInference.from_file(self.serialized) # serialize result = inf.get_summary() result.to_file(""scratch/inference_result.json"") # unserialize result2 = fd.InferenceResult.from_file(""scratch/inference_result.json"") self.assertEqualObjects(result, result2) ","Python" "Allele","Sendrowski/fastDFE","testing/test_discretization.py",".py","19168","604","from unittest.mock import patch import numpy as np import pytest from matplotlib import pyplot as plt from scipy.special import hyp1f1 from tqdm import tqdm import fastdfe as fd from fastdfe import GammaExpParametrization from fastdfe.discretization import Discretization from testing import TestCase class DiscretizationTestCase(TestCase): """""" Test the Discretization class. """""" n = 20 @staticmethod def diff(a, b): """""" Difference. """""" return a - b def diff_rel(self, a, b): """""" Relative difference. """""" return self.diff(a, b) / a def diff_max_abs(self, a, b): """""" Maximum absolute difference. """""" return np.max(np.abs(self.diff(a, b))) def diff_rel_max_abs(self, a, b): """""" Maximum absolute relative difference. """""" return np.max(np.abs(self.diff_rel(a, b))) def test_dfe_to_sfs_linearization_midpoint_vs_quad(self): """""" Check for discrepancies between the linearized DFE to SFS transformation using midpoint integration vs scipy's quad. """""" opts = dict( n=self.n, h=0.5, intervals_ben=(1.0e-5, 100, 100), intervals_del=(-10000, -1.0e-5, 100) ) d_midpoint = Discretization(**opts, integration_mode='midpoint') d_quad = Discretization(**opts, integration_mode='quad') P_quad = d_midpoint.get_counts(h=0.5) P_lin = d_quad.get_counts(h=0.5) # P_diff_rel = self.diff_rel(P_quad, P_lin) diff = self.diff_rel_max_abs(P_quad, P_lin) # this is rather large but is due to points near 0 # for which we have rather small values (on the order of 1e-17) assert diff < 1 model = GammaExpParametrization() params = GammaExpParametrization.x0 | {'h': 0.5} sfs_quad = d_quad.model_selection_sfs(model, params) sfs_mid = d_midpoint.model_selection_sfs(model, params) diff = self.diff_rel_max_abs(sfs_quad, sfs_mid) assert diff < 5e-3 def test_sfs_counts_linearized_vs_quad(self): """""" Compare precomputed linearization using scipy's quad with ad hoc integration. """""" model = GammaExpParametrization() params = GammaExpParametrization.x0 | {'h': 0.5} opts = dict( n=self.n, integration_mode='quad', intervals_ben=(1.0e-5, 100, 100), intervals_del=(-5000, -1.0e-5, 100) ) sfs_adhoc = Discretization(**opts, linearized=False).model_selection_sfs(model, params) sfs_cached = Discretization(**opts, linearized=True).model_selection_sfs(model, params) diff = np.max(np.abs((sfs_cached - sfs_adhoc) / sfs_cached)) assert diff < 4e-3 @pytest.mark.skip(reason=""np.float128 not available on osx-arm64"") def test_compare_H_with_regularized(self): """""" Compare H with its regularized equivalent that use the limit as S -> 0 for small S. Note, behaviour similar for other values of x. """""" s = np.logspace(np.log10(1e-20), np.log10(1e-10), 10000) fig, axs = plt.subplots(nrows=2) fig.tight_layout(pad=4) for ax in axs: ax.plot(np.abs(s), Discretization.get_counts_high_precision(0.95, s), label='H(s)') ax.plot(np.abs(s), Discretization.get_counts_high_precision_regularized(0.95, s), label='$H_{reg}(s)$') s = -s ax.set_xlabel('S' if s[0] > 0 else '-S') ax.set_ylabel('H') ax.set_xscale('log') ax.set_title('sojourn times') plt.legend() plt.show() def test_allele_counts_large_negative_S(self): """""" Plot divergence vs S. """""" d = Discretization( n=self.n, linearized=True ) S = np.linspace(-100, -10000, 100) k = np.arange(1, self.n) I = np.ones((S.shape[0], k.shape[0])) c1 = d.get_counts_semidominant_unregularized(S[:, None] * I, k[None, :] * I) c2 = d.get_counts_semidominant_large_negative_S(S[:, None] * I, k[None, :] * I) diff = self.diff_rel_max_abs(c1, c2) assert diff < 1e-15 def test_hyp1f1_mpmath_vs_scipy(self): """""" Compare mpmath and scipy's implementation of the confluent hypergeometric function. """""" s = np.linspace(-500, 500, 1000) k = np.arange(1, self.n) I = np.ones((s.shape[0], k.shape[0])) S = s[:, None] * I K = k[None, :] * I y_scipy = hyp1f1(K, self.n, S) y_mpmath = Discretization.hyp1f1(K, self.n, S) assert self.diff_rel_max_abs(y_scipy, y_mpmath) < 1e-11 def test_allele_counts_large_positive_S(self): """""" Plot divergence vs S. """""" d = Discretization( n=self.n, linearized=True ) S = np.linspace(900000, 1000000, 100) k = np.arange(1, self.n) I = np.ones((S.shape[0], k.shape[0])) c1 = d.get_counts_semidominant_unregularized(S[:, None] * I, k[None, :] * I) c2 = d.get_counts_semidominant_large_positive_S(S[:, None] * I, k[None, :] * I) diff = self.diff_rel_max_abs(c1, c2) # still relatively large, but we can now evaluate large S # using mpmath assert diff < 1e-4 def test_plot_allele_count_regularized(self): """""" Plot allele count for different values of k. """""" d = Discretization( n=self.n, intervals_ben=(1.0e-15, 100, 1000), intervals_del=(-1000000, -1.0e-15, 1000) ) fig, (ax1, ax2) = plt.subplots(nrows=2) fig.tight_layout(pad=4) for k in range(1, self.n): ax2.plot(np.arange(d.s[d.s != 0].shape[0]), d.get_counts_semidominant_unregularized(d.s[d.s != 0], k * np.ones_like(d.s[d.s != 0])), label=f""k = {k}"") ax1.set_title('default') for k in range(1, self.n): ax1.plot(np.arange(d.s.shape[0]), d.get_counts_semidominant_regularized(d.s, k * np.ones_like(d.s)), label=f""k = {k}"") ax1.set_title('regularized') plt.legend(prop=dict(size=5)) plt.show() def test_plot_H_fixed_with_regularized_negative(self): """""" Plot H_fixed with and without regularization for negative values of S. """""" d = Discretization( n=self.n, intervals_ben=(1.0e-15, 100, 0), intervals_del=(-1000000, -1.0e-15, 1000) ) plt.plot(np.arange(len(d.s)), d.get_counts_fixed_semidominant_regularized(d.s), alpha=0.5, label='regularized') plt.plot(np.arange(len(d.s)), d.get_counts_fixed_semidominant(d.s), alpha=0.5, label='normal') plt.legend() plt.show() def test_plot_H_fixed_with_regularized_positive(self): """""" Plot H_fixed with and without regularization for positive values of S. """""" d = Discretization( n=self.n, intervals_ben=(1.0e-15, 1, 1000), intervals_del=(-1000000, -1.0e-15, 0) ) plt.plot(np.arange(len(d.s)), d.get_counts_fixed_semidominant_regularized(d.s), alpha=0.5, label='positive regularized') plt.plot(np.arange(len(d.s)), d.get_counts_fixed_semidominant(d.s), alpha=0.5, label='positive normal') plt.legend() plt.show() def test_compare_with_semidominant(self): """""" Compare regularized allele counts with those obtained from H_h for semi-dominant case (h = 0.5). """""" m = 5 diff = np.zeros((3, m, 201)) for i, n in enumerate([6, 20, 100]): d = Discretization( n=n, intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1.0e+8, -1.0e-5, 100) ) for j, k in tqdm(enumerate(np.linspace(1, n - 1, m).astype(int)), total=m): ys1 = d._get_counts_dominant(n=d.n, k=k, S=d.s, h=0.5) ys2 = d.get_counts_semidominant_regularized(k=np.full_like(d.s, k), S=d.s) diff[i, j] = (np.abs(ys1 - ys2) / (ys2 + 1e-10)) diff_max = np.max(diff, axis=(1, 2)) diff_mean = np.mean(diff, axis=(1, 2)) self.assertLess(diff.mean(), 0.004) self.assertTrue((diff_max < np.array([0.02, 0.06, 0.3])).all()) pass def test_cache_fixed_h_not_semidominant(self): """""" Make sure that caching of dominance-specific allele counts invokes the correct methods. """""" d = Discretization( n=10, h=0.2, intervals_ben=(1e-5, 1e4, 100), intervals_del=(-1e8, -1e-5, 100), intervals_h=(0.0, 1.0, 5), parallelize=False ) with patch.object(d, ""get_counts_dominant"", wraps=d.get_counts_dominant) as spy: d.precompute() spy.assert_called() def test_cache_fixed_h_semidominant(self): """""" Make sure that caching of semidominant allele counts invokes the correct methods. """""" d = Discretization( n=10, h=0.5, intervals_ben=(1e-5, 1e4, 100), intervals_del=(-1e8, -1e-5, 100), intervals_h=(0.0, 1.0, 5), parallelize=False ) with patch.object(d, ""get_counts_semidominant"", wraps=d.get_counts_semidominant) as spy: d.precompute() spy.assert_called() def test_cache_dominance(self): """""" Test caching of dominance-specific allele counts. """""" d = Discretization( n=10, h=None, intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1.0e+8, -1.0e-5, 100), intervals_h=(0.0, 1.0, 5) ) d.precompute() np.testing.assert_array_equal(d.grid_h, [0.0, 0.25, 0.5, 0.75, 1.0]) T = d.get_counts_semidominant() T2 = d.get_counts(h=0.5) T3 = d.get_counts(h=0.5 - 1e-5) T4 = d.get_counts(h=0.5 + 1e-5) diff = (np.abs(T2 - T) / (T + 1e-10)) diff_max = np.max(diff) diff_mean = np.mean(diff) self.assertLess(diff_max, 0.03) self.assertLess(diff_mean, 1e-3) self.assertLess((np.abs(T2 - T3) / (T2 + 1e-10)).max(), 0.01) self.assertLess((np.abs(T2 - T4) / (T2 + 1e-10)).max(), 0.01) def test_plot_over_h(self): """""" Plot allele counts over h for different h callbacks. """""" for callback in [lambda k, S: np.full_like(S, k), lambda k, S: np.full_like(S, np.sqrt(k))]: d = Discretization( n=10, h=None, h_callback=callback, intervals_ben=(1, 1000, 5), intervals_del=(-1.0e+8, -1, 5), intervals_h=(0, 1, 10) ) hs = np.linspace(0, 1, 101) counts = np.array([d.get_counts(h=h) for h in hs]).transpose(1, 2, 0) fig, ax = plt.subplots( nrows=d.n // 3, ncols=3, figsize=(14, 10) ) ax = ax.flatten() for k in range(d.n - 1): for j in range(d.s.shape[0]): ax[k].plot(hs, counts[k, j], alpha=0.7, label=f""S={d.s[j]:.2f}"", linewidth=2) ax[k].set_ylabel(""SFS count"") ax[k].set_xlabel(""h"") ax[k].set_yscale(""log"") ax[k].set_title(f""k={k + 1}"") ax[0].legend(prop=dict(size=8)) fig.tight_layout() plt.show() def test_default_h_callback(self): """""" Make sure default results in single fixed h of 0.5. """""" d = Discretization( n=10, h_callback=lambda k, S: np.full_like(S, k), h=0.5, intervals_h=(0.0, 1.0, 6), intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1e8, -1.0e-5, 100) ) self.assertEqual(d.grid_h, None) def test_custom_h_fixed_callback_fixed_h(self): """""" Make sure passing fixed h callback and fixed h results in correct grid. """""" d = Discretization( n=10, h=0.5, h_callback=lambda k, S: np.full_like(S, k - 0.1), intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1e8, -1.0e-5, 100) ) self.assertEqual(d.grid_h, None) def test_custom_h_fixed_callback_variable_h(self): """""" Make sure fixed h callback with variable h results in default grid. """""" d = Discretization( n=10, h=None, h_callback=lambda k, S: np.full_like(S, k - 0.1), intervals_h=(0.0, 1.0, 6), intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1e8, -1.0e-5, 100), ) np.testing.assert_array_equal(d.grid_h, np.linspace(*d.intervals_h)) # test interpolation counts1 = d.get_counts(h=0.5) counts2 = d.get_counts(h=0.6) np.testing.assert_array_almost_equal((counts1 + counts2) / 2, d.get_counts(h=0.55)) def test_custom_h_variable_callback_fixed_h(self): """""" Make sure variable h callback with fixed h results in correct grid and interpolation. """""" d = Discretization( n=10, h=0.5, h_callback=lambda k, S: 0.4 * np.exp(-k * abs(S)), intervals_h=(0.0, 1.0, 6), intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1e8, -1.0e-5, 100) ) self.assertEqual(d.grid_h, None) def test_interpolation_weights_variable_h_fixed_callback(self): """""" Make sure variable h callback with fixed h results in correct grid and interpolation. """""" d = Discretization( n=10, h=None, h_callback=lambda k, S: 0.4 * np.exp(-k * abs(S)), intervals_h=(0.0, 1.0, 6), intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1e8, -1.0e-5, 100) ) np.testing.assert_array_equal(d.grid_h, np.linspace(*d.intervals_h)) i, w = d.get_interpolation_weights(h=0.5) hs = d.map_h(0.5, d.s) np.testing.assert_array_almost_equal(i + w, hs * 5 + 1) x = np.arange(len(d.s)) plt.plot(x, i + w, label='index + weight') plt.plot(x, w, label='weights') plt.plot(x, i, label='indices') plt.plot(x, hs, label='h callback') plt.title(""Interpolation indices + weights over S"") plt.xlabel(""S"") plt.ylabel(""Index + weight"") plt.legend() plt.show() pass def test_plot_custom_h_callback(self): """""" Plot allele counts over h for a custom h callback. """""" h = lambda k, S: 0.4 * np.exp(-k * abs(S)) plt_s = np.logspace(-5, 2, 100) plt_k = [0.1, 1, 10, 100] plt.figure(figsize=(10, 6)) for k in plt_k: hs = h(k, plt_s) plt.plot(plt_s, hs, label=f'k={k}') plt.xscale('log') plt.xlabel('S') plt.ylabel('h') plt.title('Custom h callback over S for different k') plt.legend() plt.show() def test_fixed_h_vs_interpolated_h(self): """""" Compare allele counts obtained using fixed h(S) vs interpolated h. """""" k = 1 d1 = Discretization( n=10, h=0.5, h_callback=lambda k, S: 0.4 * np.exp(-k * abs(S)), intervals_h=(0.0, 1.0, 6), intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1e8, -1.0e-5, 100) ) c1 = d1.get_counts(0.5) d2 = Discretization( n=10, h=None, h_callback=d1.h_callback, intervals_h=d1.intervals_h, intervals_ben=d1.intervals_ben, intervals_del=d1.intervals_del ) c2 = d2.get_counts(0.5) diff = self.diff_rel_max_abs(c1, c2) self.assertLess(diff, 0.03) def test_compare_fixed_counts_with_semidominant(self): """""" Compare Discretization.get_counts_fixed_dominant and Discretization.get_counts_fixed_regularized. """""" d = Discretization( n=10, h=None, intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1e8, -1.0e-5, 100) ) y1 = fd.discretization.Discretization.get_counts_fixed_dominant(d.s, 0.5) y2 = fd.discretization.Discretization.get_counts_fixed_semidominant_regularized(d.s) diff = np.abs(y1 - y2) / (y2 + 1e-10) self.assertLess(diff.max(), 0.001) def test_fixed_counts_varying_h(self): """""" Test Discretization.get_counts_fixed_dominant with varying h. """""" d = Discretization( n=10, h=None, intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1e8, -1.0e-5, 100), ) rng = np.random.default_rng(0) hs = rng.uniform(0, 1, size=d.s.shape[0]) y_var = fd.discretization.Discretization.get_counts_fixed_dominant(d.s, hs) # reference: two fixed extremes y_h0 = fd.discretization.Discretization.get_counts_fixed_dominant(d.s, 0.0) y_h1 = fd.discretization.Discretization.get_counts_fixed_dominant(d.s, 1.0) # bounds: per-s dominance interpolation assert np.all(y_var >= np.minimum(y_h0, y_h1)) assert np.all(y_var <= np.maximum(y_h0, y_h1)) x = np.arange(d.s.shape[0]) plt.plot(x, y_h0, label=""h=0"", alpha=0.7) plt.plot(x, y_h1, label=""h=1"", alpha=0.7) plt.scatter(x, y_var, c=hs, cmap=""viridis"", s=10, label=""varying h"") plt.yscale(""log"") plt.colorbar(label=""h"") plt.ylim(1e-4, 1e5) plt.legend() plt.show() def test_plot_counts_fixed(self): """""" Plot allele counts for fixed h. """""" d = Discretization( n=10, h=None, intervals_ben=(1.0e-5, 1.0e4, 100), intervals_del=(-1e8, -1.0e-5, 100), ) hs = np.round(np.linspace(0, 1, 6), 2) # cache all results at once counts = { h: fd.discretization.Discretization.get_counts_fixed_dominant(d.s, h) for h in hs } # make sure counts are larger for larger h on beneficial side and vice versa Y = np.stack([counts[h] for h in hs], axis=0) assert np.all(np.diff(Y[:, d.s > 0], axis=0) >= 0) assert np.all(np.diff(Y[:, d.s < 0], axis=0) <= 0) # plotting x = np.arange(len(d.s)) for h, y in counts.items(): plt.plot(x, y, label=f""h={h}"") plt.legend() plt.yscale(""log"") plt.ylim(1e-4, 1e5) plt.show() ","Python" "Allele","Sendrowski/fastDFE","testing/test_spectra.py",".py","27578","828","import dadi import numpy as np import pandas as pd from numpy import testing from fastdfe import spectrum, Spectra, Spectrum from testing import TestCase class SpectraTestCase(TestCase): """""" Test the Spectrum and Spectra classes. """""" n = 20 @staticmethod def test_multiply_by_scalar(): """""" Test that multiplying a spectra by a scalar works as expected. """""" s = Spectra(dict( all=np.arange(20), sub=np.arange(3, 23) )) * 4 testing.assert_array_equal(np.arange(20) * 4, s[['all']].to_list()[0]) testing.assert_array_equal(np.arange(3, 23) * 4, s[['sub']].to_list()[0]) @staticmethod def test_restore_from_list(): """""" Test that restoring a spectra from a list works as expected. """""" s = Spectra(dict( all=np.arange(20), sub=np.arange(3, 23) )) * 4 s2 = s.from_list(s.to_list(), s.types) testing.assert_array_equal(s.to_numpy(), s2.to_numpy()) @staticmethod def test_multiply_by_list(): """""" Test that multiplying a spectra by a list works as expected. """""" s = Spectra(dict( all=np.arange(20), sub=np.arange(3, 23) )) * [2, 4] testing.assert_array_equal(np.arange(20) * 2, s[['all']].to_list()[0]) testing.assert_array_equal(np.arange(3, 23) * 4, s[['sub']].to_list()[0]) def test_kingman_sfs(self): """""" Test that the kingman sfs is as expected. """""" np.testing.assert_array_equal( Spectrum.standard_kingman(10, n_monomorphic=100).data, [100, 1, 0.5, 1 / 3, 1 / 4, 1 / 5, 1 / 6, 1 / 7, 1 / 8, 1 / 9, 0] ) def test_create_from_spectrum_dict(self): """""" Test that creating a spectra from a dict of spectra works as expected. """""" s = Spectra.from_spectra(dict( all=spectrum.standard_kingman(self.n) * 4, sub=spectrum.standard_kingman(self.n) * 2 )) testing.assert_array_equal((spectrum.standard_kingman(self.n) * 4).to_list(), s['all'].to_list()) testing.assert_array_equal((spectrum.standard_kingman(self.n) * 2).to_list(), s['sub'].to_list()) def test_create_from_spectrum(self): """""" Test that creating a spectra from a single spectrum works as expected. """""" s = Spectra.from_spectrum(spectrum.standard_kingman(self.n)) testing.assert_array_equal(spectrum.standard_kingman(self.n).to_list(), s['all'].to_list()) testing.assert_equal(self.n, s.n) testing.assert_equal(1, s.k) def test_create_from_array_pass_targets_div(self): """""" Test that creating a spectra from an array works as expected. """""" data = spectrum.standard_kingman(self.n) data.data[-1] = 6543 s = Spectra.from_list([data.to_list()], types=['all']) testing.assert_array_equal(data.data, s['all'].data) testing.assert_equal(s.n, self.n) testing.assert_equal(1, s.k) def test_create_from_dataframe(self): """""" Test that creating a spectra from a dataframe works as expected. """""" df = pd.DataFrame(dict( all=(spectrum.standard_kingman(self.n) * 4).to_list(), sub=(spectrum.standard_kingman(self.n) * 2).to_list() )) s = Spectra.from_dataframe(df) pd.testing.assert_frame_equal(df, s.data) def test_spectra_restore_from_file(self): """""" Test that restoring a spectra from a file works as expected. """""" s = Spectra.from_spectra(dict( all=spectrum.standard_kingman(self.n) * 4, sub=spectrum.standard_kingman(self.n) * 2 )) out = ""scratch/test_spectra_restore_from_file.csv"" s.to_file(out) s2 = s.from_file(out) pd.testing.assert_frame_equal(s.data, s2.data) def test_spectrum_restore_from_file(self): """""" Test that restoring a spectrum from a file works as expected. """""" s = spectrum.standard_kingman(self.n) out = ""scratch/test_spectrum_restore_from_file.csv"" s.to_file(out) s2 = Spectrum.from_file(out) testing.assert_array_almost_equal(s.data, s2.data, decimal=15) def test_restore_from_dict(self): """""" Test that restoring a spectra from a dict works as expected. """""" s = Spectra.from_spectra(dict( all=spectrum.standard_kingman(self.n) * 4, sub=spectrum.standard_kingman(self.n) * 2 )) s2 = s.from_dict(s.to_dict()) pd.testing.assert_frame_equal(s.data, s2.data) def test_normalize(self): """""" Test that normalizing a spectra works as expected. """""" s = Spectra.from_spectra(dict( all=spectrum.standard_kingman(self.n), sub=spectrum.standard_kingman(self.n) )) * [2, 4] s = s.normalize() testing.assert_almost_equal(1, np.sum(s['all'].to_list()[:-1])) testing.assert_almost_equal(1, np.sum(s['sub'].to_list()[:-1])) def test_properties(self): """""" Test that the properties of a spectra work as expected. """""" s = Spectra.from_spectra(dict( all=spectrum.standard_kingman(self.n), sub=spectrum.standard_kingman(self.n) )) * [2, 4] testing.assert_equal(2, s.k) testing.assert_equal(self.n, s.n) testing.assert_array_equal(['all', 'sub'], s.types) def test_from_polydfe(self): """""" Test that the from_polydfe method works as expected. """""" data = np.arange(self.n) * 10 n_sites = 100000000 n_div = 12345 s = Spectrum.from_polydfe(data, n_sites=n_sites, n_div=n_div) testing.assert_equal(s.to_list()[0], n_sites - np.sum(data) - n_div) testing.assert_equal(s.n_monomorphic, n_sites - np.sum(data)) testing.assert_equal(s.n_polymorphic, np.sum(data)) testing.assert_equal(s.n_div, n_div) testing.assert_equal(s.n_sites, n_sites) @staticmethod def test_site_wise_wattersons_estimator_spectrum(): """""" Test that the wattersons_estimator method works as expected. """""" data = [3434, 6346, 234, 4342, 55, 525, 24, 56, 2, 42, 4] testing.assert_equal(Spectrum(data).theta, dadi.Spectrum(data).Watterson_theta() / sum(data)) @staticmethod def test_wattersons_estimator_spectrum(): """""" Test that the wattersons_estimator method works as expected. """""" data = [3434, 6346, 234, 4342, 55, 525, 24, 56, 2, 42, 4] testing.assert_equal(Spectrum(data).Theta, dadi.Spectrum(data).Watterson_theta()) @staticmethod def test_site_wise_wattersons_estimator_spectra(): """""" Test that the wattersons_estimator method works as expected. """""" data = { 'all': [3434, 6346, 234, 4342, 55, 525, 24, 56, 2, 42, 4], 'sub': [1234, 2345, 234, 1234, 55, 525, 24, 56, 2, 42, 4] } s = Spectra.from_dict(data) testing.assert_equal(s.theta.to_list(), [ dadi.Spectrum(data['all']).Watterson_theta() / sum(data['all']), dadi.Spectrum(data['sub']).Watterson_theta() / sum(data['sub']) ]) @staticmethod def test_wattersons_estimator_spectra(): """""" Test that the wattersons_estimator method works as expected. """""" data = { 'all': [3434, 6346, 234, 4342, 55, 525, 24, 56, 2, 42, 4], 'sub': [1234, 2345, 234, 1234, 55, 525, 24, 56, 2, 42, 4] } s = Spectra.from_dict(data) testing.assert_equal(s.Theta.to_list(), [ dadi.Spectrum(data['all']).Watterson_theta(), dadi.Spectrum(data['sub']).Watterson_theta() ]) def test_plot_spectrum(self): """""" Test that the plot_spectrum method works as expected. """""" (spectrum.standard_kingman(self.n) * 4).plot() def test_plot_spectrum_log_scale(self): """""" Test that the plot_spectrum method works as expected when using a log scale. """""" (spectrum.standard_kingman(self.n) * 4).plot(log_scale=True) def test_plot_spectra(self): """""" Test that the plot_spectra method works as expected. """""" Spectra.from_spectra(dict( all=spectrum.standard_kingman(self.n) * 4, sub=spectrum.standard_kingman(self.n) * 2 )).plot() def test_plot_spectra_log_scale(self): """""" Test that the plot_spectra method works as expected when using a log scale. """""" Spectra.from_spectra(dict( all=spectrum.standard_kingman(self.n) * 4, sub=spectrum.standard_kingman(self.n) * 2 )).plot(log_scale=True) def test_plot_spectra_use_subplots(self): """""" Test that the plot_spectra method works as expected. """""" Spectra.from_spectra(dict( all=spectrum.standard_kingman(self.n) * 4, sub=spectrum.standard_kingman(self.n) * 2 )).plot(use_subplots=True) def test_plot_spectra_use_subplots_log_scale(self): """""" Test that the plot_spectra method works as expected when using a log scale. """""" Spectra.from_spectra(dict( all=spectrum.standard_kingman(self.n) * 4, sub=spectrum.standard_kingman(self.n) * 2 )).plot(use_subplots=True, log_scale=True) def test_select_wildcard(self): """""" Test that the select method works as expected. """""" s = Spectra.from_spectra(dict( all=spectrum.standard_kingman(self.n), all2=spectrum.standard_kingman(self.n), sub=spectrum.standard_kingman(self.n) )) assert len(s['all.*']) == 2 assert isinstance(s['sub.*'], Spectrum) assert isinstance(s[['sub.*']], Spectra) def test_select_no_regex(self): """""" Test that the select method works as expected when not using regex. """""" s = Spectra.from_spectra(dict( all=spectrum.standard_kingman(self.n), all2=spectrum.standard_kingman(self.n), sub=spectrum.standard_kingman(self.n) )) assert isinstance(s.__getitem__('all', use_regex=False), Spectrum) assert isinstance(s.__getitem__(['sub', 'all'], use_regex=False), Spectra) assert len(s.__getitem__(['sub', 'all'], use_regex=False)) == 2 assert isinstance(s.__getitem__(['sub'], use_regex=False), Spectra) assert len(s.__getitem__(['sub'], use_regex=False)) == 1 @staticmethod def test_merge_level(): """""" Test that the merge_level method works as expected. """""" s = Spectra.from_spectra({ 'bla.foo.bar': Spectrum([1000, 3, 4, 1]), 'test1.te.x': Spectrum([100, 4, 7, 6]), 'test2.te.x': Spectrum([55, 2, 1, 7]), }).merge_groups([1, 2]) expected = Spectra.from_spectra({ 'foo.bar': Spectrum([1000, 3, 4, 1]), 'te.x': Spectrum([155, 6, 8, 13]), }) pd.testing.assert_frame_equal(s.data, expected.data) @staticmethod def test_add_spectra(): """""" Test that the add_spectra method works as expected. """""" s = Spectra.from_spectra({ 'bla.foo.bar': Spectrum([1000, 3, 4, 1]), 'test1.te.x': Spectrum([100, 4, 7, 6]), 'test2.foo.x': Spectrum([55, 2, 1, 7]), }) + Spectra.from_spectra({ 'bla.foo.bar': Spectrum([543, 7, 1, 2]), 'test1.te.x': Spectrum([200, 4, 10, 6]), 'test2.test2.x': Spectrum([55, 2, 1, 7]), }) expected = Spectra.from_spectra({ 'bla.foo.bar': Spectrum([1543, 10, 5, 3]), 'test1.te.x': Spectrum([300, 8, 17, 12]), 'test2.foo.x': Spectrum([55, 2, 1, 7]), 'test2.test2.x': Spectrum([55, 2, 1, 7]), }) pd.testing.assert_frame_equal(s.data, expected.data) @staticmethod def test_rename_spectra(): """""" Test that the rename_spectra method works as expected. """""" # create spectra with two subtypes and two types spectra = Spectra.from_spectra({ ""subtype1.type1"": Spectrum.standard_kingman(10) * 1, ""subtype1.type2"": Spectrum.standard_kingman(10) * 2, ""subtype2.type1"": Spectrum.standard_kingman(10) * 3, }) spectra = spectra.prefix(""subsub"") assert spectra.types == [""subsub.subtype1.type1"", ""subsub.subtype1.type2"", ""subsub.subtype2.type1""] @staticmethod def test_fold_spectrum(): """""" Test that the folding of spectra works as expected """""" spectra = [ [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9], [2, 1, 4, 4, 325, 5, 213, 515] ] for s in spectra: np.testing.assert_array_equal(Spectrum(s).fold().data, dadi.Spectrum(s).fold().data) def test_spectrum_is_folded(self): """""" Test that the is_folded property works as expected """""" data = [ dict(s=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], folded=False), dict(s=[1, 1, 0, 0], folded=True), dict(s=[1, 1, 5, 0, 0], folded=True), dict(s=[0, 0, 0, 0, 1], folded=False), ] for d in data: self.assertEqual(Spectrum(d['s']).is_folded(), d['folded']) @staticmethod def test_folding_folded_spectrum_has_no_effect(): """""" Test that folding a folded spectrum has no effect """""" data = [ [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 1, 0, 0], [1, 1, 5, 0, 0], [0, 0, 0, 0, 1], ] for s in data: np.testing.assert_array_equal(Spectrum(s).fold().fold().data, Spectrum(s).fold().data) @staticmethod def test_fold_spectra(): """""" Test that the folding of spectra works as expected """""" s = Spectra.from_spectra(dict( type1=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), type2=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 65]) )) s_folded = s.fold() for t in s.types: np.testing.assert_array_equal(s[t].fold().data, s_folded[t].data) assert not np.array(list(s.is_folded().values())).all() assert np.array(list(s_folded.is_folded().values())).all() @staticmethod def test_has_dots(): """""" Test that the has_dots() method works as expected """""" assert Spectra.from_spectra(dict( type1=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), type2=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 65]) )).has_dots() is False assert Spectra.from_spectra({ 'test.foo': Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) }).has_dots() is True @staticmethod def test_replace_dots(): """""" Test that the replace_dots() method works as expected """""" s = Spectra.from_spectra({ 'test.foo': Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) }).replace_dots() assert s.has_dots() is False assert s.types == ['test_foo'] @staticmethod def test_drop_empty(): """""" Test that the drop_empty() method works as expected """""" assert Spectra.from_spectra(dict( type1=Spectrum([1, 0, 0, 0, 0, 0, 0, 0, 0, 10]), type2=Spectrum([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), type3=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 65]), )).drop_empty().types == ['type1', 'type3'] @staticmethod def test_drop_zero_entries(): """""" Test that the drop_zero_entries() method works as expected """""" assert Spectra.from_spectra(dict( type1=Spectrum([1, 0, 0, 0, 0, 0, 0, 0, 0, 10]), type2=Spectrum([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), type3=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 65]), type4=Spectrum([1, 2, 0, 4, 5, 6, 7, 8, 9, 65]), )).drop_zero_entries().types == ['type3'] @staticmethod def test_drop_sparse(): """""" Test that the drop_zero_entries() method works as expected """""" spectra = Spectra.from_spectra(dict( type1=Spectrum([1, 0, 0, 0, 0, 0, 0, 0, 0, 10]), type2=Spectrum([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), type3=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 65]), type4=Spectrum([1, 2, 0, 4, 5, 6, 7, 8, 9, 65]), )) assert spectra.drop_sparse(n_polymorphic=0).types == ['type3', 'type4'] assert spectra.drop_sparse(n_polymorphic=1).types == ['type3', 'type4'] assert spectra.drop_sparse(n_polymorphic=40).types == ['type3', 'type4'] assert spectra.drop_sparse(n_polymorphic=41).types == ['type3'] assert spectra.drop_sparse(n_polymorphic=44).types == [] @staticmethod def test_add_spectrum(): """""" Test whether two spectrum objects can be added. """""" testing.assert_array_equal((Spectrum([1, 2, 3]) + Spectrum([3, 4, 5])).data, Spectrum([4, 6, 8]).data) @staticmethod def test_subtract_spectrum(): """""" Test whether two spectrum objects can be subtracted. """""" testing.assert_array_equal((Spectrum([3, 4, 5]) - Spectrum([1, 2, 3])).data, [2, 2, 2]) @staticmethod def test_normalize_spectrum(): """""" Test whether two spectrum objects can be normalized. """""" testing.assert_array_equal(Spectrum([10, 1, 2, 3, 10]).normalize().data, [10, 1 / 6, 1 / 3, 1 / 2, 10]) @staticmethod def test_spectra_n_monomorphic(): """""" Test whether the n_monomorphic property works as expected. """""" spectra = Spectra.from_spectra(dict( type1=Spectrum([1, 0, 0, 0, 0, 0, 0, 0, 0, 10]), type2=Spectrum([1, 2, 0, 4, 5, 6, 7, 8, 9, 65]), )) assert np.all(spectra.n_monomorphic == pd.Series(dict(type1=11, type2=66))) def test_reorder_levels(self): """""" Test whether the reorder_levels method works as expected. """""" spectra = Spectra({ ""type1.subtype1.subsubtype1"": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ""type1.subtype1.subsubtype2"": [1, 4, 12, 4, 5, 6, 7, 8, 9, 10], ""type1.subtype2.subsubtype1"": [1, 7, 7, 4, 5, 6, 7, 8, 9, 10], ""type1.subtype2.subsubtype2"": [1, 8, 3, 4, 5, 6, 7, 8, 9, 10], ""type2.subtype1.subsubtype1"": [1, 0, 1, 4, 5, 6, 7, 8, 9, 10], ""type2.subtype1.subsubtype2"": [1, 6, 3, 4, 5, 6, 7, 8, 9, 10], }) spectra2 = spectra.reorder_levels([1, 0, 2]) self.assertEqual(spectra2.types, [ ""subtype1.type1.subsubtype1"", ""subtype1.type1.subsubtype2"", ""subtype2.type1.subsubtype1"", ""subtype2.type1.subsubtype2"", ""subtype1.type2.subsubtype1"", ""subtype1.type2.subsubtype2"", ]) testing.assert_array_equal(spectra2.to_list(), spectra.reorder_levels([1, 0, 2]).to_list()) testing.assert_array_equal( list(spectra2[""subtype1.type1.subsubtype1""]), list(spectra[""type1.subtype1.subsubtype1""]) ) def test_subsample_spectrum_random(self): """""" Test whether the subsample method works as expected. """""" kingman = Spectrum.standard_kingman(30) * 10000 sub = kingman.subsample(10, mode='random') s = Spectra.from_spectra(dict( actual=Spectrum.standard_kingman(10) * 10000, subsampled=sub )) s.plot() self.assertEqual(10, sub.n) diff_rel = np.abs(s['actual'].polymorphic - s['subsampled'].polymorphic) / s['actual'].polymorphic self.assertTrue(np.all(diff_rel < 0.1)) def test_subsample_folded_spectrum(self): """""" Test whether the subsample method works as expected. """""" kingman = (Spectrum.standard_kingman(30) * 10000).fold() sub = kingman.subsample(10, mode='probabilistic') truth = (Spectrum.standard_kingman(10) * 10000).fold() self.assertTrue(np.all(np.abs(truth.data[1:] - sub.data[1:]) < 1e-12)) def test_subsample_spectrum_probabilistic_vs_random_folded(self): """""" Test random vs probabilistic subsampling. """""" kingman = (Spectrum.standard_kingman(30) * 10000).fold() sub_random = kingman.subsample(10, mode='random') sub_probabilistic = kingman.subsample(10, mode='probabilistic') s = Spectra.from_spectra(dict( actual=(Spectrum.standard_kingman(10) * 10000).fold(), random=sub_random, probabilistic=sub_probabilistic )) s.plot() diff_rel = np.abs(s['actual'].polymorphic - s['probabilistic'].polymorphic) / s['probabilistic'].polymorphic self.assertTrue(np.all(diff_rel[:5] < 1e-15)) def test_subsample_spectrum_probabilistic_vs_random_unfolded(self): """""" Test random vs probabilistic subsampling. """""" kingman = Spectrum.standard_kingman(30) * 10000 sub_random = kingman.subsample(10, mode='random') sub_probabilistic = kingman.subsample(10, mode='probabilistic') s = Spectra.from_spectra(dict( actual=Spectrum.standard_kingman(10) * 10000, random=sub_random, probabilistic=sub_probabilistic )) s.plot() diff_rel = np.abs(s['actual'].polymorphic - s['probabilistic'].polymorphic) / s['probabilistic'].polymorphic self.assertTrue(np.all(diff_rel < 1e-15)) def test_larger_subsample_size_raises_value_error(self): """""" Test whether the subsample method raises a ValueError when the requested subsample size is larger than the original sample size. """""" self.assertRaises(ValueError, Spectrum.standard_kingman(30).subsample, 40) @staticmethod def test_subsample_spectra(): """""" Test whether the subsample method works as expected. """""" spectra = Spectra({ ""type1.subtype1.subsubtype1"": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ""type1.subtype1.subsubtype2"": [1, 4, 12, 4, 5, 6, 7, 8, 9, 10], }) spectra.subsample(7, mode='random').plot() # make sure n_sites is the same testing.assert_array_equal(spectra.subsample(7).n_sites, spectra.n_sites) def test_has_divergence(self): """""" Test whether the has_divergence method works as expected. """""" s1 = Spectrum([1, 2, 3, 0]) s2 = Spectrum([1, 2, 3, 4]) self.assertFalse(s1.has_div) self.assertTrue(s2.has_div) self.assertTrue(Spectra.from_spectra({ ""type1"": s1, ""type2"": s2 }).has_div.any()) self.assertFalse(Spectra.from_spectra({ ""type1"": s1, ""type2"": s1 }).has_div.all()) @staticmethod def test_copy_spectrum(): """""" Test whether the copy method works as expected. """""" s = Spectrum([1, 2, 3, 4, 5]) s2 = s.copy() testing.assert_array_equal(s.data, s2.data) @staticmethod def test_spectrum_power(): """""" Test whether the power method works as expected. """""" s = Spectrum([1, 2, 3, 4, 5]) testing.assert_array_equal((s ** 2).data, [1, 4, 9, 16, 25]) @staticmethod def test_spectrum_divide(): """""" Test whether the divide method works as expected. """""" s = Spectrum([1, 2, 3, 4, 5]) testing.assert_array_equal((s / 2).data, [0.5, 1, 1.5, 2, 2.5]) @staticmethod def test_spectrum_floor_divide(): """""" Test whether the floor divide method works as expected. """""" s = Spectrum([1, 2, 3, 4, 5]) testing.assert_array_equal((s // 2).data, [0, 1, 1, 2, 2]) @staticmethod def test_spectra_to_dataframe(): """""" Test whether the to_dataframe method works as expected. """""" s = Spectra.from_spectra(dict( all=spectrum.standard_kingman(10), sub=spectrum.standard_kingman(10) * 2 )) df = s.to_dataframe() pd.testing.assert_frame_equal(df, s.data) def test_spectra_floor_divide(self): """""" Test whether the floor divide method works as expected. """""" s = Spectra.from_spectra(dict( all=spectrum.standard_kingman(10), sub=spectrum.standard_kingman(10) * 2 )) s2 = s // 2 testing.assert_array_equal(s2['all'].data, s['all'].data // 2) testing.assert_array_equal(s2['sub'].data, s['sub'].data // 2) def test_misidentify_value_error(self): """""" Test whether the misidentify method raises a ValueError when the rate is not between 0 and 1. """""" sfs = Spectrum([0, 1, 2]) with self.assertRaises(ValueError): sfs.misidentify(-0.1) with self.assertRaises(ValueError): sfs.misidentify(1.5) def test_misidentify_expected_sfs_even_n(self): """""" Test whether the misidentify method works as expected for even n. """""" sfs = Spectrum([177595, 922, 363, 210, 164, 162, 712]) np.testing.assert_array_equal( sfs.misidentify(0.1).data, [177595, 922 * 0.9 + 162 * 0.1, 363 * 0.9 + 164 * 0.1, 210, 164 * 0.9 + 363 * 0.1, 162 * 0.9 + 922 * 0.1, 712] ) def test_misidentify_expected_sfs_odd_n(self): """""" Test whether the misidentify method works as expected for odd n. """""" sfs = Spectrum([177749, 889, 347, 214, 189, 739]) np.testing.assert_array_equal( sfs.misidentify(0.1).data, [177749, 889 * 0.9 + 189 * 0.1, 347 * 0.9 + 214 * 0.1, 214 * 0.9 + 347 * 0.1, 189 * 0.9 + 889 * 0.1, 739] ) def test_misidentify_epislon_0(self): """""" Test whether the misidentify method works as expected for epsilon = 0. """""" sfs = Spectrum([177595, 922, 363, 210, 164, 162, 712]) np.testing.assert_array_equal( sfs.misidentify(0).data, sfs.data ) def test_misidentify_epislon_1(self): """""" Test whether the misidentify method works as expected for epsilon = 1. """""" sfs = Spectrum([177595, 922, 363, 210, 164, 162, 712]) np.testing.assert_array_equal( sfs.misidentify(1).data, [sfs.data[0]] + sfs.data[1:sfs.n][::-1].tolist() + [sfs.data[-1]] ) def test_resample_spectrum(self): """""" Test whether the Poisson resample method works as expected. """""" sfs = Spectrum.standard_kingman(10, n_monomorphic=3 * 10 ** 6) * 1000 resampled = np.array([sfs.resample().data for _ in range(1000)]) mean = resampled.mean(axis=0) var = resampled.var(axis=0) self.assertLess(self.rel_diff(sfs.data, mean).max(), 5e-3) rel_var_diff = np.abs(var - mean) / mean self.assertLess(rel_var_diff[1:-1].max(), 0.2) ","Python" "Allele","Sendrowski/fastDFE","testing/test_config.py",".py","5977","167","import numpy as np from numpy import testing from fastdfe import Config, BaseInference, SharedParams from fastdfe.optimization import Covariate from testing import TestCase class ConfigTestCase(TestCase): """""" Test the Config class. """""" maxDiff = None config_file = ""testing/cache/configs/pendula_C_full_anc/config.yaml"" init_file = ""resources/polydfe/init/C.full_anc_init"" spectra_file = ""resources/polydfe/pendula/spectra/sfs.txt"" def assert_config_equal(self, observed: Config, expected: Config, exclude: list = []): """""" Assert that the two given configs are equal. :param observed: Observed config :param expected: Expected config :param exclude: Keys to exclude from comparison """""" d1 = dict((k, v) for k, v in observed.data.items() if k not in exclude) d2 = dict((k, v) for k, v in expected.data.items() if k not in exclude) self.assertDictEqual(d1, d2) def test_parse_restore_polydfe_sfs_config(self): """""" Test whether the sfs config can be properly restored from file. """""" out_file = ""scratch/parse_restore_polydfe_sfs_config.txt"" # create config from sfs file config = Config(polydfe_spectra_config=self.spectra_file) # recreate sfs config file config.create_polydfe_sfs_config(out_file) # compare both files # there were some rounding errors causing the last character to be different testing.assert_equal(open(out_file).read()[:-1], open(out_file).read()[:-1]) def test_parse_restore_polydfe_init_file(self): """""" Check whether the init file can properly be stored from file. Note that the init file will be different from the original polyDFE init file as not all information is stored. """""" out_file = ""scratch/parse_restore_polydfe_init_file.txt"" # parse and recreate init file config = Config(polydfe_init_file=self.init_file) config.create_polydfe_init_file(out_file, 20) # create config from newly created init file config2 = Config(polydfe_init_file=out_file) self.assert_config_equal(config, config2) def test_restore_config_from_file(self): """""" Check whether the config can be properly restored from file. """""" # load config from sfs and init file config = Config( polydfe_spectra_config=self.spectra_file, polydfe_init_file=self.init_file ) file = 'scratch/restore_config_from_file1.json' file2 = 'scratch/restore_config_from_file2.json' # save config and restore from file config.to_file(file) config2 = config.from_file(file) config2.to_file(file2) # compare original and restored config testing.assert_equal(open(file).read(), open(file2).read()) # compare original json representation and restored json representation testing.assert_equal(config.to_json(), Config.from_json(config.to_json()).to_json()) # compare original json representation and restored json representation testing.assert_equal(config.to_yaml(), Config.from_yaml(config.to_yaml()).to_yaml()) def test_recreate_config_from_inference(self): """""" Load config from file, create inference object and recreate config from inference object. """""" config = Config.from_file(self.config_file) config2 = BaseInference.from_config(config).create_config() # 'bounds' and 'opts_mle' will be different # because of the default specific to Inference. self.assert_config_equal(config, config2, ['bounds', 'scales', 'opts_mle', 'sfs_neut', 'sfs_sel', 'x0']) def test_restore_shared_params(self): """""" Test whether shared params can be properly restored from file. """""" config = Config(shared_params=[ SharedParams(params=['p_b', 'S_b'], types=['pendula', 'pubescens']), SharedParams(params=['eps'], types=['example_1', 'example_2', 'pubescens']), SharedParams(params=['b', 'S_d'], types=['example_1', 'example_2', 'example_3']) ]) out = ""scratch/test_restore_shared_params.yaml"" config.to_file(out) config2 = Config.from_file(out) self.assert_config_equal(config, config2) def test_restore_covariates(self): """""" Test whether covariates can be properly restored from file. """""" config = Config(covariates=[ Covariate(param='S_d', values=dict(t1=1, t2=2)), Covariate(param='xx', values=dict(bar=34)) ]) out = ""scratch/test_restore_shared_params.yaml"" config.to_file(out) config2 = Config.from_file(out) self.assert_config_equal(config, config2) @staticmethod def test_download_config(): """""" Test whether the config can be properly downloaded from a URL. """""" config = Config.from_file( ""https://github.com/Sendrowski/fastDFE/blob/master/"" ""resources/configs/shared/pendula_tutorial/config.yaml?raw=true"" ) np.testing.assert_equal( config.data['sfs_neut'].data['all'].to_numpy(), np.array([173705, 3294, 1115, 534, 326, 239, 225, 214, 231, 176, 73]) ) @staticmethod def test_download_config_no_cache(): """""" Test whether the config can be properly downloaded from a URL without caching. """""" config = Config.from_file( ""https://github.com/Sendrowski/fastDFE/blob/master/"" ""resources/configs/shared/pendula_tutorial/config.yaml?raw=true"", cache=False ) np.testing.assert_equal( config.data['sfs_neut'].data['all'].to_numpy(), np.array([173705, 3294, 1115, 534, 326, 239, 225, 214, 231, 176, 73]) ) ","Python" "Allele","Sendrowski/fastDFE","testing/test_polydfe_wrapper.py",".py","2210","78","import os import pytest from fastdfe.polydfe import PolyDFEResult, PolyDFE from testing import TestCase class PolyDFEWrapperTestCase(TestCase): """""" Test polyDFE wrapper. """""" polydfe_bin = 'resources/polydfe/bin/polyDFE-2.0-macOS-64-bit' postprocessing_source = 'resources/polydfe/postprocessing/script.R' config = ""testing/cache/configs/pendula_C_full_anc/config.yaml"" serialized = ""testing/cache/polydfe/pendula_C_full_anc/serialized.json"" def test_run_polydfe_from_config(self): """""" Run polyDFE from config. """""" # run polyDFE polydfe = PolyDFE.from_config_file(self.config) polydfe.run( output_file=f""scratch/test_run_polydfe_from_config.txt"", binary=self.polydfe_bin, postprocessing_source=self.postprocessing_source ) polydfe.to_file(""scratch/test_run_polydfe_from_config.json"") def test_restore_serialized_wrapper(self): """""" Serialize polyDFE wrapper and restore. """""" # run polyDFE polydfe = PolyDFE.from_config_file(self.config) polydfe.run( output_file=""scratch/test_restore_serialized_wrapper.json"", binary=self.polydfe_bin, postprocessing_source=self.postprocessing_source ) # serialize and restore from JSON polydfe_restored = polydfe.from_json(polydfe.to_json()) # compare JSON representation self.assertEqual(polydfe.to_json(), polydfe_restored.to_json()) @pytest.mark.slow def test_run_bootstrap_sample(self): """""" Serialize polyDFE wrapper and restore. """""" # run polyDFE polydfe = PolyDFE.from_file(self.serialized) config = polydfe.create_bootstrap() bootstrap = PolyDFE(config) bootstrap.run( output_file=""scratch/test_run_bootstrap_sample.json"", binary=self.polydfe_bin, postprocessing_source=self.postprocessing_source ) def test_visualize_inference(self): """""" Plot everything possible. """""" polydfe = PolyDFE.from_file(self.serialized) polydfe.plot_all() ","Python" "Allele","Sendrowski/fastDFE","testing/conftest.py",".py","44","1","collect_ignore = [""test_polydfe_wrapper.py""]","Python" "Allele","Sendrowski/fastDFE","testing/test_likelihood.py",".py","1874","51","import numpy as np from scipy.special import factorial from fastdfe.likelihood import Likelihood from testing import TestCase class LikelihoodTestCase(TestCase): """""" Test the Likelihood class. """""" def test_stirling_approximation(self): """""" Compare Stirling approximation of the factorial with its expected value. Note that we can only do this for moderately low exponents due to overflow. """""" x = np.arange(100, 150) expected = np.log(factorial(x)) observed = Likelihood.log_factorial_stirling(x) self.assertTrue(np.linalg.norm(expected - observed, ord=1) > 1e-05) def test_log_poisson(self): """""" Test the log poisson function. """""" comparisons = [ dict(mu=1, k=1, places=50), dict(mu=1, k=2, places=50), dict(mu=11, k=32, places=12), # Likelihood.poisson becomes imprecise dict(mu=0, k=0, places=45), # yields log likelihood very close to zero for approximation dict(mu=0, k=1, places=50), # yields very low log likelihood dict(mu=1, k=0, places=50), # yields log likelihood of -1 ] for comp in comparisons: expected = np.log(Likelihood.poisson(mu=np.array([comp['mu']]), k=np.array([comp['k']])))[0] observed = Likelihood.log_poisson(mu=np.array([comp['mu']]), k=np.array([comp['k']]))[0] self.assertAlmostEqual(expected, observed, places=comp['places']) def test_log_poisson_zero_entries(self): """""" Make sure the log poisson function does not return inf or nan values. """""" res = Likelihood.log_poisson(mu=np.array([1, 0, 0]), k=np.array([0, 1, 0])) # check that there are no inf or nan values assert ((res == np.inf) | (np.isnan(res)) | (res == -np.inf)).sum() == 0 ","Python" "Allele","Sendrowski/fastDFE","R/fastdfe.R",".R","19263","557","if (getRversion() >= ""2.15.1"") utils::globalVariables(c("".data"")) # vector of required packages required_packages <- c(""reticulate"", ""ggplot2"", ""cowplot"", ""pheatmap"", ""RColorBrewer"", ""scales"") # install required R packages for(package in required_packages){ if(!package %in% installed.packages()[,""Package""]){ install.packages(package) } } #' Check if the `fastdfe` Python module is installed #' #' This function uses the reticulate package to verify if the `fastdfe` Python #' module is currently installed. #' #' @return Logical `TRUE` if the `fastdfe` Python module is installed, otherwise `FALSE`. #' #' @examples #' \dontrun{ #' is_installed() # Returns TRUE or FALSE based on the installation status of fastdfe #' } #' #' @export fastdfe_is_installed <- function() { # Check if fastdfe is installed installed <- reticulate::py_module_available(""fastdfe"") return(installed) } #' Install the `fastdfe` Python module #' #' This function checks if the `fastdfe` Python module is available. #' If not, or if the `force` argument is TRUE, it installs it via pip. #' If the `silent` argument is set to TRUE, the function will not output a #' message when the module is already installed. #' #' @param version A character string specifying the version of the `fastdfe` module #' to install. Default is `NULL` which will install the latest version. #' @param force Logical, if `TRUE` it will force the reinstallation of the `fastdfe` module #' even if it's already available. Default is `FALSE`. #' @param silent Logical, if `TRUE` it will suppress the message about `fastdfe` being #' already installed. Default is `FALSE`. #' #' @return Invisible `NULL`. #' #' @examples #' \dontrun{ #' install_fastdfe() # Installs the latest version of fastdfe #' install_fastdfe(""1.2.1"") # Installs version 1.2.1 of fastdfe #' install_fastdfe(force = TRUE) # Reinstalls the fastdfe module #' } #' #' @export install_fastdfe <- function(version = NULL, force = FALSE, silent = FALSE, python_version = '3.11') { # Create the package string with the version if specified package_name <- ""fastdfe"" if (!is.null(version)) { package_name <- paste0(package_name, ""=="", version) } # Check if fastdfe is installed or if force is TRUE if (force || !fastdfe_is_installed()) { reticulate::py_install( package_name, method = ""conda"", pip = TRUE, python_version = python_version, version = version, ignore_installed = TRUE ) } else { if (!silent) { message(""The 'fastdfe' Python module is already installed."") } } invisible(NULL) } #' Load the fastdfe library and associated visualization functions #' #' This function imports the Python package 'fastdfe' using the reticulate package #' and then configures it to work seamlessly with R, overriding some of the default #' visualization functions with custom R-based ones. This function also ensures #' that required R libraries are loaded for visualization. #' #' @param install A logical. If TRUE, the function will attempt to run install_fastdfe(). #' #' @return A reference to the 'fastdfe' Python library loaded through reticulate. #' This reference can be used to access 'fastdfe' functionalities. #' #' @examples #' \dontrun{ #' load_fastdfe(install = TRUE) #' # now you can use fastdfe functionalities as per its API #' } #' #' @seealso \link[reticulate]{import} for importing Python modules in R. #' #' @importFrom grDevices colorRampPalette dev.off pdf #' @export load_fastdfe <- function(install = FALSE) { # install if install flag is true if (install) { install_fastdfe(silent = TRUE) } # configure plot options(repr.plot.width = 4.6, repr.plot.height = 3.2) fd <- reticulate::import(""fastdfe"") # override python visualization functions viz <- fd$visualization$Visualization # # Plot discretized DFEs using a bar plot # # @param values List or numeric vector. Array of values of # size `length(intervals) - 1`, containing the # discretized DFE for each type. # @param errors List or numeric vector. Array of errors of # size `length(intervals) - 1`, containing the # discretized DFE for each type. Default is `NULL`. # @param labels List or character vector. Labels for the different types # of DFEs. Default is `NULL`. # @param file Character. File path to save plot to. Default is `NULL`. # @param show Logical. Whether to show plot. Default is `TRUE`. # @param intervals Numeric vector. Array of interval boundaries yielding # `length(intervals) - 1` bars. Default # is `c(-Inf, -100, -10, -1, 0, 1, Inf)`. # @param title Character. Title of the plot. Default is 'discretized DFE'. # @param interval_labels List of character. Labels for the intervals, # which are the same for all types. Default is `NULL`. # @param ... Additional arguments which are ignored # # @return A ggplot object. viz$plot_discretized <- function( values, errors = NULL, labels = NULL, file = NULL, show = TRUE, intervals = c(-Inf, -100, -10, -1, 0, 1, Inf), title = 'discretized DFE', interval_labels = NULL, ... ) { # number of intervals and DFEs n_intervals <- length(intervals) - 1 n_dfes <- length(values) # create data frame with x and y values df <- data.frame(x = rep(1:n_intervals, n_dfes), y = unlist(values)) # if labels provided, add as factor to data frame if (is.null(labels)) { labels <- as.character(1:n_dfes) } df$group <- factor( rep(labels, each = n_intervals), levels = labels ) # if errors provided, calculate ymin and ymax if (!is.null(errors)) { has_err <- vapply(errors, function(e) !is.null(e), logical(1)) if (any(has_err)) { df$ymin <- unlist(lapply(seq_len(n_dfes), function(i) if (has_err[i]) values[[i]] - errors[[i]][1, ] else rep(NA_real_, n_intervals) )) df$ymax <- unlist(lapply(seq_len(n_dfes), function(i) if (has_err[i]) values[[i]] + errors[[i]][2, ] else rep(NA_real_, n_intervals) )) } } # create labels for x-axis if (is.null(interval_labels)) { xlabels <- c() for (i in 2:length(intervals)) { xlabels <- c(xlabels, viz$interval_to_string(intervals[i - 1], intervals[i])) } } else { xlabels <- interval_labels } # base plot with bars p <- ggplot2::ggplot(df, ggplot2::aes(x = factor(.data$x), y = .data$y)) + ggplot2::geom_bar(stat = ""identity"", position = ggplot2::position_dodge(), show.legend = n_dfes > 1) + ggplot2::scale_x_discrete(labels = xlabels, expand = ggplot2::expansion(mult = c(0, 0))) + ggplot2::scale_y_continuous(expand = ggplot2::expansion(mult = c(0, 0.05))) + ggplot2::labs(x = ""S"", y = ""fraction"", title = title) + ggplot2::theme_bw() + ggplot2::theme(panel.grid.major = ggplot2::element_blank(), panel.grid.minor = ggplot2::element_blank()) # add group aesthetic if 'group' column present if ('group' %in% colnames(df)) p <- p + ggplot2::aes(fill = .data$group) # add error bars if 'ymin' and 'ymax' columns present if (all(c('ymin', 'ymax') %in% colnames(df))) { p <- p + ggplot2::geom_errorbar(ggplot2::aes(ymin = .data$ymin, ymax = .data$ymax), width = 0.2, position = ggplot2::position_dodge(0.9)) } # add legend on the right if labels were provided if (!is.null(labels)) p <- p + ggplot2::theme(legend.position = ""right"") # display plot if 'show' is TRUE if (show) print(p) # save plot to file if 'file' is provided if (!is.null(file)) ggplot2::ggsave(file, plot = p) return(p) } # Visualize the inferred parameters and their confidence intervals # using a bar plot. Note that there problems with parameters that span 0 (which is usually not the case). # # @param values List of numeric vectors. Dictionary of parameter values with the parameter in the same order as `labels`. # @param labels List or character vector. Unique labels for the DFEs. # @param param_names List or character vector. Labels for the parameters. # @param errors List of numeric vectors. Dictionary of errors with the parameter in the same order as `labels`. # @param file Character. File path to save plot to. Default is `NULL`. # @param show Logical. Whether to show plot. Default is `TRUE`. # @param title Character. Title of the plot. Default is 'parameter estimates'. # @param legend Logical. Whether to show the legend. Default is `TRUE`. # @param scale Character. Whether to use a linear or log scale. Default is 'log'. # @param ... Additional arguments which are ignored # # @return A ggplot object. viz$plot_inferred_parameters <- function( values, labels, param_names, errors = NULL, file = NULL, show = TRUE, title = 'parameter estimates', legend = TRUE, scale = 'log', ... ) { # number of types and parameters n_types <- length(values) n_params <- length(param_names) # create data frame with x, y values and track the negative values negative_flags <- unlist(lapply(values, function(x) sapply(x, function(y) ifelse(y < 0, TRUE, FALSE)))) df <- data.frame(x = rep(1:n_params, n_types), y = unlist(lapply(values, function(x) sapply(x, abs)))) # Adjust the parameter names based on negative flags updated_param_names <- param_names for (i in 1:length(negative_flags)) { if (negative_flags[i]) { idx <- (i - 1) %% n_params + 1 updated_param_names[idx] <- paste0(""-"", param_names[idx]) } } # if labels provided, add as factor to data frame if (is.null(labels)) { labels <- as.character(1:n_types) # create numeric labels if labels are NULL } df$group <- as.factor(rep(unlist(labels), each = n_params)) # if errors provided, add as y-error bars to data frame if (!is.null(errors) && !is.null(errors[[1]])) { df$ymin <- unlist(lapply(1:n_types, function(i) abs(values[[i]]) - errors[[i]][1, ])) df$ymax <- unlist(lapply(1:n_types, function(i) abs(values[[i]]) + errors[[i]][2, ])) } # base plot with bars p <- ggplot2::ggplot(df, ggplot2::aes(x = factor(.data$x), y = .data$y)) + ggplot2::geom_bar(stat = ""identity"", position = ggplot2::position_dodge(), show.legend = n_types > 1) + ggplot2::scale_x_discrete(labels = updated_param_names, expand = ggplot2::expansion(mult = c(0, 0))) + ggplot2::labs(x = ""Parameters"", y = ""Values"", title = title) + ggplot2::theme_bw() + ggplot2::theme(panel.grid.major = ggplot2::element_blank(), panel.grid.minor = ggplot2::element_blank()) # add group aesthetic if 'group' column present if ('group' %in% colnames(df)) p <- p + ggplot2::aes(fill = .data$group) # add error bars if 'ymin' and 'ymax' columns present if (all(c('ymin', 'ymax') %in% colnames(df))) { p <- p + ggplot2::geom_errorbar(ggplot2::aes(ymin = .data$ymin, ymax = .data$ymax), width = 0.2, position = ggplot2::position_dodge(0.9)) } # add legend on the right if labels were provided if (legend) p <- p + ggplot2::theme(legend.position = ""right"") if (scale == ""log"") { p <- p + ggplot2::scale_y_continuous( trans = ""log10"", expand = ggplot2::expansion(mult = c(0, 0.05)) ) } else { p <- p + ggplot2::scale_y_continuous( expand = ggplot2::expansion(mult = c(0, 0.05)) ) } # display plot if 'show' is TRUE if (show) suppressWarnings(print(p)) # save plot to file if 'file' is provided if (!is.null(file)) ggplot2::ggsave(file, plot = p) return(p) } # Create a scatter plot. # # @param values List or matrix. Values to plot. # @param file Character. File path to save plot to. Default is NULL. # @param show Logical. Whether to show plot. Default is TRUE. # @param title Character. Title of plot. # @param scale Character. Scale of y-axis. One of 'lin', 'log'. Default is 'lin'. # # @return A ggplot object. viz$plot_scatter <- function( values, file = NULL, show = TRUE, title = NULL, scale = 'lin', ... ) { # Create data frame data <- data.frame(x = seq_along(values), y = unlist(values)) # Create plot p <- ggplot2::ggplot(data, ggplot2::aes(x = .data$x, y = .data$y)) + ggplot2::geom_point() + ggplot2::labs(title = title, y = 'lnl') # Set y scale if (scale == 'log') { p <- p + ggplot2::scale_y_continuous(trans = 'log10') } # Display plot if 'show' is TRUE if (show) print(p) # Save plot to file if 'file' is provided if (!is.null(file)) ggplot2::ggsave(file, plot = p) return(p) } # Plot the given 1D spectra # # @param spectra List of lists of spectra or a 2D array in which each row # is a spectrum in the same order as labels # @param labels Character vector. Labels for each spectrum # @param log_scale Logical. Whether to use logarithmic y-scale # @param use_subplots Logical. Whether to use subplots # @param show_monomorphic Logical. Whether to show monomorphic site counts # @param title Character. Title of plot # @param n_ticks Numeric. Number of x-ticks to use # @param file Character. File to save plot to # @param show Logical. Whether to show the plot # # @return ggplot object viz$plot_spectra <- function( spectra, labels = character(0), log_scale = FALSE, use_subplots = FALSE, show_monomorphic = FALSE, title = NULL, file = NULL, show = TRUE, ... ) { if (length(spectra) == 0) { warning('No spectra to plot.') return(NULL) } if (use_subplots) { # Creating a grid of plots plot_list <- lapply(1:length(spectra), function(i) { viz$plot_spectra( spectra = list(spectra[[i]]), labels = if (length(labels)) labels[i] else character(0), log_scale = log_scale, show_monomorphic = show_monomorphic, show = FALSE ) + ggplot2::labs(title = if (length(labels) >= i) labels[i] else '') }) plot_grid <- cowplot::plot_grid(plotlist = plot_list) if (show) print(plot_grid) if (!is.null(file)) ggplot2::ggsave(file, plot = plot_grid) return(plot_grid) } if (length(labels) == 0) { labels <- as.character(1:length(spectra)) } df <- data.frame() for (i in seq_along(spectra)) { indices <- if (show_monomorphic) seq_along(spectra[[i]]) else seq_along(spectra[[i]])[-c(1, length(spectra[[i]]))] heights <- if (show_monomorphic) unlist(spectra[[i]]) else unlist(spectra[[i]][-c(1, length(spectra[[i]]))]) df_temp <- data.frame(indices = indices, heights = heights, group = rep(labels[i], length(indices))) df <- rbind(df, df_temp) } # Create a ggplot object p <- ggplot2::ggplot(df, ggplot2::aes(x = indices, y = heights, fill = .data$group)) + ggplot2::geom_bar(stat = ""identity"", position = ""dodge"", width = 0.7, show.legend = length(spectra) > 1) + ggplot2::labs(x = ""frequency"", y = """", title = title) + ggplot2::theme_bw() + ggplot2::theme(panel.grid.major = ggplot2::element_blank(), panel.grid.minor = ggplot2::element_blank()) + ggplot2::scale_y_continuous(expand = ggplot2::expansion(mult = c(0, .1))) if (log_scale) { p <- p + ggplot2::scale_y_log10() } # Adjust x-axis labels based on show_monomorphic if (show_monomorphic) { p <- p + ggplot2::scale_x_continuous(breaks = 0:(length(spectra[[1]]) + 1), labels = 0:(length(spectra[[1]]) + 1) - 1, expand = c(0, 0)) } else { p <- p + ggplot2::scale_x_continuous(breaks = 1:length(spectra[[1]]), labels = 1:length(spectra[[1]]) - 1, expand = c(0, 0)) } # Display or save the plot if (show) print(p) if (!is.null(file)) ggplot2::ggsave(file, plot = p) return(p) } # Plot p-values of nested likelihoods. # # @param P Matrix of p-values # @param labels_x Labels for x-axis # @param labels_y Labels for y-axis # @param file File to save plot to # @param show Whether to show plot # @param cmap Colormap to use # @param title Title of plot # @param vmin Minimum value for colorbar # @param vmax Maximum value for colorbar # # @return NULL viz$plot_nested_models <- function( P, labels_x, labels_y, file = NULL, show = TRUE, cmap = NULL, title = NULL, vmin = 1e-10, vmax = 1, ... ) { # Format number to be displayed. format_number <- function(x) { if (is.null(x) || is.na(x) || x == 0) { return(0) } if (x < 0.0001) { return(format(x, scientific = TRUE)) } return(round(x, 4)) } # Convert list to matrix and replace NULLs with NAs P <- sapply(P, function(x) ifelse(is.null(x), NA, x)) P_mat <- matrix(P, nrow = sqrt(length(P)), ncol = sqrt(length(P)), byrow = TRUE) # Determine values to display annotation <- apply(P_mat, c(1, 2), function(x) as.character(format_number(x))) annotation[is.na(P_mat)] <- '-' # Change NAs to 1 to get a nicer color P_mat[is.na(P_mat)] <- NA # Keep within color bar bounds P_mat[P_mat < vmin] <- vmin P_mat[P_mat > vmax] <- vmax # Default color map if (is.null(cmap)) { cmap <- rev(colorRampPalette(RColorBrewer::brewer.pal(9, ""YlOrRd""))(100)) } # Plot heatmap p = pheatmap::pheatmap(mat = P_mat, color = cmap, cluster_rows = FALSE, cluster_cols = FALSE, display_numbers = TRUE, legend = TRUE, breaks = seq(vmin, 0.1, length.out = 101), labels_row = gsub(""_"", "" "", labels_y), labels_col = gsub(""_"", "" "", labels_x), angle_col = 45, cellheight = 40, cellwidth = 40, main = title ) if (!is.null(file)) { pdf(file) print(p) dev.off() } if (!show) { dev.off() } } return(fd) } ","R" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_maximum_likelihood_ancestral_annotation.py",".py","419","18","# example for ancestral allele annotation import fastdfe as fd ann = fd.Annotator( vcf=""https://github.com/Sendrowski/fastDFE/"" ""blob/dev/resources/genome/betula/all."" ""with_outgroups.subset.10000.vcf.gz?raw=true"", annotations=[fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], n_ingroups=15 )], output=""genome.polarized.vcf.gz"" ) ann.annotate() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/convert_plink.py",".py","351","17",""""""" Convert VCF file to plink format. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2022-05-31"" from snakemake.shell import shell vcf = snakemake.input[0] out = snakemake.output[0] prefix = out[:out.rfind(""."")] # create bed, bim and fam files shell(f""plink --vcf {vcf} --out {prefix} --allow-extra-chr"") ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/fold_sfs.py",".py","487","24",""""""" Fold SFS """""" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False file = snakemake.input[0] out = snakemake.output[0] except NameError: # testing testing = True file = ""results/sfs/hg38/chr/chr22.degeneracy/ingroup_pan_troglodytes/outgroups_ref_gorilla_gorilla_gorilla.ref_pongo_abelii/sfs.11.csv"" out = f""scratch/folded_sfs.csv"" import fastdfe as fd fd.Spectra.from_file(file).fold().to_file(out) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_allele_counts.py",".py","1632","70",""""""" Visualize the expected allele counts. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-06"" import numpy as np from matplotlib import pyplot as plt try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') testing = False n = snakemake.params.n out = snakemake.output[0] except ModuleNotFoundError: # testing testing = True n = 7 out = ""scratch/allele_counts.png"" from fastdfe.discretization import Discretization d = Discretization( n=n, intervals_ben=(1e-15, 1000, 1000), intervals_del=(-1000000, -1e-15, 1000) ) fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1, figsize=(6, 6)) fig.tight_layout(pad=4) ones = np.ones(d.n_intervals - 1) for i in range(1, n): ax1.plot(np.arange(d.n_intervals - 1), d.get_counts_semidominant_unregularized(d.s[d.s != 0], i * ones), label=f""i={i}"") ax2.plot(np.arange(d.n_intervals - 1), d.get_counts_semidominant_regularized(d.s[d.s != 0], i * ones), label=f""i={i}"") ax1.set_title('allele counts') ax2.set_title('regularized allele counts') for ax in (ax1, ax2): ax.set_xlabel('$S$') ax.set_ylabel('$P_{sel}(i, S)$') xticks = plt.gca().get_xticks() labels = [""{:.0e}"".format(d.s[int(l)]) if 0 <= int(l) < d.n_intervals else None for l in xticks] ax.set_xticklabels(labels) ax.legend(ncol=2, prop=dict(size=10)) ax.margins(x=0) ax.set_xlim(left=0, right=d.n_intervals - 1) plt.savefig(out, dpi=400, bbox_inches='tight', pad_inches=0) if testing: plt.show() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/derive_ancestral_alleles.py",".py","483","21",""""""" Derive the ancestral alleles using EST-SFS. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2022-05-31"" from snakemake.shell import shell data = snakemake.input.data seed = snakemake.input.seed config = snakemake.input.config bin = snakemake.input.bin out_sfs = snakemake.output.sfs out_probs = snakemake.output.probs tmp_dir = snakemake.resources.tmpdir # execute command shell(f""{bin} {config} {data} {seed} {out_sfs} {out_probs}"") ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_dfe_comparison.py",".py","753","34",""""""" Visualize DFE inference results. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-02"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False inputs = snakemake.input out_dfe_discretized = snakemake.output[0] except NameError: # testing testing = True inputs = [ ""results/fastdfe/pendula_C_full_bootstrapped_100/serialized.json"", ""results/fastdfe/pubescens_C_full_bootstrapped_100/serialized.json"" ] out = ""scratch/comp.png"" import fastdfe as fd inferences = [fd.BaseInference.from_file(input) for input in inputs] fd.Inference.plot_discretized(inferences, labels=['pendula', 'pubescens']) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/create_config_covariates_arabidopsis.py",".py","2268","99",""""""" Create config file for joint inference of Arabidopsis thaliana. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-06-06"" import pandas as pd try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False sfs_file = snakemake.input[0] col = snakemake.params.col n_bins = snakemake.params.n_bins subsample_size = snakemake.params.subsample_size param = snakemake.params.param out = snakemake.output[0] except NameError: # testing testing = True sfs_file = ""results/sfs_covariates/arabidopsis.csv"" col = 'mean.rsa' n_bins = 15 subsample_size = 20 param = 'S_d' out = ""scratch/sfs_arabidopsis.yaml"" import fastdfe as fd # read SFS stratified by gene genes = pd.read_csv(sfs_file, sep=""\t"") genes['count'] = 1 # create bins genes['group'] = pd.qcut( x=genes[col], q=n_bins, labels=[f""bin_{i}"" for i in range(n_bins)], ) # group by bins grouped = genes.groupby('group', observed=True) # extract SFS cols_neut = ['Lps'] + [f'sfsS{i}' for i in range(1, 105)] + ['Ds'] cols_sel = ['Lpn'] + [f'sfsN{i}' for i in range(1, 105)] + ['Dn'] # create spectra objects sfs_neut = fd.Spectra.from_dict( {k: r.values for k, r in grouped.sum()[cols_neut].iterrows()} ) sfs_sel = fd.Spectra.from_dict( {k: r.values for k, r in grouped.sum()[cols_sel].iterrows()} ) # determine average value of covariate in each bin cov = grouped[col].mean() # shuffle covariate values for testing # cov = dict(zip(cov.index, np.random.permutation(cov.values))) # create covariate object covariates = fd.Covariate( param=param, values=dict((t, cov[t]) for t in sfs_neut.types) ) # create config object config = fd.Config( sfs_neut=sfs_neut.subsample(subsample_size), sfs_sel=sfs_sel.subsample(subsample_size), shared_params=[fd.SharedParams(params='all', types='all')], covariates=[covariates], n_runs=20, n_bootstraps=100, do_bootstrap=True, parallelize=True ) # plot SFS if testing: (config.data['sfs_neut'].prefix('neutral') + config.data['sfs_sel'].prefix('selected')).plot( show=testing, use_subplots=True ) # save config config.to_file(out) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/compare_inferred_observed_monomorphic.R",".R","1621","61","library(fastdfe) fd <- load_fastdfe() # url for fastdfe repo url = ""https://github.com/Sendrowski/fastDFE/blob/dev/resources/genome/betula/"" # create parser where we consider monomorphic sites p <- fd$Parser( vcf = paste0(url, ""all.with_outgroups.subset.200000.vcf.gz?raw=true""), fasta = paste0(url, ""genome.subset.1000.fasta.gz?raw=true""), gff = paste0(url, ""genome.gff.gz?raw=true""), target_site_counter = NULL, n = 10, annotations = c(fd$DegeneracyAnnotation()), filtrations = c(fd$CodingSequenceFiltration()), stratifications = c(fd$DegeneracyStratification()) ) sfs <- p$parse() sfs$plot(title = ""observed"") # create parser where we infer monomrphic sites p2 = fd$Parser( vcf = paste0(url, ""all.with_outgroups.subset.200000.vcf.gz?raw=true""), fasta = paste0(url, ""genome.subset.1000.fasta.gz?raw=true""), gff = paste0(url, ""genome.gff.gz?raw=true""), target_site_counter = fd$TargetSiteCounter( n_samples = 1000000, n_target_sites = sum(sfs$n_sites) ), n = 10, annotations = c(fd$DegeneracyAnnotation()), filtrations = c(fd$CodingSequenceFiltration()), stratifications = c(fd$DegeneracyStratification()) ) sfs2 <- p2$parse() sfs$plot(title = ""inferred"") infs <- list() spectra <- list(sfs, sfs2) for (i in seq_along(spectra)) { inf <- fd$BaseInference( sfs_neut = spectra[[i]]$select('neutral'), sfs_sel = spectra[[i]]$select('selected'), do_bootstrap = TRUE, model = fd$DiscreteFractionalParametrization(), ) inf$run() infs[[i]] <- inf } # plot inferred DFEs fd$Inference$plot_discretized(infs, labels = c('monomorphic', 'inferred')) ","R" "Allele","Sendrowski/fastDFE","snakemake/scripts/prepare_input_est_sfs.py",".py","4441","137",""""""" Prepare the input for est-sfs. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2022-05-31"" import os from typing import Dict import numpy as np import pandas as pd from cyvcf2 import VCF from tqdm import tqdm try: vcf_file = snakemake.input.vcf ingroups_file = snakemake.input.ingroups outgroups_file = snakemake.input.outgroups out_data = snakemake.output.data n_outgroups = snakemake.config['n_outgroup'] n_max_subsamples = snakemake.config['n_samples'] seed = snakemake.config.get('seed', 0) except NameError: # testing vcf_file = ""../resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"" ingroups_file = ""../resources/genome/betula/sample_sets/birch.args"" outgroups_file = ""../resources/genome/betula/sample_sets/outgroups.args"" out_data = ""scratch/est-sfs.data.txt"" n_outgroups = 2 n_max_subsamples = 50 seed = 0 rng = np.random.default_rng(seed=seed) def subsample(bases: np.ndarray, size: int) -> np.ndarray: """""" Subsample a set of bases. :param bases: A list of bases. :param size: The size of the subsample. :return: A subsample of the bases. """""" # return an empty array when there are no haplotypes # this can happen for an uncalled outgroup site if len(bases) == 0: return np.array([]) # sample with replacement if the number of haplotypes is less than the subsample size if len(bases) < size: return np.array(bases)[rng.choice(len(bases), size=size, replace=True)] return np.array(bases)[rng.choice(len(bases), size=size, replace=False)] def count(bases: np.ndarray) -> Dict[str, int]: """""" Count the number of bases in a list of haplotypes. :param bases: Array of bases. :return: A dictionary of base counts. """""" counts = {'A': 0, 'C': 0, 'G': 0, 'T': 0} for key, value in zip(*np.unique(bases, return_counts=True)): counts[key] = value return counts def base_dict_to_string(d: Dict[str, int]) -> str: """""" Convert a dictionary of bases to a string. :param d: A dictionary of base counts. :return: A string of base counts. """""" return ','.join(map(str, [d['A'], d['C'], d['G'], d['T']])) def get_called_bases(calls: np.ndarray) -> np.ndarray: """""" Get the called bases from a list of calls. :param calls: Array of calls. :return: Array of called bases. """""" return np.array([b for b in '/'.join(calls).replace('|', '/') if b in 'ACGT']) # load ingroup and outgroup samples ingroups = pd.read_csv(ingroups_file, header=None, index_col=False)[0].tolist() outgroups = pd.read_csv(outgroups_file, header=None, index_col=False)[0].tolist() # number of subsamples to sample from haplotypes n_subsamples = min(n_max_subsamples, len(ingroups)) # write to data file with open(out_data, 'w') as f: # create reader vcf_reader = VCF(vcf_file) # raise error if outgroup samples are not in VCF if not set(outgroups).issubset(set(vcf_reader.samples)): raise ValueError(""Outgroup samples not in VCF."") # get indices of ingroup and outgroup samples ingroup_mask = [sample in ingroups for sample in vcf_reader.samples] outgroup_mask = [sample in outgroups for sample in vcf_reader.samples] for variant in tqdm(vcf_reader): # Only do inference for bi-allelic SNPs. if variant.is_snp: # get base counts for outgroup samples outgroup_counts = get_called_bases(variant.gt_bases[outgroup_mask]) # Only do inference for bi-allelic SNPs for which # at least ``n_outgroups`` outgroup samples are called if len(variant.ALT) == 1 and len(outgroup_counts) >= n_outgroups: # get base counts for ingroup samples ingroup_counts = count(subsample(get_called_bases(variant.gt_bases[ingroup_mask]), n_subsamples)) # subsample outgroup samples outgroup_subsamples = subsample(outgroup_counts, n_outgroups) # create a base count dictionary for each haplotype outgroup_dicts = [dict(A=0, C=0, G=0, T=0) for _ in range(n_outgroups)] for i, sub in enumerate(outgroup_subsamples): outgroup_dicts[i][sub] = 1 f.write(' '.join([base_dict_to_string(r) for r in [ingroup_counts] + outgroup_dicts]) + os.linesep) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/compare_dist_dominance.py",".py","2611","99",""""""" Compare distance including dominance with distance excluding dominance """""" from math import pi from typing import Callable import numpy as np import scipy.special as sp from matplotlib import pyplot as plt from fastdfe.discretization import Discretization def integral(S, h, x): """""" Indefinite integral of the function """""" erf = sp.erfi if S > 0 else sp.erf return ( np.sqrt(pi) * np.exp(np.float128(h ** 2 * S / (1 - 2 * h))) / (2 * np.sqrt(4 * h - 2) * np.sqrt(np.abs(S) / 2)) * erf(np.sqrt(np.abs(S) / 2) * (h * (2 * x - 1) - x) / np.sqrt(h - 0.5)) ) def f(x, S, h): """""" Allele frequency distribution for scaled selection coefficient S and dominance h """""" return ( np.exp(np.float128(2 * S * h * x + S * (1 - 2 * h) * x ** 2)) / (x * (1 - x)) * (integral(S, h, 1) - integral(S, h, x)) / (integral(S, h, 1) - integral(S, h, 0)) ) comp = {} for (x, S) in [(0.1, 1)]: comp[(x, S)] = (f(x=x, S=S, h=0.6), Discretization.get_counts_high_precision_regularized(x=x, S=S)) def plot_surface(ax: plt.Axes, func: Callable, title: str): """""" Plot the surface plot of the function :param ax: The axis object to plot on :param func: The function to plot :param title: Title for the subplot """""" # Parameters x_vals = np.linspace(0.01, 0.99, 100) # allele frequencies S_vals = np.linspace(-100, 100, 100) # selection coefficients # Compute the function values X, S = np.meshgrid(x_vals, S_vals) Z = np.array([func(x, s) for x, s in zip(np.ravel(X), np.ravel(S))]) Z = Z.reshape(X.shape) # Surface plot surf = ax.plot_surface(X, S, Z, cmap='viridis', edgecolor='none') ax.set_xlabel('x') ax.set_ylabel('S') ax.set_zlabel('f') ax.set_title(title) # Color bar for surface plot fig.colorbar(surf, ax=ax, shrink=0.5, aspect=5) # Create a figure with two subplots fig = plt.figure(figsize=(14, 7)) # First subplot for f(x, S, h=0.6) ax1 = fig.add_subplot(121, projection='3d') plot_surface(ax1, lambda x, S: f(x, S, h=0.6), title=""f(x, S, h=0.6)"") # Second subplot for discretization.H_regularized ax2 = fig.add_subplot(122, projection='3d') plot_surface(ax2, Discretization.get_counts_high_precision_regularized, title=""discretization.H_regularized"") plt.tight_layout() plt.show() S = 20 q = np.linspace(0.01, 0.99, 100) h_vals = np.array([0.1, 0.6, 1, 1.3]) for h in h_vals: plt.plot(q, f(q, S, h), label=f""h={h}"") plt.legend() plt.xlabel(""q"") plt.ylabel(""f(q)"") plt.show() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_filterer.py",".py","555","16","import fastdfe as fd # only keep variants in coding sequences f = fd.Filterer( vcf=""http://ftp.1000genomes.ebi.ac.uk/vol1/ftp/data_collections/"" ""1000_genomes_project/release/20181203_biallelic_SNV/"" ""ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz"", gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", output='scratch/sapiens.chr21.coding.vcf', filtrations=[fd.CodingSequenceFiltration()], aliases=dict(chr21=['21']), ) f.filter() ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_joint_inference.py",".py","1209","41",""""""" Visualize a DFE inference. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False serialized = snakemake.input[0] out_dfe = snakemake.output.get('dfe', None) out_spectra = snakemake.output.get('spectra', None) out_params = snakemake.output.get('params', None) except NameError: # testing testing = True # config_file = 'results/configs/example_1_C_full_anc/config.yaml' # config_file = 'results/configs/example_1_C_deleterious_anc_bootstrapped_100/config.yaml' # config_file = 'results/configs/pendula_C_full_anc_bootstrapped_100/config.yaml' serialized = 'results/fastdfe/hominidae/cov/S_d.serialized.json' out_dfe = ""scratch/dfe.png"" out_spectra = ""scratch/spectra.png"" out_params = ""scratch/params.png"" from fastdfe import JointInference # create from config inf = JointInference.from_file(serialized) # plot results inf.plot_inferred_parameters(file=out_params, show=testing) inf.plot_sfs_comparison(file=out_spectra, show=testing) inf.plot_discretized(file=out_dfe, show=testing) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/compute_sfs_slim.py",".py","3282","128",""""""" Compute the site frequency spectrum (SFS) for selected and neutral sites in a tree sequence. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2024-02-26"" import random import matplotlib.pyplot as plt import msprime as ms import numpy as np import pandas as pd import tskit from scipy.stats import hypergeom from tqdm import tqdm try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False file_in = snakemake.input[0] n = snakemake.params.n mu = snakemake.params.mu L = snakemake.params.L N = snakemake.params.N out = snakemake.output.sfs out_ds_continuous = snakemake.output.ds_continuous out_ds_discretized = snakemake.output.ds_discretized except NameError: # testing testing = True file_in = ""results/slim/n_replicate=1/g=10000/L=10000000000/mu=1e-09/r=1e-09/N=1000/s_b=0.05/b=1/s_d=0.1/p_b=0.2/sequence.trees"" n = 10 mu = 1e-9 L = 10000000000 N = 1000 out = ""scratch/slim_sfs.csv"" out_ds_continuous = ""scratch/slim_dfe.png"" out_ds_discretized = ""scratch/slim_discretized.png"" # load the tree sequence ts = tskit.load(file_in) j = 0 sfs_sel = np.zeros(n + 1) n_repeat_sel = 0 # selection coefficients s = np.zeros(ts.num_mutations) for i, var in tqdm(enumerate(ts.variants()), desc='Computing selected SFS'): for mut in var.site.mutations: s[j] = mut.metadata['mutation_list'][0]['selection_coeff'] j += 1 n_repeat_sel += int(len(var.site.mutations) > 1) # add hypergeometric counts sfs_sel += hypergeom.pmf(k=range(n + 1), M=ts.sample_size, n=np.sum(var.genotypes > 0), N=n) print(f""Repeat mutations (selected): {n_repeat_sel}"") # add monomorphic sites sfs_sel[0] = L - sfs_sel.sum() # simulate neutral mutations ts = ms.sim_mutations(ts, rate=mu, keep=False) sfs_neut = np.zeros(n + 1) n_repeat_neut = 0 for var in tqdm(ts.variants(), desc='Computing neutral SFS'): n_repeat_neut += int(len(var.site.mutations) > 1) sfs_neut += hypergeom.pmf(k=range(n + 1), M=ts.sample_size, n=np.sum(var.genotypes > 0), N=n) print(f""Repeat mutations (neutral): {n_repeat_neut}"") # add monomorphic sites sfs_neut[0] = L - sfs_neut.sum() # save as csv using pandas spectra = pd.DataFrame(dict(neutral=sfs_neut, selected=sfs_sel)) spectra.to_csv(out, index=False) # determine Ne from sfs_neut using Watterson's estimator theta = sum(sfs_neut[1:-1]) / np.sum(1 / np.arange(1, n)) / sum(sfs_neut) # theta = 4 * Ne * mu -> Ne = theta / (4 * mu) Ne = theta / (4 * mu) S = 4 * Ne * s # plot histogram of selection coefficients plt.hist(S, bins=400, density=True) # set upper and lower bounds to 1 and 99th percentiles plt.xlim(np.percentile(S, 1), np.percentile(S, 99)) plt.xlabel('S') plt.title(f'Observed S, $N_e$ = {Ne:.2f}') plt.margins(x=0) plt.savefig(out_ds_continuous) if testing: plt.show() plt.clf() # bin the selection coefficients values, _ = np.histogram(S, bins=[-np.inf, -100, -10, -1, 0, 1, np.inf]) values = values / np.sum(values) plt.bar(['<-100', '-100:-10', '-10:-1', '-1:0', '0:1', '>1'], values) plt.xlabel('S') plt.title(f'Observed S, $N_e$ = {Ne:.2f}') plt.margins(x=0) plt.savefig(out_ds_discretized) if testing: plt.show() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/compare_dfe_sample_sizes.py",".py","4467","149","import sys # necessary to import fastdfe locally sys.path.append('.') import numpy as np from matplotlib import pyplot as plt import fastdfe as fd try: testing = False n_dfes = 6 n_runs = 10 n_bootstraps = 100 n_bootstrap_retries = 2 n_fixed = 20 intervals_del = (-1.0e+8, -1.0e-5, 1000) intervals_ben = (1.0e-5, 1.0e4, 1000) out = snakemake.output[0] except NameError: # testing testing = True n_dfes = 2 n_runs = 1 n_bootstraps = 4 n_bootstrap_retries = 1 n_fixed = 20 intervals_del = (-1.0e+8, -1.0e-5, 100) intervals_ben = (1.0e-5, 1.0e4, 100) out = ""scratch/compare_dfe_accuracy.png"" fig, ax = plt.subplots(2, 2, figsize=(10.5, 6)) plt.rcParams['xtick.labelsize'] = 9 plt.rcParams[""axes.prop_cycle""] = plt.cycler(color=plt.cm.viridis(np.linspace(0.15, 1, n_dfes + 1))) params = [dict(S_d=-300, b=0.3, p_b=0, S_b=1), dict(S_d=-300, b=0.3, p_b=0.05, S_b=1)] def sci(x): base, exp = f""{x:e}"".split(""e"") return f""{int(np.round(float(base)))}e{int(exp)}"" for i, param in enumerate(params): dfes = {} spectra = {} for n in np.logspace(np.log10(6), np.log10(100), n_dfes).astype(int): sim = fd.Simulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=n, n_sites=1e7, theta=1e-5), intervals_ben=intervals_ben, intervals_del=intervals_del, params=param, model=fd.GammaExpParametrization() ) sim.run() s = sim.get_spectra() s.data *= 10000 / s.n_polymorphic inf = fd.BaseInference( sfs_neut=s['neutral'], sfs_sel=s['selected'], intervals_ben=intervals_ben, intervals_del=intervals_del, fixed_params=dict(all=dict(h=0.5, eps=0) | (dict(p_b=0, S_b=1) if param['p_b'] == 0 else {})), n_runs=n_runs, n_bootstraps=n_bootstraps, n_bootstrap_retries=n_bootstrap_retries ) inf.run() spectra[n] = inf.get_spectra()[['neutral', 'selected']] dfes[n] = inf.get_dfe() param_str = ', '.join([f'{k}={v}' for k, v in param.items() if k in ['S_d', 'b', 'p_b', 'S_b']]) fd.DFE.plot_many( [sim.dfe] + list(dfes.values()), labels=np.arange(len(dfes) + 1).astype(str), point_estimate='mean', # intervals=[-np.inf, -100, -10, -1, 1, np.inf], ax=ax[i, 0], title=f""SFS sample sizes $({param_str})$"", show=False ) labels = ([""true DFE""] + [f""n={n},{'':<{3 - int(np.log10(n))}}#SNP={sci(spectra[n].all.n_polymorphic)}"" for n in dfes.keys()]) ax[i, 0].legend(ax[i, 0].get_legend_handles_labels()[0], labels, prop={""family"": ""monospace"", ""size"": 8}) dfes = {} spectra = {} for n_snps in np.logspace(3, 6, n_dfes) * 1.5: sim = fd.Simulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=n_fixed, n_sites=1e7, theta=1e-5), intervals_ben=intervals_ben, intervals_del=intervals_del, params=param, model=fd.GammaExpParametrization() ) sim.run() s = sim.get_spectra() s.data *= n_snps / s.n_polymorphic inf = fd.BaseInference( sfs_neut=s['neutral'], sfs_sel=s['selected'], intervals_ben=intervals_ben, intervals_del=intervals_del, fixed_params=dict(all=dict(h=0.5, eps=0) | (dict(p_b=0, S_b=1) if param['p_b'] == 0 else {})), n_runs=n_runs, n_bootstraps=n_bootstraps, n_bootstrap_retries=n_bootstrap_retries ) inf.run() spectra[n_snps] = inf.get_spectra()[['neutral', 'selected']] dfes[n_snps] = inf.get_dfe() param_str = ', '.join([f'{k}={v}' for k, v in param.items() if k in ['S_d', 'b', 'p_b', 'S_b']]) fd.DFE.plot_many( [sim.dfe] + list(dfes.values()), labels=np.arange(len(dfes) + 1).astype(str), point_estimate='mean', # intervals=[-np.inf, -100, -10, -1, 1, np.inf], ax=ax[i, 1], title=f""Number of SNPs $({param_str})$"", show=False ) labels = [""true DFE""] + [f""n={n_fixed}, #SNP={sci(spectra[theta].all.n_polymorphic)}"" for theta in dfes.keys()] ax[i, 1].legend(ax[i, 1].get_legend_handles_labels()[0], labels, prop={""family"": ""monospace"", ""size"": 8}) plt.tight_layout() fig.savefig(out, dpi=200) if testing: plt.show() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/create_config_covariates_hominidae.py",".py","1887","70",""""""" Check for covariates in the great ape dataset. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-05-31"" import pandas as pd try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False types = snakemake.params.types param = snakemake.params.param sfs_neutral = snakemake.input.neutral sfs_selected = snakemake.input.selected out = snakemake.output[0] except NameError: # testing testing = True types = [ 'bonobo', 'bornean_orang', 'central_chimp', 'eastern_chimp', 'human', 'NC_chimp', 'sumatran_orang', 'western_chimp', 'western_lowland_gorilla' ] param = 'S_d' sfs_neutral = [f'../resources/SFS/hominidae/uSFS/{t}_4fold_all_sfs.txt' for t in types] sfs_selected = [f'../resources/SFS/hominidae/uSFS/{t}_0fold_all_sfs.txt' for t in types] out = ""scratch/joint_inference.yaml"" from fastdfe import Config, Spectra, Spectrum, Covariate, SharedParams def get_sfs(file: str) -> Spectrum: """""" Get SFS from file. :param file: The file to read the SFS from. :return: The SFS. """""" return Spectrum(pd.read_csv(file, header=None).iloc[0].tolist()) config = Config( sfs_neut=Spectra.from_spectra(dict((t, get_sfs(sfs_neutral[i])) for i, t in enumerate(types))), sfs_sel=Spectra.from_spectra(dict((t, get_sfs(sfs_selected[i])) for i, t in enumerate(types))), do_bootstrap=True, n_bootstraps=100, n_runs=100, parallelize=True, # fixed_params=dict(all=dict(eps=0, p_b=0, S_b=1)), shared_params=[SharedParams(params='all', types='all')], covariates=[Covariate( param=param, values=dict((t, get_sfs(sfs_neutral[i]).theta / (4 * 1e-9)) for i, t in enumerate(types)) )], ) config.to_file(out) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/parse_output_polydfe.py",".py","774","33",""""""" Parse polyDFE output. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-06"" try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') testing = False input = snakemake.input[0] postprocessing_source = '../resources/polydfe/postprocessing/script.R' out = snakemake.output[0] except NameError: # testing testing = True input = 'scratch/polydfe_out.txt' postprocessing_source = '../resources/polydfe/postprocessing/script.R' out = 'scratch/polydfe_out.json' import json from fastdfe.polydfe import PolyDFE with open(out, 'w') as fh: json.dump(PolyDFE.parse_output(input, postprocessing_source), fh, indent=4) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/parse_vcf_hgdp.py",".py","2021","84",""""""" Parse SFS from HGDP VCF. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-05-25"" import numpy as np try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False chr = snakemake.params.chr vcf_file = snakemake.input.vcf fasta = snakemake.input.fasta gff = snakemake.input.gff samples_file = snakemake.input.samples out_csv = snakemake.output.csv out_png = snakemake.output.png aliases = snakemake.params.aliases max_sites = snakemake.params.get('max_sites', np.inf) n_samples = snakemake.params.get('n_samples', 1000000) n = snakemake.params.get('n', 20) except NameError: # testing testing = True chr = ""9"" vcf_file = f""results/vcf/hgdp/{chr}/opts.vcf.gz"" fasta = f""results/fasta/hgdp/{chr}.fasta.gz"" gff = f""results/gff/hgdp/{chr}.corrected.gff3.gz"" samples_file = ""results/sample_lists/hgdp/all.args"" out_csv = ""scratch/parse_csv_hgdp.spectra.csv"" out_png = ""scratch/parse_csv_hgdp.spectra.png"" aliases = {f""chr{chr}"": [chr]} max_sites = 10000 n_samples = 10000 n = 20 import pandas as pd import fastdfe as fd samples = pd.read_csv(samples_file).iloc[:, 0].tolist() # setup parser p = fd.Parser( vcf=vcf_file, fasta=fasta, gff=gff, aliases=aliases, max_sites=max_sites, target_site_counter=fd.TargetSiteCounter( n_samples=n_samples, n_target_sites=fd.Annotation.count_target_sites( file=gff )[chr] ), n=n, annotations=[fd.DegeneracyAnnotation()], filtrations=[ fd.CodingSequenceFiltration(), fd.SNVFiltration(), fd.PolyAllelicFiltration() ], stratifications=[fd.DegeneracyStratification()], include_samples=samples, info_ancestral='AA_ensembl' ) # parse spectra spectra = p.parse() # save to file spectra.to_file(out_csv) # plot data and save to file spectra.plot(show=testing, file=out_png) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_base_inference.py",".py","2328","75",""""""" Visualize DFE inference results. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-02"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False input = snakemake.input[0] out_dfe_discretized = snakemake.output.get('dfe_discretized', None) out_dfe_continuous = snakemake.output.get('dfe_continuous', None) out_sfs_comparison = snakemake.output.get('sfs_comparison', None) sfs_comparison_detailed = snakemake.output.get('sfs_comparison_detailed', None) out_sfs_input = snakemake.output.get('sfs_input', None) out_mle_params = snakemake.output.get('mle_params', None) out_bucket_sizes = snakemake.output.get('bucket_sizes', None) except NameError: # testing testing = True input = ""results/fastdfe/example_3_C_full_anc_bootstrapped_100/serialized.json"" out_dfe_discretized = ""scratch/dfe_discretized.png"" out_dfe_continuous = ""scratch/dfe_continuous.png"" out_sfs_comparison = ""scratch/sfs_comparison.png"" sfs_comparison_detailed = ""scratch/sfs_comparison_detailed.png"" out_sfs_input = ""scratch/sfs_input.png"" out_mle_params = ""scratch/mle_params.png"" out_bucket_sizes = ""scratch/bucket_sizes.png"" import fastdfe as fd inf = fd.BaseInference.from_file(input) if out_dfe_continuous is not None: inf.plot_continuous(file=out_dfe_continuous, show=testing) if out_dfe_discretized is not None: inf.plot_discretized(file=out_dfe_discretized, show=testing) if out_mle_params is not None: inf.plot_inferred_parameters(file=out_mle_params, show=testing) if out_sfs_comparison is not None: inf.plot_sfs_comparison( file=out_sfs_comparison, show=testing, title=f""SFS comparison, L1 norm:{inf.get_residual(1) / inf.sfs_sel.n_polymorphic:.2f}"" ) if sfs_comparison_detailed is not None: inf.plot_sfs_comparison( sfs_types=[""neutral"", ""selected"", ""modelled""], file=sfs_comparison_detailed, show=testing, title='' ) if out_sfs_input is not None: inf.plot_sfs_comparison( sfs_types=[""neutral"", ""selected""], file=out_sfs_input, show=testing ) if out_bucket_sizes is not None: inf.plot_bucket_sizes(file=out_bucket_sizes, show=testing) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_spectra.py",".py","582","33",""""""" Plot spectra. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-30"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False file = snakemake.input[0] out = snakemake.output[0] except NameError: # testing testing = True file = ""results/sfs/pendula/all.csv"" out = ""scratch/spectra.png"" from fastdfe import Spectra s = Spectra.from_file(file) s = s.merge_groups([0]) s.plot(show=testing, file=out, show_monomorphic=False, use_subplots=False) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_parser_homo.py",".py","1039","35","import fastdfe as fd # parse selected and neutral SFS from human chromosome 1 p = fd.Parser( vcf=""https://ngs.sanger.ac.uk/production/hgdp/hgdp_wgs.20190516/"" ""hgdp_wgs.20190516.full.chr21.vcf.gz"", fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"", gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", aliases=dict(chr21=['21']), n=10, target_site_counter=fd.TargetSiteCounter( n_samples=1000000, n_target_sites=fd.Annotation.count_target_sites( ""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"" )['21'] ), annotations=[ fd.DegeneracyAnnotation() ], filtrations=[ fd.CodingSequenceFiltration() ], stratifications=[fd.DegeneracyStratification()], info_ancestral='AA_ensembl' ) sfs = p.parse() sfs.plot() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/install_est_sfs.py",".py","1014","43",""""""" Set up est-sfs by downloading it from Sourceforge and compiling it. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2022-05-31"" from snakemake.shell import shell try: out = snakemake.output[0] tmp_dir = snakemake.resources.tmpdir max_sites = snakemake.config['max_sites'] except NameError: # testing out = ""scratch/est-sfs"" tmp_dir = ""/tmp"" max_sites = 100000 version = ""2.04"" # set up est-sfs # Note: the compilation only works on Linux shell(f"""""" set -x work_dir=$(readlink -f .) cd {tmp_dir} wget https://sourceforge.net/projects/est-usfs/files/est-sfs-release-{version}.tar.gz/download -O est-sfs.tar.gz rm -rf est-sfs mkdir est-sfs tar -xvf est-sfs.tar.gz -C est-sfs --strip-components 1 cd est-sfs sed -i 's/#define max_config 1000000/#define max_config {max_sites}/g' est-sfs.c export C_INCLUDE_PATH=$CONDA_PREFIX/include make mv est-sfs ""$work_dir/{out}"" """""") ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_presentation_base_inference.py",".py","846","38",""""""" Base inference example for presentation """""" import numpy as np import fastdfe as fd inf = fd.BaseInference( sfs_neut=fd.Spectrum( [66200, 410, 120, 60, 42, 43, 52, 65, 0] ), sfs_sel=fd.Spectrum( [281937, 600, 180, 87, 51, 43, 49, 61, 0] ), model=fd.GammaExpParametrization(), n_runs=10, n_bootstraps=100, do_bootstrap=True ) inf.run() import matplotlib.pyplot as plt # create subplots axs = plt.subplots(3, 1, figsize=(3.5, 6))[1].flatten() # plot results types = ['neutral', 'selected'] inf.plot_sfs_comparison(ax=axs[0], show=False, sfs_types=types) inf.plot_sfs_comparison(ax=axs[1], show=False, colors=['C1', 'C5']) inf.plot_discretized(ax=axs[2], show=False, intervals=[-np.inf, -100, -1, 0, np.inf]) plt.savefig('scratch/base_inference_presentation.png', dpi=400) plt.show() pass","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/annotate_degeneracy.py",".py","944","43",""""""" Annotate degeneracy of variants in a VCF file. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-05-12"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False vcf_file = snakemake.input.vcf fasta = snakemake.input.ref gff = snakemake.input.gff out = snakemake.output[0] except ModuleNotFoundError: # testing testing = True vcf_file = ""resources/genome/betula/all.polarized.subset.200000.vcf.gz"" fasta = ""resources/genome/betula/genome.fasta"" gff = ""resources/genome/betula/genome.gff.gz"" out = 'resources/genome/betula/all.polarized.deg.subset.200000.vcf.gz' import fastdfe as fd fd.logger.setLevel('DEBUG') # initialize annotator ann = fd.Annotator( vcf=vcf_file, output=out, fasta=fasta, gff=gff, annotations=[fd.DegeneracyAnnotation()], ) # run annotator ann.annotate() ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/run_gatk.py",".py","502","25",""""""" Run the GATK. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2022-05-31"" from snakemake.shell import shell from snakemake_wrapper_utils.java import get_java_opts java_opts = get_java_opts(snakemake) flags = snakemake.params.flags command = snakemake.params.command cmd = f""gatk --java-options '{java_opts}' {command}"" if '-O' not in flags: flags['-O'] = snakemake.output[0] for flag, val in flags.items(): cmd += f"" {flag} {val}"" shell(cmd) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_manuscript_covariates_cached.py",".py","460","17","import fastdfe as fd import matplotlib.pyplot as plt # example for joint inference with covariates inf = fd.JointInference.from_file(""scratch/example_manuscript_covariates.json"") _, axs = plt.subplots(1, 2, figsize=(10.5, 4)) inf.plot_covariate(ax=axs[0], xlabel='RSA', show=False) inf.plot_discretized( ax=axs[1], show_marginals=False, kwargs_legend=dict(prop=dict(size=9)), show=True ) # plt.savefig(""scratch/joint_inference_covariates.png"") ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_manuscript_parser.py",".py","833","31","import fastdfe as fd basepath = (""https://github.com/Sendrowski/fastDFE/"" ""blob/dev/resources/genome/betula/"") # instantiate parser p = fd.Parser( n=8, # SFS sample size vcf=(basepath + ""biallelic.with_outgroups."" ""subset.50000.vcf.gz?raw=true""), fasta=basepath + ""genome.subset.1000.fasta.gz?raw=true"", gff=basepath + ""genome.gff.gz?raw=true"", target_site_counter=fd.TargetSiteCounter( n_target_sites=350000 # total number of target sites ), annotations=[ fd.DegeneracyAnnotation(), # determine degeneracy fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""] # use one outgroup ) ], stratifications=[fd.DegeneracyStratification()] ) # obtain SFS spectra: fd.Spectra = p.parse() spectra.plot() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_manuscript_covariates.py",".py","815","31","import matplotlib.pyplot as plt import fastdfe as fd # example for joint inference with covariates inf = fd.JointInference.from_config_file( ""https://github.com/Sendrowski/fastDFE/"" ""blob/dev/resources/configs/arabidopsis/"" ""covariates_example.yaml?raw=true"" ) inf.run() # get p-value for covariate significance p = inf.perform_lrt_covariates() p_str = f""p = {p:.1e}"" if p >= 1e-100 else ""p < 1e-100"" # plot results _, axs = plt.subplots(1, 2, figsize=(10.5, 3.5)) inf.plot_covariate(ax=axs[0], xlabel='RSA', show=False) inf.plot_discretized( title=f""DFE comparison, "" + p_str, ax=axs[1], show_marginals=False, show=False ) plt.savefig('../reports/manuscript/figures/joint_inference_covariates.high_resolution.jpg', dpi=1200) # plt.savefig(""scratch/joint_inference_covariates.png"") pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dfe.py",".py","1628","55",""""""" Infer the DFE from the SFS using fastDFE. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False config_file = snakemake.input[0] out_summary = snakemake.output.summary out_serialized = snakemake.output.serialized out_dfe = snakemake.output.get('dfe', None) out_spectra = snakemake.output.get('spectra', None) out_params = snakemake.output.get('params', None) except NameError: # testing testing = True # config_file = 'results/configs/example_1_C_full_anc/config.yaml' # config_file = 'results/configs/example_1_C_deleterious_anc_bootstrapped_100/config.yaml' # config_file = 'results/configs/pendula_C_full_anc_bootstrapped_100/config.yaml' config_file = 'results/configs/pendula_C_full_anc_bootstrapped_sequential_100/config.yaml' out_summary = ""scratch/summary.json"" out_serialized = ""scratch/serialized.json"" out_dfe = ""scratch/dfe.png"" out_spectra = ""scratch/spectra.png"" out_params = ""scratch/params.png"" from fastdfe import BaseInference # create from config inference = BaseInference.from_config_file(config_file) # perform inference inference.run() # save object in serialized form inference.to_file(out_serialized) # save summary inference.get_summary().to_file(out_summary) # plot results inference.plot_inferred_parameters(file=out_params, show=testing) inference.plot_sfs_comparison(file=out_spectra, show=testing) inference.plot_discretized(file=out_dfe, show=testing) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/parse_vcf.py",".py","1329","62",""""""" Parse a VCF file. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-29-03"" import numpy as np try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False vcf_file = snakemake.input.vcf fasta = snakemake.input.ref n = snakemake.params.n max_sites = snakemake.params.get('max_sites', np.inf) stratifications = snakemake.params.get('stratifications', ['DegeneracyStratification']) out = snakemake.output[0] except NameError: # testing testing = True vcf_file = 'results/vcf/betula/vcf/all.vcf.gz' fasta = '../resources/genome/betula/genome.fasta' n = 20 max_sites = np.inf stratifications = [ 'DegeneracyStratification', 'AncestralBaseStratification' ] out = ""scratch/sfs_parsed.csv"" import fastdfe as fd # instantiate stratifications for i, s in enumerate(stratifications): if s == 'BaseContextStratification': stratifications[i] = fd.BaseContextStratification(fasta=fasta) else: stratifications[i] = getattr(fastdfe.parser, s)() # instantiate parser p = fd.Parser( n=n, vcf=vcf_file, max_sites=max_sites, stratifications=stratifications ) # parse SFS sfs = p.parse() # save to file sfs.to_file(out) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dfe_polydfe_hgdp.py",".py","2026","76",""""""" Infer the DFE from the SFS for the HGDP dataset using polyDFE. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-05-29"" import os try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') execute = shell testing = False config_file = snakemake.input.config spectra_file = snakemake.input.spectra bin = snakemake.params.get('bin', 'resources/polydfe/bin/polyDFE-2.0-macOS-64-bit') out_summary = snakemake.output.summary out_serialized = snakemake.output.serialized out_polydfe = snakemake.output.polydfe out_dfe = snakemake.output.dfe out_spectra = snakemake.output.spectra out_params = snakemake.output.params except ModuleNotFoundError: # testing testing = True execute = None config_file = '../resources/configs/HGDP/polydfe.yaml' spectra_file = ""results/spectra/hgdp/1/opts.n.10/all.csv"" bin = '../resources/polydfe/bin/polyDFE-2.0-macOS-64-bit' out_summary = ""scratch/summary.json"" out_serialized = ""scratch/serialized.json"" out_polydfe = ""scratch/polydfe.txt"" out_dfe = ""scratch/dfe.png"" out_spectra = ""scratch/spectra.png"" out_params = ""scratch/params.png"" from fastdfe import Config, Spectra from fastdfe.polydfe import PolyDFE # load config from file config = Config.from_file(config_file) # load spectra from file spectra = Spectra.from_file(spectra_file) # update config with spectra config.update( sfs_neut=spectra['neutral'], sfs_sel=spectra['selected'], do_bootstrap=False ) # create from config inference = PolyDFE.from_config(config) # perform inference summary = inference.run(out_polydfe, binary=bin, wd=os.getcwd(), execute=execute) # save object in serialized form inference.to_file(out_serialized) # save summary summary.to_file(out_summary) inference.plot_inferred_parameters(file=out_params, show=testing) inference.plot_discretized(file=out_dfe, show=testing) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_pendula_complex.py",".py","919","35","import fastdfe as fd basepath = (""https://github.com/Sendrowski/fastDFE/"" ""blob/dev/resources/genome/betula/"") # instantiate parser p = fd.Parser( n=10, vcf=""../resources/genome/betula/all.vcf.gz"", stratifications=[fd.DegeneracyStratification(), fd.AncestralBaseStratification()] ) # parse SFS spectra: fd.Spectra = p.parse() # create inference object inf = fd.JointInference( # select neutral and selected spectra from stratified spectra sfs_neut=spectra['neutral.*'].merge_groups(1), sfs_sel=spectra['selected.*'].merge_groups(1), # fix ancestral misidentification rate to 0 fixed_params=dict(all=dict(eps=0)), # share S_b and p_b across types shared_params=[fd.SharedParams(params=['p_b', 'S_b'], types='all')], do_bootstrap=True ) # run inference inf.run() # plot discretized DFE inf.plot_discretized(show=False, kwargs_legend=dict(framealpha=0)) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/merge_bootstraps_polydfe.py",".py","985","39",""""""" Merge bootstraps and original inference result. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-10"" try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') testing = False file_original = snakemake.input.original files_bootstrap = snakemake.input.bootstraps out = snakemake.output[0] except ModuleNotFoundError: # testing testing = True file_original = 'results/polydfe/pendula_C_deleterious_bootstrapped_100/serialized.json' files_bootstrap = [f'results/polydfe/pendula_C_full_anc/bootstraps/{i}/serialized.json' for i in range(100)] out = 'scratch/polydfe_bs.json' from fastdfe.polydfe import PolyDFE # load from file original = PolyDFE.from_file(file_original) bootstraps = [PolyDFE.from_file(f) for f in files_bootstrap] # add bootstraps original.add_bootstraps(bootstraps) # save to file original.to_file(out) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_manuscript_joint_inference.py",".py","518","22","import fastdfe as fd spectra = fd.Spectra.from_file( ""https://github.com/Sendrowski/fastDFE/blob/dev/"" ""resources/SFS/betula/spectra.20.csv?raw=true"" ) inf = fd.JointInference( sfs_neut=spectra['neutral.*'].merge_groups(1), sfs_sel=spectra['selected.*'].merge_groups(1), do_bootstrap=True, model=fd.DiscreteFractionalParametrization(), shared_params=[fd.SharedParams(params=['S1', 'S2'], types='all')] ) inf.run() inf.plot_discretized() #inf.plot_inferred_parameters(scale='lin') pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/benchmark_fastdfe_import.py",".py","203","14",""""""" Benchmark the import of fastdfe """""" import time start = time.time() # noinspection PyUnresolvedReferences import fastdfe end = time.time() print(f""fastdfe imported in {end - start:.2f} seconds"") ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_polydfe_inference.py",".py","912","35",""""""" Visualize polyDFE inference results. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-11"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False input = snakemake.input[0] out_dfe_discretized = snakemake.output.dfe_discretized out_mle_params = snakemake.output.mle_params except NameError: # testing testing = True # input = ""scripts/polydfe/pendula_C_full_anc/serialized.json"" input = ""results/fastdfe/pendula_C_full_bootstrapped_100/serialized.json"" out_dfe_discretized = ""scratch/dfe_discretized.png"" out_mle_params = ""scratch/mle_params.png"" from fastdfe.polydfe import PolyDFE inference = PolyDFE.from_file(input) inference.plot_inferred_parameters(file=out_mle_params, show=testing) inference.plot_discretized(file=out_dfe_discretized, show=testing) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_shared_dfe_inference.py",".py","1337","44",""""""" Visualize DFE inference results. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-02"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False input = snakemake.input[0] out_dfe_discretized = snakemake.output.dfe_discretized out_dfe_log = snakemake.output.dfe_log out_sfs_comparison = snakemake.output.sfs_comparison out_mle_params = snakemake.output.mle_params out_bucket_sizes = snakemake.output.bucket_sizes except NameError: # testing testing = True input = ""scratch/serialized_shared.json"" out_dfe_discretized = ""scratch/dfe_discretized.png"" out_dfe_log = ""scratch/dfe_log.png"" out_sfs_comparison = ""scratch/sfs_comparison.png"" out_mle_params = ""scratch/mle_params.png"" out_bucket_sizes = ""scratch/bucket_sizes.png"" import fastdfe as fd inference = fd.BaseInference.from_file(input) inference.plot_inferred_parameters(file=out_mle_params, show=testing) inference.plot_bucket_sizes(file=out_bucket_sizes, show=testing) inference.plot_sfs_comparison(file=out_sfs_comparison, show=testing) inference.plot_continuous(file=out_dfe_log, show=testing) inference.plot_discretized(file=out_dfe_discretized, show=testing) inference.plot_interval_density(show=testing) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/combine_spectra.py",".py","858","42",""""""" Create spectra objects. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2022-30-03"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False files = snakemake.input names = snakemake.params.names out = snakemake.output[0] except NameError: # testing testing = True files = [ 'resources/polydfe/pendula/spectra/sfs.txt', 'resources/polydfe/pubescens/spectra/sfs.txt' ] names = [ 'pendula', 'pubescens' ] out = ""scratch/spectra.csv"" import fastdfe as fd spectra = fd.Spectra({}) for name, file in zip(names, files): s = fd.spectrum.parse_polydfe_sfs_config(file) spectra['sfs_neut.' + name] = s['sfs_neut'] spectra['sfs_sel.' + name] = s['sfs_sel'] spectra.to_file(out) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/recode_ancestral_alleles_vcf.py",".py","5615","174",""""""" Annotate the VCF with ancestral allele information. An AA info tag is added in addition to further information. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2022-05-31"" import logging import numpy as np import sys from collections import Counter from tqdm import tqdm import pandas as pd from cyvcf2 import VCF, Writer try: vcf_file = snakemake.input.vcf probs = snakemake.input.probs data = snakemake.input.data ingroups_file = snakemake.input.ingroups outgroups_file = snakemake.input.outgroups n_outgroups = snakemake.config['n_outgroup'] log = snakemake.log[0] out = snakemake.output.vcf log_level = snakemake.config.get('log_level', 20) except NameError: # testing vcf_file = ""../resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"" probs = ""results/est-sfs/.probs.txt"" data = ""results/est-sfs/.data.txt"" ingroups_file = ""../resources/genome/betula/sample_sets/birch.args"" outgroups_file = ""../resources/genome/betula/sample_sets/outgroups.args"" n_outgroups = 2 log = ""scratch/est-sfs.log"" out = ""scratch/1.polarized.vcf"" log_level = logging.INFO # configure logger logger = logging.getLogger() logger.setLevel(logging.DEBUG) # add file handler logger.addHandler(logging.FileHandler(log)) # add stream handler stream_handler = logging.StreamHandler(sys.stdout) stream_handler.setLevel(log_level) logger.addHandler(stream_handler) def get_called_bases(calls: np.ndarray) -> np.ndarray: """""" Get the called bases from a list of calls. :param calls: Array of calls. :return: Array of called bases. """""" return np.array([b for b in '/'.join(calls).replace('|', '/') if b in 'ACGT']) # load ingroup and outgroup samples ingroups = pd.read_csv(ingroups_file, header=None, index_col=False)[0].tolist() outgroups = pd.read_csv(outgroups_file, header=None, index_col=False)[0].tolist() vcf_reader = VCF(vcf_file) # Add AA info field to the header vcf_reader.add_info_to_header({ 'ID': 'AA', 'Number': '.', 'Type': 'Character', 'Description': 'Ancestral Allele'} ) vcf_reader.add_info_to_header({ 'ID': 'EST_SFS_output', 'Number': '.', 'Type': 'String', 'Description': 'EST-SFS probabilities'} ) vcf_reader.add_info_to_header({ 'ID': 'EST_SFS_input', 'Number': '.', 'Type': 'String', 'Description': 'EST-SFS input'} ) probs_reader = open(probs, 'r') data_reader = open(data, 'r') writer = Writer(out, vcf_reader) # get indices of ingroup and outgroup samples ingroup_mask = [sample in ingroups for sample in vcf_reader.samples] outgroup_mask = [sample in outgroups for sample in vcf_reader.samples] # write to data file for variant in tqdm(vcf_reader): # initialize info fields variant.INFO['AA'] = '.' variant.INFO['EST_SFS_output'] = '.' variant.INFO['EST_SFS_input'] = '.' if not variant.is_snp: # simply assign the ancestral allele to be the reference allele variant.INFO['AA'] = variant.REF else: # get base counts for outgroup samples outgroup_counts = get_called_bases(variant.gt_bases[outgroup_mask]) # Only do inference for bi-allelic SNPs for which # at least ``n_outgroups`` outgroup samples are called if len(variant.ALT) == 1 and len(outgroup_counts) >= n_outgroups: line = probs_reader.readline() # get probability of major allele prob_major_allele = float(line.split(' ')[2]) # restrict haplotypes to the non-outgroup birch samples bases = get_called_bases(variant.gt_bases[ingroup_mask]) major_allele = '.' ancestral_allele = '.' if len(bases) > 0: # determine major allele major_allele = Counter(bases).most_common()[0][0] # take the major allele to be the ancestral allele # if its probability is greater than equal 0.5 if prob_major_allele >= 0.5: ancestral_allele = major_allele else: # there are exactly two alleles ancestral_allele = variant.ALT[0] # add ancestral allele annotation to record variant.INFO['AA'] = ancestral_allele # read est-sfs input data est_input = data_reader.readline().replace('\n', '').replace(' ', '|').replace(',', ':') est_output = line.replace('\n', '').replace(' ', '|') # add additional information from est-sfs variant.INFO['EST_SFS_output'] = est_output variant.INFO['EST_SFS_input'] = est_input # only log if major allele, ancestral allele and reference allele are not the same if not (major_allele == ancestral_allele == variant.REF): logger.debug(dict( site=f""{variant.CHROM}:{variant.POS}"", ancestral_allele=ancestral_allele, major_allele=major_allele, reference=variant.REF, prob_major_allele=prob_major_allele, est_sfs_input=est_input, est_sfs_output=est_output )) writer.write_record(variant) # raise error if there are lines left from the EST-SFS output if next(probs_reader, None) is not None: raise AssertionError(""There are more lines in the EST-SFS output than there are variants in the VCF file."") # raise error if there are lines left from the EST-SFS input probs_reader.close() ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_annotator.py",".py","656","17","import fastdfe as fd ann = fd.Annotator( vcf=""http://ftp.1000genomes.ebi.ac.uk/vol1/ftp/data_collections/"" ""1000_genomes_project/release/20181203_biallelic_SNV/"" ""ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz"", fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"", gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", output='scratch/sapiens.chr21.degeneracy.vcf.gz', annotations=[fd.DegeneracyAnnotation()], aliases=dict(chr21=['21']), ) ann.annotate() ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/derive_sample_list.py",".py","635","25",""""""" Derive a with sample names separated by new lines. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2022-05-31"" import pandas as pd try: samples_file = snakemake.input[0] name_col = snakemake.params.get('name_col', 'name') sep = snakemake.params.get('sep', '\t') out = snakemake.output[0] except NameError: samples_file = ""results/sample_sets/hgdp/Maya.csv"" sep = snakemake.params.get('sep', '\t') name_col = 'sample' out = ""scratch/all.args"" samples = pd.read_csv(samples_file, sep=sep) samples[name_col].to_csv(out, header=False, index=False, sep=sep) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_manuscript_base_inference.py",".py","912","32","import fastdfe as fd # create inference object inf = fd.BaseInference( sfs_neut=fd.Spectrum([66200, 410, 120, 60, 42, 43, 52, 65, 0]), sfs_sel=fd.Spectrum([281937, 600, 180, 87, 51, 43, 49, 61, 0]), model=fd.GammaExpParametrization(), # the model to use n_runs=10, # number of optimization runs n_bootstraps=100, # number of bootstrap replicates do_bootstrap=True ) # run inference inf.run() import matplotlib.pyplot as plt # create subplots axs = plt.subplots(2, 2, figsize=(11, 7))[1].flatten() # plot results types = ['neutral', 'selected'] inf.plot_sfs_comparison(ax=axs[0], show=False, sfs_types=types) inf.plot_sfs_comparison(ax=axs[1], show=False, colors=['C1', 'C5']) inf.plot_inferred_parameters(ax=axs[2], show=False) inf.plot_discretized(ax=axs[3], show=False) plt.savefig('../reports/manuscript/figures/base_inference.high_resolution.jpg', dpi=1200) plt.show() pass","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/merge_spectra.py",".py","697","39",""""""" Merge several spectra. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-30"" try: import sys # necessary to import fastdfe locally sys.path.append('.') testing = False spectra_files = snakemake.input out = snakemake.output[0] except NameError: # testing testing = True spectra_files = [ ""results/sfs/pendula/16.csv"", ""results/sfs/pendula/15.csv"", ""results/sfs/pendula/14.csv"" ] out = ""scratch/out.txt"" import numpy as np from fastdfe import Spectra s = Spectra.from_file(spectra_files[0]) for f in spectra_files[1:]: s += Spectra.from_file(f) s.to_file(out) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/modify_config.py",".py","793","40",""""""" Modify an existing config file. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-13"" try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') testing = False config_file = snakemake.input[0] opts = snakemake.params.get('opts', {}) out = snakemake.output[0] except NameError: # testing testing = True config_file = 'results/configs/pendula_C_full_anc/config.yaml' opts = dict( do_bootstrap=True ) out = 'scratch/config_modified.yaml' import fastdfe as fd # create config object config = fd.Config.from_file(config_file) # merge config with new options config.data |= opts # save config to file config.to_file(out) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_tool_comparison.py",".py","1403","48",""""""" Visualize DFE inference results. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-02"" import numpy as np from matplotlib import pyplot as plt try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False input_fastdfe = snakemake.input.fastdfe input_polydfe = snakemake.input.polydfe out_discretized = snakemake.output.discretized out_params = snakemake.output.inferred_params except NameError: # testing testing = True input_fastdfe = ""results/fastdfe/pubescens_C_full_bootstrapped_100/serialized.json"" input_polydfe = ""results/polydfe/pubescens_C_full_bootstrapped_100/serialized.json"" out_discretized = ""scratch/comp_discretized.png"" out_params = ""scratch/comp_inferred_params.png"" from fastdfe import BaseInference, Inference from fastdfe.polydfe import PolyDFE inferences = [BaseInference.from_file(input_fastdfe), PolyDFE.from_file(input_polydfe)] Inference.plot_discretized(inferences, labels=['fastDFE', 'polyDFE'], show=testing, file=out_discretized, title='') Inference.plot_inferred_parameters(inferences, labels=['fastDFE', 'polyDFE'], show=False, file=None, title='') # use symlog scale for the inferred parameters plt.gca().set_yscale('symlog', linthresh=0.1) plt.savefig(out_params, bbox_inches='tight') if testing: plt.show() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/infer_shared_dfe.py",".py","1687","70",""""""" Perform joint inference. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-19"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False config_file = snakemake.input[0] out_summary = snakemake.output.summary out_serialized = snakemake.output.serialized except NameError: # testing testing = True # config_file = 'resources/configs/shared/covariates_dummy_example_1/config.yaml' # config_file = 'results/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml' config_file = '../resources/configs/shared/pendula_betula_tutorial/config.yaml' out_summary = ""scratch/summary.json"" out_serialized = ""scratch/serialized_shared.json"" import logging from fastdfe import Config, JointInference # set log level to debug logging.getLogger('fastdfe').setLevel(logging.INFO) # load config from file config = Config.from_file(config_file) # update config """"""config.update( model=DiscreteParametrization(), fixed_params={}, shared_params=[SharedParams(types='all', params=['S2'])], covariates=[], parallelize=False, n_runs=1 )"""""" # create from config inference = JointInference.from_config(config) # perform inference inference.run() # bootstrap # inference.bootstrap(10) # save object in serialized form inference.to_file(out_serialized) # save summary inference.get_summary().to_file(out_summary) if testing: inference.plot_discretized() inference.plot_continuous() inference.plot_inferred_parameters() inference.perform_lrt_covariates() inference.perform_lrt_shared() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_nested_model_comparison_hominidae.py",".py","770","34",""""""" Plot nested model comparison for the hominidae dataset. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-05-31"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False config = snakemake.params.config out = snakemake.output[0] except NameError: # testing testing = True config = ""results/fastdfe/hominidae/cov/eps.yaml"" out = ""scratch/joint_inference.yaml"" import fastdfe as fd import matplotlib.pyplot as plt inf = fd.JointInference.from_config_file(config) fig, axs = plt.subplots(len(inf.types), figsize=(10, 10)) for i, t in enumerate(inf.types): inf.marginal_inferences[t].plot_nested_models(ax=axs[i], show=False) plt.show() ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/check_stratified_spectra.py",".py","954","35",""""""" Testing the inference results against the results of polyDFE. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-31"" try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') testing = False input_fastdfe = snakemake.input.fastdfe input_polydfe = snakemake.input.polydfe except ModuleNotFoundError: # testing testing = True spectra_files = [ 'results/sfs/pendula/DegeneracyStratification/all.csv', 'results/sfs/pendula/DegeneracyStratification.BaseContextStratification/all.csv', 'results/sfs/pendula/DegeneracyStratification.BaseTransitionStratification/all.csv', 'results/sfs/pendula/DegeneracyStratification.BaseContextStratification.BaseTransitionStratification/all.csv' ] from fastdfe import Spectra spectra = [Spectra.from_file(s) for s in spectra_files] pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/create_seed_file_est_sfs.py",".py","281","17",""""""" Create a seed file for est-sfs. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2022-05-31"" try: out = snakemake.output[0] except NameError: # testing out = ""scratch/seed.txt"" # create seed file open(out, 'w').write('0') ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/combine_plots.py",".py","3897","153",""""""" Combine a bunch of images in a single plot. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2022-30-03"" import itertools import re from typing import List import matplotlib.image as mpimg import matplotlib.pyplot as plt import numpy as np try: testing = False files = snakemake.input n_cols = snakemake.params.get('n_cols', None) n_rows = snakemake.params.get('n_rows', None) titles = snakemake.params.get('titles', None) title_size_rel = snakemake.params.get('title_size_rel', 20) title_xoffset = snakemake.params.get('title_xoffset', None) pad = snakemake.params.get('pad', 0.1) figsize = snakemake.params.get('figsize', None) dpi = snakemake.params.get('dpi', 1000) out = snakemake.output[0] except NameError: # testing testing = True files = [ ""scratch/combined.png"", ""scratch/combined.png"", ""scratch/combined.png"", ""scratch/combined.png"", ] n_cols = None n_rows = None titles = None title_size_rel = 20 title_xoffset = None pad = 0.1 figsize = None dpi = 1000 out = ""scratch/combined2.png"" def get_index_common_start(strs: List[str]): """""" Return first position where given strings differ. :param strs: List of strings :return: Index """""" n = min(len(f) for f in strs) for i in range(n): if not all([strs[0][i] == strs[j][i] for j in range(1, len(strs))]): return i return n def determine_names_dep(files: List[str]) -> List[str]: """""" Determine names by removing common start and end substrings. :return: List of names """""" i = get_index_common_start(files) j = get_index_common_start([f[::-1] for f in files]) return [s[i:-j] for s in files] def determine_names(out: str) -> List[str]: """""" Determine names from output file path. :param out: Output file path :return: List of names """""" matches = re.finditer(""\[(.*?)\]"", out) elements = [match.groups()[0].split(',') for match in matches] prod = itertools.product(*elements) return [','.join(p) for p in prod] if titles is None: titles = determine_names(out) # infer names from input file names if names # inferred from output file name are too long if len(titles[0]) > 30: titles = determine_names_dep(files) if len(titles) != len(files): titles = [''] * len(files) # determine number of rows and columns if not specified n_files = len(files) if n_cols is None and n_rows is not None: # infer number of columns from number of rows n_cols = int(np.ceil(n_files / n_rows)) if n_rows is None and n_cols is not None: # infer number of rows from number of columns n_rows = int(np.ceil(n_files / n_cols)) if n_cols is None and n_rows is None: # display up to three files in one row only if n_files < 4: n_rows, n_cols = 1, n_files # take the number of rows and columns to # be the same for more than three files else: n = int(np.ceil(np.sqrt(n_files))) n_rows, n_cols = n, n # infer figsize if not set if figsize is None: img = mpimg.imread(files[0]) img_aspect = img.shape[1] / img.shape[0] scale = 3 # adjust as needed figsize = (scale * n_cols * img_aspect, scale * n_rows) fig, axs = plt.subplots(nrows=n_rows, ncols=n_cols, squeeze=False, figsize=figsize) axs = axs.flatten() for file, title, ax in zip(files, titles, axs): ax.imshow(mpimg.imread(file)) ax.set_title( title, fontdict=dict(fontsize=title_size_rel / n_cols), pad=0, **(dict(x=title_xoffset) if title_xoffset is not None else {}) ) # turn off axes [ax.axis(""off"") for ax in axs] fig.tight_layout(pad=pad) plt.savefig(out, dpi=dpi, bbox_inches='tight', pad_inches=pad) if testing: plt.show() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/prepare_config_hgdp.py",".py","888","42",""""""" Prepare fastDFE config for HGDP data. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-05-30"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False config_file = snakemake.input.config spectra_file = snakemake.input.spectra out = snakemake.output[0] except NameError: # testing testing = True config_file = '../resources/configs/HGDP/test.yaml' spectra_file = ""results/spectra/hgdp/1/opts.n.20/all.csv"" out = ""scratch/config.yaml"" from fastdfe import Config, Spectra # load config from file config = Config.from_file(config_file) # load spectra from file spectra = Spectra.from_file(spectra_file) # update config with spectra config.update( sfs_neut=spectra['neutral'], sfs_sel=spectra['selected'] ) # save config config.to_file(out) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_presentation_parser.py",".py","663","27",""""""" Example presentation parser """""" import fastdfe as fd basepath = ""https://github.com/Sendrowski/fastDFE/blob/dev/resources/genome/betula/"" p = fd.Parser( n=8, vcf=basepath + ""biallelic.with_outgroups.subset.50000.vcf.gz?raw=true"", fasta=basepath + ""genome.subset.1000.fasta.gz?raw=true"", gff=basepath + ""genome.gff.gz?raw=true"", annotations=[ fd.MaximumLikelihoodAncestralAnnotation(outgroups=[""ERR2103730""]), fd.DegeneracyAnnotation() ], stratifications=[fd.DegeneracyStratification()], target_site_counter=fd.TargetSiteCounter(n_target_sites=350000) ) spectra: fd.Spectra = p.parse() spectra.plot() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/prepare_config_hominidae.py",".py","1060","45",""""""" Prepare fastdfe config for SFS of the great apes study. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-05-31"" import pandas as pd try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False sfs_neutral = snakemake.input.neutral sfs_selected = snakemake.input.selected out = snakemake.output[0] except NameError: # testing testing = True type = 'human' sfs_neutral = f'../resources/SFS/hominidae/uSFS/{type}_4fold_all_sfs.txt' sfs_selected = f'../resources/SFS/hominidae/uSFS/{type}_0fold_all_sfs.txt' out = 'scratch/config.yaml' from fastdfe import Config, Spectra, Spectrum sfs = Spectra.from_spectra(dict( neutral=Spectrum(pd.read_csv(sfs_neutral, header=None).iloc[0].tolist()), selected=Spectrum(pd.read_csv(sfs_selected, header=None).iloc[0].tolist()) )) config = Config( sfs_neut=sfs['neutral'], sfs_sel=sfs['selected'], do_bootstrap=True, n_bootstraps=100 ) config.to_file(out) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/scatter_output_est_sfs.py",".py","1162","39",""""""" Scatter the output of est-sfs. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2022-05-31"" try: probs_in = snakemake.input.probs data_in = snakemake.input.data probs_out = snakemake.output.probs except NameError: # testing probs_in = ""results/test/remote/est-sfs/passed.biallelic.90.probs.all.txt"" data_in = [f""output/default/est-sfs/data/{n}.txt"" for n in range(1, 11)] probs_out = [f""scratch/est-sfs/probs/{n}.txt"" for n in range(1, 11)] with open(probs_in, 'r') as probs_all: # iterate over files for data_file, probs_file in zip(data_in, probs_out): # obtain number of lines to read and write line_count = sum(1 for line in open(data_file)) with open(probs_file, 'w') as out: # iterate over lines for i in range(line_count): line = probs_all.readline() # write to out file out.write(line) # raise error if there are lines left from the EST-SFS output if next(probs_all, None) is not None: raise AssertionError(""Unassigned sites left from EST-SFS output."") ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/check_overlapping_confidence_intervals.py",".py","1168","45",""""""" Testing the inference results against the results of polyDFE. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-16"" import numpy as np try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') testing = False input_fastdfe = snakemake.input.fastdfe input_polydfe = snakemake.input.polydfe except ModuleNotFoundError: # testing testing = True input_fastdfe = 'results/fastdfe/pendula_C_full_bootstrapped_100/serialized.json' input_polydfe = 'results/polydfe/pendula_C_full_bootstrapped_100/serialized.json' from fastdfe import BaseInference from fastdfe.polydfe import PolyDFE native = BaseInference.from_file(input_fastdfe) polydfe = PolyDFE.from_file(input_polydfe) res = dict( fastdfe=native.get_discretized(), polydfe=polydfe.get_discretized() ) # fastdfe.plot_discretized(title='fastDFE') # polydfe.plot_discretized(title='polyDFE') # check that the confidence interval overlap assert np.all(res['fastdfe'][1][0] < res['polydfe'][1][1]) assert np.all(res['polydfe'][1][0] < res['fastdfe'][1][1]) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/infer_joint_dfe.py",".py","1580","54",""""""" Infer the joint DFE from the SFS using fastDFE. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False config_file = snakemake.input[0] out_summary = snakemake.output.summary out_serialized = snakemake.output.serialized out_dfe = snakemake.output.get('dfe', None) out_spectra = snakemake.output.get('spectra', None) out_params = snakemake.output.get('params', None) except NameError: # testing testing = True # config_file = 'results/configs/example_1_C_full_anc/config.yaml' # config_file = 'results/configs/example_1_C_deleterious_anc_bootstrapped_100/config.yaml' # config_file = 'results/configs/pendula_C_full_anc_bootstrapped_100/config.yaml' config_file = 'scratch/bonobo.yaml' out_summary = ""scratch/summary.json"" out_serialized = ""scratch/serialized.json"" out_dfe = ""scratch/dfe.png"" out_spectra = ""scratch/spectra.png"" out_params = ""scratch/params.png"" from fastdfe import JointInference # create from config inference = JointInference.from_config_file(config_file) # perform inference inference.run() # save object in serialized form inference.to_file(out_serialized) # save summary inference.get_summary().to_file(out_summary) # plot results inference.plot_inferred_parameters(file=out_params, show=testing) inference.plot_sfs_comparison(file=out_spectra, show=testing) inference.plot_discretized(file=out_dfe, show=testing) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_selected_sfs.py",".py","1020","49",""""""" Visualize linearized DFE to SFS transformation. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-27"" import numpy as np from matplotlib import pyplot as plt try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') testing = False n = snakemake.params.n S = snakemake.params.S out = snakemake.output[0] except ModuleNotFoundError: # testing testing = True n = 7 S = -10 out = ""scratch/sfs_selected.png"" from fastdfe.discretization import Discretization from fastdfe import Spectrum d = Discretization( n=n, intervals_ben=(1e-15, 1000, 1000), intervals_del=(-1000000, -1e-15, 1000) ) k = np.arange(1, n) s = Spectrum.from_polymorphic(d.get_counts_semidominant_regularized(S * np.ones_like(k), k)) plt.figure(figsize=(2, 2)) s.plot(file=out, show=False, title=f""S = {S}"", ax=plt.gca()) plt.gca().set_ylim(bottom=0, top=1.25) plt.show() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_pendula_biased_gc.py",".py","1255","53","import numpy as np import fastdfe as fd p = fd.Parser( n=10, vcf=""../resources/genome/betula/all.vcf.gz"", stratifications=[fd.DegeneracyStratification(), fd.BaseTransitionStratification()] ) # parse SFS s: fd.Spectra = p.parse() s.plot(use_subplots=True) # extract neutral and selected SFS neut = s['neutral.*'].merge_groups(1) sel = s['selected.*'].merge_groups(1) """""" # create inference objects inferences = [fd.BaseInference( sfs_neut=neut[t], sfs_sel=sel[t], model=fd.DiscreteFractionalParametrization(np.array([-100000, -100, -10, -1, 1, 1000])), do_bootstrap=True ) for t in neut.types] # run inference [i.run() for i in inferences] fd.Inference.plot_discretized(inferences, labels=neut.types) """""" inf = fd.JointInference( sfs_neut=neut, sfs_sel=sel, shared_params=[fd.SharedParams(params=['S1', 'S4'], types='all')], model=fd.DiscreteFractionalParametrization(np.array([-100000, -100, -10, -1, 1, 1000])), covariates=[fd.Covariate( param='S3', values=dict((t, int(t not in ['A>T', 'T>A', 'G>C', 'C>G'])) for t in neut.types) )], fixed_params=dict(all=dict(eps=0)), do_bootstrap=True ) inf.run() inf.plot_discretized(kwargs_legend=dict(prop=dict(size=5))) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_sfs_demographies.py",".py","3144","64",""""""" Plot SFS from different demographic scenarios. """""" import sys # necessary to import fastdfe locally sys.path.append('.') from matplotlib import pyplot as plt import fastdfe as fd from matplotlib.ticker import MultipleLocator try: testing = False files_fd = snakemake.input.fastdfe files_slim = snakemake.input.slim labels = snakemake.params.labels out = snakemake.output[0] except NameError: # testing testing = True files_fd = [ ""results/sfs/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/constant/unfolded/sfs.csv"", ""results/sfs/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/expansion_4/unfolded/sfs.csv"", ""results/sfs/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/reduction_4/unfolded/sfs.csv"", ""results/sfs/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/bottleneck_20/unfolded/sfs.csv"", ""results/sfs/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/substructure_0.0001/unfolded/sfs.csv"", ""results/sfs/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/dominance_0.2/unfolded/sfs.semidominant.csv"" ] files_slim = [ ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/constant/unfolded/sfs.csv"", ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/expansion_4/unfolded/sfs.csv"", ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/reduction_4/unfolded/sfs.csv"", ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/bottleneck_20/unfolded/sfs.csv"", ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/substructure_0.0001/unfolded/sfs.csv"", ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/dominance_0.2/unfolded/sfs.csv"" ] labels = [""constant"", ""expansion"", ""reduction"", ""bottleneck"", ""substructure"", ""recessiveness""] out = ""scratch/sfs_demographies.png"" fig, ax = plt.subplots(3, 2, figsize=(7, 4.5), sharex=True) ax = ax.flatten() for i in range(len(files_fd)): sfs = fd.Spectra.from_spectra(dict( SLiM=fd.Spectra.from_file(files_slim[i])['selected'], fastDFE=fd.Spectrum.from_file(files_fd[i]), )) sfs.plot(ax=ax[i], show=False) ax[i].set_xlabel("""", fontsize=6) ax[i].set_title(labels[i], fontsize=14) if labels[i] == ""expansion"": ax[i].yaxis.set_major_locator(MultipleLocator(20000)) ax[i].ticklabel_format(axis=""y"", style=""sci"", scilimits=(0, 0)) fig.tight_layout(pad=0.7) if testing: plt.show() fig.savefig(out, dpi=300) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/create_bootstrap_polydfe.py",".py","745","36",""""""" Create config file for bootstrapped samples to be run with polyDFE. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-10"" try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') testing = False input = snakemake.input[0] out = snakemake.output[0] except NameError: # testing testing = True input = 'scratch/polydfe_wrapper.json' out = 'scratch/polydfe_config.yaml' from fastdfe.polydfe import PolyDFE # restore polyDFE wrapper from file polydfe = PolyDFE.from_file(input) # create bootstrap config = polydfe.create_bootstrap() # save polyDFE wrapper object to file config.to_file(out) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/import_fastdfe.py",".py","20","1","import fastdfe as fd","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_dfe_collage.py",".py","4334","150",""""""" Combine DFE plots. """""" import re import sys from pathlib import Path import numpy as np # necessary to import fastdfe locally sys.path.append('.') import matplotlib.pyplot as plt import fastdfe as fd try: testing = False files_sfs = snakemake.input.slim files_summary = snakemake.input.fastdfe labels = snakemake.params.labels out = snakemake.output[0] except NameError: testing = True files_sfs = [ ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.3/s_d=3e-1/p_b=0.00/n=20/constant/unfolded/sfs.csv"", ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/constant/unfolded/sfs.csv"", ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-2/b=0.1/s_d=3e-1/p_b=0.01/n=20/constant/unfolded/sfs.csv"", ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.3/s_d=3e-2/p_b=0.05/n=20/constant/unfolded/sfs.csv"", ] files_summary = [ Path(f).with_name(""summary.json"") for f in files_sfs ] labels = [ ""Strongly deleterious"", ""Weakly deleterious"", ""Rare beneficial"", ""Frequent beneficial"", ] out = ""scratch/dfe_collage.png"" plt.rcParams['xtick.labelsize'] = 8 def extract_params(path: str) -> dict: """""" Extract simulation parameters from path string. """""" params = {} for key in [""s_d"", ""s_b"", ""b"", ""p_b"", ""N"", ""mu""]: m = re.search(rf""/{key}=([0-9.eE+-]+)"", path) if m: params[key] = float(m.group(1)) return params def format_params(params_slim: dict, params_fd: dict) -> tuple[dict, dict]: """""" Format parameters for display. """""" trailing = dict( p_b=2, b=2, S_b=1, S_d=0, N_e=0 ) for key in params_slim: params_slim[key] = f""{params_slim[key]:.{trailing[key]}f}"" if key in params_fd: params_fd[key] = f""{params_fd[key]:.{trailing[key]}f}"" while params_slim[key].endswith(""0"") and params_fd[key].endswith(""0""): params_slim[key] = params_slim[key][:-1] params_fd[key] = params_fd[key][:-1] params_slim[key] = params_slim[key].rstrip(""."") params_fd[key] = params_fd[key].rstrip(""."") return ( ','.join( [f""${k}$={' ' * (len(params_fd[k]) - len(v)) if k in params_fd else ''}{v}"" for k, v in params_slim.items()]), ','.join([f""${k}$={' ' * (len(params_slim[k]) - len(v)) if k in params_slim else ''}{v}"" for k, v in params_fd.items()]), ) fig, ax = plt.subplots(2, 2, figsize=(7, 4), sharex=True, sharey=True) ax = ax.flatten() for i, (f_sfs, f_sum) in enumerate(zip(files_sfs, files_summary)): spectra = fd.Spectra.from_file(f_sfs) result = fd.InferenceResult.from_file(f_sum) params = extract_params(f_sfs) Ne = spectra[""neutral""].theta / (4 * params[""mu""]) dfe_slim = fd.DFE(dict( S_d=-4 * Ne * params[""s_d""], b=params[""b""], p_b=params[""p_b""], S_b=4 * Ne * params[""s_b""], N_e=Ne )) params_slim = dfe_slim.params.copy() if params_slim[""p_b""] == 0: params_slim.pop(""S_b"") params_fd = {k: v for k, v in result.dfe.params.items() if k in params_slim} params_slim, params_fd = format_params(params_slim, params_fd) fd.DFE.plot_many( [dfe_slim, result.dfe], labels=[ f""SLiM ({params_slim})"", f""fastDFE({params_fd})"" ], intervals=[-np.inf, -100, -10, -1, 1, np.inf], ax=ax[i], show=False, title=labels[i], ) leg = ax[i].legend(loc='upper left', prop={""family"": ""monospace"", ""size"": 6.3}) for h in leg.legend_handles: h.set_hatch(None) ax[i].set_ylim(0, 1) # remove hatch patterns from bars for container in ax[i].containers: if container is not None: for patch in container: if patch is not None and hasattr(patch, ""set_hatch""): patch.set_hatch("""") fig.tight_layout(pad=0.05) ax[1].set_ylabel("""") ax[3].set_ylabel("""") ax[0].set_xlabel("""") ax[1].set_xlabel("""") fig.savefig(out, dpi=300) if testing: plt.show() ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/parse_polarize_vcf_betula.py",".py","1665","73",""""""" Parse betula VCF. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-08-06"" import pandas as pd try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False vcf_file = snakemake.input.vcf fasta = snakemake.input.ref gff = snakemake.input.gff samples_file = snakemake.input.samples max_sites = snakemake.params.max_sites.get(""max_sites"", np.inf) n = snakemake.params.n out_csv = snakemake.output.csv out_png = snakemake.output.png except NameError: # testing testing = True vcf_file = '../resources/genome/betula/all.with_outgroups.vcf.gz' fasta = '../resources/genome/betula/genome.fasta' gff = '../resources/genome/betula/genome.gff.gz' samples_file = '../resources/genome/betula/sample_sets/pendula.args' max_sites = 100000 n = 10 out_csv = ""scratch/sfs_parsed.csv"" out_png = ""scratch/sfs_parsed.png"" import fastdfe as fd ingroups = pd.read_csv(samples_file).iloc[:, 0].tolist() p = fd.Parser( vcf=vcf_file, fasta=fasta, gff=gff, n=n, annotations=[ fd.DegeneracyAnnotation(), fd.MaximumLikelihoodAncestralAnnotation( n_ingroups=20, ingroups=ingroups, outgroups=[""ERR2103730""], max_sites=10000 ) ], filtrations=[ fd.CodingSequenceFiltration(), fd.PolyAllelicFiltration(), ], stratifications=[fd.DegeneracyStratification()], include_samples=ingroups, max_sites=max_sites ) sfs = p.parse() sfs.plot(show=testing, file=out_png) sfs.to_file(out_csv) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/gather_input_est_sfs.py",".py","507","21",""""""" Gather the scattered input for est-sfs. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2022-05-31"" try: data_files = snakemake.input out = snakemake.output[0] except NameError: # testing data_files = [f""output/default/est-sfs/data/{n}.txt"" for n in range(1, 10)] out = ""scratch/data.combined.txt"" # combine contents of all data files with open(out, 'w') as f: for file in data_files: f.writelines(open(file, 'r').readlines()) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_presentation_joint_inference.py",".py","712","32","import matplotlib.pyplot as plt import fastdfe as fd spectra = fd.Spectra.from_file( ""../resources/SFS/betula/spectra.20.csv"" ) inf = fd.JointInference( sfs_neut=spectra['neutral.*'].merge_groups(1), sfs_sel=spectra['selected.*'].merge_groups(1), do_bootstrap=True, model=fd.DiscreteFractionalParametrization(), shared_params=[fd.SharedParams(params=['S1', 'S2', 'S4'], types='all')] ) inf.run() fig = plt.figure(figsize=(4, 3)) fd.Inference.plot_inferred_parameters( ax=plt.gca(), inferences=list(inf.joint_inferences.values()), labels=['type 1', 'type 2'], scale='lin', show=False ) plt.gca().set_xticklabels([f""$p{i}$"" for i in range(1, 8)]) plt.show() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dfe_slim_fastdfe.py",".py","2771","104",""""""" Infer the DFE from spectra generated by SLiM. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2024-02-26"" import sys # necessary to import fastdfe locally sys.path.append('.') import fastdfe as fd import numpy as np from matplotlib import pyplot as plt try: testing = False sfs_file = snakemake.input[0] full_dfe = snakemake.params.get('full_dfe') h = snakemake.params.get('h', 0.5) mu = snakemake.params.mu demography = snakemake.params.demography out_summary = snakemake.output.summary out_serialized = snakemake.output.serialized out_dfe = snakemake.output.get('dfe', None) out_model_fit = snakemake.output.get('model_fit', None) out_spectra = snakemake.output.get('spectra', None) out_params = snakemake.output.get('params', None) except NameError: # testing testing = True sfs_file = 'results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-9/b=5/s_d=3e-1/p_b=0/n=100/folded/sfs.csv' full_dfe = True h = 0.5 mu = 1e-8 demography = ""constant"" out_summary = ""scratch/summary.json"" out_serialized = ""scratch/serialized.json"" out_dfe = ""scratch/dfe.png"" out_model_fit = ""scratch/model_fit.png"" out_spectra = ""scratch/spectra.png"" out_params = ""scratch/params.png"" s = fd.Spectra.from_file(sfs_file) theta = s['neutral'].theta Ne = theta / (4 * mu) if demography == 'dominance_function': h_callback = lambda k, S: np.maximum(0.4 * np.exp(-h * abs(S / (4 * Ne))), 0.1) else: h_callback = lambda h, S: np.full_like(S, h) # create from config inf = fd.BaseInference( sfs_neut=s['neutral'], sfs_sel=s['selected'], do_bootstrap=True, parallelize=True, bounds=dict(h=(0, h)), n_runs=100, h_callback=h_callback, fixed_params=dict(all=dict(eps=0, h=h) | (dict(p_b=0, S_b=1) if not full_dfe else {})) ) # perform inference inf.run() # save object in serialized form inf.to_file(out_serialized) # save summary inf.get_summary().to_file(out_summary) params = {k: v for k, v in inf.bootstraps.select_dtypes('number').median().to_dict().items()} params_str = dict( S_d=f""{params['S_d']:.0f}"", b=f""{params['b']:.2f}"", p_b=f""{params['p_b']:.2f}"", S_b=f""{params['S_b']:.1f}"" ) # plot results inf.plot_inferred_parameters(file=out_params, show=testing) inf.plot_sfs_comparison(file=out_model_fit, show=testing) fig, ax = plt.subplots(figsize=(4.5, 2.2)) plt.rcParams['axes.titlesize'] = 11 inf.plot_discretized( file=out_dfe, show=testing, title=""Inferred DFE\n"" + "", "".join([f""${k}$={v}"" for k, v in params_str.items()]), intervals=[-np.inf, -100, -10, -1, 1, np.inf], ax=ax ) s.plot(file=out_spectra, show=testing) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/scatter_lines.jl",".jl","694","27",""""""" Scatter the lines of a file into several files by writing the jth line into the `jth % n_files` files. """""" if @isdefined snakemake input = snakemake.input[1] n_chunks = snakemake.params[""n_chunks""] i = snakemake.params[""i""] out = snakemake.output[1] else input = ""results/test/remote/est-sfs/passed.biallelic.90.data.all.txt"" n_chunks = 4 i = 3 out = ""scratch/$i.data.txt"" end open(input) do f_in open(out, ""w"") do f_out for (j, line) in enumerate(eachline(f_in)) # only write every 'j % n == i % n'th line if j % n_chunks == i % n_chunks write(f_out, line * ""\n"") end end end end","Julia" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_dfe_slim.py",".py","1635","72",""""""" Plot the distribution of selection coefficients from SLiM simulations. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2024-03-03"" import numpy as np from matplotlib import pyplot as plt try: import sys # necessary to import fastdfe locally sys.path.append('.') testing = False spectra_file = snakemake.input[0] p_b = snakemake.params.p_b s_b = snakemake.params.s_b s_d = snakemake.params.s_d b = snakemake.params.b mu = snakemake.params.mu out = snakemake.output[0] except NameError: # testing testing = True spectra_file = ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-9/b=5/s_d=3e-1/p_b=0/n=20/unfolded/sfs.csv"" p_b = 0.4 s_b = 18 s_d = 67 b = 7 mu = 1e-9 out = ""scratch/slim_dfe.png"" import fastdfe as fd spectra = fd.Spectra.from_file(spectra_file) Ne = spectra['neutral'].theta / (4 * mu) params = dict( S_d=-4 * Ne * s_d, b=b, p_b=p_b, S_b=4 * Ne * s_b, N_e=Ne ) params_str = dict( S_d=f""{params['S_d']:.0f}"", b=f""{params['b']:.2f}"", p_b=f""{params['p_b']:.2f}"", S_b=f""{params['S_b']:.1f}"", N_e=f""{params['N_e']:.0f}"" ) fig, ax = plt.subplots(figsize=(4.5, 2.2)) plt.rcParams['axes.titlesize'] = 11 fd.GammaExpParametrization().plot( params=dict(S_d=min(params['S_d'], -1e-16), S_b=max(params['S_b'], 1e-16), b=b, p_b=p_b), intervals=[-np.inf, -100, -10, -1, 1, np.inf], title='Simulated DFE\n' + "", "".join([f""${k}$={v}"" for k, v in params_str.items()]), show=testing, file=out, ax=ax ) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_parser_pendula.py",".py","673","28","import fastdfe as fd basepath = ""../resources/genome/betula/"" # instantiate parser p = fd.Parser( n=8, # SFS sample size vcf=(basepath + ""all.with_outgroups.vcf.gz""), fasta=basepath + ""genome.subset.1000.fasta.gz"", gff=basepath + ""genome.gff.gz"", annotations=[ fd.DegeneracyAnnotation(), # determine degeneracy fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], # use one outgroup n_ingroups=20, # subsample size max_sites=50000 ) ], stratifications=[fd.DegeneracyStratification()] ) # obtain SFS spectra: fd.Spectra = p.parse() spectra.plot(title=""SFS"") pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/annotate_synonymy.py",".py","1302","51",""""""" Annotate synonymy of variants in a VCF file. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-05-12"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False vcf_file = snakemake.input.vcf fasta = snakemake.input.ref gff = snakemake.input.gff aliases = snakemake.params.aliases out = snakemake.output[0] except ModuleNotFoundError: # testing testing = True vcf_file = ""https://ftp.1000genomes.ebi.ac.uk/vol1/ftp/data_collections/1000_genomes_project/release/"" \ ""20181203_biallelic_SNV/ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz"" fasta = ""https://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" \ ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"" gff = ""https://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" \ ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"" aliases = dict(chr21=['21']) out = 'scratch/synonymy.vcf' import fastdfe as fd fd.logger.setLevel('DEBUG') # initialize annotator ann = fd.Annotator( vcf=vcf_file, fasta=fasta, gff=gff, aliases=aliases, output=out, annotations=[fd.SynonymyAnnotation()], ) # run annotator ann.annotate() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_parametrization.py",".py","1512","72",""""""" Visualize a DFE. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-06"" import numpy as np from matplotlib import pyplot as plt try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') testing = False input = snakemake.input[0] postprocessing_source = '../resources/polydfe/postprocessing/script.R' out = snakemake.output[0] except ModuleNotFoundError: # testing testing = True n = 20 params = { 'S_d': -1000, 'b': 0.1, 'p_b': 0.1, 'S_b': 0.1 } out = ""scratch/parametrization.png"" import fastdfe as fd p = fd.GammaExpParametrization() d = fd.Discretization( n=n, intervals_ben=(1e-15, 1000, 1000), intervals_del=(-1000000, -1e-15, 1000) ) d1 = p.get_pdf(**params)(d.s) d2 = p._discretize(params, d.bins) / d.interval_sizes plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='midpoints') plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='exact') plt.legend() ax = plt.gca() xticks = ax.get_xticks() labels = [""{:.0e}"".format(d.s[int(l)]) if 0 <= int(l) < d.n_intervals else None for l in xticks] ax.set_xticklabels(labels) plt.title(params) plt.margins(x=0) plt.xlabel('S') plt.ylabel('f(S)') plt.gcf().set_size_inches(np.array([1, 0.35]) * np.array(plt.rcParams[""figure.figsize""])) plt.savefig(out, dpi=200, bbox_inches='tight', pad_inches=0.1) if testing: plt.show() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dfe_covariates.py",".py","2378","87",""""""" Infer the joint DFE from the SFS using fastDFE. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False config_file = snakemake.input[0] kwargs_legend = snakemake.params.get('legend', {}) figsize = snakemake.params.get('figsize', (20, 10)) out_summary = snakemake.output.summary out_serialized = snakemake.output.serialized out_dfe = snakemake.output.get('dfe', None) out_covariates = snakemake.output.get('covariates', None) out_spectra = snakemake.output.get('spectra', None) out_params = snakemake.output.get('params', None) except NameError: # testing testing = True # config_file = 'results/configs/example_1_C_full_anc/config.yaml' # config_file = 'results/configs/example_1_C_deleterious_anc_bootstrapped_100/config.yaml' # config_file = 'results/configs/pendula_C_full_anc_bootstrapped_100/config.yaml' config_file = 'results/fastdfe/arabidopsis/cov/S_d.mean.rsa.10.20.yaml' kwargs_legend = {} figsize = (20, 10) out_summary = ""scratch/summary.json"" out_serialized = ""scratch/serialized.json"" out_dfe = ""scratch/dfe.png"" out_covariates = ""scratch/covariates.png"" out_spectra = ""scratch/spectra.png"" out_params = ""scratch/params.png"" import fastdfe as fd # create from config inf = fd.JointInference.from_config_file(config_file) # perform inference inf.run() # save object in serialized form inf.to_file(out_serialized) # save summary inf.get_summary().to_file(out_summary) p = f""p: {inf.perform_lrt_covariates():.2e}"" c0 = f""c0: ({inf.bootstraps.mean()[inf.types[0] + '.c0']:.2e}, {inf.bootstraps.var()[inf.types[0] + '.c0']:.2e})"" # plot results inf.plot_inferred_parameters( file=out_params, show=testing, title=f'inferred parameters, {p}, {c0}', kwargs_legend=kwargs_legend ) inf.plot_sfs_comparison( use_subplots=True, file=out_spectra, show=testing, title=f'SFS comparison, {p}, {c0}', kwargs_legend=kwargs_legend ) inf.plot_discretized( file=out_dfe, show=testing, title=f'DFE comparison, {p}, {c0}', kwargs_legend=kwargs_legend ) inf.plot_covariate( file=out_covariates, show=testing, title=f'covariate comparison, {p}, {c0}' ) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/simulate_sfs.py",".py","2654","102",""""""" Simulate the selected SFS using fastDFE. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2024-12-25"" import numpy as np import re from matplotlib import pyplot as plt try: import sys # necessary to import fastdfe locally sys.path.append('.') testing = False sfs_file = snakemake.input[0] s_b = snakemake.params.s_b b = snakemake.params.b s_d = snakemake.params.s_d p_b = snakemake.params.p_b n = snakemake.params.n h = snakemake.params.h mu = snakemake.params.mu demography = snakemake.params.demography parallelize = snakemake.params.get('parallelize', False) title = snakemake.params.title out_sfs = snakemake.output.sfs out_comparison = snakemake.output.comp except NameError: def get_param(string, param): return float(re.search(rf""{param}=([\d.e+-]+)"", string).group(1)) # testing testing = True sfs_file = 'results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.3/s_d=3e-1/p_b=0.00/n=20/constant/unfolded/sfs.csv' s_b = get_param(sfs_file, 's_b') b = get_param(sfs_file, '/b') s_d = get_param(sfs_file, 's_d') p_b = get_param(sfs_file, 'p_b') n = 20 h = float(re.search(r""dominance_function_([\d.]+)"", sfs_file).group(1)) if ""dominance"" in sfs_file else 0.5 mu = 1e-8 demography = ""constant"" parallelize = True title = f""$s_b$={s_b:.0e}, $b$={b}, $s_d$={s_d:.0e}, $p_b$={p_b}"" out_sfs = ""scratch/sfs.csv"" out_comparison = ""scratch/comp.png"" import fastdfe as fd spectra = fd.Spectra.from_file(sfs_file) theta = spectra['neutral'].theta Ne = theta / (4 * mu) model = fd.GammaExpParametrization() model.bounds['S_b'] = (1e-10, 100) model.bounds['S_d'] = (-1e6, -1e-2) if demography == 'dominance_function': h_callback = lambda k, S: np.maximum(0.4 * np.exp(-h * abs(S / (4 * Ne))), 0.1) #h_callback = lambda k, S: np.full_like(S, 0.7) else: h_callback = lambda h, S: np.full_like(S, h) sim = fd.Simulation( params=dict( S_b=4 * Ne * s_b, b=b, S_d=-4 * Ne * s_d, p_b=p_b, h=h, ), intervals_del=(-1.0e+8, -1.0e-5, 100), intervals_ben=(1.0e-5, 1.0e4, 100), h_callback=h_callback, sfs_neut=spectra['neutral'], model=model, parallelize=parallelize, ) sfs_sel = sim.run() sfs_sel.to_file(out_sfs) fig, ax = plt.subplots(figsize=np.array([4, 3]) * 0.9) comp = fd.Spectra(dict( slim=spectra['selected'], fastdfe=sfs_sel )) plt.rcParams['axes.titlesize'] = 11 comp.plot(file=out_comparison, show=testing, title=title, ax=ax) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/setup_config_est_sfs.py",".py","589","26",""""""" Set up the config for est-sfs. We use the substitution model (1) recommended by the paper. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2022-05-31"" try: out = snakemake.output[0] config = snakemake.config max_sites = snakemake.config['max_sites'] except NameError: # testing out = ""scratch/est-sfs.config"" config = { 'n_outgroup': 2, 'model': 1, 'nrandom': 5 } with open(out, 'w') as f: for param in [""n_outgroup"", ""model"", 'nrandom']: f.write(f""{param} {config[param]}\n"") ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/create_config.py",".py","1114","48",""""""" Create a config file which can be used both to run polyDFE and the new inference tool. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-07"" try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') testing = False spectra_file = snakemake.input.sfs init_file = snakemake.input.init do_bootstrap = snakemake.params.get('do_bootstrap', None) model = snakemake.params.get('model', 'GammaExpParametrization') out = snakemake.output[0] except ModuleNotFoundError: # testing testing = True spectra_file = 'resources/polydfe/pubescens/spectra/sfs.txt' init_file = 'resources/polydfe/init/D.full_init' do_bootstrap = None model = 'DiscreteParametrization' out = 'scratch/config.yaml' import fastdfe as fd # create config object config = fd.Config( polydfe_spectra_config=spectra_file, polydfe_init_file=init_file, do_bootstrap=do_bootstrap, n_bootstraps=10, model=model ) # save config to file config.to_file(out) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/parse_vcf_betula.py",".py","1325","60",""""""" Parse betula VCF. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-08-06"" import pandas as pd try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False vcf_file = snakemake.input.vcf fasta = snakemake.input.ref gff = snakemake.input.gff samples_file = snakemake.input.samples n = snakemake.params.n out_csv = snakemake.output.csv out_png = snakemake.output.png except NameError: # testing testing = True vcf_file = '../resources/genome/betula/all.polarized.vcf.gz' fasta = '../resources/genome/betula/genome.fasta' gff = '../resources/genome/betula/genome.gff.gz' samples_file = '../resources/genome/betula/sample_sets/pendula.args' n = 10 out_csv = ""scratch/sfs_parsed.csv"" out_png = ""scratch/sfs_parsed.png"" import fastdfe as fd p = fd.Parser( vcf=vcf_file, fasta=fasta, gff=gff, n=n, annotations=[fd.DegeneracyAnnotation()], filtrations=[ fd.CodingSequenceFiltration(), fd.PolyAllelicFiltration(), ], stratifications=[fd.DegeneracyStratification()], include_samples=pd.read_csv(samples_file).iloc[:, 0].tolist() ) sfs = p.parse() sfs.plot(show=testing, file=out_png) sfs.to_file(out_csv) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/filter_sample_set.py",".py","722","27",""""""" Filter the given sample set to satisfy `samples[filter_col] == filter_val`. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2022-05-31"" import pandas as pd try: samples_file = snakemake.input[0] filter_col = snakemake.params.get('filter_col', 'species') filter_val = snakemake.params.filter_val sep = snakemake.params.get('sep', '\t') out = snakemake.output[0] except NameError: samples_file = ""resources/quercus/ingroups.csv"" filter_col = 'species' filter_val = 'Qa' sep = '\t' out = ""scratch/acutissima.csv"" samples = pd.read_csv(samples_file, sep=sep) samples[samples[filter_col] == filter_val].to_csv(out, index=False, sep=sep) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dfe_from_spectra.py",".py","1088","57",""""""" Infer the DFE from the SFS. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-05-25"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False spectra_file = snakemake.input.spectra out_serialized = snakemake.output.serialized except NameError: # testing testing = True spectra_file = ""scratch/parse_spectra_from_url.spectra.csv"" out_serialized = ""scratch/infer_dfe_from_url.serialized.json"" from fastdfe import BaseInference, Spectra # parse spectra and fold spectra = Spectra.from_file(spectra_file) # fold spectra spectra = spectra.fold() # plot spectra spectra.plot() # create inference inf = BaseInference( sfs_neut=spectra['neutral'], sfs_sel=spectra['selected'], n_bootstraps=100, do_bootstrap=True, n_runs=30 ) # perform inference inf.run() # save object in serialized form inf.to_file(out_serialized) # plot data if testing: inf.plot_discretized() inf.plot_inferred_parameters() inf.plot_sfs_comparison() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/create_config_from_spectra.py",".py","1014","42",""""""" Create a config file given a spectra object. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-07"" try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') testing = False spectra_file = snakemake.input.spectra init_file = snakemake.input.init levels = snakemake.params.get('levels', [1]) out = snakemake.output[0] except ModuleNotFoundError: # testing testing = True spectra_file = 'results/spectra/pendula.pubescens.example_1.example_2.example_3.csv' init_file = 'resources/polydfe/init/C.full_anc_init' levels = [1] out = 'scratch/config_merged.yaml' from fastdfe import Spectra, Config spectra = Spectra.from_file(spectra_file) config = Config( sfs_neut=spectra[['sfs_neut.*']].merge_groups(levels), sfs_sel=spectra[['sfs_sel.*']].merge_groups(levels), polydfe_init_file=init_file, n_bootstraps=2 ) config.to_file(out) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/compare_speed_parallelization.py",".py","591","23","import sys sys.path.append('.') import fastdfe as fd inf = fd.BaseInference( sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), fixed_params=dict(all=dict(h=0.5)), parallelize=False ) inf.run() inf = fd.BaseInference( sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), fixed_params=dict(all=dict(h=0.5)), parallelize=True ) inf.run() ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_nested_likelihoods.py",".py","707","35",""""""" Compare different model type using likelihood ratio tests. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-16"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False input = snakemake.input[0] out = snakemake.output[0] except NameError: # testing testing = True input = ""results/fastdfe/pendula_C_full_bootstrapped_100/serialized.json"" out = ""scratch/lrt.png"" import fastdfe as fd fd.logger.setLevel(logging.INFO) # load object from file inference = fd.BaseInference.from_file(input) # compare nested models inference.plot_nested_models(file=out, show=testing) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dfe_polydfe.py",".py","1522","59",""""""" Run polyDFE. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-06"" import os try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') execute = shell testing = False config_file = snakemake.input[0] bin = snakemake.params.get('bin', '../resources/polydfe/bin/polyDFE-2.0-macOS-64-bit') out = snakemake.output.polydfe out_summary = snakemake.output.summary out_serialized = snakemake.output.serialized out_dfe = snakemake.output.get('dfe', None) out_params = snakemake.output.get('params', None) except ModuleNotFoundError: # testing testing = True execute = None config_file = 'results/configs/pendula_D_full/config.yaml' bin = '../resources/polydfe/bin/polyDFE-2.0-macOS-64-bit' out = 'scratch/polydfe_out.txt' out_summary = 'scratch/polydfe_out.json' out_serialized = 'scratch/polydfe_serialized.json' out_dfe = ""scratch/dfe.png"" out_params = ""scratch/params.png"" from fastdfe import Config from fastdfe.polydfe import PolyDFE config = Config.from_file(config_file) polydfe = PolyDFE(config) summary = polydfe.run(out, binary=bin, wd=os.getcwd(), execute=execute) # save summary to file summary.to_file(out_summary) # save polyDFE wrapper object to file polydfe.to_file(out_serialized) polydfe.plot_inferred_parameters(file=out_params, show=testing) polydfe.plot_discretized(file=out_dfe, show=testing) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/merge_spectra_hominidae.py",".py","1516","60",""""""" Merge spectra from the great apes study. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-05-31"" import pandas as pd try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False types = snakemake.params.types param = snakemake.params.param sfs_neutral = snakemake.input.neutral sfs_selected = snakemake.input.selected out = snakemake.output[0] except NameError: # testing testing = True types = [ 'bonobo', 'bornean_orang', 'central_chimp', 'eastern_chimp', 'human', 'NC_chimp', 'sumatran_orang', 'western_chimp', 'western_lowland_gorilla' ] param = 'S_d' sfs_neutral = [f'../resources/SFS/hominidae/uSFS/{t}_4fold_all_sfs.txt' for t in types] sfs_selected = [f'../resources/SFS/hominidae/uSFS/{t}_0fold_all_sfs.txt' for t in types] out = ""scratch/joint_inference.yaml"" import fastdfe as fd def get_sfs(file: str) -> fd.Spectrum: """""" Get SFS from file. :param file: The file to read the SFS from. :return: The SFS. """""" return fd.Spectrum(pd.read_csv(file, header=None).iloc[0].tolist()) neutral = fd.Spectra.from_spectra(dict((t, get_sfs(sfs_neutral[i])) for i, t in enumerate(types))) selected = fd.Spectra.from_spectra(dict((t, get_sfs(sfs_selected[i])) for i, t in enumerate(types))) spectra = neutral.prefix('neutral') + selected.prefix('selected') pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/gather_lines.jl",".jl","964","38",""""""" Merge the lines of several files into one file. """""" if @isdefined snakemake input = snakemake.input out = snakemake.output[1] else input = Dict(i => ""results/test/remote/est-sfs/passed.biallelic.90.probs."" * string(i) * "".4.txt"" for i in 1:4) out = ""scratch/probs.txt"" end # iterate over all files and write one line per file for each iteration function gather_lines(f_chunks) open(out, ""w"") do f_out while true # iterate over file handles and write lines for f in f_chunks line = readline(f) if length(line) > 0 write(f_out, line * ""\n"") else return end end end end end # initialize file handles # make sure they are ordered correctly f_chunks = [open(f) for f in [input[i] for i in 1:length(input)]] gather_lines(f_chunks) # close file handles [close(f) for f in f_chunks]","Julia" "Allele","Sendrowski/fastDFE","snakemake/scripts/plot_pca.py",".py","7731","244",""""""" Create a PCA plot. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2023-05-27"" import warnings import matplotlib.pyplot as plt import numpy as np import pandas as pd import seaborn as sns from pandas_plink import read_plink from sklearn.decomposition import PCA from sklearn.impute import SimpleImputer try: testing = False bed = snakemake.input.bed samples_file = snakemake.input.samples name_col = snakemake.params.get('name_col', 'name') add_names = snakemake.params.get('add_names', False) marker_size = snakemake.params.get('marker_size', 20) label_col = snakemake.params.get('label_col', None) label_dict = snakemake.params.get('label_dict', None) legend_title = snakemake.params.get('legend_title', None) legend_outside = snakemake.params.get('legend_outside', True) legend = snakemake.params.get('add_legend', True) legend_n_cols = snakemake.params.get('legend_n_cols', 3) legend_size = snakemake.params.get('legend_size', 6) subsample_size = snakemake.params.get('subsample_size', 0) seed = snakemake.params.get('seed', 0) cbar = snakemake.params.get('cbar', True) cmap = snakemake.params.get('cmap', None) out = snakemake.output[0] except NameError: # testing testing = True bed = 'results/plink/hgdp/21.bed' samples_file = 'results/sample_sets/hgdp/French.csv' name_col = 'sample' add_names = False marker_size = 20 label_col = 'population' label_dict = {} legend_title = None legend = True legend_size = 6 legend_n_cols = 3 cbar = False legend_outside = True subsample_size = 10000 seed = 0 cmap = None out = ""scratch/pca.png"" def load_data( bed: str, samples_file: str, subsample_size: int, seed: int, name_col: str = 'name', sep: str = '\t' ): """""" Load the data from the bed file and the samples file. :param bed: Bed file with the genotypes. :param samples_file: File with the samples. :param subsample_size: Subsample the SNPs to this size. :param seed: The seed for the random number generator. Use ``None`` for no seed. :param name_col: The column in the samples file that contains the names of the samples. :param sep: The separator of the samples file. :raises ValueError: If the samples in the samples file are not a subset of the samples in the bed file. """""" # load genotypes (bim, fam, genotypes) = read_plink(bed) # subsample SNPs if desired if subsample_size and genotypes.shape[0] > subsample_size: indices = np.random.default_rng(seed=seed).choice(range(genotypes.shape[0]), subsample_size, replace=False) genotypes = genotypes[indices] # load samples samples = pd.read_csv(samples_file, sep=sep) # make sure the samples in samples_file are a subset of fam.iid if not set(samples[name_col].values).issubset(set(fam.iid.values)): raise ValueError(""Some samples in samples file are not in the fam.iid!"") # order samples by fam.iid order = {sample: i for i, sample in enumerate(fam.iid.values)} samples[""ordering""] = samples[name_col].map(order) samples.sort_values(by=""ordering"", inplace=True) # create a map of sample name to index in fam.iid fam_order = {name: i for i, name in enumerate(fam.iid.values)} # get indices of samples in fam.iid order samples_indices = samples[name_col].map(fam_order).values # subset genotypes = genotypes[:, samples_indices] # Silence FutureWarning: The `numpy.may_share_memory` function is not implemented by Dask array. # You may want to use the da.map_blocks function or something similar to silence this warning. # Your code may stop working in a future release with warnings.catch_warnings(): warnings.simplefilter(""ignore"") # impute missing genotype values genotypes = SimpleImputer(missing_values=np.nan, strategy=""mean"").fit_transform(genotypes) # transpose return np.array(genotypes).T, samples def prepare_plot( x: np.ndarray, y: np.ndarray, label_dict: dict, samples: pd.DataFrame, label_col: str, marker_size: int = 20, cmap: str = None, legend: bool = True, legend_title: str = None, legend_outside: bool = True, legend_n_cols: int = 1, legend_size: int = 6, cbar: bool = None, name_col: str = 'name', add_names: bool = False, ) -> plt.Axes: """""" Prepare a PCA plot. :param x: The x values. :param y: The y values. :param label_dict: A dictionary that maps the labels to new labels. :param samples: Dataframe with the samples. :param label_col: The column in the samples file that contains the labels. :param marker_size: The size of the markers. :param cmap: The colormap. :param legend: Whether to add a legend. :param legend_title: The title of the legend. :param legend_outside: Whether to put the legend outside the plot. :param legend_n_cols: The number of columns in the legend. :param legend_size: The size of the legend. :param cbar: Whether to add a color bar. :param name_col: The column in the samples file that contains the names of the samples. :param add_names: Whether to add sample names to the plot. :return: """""" # recode labels if desired and replace missing values with placeholder if label_dict: samples['label_dict'] = [label_dict[x] if x in label_dict else '-' for x in samples[label_col]] label_col = 'label_dict' else: # replace missing values if label_col: samples.loc[samples[label_col].isna(), label_col] = '-' # plot the 2 components ax = sns.scatterplot(x=x, y=y, hue=samples[label_col] if label_col else None, s=marker_size, palette=cmap) # whether to include a legend if legend: # set legend title ax.get_legend().set_title(legend_title) # whether to place the legend outside the graph if legend_outside: plt.legend(loc='center left', bbox_to_anchor=(1.02, 0.5), ncol=legend_n_cols, prop={'size': legend_size}) else: if ax.get_legend(): ax.get_legend().remove() # whether to show a color bar if cbar: norm = plt.Normalize(samples[label_col].min(), samples[label_col].max()) sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm) sm.set_array([]) ax.figure.colorbar(sm) # add sample names if specified if add_names: eps = 0.15 for i in range(samples.shape[0]): plt.text(x=x[i] + eps, y=y[i] + eps, s=samples[name_col][i], size=4, alpha=0.5) plt.gca().axis('square') plt.tight_layout(pad=5) return plt.gca() genotypes, samples = load_data( bed=bed, samples_file=samples_file, subsample_size=subsample_size, seed=seed, name_col=name_col ) pca = PCA(n_components=2) pc = pca.fit_transform(genotypes) prepare_plot( x=pc[:, 0], y=pc[:, 1], label_dict=label_dict, samples=samples, label_col=label_col, marker_size=marker_size, cmap=cmap, legend=legend, legend_title=legend_title, legend_outside=legend_outside, legend_n_cols=legend_n_cols, legend_size=legend_size, cbar=cbar, name_col=name_col, add_names=add_names ) # add axis labels v1 = round(pca.explained_variance_ratio_[0] * 100, 2) v2 = round(pca.explained_variance_ratio_[1] * 100, 2) plt.xlabel(f'{v1}%') plt.ylabel(f'{v2}%') plt.savefig(out, dpi=200, bbox_inches='tight', pad_inches=0.1) if testing: plt.show() ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/annotate_vep.py",".py","571","30",""""""" Predict the variant effects with VEP. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2023-05-13"" from snakemake.shell import shell ref = snakemake.input.ref vcf = snakemake.input.vcf gff = snakemake.input.gff species = snakemake.params.species out = snakemake.output[0] shell( f""vep "" f""--gff {gff} "" f""--fasta {ref} "" f""-i {vcf} "" f""--vcf "" f""--species {species} "" f""--allow_non_variant "" f""-o {out} "" f""--fields 'Consequence,Codons' "" f""--compress_output bgzip "" f""--pick"" ) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/determine_4fold_vs_0fold.py",".py","1229","31",""""""" Determine the ratio of 4-fold to 0-fold sites in a genome by using TargetSiteCounter. """""" import fastdfe as fd p = fd.Parser( n=20, # number of individuals not important # choose sufficiently many sites since TargetSiteCounter is restricted to the same genomic interval max_sites=10000, vcf=""https://github.com/Sendrowski/fastDFE/blob/dev/resources/"" ""genome/betula/biallelic.polarized.subset.50000.vcf.gz?raw=true"", fasta=""https://github.com/Sendrowski/fastDFE/blob/dev/resources/"" ""genome/betula/genome.subset.1000.fasta.gz?raw=true"", gff=""https://github.com/Sendrowski/fastDFE/blob/dev/resources/"" ""genome/betula/genome.gff.gz?raw=true"", target_site_counter=fd.TargetSiteCounter( n_target_sites=100000, # doesn't matter since we're only interested in the ratio n_samples=10000 # choose sufficiently many samples for the ratio to be accurate ), stratifications=[fd.DegeneracyStratification()], # stratify by 4-fold and 0-fold sites annotations=[fd.DegeneracyAnnotation()], # annotate sites with degeneracy on-the-fly filtrations=[fd.SNPFiltration()], ) sfs = p.parse() r = sfs['neutral'].data[0] / sfs['selected'].data[0] pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_pendula_model_comp.py",".py","455","25","import matplotlib.pyplot as plt import fastdfe as fd # create inference object inf = fd.BaseInference( # neutral SFS sfs_neut=fd.Spectrum( [177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652] ), # selected SFS sfs_sel=fd.Spectrum([ 797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794] ), do_bootstrap=True ) # run inference inf.run() # plot discretized DFE inf.plot_nested_models(show=False) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/remove_info_tags_vcf.py",".py","1000","44",""""""" Remove polarization from VCF file. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-12-09"" from cyvcf2 import VCF, Writer from tqdm import tqdm try: from snakemake.shell import shell import sys # necessary to import fastdfe locally sys.path.append('..') testing = False vcf_in = snakemake.input.vcf tags = snakemake.params.tags vcf_out = snakemake.output.vcf except ModuleNotFoundError: # testing testing = True vcf_in = ""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"" tags = [""AA"", ""Degeneracy"", ""Degeneracy_Info"", ""Synonymy"", ""Synonymy_Info"", ""EST_SFS_input"", ""EST_SFS_probs""] vcf_out = ""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz.new"" # remove polarization (AA tag) using cyvcf2 vcf = VCF(vcf_in) writer = Writer(vcf_out, vcf) # remove polarization for v in tqdm(vcf): for tag in tags: del v.INFO[tag] writer.write_record(v) pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/annotate_snpeff.py",".py","420","25",""""""" Predict the variant effects with SnpEff. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""j.sendrowski18@gmail.com"" __date__ = ""2023-05-21"" from snakemake.shell import shell vcf = snakemake.input.vcf species = snakemake.params.species out = snakemake.output[0] # download database shell(""snpEff download {species}"") # annotate shell( f""snpEff "" f""-v {species} "" f""{vcf} "" f""| bgzip > {out}"" ) ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/example_pendula_joint.py",".py","757","32","import fastdfe as fd # neutral SFS for two types sfs_neut = fd.Spectra(dict( pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] )) # selected SFS for two types sfs_sel = fd.Spectra(dict( pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] )) # create inference object inf = fd.JointInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, shared_params=[fd.SharedParams(types=[""pendula"", ""pubescens""], params=[""eps"", ""S_d""])], do_bootstrap=True ) # run inference inf.run() # plot discretized DFE inf.plot_discretized() # inf.plot_inferred_parameters() pass ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dominance_simulation.py",".py","4925","208","import sys import numpy as np import pandas as pd # necessary to import fastdfe locally sys.path.append('.') from matplotlib.cm import ScalarMappable import matplotlib.gridspec as gridspec from matplotlib import pyplot as plt import fastdfe as fd try: testing = False hs = np.round(np.linspace(0, 1, 11), 2) n = snakemake.params.n n_runs = 10 n_bootstraps = 100 n_bootstrap_retries = 2 intervals_del = (-1.0e+8, -1.0e-5, 100) intervals_ben = (1.0e-5, 1.0e4, 100) intervals_h = (0, 1, 21) out = snakemake.output[0] except NameError: # testing testing = True hs = np.round(np.linspace(0, 1, 11), 2) n = 20 n_runs = 10 n_bootstraps = 10 n_bootstrap_retries = 2 intervals_del = (-1.0e+8, -1.0e-5, 100) intervals_ben = (1.0e-5, 1.0e4, 100) intervals_h = (0, 1, 21) out = ""compare_dfe_accuracy.png"" d = fd.discretization.Discretization( n=n, h=None, intervals_del=intervals_del, intervals_ben=intervals_ben, intervals_h=intervals_h ) sims, infs = {}, {} for h in hs: sims[h] = fd.Simulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=n, n_sites=1e8, theta=1e-4), params=dict(S_d=-300, b=0.3, p_b=0, S_b=1, h=h), model=fd.GammaExpParametrization(), intervals_del=intervals_del, intervals_ben=intervals_ben, discretization=d ) sims[h].run() infs[h] = fd.BaseInference( sfs_neut=sims[h].sfs_neut / 2, sfs_sel=sims[h].sfs_sel, intervals_h=intervals_h, intervals_del=intervals_del, intervals_ben=intervals_ben, discretization=d, fixed_params=dict(all=dict(eps=0, p_b=0, S_b=1)), n_runs=n_runs, n_bootstraps=n_bootstraps, n_bootstrap_retries=n_bootstrap_retries, ) infs[h].run() fig = plt.figure(figsize=(9, 5)) gs = gridspec.GridSpec(2, 3, width_ratios=[1, 1, 0.05]) # generate the 2×2 axes grid in one go ax = np.array([[fig.add_subplot(gs[i, j]) for j in range(2)] for i in range(2)]) # colorbar axis spans all rows in last column cax = fig.add_subplot(gs[:, 2]) plt.rcParams['xtick.labelsize'] = 9 plt.rcParams[""legend.fontsize""] = 9 # global color map for all h cmap = plt.cm.viridis norm = plt.Normalize(min(hs), max(hs)) colors = {h: cmap(norm(h)) for h in hs} fd.Spectra.from_spectra( {f""h={h}"": infs[h].sfs_sel for h in hs} ).plot(ax=ax[0, 0], show=False) ax[0, 0].set_title( f'Selected SFS $({"", "".join([f""{k}={v}"" for k, v in sims[hs[0]].params.items() if k in [""S_d"", ""b"", ""p_b""]])})$' ) ax[0, 0].legend_.remove() bars = ax[0, 0].patches offset = 0 # each h for h in hs: for b in bars[offset: offset + n + 1]: b.set_facecolor(colors[h]) b.set_alpha(0.8) b.set_hatch("""") offset += n + 1 fd.DFE.plot_many( [sims[hs[0]].dfe] + [inf.get_dfe() for inf in infs.values()], labels=['true DFE'] + ['_nolegend_' for _ in hs], intervals=[-np.inf, -100, -10, -1, 0], ax=ax[0, 1], show=False, point_estimate='mean', title='Inferred DFE under varying $h$' ) leg = ax[0, 1].legend() bars = ax[0, 1].patches n_bins = 4 offset = 0 legend_handle = leg.get_patches()[0] legend_handle.set_facecolor(""grey"") legend_handle.set_alpha(0.9) for b in bars[offset: offset + n_bins]: b.set_facecolor(""grey"") b.set_alpha(0.9) b.set_hatch("""") offset += n_bins # inferred DFEs = one block per h for h in hs: for b in bars[offset: offset + n_bins]: b.set_facecolor(colors[h]) b.set_alpha(0.9) b.set_hatch("""") offset += n_bins data = [infs[h].bootstraps[""h""].values for h in hs] vp = ax[1, 0].violinplot( data, positions=hs, showmeans=True, showextrema=False, widths=0.08 ) # recolor each body for h, body in zip(hs, vp['bodies']): body.set_facecolor(colors[h]) body.set_edgecolor(colors[h]) body.set_alpha(0.8) # recolor the means if 'cmeans' in vp: vp['cmeans'].set_color('black') ax[1, 0].set_xlabel(""true $h$"") ax[1, 0].set_ylabel(""inferred $h$"") ax[1, 0].set_title(""Inferred vs true $h$"") vals = [] for h in hs: df = infs[h].bootstraps.copy() df[""S_d""] = df[""S_d""].abs() df[""true_h""] = h vals.append(df) df_all = pd.concat(vals, ignore_index=True) # Normalize true_h into [0,1] for colormap norm = plt.Normalize(min(hs), max(hs)) cmap = plt.cm.viridis sc = ax[1, 1].scatter( df_all[""S_d""], df_all[""h""], s=12, alpha=0.5, c=df_all[""true_h""], cmap=cmap, norm=norm, ) ax[1, 1].set_xscale(""log"") ax[1, 1].set_xlabel(""$S_d$"") ax[1, 1].set_ylabel(""$h$"") ax[1, 1].set_title(""Bootstrap distribution of $h$ vs $S_d$"") # add colorbar sm = ScalarMappable(norm=norm, cmap=cmap) sm.set_array([]) cbar = fig.colorbar(sm, cax=cax) cbar.ax.set_ylabel(""h"", rotation=0, labelpad=0, va='center', fontsize=13) plt.tight_layout(pad=0.8) fig.savefig(out, dpi=200) if testing: plt.show() ","Python" "Allele","Sendrowski/fastDFE","snakemake/scripts/annotate_polarization.py",".py","1310","54",""""""" Annotate polarization of variants in a VCF file. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-09-26"" try: import sys # necessary to import fastdfe locally sys.path.append('..') testing = False vcf_file = snakemake.input.vcf n_ingroups = snakemake.params.n_ingroups outgroups = snakemake.params.outgroups exclude = snakemake.params.exclude max_sites = snakemake.params.get(""max_sites"", None) confidence_threshold = snakemake.params.get(""confidence_threshold"", 0) out = snakemake.output[0] except ModuleNotFoundError: # testing testing = True vcf_file = ""resources/genome/betula/biallelic.with_outgroups.vcf.gz"" outgroups = [""ERR2103730""] exclude = [""ERR2103731""] n_ingroups = 20 max_sites = 10000 confidence_threshold = 0 out = 'scratch/biallelic.polarized.vcf.gz' import fastdfe as fd # initialize annotator ann = fd.Annotator( vcf=vcf_file, output=out, annotations=[ fd.MaximumLikelihoodAncestralAnnotation( outgroups=outgroups, exclude=exclude, n_ingroups=n_ingroups, max_sites=max_sites, confidence_threshold=confidence_threshold ) ] ) # run annotation ann.annotate() pass","Python" "Allele","Sendrowski/fastDFE","fastdfe/spectrum.py",".py","33311","1164",""""""" SFS utilities. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2022-07-24"" import logging from typing import Dict, List, Union, Iterable, Any, Literal, Sequence from numpy.random import Generator import numpy as np import pandas as pd from scipy.stats import hypergeom from .io_handlers import download_if_url # get logger logger = logging.getLogger('fastdfe') def standard_kingman(n: int) -> 'Spectrum': """""" Get standard Kingman SFS for theta = 1. :param n: Standard Kingman SFS :return: Spectrum """""" return Spectrum(pad(1 / np.arange(1, int(n)))) def pad(counts: Sequence) -> np.ndarray: """""" Pad array with monomorphic counts. :param counts: SFS counts to pad :return: Padded array """""" return np.array([0] + list(counts) + [0]) class Spectrum(Iterable): """""" Class for holding and manipulating a site-frequency spectrum. """""" def __init__(self, data: Sequence[float]): """""" Initialize spectrum. :param data: SFS counts """""" self.data: np.ndarray = np.array(data, dtype=float) @property def n(self) -> int: """""" The sample size. :return: Sample size """""" return self.data.shape[0] - 1 @property def n_sites(self) -> float: """""" The total number of sites. :return: Total number of sites """""" return sum(self.data) @property def n_div(self) -> float: """""" Number of divergence counts. :return: Number of divergence counts """""" return self.data[-1] @property def has_div(self) -> bool: """""" Whether n_div was specified. :return: Whether n_div was specified """""" return self.n_div != 0 @property def n_monomorphic(self) -> float: """""" Number of monomorphic sites. :return: Number of monomorphic sites """""" return self.data[0] + self.data[-1] @property def polymorphic(self) -> np.ndarray: """""" Get the polymorphic counts. :return: Polymorphic counts """""" return self.data[1:-1] @property def n_polymorphic(self) -> np.ndarray: """""" Get the polymorphic counts. :return: Polymorphic counts """""" return np.sum(self.polymorphic) def to_list(self) -> list: """""" Convert to list. :return: SFS counts """""" return list(self.data) def to_spectra(self) -> 'Spectra': """""" Convert to Spectra object. :return: Spectra object """""" return Spectra.from_spectrum(self) def to_file(self, file: str): """""" Save object to file. :param file: File name """""" self.to_spectra().to_file(file) @staticmethod def from_file(file: str) -> 'Spectrum': """""" Load object from file. :param file: File name :return: Spectrum object """""" return Spectra.from_file(file).to_spectrum() def to_numpy(self) -> np.ndarray: """""" Convert to array. :return: SFS counts """""" return self.data @property def theta(self) -> float: """""" Calculate site-wise population mutation rate using Watterson's estimator. Note that theta is given per site, i.e. Watterson's estimator is divided by the total number of sites (:attr:`n_sites`). """""" return self.Theta / self.n_sites @property def Theta(self) -> float: """""" Calculate genome-wide population mutation rate using Watterson's estimator. .. note:: Property :attr:`Theta` is not normalized by the total number of sites, unlike :attr:`theta`. """""" return self.n_polymorphic / np.sum(1 / np.arange(1, self.n)) def fold(self) -> 'Spectrum': """""" Fold the site-frequency spectrum. :return: Folded spectrum """""" mid = (self.n + 1) // 2 data = self.data.copy() data[:mid] += data[-mid:][::-1] data[-mid:] = 0 return Spectrum(data) def misidentify(self, epsilon: float) -> 'Spectrum': """""" Introduce ancestral misidentification at rate epsilon. Note that monomorphic counts won't be affected. :param epsilon: Misidentification rate (0 <= epsilon <= 1) :return: Spectrum with misidentification applied :raise ValueError: If epsilon is not between 0 and 1 """""" if not 0 <= epsilon <= 1: raise ValueError(""epsilon must be between 0 and 1"") data = self.data.copy() n = self.n flipped = epsilon * data[1:n][::-1] retained = (1 - epsilon) * data[1:n] data[1:n] = retained + flipped return Spectrum(data) def subsample( self, n: int, mode: Literal['random', 'probabilistic'] = 'probabilistic', seed: int | Generator = None ) -> 'Spectrum': """""" Subsample spectrum to a given sample size. .. warning:: If using the 'random' mode, The SFS counts are cast to integers before subsampling so this will only provide sensible results if the SFS counts are integers or if they are large enough to be approximated well by integers. The 'probabilistic' mode does not have this limitation. :param n: Sample size :param mode: Subsampling mode. Either 'random' or 'probabilistic'. :param seed: Random state or seed. Only for 'random' mode. :return: Subsampled spectrum """""" if n >= self.n: raise ValueError(f'Subsampled sample size {n} must be smaller than original sample size {self.n}.') if mode not in ['random', 'probabilistic']: raise ValueError(f'Unknown subsampling mode {mode}.') subsample = np.zeros(n + 1, dtype=float) if mode == 'random': # add monomorphic counts subsample[0] = self.data[0] subsample[-1] = self.data[-1] # iterate over spectrum and subsample hypergeometrically for i, m in enumerate(self.polymorphic.astype(int)): # get subsampled counts samples = hypergeom.rvs(M=self.n, n=i + 1, N=n, size=m, random_state=seed) # add subsampled counts subsample += np.histogram(samples, bins=np.arange(n + 2))[0] else: for i, m in enumerate(self.data): probs = hypergeom.pmf(k=range(n + 1), M=self.n, n=i, N=n) # add subsampled counts subsample += m * probs sfs = Spectrum(subsample) # fold if original spectrum was folded if self.is_folded(): sfs = sfs.fold() return sfs def resample(self, seed: int | Generator = None) -> 'Spectrum': """""" Resample SFS assuming independent Poisson counts. :param seed: Random state or seed :return: Resampled spectrum. """""" if isinstance(seed, Generator): rng = seed else: rng = np.random.default_rng(None if seed is None else int(seed)) return Spectrum.from_polydfe( # resample polymorphic sites only polymorphic=rng.poisson(lam=self.polymorphic), n_sites=self.n_sites, n_div=self.n_div ) def is_folded(self) -> bool: """""" Check if the site-frequency spectrum is folded. :return: True if folded, False otherwise """""" mid = (self.n + 1) // 2 return np.all(self.data[-mid:] == 0) def normalize(self) -> 'Spectrum': """""" Normalize SFS so that all non-monomorphic counts add up to 1. :return: Normalized spectrum """""" # copy array data = self.data.copy() # normalize counts data[1:-1] /= data[1:-1].sum() return Spectrum(data) def copy(self) -> 'Spectrum': """""" Copy the spectrum. :return: Copy of the spectrum """""" return Spectrum(self.data.copy()) @staticmethod def from_polymorphic(data: Sequence) -> 'Spectrum': """""" Create Spectrum from polymorphic counts only. :param data: Polymorphic counts :return: Spectrum """""" return Spectrum([0] + list(data) + [0]) @staticmethod def from_list(data: Sequence) -> 'Spectrum': """""" Create Spectrum from list. :param data: SFS counts :return: Spectrum """""" return Spectrum(data) @staticmethod def from_polydfe( polymorphic: Sequence, n_sites: float, n_div: float ) -> 'Spectrum': """""" Create Spectra from polyDFE specification which treats the number of mutational target sites and the divergence counts separately. :param polymorphic: Polymorphic counts :param n_sites: Total number of sites :param n_div: Number of divergence counts :return: Spectrum """""" # determine number of monomorphic ancestral counts n_monomorphic = n_sites - np.sum(list(polymorphic) + [n_div]) data = [n_monomorphic] + list(polymorphic) + [n_div] return Spectrum(data) @staticmethod def _array_or_scalar(data: Iterable | float) -> np.ndarray | float: """""" Convert to array if iterable or return scalar otherwise. :param data: Iterable or scalar. :return: Array or scalar """""" if isinstance(data, Iterable): return np.array(list(data)) return data def __mul__(self, other: Iterable | float) -> 'Spectrum': """""" Multiply spectrum. :param other: Iterable or scalar :return: Spectrum """""" return Spectrum(self.data * self._array_or_scalar(other)) __rmul__ = __mul__ def __add__(self, other: Iterable | float) -> 'Spectrum': """""" Add spectrum. :param other: Iterable or scalar :return: Spectrum """""" return Spectrum(self.data + self._array_or_scalar(other)) def __sub__(self, other: Iterable | float) -> 'Spectrum': """""" Subtract spectrum. :param other: Iterable or scalar :return: Spectrum """""" return Spectrum(self.data - self._array_or_scalar(other)) def __pow__(self, other: Iterable | float) -> 'Spectrum': """""" Power operator. :param other: Iterable or scalar :return: Spectrum """""" return Spectrum(self.data ** self._array_or_scalar(other)) def __floordiv__(self, other: Iterable | float) -> 'Spectrum': """""" Divide spectrum. :param other: Iterable or scalar :return: Spectrum """""" return Spectrum(self.data // self._array_or_scalar(other)) def __truediv__(self, other: Iterable | float) -> 'Spectrum': """""" Add spectrum. :param other: Iterable or scalar :return: Spectrum """""" return Spectrum(self.data / self._array_or_scalar(other)) def __iter__(self): """""" Get iterator. :return: Iterator """""" return self.data.__iter__() def __len__(self) -> int: """""" Get length of spectrum (including monomorphic and fixed counts). :return: Length of spectrum """""" return self.data.shape[0] def plot( self, show: bool = True, file: str = None, title: str = None, log_scale: bool = False, show_monomorphic: bool = False, kwargs_legend: dict = dict(prop=dict(size=8)), ax: 'plt.Axes' = None ) -> 'plt.Axes': """""" Plot spectrum. :param show: Whether to show plot. :param file: File to save plot to. :param title: Title of plot. :param log_scale: Whether to use log scale on y-axis. :param show_monomorphic: Whether to show monomorphic counts. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :param ax: Axes to plot on. Only for Python visualization backend. :return: Axes """""" from .visualization import Visualization return Visualization.plot_spectra( spectra=[self.to_list()], file=file, show=show, title=title, log_scale=log_scale, show_monomorphic=show_monomorphic, ax=ax, kwargs_legend=kwargs_legend ) @staticmethod def standard_kingman(n: int, n_monomorphic: int = 0) -> 'Spectrum': """""" Get standard Kingman SFS. :param n: sample size :param n_monomorphic: Number of monomorphic sites. :return: Standard Kingman SFS """""" sfs = standard_kingman(n) sfs.data[0] = n_monomorphic return sfs class Spectra: """""" Class for holding and manipulating site-frequency spectra of multiple types. """""" def __init__(self, data: Dict[str, Iterable]): """""" Initialize spectra. :param data: Dictionary of SFS counts keyed by type """""" self.data: pd.DataFrame = pd.DataFrame(data) @property def n(self) -> int: """""" The sample size. :return: Sample size """""" return self.data.shape[0] - 1 @property def k(self) -> int: """""" The number of types. :return: Number of types """""" return self.data.shape[1] @property def n_monomorphic(self) -> pd.Series: """""" The number of monomorphic sites. :return: Number of monomorphic sites """""" return self.data.iloc[0] + self.data.iloc[-1] @property def polymorphic(self) -> np.ndarray: """""" The polymorphic counts. :return: Polymorphic counts """""" return self.data[1:-1] @property def n_polymorphic(self) -> np.ndarray: """""" The total number of polymorphic counts. :return: Total number of polymorphic counts for each type """""" return self.polymorphic.sum() @staticmethod def from_list(data: Sequence, types: List) -> 'Spectra': """""" Create from array of spectra. Note that data.ndim needs to be 2. :param data: Array of spectra :param types: Types :return: Spectra """""" return Spectra(dict((t, d) for t, d in zip(types, data))) @property def types(self) -> List[str]: """""" The types. :return: Types """""" return self.data.columns.to_list() @property def n_sites(self) -> pd.Series: """""" The number of mutational target sites which is the sum of all SFS entries. :return: Number of mutational target sites for each type """""" return self.data.sum() @property def n_div(self) -> pd.Series: """""" The number of divergence counts. :return: Number of divergence counts for each type """""" return self.data.iloc[-1] @property def has_div(self) -> pd.Series: """""" Whether n_div was specified. :return: Whether n_div was specified for each type """""" # noinspection PyTypeChecker return self.n_div != 0 @property def theta(self) -> pd.Series: """""" Calculate site-wise population mutation rate using Watterson's estimator. Note that theta is given per site, i.e. Watterson's estimator is divided by the total number of sites (:attr:`n_sites`). """""" return self.Theta / self.n_sites @property def Theta(self) -> pd.Series: """""" Calculate genome-wide population mutation rate using Watterson's estimator. .. note:: Property :attr:`Theta` is not normalized by the total number of sites, unlike :attr:`theta`. """""" return self.n_polymorphic / np.sum(1 / np.arange(1, self.n)) def normalize(self) -> 'Spectra': """""" Normalize spectra by sum of all entries. :return: Normalized spectra """""" return self / self.data.sum() def to_file(self, file: str): """""" Save object to file. :param file: File name """""" self.data.to_csv(file, index=False) def to_spectra(self) -> Dict[str, Spectrum]: """""" Convert to dictionary of spectrum objects. :return: Dictionary of spectrum objects """""" return dict((t, self.select(t, use_regex=False)) for t in self.types) def to_dataframe(self) -> pd.DataFrame: """""" Get representation as dataframe. :return: Dataframe """""" return self.data def to_numpy(self) -> np.ndarray: """""" Convert to numpy array. :return: Numpy array """""" return self.data.to_numpy().T def to_list(self) -> list: """""" Convert to nested list. :return: Nested list """""" return list(list(d) for d in self.to_numpy()) def to_dict(self) -> dict: """""" Convert to dictionary. :return: Dictionary of lists """""" # return dictionary of lists return dict((k, list(v.values())) for k, v in self.data.to_dict().items()) def __mul__(self, other: Any) -> 'Spectra': """""" Multiply Spectra. :param other: Scalar :return: Spectra """""" return Spectra.from_dataframe(self.data * other) __rmul__ = __mul__ def __floordiv__(self, other: Any) -> 'Spectra': """""" Divide Spectra. :param other: Scalar :return: Spectra """""" return Spectra.from_dataframe(self.data // other) def __truediv__(self, other: Any) -> 'Spectra': """""" Divide Spectra. :param other: Scalar :return: Spectra """""" return Spectra.from_dataframe(self.data / other) def __len__(self) -> int: """""" Get number of spectra. :return: Number of spectra """""" return self.k def __add__(self, other: 'Spectra') -> 'Spectra': """""" Merge types of two spectra objects by adding up their counts entry-wise. :param other: Spectra object :return: Spectra with merged types """""" return Spectra.from_dataframe(self.data.add(other.data, fill_value=0)) def __getitem__( self, keys: str | List[str] | np.ndarray | tuple, use_regex: bool = True ) -> Union['Spectrum', 'Spectra']: """""" Get item. :param keys: String or list of strings, possibly regex to match type names :param use_regex: Whether to use regex to match type names :return: Spectrum or Spectra object depending on the number of matches """""" # whether the input in an array is_array = isinstance(keys, (np.ndarray, list, tuple)) if use_regex: # subset dataframe using column names using regex subset = self.data.loc[:, self.data.columns.str.fullmatch('|'.join(keys) if is_array else keys)] else: # subset dataframe using column names subset = self.data.loc[:, keys] # return spectrum object if we have a series if isinstance(subset, pd.Series): return Spectrum(list(subset)) # return spectrum object if only one column is left # and if not multiple keys were supplied if subset.shape[1] == 1 and not is_array: return Spectrum(list(subset.iloc[:, 0])) # wrap subset dataframe in spectra object return Spectra.from_dataframe(subset) def __setitem__(self, key: str, s: Spectrum): """""" Save new spectrum as type. :param key: Type :param s: Spectrum """""" self.data[key] = s.to_list() def __iter__(self): """""" Get iterator. :return: Iterator """""" return self.data.__iter__() def select( self, keys: str | List[str] | np.ndarray | tuple, use_regex: bool = True ) -> 'Spectra': """""" Select types. Alias for __getitem__. :param keys: String or list of strings, possibly regex to match type names :param use_regex: Whether to use regex to match type names :return: Spectrum or Spectra depending on the number of matches """""" return self.__getitem__(keys, use_regex=use_regex) def copy(self) -> 'Spectra': """""" Copy object. :return: Copy of object """""" return Spectra.from_dataframe(self.data.copy()) def _to_multi_index(self) -> 'Spectra': """""" Convert to Spectra object with multi-indexed columns. :return: Spectra object with multi-indexed columns """""" other = self.copy() columns = [tuple(col.split('.')) for col in other.data.columns] other.data.columns = pd.MultiIndex.from_tuples(columns) return other def _to_single_index(self) -> 'Spectra': """""" Convert to Spectra object with single-indexed columns (using dot notation). :return: Spectra object with single-indexed columns """""" other = self.copy() if other.data.columns.nlevels > 1: columns = other.data.columns.map('.'.join) other.data.columns = columns return other def get_empty(self) -> 'Spectra': """""" Get a Spectra object with zero counts but having the same shape and types as self. :return: Spectra object with zero counts """""" return Spectra.from_dataframe(pd.DataFrame(0, index=self.data.index, columns=self.data.columns)) def merge_groups(self, level: List[int] | int = 0) -> 'Spectra': """""" Group over given levels and sum up spectra so the spectra are summed over the levels that were not specified. :param level: Level(s) to group over :return: Spectra object with merged groups """""" # cast to int level = [int(l) for l in level] if isinstance(level, Iterable) else int(level) return Spectra.from_dataframe(self._to_multi_index().data.T.groupby(level=level).sum().T)._to_single_index() def has_dots(self) -> bool: """""" Check whether column names contain dots. :return: True if column names contain dots, False otherwise """""" return any('.' in col for col in self.data.columns) def replace_dots(self, replacement: str = '_') -> 'Spectra': """""" Replace dots in column names with a given string. :param replacement: Replacement string :return: Spectra object with replaced dots """""" other = self.copy() other.data.columns = other.data.columns.str.replace('.', replacement) return other @property def all(self) -> 'Spectrum': """""" The 'all' type equals the sum of all spectra. :return: Spectrum object """""" return Spectrum(self.data.sum(axis=1).to_list()) def combine(self, s: 'Spectra') -> 'Spectra': """""" Merge types of two Spectra objects. :param s: Other Spectra object :return: Merged Spectra object """""" return Spectra(self.to_dict() | s.to_dict()) @staticmethod def from_dict(data: dict) -> 'Spectra': """""" Load from nested dictionary first indexed by types and then by samples. :param data: Dictionary of lists indexed by types :return: Spectra object """""" lists = [list(v.values() if isinstance(v, dict) else v) for v in data.values()] return Spectra.from_list(lists, types=list(data.keys())) @staticmethod def from_dataframe(data: pd.DataFrame) -> 'Spectra': """""" Load Spectra object from dataframe. :param data: Dataframe :return: Spectra object """""" return Spectra.from_dict(data.to_dict()) @classmethod def from_file(cls, file: str) -> 'Spectra': """""" Save object to file. :param file: Path to file, possibly URL :return: Spectra object """""" return Spectra.from_dataframe(pd.read_csv(download_if_url( file, desc=f'{cls.__name__}>Downloading file')) ) @staticmethod def from_spectra(spectra: Dict[str, Spectrum]) -> 'Spectra': """""" Create from dict of spectrum objects indexed by type. :param spectra: Dictionary of spectrum objects indexed by type :return: Spectra object """""" return Spectra.from_list([sfs.to_list() for sfs in spectra.values()], types=list(spectra.keys())) @staticmethod def from_spectrum(sfs: Spectrum) -> 'Spectra': """""" Create from single spectrum object. The type of the spectrum is set to 'all'. :param sfs: Spectrum :return: Spectra object """""" return Spectra.from_spectra(dict(all=sfs)) def to_spectrum(self) -> Spectrum: """""" Convert to Spectrum object by summing over all types. :return: Spectrum object """""" return self.all def plot( self, show: bool = True, file: str = None, title: str = None, log_scale: bool = False, use_subplots: bool = False, show_monomorphic: bool = False, kwargs_legend: dict = dict(prop=dict(size=8)), ax: 'plt.Axes' = None ) -> 'plt.Axes': """""" Visualize spectra. :param show: Whether to show the plot. :param file: File name to save the plot to. :param title: Plot title. :param log_scale: Whether to use log scale on y-axis. :param use_subplots: Whether to use subplots. Only for Python visualization backend. :param show_monomorphic: Whether to show monomorphic sites. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :param ax: Axes to plot on. Only for Python visualization backend and if ``use_subplots`` is ``False``. :return: Axes """""" from .visualization import Visualization return Visualization.plot_spectra( spectra=list(list(v) for v in self.to_spectra().values()), labels=self.types, file=file, show=show, title=title, log_scale=log_scale, use_subplots=use_subplots, show_monomorphic=show_monomorphic, kwargs_legend=kwargs_legend, ax=ax ) def drop_empty(self) -> 'Spectra': """""" Remove types whose spectra have no counts. :return: Spectra with non-empty types """""" return Spectra.from_dataframe(self.data.loc[:, self.data.any()]) def drop_zero_entries(self) -> 'Spectra': """""" Remove types whose spectra have some zero entries. Note that we ignore zero counts in the last entry i.e. fixed derived alleles. :return: Spectra with non-zero entries """""" return Spectra.from_dataframe(self.data.loc[:, self.data[:-1].all()]) def drop_sparse(self, n_polymorphic: int) -> 'Spectra': """""" Remove types whose spectra have fewer than equal ``n_polymorphic`` polymorphic sites. :return: Spectra """""" return Spectra.from_dataframe(self.data.loc[:, self.data[1:-1].sum() > int(n_polymorphic)]) def rename(self, names: List[str]) -> 'Spectra': """""" Rename types. :param names: New names :return: Spectra with renamed types """""" other = self.copy() other.data.columns = names return other def prefix(self, prefix: str) -> 'Spectra': """""" Prefix types, i.e. 'type' -> 'prefix.type' for all types. :param prefix: Prefix :return: Spectra with prefixed types """""" return self.rename([prefix + '.' + col for col in self.types]) def reorder_levels(self, levels: List[int]) -> 'Spectra': """""" Reorder levels. :param levels: New order of levels :return: Spectra with reordered levels """""" s = self._to_multi_index() s.data.columns = s.data.columns.reorder_levels(levels) s = s._to_single_index() return s def print(self): """""" Print spectra. """""" print(self.data.T) def fold(self): """""" Fold spectra. :return: Folded spectra """""" return Spectra.from_spectra({t: s.fold() for t, s in self.to_spectra().items()}) def subsample( self, n: int, mode: Literal['random', 'probabilistic'] = 'probabilistic', seed: int | Generator = None ) -> 'Spectra': """""" Subsample spectra to a given sample size. .. warning:: If using the 'random' mode, The SFS counts are cast to integers before subsampling so this will only provide sensible results if the SFS counts are integers or if they are large enough to be approximated by integers. The 'probabilistic' mode does not have this limitation. :param n: Sample size :param mode: Subsampling mode. Either 'random' or 'probabilistic'. :param seed: Random state or seed. Only for 'random' mode. :return: Subsampled spectra """""" return Spectra.from_spectra({t: s.subsample(n, mode, seed) for t, s in self.to_spectra().items()}) def resample(self, seed: int | Generator = None) -> 'Spectra': """""" Resample SFS assuming independent Poisson counts. :param seed: Random state or seed :return: Resampled spectra. """""" return Spectra.from_spectra({t: s.resample(seed) for t, s in self.to_spectra().items()}) def is_folded(self) -> Dict[str, bool]: """""" Check whether spectra are folded. :return: Dictionary of types and whether they are folded """""" return {t: s.is_folded() for t, s in self.to_spectra().items()} def sort_types(self) -> 'Spectra': """""" Sort types alphabetically. :return: Sorted spectra object """""" return Spectra.from_dataframe(self.data.sort_index(axis=1)) def parse_polydfe_sfs_config(file: str) -> Spectra: """""" Parse frequency spectra and mutational target site from polyDFE configuration file. :param file: File name :return: Spectra object """""" df = pd.read_csv(file, header=None, comment='#') # parse number of spectra and sample size n_neut, n_sel, n = np.array(df.iloc[0][0].split()).astype(int) # issue notice about number of spectra and sample size logger.info(f'Parsing {n_neut} neutral and {n_sel} selected SFS with ' f'a sample size of {n}.') # issue notice that fastDFE does not support variable mutation rates if n_neut > 1 or n_sel > 1: logger.info('Note that fastDFE does not model variable mutation rates ' 'as this did not turn out to change the inference result. ' 'The parsed spectra are thus merged together.') def to_spectrum(data: np.ndarray) -> Spectrum: """""" Parse spectrum and number of mutational target sites. We ignore the number of mutational target sites for divergence counts but include the divergence counts for completeness of the SFS. :param data: Spectrum data :return: Spectrum object """""" # iterate over spectra and merge them as we do not # support variable mutation rates data_merged = data.sum(axis=0) # polymorphic counts polymorphic = list(data_merged[:n - 1]) # parse number mutational target sites for ingroup n_sites = float(data_merged[n - 1]) # parse optional divergence counts n_div = float(data_merged[n]) if n < data_merged.shape[0] else 0 return Spectrum.from_polydfe(polymorphic, n_sites=n_sites, n_div=n_div) # iterate over spectra and merge them as we do not # support variable mutation rates data_neut = np.array([df.iloc[i][0].split() for i in range(1, n_neut + 1)], dtype=float) sfs_neut = to_spectrum(data_neut) # iterate over spectra and merge them as we do not # support variable mutation rates data_sel = np.array([df.iloc[i][0].split() for i in range(n_neut + 1, n_neut + n_sel + 1)], dtype=float) sfs_sel = to_spectrum(data_sel) return Spectra.from_spectra(dict( sfs_neut=sfs_neut, sfs_sel=sfs_sel )) ","Python" "Allele","Sendrowski/fastDFE","fastdfe/filtration.py",".py","23163","730",""""""" VCF filtrations and a filterer to apply them. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-05-11"" import functools import logging from abc import ABC, abstractmethod from typing import Iterable, List, Optional, Callable, Dict, Union import numpy as np import pandas as pd from .annotation import DegeneracyAnnotation from .io_handlers import get_major_base, MultiHandler, get_called_bases, DummyVariant # get logger logger = logging.getLogger('fastdfe') def _count_filtered(func: Callable) -> Callable: """""" Decorator that increases ``self.n_filtered`` by 1 if the decorated function returns False. """""" @functools.wraps(func) def wrapper(self, variant): """""" Wrapper function. :param self: Self. :param variant: The variant to filter. :return: The result of the decorated function. """""" result = func(self, variant) if not result: self.n_filtered += 1 return result return wrapper class Filtration(ABC): """""" Base class for filtering sites based on certain criteria. """""" #: The number of sites that didn't pass the filter. n_filtered: int = 0 def __init__(self): """""" Initialize filtration. """""" #: The logger. self._logger = logger.getChild(self.__class__.__name__) #: The handler. self._handler: MultiHandler | None = None @abstractmethod @_count_filtered def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Filter site. :param variant: The variant to filter. :return: ``True`` if the variant should be kept, ``False`` otherwise. """""" pass def _setup(self, handler: MultiHandler): """""" Perform any necessary pre-processing. This method is called before the actual filtration. :param handler: The handler. """""" self._handler = handler def _rewind(self): """""" Rewind the filtration. """""" self.n_filtered = 0 def _teardown(self): """""" Perform any necessary post-processing. This method is called after the actual filtration. """""" self._logger.info(f""Filtered out {self.n_filtered} sites."") class MaskedFiltration(Filtration, ABC): """""" Filter sites based on a samples mask. """""" def __init__( self, use_parser: bool = True, include_samples: List[str] | None = None, exclude_samples: List[str] | None = None ): """""" Create a new filtration instance. :param use_parser: Whether to use the samples mask from the parser, if used together with parser. :param include_samples: The samples to include, defaults to all samples. :param exclude_samples: The samples to exclude, defaults to no samples. """""" super().__init__() #: Whether to use the samples mask from the parser, if used together with parser. self.use_parser: bool = use_parser #: The samples to include. self.include_samples: List[str] | None = include_samples #: The samples to exclude. self.exclude_samples: List[str] | None = exclude_samples #: The samples mask. self._samples_mask: np.ndarray | None = None def _prepare_samples_mask(self): """""" Prepare the samples mask. """""" from .parser import Parser if self.use_parser and isinstance(self._handler, Parser): # use samples mask from parser self._samples_mask = self._handler._samples_mask elif self.include_samples is None and self.exclude_samples is None: # no samples mask self._samples_mask = None else: # determine samples to include if self.include_samples is None: mask = np.ones(len(self._handler._reader.samples)).astype(bool) else: mask = np.isin(self._handler._reader.samples, self.include_samples) # determine samples to exclude if self.exclude_samples is not None: mask &= ~np.isin(self._handler._reader.samples, self.exclude_samples) self._samples_mask = mask def _setup(self, handler: MultiHandler): """""" Prepare the samples mask. :param handler: The handler. """""" super()._setup(handler) # prepare samples mask self._prepare_samples_mask() class SNPFiltration(MaskedFiltration): """""" Only keep SNPs. Note that this entails discarding mono-morphic sites. """""" @_count_filtered def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Filter site. :param variant: The variant to filter. :return: ``True`` if the variant is an SNP, ``False`` otherwise. """""" # simply check whether the variant is an SNP if we don't have a samples mask if self._samples_mask is None or isinstance(variant, DummyVariant): return variant.is_snp # otherwise check whether the variant is an SNP among the included samples return len(np.unique(get_called_bases(variant.gt_bases[self._samples_mask]))) > 1 class SNVFiltration(Filtration): """""" Only keep single site variants (discard indels and MNPs but keep monomorphic sites). """""" @_count_filtered def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Filter site. :param variant: The variant to filter. :return: ``True`` if the variant is kept, ``False`` otherwise. """""" return np.all([alt in ['A', 'C', 'G', 'T'] for alt in [variant.REF] + variant.ALT]) class PolyAllelicFiltration(MaskedFiltration): """""" Filter out poly-allelic sites. """""" @_count_filtered def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Filter site. Note that we don't check explicitly all alleles, but rather rely on ``ALT`` field. :param variant: The variant to filter. :return: ``True`` if the variant is not poly-allelic, ``False`` otherwise. """""" # if we don't have a samples mask, simply check whether the variant is poly-allelic if self._samples_mask is None or isinstance(variant, DummyVariant): return len(variant.ALT) < 2 # otherwise check whether the variant is poly-allelic among the included samples return len(np.unique(get_called_bases(variant.gt_bases[self._samples_mask]))) < 3 class AllFiltration(Filtration): """""" Filter out all sites. Only useful for testing purposes. """""" @_count_filtered def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Filter site. :param variant: The variant to filter. :return: ``False``. """""" return False class NoFiltration(Filtration): """""" Do not filter out any sites. Only useful for testing purposes. """""" @_count_filtered def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Filter site. :param variant: The variant to filter. :return: ``True``. """""" return True class CodingSequenceFiltration(Filtration): """""" Filter out sites that are not in coding sequences. This filter should find frequent use when parsing spectra for DFE inference as we only consider sites in coding sequences for this purpose. By using it, the annotation and parsing of unnecessary sites can be avoided which increases the speed. Note that we assume here that within contigs, sites in the GFF file are sorted by position in ascending order. For this filtration to work, we require a GFF file (passed to :class:`~fastdfe.parser.Parser` or :class:`~fastdfe.filtration.Filterer`). """""" def __init__(self): """""" Create a new filtration instance. """""" Filtration.__init__(self) #: The coding sequence enclosing the current variant or the closest one downstream. self.cd: Optional[pd.Series] = None #: The number of processed sites. self.n_processed: int = 0 def _setup(self, handler: MultiHandler): """""" Touch the GFF file to load it. :param handler: The handler. """""" # require GFF file handler._require_gff(self.__class__.__name__) # setup GFF handler super()._setup(handler) # load coding sequences _ = handler._cds def _rewind(self): """""" Rewind the filtration. """""" super()._rewind() # reset coding sequence self.cd = None @_count_filtered def filter_site(self, v: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Filter site by whether it is in a coding sequence. :param v: The variant to filter. :return: ``True`` if the variant is in a coding sequence, ``False`` otherwise. """""" aliases = self._handler.get_aliases(v.CHROM) # if self.cd is None or not on the same chromosome or ends before the variant if self.cd is None or self.cd.seqid not in aliases or v.POS > self.cd.end: # initialize mock coding sequence self.cd = pd.Series({ 'seqid': v.CHROM, 'start': DegeneracyAnnotation._pos_mock, 'end': DegeneracyAnnotation._pos_mock }) # find coding sequences downstream cds = self._handler._cds[self._handler._cds['seqid'].isin(aliases) & (self._handler._cds['end'] >= v.POS)] if not cds.empty: # take the first coding sequence self.cd = cds.iloc[0] if self.cd.start == v.POS: self._logger.debug(f'Found coding sequence for {v.CHROM}:{v.POS}.') else: self._logger.debug(f'Found coding sequence downstream of {v.CHROM}:{v.POS}.') if self.n_processed == 0 and self.cd.start == DegeneracyAnnotation._pos_mock: self._logger.warning(f'No subsequent coding sequence found on the same contig as the first variant. ' f'Please make sure this is the correct GFF file with contig names matching ' f'the VCF file. You can use the aliases parameter to match contig names.') self.n_processed += 1 # check whether the variant is in the current coding sequence if self.cd is not None and self.cd.seqid in aliases and self.cd.start <= v.POS <= self.cd.end: return True return False class DeviantOutgroupFiltration(Filtration): """""" Filter out sites where the major allele of the specified outgroup samples differs from the major allele of the ingroup samples. """""" def __init__( self, outgroups: List[str], ingroups: List[str] = None, strict_mode: bool = True, retain_monomorphic: bool = True ): """""" Construct DeviantOutgroupFiltration. :param outgroups: The name of the outgroup samples to consider. :param ingroups: The name of the ingroup samples to consider, defaults to all samples but the outgroups. :param strict_mode: Whether to filter out sites where no outgroup sample is present, defaults to ``True``. :param retain_monomorphic: Whether to retain monomorphic sites, defaults to ``True``, which is faster. """""" super().__init__() #: The ingroup samples. self.ingroups: List[str] | None = ingroups #: The outgroup samples. self.outgroups: List[str] = outgroups #: Whether to filter out sites where no outgroup sample is present. self.strict_mode: bool = strict_mode #: Whether to retain monomorphic sites. self.retain_monomorphic: bool = retain_monomorphic #: The samples found in the VCF file. self.samples: Optional[np.ndarray] = None #: The ingroup mask. self.ingroup_mask: Optional[np.ndarray] = None #: The outgroup mask. self.outgroup_mask: Optional[np.ndarray] = None def _setup(self, handler: MultiHandler): """""" Touch the reader to load the samples. :param handler: The handler. """""" super()._setup(handler) # create samples array self.samples: np.ndarray = np.array(handler._reader.samples) # create ingroup and outgroup masks self._create_masks() def _create_masks(self): """""" Create ingroup and outgroup masks based on the samples. """""" # create outgroup masks self.outgroup_mask: np.ndarray = np.isin(self.samples, self.outgroups) # make sure all outgroups are present if self.outgroup_mask.sum() != len(self.outgroups): raise ValueError(f'Not all outgroup samples are present in the VCF file: {self.outgroups}') # create ingroup mask if self.ingroups is None: self.ingroup_mask = ~self.outgroup_mask else: self.ingroup_mask = np.isin(self.samples, self.ingroups) @_count_filtered def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Filter site. :param variant: The variant to filter. :return: ``True`` if the variant should be kept, ``False`` otherwise. """""" # keep monomorphic sites if requested if not variant.is_snp and self.retain_monomorphic: return True # filter out dummies if retain_monomorphic is false if isinstance(variant, DummyVariant): return False # get major base among ingroup samples ingroup_base = get_major_base(variant.gt_bases[self.ingroup_mask]) # get major base among outgroup samples outgroup_base = get_major_base(variant.gt_bases[self.outgroup_mask]) # filter out if no outgroup base is present and strict mode is enabled if outgroup_base is None: return not self.strict_mode # filter out if outgroup base is different from ingroup base return ingroup_base == outgroup_base class ExistingOutgroupFiltration(Filtration): """""" Filter out sites for which at least ``n_missing`` of the specified outgroup samples have no called base. """""" def __init__(self, outgroups: List[str], n_missing: int = 1): """""" Construct ExistingOutgroupFiltration. :param outgroups: The names of the outgroup samples considered. :param n_missing: The number of outgroup samples that need to be missing to fail the filter. """""" super().__init__() #: The outgroup samples. self.outgroups: List[str] = outgroups #: Minimum number of missing outgroups required to filter out a site. self.n_missing: int = n_missing #: The samples found in the VCF file. self.samples: Optional[np.ndarray] = None #: The outgroup mask. self.outgroup_mask: Optional[np.ndarray] = None def _setup(self, handler: MultiHandler): """""" Touch the reader to load the samples. :param handler: The handler. """""" super()._setup(handler) # create samples array self.samples: np.ndarray = np.array(handler._reader.samples) # create outgroup mask self._create_mask() def _create_mask(self): """""" Create outgroup mask based on the samples. """""" self.outgroup_mask: np.ndarray = np.isin(self.samples, self.outgroups) @_count_filtered def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Filter site. :param variant: The variant to filter. :return: ``True`` if the variant should be kept, ``False`` otherwise. """""" # keep dummy variants if isinstance(variant, DummyVariant): return True # get outgroup genotypes outgroups = variant.gt_bases[self.outgroup_mask] # count how many outgroups have no called base missing_count = sum(len(get_called_bases(outgroup)) == 0 for outgroup in outgroups) # filter out if at least n outgroups are missing return missing_count < self.n_missing class BiasedGCConversionFiltration(Filtration): """""" Only retain A<->T and G<->C substitutions (which are unaffected by biased gene conversion, see [CITGB]_). Mono-allelic sites are always retained, and we assume sites are at most bi-allelic. Note that the number of mutational target sites is reduced by this filtration. .. [CITGB] Pouyet et al., 'Background selection and biased gene conversion affect more than 95% of the human genome and bias demographic inferences.', Elife, 7:e36317, 2018 """""" @_count_filtered def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Remove bi-allelic sites that are not A<->T or G<->C substitutions. :param variant: The variant to filter. :return: ``True`` if the variant should be kept, ``False`` otherwise. """""" if variant.is_snp and len(variant.ALT) > 0: return (variant.REF, variant.ALT[0]) in [('A', 'T'), ('T', 'A'), ('G', 'C'), ('C', 'G')] return True class ContigFiltration(Filtration): """""" Filter out sites that are not on the specified contigs. """""" def __init__(self, contigs: List[str]): """""" Construct ContigFiltration. :param contigs: The contigs to retain. """""" super().__init__() #: The contigs to retain. self.contigs: List[str] = contigs @_count_filtered def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Filter site. :param variant: The variant to filter. :return: ``True`` if the variant is on one of the specified contigs, ``False`` otherwise. """""" return variant.CHROM in self.contigs class Filterer(MultiHandler): """""" Filter a VCF file using a list of filtrations. Example usage: :: import fastdfe as fd # only keep variants in coding sequences f = fd.Filterer( vcf=""http://ftp.1000genomes.ebi.ac.uk/vol1/ftp/data_collections/"" ""1000_genomes_project/release/20181203_biallelic_SNV/"" ""ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz"", gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", output='sapiens.chr21.coding.vcf.gz', filtrations=[fd.CodingSequenceFiltration()], aliases=dict(chr21=['21']) ) f.filter() """""" def __init__( self, vcf: str | Iterable['cyvcf2.Variant'], output: str, gff: str | None = None, filtrations: List[Filtration] = [], info_ancestral: str = 'AA', max_sites: int = np.inf, seed: int | None = 0, cache: bool = True, aliases: Dict[str, List[str]] = {} ): """""" Create a new filter instance. :param vcf: The VCF file, possibly gzipped or a URL. :param output: The output file. :param gff: The GFF file, possibly gzipped or a URL. This argument is required for some filtrations. :param filtrations: The filtrations. :param info_ancestral: The info field for the ancestral allele. :param max_sites: The maximum number of sites to process. :param seed: The seed for the random number generator. Use ``None`` for no seed. :param cache: Whether to cache files downloaded from urls. :param aliases: Dictionary of aliases for the contigs in the VCF file, e.g. ``{'chr1': ['1']}``. """""" super().__init__( vcf=vcf, gff=gff, info_ancestral=info_ancestral, max_sites=max_sites, seed=seed, cache=cache, aliases=aliases ) #: The filtrations. self.filtrations: List[Filtration] = filtrations #: The output file. self.output: str = output #: The number of sites that did not pass the filters. self.n_filtered: int = 0 #: The VCF writer. self._writer: 'cyvcf2.Writer' | None = None def is_filtered(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Whether the given variant is kept. :param variant: The variant to check. :return: ``True`` if the variant is kept, ``False`` otherwise. """""" # filter the variant for filtration in self.filtrations: if not filtration.filter_site(variant): self.n_filtered += 1 return False return True def _setup(self): """""" Set up the filtrations. """""" try: from cyvcf2 import Writer except ImportError: raise ImportError( ""VCF support in fastdfe requires the optional 'cyvcf2' package. "" ""Please install fastdfe with the 'vcf' extra: pip install fastdfe[vcf]"" ) # setup filtrations for f in self.filtrations: f._setup(self) # create the writer self._writer = Writer(self.output, self._reader) def _teardown(self): """""" Tear down the filtrations. """""" for f in self.filtrations: f._teardown() # close the writer and reader self._writer.close() self._reader.close() def filter(self): """""" Filter the VCF. """""" self._logger.info('Start filtering') # setup filtrations self._setup() # get progress bar with self.get_pbar(desc=f""{self.__class__.__name__}>Processing sites"") as pbar: # iterate over the sites for i, variant in enumerate(self._reader): if self.is_filtered(variant): # write the variant self._writer.write_record(variant) pbar.update() # explicitly stopping after ``n`` sites fixes a bug with cyvcf2: # 'error parsing variant with `htslib::bcf_read` error-code: 0 and ret: -2' if i + 1 == self.n_sites or i + 1 == self.max_sites: break # teardown filtrations self._teardown() self._logger.info(f'Filtered out {self.n_filtered} of {self.n_sites} sites in total.') ","Python" "Allele","Sendrowski/fastDFE","fastdfe/joint_inference.py",".py","54523","1363",""""""" Joint inference module. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" import copy import functools import logging import time from typing import List, Dict, Tuple, Literal, Optional, cast, Callable import jsonpickle import multiprocess as mp import numpy as np import pandas as pd from numpy.linalg import norm from tqdm import tqdm from .abstract_inference import Inference from .base_inference import BaseInference from .bootstrap import Bootstrap from .config import Config from .discretization import Discretization from .optimization import Optimization, SharedParams, pack_shared, expand_shared, \ Covariate, flatten_dict, merge_dicts, correct_values, parallelize as parallelize_func, expand_fixed, \ collapse_fixed_to_mean, unpack_shared, collapse_fixed from .parametrization import Parametrization from .settings import Settings from .spectrum import Spectrum, Spectra # get logger logger = logging.getLogger('fastdfe') class JointInference(BaseInference): """""" Enabling the sharing of parameters among several Inference objects. Example usage: :: import fastdfe as fd # neutral SFS for two types sfs_neut = fd.Spectra(dict( pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] )) # selected SFS for two types sfs_sel = fd.Spectra(dict( pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] )) # create inference object inf = fd.JointInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, do_bootstrap=True ) # run inference inf.run() """""" def __init__( self, sfs_neut: Spectra, sfs_sel: Spectra, include_divergence: bool = None, intervals_del: Tuple[float, float, int] = (-1.0e+8, -1.0e-5, 1000), intervals_ben: Tuple[float, float, int] = (1.0e-5, 1.0e4, 1000), intervals_h: Tuple[float, float, int] = (0.0, 1.0, 21), h_callback: Callable[[np.ndarray], np.ndarray] = None, integration_mode: Literal['midpoint', 'quad'] = 'midpoint', linearized: bool = True, model: Parametrization | str = 'GammaExpParametrization', seed: int = 0, x0: Dict[str, Dict[str, float]] = {}, bounds: Dict[str, Tuple[float, float]] = {}, scales: Dict[str, Literal['lin', 'log', 'symlog']] = {}, loss_type: Literal['likelihood', 'L2'] = 'likelihood', opts_mle: dict = {}, method_mle: str = 'L-BFGS-B', n_runs: int = 10, fixed_params: Dict[str, Dict[str, float]] = None, shared_params: List[SharedParams] = [], covariates: List[Covariate] = [], do_bootstrap: bool = True, n_bootstraps: int = 100, n_bootstrap_retries: int = 2, parallelize: bool = True, folded: bool = None, discretization: Discretization = None, optimization: Optimization = None, locked: bool = False, **kwargs ): """""" Create instance. :param sfs_neut: Neutral SFS. Note that we require monomorphic counts to be specified in order to infer the mutation rate. :param sfs_sel: Selected SFS. Note that we require monomorphic counts to be specified in order to infer the mutation rate. :param include_divergence: Whether to include divergence in the likelihood :param intervals_del: ``(start, stop, n_interval)`` for deleterious population-scaled selection coefficients. The intervals will be log10-spaced. Decreasing the number of intervals to ``100`` provides nearly identical results while increasing speed, especially when precomputing across dominance coefficients. :param intervals_ben: Same as ``intervals_del`` but for positive selection coefficients. Decreasing the number of intervals to ``100`` provides nearly identical results while increasing speed, especially when precomputing across dominance coefficients. :param intervals_h: ``(start, stop, n_interval)`` for dominance coefficients which are linearly spaced. This is only used when inferring dominance coefficients. Values of ``h`` between the edges will be interpolated linearly. :param h_callback: A function mapping the scalar parameter ``h`` and the array of selection coefficients ``S`` to dominance coefficients of the same shape, allowing models where ``h`` depends on ``S``. The default is ``lambda h, S: np.full_like(S, h)``, keeping ``h`` constant. Expected allele counts for a given dominance value are obtained by linear interpolation between precomputed values in ``intervals_h``. The inferred parameter is still named ``h``, even if transformed by ``h_callback``, and its bounds, scales, and initial values can be set via ``bounds``, ``scales``, and ``x0``. The fitness of heterozygotes and mutation homozygotes is defined as ``1 + 2hs`` and ``1 + 2s``, respectively. :param integration_mode: Integration mode when computing expected SFS under semidominance. ``quad`` is not recommended. :param linearized: Whether to discretize and cache the linearized integral mapping DFE to SFS or use ``scipy.integrate.quad`` in each call. ``False`` not recommended. :param model: DFE parametrization :param seed: Random seed. Use ``None`` for no seed. :param x0: Dictionary of initial values in the form ``{type: {param: value}}`` :param bounds: Bounds for the optimization in the form ``{param: (lower, upper)}`` :param scales: Scales for the optimization in the form ``{param: scale}`` :param loss_type: Loss type :param opts_mle: Options for the optimization :param method_mle: Method to use for optimization. See ``scipy.optimize.minimize`` for available methods. :param n_runs: Number of independent optimization runs out of which the best one is chosen. The first run will use the initial values if specified. Consider increasing this number if the optimization does not produce good results. :param fixed_params: Parameters kept constant during optimization, given as ``{type: {param: value}}``. By default, the ancestral misidentification rate ``eps`` is fixed to zero, ``h`` to 0.5, and the DFE parameters are fixed so that only the deleterious component of the DFE is estimated. :param shared_params: List of shared parameters :param do_bootstrap: Whether to perform bootstrapping :param n_bootstraps: Number of bootstraps :param n_bootstrap_retries: Number of optimization runs for each bootstrap sample. This parameter previously defined the number of retries per bootstrap sample when subsequent runs failed, but now it defines the total number of runs per bootstrap sample, taking the most likely one. :param parallelize: Whether to parallelize computations :param folded: Whether the SFS are folded. If not specified, the SFS will be folded if all of the given SFS appear to be folded. :param discretization: Discretization instance. Mainly intended for internal use. :param optimization: Optimization instance. Mainly intended for internal use. :param locked: Whether inferences can be run from the class itself. Used internally. :param kwargs: Additional keyword arguments which are ignored. """""" if sfs_neut.has_dots() or sfs_sel.has_dots(): raise ValueError('Type names cannot contain dots are not allowed as they are used internally.' 'You can use the `replace_dots` method to replace dots with another character.') # check whether types are equal if set(sfs_neut.types) != set(sfs_sel.types): raise ValueError('The neutral and selected spectra must have exactly the same types.') #: SFS types self.types: List[str] = sfs_neut.types # initialize parent # the `self.folded` property will generalize nicely as we # evaluate ``sfs_sel.all.is_folded and sfs_neut.all.is_folded`` BaseInference.__init__(**locals()) #: original MLE parameters before adding covariates and unpacked shared self.params_mle_raw: Optional[Dict[str, Dict[str, float]]] = None #: Shared parameters with expanded 'all' type self.shared_params = expand_shared(shared_params, self.types, self.optimization.param_names) # add covariates as shared parameters self._add_covariates_as_shared(covariates) # check if the shared parameters were specified correctly self.check_shared_params() # throw error if joint inference does not make sense if not self.joint_inference_makes_sense(): self._logger.warning('Joint inference does not make sense as no parameters are shared ' 'across more than one type. If this is not intended consider running ' 'several marginal inferences instead, which is more efficient.') # issue notice self._logger.info(f'Using shared parameters {self.shared_params}.') #: Covariates indexed by parameter name self.covariates: Dict[str, Covariate] = {f""c{i}"": cov for i, cov in enumerate(covariates)} # only show param and values cov_repr = dict((k, dict(param=v.param, values=v.values)) for k, v in self.covariates.items()) # issue notice self._logger.info(f'Including covariates: {cov_repr}.') # parameter names for covariates args_cov = list(self.covariates.keys()) # bounds for covariates bounds_cov = dict((k, cov.bounds) for k, cov in self.covariates.items()) #: Initial values for covariates self._x0_cov = dict((k, cov.x0) for k, cov in self.covariates.items()) # use linear scale for covariates scales_cov = dict((k, cov.bounds_scale) for k, cov in self.covariates.items()) if fixed_params is None: fixed_params = {'all': {'eps': 0, 'h': 0.5} | self.model.submodels['dele']} if not 'all' in fixed_params: fixed_params['all'] = {} #: fixed parameters with expanded 'all' type self.fixed_params: Dict[str, Dict[str, float]] = expand_fixed(fixed_params, self.types) if discretization is None: # create discretization instance #: Discretization instance self.discretization: Discretization = Discretization( n=self.n, h=collapse_fixed(fixed_params, self.types)['all'].get('h', None), intervals_del=intervals_del, intervals_ben=intervals_ben, intervals_h=intervals_h, h_callback=h_callback, integration_mode=integration_mode, linearized=linearized, parallelize=parallelize ) else: # otherwise assign instance self.discretization: Discretization = discretization # collapse fixed parameters fixed_collapsed = collapse_fixed_to_mean(self.fixed_params, self.types) # include 'all' type with infers the DFE for all spectra added together #: Dictionary of marginal inferences indexed by type self.marginal_inferences: Dict[str, BaseInference] = dict( all=BaseInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, discretization=self.discretization, include_divergence=include_divergence, model=model, seed=seed, x0=x0, bounds=bounds, scales=scales, loss_type=loss_type, opts_mle=opts_mle, method_mle=method_mle, fixed_params=dict(all=fixed_collapsed['all']) if 'all' in fixed_collapsed else {}, do_bootstrap=do_bootstrap, n_bootstraps=n_bootstraps, n_bootstrap_retries=n_bootstrap_retries, parallelize=parallelize, folded=self.folded, n_runs=n_runs) ) # check that the fixed parameters are valid self.check_fixed_params_exist() # check if the fixed parameters are compatible with the shared parameters self.check_no_shared_params_fixed() #: parameter scales self.scales: Dict[str, Literal['lin', 'log', 'symlog']] = \ self.model.scales | self._default_scales | scales_cov | scales #: parameter bounds self.bounds: Dict[str, Tuple[float, float]] = self.model.bounds | self._default_bounds | bounds | bounds_cov # create optimization instance for joint inference # take initial values and bounds from marginal inferences # and from this inference for type 'all' #: Joint optimization instance self.optimization: Optimization = Optimization( bounds=self.bounds, scales=self.scales, opts_mle=self.optimization.opts_mle, method_mle=method_mle, loss_type=self.optimization.loss_type, param_names=self.model.param_names + ['eps', 'h'] + args_cov, parallelize=self.parallelize, fixed_params=self.fixed_params, seed=self.seed ) # Construct the marginal inference object for each type. # Note that we use the same discretization # instance to avoid precomputing the linearization # several times. for t in sfs_neut.types: self.marginal_inferences[t] = BaseInference( # pass subtypes sfs_neut=sfs_neut[[t]], sfs_sel=sfs_sel[[t]], discretization=self.discretization, include_divergence=include_divergence, model=model, seed=seed, x0=x0, bounds=bounds, scales=scales, loss_type=loss_type, opts_mle=opts_mle, method_mle=method_mle, fixed_params=dict(all=self.fixed_params[t]) if t in self.fixed_params else {}, do_bootstrap=do_bootstrap, n_bootstraps=n_bootstraps, n_bootstrap_retries=n_bootstrap_retries, parallelize=parallelize, folded=self.folded, n_runs=n_runs ) #: Joint inference object indexed by type self.joint_inferences: Dict[str, BaseInference] = {} # add base inference object for each type for t in sfs_neut.types: self.joint_inferences[t] = BaseInference( # pass subtypes sfs_neut=sfs_neut[[t]], sfs_sel=sfs_sel[[t]], discretization=self.discretization, include_divergence=include_divergence, model=model, seed=seed, x0=x0, bounds=bounds, scales=scales, loss_type=loss_type, opts_mle=opts_mle, method_mle=method_mle, fixed_params=dict(all=self.fixed_params[t]) if t in self.fixed_params else {}, do_bootstrap=do_bootstrap, n_bootstraps=n_bootstraps, n_bootstrap_retries=n_bootstrap_retries, parallelize=parallelize, folded=self.folded, n_runs=n_runs, locked=True ) def check_shared_params(self): """""" Check if the shared parameters were specified correctly. """""" for shared in self.shared_params: # check parameters if len(set(shared.params) - set(self.param_names)) != 0: raise ValueError( f'Specified shared parameters {list(set(shared.params) - set(self.param_names))} ' f""don't match with any of {self.param_names}."" ) # check types if len(set(shared.types) - set(self.types)) != 0: raise ValueError( f'Specified types {list(set(shared.types) - set(self.types))} ' f"" in shared parameters don't match with any of {self.types}."" ) def check_no_shared_params_fixed(self): """""" Check that no shared parameters are fixed and raise an error otherwise. """""" for shared in self.shared_params: for t in shared.types: if t in self.fixed_params: for p in shared.params: if p in self.fixed_params[t]: raise ValueError(f""Parameter '{p}' in type '{t}' is both "" f""shared and fixed, which is not allowed. "" f""Note that covariates are automatically shared."") def get_shared_param_names(self) -> List[str]: """""" Get the names of the shared parameters. :return: Names of the shared parameters. """""" shared = [] for p in self.shared_params: shared += p.params return cast(List[str], np.unique(shared).tolist()) def _add_covariates_as_shared(self, covariates: List[Covariate]): """""" Add covariates as shared parameters. :param covariates: List of covariates. """""" cov_but_not_shared = self._determine_unshared_covariates(covariates) # add parameters with covariates to shared parameters if len(cov_but_not_shared) > 0: self._logger.info(f'Parameters {cov_but_not_shared} have ' f'covariates and thus need to be shared. ' f'Adding them to shared parameters.') # add to shared parameters self.shared_params.append(SharedParams(params=cov_but_not_shared, types=self.types)) def _determine_unshared_covariates(self, covariates): """""" Determine which covariates are not shared. :param covariates: :return: """""" # determine completely shared parameters completely_shared = [] for shared in self.shared_params: if len(shared.types) == len(self.types): completely_shared += shared.params # determine parameters with covariates params_with_covariates = [cov.param for cov in covariates] # determine parameters with covariates that are not shared return list(set(params_with_covariates) - set(completely_shared)) def run( self, **kwargs ) -> Spectrum: """""" Run inference. :param kwargs: Additional keyword arguments :return: Modelled SFS. """""" # run marginal optimization self._run_marginal() # run joint optimization return self._run_joint() def _run_marginal(self): """""" Run marginal optimization. :return: Dict of marginal inferences indexed by type. """""" def run_marginal(data: Tuple[str, BaseInference]) -> Tuple[str, BaseInference]: """""" Run marginal inference. Start with initial values obtained from 'all' type. :param data: Tuple of type and inference object. :return: Tuple of type and inference object. """""" # issue notice self._logger.info(f""Running marginal inference for type '{data[0]}'."") data[1].run_if_required( do_bootstrap=False ) return data # run for 'all' type run_marginal(('all', self.marginal_inferences['all'])) # update initial values of marginal inferences # with MLE estimate of 'all' type for inf in self.marginal_inferences.values(): inf.x0 = dict(all=self.marginal_inferences['all'].params_mle) # skip marginal inference if only one type was specified if len(self.types) == 1: self._logger.info('Skipping marginal inference as only one type was specified.') else: # issue notice self._logger.info(f'Running marginal inferences for types {self.types}.') # optionally parallelize marginal inferences run_inferences = dict(parallelize_func( func=run_marginal, data=list(self.marginals_without_all().items()), parallelize=False, pbar=False )) # reassign marginal inferences self.marginal_inferences = dict(all=self.marginal_inferences['all']) | run_inferences return self.marginal_inferences def marginals_without_all(self) -> Dict[str, BaseInference]: """""" Get marginal inference without 'all' type. :return: Dict of marginal inferences indexed by type. """""" return dict((t, inf) for t, inf in self.marginal_inferences.items() if t != 'all') def _run_joint(self) -> Spectrum: """""" Run joint optimization. :return: Modelled SFS. """""" # issue notice self._logger.info(f'Running joint inference for types {self.types}.') # issue notice self._logger.debug(f'Starting numerical optimization of {self.n_runs} ' 'independently initialized samples which are run ' + ('in parallel.' if self.parallelize else 'sequentially.')) # starting time of joint inference start_time = time.time() # Perform joint optimization. self.result, params_mle = self.optimization.run( x0=self.get_x0(), scales=self.scales, bounds=self.bounds, n_runs=self.n_runs, get_counts=self.get_counts(), desc=f'{self.__class__.__name__}>Performing joint inference' ) # assign runs dataframe and likelihoods self.runs = self.optimization.runs self.likelihoods = self.runs.likelihood.to_list() # store packed MLE params for later usage self.params_mle_raw = copy.deepcopy(params_mle) # unpack shared parameters params_mle = unpack_shared(params_mle) # normalize parameters for each type for t in self.types: params_mle[t] = self.model._normalize(params_mle[t]) # report on optimization result self._report_result(self.result, params_mle) # assign optimization result and MLE parameters for each type for t, inf in self.joint_inferences.items(): params_mle[t] = correct_values( params=Covariate._apply(self.covariates, params_mle[t], t), bounds=self.bounds, scales=self.scales ) # remove effect of covariates and assign result inf._assign_result(self.result, params_mle[t]) # assign execution time inf.execution_time = time.time() - start_time # assign MLE params self.params_mle = params_mle # assign joint likelihood self.likelihood = -self.result.fun # calculate L2 residual self.L2_residual = self.get_residual(2) # check L2 residual self._check_L2_residual() # add execution time self.execution_time += time.time() - start_time # perform bootstrap if configured if self.do_bootstrap: self.bootstrap() return self.sfs_mle def joint_inference_makes_sense(self) -> bool: """""" Check if joint inference makes sense. :return: Whether joint inference makes sense. """""" return len(self.types) >= 2 and len(self.shared_params) != 0 def get_counts(self) -> dict: """""" Get callback functions for modelling SFS counts from given parameters. :return: Dict of callback functions indexed by type. """""" # Note that it's important we bind t into the lambda function # at the time of creation. return dict((t, (lambda params, t=t: inf._model_sfs( discretization=self.discretization, model=self.model, params=correct_values(Covariate._apply(self.covariates, params, t), self.bounds, self.scales), sfs_neut=self.joint_inferences[t].sfs_neut, sfs_sel=self.joint_inferences[t].sfs_sel, folded=self.folded ))) for t, inf in self.joint_inferences.items()) @BaseInference._run_if_required_wrapper @functools.lru_cache def run_joint_without_covariates(self, do_bootstrap: bool = True) -> 'JointInference': """""" Run joint inference without covariates. Note that the result of this function is cached. :return: Joint inference instance devoid of covariates. """""" config = self.create_config() # retain shared parameters but remove covariates config.update( shared_params=self.shared_params, covariates={}, do_bootstrap=do_bootstrap ) # create copy other = JointInference.from_config(config) # issue notice self._logger.info('Running joint inference without covariates.') # run inference other.run() return other def create_config(self) -> 'Config': """""" Create a config object from the inference object. :return: Config object. """""" return Config( sfs_neut=Spectra.from_spectra(dict((t, inf.sfs_neut) for t, inf in self.marginals_without_all().items())), sfs_sel=Spectra.from_spectra(dict((t, inf.sfs_sel) for t, inf in self.marginals_without_all().items())), intervals_ben=self.discretization.intervals_ben, intervals_del=self.discretization.intervals_del, integration_mode=self.discretization.integration_mode, linearized=self.discretization.linearized, model=self.model, seed=self.seed, opts_mle=self.optimization.opts_mle, method_mle=self.optimization.method_mle, x0=self.x0, bounds=self.bounds, scales=self.scales, loss_type=self.optimization.loss_type, fixed_params=self.fixed_params, covariates=[c for c in self.covariates.values()], shared_params=self.shared_params, do_bootstrap=self.do_bootstrap, n_bootstraps=self.n_bootstraps, parallelize=self.parallelize, n_runs=self.n_runs ) @BaseInference._run_if_required_wrapper def perform_lrt_covariates(self, do_bootstrap: bool = False) -> float: """""" Perform likelihood ratio test against joint inference without covariates. In the simple model we share parameters across types. Low p-values indicate that including covariates significantly improves the model fit. To access the JointInference object without covariates, you can call :meth:`run_joint_without_covariates`, which is cached. :param do_bootstrap: Whether to bootstrap. :return: Likelihood ratio test p-value. """""" if len(self.covariates) == 0: raise ValueError('No covariates were specified.') # bootstrap if required if do_bootstrap: self.bootstrap_if_required() # run joint inference without covariates simple = self.run_joint_without_covariates(do_bootstrap=do_bootstrap) return self.lrt(simple.likelihood, self.likelihood, len(self.covariates)) def _get_run_bootstrap_sample(self) -> Callable[[int], Tuple['scipy.optimize.OptimizeResult', dict, dict, int]]: """""" Get function which runs a single bootstrap sample. :return: Static function which runs a single bootstrap sample, taking an optional seed and returning the optimization result of best run, MLE parameters, the best x0, and its index. """""" optimization = self.optimization discretization = self.discretization covariates = self.covariates model = self.model types = self.types folded = self.folded params_mle_raw = self.params_mle_raw scales = self.scales bounds = self.bounds scales_default = self.scales bounds_default = self.bounds n_retries = self.n_bootstrap_retries sfs_neut = dict((t, self.marginal_inferences[t].sfs_neut) for t in self.types) sfs_sel = dict((t, self.marginal_inferences[t].sfs_sel) for t in self.types) def run_bootstrap_sample(seed: int) -> Tuple['scipy.optimize.OptimizeResult', dict, dict, int]: """""" Resample the observed selected SFS and rerun the optimization procedure. We take the MLE params as initial params here. We make this function static to improve performance when parallelizing. :return: :return: Optimization result of best run, MLE parameters, and best x0. """""" results = [] x0 = params_mle_raw rng = np.random.default_rng(seed) # resample spectra spectra = {} for t in types: spectra[t] = dict( neut=sfs_neut[t].resample(seed=rng), sel=sfs_sel[t].resample(seed=rng) ) # run `n_retries` times for _ in range(max(n_retries, 1)): # perform joint optimization # Note that it's important we bind t into the lambda function # at the time of creation. result, params_mle = optimization.run( x0=x0, scales=scales, bounds=bounds, n_runs=1, debug_iterations=False, print_info=False, desc=f""{self.__class__.__name__}>Bootstrapping joint inference"", get_counts=dict((t, lambda params, t=t: BaseInference._model_sfs( discretization=discretization, model=model, params=correct_values(Covariate._apply(covariates, params, t), bounds_default, scales_default), sfs_neut=spectra[t]['neut'], sfs_sel=spectra[t]['sel'], folded=folded )) for t in types) ) # unpack shared parameters params_mle = unpack_shared(params_mle) for t in types: # normalize parameters for each type params_mle[t] = model._normalize(params_mle[t]) # add covariates for each type params_mle[t] = correct_values( params=Covariate._apply(covariates, params_mle[t], t), bounds=bounds_default, scales=scales_default ) results += [(result, params_mle, x0)] x0 = self.optimization.sample_x0(params_mle_raw, random_state=rng) return results return run_bootstrap_sample def bootstrap( self, n_samples: int = None, parallelize: bool = None, update_likelihood: bool = False, n_retries: int = None, pbar: bool = True, pbar_title: str = 'Bootstrapping joint inference' ) -> Optional[pd.DataFrame]: """""" Perform the parametric bootstrap both for the marginal and joint inferences. :param n_samples: Number of bootstrap samples. Defaults to :attr:`n_bootstraps`. :param parallelize: Whether to parallelize the bootstrap. Defaults to :attr:`parallelize`. :param update_likelihood: Whether to update the likelihood to be the mean of the bootstrap samples and the original likelihood. This is not statistically valid but can stabilize maximum likelihood estimate subject optimization noise. :param n_retries: Number of optimization runs for each bootstrap sample. Defaults to :attr:`n_bootstrap_retries`. :param pbar: Whether to show a progress bar. :param pbar_title: Title for the progress bar. :return: DataFrame with bootstrap samples """""" # update properties self.update_properties( n_bootstraps=n_samples, parallelize=parallelize, n_bootstrap_retries=n_retries ) # bootstrap marginal inferences for t, inf in self.marginal_inferences.items(): self._logger.info(f""Bootstrapping type '{t}'."") inf.bootstrap( n_samples=int(self.n_bootstraps), parallelize=self.parallelize, n_retries=self.n_bootstrap_retries, update_likelihood=update_likelihood, pbar_title=f""Bootstrapping '{t}'"" ) # bootstrap joint inference self._bootstrap( n_samples=n_samples, parallelize=parallelize, update_likelihood=update_likelihood, n_retries=n_retries, pbar=pbar, pbar_title=pbar_title ) # assign bootstrap parameters to joint inference objects for t, inf in self.joint_inferences.items(): # filter for columns belonging to the current type inf.bootstraps = self.bootstraps.filter(regex=f'{t}\\..*').rename(columns=lambda x: x.split('.')[-1]) # add estimates for alpha to the bootstraps inf._add_alpha_to_bootstraps() return self.bootstraps def bootstrap_if_required(self): """""" Bootstrap if not done yet. """""" if self.bootstraps is None: self.bootstrap() def get_x0(self) -> Dict[str, Dict[str, float]]: """""" Get initial values for joint inference. :return: Dictionary of initial values indexed by type """""" x0 = {} # create initial values from marginal inferences for t, inf in self.marginals_without_all().items(): # the MLE params might not be defined if inf.params_mle is not None: x0[t] = inf.params_mle else: x0[t] = self.marginal_inferences['all'].x0['all'] # get shared parameters from last inference and merge # with parameters for type 'all' shared = {} # get dict of shared parameters for s in self.shared_params: for p in s.params: # take mean value over types shared[':'.join(s.types) + '.' + p] = cast(float, np.mean([x0[t][p] for t in s.types])) # pack shared parameters packed = pack_shared(x0, self.shared_params, shared) # add parameters for covariates and return return merge_dicts(packed, {':'.join(self.types): self._x0_cov}) @BaseInference._run_if_required_wrapper def perform_lrt_shared(self, do_bootstrap: bool = False) -> float: """""" Compare likelihood of joint inference with product of marginal likelihoods. This provides information about the goodness of fit achieved by the parameter sharing. Low p-values indicate that parameter sharing is not justified, i.e., that the marginal inferences provide a significantly better fit to the data. Note that it is more difficult to properly optimize the joint likelihood, which makes this test conservative, i.e., the reported p-value may be larger than what it should be. :param do_bootstrap: Whether to perform bootstrapping. :return: p-value """""" if do_bootstrap: self.bootstrap_if_required() # determine likelihood of marginal inferences ll_marginal = sum([inf.likelihood for inf in self.marginals_without_all().values()]) # determine number of parameters, fixed parameters cancel out n_marginal = np.sum([len(inf.params_mle) for inf in self.marginals_without_all().values()]) n_joint = len(flatten_dict(self.get_x0())) return self.lrt(ll_simple=self.likelihood, ll_complex=ll_marginal, df=n_marginal - n_joint) def get_inferences( self, types: List[str] = None, labels: List[str] = None, show_marginals: bool = True ) -> Dict[str, 'BaseInference']: """""" Get all inference objects as dictionary. :param types: Types to include :param labels: Labels for types :param show_marginals: Whether to also show marginal inferences :return: Dictionary of base inference objects indexed by type and joint vs marginal subtypes """""" def get(infs: Dict[str, BaseInference], prefix: str) -> Dict[str, BaseInference]: """""" Get filtered and prefixed inferences. :param infs: Dictionary of inferences. :param prefix: Prefix :return: Dictionary of inferences """""" # filter types if types are given if types is not None: infs = dict((k, v) for k, v in infs.items() if k in types) # add prefix to keys return dict((prefix + '.' + k, v) for k, v in infs.items()) # get joint inferences inferences = get(self.joint_inferences, 'joint') if show_marginals: # include marginal inferences inferences = get(self.marginal_inferences, 'marginal') | inferences # use labels as keys if given if labels is not None: if len(labels) != len(inferences): raise ValueError(f'Number of labels ({len(labels)}) does not match ' f'number of inferences ({len(inferences)}).') inferences = dict(zip(labels, inferences.values())) return inferences @BaseInference._run_if_required_wrapper def plot_discretized( self, file: str = None, show: bool = True, intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), show_marginals: bool = True, confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'original', title: str = 'discretized DFE comparison', labels: List[str] = None, kwargs_legend: dict = dict(prop=dict(size=8)), ax: 'plt.Axes' = None ) -> 'plt.Axes': """""" Plot discretized DFE comparing the different types. :param labels: Labels for types :param title: Title of plot :param intervals: Array of interval boundaries over ``(-inf, inf)`` yielding ``intervals.shape[0] - 1`` bars. :param show_marginals: Whether to also show marginal inferences :param bootstrap_type: Type of bootstrap :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :param ci_level: Confidence level :param confidence_intervals: Whether to plot confidence intervals :param file: File to save plot to :param show: Whether to show plot :param ax: Axes to plot on. Only for Python visualization backend. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :return: Axes object """""" labels, inferences = zip(*self.get_inferences(labels=labels, show_marginals=show_marginals).items()) return Inference.plot_discretized(**locals()) def plot_sfs_comparison( self, sfs_types: List[Literal['modelled', 'observed', 'selected', 'neutral']] = ['observed', 'modelled'], types: List[str] = None, labels: List[str] = None, colors: List[str] = None, file: str = None, show: bool = True, ax: 'plt.Axes' = None, title: str = 'SFS comparison', use_subplots: bool = False, show_monomorphic: bool = False, kwargs_legend: dict = dict(prop=dict(size=8)), ) -> 'plt.Axes': """""" Plot SFS comparison. :param types: Types to plot :param file: File to save plot to :param labels: Labels for types. :param colors: Colors for types. Only for Python visualization backend. :param sfs_types: Types of SFS to plot :param show: Whether to show plot :param ax: Axes to plot on. Only for Python visualization backend and if ``use_subplots`` is ``False``. :param title: Plot title :param use_subplots: Whether to use subplots. Only for Python visualization backend. :param show_monomorphic: Whether to show monomorphic counts :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :return: Axes object """""" from .visualization import Visualization if 'modelled' in sfs_types: self.run_if_required() mapping = dict( observed='sfs_sel', selected='sfs_sel', modelled='sfs_mle', neutral='sfs_neut' ) inferences = self.get_inferences(types=types) def get_label(t: str, sfs_type: str) -> str: """""" Get label for types. :param t: Type :param sfs_type: SFS type :return: Label """""" subtypes = t.split('.') # insert sfs type at second position return '.'.join([subtypes[0]] + [sfs_type] + subtypes[1:]) # get spectra spectra = {get_label(t, sfs): getattr(inf, mapping[sfs]) for t, inf in inferences.items() for sfs in sfs_types} return Visualization.plot_spectra( spectra=[list(v) for v in spectra.values()], labels=list(spectra.keys()) if labels is None else labels, colors=colors, file=file, show=show, ax=ax, title=title, use_subplots=use_subplots, show_monomorphic=show_monomorphic, kwargs_legend=kwargs_legend ) @BaseInference._run_if_required_wrapper def plot_continuous( self, file: str = None, show: bool = True, intervals: np.ndarray = None, confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', title: str = 'DFE comparison', labels: List[str] = None, scale_density: bool = False, scale: Literal['lin', 'log', 'symlog'] = 'lin', kwargs_legend: dict = dict(prop=dict(size=8)), ax: 'plt.Axes' = None ) -> 'plt.Axes': """""" Plot discretized DFE. The special constants ``np.inf`` and ``-np.inf`` are also valid interval bounds. By default, the PDF is plotted as is. Due to the logarithmic scale on the x-axis, we may get a wrong intuition on how the mass is distributed, however. To get a better intuition, we can optionally scale the density by the x-axis interval size using ``scale_density = True``. This has the disadvantage that the density now changes for x, so that even a constant density will look warped. :param scale_density: Whether to scale the density by the x-axis interval size :param scale: y-scale :param labels: Labels for types :param title: Title of plot :param bootstrap_type: Type of bootstrap :param ci_level: Confidence level :param confidence_intervals: Whether to plot confidence intervals :param file: File to save plot to :param show: Whether to show plot :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :param ax: Axes to plot on. Only for Python visualization backend. :return: Axes object """""" if intervals is None: intervals = self.discretization.bins labels, inferences = zip(*self.get_inferences(labels=labels).items()) return Inference.plot_continuous(**locals()) @BaseInference._run_if_required_wrapper def plot_inferred_parameters( self, file: str = None, confidence_intervals: bool = True, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', ci_level: float = 0.05, show: bool = True, title: str = 'inferred parameters', labels: List[str] = None, ax: 'plt.Axes' = None, scale: Literal['lin', 'log', 'symlog'] = 'log', kwargs_legend: dict = dict(prop=dict(size=8), loc='upper right'), **kwargs: List[str] ) -> 'plt.Axes': """""" Plot discretized DFE comparing the different types. :param labels: Labels for types :param title: Title of plot :param bootstrap_type: Type of bootstrap :param ci_level: Confidence level :param confidence_intervals: Whether to plot confidence intervals :param file: File to save plot to :param show: Whether to show plot :param ax: Axes to plot on. Only for Python visualization backend. :param scale: y-scale :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :return: Axes object """""" labels, inferences = zip(*self.get_inferences(labels=labels).items()) return Inference.plot_inferred_parameters(**locals()) @BaseInference._run_if_required_wrapper def plot_inferred_parameters_boxplot( self, file: str = None, show: bool = True, title: str = 'inferred parameters', labels: List[str] = None, **kwargs: List[str] ) -> 'plt.Axes': """""" Plot discretized DFE comparing the different types. :param labels: Labels for types :param title: Title of plot :param file: File to save plot to :param show: Whether to show plot :return: Axes object :raises ValueError: If no inference objects are given or no bootstraps are found. """""" labels, inferences = zip(*self.get_inferences(labels=labels).items()) return Inference.plot_inferred_parameters_boxplot(**locals()) @BaseInference._run_if_required_wrapper def plot_covariate( self, index: int = 0, file: str = None, show: bool = True, title: str = None, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'original', show_types: bool = True, ci_level: float = 0.05, xlabel: str = ""cov"", ylabel: str = None, ax: 'plt.Axes' = None ) -> 'plt.Axes': """""" Plot the covariate given by the index. :param index: The index of the covariate. :param file: File to save plot to. :param show: Whether to show plot. :param title: Plot title. :param bootstrap_type: Bootstrap type. :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :param show_types: Whether to show types on second x-axis. :param ci_level: Confidence level. :param xlabel: X-axis label. :param ylabel: Y-axis label, defaults to the covariate parameter name. :param ax: Axes to plot on. Only for Python visualization backend. :return: Axes object. """""" from .visualization import Visualization key = f""c{index}"" # check if covariate exists if key not in self.covariates: raise ValueError(f""Covariate with index {index} does not exist."") # default title if title is None: title = f'covariate {key}' cov = self.covariates[key] values = [self.params_mle[t][cov.param] for t in self.types] # get errors if bootstrapped errors = None if self.bootstraps is not None: bootstraps = np.array([self.bootstraps[f""{t}.{cov.param}""] for t in self.types]).T # compute errors values, errors, _ = Bootstrap.get_errors( values=values, bs=bootstraps, bootstrap_type=bootstrap_type, ci_level=ci_level, point_estimate=point_estimate ) return Visualization.plot_covariate( covariates=[cov.values[t] for t in self.types], values=values, errors=errors, file=file, show=show, title=title, xlabel=xlabel, ylabel=ylabel or cov.param, labels=self.types if show_types else None, ax=ax ) def get_discretized( self, intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'mean' ) -> Dict[str, Tuple[np.ndarray, np.ndarray]]: """""" Get discretized DFEs. :param intervals: Array of interval boundaries over ``(-inf, inf)`` yielding ``intervals.shape[0] - 1`` bins. :param confidence_intervals: Whether to return confidence intervals :param ci_level: Confidence interval level :param bootstrap_type: Type of bootstrap :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :return: Dictionary of array of values and array of errors indexed by inference type """""" return Inference.get_discretized( inferences=list(self.get_inferences().values()), labels=list(self.get_inferences().keys()), intervals=intervals, confidence_intervals=confidence_intervals, ci_level=ci_level, bootstrap_type=bootstrap_type, point_estimate=point_estimate ) def get_bootstrap_params(self) -> Dict[str, float]: """""" Get bootstrap parameters. :return: Bootstrap parameters """""" return flatten_dict(dict((t, self.joint_inferences[t].get_bootstrap_params()) for t in self.types)) def to_json(self) -> str: """""" Serialize object. Note that the deserialized inference objects no longer share the same optimization instance among other things. :return: JSON string """""" # using make_ref=True resulted in weird behaviour when unserializing. return jsonpickle.encode(self, indent=4, warn=True, make_refs=False) @functools.cached_property def alpha(self) -> Optional[float]: """""" The is no single alpha for the joint inference. Please refer to the ``self.joint_inferences[t].alpha``. :return: None """""" return def _set_fixed_params(self, params: Dict[str, Dict[str, float]]): """""" Set fixed parameters. :param params: Fixed parameters """""" # set for 'all' type self.marginal_inferences['all']._set_fixed_params(params) # expand types self.fixed_params = expand_fixed(params, self.types) # propagate to inference objects for t in self.types: self.marginal_inferences[t]._set_fixed_params(dict(all=self.fixed_params[t])) self.joint_inferences[t]._set_fixed_params(dict(all=self.fixed_params[t])) # propagate to optimization self.optimization.set_fixed_params(self.fixed_params) # check if the fixed parameters are compatible with the shared parameters self.check_no_shared_params_fixed() def get_residual(self, k: int) -> float: """""" Residual of joint inference. We calculate the residual over the jointly inferred SFS for all types. :param k: Order of the norm :return: L2 residual """""" counts_mle = np.array([inf.sfs_mle.polymorphic for inf in self.joint_inferences.values()]).flatten() counts_sel = np.array([inf.sfs_sel.polymorphic for inf in self.joint_inferences.values()]).flatten() return norm(counts_mle - counts_sel, k) def get_alpha(self, params: dict = None) -> float: """""" Get alpha, the proportion of beneficial non-synonymous substitutions. :param params: DFE parameters to use for calculation of format `{type: {param: value}}`. """""" if params is None: params = self.params_mle alphas = {} for t in self.types: alphas[t] = self.discretization.get_alpha(self.model, params[t]) return alphas ","Python" "Allele","Sendrowski/fastDFE","fastdfe/settings.py",".py","375","19",""""""" Package-wide settings """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-09-12"" class Settings: """""" Class that holds package-wide settings """""" #: Whether to disable the progress bar. disable_pbar = False #: Whether to use parallel processing. Use ``None`` for local setting. parallelize = None ","Python" "Allele","Sendrowski/fastDFE","fastdfe/likelihood.py",".py","2556","98",""""""" MLE utilities. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" import numpy as np from scipy.special import factorial from scipy.stats import poisson class Likelihood: """""" Utilities for computing Poisson likelihoods. """""" #: Epsilon for numerical stability eps = 1e-50 @staticmethod def add_epsilon(x: np.ndarray) -> np.ndarray: """""" Add epsilon to zero counts. :param x: Array to add epsilon to :return: Array with epsilon added to zero counts """""" # convert to float x = x.astype(float) # replace 0s with epsilon to avoid log(0) x[x == 0] = Likelihood.eps return x @staticmethod def poisson(mu: np.ndarray, k: np.ndarray) -> np.ndarray: """""" Compute Poisson(mu, k). :param mu: Mean of Poisson distribution :param k: Number of events :return: Poisson(mu, k) """""" # add epsilon to zero counts mu = Likelihood.add_epsilon(mu) return poisson.pmf(k, mu) @staticmethod def log_poisson(mu: np.ndarray, k: np.ndarray) -> np.ndarray: """""" Compute log(Poisson(mu, k)). :param mu: Mean of Poisson distribution :param k: Number of events :return: log(Poisson(mu, k)) """""" # add epsilon to zero counts mu = Likelihood.add_epsilon(mu) return k * np.log(mu) - mu - Likelihood.log_factorial(k) @staticmethod def log_factorial_stirling(n: np.ndarray | float) -> np.ndarray | float: """""" Use Stirling's approximation for values larger than n_threshold. https://en.wikipedia.org/wiki/Stirling%27s_approximation :param n: n :return: log(n!) """""" # np.log(np.sqrt(2 * np.pi * n) * (n / np.e) ** n * (1 + 1 / (12 * n))) return 0.5 * np.log(2 * np.pi * n) + n * np.log(n / np.e) + np.log(1 + 1 / (12 * n)) @staticmethod def log_factorial(n: np.ndarray, n_threshold: int = 100) -> np.ndarray: """""" Compute log(n!). :param n: n :param n_threshold: Threshold for using Stirling's approximation :return: log(n!) """""" x = np.zeros_like(n, dtype=np.float64) low = n <= n_threshold # compute for low values of n x[low] = np.log(factorial(n[low])) # use Stirling's approximation for large value of n x[~low] = Likelihood.log_factorial_stirling(n[~low]) return x ","Python" "Allele","Sendrowski/fastDFE","fastdfe/optimization.py",".py","45984","1370",""""""" Optimization module. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" import copy import logging import math from dataclasses import dataclass from typing import Callable, List, Dict, Literal, Tuple, Optional, Sequence import multiprocess as mp import numpy as np import pandas as pd from numpy.linalg import norm from numpy.random import Generator from scipy.stats import loguniform, uniform from tqdm import tqdm from .likelihood import Likelihood from .settings import Settings # get logger logger = logging.getLogger('fastdfe').getChild('Optimization') def parallelize( func: Callable, data: Sequence, parallelize: bool = True, pbar: bool = None, desc: str = None, dtype: type = object, wrap_array: bool = True ) -> np.ndarray: """""" Parallelize given function or execute sequentially. :param parallelize: Whether to parallelize :param data: Data to iterate over :param func: Function to apply to each element of data :param pbar: Whether to show a progress bar :param desc: Description for progress bar :param dtype: Data type of the returned array :param wrap_array: Whether to wrap the result in a numpy array :return: List of results """""" n = len(data) if parallelize and n > 1 and Settings.parallelize is not False: # parallelize iterator = mp.Pool().imap(func, data) else: # sequentialize iterator = map(func, data) # whether to show a progress bar if pbar is True or (pbar is None and n > 1): iterator = tqdm(iterator, total=n, disable=Settings.disable_pbar, desc=desc) if wrap_array: return np.array(list(iterator), dtype=dtype) return list(iterator) def flatten_dict(d: dict, separator='.', prefix=''): """""" Flatten dictionary. :param d: The nested dictionary :param separator: The separator character to use in the flattened dictionary keys :param prefix: The prefix to use in the flattened dictionary keys :return: The flattened dictionary """""" res = {} for key, value in d.items(): if isinstance(value, dict): # recursive call res.update(flatten_dict(value, separator, prefix + key + separator)) else: res[prefix + key] = value return res def unflatten_dict(d: dict, separator='.'): """""" Unflatten dictionary. :param d: The flattened dictionary :param separator: The separator character used in the flattened dictionary keys :return: The original nested dictionary """""" res = {} for key, value in d.items(): subkeys = key.split(separator) subdict = res # recursively create nested dictionaries for each subkey for subkey in subkeys[:-1]: subdict = subdict.setdefault(subkey, {}) # assign value to the final subkey subdict[subkeys[-1]] = value if not isinstance(value, dict) else unflatten_dict(value, separator) return res def unpack_params(x: np.ndarray, original: Dict[str, dict | tuple | float]) -> Dict[str, dict | tuple | float]: """""" Unpack params from numpy array. This is the inverse of pack_params and is used as scipy.optimize.minimize only accepts numpy arrays as parameters. :param x: Numpy array :param original: Original dictionary :return: Unpacked dictionary """""" keys = flatten_dict(original).keys() return unflatten_dict(dict(zip(keys, x))) def pack_params(params: Dict[str, dict | tuple | float]) -> np.ndarray: """""" Pack params into numpy array. This is used as scipy.optimize.minimize only accepts numpy arrays as parameters. This is the inverse of unpack_params. :param params: Dictionary to pack :return: numpy array """""" flattened = flatten_dict(params) return np.array(list(flattened.values())) def filter_dict(d, keys): """""" Recursively filter a dictionary by a list of given keys at the deepest level. :param d: The dictionary to filter :param keys: The list of keys to keep in the filtered dictionary :return: The filtered dictionary """""" filtered = {} for key, value in d.items(): if isinstance(value, dict): filtered_sub = filter_dict(value, keys) if filtered_sub: filtered[key] = filtered_sub else: if key in keys: filtered[key] = value return filtered def pack_shared( params: Dict[str, Dict[str, float]], shared: List['SharedParams'], shared_values: Dict[str, float] ) -> Dict[str, Dict[str, float]]: """""" Pack shared parameters. Here we extract shared parameters from type-specific keys and instead create entries with joint-types holding the shared parameters. Note that we only delete parameters from marginal types but in some cases we would have to delete them from compound types as well if a more general shared parameter were to be specified later on. We instead rely on the user not to do this. :param params: Dictionary of parameters indexed by type :param shared: List of shared parameters :param shared_values: Dictionary of parameters indexed by joint-type and parameter name, i.e. 'type1:type2.p1' :return: Packed dictionary """""" packed = copy.deepcopy(params) # iterator through shared parameter for s in shared: # remove shared keys for t in s.types: for p in s.params: if p in packed[t]: packed[t].pop(p) # create joint type string type_string = ':'.join(s.types) # create shared type with appropriate parameters packed = merge_dicts(packed, {type_string: dict((p, shared_values[type_string + '.' + p]) for p in s.params)}) return packed def unpack_shared(params: dict) -> dict: """""" Unpack shared parameters. Here we extract shared parameters from joint-type keys and add them tp the targeted types. :param params: Dictionary of parameters :return: Unpacked dictionary """""" unpacked = {} for t, v in params.items(): if ':' in t: unpacked = merge_dicts(unpacked, dict((s, v) for s in t.split(':'))) else: unpacked[t] = v return unpacked def expand_shared(params: List['SharedParams'], types: List[str], names: List[str]) -> List['SharedParams']: """""" Expand 'all' type for shared parameters. :param params: List of shared parameters :param types: List of types :param names: List of parameter names :return: Expanded list of shared parameters """""" expanded = [] for x in params: # expand 'all' type types = types if x.types == 'all' else x.types params = names if x.params == 'all' else x.params # noinspection PyTypeChecker expanded.append(SharedParams(types=types, params=params)) return expanded def expand_fixed( fixed_params: Dict[str, Dict[str, float]], types: List[str] ) -> Dict[str, Dict[str, float]]: """""" Expand 'all' type for shared parameters. :param fixed_params: Dictionary of fixed parameters indexed by type and parameter :param types: List of types :return: Expanded dictionary of fixed parameters """""" expanded = {} # loop through fixed parameters for key_type, params in fixed_params.items(): # expand 'all' type key_types = types if key_type == 'all' else [key_type] # loop through types for t in key_types: if t not in expanded: expanded[t] = {} if isinstance(params, dict): for param, value in params.items(): expanded[t][param] = value return expanded def collapse_fixed_to_mean( expanded_params: Dict[str, Dict[str, float]], types: List[str] ) -> Dict[str, Dict[str, float]]: """""" Collapse expanded fixed parameters to 'all' type if all types have the same fixed parameter. Take the mean of the fixed parameters. :param expanded_params: Expanded dictionary of fixed parameters :param types: List of types :return: Collapsed dictionary of fixed parameters """""" out = {""all"": dict(expanded_params.get(""all"", {}))} # collect params appearing in any type params = set() for t in types: params |= expanded_params.get(t, {}).keys() for p in params: vals = [expanded_params[t][p] for t in types if p in expanded_params.get(t, {})] if len(vals) == len(types): out[""all""][p] = float(np.mean(vals)) return out def collapse_fixed( expanded_params: Dict[str, Dict[str, float]], types: List[str] ) -> Dict[str, Dict[str, float]]: """""" Collapse expanded fixed parameters to 'all' type if all types have the same fixed parameter. :param expanded_params: Expanded dictionary of fixed parameters :param types: List of types :return: Collapsed dictionary of fixed parameters """""" # copy first out = {k: dict(v) for k, v in expanded_params.items()} out.setdefault(""all"", {}) # find params present in *every* type with identical value common = None for t in types: d = expanded_params.get(t, {}) keys = set(d.keys()) common = keys if common is None else (common & keys) if not common: return out for p in list(common): vals = [expanded_params[t][p] for t in types] if all(v == vals[0] for v in vals): out[""all""][p] = vals[0] for t in types: out[t].pop(p, None) return out def merge_dicts(dict1: dict, dict2: dict) -> dict: """""" Merge two dictionaries recursively. :param dict1: First dictionary :param dict2: Second dictionary :return: Merged dictionary """""" # make a copy of the first dictionary result = dict(dict1) # loop through the items in the second dictionary for key, value in dict2.items(): # Check if the key already exists in the result dictionary and both the # value in the result and dict2 dictionaries are dictionaries. if key in result and isinstance(result[key], dict) and isinstance(value, dict): # recursively merge the two dictionaries result[key] = merge_dicts(result[key], value) else: # simply assign the value from dict2 to the result dictionary result[key] = value return result def correct_values( params: Dict[str, float], bounds: Dict[str, Tuple[float, float]], scales: Dict[str, Literal['lin', 'log', 'symlog']], warn: bool = False, threshold: float = 1e-6 ) -> Dict[str, float]: """""" Correct initial values so that they are within the specified bounds. :param bounds: Dictionary of bounds :param params: Flattened dictionary of parameters :param scales: Dictionary of scales :param warn: Whether to warn if values are corrected :param threshold: Threshold for the error to trigger a warning :return: Corrected dictionary """""" # create a copy of params corrected = params.copy() for key, value in params.items(): # get base name name = key.split('.')[-1] # get real bounds bound = get_real_bounds(bounds[name], scale=scales[name]) # correct value if outside bounds if value < bound[0]: corrected[key] = bound[0] elif value > bound[1]: corrected[key] = bound[1] # differences between the original and corrected dictionaries differences = {key: (params[key], corrected[key]) for key in params if params[key] != corrected[key]} # warn if there are differences that exceed the threshold exceeded_threshold = {} for key, (old_val, new_val) in differences.items(): # calculate relative error err = np.abs(new_val - old_val) # add if it exceeds the relative error if err > threshold: exceeded_threshold[key] = f""{old_val} -> {new_val}"" if exceeded_threshold and warn: logger.warning(f'Given initial values outside bounds. Adjusting {exceeded_threshold}.') return corrected def get_real_bounds(bounds: Tuple[float, float], scale: Literal['lin', 'log', 'symlog']) -> Tuple[float, float]: """""" Get real bounds from the given bounds. :param bounds: Bounds of the parameter :param scale: Scale of the parameter :return: """""" if scale == 'symlog': return -bounds[1], bounds[1] return bounds def evaluate_counts(get_counts: dict, params: dict): """""" Evaluate counts using the given parameters. Here we assign the parameters to the appropriate types obtaining the counts for each type. :param get_counts: Dictionary of functions to evaluate counts for each type :param params: Dictionary of parameters :return: Dictionary of counts """""" counts = {} # unpack shared parameters unpacked = unpack_shared(params) # evaluate counts for each type for key in get_counts.keys(): counts[key] = get_counts[key](unpacked[key]) return counts def to_symlog(x: float, linthresh: float = 1e-5) -> float: """""" Convert a value to the symlog scale. :param x: The input value on the original scale. :param linthresh: The positive value that determines the range within which the symlog scale is linear. Must be greater than 0. :return: The value on the symlog scale. """""" sign = np.sign(x) abs_x = np.abs(x) log_x = np.log10(abs_x + linthresh) - np.log10(linthresh) return sign * (abs_x / linthresh if abs_x <= linthresh else log_x) def from_symlog(y: float, linthresh: float = 1e-5) -> float: """""" Convert a value from the symlog scale back to the original scale. :param y: The input value on the symlog scale. :param linthresh: The positive value that determines the range within which the symlog scale is linear. Must be greater than 0. :return: The value on the original scale. """""" sign = np.sign(y) abs_y = np.abs(y) exp_y = np.power(10, abs_y + np.log10(linthresh)) - linthresh return sign * (abs_y * linthresh if abs_y <= 1 else exp_y) def scale_bound(bounds: Tuple[float, float], scale: Literal['lin', 'log', 'symlog']): """""" Convert a bound to the specified scale. For symlog scale we assume the symmetric bounds, so that the upper bound denotes the boundaries and the lower bound the linear threshold. :param bounds: The bound to convert :param scale: The scale to convert to :return: The converted bound :raises ValueError: if the scale is unknown """""" if scale == 'lin': return bounds if scale == 'log': if bounds[1] < 0: return -np.log10(-bounds[0]), -np.log10(-bounds[1]) if bounds[0] > 0: return np.log10(bounds[0]), np.log10(bounds[1]) raise ValueError('Bounds must not span zero for log scale.') if scale == 'symlog': if bounds[0] <= 0 or bounds[1] <= 0: raise ValueError('Both bounds must be positive for symlog scale.') return to_symlog(-bounds[1], linthresh=bounds[0]), to_symlog(bounds[1], linthresh=bounds[0]) raise ValueError(f'Unknown scale {scale}.') def unscale_bound( scaled_bounds: Tuple[float, float], scale: Literal['lin', 'log', 'symlog'], linthresh: float = 1e-5 ) -> Tuple[float, float]: """""" Convert a bound from the specified scale back to the original scale. For symlog scale, we assume symmetric bounds, so that the upper bound denotes the boundaries and the lower bound the linear threshold, i.e. ``bounds = (-bounds[1], bounds[1])`` and ``linthresh = bounds[0]``. Note that we cannot reliably recover negative bounds that were log scaled. :param linthresh: :param scaled_bounds: The bound to convert :param scale: The scale to convert from :return: The converted bound :raises ValueError: if the scale is unknown """""" if scale == 'lin': return scaled_bounds if scale == 'log': return np.power(10, scaled_bounds[0]), np.power(10, scaled_bounds[1]) if scale == 'symlog': upper_bound = from_symlog(scaled_bounds[1], linthresh=linthresh) return linthresh, upper_bound raise ValueError(f'Unknown scale {scale}.') def scale_bounds( bounds: Dict[str, Tuple[float, float]], scales: Dict[str, Literal['lin', 'log', 'symlog']] ) -> Dict[str, Tuple[float, float]]: """""" Convert bounds to the specified scale. For symlog scale we assume the symmetric bounds, so that the upper bound denotes the boundaries and the lower bound the linear threshold. :param bounds: Flattened dictionary of bounds to convert index by type and parameter :param scales: Dictionary of scales indexed by parameter :return: The converted bounds :raises ValueError: if the scale is unknown """""" scaled_bounds = {} for key, value in bounds.items(): scaled_bounds[key] = scale_bound(value, scale=scales[get_basename(key)]) return scaled_bounds def scale_value(value: float, bounds: Tuple[float, float], scale: Literal['lin', 'log', 'symlog']) -> float: """""" Convert a value to the specified scale. For symlog scale, the untransformed bounds are needed, so that the upper bound denotes the boundaries and the lower bound the linear threshold. :param value: The value to convert. :param bounds: The untransformed bounds for the symlog scale. :param scale: The scale to convert to. :return: The converted value. :raises ValueError: if the scale is unknown. """""" if scale == 'lin': return value if scale == 'log': if value < 0: return -np.log10(-value) return np.log10(value) if scale == 'symlog': return to_symlog(value, linthresh=bounds[0]) raise ValueError(f'Unknown scale {scale}.') def unscale_value(scaled_value: float, bounds: Tuple[float, float], scale: Literal['lin', 'log', 'symlog']) -> float: """""" Convert a value from the specified scale back to the original scale. For symlog scale, the untransformed bounds are needed, so that the upper bound denotes the boundaries and the lower bound the linear threshold. :param scaled_value: The value to convert. :param bounds: The untransformed bounds for the symlog scale. :param scale: The scale to convert from. :return: The converted value. :raises ValueError: if the scale is unknown. """""" if scale == 'lin': return scaled_value if scale == 'log': if bounds[1] < 0: return -np.power(10, -scaled_value) return np.power(10, scaled_value) if scale == 'symlog': return from_symlog(scaled_value, linthresh=bounds[0]) raise ValueError(f'Unknown scale {scale}.') def perturb_value(value: float, bounds: Tuple[float, float], rng: np.random.Generator) -> float: """""" Perturb a value within the given bounds using a normal distribution with mean at the value and standard deviation equal to the value. :param value: The value to perturb. :param bounds: The bounds to perturb within. :param rng: The random number generator to use. :return: The perturbed value. """""" std = 2 * abs(value) if value != 0 else 0.1 * abs(bounds[1] - bounds[0]) perturbed = rng.normal(loc=value, scale=std) # ensure within bounds perturbed = max(bounds[0], min(bounds[1], perturbed)) return perturbed def scale_values( params: Dict[str, Dict[str, float]], bounds: Dict[str, Tuple[float, float]], scales: Dict[str, Literal['lin', 'log', 'symlog']] ) -> Dict[str, Dict[str, float]]: """""" Scale values according to the given scales. :param params: Nested dictionary of parameters indexed by type and parameter :param scales: Dictionary of scales indexed by parameter name :param bounds: Dictionary of bounds indexed by parameter name :return: Nested dictionary of scaled parameters indexed by type and parameter """""" scaled = {} for key, value in flatten_dict(params).items(): # scale value scaled[key] = scale_value(value, bounds[get_basename(key)], scales[get_basename(key)]) return unflatten_dict(scaled) def unscale_values( params: Dict[str, Dict[str, float]], bounds: Dict[str, Tuple[float, float]], scales: Dict[str, Literal['lin', 'log', 'symlog']] ) -> Dict[str, Dict[str, float]]: """""" Unscale values according to the given scales. :param params: Nested dictionary of parameters indexed by type and parameter :param scales: Dictionary of scales indexed by parameter name :param bounds: Dictionary of scales indexed by parameter name :return: Nested dictionary of unscaled parameters indexed by type and parameter """""" unscaled = {} for key, value in flatten_dict(params).items(): # unscale value unscaled[key] = unscale_value(value, bounds[get_basename(key)], scales[get_basename(key)]) return unflatten_dict(unscaled) def get_basename(name: str) -> str: """""" Get the basename of parameter string, i.e. type.param -> param. :param name: The string to get the basename from. :return: The basename. """""" return name.split('.')[-1] def check_bounds( bounds: Dict[str, Tuple[float, float]], params: Dict[str, float], fixed_params: Dict[str, float] = {}, percentile: float = 1, scale: Literal['lin', 'log'] = 'lin' ) -> Tuple[Dict[str, Tuple[float, float, float]], Dict[str, Tuple[float, float, float]]]: """""" Issue warnings if the passed parameters are close to the specified bounds. :param bounds: The bounds to check against. :param params: The parameters to check. :param fixed_params: The fixed parameters. :param percentile: The percentile threshold to consider a parameter close to the bounds. :param scale: Scale type: 'lin' for linear and 'log' for logarithmic. :return: Tuple of dictionaries of parameters close to the lower and upper bounds, i.e. (lower, value, upper). """""" near_lower = {} near_upper = {} def transform(value: float, to_scale: Literal['lin', 'log']) -> float: """""" Transform a value to the specified scale. :param value: The value to transform. :param to_scale: The scale to transform to. :return: The transformed value. """""" if to_scale == 'log': return math.log(value) if value > 0 else -float('inf') return value for key, value in params.items(): # get base name name = key.split('.')[-1] # get bounds lower, upper = bounds[name] # transform values _lower = transform(lower, scale) _upper = transform(upper, scale) _value = transform(value, scale) if key not in fixed_params: if _lower is not None and (_value - _lower) / (_upper - _lower) <= percentile / 100: near_lower[key] = (lower, value, upper) if _upper is not None and (_upper - _value) / (_upper - _lower) <= percentile / 100: near_upper[key] = (lower, value, upper) return near_lower, near_upper @dataclass class SharedParams: """""" Class specifying the sharing of params among types. ``all`` means all available types or params. Example usage: :: import fastdfe as fd # neutral SFS for two types sfs_neut = fd.Spectra(dict( pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] )) # selected SFS for two types sfs_sel = fd.Spectra(dict( pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] )) # create inference object inf = fd.JointInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, shared_params=[fd.SharedParams(types=[""pendula"", ""pubescens""], params=[""eps"", ""S_d""])], do_bootstrap=True ) # run inference inf.run() """""" #: The params to share params: List[str] | Literal['all'] = 'all' #: The types to share types: List[str] | Literal['all'] = 'all' @dataclass class Covariate: """""" Class defining a covariate which induces a relationship with one or many parameters. The relationship is defined by a callback function which modifies the parameters. The default callback introduces a linear relationship. Below an example of introducing linear covariates for ``S_d``, the for mean strength of deleterious mutations (cf. :class:`~fastdfe.parametrization.GammaExpParametrization`). Each of the three types is associated with one covariate. This we pass to :class:`~fastdfe.joint_inference.JointInference` together with the stratified spectra: :: import fastdfe as fd cov = fd.Covariate( param='S_d', values=dict(type1=5, type2=3, type3=1) ) """""" #: The parameter to modify param: str #: The values of the covariate for each type values: Dict[str, float] #: The callback function to modify the parameters callback: Optional[Callable] = None #: The bounds of the covariate parameter to be estimated bounds: tuple = (1e-4, 1e4) #: The initial value of the covariate x0: float = 0 #: The scale of the bounds. See :func:`scale_value` for details bounds_scale: Literal['lin', 'log', 'symlog'] = 'symlog' def __post_init__(self): """""" Cast bounds to tuple and check if an inverse_callback is provided when a custom callback is specified. """""" self.bounds = tuple(self.bounds) def apply(self, covariate: float, type: str, params: Dict[str, float]) -> Dict[str, float]: """""" Apply the custom or default callback to modify the given parameters. :param covariate: The value of the covariate. :param type: The type of the relationship. :param params: The input parameters. :return: Modified parameters. """""" # Use custom callback if given else default callback callback = self.apply_default if self.callback is None else self.callback return callback(covariate=covariate, type=type, params=params) def apply_default(self, covariate: float, type: str, params: Dict[str, float]) -> Dict[str, float]: """""" Modify the given parameters introducing a linear relationship with the given covariate. :param covariate: The value of the covariate. :param type: The type of the relationship. :param params: The input parameters. :return: Modified parameters. """""" # create a copy of input parameters modified = params.copy() # introduce linear relationship if self.param in params: modified[self.param] += covariate * self.values[type] return modified @staticmethod def _apply(covariates: Dict[str, 'Covariate'], params: dict, type: str) -> dict: """""" Apply given covariates to given parameters. :param covariates: Dictionary of covariates to add :param params: Dict of parameters :param type: SFS type :return: Dict of parameters with covariates added """""" for k, cov in covariates.items(): params = cov.apply( covariate=params[k], type=type, params=params ) return params class Optimization: """""" Class for optimizing the DFE. """""" #: Optimization method to use. Use class property for downward compatibility method_mle = 'L-BFGS-B' def __init__( self, bounds: Dict[str, Tuple[float, float]], param_names: List[str], loss_type: Literal['likelihood', 'L2'] = 'likelihood', opts_mle: dict = {}, method_mle: str = 'L-BFGS-B', parallelize: bool = True, fixed_params: Dict[str, Dict[str, float]] = {}, scales: Dict[str, Literal['lin', 'log', 'symlog']] = {}, seed: int = None ): """""" Create object. :param parallelize: Whether to parallelize the optimization :param bounds: Dictionary of bounds :param opts_mle: Dictionary of options for the optimizer :param method_mle: Optimization method to use :param loss_type: Type of loss function to use :param fixed_params: Dictionary of fixed parameters :param scales: Dictionary of scales :param param_names: List of parameter names """""" #: Parameter bounds self.bounds: Dict[str, Tuple[float, float]] = bounds #: Parameter scales to use self.scales: Dict[str, Literal['lin', 'log', 'symlog']] = scales #: additional options for the optimizer self.opts_mle: dict = opts_mle #: Optimization method to use self.method_mle: str = method_mle #: Type of loss function to use self.loss_type: str = loss_type #: Fixed parameters self.fixed_params: Dict[str, Dict[str, float]] = flatten_dict(fixed_params) # check if fixed parameters are within the specified bounds if correct_values(self.fixed_params, self.bounds, warn=False, scales=scales) != self.fixed_params: raise ValueError('Fixed parameters are outside the specified bounds. ' f'Fixed params: {self.fixed_params}, bounds: {self.bounds}.') #: Parameter names self.param_names: List[str] = param_names #: Whether to parallelize the optimization self.parallelize: bool = parallelize #: Initial values self.x0: Optional[dict] = None #: Number of runs self.n_runs: Optional[int] = None #: DataFrame holding information about all optimization runs self.runs: Optional[pd.DataFrame] = None #: Random generator instance self.rng = np.random.default_rng(seed=seed) def run( self, get_counts: Dict[str, Callable], x0: Dict[str, Dict[str, float]] = {}, scales: Dict[str, Literal['lin', 'log', 'symlog']] = {}, bounds: Dict[str, Tuple[float, float]] = {}, n_runs: int = 1, debug_iterations: bool = True, print_info: bool = True, opts_mle: dict = None, pbar: bool = None, desc: str = 'Inferring DFE', ) -> Tuple['scipy.optimize.OptimizeResult', dict]: """""" Perform the optimization procedure. :param scales: Scales of the parameters :param bounds: Bounds of the parameters :param n_runs: Number of independent optimization runs out of which the best one is chosen. The first run will use the initial values if specified. Consider increasing this number if the optimization does not produce good results. :param x0: Dictionary of initial values in the form ``{type: {param: value}}`` :param get_counts: Dictionary of functions to evaluate counts for each type :param debug_iterations: Whether to print debug messages for each iteration :param opts_mle: Dictionary of options for the optimizer :param print_info: Whether to print information about the bounds :param pbar: Whether to show a progress bar :param desc: Description for the progress bar :return: The optimization result and the likelihoods """""" from scipy.optimize import minimize, OptimizeResult # number of optimization runs self.n_runs = n_runs # store the scales of the parameters if scales: self.scales = scales # store the bounds of the parameters if bounds: self.bounds = bounds # store the options for the optimizer if opts_mle: self.opts_mle = opts_mle # filter out unneeded values # this also holds the fixed parameters self.x0 = filter_dict(x0, self.param_names) # flatten initial values flattened = flatten_dict(self.x0) # determine parameter names of parameters to be optimized optimized_param_names = list(set(flattened) - set(self.fixed_params)) # issue debug messages logger.debug(f'Performing optimization on {len(flattened)} parameters: {list(flattened.keys())}.') logger.debug(f'Using initial values: {flattened}.') if print_info: logger.info(f""Optimizing {len(optimized_param_names)} parameters: [{', '.join(optimized_param_names)}]."") # issue warning when the number of parameters to be optimized is large if len(optimized_param_names) > 10: logger.warning(f'A large number of parameters is optimized jointly. ' f'Please be aware that this makes it harder to find a good optimum.') # correct initial values to be within bounds self.x0 = unflatten_dict(correct_values(flattened, self.bounds, warn=True, scales=self.scales)) # determine parameter bounds bounds = self.get_bounds(flatten_dict(self.x0)) def optimize(x0: Dict[str, Dict[str, float]]) -> OptimizeResult: """""" Perform numerical minimization. :param x0: Dictionary of initial values in the form ``{type: {param: value}}`` :return: Optimization result """""" logger.debug(f""Initial parameters: {x0}."") return minimize( fun=self.get_loss_function( get_counts=get_counts, print_debug=debug_iterations ), x0=pack_params(self.scale_values(x0)), method=self.method_mle, bounds=pack_params(scale_bounds(bounds, self.scales)), options=self.opts_mle ) # initial parameters for the samples initial_params = [self.x0] + [self.sample_x0(self.x0) for _ in range(int(self.n_runs) - 1)] # parallelize MLE for different initializations results = parallelize(optimize, initial_params, self.parallelize, pbar=pbar, desc=desc) # build a pandas DataFrame of all runs records = [] for i, res in enumerate(results): params = unpack_params(res.x, self.x0) params = unscale_values(params, self.bounds, self.scales) flat = flatten_dict(params) flat['likelihood'] = -res.fun flat['success'] = res.success flat['result'] = str(str) flat['x0'] = str(flatten_dict(initial_params[i])) records.append(flat) # store runs as DataFrame self.runs = pd.DataFrame(records) # get result with the lowest likelihood result = results[np.argmax(self.runs.likelihood)] # unpack MLE params array into a dictionary params_mle = unpack_params(result.x, self.x0) # unscale parameters params_mle = unscale_values(params_mle, self.bounds, self.scales) # check if the MLE reached one of the bounds if print_info: self.check_bounds(flatten_dict(params_mle)) return result, params_mle def scale_values(self, values: Dict[str, Dict[str, float]]) -> Dict[str, Dict[str, float]]: """""" Scale the values of the parameters. :param values: Dictionary of initial values in the form ``{type: {param: value}}`` :return: Dictionary of scaled initial values """""" return scale_values(values, self.bounds, self.scales) def get_loss_function( self, get_counts: Dict[str, Callable], print_debug: bool = True ) -> Callable: """""" Get the loss function. :param get_counts: Dictionary of functions to evaluate counts for each type :param print_debug: Whether to print debug messages :return: The loss function """""" def loss(x: np.ndarray) -> float: """""" The loss function. :param x: Parameters :return: The loss """""" # unpack parameters into dictionary using the keys of self.x0 params = unpack_params(x, self.x0) # unscale parameters params = unscale_values(params, self.bounds, self.scales) # Model SFS from parameters. # Here the order of types does not matter. # We only collect the counts for types that are # given in get_counts. This makes it possible to # avoid specifying type 'all' which is of no use # in joint inference. counts_dict = evaluate_counts(get_counts, params) # flatten and convert to array counts = np.array(list(counts_dict.values())) # reshape and merge counts_modelled, counts_observed = np.stack(counts, axis=1).reshape(2, -1) # use independent Poisson likelihoods LL = Likelihood.log_poisson(mu=counts_modelled, k=counts_observed) # combine likelihoods ll = np.sum(LL) # compute L2 norm L2 = norm(counts_modelled - counts_observed, 2) # information on iteration iter_info = flatten_dict(params) | dict(likelihood=ll, L2=L2) # log likelihood if print_debug: # check likelihood if np.isnan(ll): raise ValueError('Oh boy, likelihood is nan. This is no good...') # log variables logger.debug(iter_info) # return appropriate loss return dict(L2=L2, likelihood=-ll)[self.loss_type] return loss def sample_x0(self, example: dict, random_state: int | Generator = None) -> Dict[str, dict]: """""" Sample initial values. :param example: An example dictionary for generating the initial values :param random_state: Random state or seed :return: A dictionary of initial values """""" if random_state is None: random_state = self.rng sample = {} for key, value in example.items(): if isinstance(value, dict): sample[key] = self.sample_x0(value, random_state) elif key in self.bounds and key in self.scales: sample[key] = self.sample_value(self.bounds[key], self.scales[key], random_state) return sample @staticmethod def sample_value( bounds: Tuple[float, float], scale: Literal['lin', 'log', 'symlog'], random_state: int | Generator = None ) -> float: """""" Sample a value between given bounds using the given scaling. This function works for positive, negative, and mixed bounds. Note that when ``scale == 'symlog'``, ``bounds[0]`` defines the linear threshold and the actual bounds are ``(-bounds[1], bounds[1])``. :param bounds: Tuple of lower and upper bounds :param scale: Scaling of the parameter. :param random_state: Random state or seed :return: Sampled value """""" def flip(bounds: Tuple[float, float]) -> Tuple[float, float]: """""" Flip the bounds. :param bounds: Tuple of lower and upper bounds :return: Flipped bounds """""" return -bounds[1], -bounds[0] def symlog_rvs(lower: float, upper: float, random_state: int | Generator = None) -> float: """""" Sample from a symmetric log-uniform distribution. :param lower: Lower bound which is the linear threshold :param upper: Upper bound so that the actual bounds are (-upper, upper) :param random_state: Random state :return: Sampled value """""" val = loguniform.rvs(lower, upper, random_state=random_state) # flip sign with 50% probability return val if uniform.rvs() < 0.5 else -val # dictionary of scaling functions scaling_functions = { 'lin': uniform.rvs, 'log': loguniform.rvs, 'symlog': symlog_rvs } # raise an error if the scale is not valid if scale not in scaling_functions: raise ValueError(f""Scale must be one of: {', '.join(scaling_functions.keys())}"") # raise an error if bounds span 0 and scale is 'log' if bounds[0] < 0 < bounds[1] and scale == 'log': raise ValueError(f""Log scale not possible for bounds that span 0."") # raise an error if bounds are negative and scale is 'symlog' if bounds[0] < 0 and scale == 'symlog': raise ValueError(f""Symlog scale not possible for negative bounds."") # flip bounds if they are negative flipped = bounds[0] < 0 if flipped: bounds = flip(bounds) # sample a value using the appropriate scaling function sample = scaling_functions[scale](bounds[0], bounds[1] - bounds[0], random_state=random_state) # return the sampled value, flipping back if necessary return -sample if flipped else sample def check_bounds(self, params: Dict[str, float], percentile: float = 1) -> None: """""" Check if the given parameters are within the bounds. :param params: Parameters :param percentile: Percentile of the bounds to check :return: Whether the parameters are within the bounds """""" # we scale the bounds to obtain more sensible warnings bounds = scale_bounds(self.bounds, self.scales) params_scaled = flatten_dict(self.scale_values(unflatten_dict(params))) # get parameters close to the bounds near_lower, near_upper = check_bounds( params=params_scaled, bounds=bounds, fixed_params=self.fixed_params, percentile=percentile, scale='lin' ) if len(near_lower | near_upper) > 0: def get_values(keys: List[str]) -> Dict[str, Tuple[str, str, str]]: """""" Unscale the parameters. :param keys: List of parameter names :return: Unscaled parameters """""" unscaled = {} for key in keys: unscaled[key] = ( ""{:g}"".format(self.bounds[get_basename(key)][0]), ""{:.8g}"".format(params[key]), ""{:g}"".format(self.bounds[get_basename(key)][1]) ) return unscaled # string representation of parameters near_lower_unscaled = str(get_values(list(near_lower.keys()))).replace('\'', '') near_upper_unscaled = str(get_values(list(near_upper.keys()))).replace('\'', '') # issue warning logger.warning( f'The MLE estimate is close to the upper bound ' f'for {near_upper_unscaled} and lower bound ' f'for {near_lower_unscaled} [(lower, value, upper)], but ' f'this might be nothing to worry about.' ) def get_bounds(self, x0: Dict[str, float]) -> Dict[str, Tuple[float, float]]: """""" Get a nested dictionary of bounds the same structure as the given initial values. :param x0: Flattened dictionary of initial values :return: A dictionary of initial values """""" bounds = {} for key, value in x0.items(): # check if the parameter is fixed if key in self.fixed_params: bounds[key] = (self.fixed_params[key], self.fixed_params[key]) else: bounds[key] = self.bounds[key.split('.')[-1]] return bounds def set_fixed_params(self, fixed_params: Dict[str, Dict[str, float]]): """""" Set fixed parameters. We flatten the dictionary to make it easier to work with. :param fixed_params: Dictionary of fixed parameters """""" self.fixed_params = flatten_dict(fixed_params) @staticmethod def perturb_params( params: Dict[str, Dict[str, float]], bounds: Dict[str, Tuple[float, float]], seed: Optional[int] = None, ) -> Dict[str, Dict[str, float]]: """""" Perturb values within the given bounds using a normal distribution with mean at the value and standard deviation equal to the value. :param params: Nested dictionary of parameters indexed by type and parameter :param bounds: Dictionary of bounds indexed by parameter name :param seed: Seed for the random number generator :return: Nested dictionary of perturbed parameters indexed by type and parameter """""" rng = np.random.default_rng(seed) perturbed = {} for key, value in flatten_dict(params).items(): # perturb value perturbed[key] = perturb_value(value, bounds[get_basename(key)], rng) return unflatten_dict(perturbed) ","Python" "Allele","Sendrowski/fastDFE","fastdfe/polydfe.py",".py","13173","434",""""""" polyDFE wrapper utilities. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" import copy import json import logging import subprocess import tempfile import time from typing import Callable, List, Optional, Literal, Dict import numpy as np import pandas as pd from typing_extensions import Self from .abstract_inference import AbstractInference, Inference from .config import Config from .parametrization import _from_string, Parametrization, DiscreteParametrization from .polydfe_utils import create_sfs_config, models # get logger logger = logging.getLogger('fastdfe').getChild('PolydfeWrapper') class PolyDFEResult: """""" Class for parsing polyDFE output. """""" # default postprocessing source default_postprocessing_source = '../resources/polydfe/postprocessing/script.R' # mapping of polyDFE params to new name param_mapping = dict( eps_an='eps' ) def __init__( self, output_file: str, additional_data: dict = {}, postprocessing_source: str = default_postprocessing_source ): """""" Create summary object. :param output_file: Path to polyDFE output file :param additional_data: Additional data to add to summary :param postprocessing_source: Path to polyDFE postprocessing script """""" self.output_file = output_file self.postprocessing_source = postprocessing_source self.data = self.parse_output() | additional_data @staticmethod def map_name(name: str) -> str: """""" Map polyDFE parameter name to new name. :param name: polyDFE parameter name :return: New name """""" if name in PolyDFEResult.param_mapping: return PolyDFEResult.param_mapping[name] return name def parse_output(self) -> dict: """""" Parse output from polyDFE output file. :return: Dictionary of parsed data """""" from rpy2.robjects.packages import importr # use the polyDFE R postprocessing script to parse the output file output = self.get_postprocessing_wrapper().parseOutput(self.output_file)[0] # convert to JSON rj = importr('RJSONIO') json_str = rj.toJSON(output)[0] # load dict from JSON string data = json.loads(json_str) return dict( output_file=data['input'], model=data['model'], likelihood=data['lk'], criteria=data['criteria'], params_mle=dict( # non-nuisance parameters # map polyDFE param name to new name (PolyDFEResult.map_name(k), v) for k, v in data['values'][0].items() if not k.startswith('r ') ) | dict( # nuisance parameters r=[data['values'][0][f""r {i}""] for i in range(2, data['n'])] ), n=data['n'], expec=data['expec'][0], alpha=self.get_alpha(output) ) def get_alpha(self, parsed_output: 'rpy2.robjects.vectors.ListVector') -> float: """""" Get alpha, the proportion of beneficial non-synonymous substitutions. :return: Parsed output from polyDFE """""" return self.get_postprocessing_wrapper().estimateAlpha(parsed_output)[0] def get_postprocessing_wrapper(self) -> 'ro.R': """""" Get the wrapped polyDFE postprocessing source. :return: R object """""" import rpy2.robjects as ro ps = ro.r ps.source(self.postprocessing_source) return ps def to_json(self) -> str: """""" Convert object to JSON. :return: JSON string """""" return json.dumps(self.data, indent=4) def to_file(self, file: str): """""" Save object to file. :return: File path to save to """""" with open(file, 'w') as fh: fh.write(self.to_json()) class PolyDFE(AbstractInference): """""" polyDFE wrapper. Note that this class has dependencies outside of pip. Currently only model C is fully implemented. """""" def __init__(self, config: Config): """""" Create polyDFE wrapper. :param config: Config object """""" super().__init__() self.config = config # polyDFE output file self.output_file: Optional[str] = None # the total execution time in seconds self.execution_time: float = 0 # polyDFE summary self.summary: Optional[PolyDFEResult] = None # bootstrap samples self.bootstraps: Optional[pd.DataFrame] = None @staticmethod def map_polydfe_model(model: str) -> str: """""" Map polyDFE model name to native equivalent. :param model: polyDFE model name :return: Native model name """""" return {v: k for k, v in models.items()}[model] @classmethod def from_config(cls, config: Config) -> Self: """""" Load from config object. :param config: Config object """""" return cls(config) @classmethod def from_config_file(cls, file: str) -> Self: """""" Load from config object. :param file: Config file path, possibly URL. :return: Inference object. """""" return cls.from_config(Config.from_file(file)) def run( self, output_file: str, binary: str = 'polydfe', wd: str = None, execute: Callable = None, postprocessing_source: str = PolyDFEResult.default_postprocessing_source ) -> PolyDFEResult: """""" Run polyDFE. :param postprocessing_source: polyDFE postprocessing source :param execute: Function for executing shell commands :param wd: Working directory :param binary: polyDFE binary :param output_file: Output file :return: polyDFE summary """""" start_time = time.time() # define default function for executing command if execute is None: def shell(command: str): """""" Execute shell command. :param command: Command string """""" return subprocess.run(command, check=True, cwd=wd, shell=True) execute = shell # save the spectra and init file, so they can be reviewed if necessary # use temp file to generate the file name. with open(tempfile.NamedTemporaryFile().name, 'w') as spectra_file: with open(tempfile.NamedTemporaryFile().name, 'w') as init_file: # save files self.config.create_polydfe_sfs_config(spectra_file.name) self.config.create_polydfe_init_file(init_file.name, n=self.config.data['sfs_neut'].n) # add number of fragment if model is DiscreteParametrization model = _from_string(self.config.data['model']) k = str(model.k - 1) + ' ' if isinstance(model, DiscreteParametrization) else '' # construct command string command = (f""{binary} "" f""-d {spectra_file.name} "" f""-m {self.config.get_polydfe_model()} {k}"" f""-i {init_file.name} 1 "" f""-v 1 > {output_file}"") # log command signature self._logger.info(f""Running: '{command}'"") # execute command execute(command) # add execution time self.execution_time += time.time() - start_time # create summary from output file self.summary = PolyDFEResult( output_file=output_file, additional_data=dict(execution_time=self.execution_time), postprocessing_source=postprocessing_source ) return self.summary def create_bootstrap(self) -> Config: """""" Create a bootstrap sample using polyDFE's resampling. :return: Config object """""" if self.summary is None: raise Exception('PolyDFE needs to be run before creating bootstrap samples.') # postprocessing wrapper ps = self.summary.get_postprocessing_wrapper() # create temporary SFS config file with tempfile.NamedTemporaryFile() as tmp: create_sfs_config( file=tmp.name, sfs_neut=self.config.data['sfs_neut']['all'], sfs_sel=self.config.data['sfs_sel']['all'] ) # create bootstrap SFS config ps.bootstrapData(tmp.name, rep=1) # file name of resampled SFS config sfs_config_file = tmp.name + '_1' # use exiting config as template and load init and SFS file config = copy.deepcopy(self.config) config.parse_polydfe_sfs_config(sfs_config_file) config.data['x0'] = dict(all=self.summary.data['params_mle']) return config def add_bootstraps(self, bootstraps: 'List[PolyDFE]'): """""" Add bootstraps samples. :param bootstraps: List of bootstrap samples """""" # load MLE params into dataframe self.bootstraps = pd.DataFrame([bs.get_bootstrap_params() for bs in bootstraps]) # drop nuisance parameters and eps_cont self.bootstraps.drop(columns=['r', 'eps_cont'], inplace=True, errors='ignore') # update execution time self.execution_time += float(np.sum([bs.summary.data['execution_time'] for bs in bootstraps])) def plot_all(self, show: bool = True): """""" Plot a bunch of plots. :param show: Whether to show the plot """""" self.plot_inferred_parameters(show=show) self.plot_discretized(show=show) def plot_inferred_parameters( self, confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', file: str = None, show: bool = True, title: str = 'parameter estimates', scale: Literal['lin', 'log', 'symlog'] = 'log', legend: bool = True, ax: 'plt.Axes' = None, kwargs_legend: dict = dict(prop=dict(size=8), loc='upper right'), ) -> 'plt.Axes': """""" Visualize the inferred parameters and their confidence intervals. :param scale: Scale of the y-axis :param confidence_intervals: Whether to show confidence intervals :param ci_level: Confidence interval level :param bootstrap_type: Type of bootstrap :param legend: Show legend :param ax: Axes to plot on. Only for Python visualization backend. :param title: Title of the plot :param show: Show the plot :param file: File to save the plot to :param show: Show the plot :param ax: Axes to plot on. Only for Python visualization backend. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :return: Axes object """""" return Inference.plot_inferred_parameters( inferences=[self], labels=['all'], confidence_intervals=confidence_intervals, ci_level=ci_level, bootstrap_type=bootstrap_type, file=file, show=show, title=title, legend=legend, scale=scale, ax=ax, kwargs_legend=kwargs_legend ) def get_bootstrap_param_names(self) -> List[str]: """""" Parameter names for parameters included in bootstraps. :return: List of parameter names """""" return _from_string(self.config.data['model']).param_names + ['eps', 'alpha'] def get_bootstrap_params(self) -> Dict[str, float]: """""" Get the parameters to be included in the bootstraps. :return: Dict of parameters """""" params = self.summary.data['params_mle'] | dict(alpha=self.summary.data['alpha']) # filter params return dict((k, params[k]) for k in self.get_bootstrap_param_names()) @property def params_mle(self) -> dict: """""" Get the maximum likelihood estimate of the parameters. :return: Dict of parameters """""" return self.summary.data['params_mle'] @params_mle.setter def params_mle(self, value): """""" Set the maximum likelihood estimate of the parameters. :param value: Dict of parameters """""" pass @property def model(self) -> Parametrization: """""" Get the DFE parametrization. :return: Parametrization """""" return _from_string(self.config.data['model']) @model.setter def model(self, value): """""" Set the DFE parametrization. :param value: Parametrization """""" pass ","Python" "Allele","Sendrowski/fastDFE","fastdfe/base_inference.py",".py","67799","1823",""""""" Base inference class. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" import copy import functools import itertools import logging import time from math import comb from typing import List, Optional, Dict, Literal, cast, Tuple, Sequence, Callable import jsonpickle import multiprocess as mp import numpy as np import pandas as pd from numpy.linalg import norm from scipy.stats import chi2 from typing_extensions import Self from . import optimization from . import parametrization from .abstract_inference import AbstractInference, Inference from .config import Config from .discretization import Discretization from .optimization import Optimization, flatten_dict, pack_params, expand_fixed, unpack_shared from .parametrization import Parametrization, _from_string, DFE from .spectrum import Spectrum, Spectra from .spectrum import standard_kingman from .utils import Serializable # get logger logger = logging.getLogger('fastdfe') class BaseInference(AbstractInference): """""" Base inference class for inferring the SFS given one neutral and one selected SFS. Note that BaseInference is by default seeded. Example usage: :: import fastdfe as fd sfs_neut = fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]) sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]) # create inference object inf = fd.BaseInference( sfs_neut=sfs_neut, sfs_sel=sfs_sel, n_runs=10, n_bootstraps=100, do_bootstrap=True ) # run inference inf.run() # plot discretized DFE inf.plot_discretized() # plot SFS comparison inf.plot_sfs_comparison() """""" #: Default parameters not connected to the DFE parametrization _default_x0 = dict( eps=0.0, h=0.5 ) #: Default parameter bounds not connected to the DFE parametrization _default_bounds = dict( eps=(0, 0.15), h=(0, 1) ) #: Default scales for the parameters not connected to the DFE parametrization _default_scales = dict( eps='lin', h='lin' ) #: Default options for the maximum likelihood optimization _default_opts_mle = dict( # ftol=1e-10, # gtol=1e-10 ) # Optimization runs. Static for backward compatibility. runs: Optional[pd.DataFrame] = None def __init__( self, sfs_neut: Spectra | Spectrum, sfs_sel: Spectra | Spectrum, intervals_del: Tuple[float, float, int] = (-1.0e+8, -1.0e-5, 1000), intervals_ben: Tuple[float, float, int] = (1.0e-5, 1.0e4, 1000), intervals_h: Tuple[float, float, int] = (0.0, 1.0, 21), h_callback: Callable[[np.ndarray], np.ndarray] = None, integration_mode: Literal['midpoint', 'quad'] = 'midpoint', linearized: bool = True, model: Parametrization | str = 'GammaExpParametrization', seed: int = 0, x0: Dict[str, Dict[str, float]] = {}, bounds: Dict[str, Tuple[float, float]] = {}, scales: Dict[str, Literal['lin', 'log', 'symlog']] = {}, loss_type: Literal['likelihood', 'L2'] = 'likelihood', opts_mle: dict = {}, method_mle: str = 'L-BFGS-B', n_runs: int = 10, fixed_params: Dict[str, Dict[str, float]] = None, do_bootstrap: bool = True, n_bootstraps: int = 100, n_bootstrap_retries: int = 2, parallelize: bool = True, folded: bool = None, discretization: Discretization = None, optimization: Optimization = None, locked: bool = False, **kwargs ): """""" Create BaseInference instance. :param sfs_neut: The neutral SFS. Note that we require monomorphic counts to be specified in order to infer the mutation rate. If a :class:`~fastdfe.spectrum.Spectra` object with more than one SFS is provided, the ``all`` attribute will be used. :param sfs_sel: The selected SFS. Note that we require monomorphic counts to be specified in order to infer the mutation rate. If a :class:`~fastdfe.spectrum.Spectra` object with more than one SFS is provided, the ``all`` attribute will be used. :param intervals_del: ``(start, stop, n_interval)`` for deleterious population-scaled selection coefficients. The intervals will be log10-spaced. Decreasing the number of intervals to ``100`` provides nearly identical results while increasing speed, especially when precomputing across dominance coefficients. :param intervals_ben: Same as ``intervals_del`` but for positive selection coefficients. Decreasing the number of intervals to ``100`` provides nearly identical results while increasing speed, especially when precomputing across dominance coefficients. :param intervals_h: ``(start, stop, n_interval)`` for dominance coefficients which are linearly spaced. This is only used when inferring dominance coefficients. Values of ``h`` between the edges will be interpolated linearly. :param h_callback: A function mapping the scalar parameter ``h`` and the array of selection coefficients ``S`` to dominance coefficients of the same shape, allowing models where ``h`` depends on ``S``. The default is ``lambda h, S: np.full_like(S, h)``, keeping ``h`` constant. Expected allele counts for a given dominance value are obtained by linear interpolation between precomputed values in ``intervals_h``. The inferred parameter is still named ``h``, even if transformed by ``h_callback``, and its bounds, scales, and initial values can be set via ``bounds``, ``scales``, and ``x0``. The fitness of heterozygotes and mutation homozygotes is defined as ``1 + 2hs`` and ``1 + 2s``, respectively. :param integration_mode: Integration mode when computing expected SFS under semidominance. ``quad`` is not recommended. :param linearized: Whether to discretize and cache the linearized integral mapping DFE to SFS or use ``scipy.integrate.quad`` in each call. ``False`` not recommended. :param model: Instance of DFEParametrization which parametrized the DFE :param seed: Seed for the random number generator. Use ``None`` for no seed. :param x0: Dictionary of initial values in the form ``{'all': {param: value}}`` :param bounds: Bounds for the optimization in the form ``{param: (lower, upper)}`` :param scales: Scales for the optimization in the form ``{param: scale}`` :param loss_type: Type of loss function to use for optimization. :param opts_mle: Options for the optimization. :param method_mle: Method to use for optimization. See ``scipy.optimize.minimize`` for available methods. :param n_runs: Number of independent optimization runs out of which the best one is chosen. The first run will use the initial values if specified. Consider increasing this number if the optimization does not produce good results. :param fixed_params: Parameters kept constant during optimization, given as ``{'all': {param: value}}``. By default, the ancestral misidentification rate ``eps`` is fixed to zero, ``h`` to 0.5, and the DFE parameters are fixed so that only the deleterious component of the DFE is estimated. :param do_bootstrap: Whether to do bootstrapping. :param n_bootstraps: Number of bootstraps. :param n_bootstrap_retries: Number of optimization runs for each bootstrap sample. This parameter previously defined the number of retries per bootstrap sample when subsequent runs failed, but now it defines the total number of runs per bootstrap sample, taking the most likely one. :param pbar: Whether to show a progress bar. :param parallelize: Whether to parallelize computations. :param folded: Whether the SFS are folded. If not specified, the SFS will be folded if both of the given SFS appear to be folded. :param discretization: Discretization instance. Mainly intended for internal use. :param optimization: Optimization instance. Mainly intended for internal use. :param locked: Whether inferences can be run from the class itself. Used internally. :param kwargs: Additional keyword arguments which are ignored. """""" super().__init__() # assign neutral SFS if isinstance(sfs_neut, Spectra): #: Neutral SFS self.sfs_neut: Spectrum = sfs_neut.all else: # assume we have Spectrum object self.sfs_neut: Spectrum = sfs_neut # assign selected SFS if isinstance(sfs_sel, Spectra): #: Selected SFS self.sfs_sel: Spectrum = sfs_sel.all else: # assume we have Spectrum object self.sfs_sel: Spectrum = sfs_sel # check that we have monomorphic counts if self.sfs_neut.to_list()[0] == 0 or self.sfs_sel.to_list()[0] == 0: raise ValueError('Some of the provided SFS have zero ancestral monomorphic counts. ' 'Note that we require monomorphic counts in order to infer the mutation rate.') # check that we have polymorphic counts if self.sfs_neut.n_polymorphic == 0 or self.sfs_neut.n_polymorphic == 0: raise ValueError('Some of the provided SFS have zero polymorphic counts. ' 'Note that we require polymorphic counts in order to infer the DFE.') if self.sfs_neut.n != self.sfs_sel.n: raise ValueError('The sample sizes of the neutral and selected SFS must be equal.') #: The DFE parametrization self.model: Parametrization = parametrization._from_string(model) if folded is None: #: Whether the SFS are folded self.folded: bool = self.sfs_sel.is_folded() and self.sfs_neut.is_folded() else: self.folded = folded #: Sample size self.n: int = sfs_neut.n if self.n > 400: raise ValueError( f""Population sample size n={self.n} above allowed maximum of 400. "" f""Note that high sample sizes (e.g. n > 50) don't carry much additional "" f""information over moderate sample sizes and don't necessarily improve DFE inference."" ) if fixed_params is None: fixed_params = {'all': {'eps': 0, 'h': 0.5} | self.model.submodels['dele']} if not 'all' in fixed_params: fixed_params['all'] = {} # expand 'all' type #: Fixed parameters self.fixed_params: Dict[str, Dict[str, float]] = expand_fixed(fixed_params, ['all']) # check that the fixed parameters are valid self.check_fixed_params_exist() if discretization is None: # create discretization instance #: Discretization instance self.discretization: Discretization = Discretization( n=self.n, h=self.fixed_params.get('all', {}).get('h', None), h_callback=h_callback, intervals_del=intervals_del, intervals_ben=intervals_ben, intervals_h=intervals_h, integration_mode=integration_mode, linearized=linearized, parallelize=parallelize ) else: # otherwise assign instance self.discretization: Discretization = discretization #: Estimate of theta from neutral SFS self.theta: float = self.sfs_neut.theta # raise warning if theta is unusually large if self.theta > 0.05 or self.sfs_sel.theta > 0.05: self._logger.warning(""Mutation rate appears unusually high. "" ""This is a reminder to provide monomorphic site counts."") #: MLE estimates of the initial optimization self.params_mle: Optional[Dict[str, float]] = None #: Modelled MLE SFS self.sfs_mle: Optional[Spectrum] = None #: Likelihood of the MLE, this value may be updated after bootstrapping self.likelihood: Optional[float] = None #: Likelihoods of the different ML runs, controlled by ``n_runs`` self.likelihoods: Optional[List[float]] = None #: Number of MLE runs to perform self.n_runs: int = n_runs #: Dataframe holding information on all optimization runs self.runs: Optional[pd.DataFrame] = None #: Numerical optimization result self.result: Optional['scipy.optimize.OptimizeResult'] = None # Bootstrap options #: Whether to do bootstrapping self.do_bootstrap: bool = do_bootstrap #: Number of bootstraps self.n_bootstraps: int = n_bootstraps #: Number of optimization runs for each bootstrap sample self.n_bootstrap_retries: int = n_bootstrap_retries #: Whether to parallelize computations self.parallelize: bool = parallelize #: Parameter scales self.scales: Dict[str, Literal['lin', 'log', 'symlog']] = self.model.scales | self._default_scales | scales #: Parameter bounds self.bounds: Dict[str, Tuple[float, float]] = self.model.bounds | self._default_bounds | bounds if optimization is None: # create optimization instance # merge with default values of inference and model #: Optimization instance self.optimization: Optimization = Optimization( bounds=self.bounds, scales=self.scales, opts_mle=self._default_opts_mle | opts_mle, method_mle=method_mle, loss_type=loss_type, param_names=self.param_names, parallelize=self.parallelize, fixed_params=fixed_params, seed=seed ) else: # otherwise assign instance self.optimization: Optimization = optimization # warn if folded is true, and we estimate the full DFE if self.folded: fixed_dele = set(self.model.submodels['dele'].keys()) if 'dele' in self.model.submodels else set() fixed = set(self.fixed_params['all'].keys()) if 'all' in self.fixed_params else set() if not fixed_dele.issubset(fixed): self._logger.warning(""You are estimating the full DFE, but the SFS are folded. "" ""This is not recommend as the folded SFS contains little information "" ""on beneficial mutations."") #: Initial values self.x0: Dict[str, Dict[str, float]] = dict( all=self.model.x0 | self._default_x0 | (x0['all'] if 'all' in x0 else {}) ) #: Bootstrapped MLE parameter estimates self.bootstraps: Optional[pd.DataFrame] = None #: Bootstrap optimization results self.bootstrap_results: Optional[List['scipy.optimize.OptimizeResult']] = None #: L2 norm of differential between modelled and observed SFS self.L2_residual: Optional[float] = None #: Random number generator seed self.seed: int | None = int(seed) if seed is not None else None #: Random generator instance self.rng: np.random.Generator = np.random.default_rng(seed=seed) #: Total execution time in seconds self.execution_time: float = 0 #: Whether inferences can be run from the class itself self.locked: bool = locked def get_fixed_param_names(self) -> List[str]: """""" Get the names of the fixed parameters. """""" fixed = [] for p in self.fixed_params.values(): fixed += list(p.keys()) return cast(List[str], np.unique(fixed).tolist()) def check_fixed_params_exist(self): """""" Check that the fixed parameters are valid. """""" fixed = self.get_fixed_param_names() if not set(fixed).issubset(set(self.param_names)): non_valid_params = list(set(fixed) - set(self.param_names)) raise ValueError(f'Fixed parameters {non_valid_params} is not a valid parameter ' f'for this configuration. Valid parameters are {self.param_names}.') def raise_if_locked(self): """""" Raise an error if this object is locked. :raises Exception: """""" if self.locked: raise Exception('This object is locked as inferences ought ' 'not be run from the class itself') def run_if_required(self, *args, **kwargs) -> Optional[Spectrum]: """""" Run if not run yet. :param args: Arguments. :param kwargs: Keyword arguments. :return: DFE parametrization and modelled SFS. """""" if self.execution_time == 0: self._logger.debug('Inference needs to be run first, triggering run.') return self.run(*args, **kwargs) self._logger.debug('Inference already run, not running again.') @staticmethod def _run_if_required_wrapper(func): """""" Decorator to run inference if required. :param func: Function to decorate. :return: Decorated function. """""" @functools.wraps(func) def wrapper(self, *args, **kwargs): """""" Wrapper function. :param self: Inference instance :param args: Positional arguments :param kwargs: Keyword arguments :return: Function output """""" self.run_if_required(*args, **kwargs) return func(self, *args, **kwargs) return wrapper def run( self, do_bootstrap: bool = None, pbar: bool = None, **kwargs ) -> Spectrum: """""" Perform the DFE inference. :param pbar: Whether to show a progress bar. :param do_bootstrap: Whether to perform bootstrapping. :param kwargs: Additional keyword arguments which are ignored. :return: Modelled SFS. """""" # check if locked self.raise_if_locked() # starting time of inference start_time = time.time() # update properties self.update_properties( do_bootstrap=do_bootstrap ) # perform MLE self._logger.debug(f'Starting numerical optimization of {self.n_runs} ' 'independently initialized samples which are run ' + ('in parallel.' if self.parallelize else 'sequentially.')) # precompute discretization self.discretization.precompute() # perform numerical minimization result, params_mle = self.optimization.run( x0=self.x0, scales=self.scales, bounds=self.bounds, get_counts=self.get_counts(), n_runs=self.n_runs, pbar=pbar, desc=f'{self.__class__.__name__}>Performing inference' ) # assign runs dataframe and likelihoods self.runs = self.optimization.runs self.likelihoods = self.runs.likelihood.to_list() # unpack shared parameters params_mle = unpack_shared(params_mle) # normalize parameters params_mle['all'] = self.model._normalize(params_mle['all']) # assign optimization result and MLE parameters self._assign_result(result, params_mle['all']) # report on optimization result self._report_result(result, params_mle) # add execution time self.execution_time += time.time() - start_time # perform bootstrap if configured if self.do_bootstrap: self.bootstrap() return self.sfs_mle def get_counts(self) -> dict: """""" Get callback functions for modelling SFS counts from given parameters. :return: Callback functions for modelling SFS counts for each type. """""" return dict(all=lambda params: self._model_sfs( discretization=self.discretization, model=self.model, params=params, sfs_neut=self.sfs_neut, sfs_sel=self.sfs_sel, folded=self.folded )) def evaluate_likelihood(self, params: Dict[str, Dict[str, float]]) -> float: """""" Evaluate likelihood function at given parameters. :param params: Parameters indexed by type and parameter name. :return: The likelihood. """""" x0_cached = self.optimization.x0 self.optimization.x0 = params # prepare parameters params = pack_params(self.optimization.scale_values(flatten_dict(params))) lk = -self.optimization.get_loss_function(self.get_counts())(params) self.optimization.x0 = x0_cached return lk def _assign_result(self, result: 'scipy.optimize.OptimizeResult', params_mle: dict): """""" Assign optimization result and MLE parameters. :param params_mle: MLE parameters. :param result: Optimization result. """""" self.result = result self.params_mle = params_mle self.likelihood = -result.fun # get SFS for MLE parameters counts_mle, _ = self._model_sfs( params=params_mle, discretization=self.discretization, model=self.model, sfs_neut=self.sfs_neut, sfs_sel=self.sfs_sel, folded=self.folded ) # create spectrum object from polymorphic counts self.sfs_mle = Spectrum.from_polymorphic(counts_mle) # L2 norm of fit minus observed SFS self.L2_residual = self.get_residual(2) # check L2 residual self._check_L2_residual() def get_residual(self, k: int) -> float: """""" Residual of the modelled and observed SFS. :param k: Order of the norm :return: L2 residual """""" return norm(self.sfs_mle.polymorphic - self.sfs_sel.polymorphic, k) def _check_L2_residual(self): """""" Check L2 residual. """""" ratio = self.get_residual(1) / self.sfs_sel.n_polymorphic if ratio > 0.1: self._logger.warning(""The L1 residual comparing the modelled and observed SFS is rather large: "" f""`norm(sfs_modelled - sfs_observed, 1) / sfs_observed` = {ratio:.3f}. "" ""This may indicate that the model does not fit the data well."") def _report_result(self, result: 'scipy.optimize.OptimizeResult', params: dict): """""" Inform on optimization result. :param params: MLE parameters. :param result: Optimization result. """""" # report on optimization result if result.success: self._logger.debug(f""Successfully finished optimization after {result.nit} iterations "" f""and {result.nfev} function evaluations, obtaining a log-likelihood "" f""of -{result.fun:.4g}"") else: self._logger.warning(""Numerical optimization did not terminate normally, so "" ""the result might be unreliable. Consider adjusting "" ""the optimization parameters (increasing `gtol` or `n_runs`) "" ""or decreasing the number of optimized parameters."") self._logger.info( ""Inference results: %s (best_run ± std_across_runs)"", self._format_mean_std( self.runs[self.runs.likelihood == self.runs.likelihood.max()].select_dtypes(""number"").iloc[0], self.runs.select_dtypes(""number"").std().fillna(0) ) ) @staticmethod def _format_mean_std(mean: dict, std: dict) -> str: """""" Format numerical dictionary for printing as mean ± std. :param mean: Dictionary of means. :param std: Dictionary of standard deviations. :return: Formatted string. """""" mean = flatten_dict(mean) std = flatten_dict(std) return str({ k: f""{mean[k]:.4g} ± {std.get(k, 0):.2g}"" for k in mean }).replace(""'"", """") def update_properties(self, **kwargs) -> Self: """""" Update the properties of this class with the given dictionary given that its entries are not ``None``. .. warning:: This will fail to update the optimization instance among other things. Avoid using this method. :meta private: :param kwargs: Dictionary of properties to update. :return: Self. """""" for key, value in kwargs.items(): if value is not None: setattr(self, key, value) return self def bootstrap( self, n_samples: int = None, parallelize: bool = None, update_likelihood: bool = False, n_retries: int = None, pbar: bool = True, pbar_title: str = 'Bootstrapping' ) -> pd.DataFrame: """""" Perform the parametric bootstrap. :param n_samples: Number of bootstrap samples. Defaults to :attr:`n_bootstraps`. :param parallelize: Whether to parallelize the bootstrap. Defaults to :attr:`parallelize`. :param update_likelihood: Whether to update the likelihood to be the mean of the bootstrap samples and the original likelihood. This is not statistically valid but can stabilize maximum likelihood estimate subject optimization noise. :param n_retries: Number of optimization runs for each bootstrap sample. Defaults to :attr:`n_bootstrap_retries`. :param pbar: Whether to show a progress bar. :param pbar_title: Title for the progress bar. :return: Dataframe with bootstrap results. """""" self._bootstrap( n_samples=n_samples, parallelize=parallelize, update_likelihood=update_likelihood, n_retries=n_retries, pbar=pbar, pbar_title=pbar_title ) # remove 'all.' prefix from columns self.bootstraps.columns = self.bootstraps.columns.str.removeprefix(""all."") # add estimates for alpha to the bootstraps self._add_alpha_to_bootstraps() return self.bootstraps def _bootstrap( self, n_samples: int = None, parallelize: bool = None, update_likelihood: bool = False, n_retries: int = None, pbar: bool = True, pbar_title: str = 'Bootstrapping', ) -> pd.DataFrame: """""" Perform the parametric bootstrap. :param n_samples: Number of bootstrap samples. Defaults to :attr:`n_bootstraps`. :param parallelize: Whether to parallelize the bootstrap. Defaults to :attr:`parallelize`. :param update_likelihood: Whether to update the likelihood to be the mean of the bootstrap samples and the original likelihood. This is not statistically valid but can stabilize maximum likelihood estimate subject optimization noise. :param n_retries: Number of optimization runs for each bootstrap sample. Defaults to :attr:`n_bootstrap_retries`. :param pbar: Whether to show a progress bar. :param pbar_title: Title for the progress bar. :return: Dataframe with bootstrap results. """""" # check if locked self.raise_if_locked() # perform inference first if not done yet self.run_if_required() # precompute discretization if not done yet self.discretization.precompute() # update properties self.update_properties( n_bootstraps=n_samples, parallelize=parallelize, n_bootstrap_retries=n_retries, ) n_bootstraps = int(self.n_bootstraps) start_time = time.time() # parallelize computations if desired if self.parallelize: self._logger.debug(f""Running {n_bootstraps} bootstrap samples "" f""in parallel on {min(mp.cpu_count(), n_bootstraps)} cores."") else: self._logger.debug(f""Running {n_bootstraps} bootstrap samples sequentially."") # seeds for bootstraps seeds = self.rng.integers(0, high=2 ** 32, size=n_bootstraps) # run bootstraps results = optimization.parallelize( func=self._get_run_bootstrap_sample(), data=seeds, parallelize=self.parallelize, pbar=pbar, desc=f'{self.__class__.__name__}>{pbar_title} ({self.n_bootstrap_retries} runs each)' ) # select best result for each bootstrap sample i_best = [np.argmax([-r[0].fun if r[0].success else -np.inf for r in res]) for res in results] # get best results result = results[np.arange(n_bootstraps), i_best] # number of successful runs n_success = np.sum([res.success for res in result[:, 0]]) # dataframe of MLE estimates self.bootstraps = pd.DataFrame([flatten_dict(r) for r in result[:, 1]]) # assign additional info to bootstraps self.bootstraps['likelihood'] = [-r.fun for r in result[:, 0]] self.bootstraps['success'] = [r.success for r in result[:, 0]] self.bootstraps['result'] = [str(r) for r in result[:, 0]] self.bootstraps['x0'] = [flatten_dict(r) for r in result[:, 2]] self.bootstraps['i_best_run'] = i_best self.bootstraps['likelihoods_runs'] = [[-r[0].fun for r in res] for res in results] self.bootstraps['likelihoods_std'] = self.bootstraps['likelihoods_runs'].apply(np.std) self.bootstraps['results_runs'] = [[str(r[0]) for r in res] for res in results] self.bootstraps['x0_runs'] = [[flatten_dict(r[2]) for r in res] for res in results] # assign bootstrap results self.bootstrap_results = list(result[:, 0]) self._logger.info( ""Bootstrap summary: %s (mean ± std)"", self._format_mean_std( self.bootstraps.select_dtypes(""number"").mean().fillna(0), self.bootstraps.select_dtypes(""number"").std().fillna(0) ) ) # issue warning if some runs did not finish successfully if n_success < n_bootstraps: self._logger.warning( f""{n_bootstraps - n_success} out of {n_bootstraps} bootstrap samples "" ""did not terminate normally during numerical optimization. "" ""The confidence intervals might thus be unreliable. Consider "" ""increasing the number of optimization runs per bootstrap sample (`n_retries`), "" ""adjusting the optimization parameters (increasing `gtol` or `n_runs`), "" ""or decreasing the number of optimized parameters."" ) # add execution time self.execution_time += time.time() - start_time # assign average likelihood of successful runs if update_likelihood: self.likelihood = np.mean([-res.fun for res in result[:, 0] if res.success] + [self.likelihood]) return self.bootstraps def _add_alpha_to_bootstraps(self): """""" Add estimates for alpha to the bootstraps. """""" self._logger.debug('Computing estimates for alpha.') # add alpha estimates self.bootstraps['alpha'] = self.bootstraps.apply(lambda r: self.get_alpha(dict(r)), axis=1) def _get_run_bootstrap_sample(self) -> Callable[[int], Tuple['scipy.optimize.OptimizeResult', dict, dict, int]]: """""" Get function which runs a single bootstrap sample. :return: Static function which runs a single bootstrap sample, taking an optional seed and returning the optimization result of best run, MLE parameters, the best x0, and its index. """""" optimization = self.optimization discretization = self.discretization model = self.model folded = self.folded scales = self.scales bounds = self.bounds n_retries = self.n_bootstrap_retries sfs_sel = self.sfs_sel sfs_neut = self.sfs_neut params_mle_all = dict(all=self.params_mle) def run_bootstrap_sample(seed: int): """""" Resample the selected and neutral SFS and rerun optimization. Initial point is the MLE; each retry perturbs x0. """""" results = [] x0 = params_mle_all rng = np.random.default_rng(seed) # resample once sel = sfs_sel.resample(seed=rng) neut = sfs_neut.resample(seed=rng) for _ in range(max(n_retries, 1)): # run optimizer result, params_mle = optimization.run( x0=x0, scales=scales, bounds=bounds, n_runs=1, debug_iterations=False, print_info=False, get_counts=dict(all=lambda p: BaseInference._model_sfs( discretization=discretization, model=model, params=p, sfs_neut=neut, sfs_sel=sel, folded=folded )), desc=f""{self.__class__.__name__}>Bootstrapping"" ) # unpack shared + normalize params_mle = unpack_shared(params_mle) # normalize MLE estimates params_mle['all'] = model._normalize(params_mle['all']) results += [(result, params_mle, x0)] x0 = optimization.sample_x0(params_mle_all, random_state=rng) return results return run_bootstrap_sample def get_scales_linear(self) -> Dict[str, Literal['lin']]: """""" Get linear scales for all parameters. We do this for the bootstraps as x0 should be close to MLE. :return: Dictionary of scales. """""" return cast(Dict[str, Literal['lin']], dict((p, 'lin') for p in self.scales.keys())) def get_bounds_linear(self) -> Dict[str, Tuple[float, float]]: """""" Get linear bounds for all parameters. We do this for the bootstraps as x0 should be close to MLE. :return: Dictionary of bounds. """""" scaled_bounds = {} for key, bounds in self.bounds.items(): # for symlog we need to convert the bounds to linear scale if self.scales[key] == 'symlog': scaled_bounds[key] = (-bounds[1], bounds[1]) else: scaled_bounds[key] = bounds return scaled_bounds @classmethod def _model_sfs( cls, discretization: Discretization, model: Parametrization, params: dict, sfs_neut: Spectrum, sfs_sel: Spectrum, folded: bool ) -> Tuple[np.ndarray, np.ndarray]: """""" Model the selected SFS from the given parameters. :param discretization: Discretization instance. :param model: Parametrization instance. :param params: Dictionary of parameters. :param sfs_sel: Observed spectrum of selected sites. :param sfs_neut: Observed spectrum of neutral sites. :param folded: Whether the SFS are folded. :return: Array of modelled and observed counts """""" # obtain modelled selected SFS counts_modelled = discretization.model_selection_sfs(model, params) # adjust for mutation rate and mutational target size counts_modelled *= sfs_neut.theta * sfs_sel.n_sites # add contribution of demography and adjust polarization error counts_modelled = cls._add_demography(sfs_neut, counts_modelled, eps=params['eps']) # fold if necessary if folded: counts_observed = sfs_sel.fold().polymorphic counts_modelled = Spectrum.from_polymorphic(counts_modelled).fold().polymorphic else: counts_observed = sfs_sel.polymorphic return counts_modelled, counts_observed @staticmethod def _adjust_polarization(counts: np.ndarray, eps: float) -> np.ndarray: """""" Adjust the polarization of the given SFS where eps is the rate of ancestral misidentification. :param counts: Polymorphic SFS counts to adjust. :param eps: Rate of ancestral misidentification. :return: Adjusted SFS counts. """""" return (1 - eps) * counts + eps * counts[::-1] @classmethod def _add_demography( cls, sfs_neut: Spectrum, counts_sel: np.ndarray, eps: float ) -> np.ndarray: """""" Add the effect of demography to counts_sel by considering how counts_neut is perturbed relative to the standard coalescent. The polarization error is also included here. :param sfs_neut: Observed spectrum of neutral sites. :param counts_sel: Modelled counts of selected sites. :param eps: Rate of ancestral misidentification. :return: Adjusted counts of selected sites. """""" # normalized counts of the standard coalescent neutral_modelled = standard_kingman(sfs_neut.n).polymorphic * sfs_neut.theta * sfs_neut.n_sites # Apply polarization error to neutral and selected counts. # Note that we fail to adjust for polarization if we were to # apply the error to both the selected and neutral modelled counts. # In addition, note that eps is not easily interpretable, # as we apply it to both neutral and selected counts, which # is of course necessary. Testing this on sample datasets # yields very reasonable results, compatible with polyDFE. neutral_observed = cls._adjust_polarization(sfs_neut.polymorphic, eps) selected_modelled = cls._adjust_polarization(counts_sel, eps) # These counts transform the standard Kingman case to the observed # neutral SFS when multiplied and thus account for demography as we assume # the distortion in sfs_neut to be due to demography alone. # Note that the nuisance parameters naturally are sensitive to a large # sampling variance in the neutral SFS. # However, DFE inference on `wiggly` spectra is not advisable anyway. r = neutral_observed / neutral_modelled # adjust for demography and polarization error return r * selected_modelled @_run_if_required_wrapper def plot_continuous( self, file: str = None, show: bool = True, intervals: np.ndarray = None, confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', scale_density: bool = False, scale: Literal['lin', 'log', 'symlog'] = 'lin', title: str = 'DFE', kwargs_legend: dict = dict(prop=dict(size=8)), ax: 'plt.Axes' = None ) -> 'plt.Axes': """""" Plot continuous DFE. The special constants np.inf and -np.inf are also valid interval bounds. By default, the PDF is plotted as is. Due to the logarithmic scale on the x-axis, we may get a wrong intuition on how the mass is distributed, however. To get a better intuition, we can optionally scale the density by the x-axis interval size using ``scale_density = True``. This has the disadvantage that the density now changes for x, so that even a constant density will look warped. :param title: Plot title. :param bootstrap_type: Type of bootstrap to use for confidence intervals. :param ci_level: Confidence level for confidence intervals. :param confidence_intervals: Whether to plot confidence intervals. :param file: File to save plot to. :param show: Whether to show plot. :param scale: y-scale :param scale_density: Whether to scale the density by the x-axis interval size :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :param ax: Axes to plot on. Only for Python visualization backend. :return: Axes object """""" if intervals is None: intervals = self.discretization.bins return Inference.plot_continuous( inferences=[self], file=file, show=show, intervals=intervals, confidence_intervals=confidence_intervals, ci_level=ci_level, bootstrap_type=bootstrap_type, title=title, scale=scale, scale_density=scale_density, kwargs_legend=kwargs_legend, ax=ax ) @_run_if_required_wrapper def plot_bucket_sizes( self, file: str = None, show: bool = True, title: str = 'bucket sizes', ax: 'plt.Axes' = None ) -> 'plt.Axes': """""" Plot mass in each bucket for the MLE DFE. This can be used to check if the interval bounds and spacing are chosen appropriately. :param file: File to save plot to. :param show: Whether to show plot. :param title: Plot title. :param ax: Axes to plot on. Only for Python visualization backend. :return: Axes object """""" from .visualization import Visualization # evaluate at fixed parameters sizes = self.model._discretize(self.params_mle, self.discretization.bins) return Visualization.plot_buckets_sizes( n_intervals=self.discretization.n_intervals, bins=self.discretization.bins, sizes=sizes, title=title, file=file, show=show, ax=ax ) @_run_if_required_wrapper def plot_interval_density( self, file: str = None, show: bool = True, intervals: Sequence = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), interval_labels: List[str] = None, color: str = 'C0', ax: 'plt.Axes' = None ) -> 'plt.Axes': """""" Plot density of the discretization intervals chosen. Note that although this plot looks similar, this is not the DFE! :param color: Color of the bars. :param file: File to save plot to. :param show: Whether to show plot. :param interval_labels: Labels for the intervals. :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. :param ax: Axes to plot on. Only for Python visualization backend. :return: Axes object """""" from .visualization import Visualization # issue warning if not self.discretization.linearized: self._logger.warning('Note that the interval density is not important if the DFE was not linearized.') return Visualization.plot_interval_density( density=self.discretization.get_interval_density(intervals), file=file, show=show, intervals=intervals, interval_labels=interval_labels, color=color, ax=ax ) def plot_sfs_comparison( self, sfs_types: List[Literal['modelled', 'observed', 'selected', 'neutral']] = ['observed', 'modelled'], labels: List[str] = None, colors: List[str] = None, file: str = None, show: bool = True, ax: 'plt.Axes' = None, title: str = 'SFS comparison', use_subplots: bool = False, show_monomorphic: bool = False, kwargs_legend: dict = dict(prop=dict(size=8)), ) -> 'plt.Axes': """""" Plot SFS comparison. :param file: File to save plot to. :param labels: Labels for the SFS. :param colors: Colors for the SFS. Only for Python visualization backend. :param sfs_types: Types of SFS to plot. :param show: Whether to show plot. :param ax: Axes to plot on. Only for Python visualization backend and if ``use_subplots`` is ``False``. :param title: Plot title :param use_subplots: Whether to use subplots. Only for Python visualization backend. :param show_monomorphic: Whether to show monomorphic counts :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :return: Axes object """""" from .visualization import Visualization if 'modelled' in sfs_types: self.run_if_required() mapping = dict( observed=self.sfs_sel, selected=self.sfs_sel, modelled=self.sfs_mle, neutral=self.sfs_neut ) return Visualization.plot_spectra( spectra=[list(mapping[t]) for t in sfs_types], labels=sfs_types if labels is None else labels, colors=colors, file=file, show=show, ax=ax, title=title, use_subplots=use_subplots, show_monomorphic=show_monomorphic, kwargs_legend=kwargs_legend ) def plot_observed_sfs( self, labels: List[str] = None, file: str = None, show: bool = True, ax: 'plt.Axes' = None ) -> 'plt.Axes': """""" Plot neutral and selected SFS. :param file: File to save plot to. :param labels: Labels for the SFS. :param show: Whether to show plot. :param ax: Axes to plot on. Only for Python visualization backend. :return: Axes object """""" return self.plot_sfs_comparison( sfs_types=['neutral', 'selected'], labels=labels, file=file, show=show, ax=ax ) @_run_if_required_wrapper def plot_all(self, show: bool = True): """""" Plot a bunch of plots. :param show: Whether to show plot. """""" self.plot_inferred_parameters(show=show) self.plot_discretized(show=show) self.plot_sfs_comparison(show=show) self.plot_continuous(show=show) self.plot_interval_density(show=show) self.plot_likelihoods(show=show) def get_stats_discretized( self, ci_level: float = 0.05, intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'mean' ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]: """""" Get statistics for the discretized DFE. :param ci_level: Confidence interval level. :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. :param bootstrap_type: Type of bootstrap to use. :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :return: Center values, errors around center, and confidence intervals. """""" return Inference.get_stats_discretized( params=self.params_mle, bootstraps=self.bootstraps, model=self.model, ci_level=ci_level, intervals=intervals, bootstrap_type=bootstrap_type, point_estimate=point_estimate ) @_run_if_required_wrapper def plot_inferred_parameters( self, confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', file: str = None, show: bool = True, title: str = 'parameter estimates', scale: Literal['lin', 'log', 'symlog'] = 'log', ax: 'plt.Axes' = None, kwargs_legend: dict = dict(prop=dict(size=8), loc='upper right'), **kwargs ) -> 'plt.Axes': """""" Visualize the inferred parameters and their confidence intervals. :param scale: y-scale of the plot. :param title: Plot title. :param confidence_intervals: Whether to show confidence intervals. :param bootstrap_type: Type of bootstrap to use. :param ci_level: Confidence level for the confidence intervals. :param file: File to save plot to. :param show: Whether to show plot. :param ax: Axes to plot on. Only for Python visualization backend. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :return: Axes object """""" return Inference.plot_inferred_parameters( inferences=[self], labels=['all'], file=file, show=show, title=title, ci_level=ci_level, confidence_intervals=confidence_intervals, bootstrap_type=bootstrap_type, scale=scale, ax=ax, kwargs_legend=kwargs_legend, ) @_run_if_required_wrapper def plot_inferred_parameters_boxplot( self, file: str = None, show: bool = True, title: str = 'parameter estimates', **kwargs ) -> 'plt.Axes': """""" Visualize the inferred parameters and their confidence intervals. :param title: Plot title. :param file: File to save plot to. :param show: Whether to show plot. :return: Axes object :raises ValueError: If no inference objects are given or no bootstraps are found. """""" return Inference.plot_inferred_parameters_boxplot( inferences=[self], labels=['all'], file=file, show=show, title=title ) @_run_if_required_wrapper def plot_likelihoods( self, file: str = None, show: bool = True, title: str = 'likelihoods', scale: Literal['lin', 'log'] = 'lin', ax: 'plt.Axes' = None, ylabel: str = 'lnl', **kwargs ) -> 'plt.Axes': """""" Visualize the likelihoods of the optimization runs using a scatter plot. :param scale: y-scale of the plot. :param title: Plot title. :param file: File to save plot to. :param show: Whether to show plot. :param ax: Axes to plot on. Only for Python visualization backend. :param ylabel: Label for the y-axis. :return: Axes object """""" from .visualization import Visualization return Visualization.plot_scatter( values=self.likelihoods, file=file, show=show, title=title, scale=scale, ax=ax, ylabel=ylabel, ) def _lrt_components( self, ll_simple: float, ll_complex: float, df: int, m: int = 0 ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: """""" Perform a likelihood ratio test (LRT) with correction for boundary constraints as described in Molenberghs et Verbeke (2007) (https://doi.org/10.2307/1403361). :param ll_simple: Log-likelihood of the simple model. :param ll_complex: Log-likelihood of the complex model. :param df: Total number of parameters being tested. :param m: Number of parameters at the boundary. :return: Weights and components (p-values), and degrees of freedom. :raises ValueError: If the number of parameters at the boundary exceeds the total number of parameters. """""" if m > df: raise ValueError('Number of parameters at the boundary exceeds total number of parameters.') lr = -2 * (ll_simple - ll_complex) # Issue info message self._logger.info(f""Simple model likelihood: {ll_simple}, "" f""Complex model likelihood: {ll_complex}, "" f""Total degrees of freedom: {df}, "" f""Parameters at boundary: {m}."") # compute mixture weights weights = np.array([comb(m, j - (df - m)) / (2 ** m) for j in range(df - m, df + 1)]) # zero degrees of freedom is point mass at 0 components = np.array([(0 if j == 0 else chi2.sf(lr, j)) for j in range(df - m, df + 1)]) df = np.array([j for j in range(df - m, df + 1)]) self._logger.debug( "" + "".join([f""{weight} * {component:.3f}"" for weight, component in zip(weights, components)]) ) return weights, components, df def lrt(self, ll_simple: float, ll_complex: float, df: int, m: int = 0) -> float: """""" Perform a likelihood ratio test (LRT) with correction for boundary constraints as described in Molenberghs et Verbeke (2007) (https://doi.org/10.2307/1403361). :param ll_simple: Log-likelihood of the simple model. :param ll_complex: Log-likelihood of the complex model. :param df: Total number of parameters being tested. :param m: Number of parameters at the boundary. :return: p-value """""" weights, components, _ = self._lrt_components(ll_simple, ll_complex, df, m) return np.sum(weights * components) def _is_nested(self, complex: 'BaseInference') -> bool: """""" Check if the given model is nested within the current model. The given model's fixed parameters need to be a proper subset of this model's fixed parameters. :param complex: More complex model. :return: Whether the models are nested. """""" if type(self.model) != type(complex.model): return False # optimization holds the flattened dictionary fixed_complex = set(complex.optimization.fixed_params.keys()) fixed_simple = set(self.optimization.fixed_params.keys()) return fixed_complex < fixed_simple def _get_df_nested(self, complex: 'BaseInference') -> Tuple[int, int]: """""" Get the degrees of freedom for the likelihood ratio test. :param complex: More complex model. :return: Degrees of freedom and number of parameters at bounds. :raises ValueError: If the models are not nested. """""" if type(self.model) != type(complex.model): raise ValueError(f'DFE parametrizations are not the same: {type(self.model)} vs. {type(complex.model)}.') if not self._is_nested(complex): raise ValueError('Models are not nested.') # optimization holds the flattened dictionary fixed_complex = set(complex.optimization.fixed_params.keys()) fixed_simple = set(self.optimization.fixed_params.keys()) # fixed parameters fixed = fixed_simple - fixed_complex fixed_params = self.optimization.fixed_params # parameter bounds bounds = self.optimization.bounds # number of parameters at bounds m = sum([fixed_params[p] == bounds[p.split('.')[1]][0] or fixed_params[p] == bounds[p.split('.')[1]][1] for p in fixed]) # degrees of freedom df = len(fixed) return df, m def compare_nested(self, complex: 'BaseInference') -> float | None: """""" Perform likelihood ratio test with given more complex model. The given model's fixed parameters need to be a proper subset of this model's fixed parameters. Low p-values indicate that the more complex model provides a significantly better fit. :param complex: More complex model. :return: p-value or None if the models are not nested. :raises ValueError: If the inference objects are not nested. """""" df, m = self._get_df_nested(complex) # run inference if not done yet self.run_if_required() complex.run_if_required() return self.lrt(self.likelihood, complex.likelihood, df, m) @_run_if_required_wrapper @functools.lru_cache def compare_nested_models(self, do_bootstrap: bool = False) -> Tuple[np.ndarray, Dict[str, 'BaseInference']]: """""" Compare the various nested versions of the specified model using likelihood ratio tests. We check for inclusion of ancestral misidentification and beneficial mutations. :param do_bootstrap: Whether to perform bootstrapping. :return: Matrix of p-values, dict of base inference objects """""" # get sub-model specifications submodels_dfe = _from_string(self.model).submodels submodels_outer = dict( no_anc=dict(eps=0), anc={} ) if 'all' in self.fixed_params and 'h' in self.fixed_params['all']: submodels_h = dict(h=self.fixed_params['all']['h']) else: submodels_h = {} # take outer product to get fixed parameters for each model inferences: Dict[str, BaseInference] = {} for p in itertools.product(submodels_dfe.keys(), submodels_outer.keys()): # create deep copy of object inference = copy.deepcopy(self) # carry over bootstrap setting inference.do_bootstrap = do_bootstrap # dict of params to be fixed params = dict(all=submodels_dfe[p[0]] | submodels_outer[p[1]] | submodels_h) # assign fixed parameters inference._set_fixed_params(params) # inform about fixed parameters self._logger.info(f'Holding parameters fixed to {params}.') # run inference inference.run() # define name name = '.'.join(p).rstrip('_') # save to dict inferences[name] = inference # number of models n = len(inferences) # create input matrix inputs = list(itertools.product(inferences.items(), inferences.items())) # create likelihood ratio matrix P = [] for i in inputs: try: P.append(i[0][1].compare_nested(i[1][1])) except ValueError: P.append(None) P = np.reshape(P, (n, n)) return P, inferences def plot_nested_models( self, file: str = None, show: bool = True, remove_empty: bool = False, transpose: bool = False, cmap: str = None, title: str = 'nested model comparison', ax: 'plt.Axes' = None, do_bootstrap: bool = False, ) -> 'plt.Axes': """""" Plot the p-values of nested likelihoods. :param file: File to save plot to. :param show: Whether to show plot. :param remove_empty: Whether to remove empty rows and columns. :param transpose: Whether to transpose the matrix. :param cmap: Colormap to use. :param title: Plot title. :param ax: Axes to plot on. Only for Python visualization backend. :param do_bootstrap: Whether to perform bootstrapping. :return: Axes object """""" from .visualization import Visualization # get p-values and names P, inferences = self.compare_nested_models(do_bootstrap=do_bootstrap) # define labels labels_x = np.array(list(inferences.keys())) labels_y = np.array(list(inferences.keys())) if remove_empty: # remove empty columns nonempty_cols = np.sum(~np.equal(P, None), axis=0) != 0 P = P[:, nonempty_cols] labels_x = labels_x[nonempty_cols] # remove empty rows nonempty_rows = np.sum(~np.equal(P, None), axis=1) != 0 P = P[nonempty_rows] labels_y = labels_y[nonempty_rows] # take transpose if specified if transpose: P = P.T labels_x, labels_y = labels_y, labels_x return Visualization.plot_nested_models( P=P, labels_x=labels_x, labels_y=labels_y, file=file, show=show, cmap=cmap, title=title, ax=ax ) @functools.wraps(AbstractInference.plot_discretized) @_run_if_required_wrapper def plot_discretized(self, *args, **kwargs): return super().plot_discretized(*args, **kwargs) def get_dfe(self) -> DFE: """""" Return a frozen DFE object containing the inferred parameters and (if available) the bootstrap samples. :return: DFE object """""" # ensure inference is run self.run_if_required() return DFE( model=self.model, params=self.params_mle, bootstraps=self.bootstraps ) def get_spectra(self) -> Spectra: """""" Return a Spectra object containing the neutral, selected and modelled SFS. :return: Spectra object with types ``neutral``, ``selected``, and ``modelled``. """""" return Spectra.from_spectra(dict( neutral=self.sfs_neut, selected=self.sfs_sel, modelled=self.sfs_mle )) def get_alpha(self, params: dict = None) -> float: """""" Get alpha, the proportion of beneficial non-synonymous substitutions. :param params: DFE Parameters to use for calculation. """""" if params is None: params = self.params_mle return self.discretization.get_alpha(self.model, params) @functools.cached_property def alpha(self) -> float: """""" Cache alpha, the proportion of beneficial non-synonymous substitutions. """""" return self.get_alpha() def get_bootstrap_params(self) -> Dict[str, float]: """""" Get the parameters to be included in the bootstraps. :return: Parameters to be included in the bootstraps. """""" return self.params_mle | dict(alpha=self.alpha) def get_bootstrap_param_names(self) -> List[str]: """""" Get the parameters to be included in the bootstraps. :return: Parameters to be included in the bootstraps. """""" return list(self.get_bootstrap_params().keys()) def get_optimized_param_names(self) -> List[str]: """""" Get the parameters names for the parameters that are optimized. :return: List of parameter names. """""" return list(set(flatten_dict(self.get_x0())) - set(flatten_dict(self.fixed_params))) def get_n_optimized(self) -> int: """""" Get the number of parameters that are optimized. :return: Number of parameters that are optimized. """""" return len(self.get_optimized_param_names()) def create_config(self) -> 'Config': """""" Create a config object from the inference object. :return: Config object. """""" return Config( sfs_neut=Spectra.from_spectrum(self.sfs_neut), sfs_sel=Spectra.from_spectrum(self.sfs_sel), intervals_ben=self.discretization.intervals_ben, intervals_del=self.discretization.intervals_del, integration_mode=self.discretization.integration_mode, linearized=self.discretization.linearized, model=self.model.__class__.__name__, seed=self.seed, x0=self.x0, bounds=self.bounds, scales=self.scales, loss_type=self.optimization.loss_type, opts_mle=self.optimization.opts_mle, method_mle=self.optimization.method_mle, n_runs=self.n_runs, fixed_params=self.fixed_params, do_bootstrap=self.do_bootstrap, n_bootstraps=self.n_bootstraps, parallelize=self.parallelize ) @classmethod def from_config(cls, config: 'Config') -> Self: """""" Load from config object. :param config: Config object. :return: Inference object. """""" return cls(**config.data) @classmethod def from_config_file(cls, file: str, cache: bool = True) -> Self: """""" Load from config file. :param file: Config file path, possibly URL. :param cache: Whether to use the cache if available. :return: Inference object. """""" from . import Config return cls.from_config(Config.from_file(file, cache=cache)) def get_summary(self) -> 'InferenceResult': """""" Get summary. :return: Inference results. """""" return InferenceResult(self) def get_x0(self) -> Dict[str, Dict[str, float]]: """""" Get initial values. :return: Initial values. """""" # filter by parameter names return dict(all=dict((p, self.x0['all'][p]) for p in self.optimization.param_names)) @property def param_names(self) -> List[str]: """""" Parameter names. :return: List of parameter names. """""" return self.model.param_names + ['eps', 'h'] def _set_fixed_params(self, params: Dict[str, Dict[str, float]]): """""" Set fixed parameters. :param params: Fixed parameters. """""" self.fixed_params = expand_fixed(params, ['all']) self.optimization.set_fixed_params(self.fixed_params) def to_json(self) -> str: """""" Serialize object. :return: JSON string """""" # using make_ref=True resulted in weird behaviour when unserializing. return jsonpickle.encode(self, indent=4, warn=True, make_refs=False) class InferenceResult(Serializable): """""" Inference result. """""" def __init__(self, inference: BaseInference): """""" Initialize object. :param inference: Inference object. """""" #: Configuration of the inference self.config: 'Config' = inference.create_config() #: Inferred DFE self.dfe: DFE = inference.get_dfe() #: Spectra self.spectra: Spectra = inference.get_spectra() #: Bootstrap samples self.bootstraps: pd.DataFrame = inference.bootstraps #: Optimization runs self.runs: pd.DataFrame = inference.runs ","Python" "Allele","Sendrowski/fastDFE","fastdfe/discretization.py",".py","33394","909",""""""" Discretization of DFE to SFS transformation. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" import logging from functools import wraps from itertools import product from math import comb from typing import Literal, Sequence, Tuple, Optional, Callable import mpmath as mp import numpy as np from scipy.integrate import quad from .optimization import parallelize as parallelize_func from .parametrization import Parametrization # configure logger logger = logging.getLogger('fastdfe').getChild('Discretization') def to_float(func): """""" Decorator to convert the return value of a function to float. :param func: Function to be decorated :return: Wrapper function """""" @wraps(func) def wrapper(*args, **kwargs) -> float | np.ndarray: """""" Wrapper function. :param args: Positional arguments :param kwargs: Keyword arguments :return: Converted result """""" result = func(*args, **kwargs) if isinstance(result, np.ndarray): return result.astype(float) else: return float(result) return wrapper class Discretization: """""" Class for discretizing the integral mapping the DFE to the expected SFS. """""" #: Mapped dominance coefficient, static to ensure backward compatibility h_mapped: float = np.array([0.5]) #: Parameter h mapping dominance coefficients if not varying, static to ensure backward compatibility h: Optional[float] = 0.5 #: Dominance coefficient callback, static to ensure backward compatibility h_callback: Callable[[float, np.ndarray], np.ndarray] = None def __init__( self, n: int, h: Optional[float] = 0.5, h_callback: Callable[[float, np.ndarray], np.ndarray] = lambda h, S: np.full_like(S, h), intervals_del: Tuple[float, float, int] = (-1.0e+8, -1.0e-5, 1000), intervals_ben: Tuple[float, float, int] = (1.0e-5, 1.0e4, 1000), intervals_h: Tuple[float, float, int] = (0.0, 1.0, 21), n_outer: int = 1000, n_inner: int = 200, s_chunk_size: int = 10, integration_mode: Literal['midpoint', 'quad'] = 'midpoint', linearized: bool = True, parallelize: bool = True, ): """""" Create Discretization instance. :param n: Number of individuals in the SFS sample. :param h: Parameter h mapping dominance coefficients if not varying, else ``None``. When ``None``, dominance coefficients are precomputed across ``intervals_h`` and interpolated as needed. Otherwise, only the fixed value is precomputed. :param intervals_del: ``(start, stop, n_interval)`` for deleterious population-scaled selection coefficients. The intervals will be log10-spaced. Decreasing the number of intervals to ``100`` provides nearly identical results while increasing speed, especially when precomputing across dominance coefficients. :param intervals_ben: ``(start, stop, n_interval)`` for beneficial population-scaled selection coefficients. The intervals will be log10-spaced. Decreasing the number of intervals to ``100`` provides nearly identical results while increasing speed, especially when precomputing across dominance coefficients. :param intervals_h: ``(start, stop, n_interval)`` for dominance coefficients which are linearly spaced. This is only used when inferring dominance coefficients. Values of ``h`` between the edges will be interpolated linearly. :param n_outer: Number of grid points for outer integrals when computing allele counts for varying dominance coefficients. :param n_inner: Number of grid points for inner integrals when computing allele counts for varying dominance coefficients. :param s_chunk_size: Chunk size for S values when precomputing across dominance coefficients. This controls memory usage vs. speed trade-off. :param integration_mode : 'midpoint' or 'quad' for midpoint integration or Scipy's quad method. :param linearized: Whether to discretize and cache the linearized integral mapping DFE to SFS or use `scipy.integrate.quad` in each call. :param parallelize: Whether to parallelize the computation of the discretization. """""" # make sure lower bounds are lower than upper bounds if not intervals_del[0] < intervals_del[1] or not intervals_ben[0] < intervals_ben[1]: raise Exception('Lower intervals bounds must be lower than upper bounds.') # make sure |S| is not too large if intervals_del[0] < -1e10 or intervals_ben[1] > 1e10: raise Exception('Bounds for S should within the interval [-1e10, 1e10] to avoid ' 'unexpected numerical behavior.') #: SFS sample size self.n: int = int(n) #: Parameter h mapping dominance coefficients if not varying self.h: float = h #: Dominance coefficient callback self.h_callback: Callable[[float, np.ndarray], np.ndarray] = h_callback # interval bounds for discretizing DFE self.intervals_del: Tuple[float, float, int] = intervals_del self.intervals_ben: Tuple[float, float, int] = intervals_ben # interval bounds for discretizing dominance coefficients self.intervals_h: Tuple[float, float, int] = intervals_h # grid sizes for integrals when computing allele counts for varying dominance coefficients self.n_outer: int = n_outer self.n_inner: int = n_inner # chunk size for S values when precomputing across dominance coefficients self.s_chunk_size: int = s_chunk_size self.integration_mode: Literal['midpoint', 'quad'] = integration_mode self.linearized: bool = linearized self.parallelize: bool = parallelize # define bins, midpoints and step size # these intervals are used when linearizing the integral # and when plotting the DFE self.bins: np.ndarray = self.get_bins(intervals_del, intervals_ben) self.s, self.interval_sizes = self.get_midpoints_and_spacing(self.bins) if h is None: self.h_mapped: Optional[np.ndarray] = None #: Grid over which to precompute dominance coefficients. Either fixed or varying. self.grid_h: Optional[np.ndarray] = np.linspace(intervals_h[0], intervals_h[1], int(intervals_h[2])) else: #: Mapped dominance coefficients if ``h`` is not ``None``. self.h_mapped: Optional[np.ndarray] = self.map_h(h, self.bins) self.grid_h: Optional[np.ndarray] = None # the number of intervals self.n_intervals: int = self.s.shape[0] # cache for DFE to SFS transformations of shape (n, len(grid_h), n_intervals) self._cache: np.ndarray = None @staticmethod def default_h_callback(h: float, S: np.ndarray) -> np.ndarray: """""" Default callback for mapping dominance coefficients. :param h: Dominance coefficient :param S: Population-scaled selection coefficients :return: Mapped dominance coefficients """""" return np.full_like(S, h) @staticmethod def exp(x: float | np.ndarray) -> float | np.ndarray: """""" Vectorized version of mpmath's exp function. :param x: Exponent :return: Result """""" return np.vectorize(mp.exp)(x) @staticmethod def hyp1f1(a: float | np.ndarray, b: float | np.ndarray, z: float | np.ndarray) -> float | np.ndarray: """""" Vectorized version of mpmath's hyp1f1 function. :param a: First parameter :param b: Second parameter :param z: Third parameter :return: Result """""" return np.vectorize(mp.hyp1f1)(a, b, z) @staticmethod def get_midpoints_and_spacing(bins: np.ndarray) -> Tuple[np.ndarray, np.ndarray]: """""" Obtain midpoints and spacing for the given bins. :param bins: Array of bins :return: Midpoints, spacing """""" # obtain midpoints s = (bins[1:] + bins[:-1]) / 2 interval_sizes = bins[1:] - bins[:-1] return s, interval_sizes @staticmethod def get_bins(intervals_del: tuple, intervals_ben: tuple) -> np.ndarray: """""" Get bins using log-spaced distances for positive and negative values of S given by ``intervals_ben`` and ``intervals_del``, respectively. :param intervals_del: ``(min, max, n)`` for negative values of S where we use log-spaced distances :param intervals_ben: ``(min, max, n)`` for positive values of S where we use log-spaced distances :return: Bins """""" bins_del = -np.logspace( np.log10(np.abs(intervals_del[0])), np.log10(np.abs(intervals_del[1])), int(intervals_del[2]) + 1 ) bins_ben = np.logspace( np.log10(intervals_ben[0]), np.log10(intervals_ben[1]), int(intervals_ben[2]) + 1 ) return np.concatenate([bins_del, bins_ben]) @staticmethod def get_counts_high_precision(x, S): """""" Allele frequency sojourn times semidominance using high-precision arithmetic which is not supported on all platforms. :param S: Selection coefficient :param x: Allele frequency :return: Allele frequency sojourn time """""" return ((1 - np.exp(-S * (1 - x), dtype=np.float128)) / (x * (1 - x) * (1 - np.exp(-S, dtype=np.float128)))).astype(float) @staticmethod def get_counts_high_precision_regularized(x, S: float | int | np.ndarray): """""" As H(x, S) but replacing with the limits close to the limit points. Note that this function is not used in practice. :param x: Allele frequency :param S: Selection coefficient :return: Allele frequency sojourn time """""" # make it accept scalars if isinstance(S, (float, int)): return Discretization.get_counts_high_precision_regularized(x, np.array([S]))[0] # else S is an array y = np.zeros_like(S, dtype=np.float128) # S close to zero close_to_zero = np.abs(S) < 1e-8 # limit (1 - exp(-S * (1 - x))) / (x * (1 - x) * (1 - exp(-S))) as S -> 0 # cf. https://www.wolframalpha.com/input?i=limit+%281+-+exp%28-S+*+%281+-+x%29%29%29+%2F+% # 28x+*+%281+-+x%29+*+%281+-+exp%28-S%29%29%29+as+S+-%3E+0 y[close_to_zero] = 1 / x # evaluate function as usual y[~close_to_zero] = Discretization.get_counts_high_precision(x, S[~close_to_zero]) return y @staticmethod def get_counts_fixed_semidominant(S: float | int | np.ndarray) -> float | int | np.ndarray: """""" The sojourn time as x -> 1 for semidominance. :param S: Selection coefficient :return: Sojourn time as x -> 1 """""" return S / (1 - np.exp(-S)) @staticmethod def get_counts_fixed_semidominant_regularized(S: float | int | np.ndarray) -> float | int | np.ndarray: """""" As :func:`H_fixed` but replacing with the limits close to the limit points. :param S: Selection coefficient :return: Sojourn time as x -> 1 """""" # make it accept scalars if isinstance(S, (float, int)): return Discretization.get_counts_fixed_semidominant(np.array([S]))[0] # else S is an array y = np.zeros_like(S) # S close to zero close_to_zero = np.abs(S) < 1e-8 # limit as S -> 0 y[close_to_zero] = 1 # avoid overflow for very low S very_negative = S < -500 # for very low S we are close to 0 y[very_negative] = 0 # remaining values remaining = ~(close_to_zero | very_negative) # evaluate as usual y[remaining] = Discretization.get_counts_fixed_semidominant(S[remaining]) return y @staticmethod def get_counts_fixed_dominant( S: np.ndarray, h: np.ndarray, n_bins: int = 1000, pow_cluster: int = 4 ) -> np.ndarray: """""" Allele frequency sojourn times under selection with specific dominance coefficients :param S: Selection coefficients. :param h: Dominance coefficients associated with selection coefficients or single dominance coefficient. :param n_bins: Number of grid points for integral over allele frequencies. :param pow_cluster: Power for clustering grid points towards 0. :return: Array of shape (len(S),) with sojourn times as x -> 1. """""" h = np.full_like(S, h) if np.isscalar(h) else np.asarray(h) S = np.asarray(S) x = np.linspace(0, 1, n_bins) ** pow_cluster # (n_bins,) H2 = h[:, None] # (P, 1) S2 = S[:, None] # (P, 1) xx = x[None, :] # (1, n_bins) exponent = -2 * S2 * H2 * xx - S2 * (1 - 2 * H2) * xx ** 2 # (P, n_bins) # stable exponentiation m = np.max(exponent, axis=1, keepdims=True) integrand = np.exp(exponent - m) # (P, n_bins) Z = np.trapz(integrand, x, axis=1) return np.exp(-m[:, 0]) / Z def get_counts_fixed(self, h: float) -> np.ndarray: """""" Get sojourn times as x -> 1 for fixed dominance coefficient. :param h: Parameter h mapping dominance coefficients :return: Sojourn times as x -> 1 """""" hs = self.map_h(h, self.s) return self.get_counts_fixed_dominant(self.s, hs) @staticmethod def _get_counts_dominant( n: int, k: int, h: float | np.ndarray, S: np.ndarray, n_outer: int = 1000, n_inner: int = 200, pow_cluster: int = 4 ): """""" Allele frequency sojourn times under selection with specific dominance coefficients. :param n: Sample size. :param k: Allele count. :param h: Dominance coefficients associated with selection coefficients or single dominance coefficient. :param S: Selection coefficients. :param n_outer: Grid size for outer integral over allele frequencies for binomial sampling. :param n_inner: Grid size for inner integrals over allele frequencies. :param pow_cluster: Power for clustering grid points towards 0. :return: Array of shape (len(S),) with allele counts. """""" h = np.full_like(S, h) if np.isscalar(h) else np.asarray(h) S = np.asarray(S) # x-grid x = np.linspace(0, 1, n_outer) ** pow_cluster # (n_outer,) # binomial term binom = comb(n, k) * x ** (k - 1) * (1 - x) ** (n - k - 1) # (n_outer,) # result array y = np.empty(S.size, dtype=float) # (P,) is_deleterious = S <= 0 if is_deleterious.any(): S_neg = S[is_deleterious] # (P1,) h_neg = h[is_deleterious] # (P1,) p1 = S_neg.size t = np.linspace(0, 1, n_inner) # (n_inner,) # q-grid from x to 1 xx = x[:, None, None] + (1 - x)[:, None, None] * t[None, None, :] xx = np.broadcast_to(xx, (n_outer, p1, n_inner)) # (n_outer, P1, n_inner) H3 = h_neg[None, :, None] # (1, P1, 1) SN3 = S_neg[None, :, None] # (1, P1, 1) exponent = -2 * SN3 * H3 * xx - SN3 * (1 - 2 * H3) * xx ** 2 # (n_outer, P1, n_inner) max_exp = exponent.max(axis=2, keepdims=True) # (n_outer, P1, 1) norm_q = np.trapz(np.exp(exponent - max_exp), xx, axis=2) # (n_outer, P1) del exponent, xx norm0 = norm_q[0] # (P1,) H2 = h_neg[None, :] # (1, P1) SN2 = S_neg[None, :] # (1, P1) exponent_main = np.exp( 2 * SN2 * H2 * x[:, None] + SN2 * (1 - 2 * H2) * x[:, None] ** 2 ) # (n_outer, P1) ratio = norm_q / norm0 # (n_outer, P1) integrand = binom[:, None] * exponent_main * ratio # (n_outer, P1) y[is_deleterious] = np.trapz(integrand, x, axis=0) # (P1,) if (~is_deleterious).any(): S_pos = S[~is_deleterious] # (P2,) h_pos = h[~is_deleterious] # (P2,) p2 = S_pos.size xx0 = np.linspace(0, 1, n_inner) ** pow_cluster # (n_inner,) Hn = h_pos[:, None] # (P2, 1) SPn = S_pos[:, None] # (P2, 1) XX0 = xx0[None, :] # (1, n_inner) exponent0 = -2 * SPn * Hn * XX0 - SPn * (1 - 2 * Hn) * XX0 ** 2 # (P2, n_inner) norm0 = np.trapz(np.exp(exponent0), xx0, axis=1) # (P2,) t = np.linspace(0, 1, n_inner) ** 5 # (n_inner,) xx = x[:, None, None] + (1 - x)[:, None, None] * t[None, None, :] xx = np.broadcast_to(xx, (n_outer, p2, n_inner)) # (n_outer, P2, n_inner) X = x[:, None, None] # (n_outer, 1, 1) H3b = h_pos[None, :, None] # (1, P2, 1) SP3b = S_pos[None, :, None] # (1, P2, 1) term = SP3b * (X - xx) * ((1 - 2 * H3b) * (X + xx) + 2 * H3b) # (n_outer, P2, n_inner) c = np.trapz(np.exp(term), xx, axis=2) # (n_outer, P2) del term, xx integrand = binom[:, None] * c / norm0[None, :] # (n_outer, P2) y[~is_deleterious] = np.trapz(integrand, x, axis=0) # (P2,) return y def map_h(self, h: float, S: np.ndarray) -> np.ndarray: """""" Map dominance coefficients using the default mapping. :param h: Dominance coefficient :param S: Population-scaled selection coefficients :return: Mapped dominance coefficients """""" if self.h_callback is not None: return self.h_callback(h, S) return self.default_h_callback(h, S) def precompute(self, force: bool = False): """""" Precompute DFE to SFS transformation, possibly across dominance coefficients. """""" if (hasattr(self, '_cache') and self._cache is not None) and not force: return h_mapped = np.unique(self.h_mapped) # compute special case h = 0.5 if h_mapped.size == 1 and h_mapped[0] == 0.5: self._cache = self.get_counts_semidominant()[:, None, :] return if isinstance(self.h_mapped, np.ndarray) and np.unique(self.h_mapped).size == 1: logger.info(f'Precomputing DFE-SFS transformation for fixed h={self.h_mapped[0]}.') elif self.h is not None: logger.info('Precomputing DFE-SFS transformation for fixed dominance coefficients.') else: logger.info( f'Precomputing DFE-SFS transformation across dominance coefficients (grid size: {len(self.grid_h)}).' ) self._cache = self.get_counts_dominant() def get_counts(self, h: float) -> np.ndarray: """""" Get DFE to SFS transformation for given dominance coefficient using precomputed values. Interpolates linearly between precomputed values. :param h: Parameter h mapping dominance coefficients :return: Matrix of size (n_intervals, n) :raises ValueError: If ``h`` is outside precomputed range. """""" # check for attribute to ensure backwards compatibility if not hasattr(self, ""_cache"") or self._cache is None: self.precompute() # return single precomputed value if h is fixed if self.h is not None: if h != self.h: raise ValueError(f'Dominance coefficient {h} does not match precomputed value {self.h}.') return self._cache[:, 0, :] # get surrounding indices and weights i, w = self.get_interpolation_weights(h) j = np.arange(self.n_intervals) # linear interpolation between h values interpolated = (1.0 - w) * self._cache[:, i - 1, j] + w * self._cache[:, i, j] return interpolated def get_interpolation_weights(self, h: float) -> Tuple[np.ndarray, np.ndarray]: """""" Get indices and weights for interpolating precomputed dominance coefficients across S. :param h: Parameter h mapping dominance coefficients :return: Indices and weights """""" hs = self.map_h(h, self.s) # require h within precomputed range if hs.min() < self.grid_h.min(): raise ValueError(f'Dominance coefficient {hs.min()} smaller than precomputed minimum {self.grid_h.min()}.') if hs.max() > self.grid_h.max(): raise ValueError(f'Dominance coefficient {hs.max()} larger than precomputed maximum {self.grid_h.max()}.') # find surrounding indices and weights i = np.searchsorted(self.grid_h, hs) h0, h1 = self.grid_h[i - 1], self.grid_h[i] w = (hs - h0) / (h1 - h0) return i, w def get_counts_semidominant_midpoint(self) -> np.ndarray: """""" Precompute linearized integral using midpoint integration. Consider parallelizing this. :return: Matrix of size (n_intervals, n) """""" logger.info('Precomputing semidominant DFE-SFS transformation using midpoint integration.') I = np.ones((self.n - 1, self.n_intervals + 1)) # we use midpoint integration K = np.arange(1, self.n)[:, None] * I S = self.bins[None, :] * I def compute_slice(i: int) -> np.ndarray: """""" Compute allele counts of a given multiplicity. :param i: Multiplicity :return: Discretized counts """""" return self.get_counts_semidominant_regularized(S[i], K[i]) # retrieve allele counts P = parallelize_func( func=compute_slice, data=np.arange(self.n - 1), parallelize=self.parallelize, desc=f""{self.__class__.__name__}>Precomputing"", dtype=float ) # take midpoint and multiply by interval size return (P[:, :-1] + P[:, 1:]) / 2 * self.interval_sizes def get_counts_semidominant_quad(self) -> np.ndarray: """""" Precompute linearized integral using Scipy's quad method. :return: Matrix of size (n_intervals, n) """""" logger.info('Precomputing semidominant DFE-SFS transformation using scipy.integrate.quad.') # initialize matrix P = np.zeros((self.bins.shape[0] - 1, self.n - 1)) # iterate over bins for i in range(self.bins.shape[0] - 1): logger.debug(f""Processing interval {(self.bins[i], self.bins[i + 1])}."") # iterate over allele count classes for j in range(self.n - 1): P[i, j] = quad(lambda s: (self.get_counts_semidominant_regularized( s, j + 1)), self.bins[i], self.bins[i + 1])[0] # For GammaExpParametrization, there is a discontinuity at 0 # which can cause problems integrating it using quadrature. # We remove this discontinuity here by taking the average value # of the adjacent bins. # Find bin that contains 0. i_zero = np.where((self.bins[:-1] < 0) & (self.bins[1:] >= 0))[0][0] # take average of adjacent bins P[i_zero] = (P[i_zero - 1] + P[i_zero + 1]) / 2 return P.T def get_counts_semidominant(self) -> np.ndarray: """""" Get uncached linearized DFE to SFS transformation for ``h = 0.5`` using special formulae. :return: Matrix of size (n_intervals, n) :raises NotImplementedError: If integration mode is not supported. """""" # precompute linearized transformation. if self.integration_mode == 'midpoint': return self.get_counts_semidominant_midpoint() if self.integration_mode == 'quad': return self.get_counts_semidominant_quad() raise NotImplementedError(f'Integration mode {self.integration_mode} not supported.') def get_counts_dominant(self) -> np.ndarray: """""" Get DFE to SFS transformation for different dominance coefficients. :return: Matrix of size (n_intervals, len(grid_h), n) """""" K = np.arange(1, self.n) # chunk S-bins n_chunks = int(np.ceil(len(self.bins) / self.s_chunk_size)) S_chunks = np.array_split(self.bins, n_chunks) h_mapped_chunks = np.array_split(self.h_mapped, n_chunks) if self.h_mapped is not None else None # number of dominance entries n_h = self.grid_h.size if self.h is None else 1 def compute_slice(args): """""" Compute allele counts for given (i, j, c). :param args: Tuple of (i, j, c) where i is allele count index, j is dominance index, c is S-chunk index """""" i, j, c = args return [self._get_counts_dominant( n=self.n, k=K[i], S=S_chunks[c], h=np.full_like(S_chunks[c], self.grid_h[j]) if self.h is None else h_mapped_chunks[c], n_outer=self.n_outer, n_inner=self.n_inner )] ijc = list(product( range(self.n - 1), range(n_h), range(n_chunks) )) P = parallelize_func( func=compute_slice, data=ijc, parallelize=self.parallelize, desc=f""{self.__class__.__name__}>Precomputing"", dtype=float, wrap_array=False ) P = np.concatenate(P, axis=1) P = P.reshape(self.n - 1, n_h, -1) return (P[:, :, :-1] + P[:, :, 1:]) / 2 * self.interval_sizes @to_float def get_counts_semidominant_large_negative_S( self, S: float | np.ndarray, k: float | np.ndarray ) -> np.ndarray | float: """""" Limit of get_allele_count for large negative S. :param S: Population-scaled selection coefficient :param k: Allele count :return: Number of counts in frequency class P(k) """""" return self.n / (k * (self.n - k)) * self.hyp1f1(k, self.n, S) def get_counts_semidominant_large_positive_S( self, S: float | np.ndarray, k: float | np.ndarray ) -> np.ndarray | float: """""" Limit of get_allele_count for large positive S. :param S: Population-scaled selection coefficient :param k: Allele count :return: Number of counts in frequency class P(k) """""" return self.n / (k * (self.n - k)) @to_float def get_counts_semidominant_unregularized( self, S: float | np.ndarray, k: float | np.ndarray ) -> np.ndarray | float: """""" The number of counts in frequency class P(k) with population-scaled selection coefficient S and h = 0.5. Binomial sampling is included here. See appendix of https://pubmed.ncbi.nlm.nih.gov/31975166 :param S: Population-scaled selection coefficient :param k: Allele count :return: Number of counts in frequency class P(k) """""" return (self.n / (k * (self.n - k))) * ((1 - self.exp(-S) * self.hyp1f1(k, self.n, S)) / (1 - self.exp(-S))) def get_counts_semidominant_regularized(self, S: float | np.ndarray, k: float | np.ndarray) -> float | np.ndarray: """""" As :meth:`get_counts_semidominant` but using the respective limits for ``S`` close to zero and ``S`` very negative. Note that ``S`` and ``k`` need to have the same shape. :param S: Population-scaled selection coefficient :param k: Allele count :return: Number of counts in frequency class ``P(k)` """""" # make it accept scalars for S if isinstance(S, (float, int)): return self.get_counts_semidominant_regularized(np.array([S]), np.array([k]))[0] # else S is an array y = np.zeros_like(S, dtype=float) # S close to zero close_to_zero = np.abs(S) < 1e-8 # simply take limit value as S -> 0 # see https://www.wolframalpha.com/input?i=limit+%28n%2F%28k%28n-k%29%29%29+*+ # 1%2F%281-exp%28-S%29%29+*+%281-exp%28-S%29*1F1%28k%2Cn%2CS%29%29+as+S+-%3E+0 if close_to_zero.any(): y[close_to_zero] = np.ones_like(S[close_to_zero]) / k[close_to_zero] # large negative S very_negative = S < -1e4 # Evaluate using limit. # We check if there are any negative values here # as numpy's vectorize does not work with empty arrays. if very_negative.any(): y[very_negative] = self.get_counts_semidominant_large_negative_S(S[very_negative], k[very_negative]) # remaining values of S remaining = np.array(~(close_to_zero | very_negative)) # evaluate function as usual for remaining values if remaining.any(): y[remaining] = self.get_counts_semidominant_unregularized(S[remaining], k[remaining]) return y def model_selection_sfs(self, model: Parametrization, params: dict) -> np.ndarray: """""" Infer SFS from the given DFE PDF. Note that demography is not included here. :param params: Parameters of the DFE :param model: DFE parametrization :return: SFS counts """""" if self.linearized: # get discretized DFE dfe = model._discretize(params, self.bins) / self.interval_sizes # get SFS from DFE using linearization # the interval sizes are already included here counts_modelled = self.get_counts(params.get('h', 0.5)) @ dfe else: if params.get('h', 0.5) != 0.5: raise NotImplementedError('Non-linearized integral currently only implemented for h = 0.5.') dfe_pdf = model.get_pdf(**params) def integrate(k: int) -> float: """""" Integrate over DFE using scipy's quad. Here we use the PDF. """""" def integrate_dfe(s: float) -> float: """""" Integrate over DFE for fixed k. Note that this produces too small results for low s, but we don't make use of it in production code anyway. """""" return self.get_counts_semidominant_regularized(s, k) * dfe_pdf(s) return quad(integrate_dfe, self.bins[0], self.bins[-1])[0] counts_modelled = np.array([integrate(k) for k in range(1, self.n)]) return counts_modelled def get_alpha(self, model: Parametrization, params: dict) -> float: """""" Get alpha, the proportion of beneficial non-synonymous substitutions. :param model: DFE parametrization :param params: Parameters of the DFE :return: Estimated for alpha """""" y = model._discretize(params, self.bins) * self.get_counts_fixed(params.get('h', 0.5)) return np.sum(y[self.s > 0]) / np.sum(y) def get_interval_density( self, inter: Sequence = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]) ) -> np.ndarray: """""" Get interval density. :param inter: Intervals :return: Interval density """""" return np.array([np.sum((inter[i - 1] < self.s) & (self.s < inter[i])) for i in range(1, len(inter))]) def __eq__(self, other) -> bool: """""" Compare two instances for equality. :param other: Other Discretization instance :return: True if equal, False otherwise """""" if not isinstance(other, Discretization): return False return ( self.n == other.n and self.h == other.h and np.array_equal(self.h_mapped, other.h_mapped) and self.intervals_del == other.intervals_del and self.intervals_ben == other.intervals_ben and self.intervals_h == other.intervals_h and self.n_outer == other.n_outer and self.n_inner == other.n_inner and self.s_chunk_size == other.s_chunk_size and self.integration_mode == other.integration_mode and self.linearized == other.linearized and self.parallelize == other.parallelize ) def __hash__(self) -> int: """""" Hash instance. """""" return hash(( self.n, self.h, tuple(self.intervals_del), tuple(self.intervals_ben), tuple(self.intervals_h), self.n_outer, self.n_inner, self.s_chunk_size, self.integration_mode, self.linearized, self.parallelize, )) ","Python" "Allele","Sendrowski/fastDFE","fastdfe/__init__.py",".py","6042","207",""""""" fastDFE package. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-10"" __version__ = '1.2.1' import logging import sys import jsonpickle import numpy as np import pandas as pd from tqdm import tqdm from .json_handlers import DataframeHandler, SpectrumHandler, SpectraHandler, NumpyArrayHandler from .spectrum import Spectrum, Spectra # register custom handles jsonpickle.handlers.registry.register(pd.DataFrame, DataframeHandler) jsonpickle.handlers.registry.register(Spectrum, SpectrumHandler) jsonpickle.handlers.registry.register(Spectra, SpectraHandler) jsonpickle.handlers.registry.register(np.ndarray, NumpyArrayHandler) class TqdmLoggingHandler(logging.Handler): """""" TQDM logging handler """""" def __init__(self, level=logging.NOTSET): """""" Initialize the handler. :param level: """""" super().__init__(level) def emit(self, record): """""" Emit a record. """""" try: msg = self.format(record) # we write to stderr as the progress bar # to make the two work together tqdm.write(msg, file=sys.stderr) self.flush() except Exception: self.handleError(record) class ColoredFormatter(logging.Formatter): """""" Colored formatter. """""" def __init__(self, *args, **kwargs): """""" Initialize the formatter. """""" super().__init__(*args, **kwargs) self.colors = { ""DEBUG"": ""\033[36m"", # Cyan ""INFO"": ""\033[32m"", # Green ""WARNING"": ""\033[33m"", # Yellow ""ERROR"": ""\033[31m"", # Red ""CRITICAL"": ""\033[31m"", # Red } self.reset = ""\033[0m"" def format(self, record): """""" Format the record. """""" color = self.colors.get(record.levelname, self.reset) formatted = super().format(record) # remove package name formatted = formatted.replace(record.name, record.name.split('.')[-1]) return f""{color}{formatted}{self.reset}"" # configure logger logger = logging.getLogger('fastdfe') # don't propagate to the root logger logger.propagate = False # set to INFO by default logger.setLevel(logging.INFO) # let TQDM handle the logging handler = TqdmLoggingHandler() # define a Formatter with colors formatter = ColoredFormatter('%(levelname)s:%(name)s: %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) # def raise_on_warning(message, category, filename, lineno, file=None, line=None): # """""" # Raise exception on warning. # """""" # raise Exception(warnings.formatwarning(message, category, filename, lineno, line)) # warnings.showwarning = raise_on_warning # load class from modules from .parametrization import Parametrization, GammaExpParametrization, DiscreteParametrization, \ GammaDiscreteParametrization, DisplacedGammaParametrization, DiscreteFractionalParametrization, DFE from .discretization import Discretization from .config import Config from .settings import Settings from .abstract_inference import Inference from .base_inference import BaseInference, InferenceResult from .joint_inference import JointInference, SharedParams from .optimization import Covariate from .simulation import Simulation from .spectrum import Spectrum, Spectra from .parser import Parser, Stratification, BaseTransitionStratification, BaseContextStratification, \ DegeneracyStratification, TransitionTransversionStratification, AncestralBaseStratification, \ SynonymyStratification, VEPStratification, SnpEffStratification, ContigStratification, ChunkedStratification, \ RandomStratification, TargetSiteCounter from .io_handlers import VCFHandler, FASTAHandler, GFFHandler, FileHandler from .annotation import Annotator, Annotation, MaximumParsimonyAncestralAnnotation, SiteInfo, \ MaximumLikelihoodAncestralAnnotation, DegeneracyAnnotation, SynonymyAnnotation, SubstitutionModel, \ K2SubstitutionModel, JCSubstitutionModel, PolarizationPrior, KingmanPolarizationPrior, AdaptivePolarizationPrior from .filtration import Filterer, Filtration, SNPFiltration, PolyAllelicFiltration, CodingSequenceFiltration, \ SNVFiltration, DeviantOutgroupFiltration, AllFiltration, NoFiltration, BiasedGCConversionFiltration, \ ExistingOutgroupFiltration, ContigFiltration __all__ = [ 'Parametrization', 'GammaExpParametrization', 'DiscreteParametrization', 'GammaDiscreteParametrization', 'DisplacedGammaParametrization', 'DiscreteFractionalParametrization', 'DFE', 'Discretization', 'Config', 'Settings', 'Inference', 'BaseInference', 'JointInference', 'InferenceResult', 'Simulation', 'SharedParams', 'Covariate', 'Spectrum', 'Spectra', 'Parser', 'FileHandler', 'VCFHandler', 'FASTAHandler', 'GFFHandler', 'TargetSiteCounter', 'Stratification', 'BaseTransitionStratification', 'BaseContextStratification', 'DegeneracyStratification', 'TransitionTransversionStratification', 'AncestralBaseStratification', 'SynonymyStratification', 'VEPStratification', 'SnpEffStratification', 'ContigStratification', 'ChunkedStratification', 'RandomStratification', 'Annotator', 'Annotation', 'SiteInfo', 'MaximumParsimonyAncestralAnnotation', 'MaximumLikelihoodAncestralAnnotation', 'PolarizationPrior', 'KingmanPolarizationPrior', 'AdaptivePolarizationPrior', 'SubstitutionModel', 'K2SubstitutionModel', 'JCSubstitutionModel', 'DegeneracyAnnotation', 'SynonymyAnnotation', 'Filtration', 'CodingSequenceFiltration', 'DeviantOutgroupFiltration', 'AllFiltration', 'NoFiltration', 'Filterer', 'SNPFiltration', 'SNVFiltration', 'PolyAllelicFiltration', 'BiasedGCConversionFiltration', 'ExistingOutgroupFiltration', 'ContigFiltration', 'Filterer', ] ","Python" "Allele","Sendrowski/fastDFE","fastdfe/visualization.py",".py","32384","1049",""""""" Visualization module. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" import functools import logging from typing import Callable, List, Literal, Dict, Sequence import matplotlib.colors as mcolors import matplotlib.pyplot as plt import numpy as np import pandas as pd import seaborn as sns from matplotlib import colors from matplotlib.colors import LogNorm from matplotlib.container import BarContainer from matplotlib.ticker import MaxNLocator from mpl_toolkits.axes_grid1 import make_axes_locatable from .parametrization import Parametrization # get logger logger = logging.getLogger('fastdfe').getChild('Visualization') class Visualization: """""" Visualization class. """""" @classmethod def change_default_figsize(cls, factor: float | np.ndarray): """""" Scale default figure size. :return: Factor to scale default figure size by """""" plt.rcParams[""figure.figsize""] = list(factor * np.array(plt.rcParams[""figure.figsize""])) @staticmethod def clear_show_save(func: Callable) -> Callable: """""" Decorator for clearing current figure in the beginning and showing or saving produced plot subsequently. :param func: Function to decorate :return: Wrapper function """""" @functools.wraps(func) def wrapper(*args, **kwargs) -> plt.Axes: """""" Wrapper function. :param args: Positional arguments :param kwargs: Keyword arguments :return: Axes """""" # add axes if not given if 'ax' not in kwargs or ('ax' in kwargs and kwargs['ax'] is None): # clear current figure plt.close() kwargs['ax'] = plt.gca() # execute function func(*args, **kwargs) # make layout tight plt.tight_layout() # show or save # show by default here return Visualization.show_and_save( file=kwargs['file'] if 'file' in kwargs else None, show=kwargs['show'] if 'show' in kwargs else True ) return wrapper @staticmethod def show_and_save(file: str = None, show: bool = True, pad: float = 1.08) -> plt.Axes: """""" Show and save plot. :param file: File path to save plot to :param show: Whether to show plot :param pad: Padding for tight layout :return: Axes """""" plt.tight_layout(pad=pad) # save figure if file path given if file is not None: plt.savefig(file, dpi=200, bbox_inches='tight', pad_inches=0.1) # show figure if specified and if not in interactive mode if show and not plt.isinteractive(): plt.show() # return current axes return plt.gca() @staticmethod def interval_to_string(left: float, right: float) -> str: """""" Get string representation for given interval. :param left: Right interval boundary :param right: Left interval boundary :return: String representation of interval """""" # left interval is closed by default bracket_left = '[' if left != -np.inf else '(' bracket_right = ')' def format_number(n: float) -> str: """""" Format number, allowing for np.inf. :param n: Number to format :return: Formatted number """""" if n == -np.inf: return '-inf' if n == np.inf: return 'inf' return '{:0.0f}'.format(n) return bracket_left + format_number(left) + ', ' + format_number(right) + bracket_right @staticmethod @clear_show_save def plot_discretized( ax: plt.Axes, values: Sequence, errors: Sequence = None, labels: Sequence = None, file: str = None, show: bool = True, intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), title: str = 'discretized DFE', interval_labels: List[str] = None, kwargs_legend: dict = dict(prop=dict(size=8)), ) -> plt.Axes: """""" Plot discretized DFEs using a bar plot. :param interval_labels: Labels for the intervals (which are the same for all types) :param labels: Labels for the different types of DFEs :param title: Title of the plot :param values: Array of values of size ``intervals.shape[0] - 1``, containing the discretized DFE for each type :param errors: Array of errors of size ``intervals.shape[0] - 1``, containing the discretized DFE for each type :param file: File path to save plot to :param show: Whether to show plot :param intervals: Array of interval boundaries over ``(-inf, inf)`` yielding ``intervals.shape[0] - 1`` bars. :param ax: Axes to plot on. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. :return: Axes """""" # number of intervals n_intervals = len(intervals) - 1 n_dfes = len(values) width_total = 0.9 width = width_total / n_dfes for i in range(n_dfes): x = np.arange(n_intervals) + i * width # plot discretized DFE bars = ax.bar( x=x, height=values[i], width=width, yerr=errors[i] if errors is not None else None, error_kw=dict( capsize=width * 7 ), label=labels[i] if labels is not None else None, linewidth=0, hatch=Visualization.get_hatch(i, labels), color=Visualization.get_color(labels[i], labels) if labels is not None else None ) Visualization.darken_edge_colors(bars) ax.set(xlabel='S', ylabel='fraction') # determine x-labels if interval_labels is None: xlabels = [Visualization.interval_to_string(intervals[i - 1], intervals[i]) for i in range(1, n_intervals + 1)] else: xlabels = interval_labels # customize x-ticks x = np.arange(n_intervals) ax.set_xticks([i + (width_total - width) / 2 for i in x], x) ax.set_xticklabels(xlabels) # set title ax.set_title(title) # show legend if labels were given if labels is not None: ax.legend(**kwargs_legend) # remove x-margins ax.autoscale(tight=True, axis='x') return ax @staticmethod @clear_show_save def plot_continuous( ax: plt.Axes, bins: np.ndarray, values: Sequence, errors: Sequence = None, labels: Sequence = None, file: str = None, show: bool = True, title: str = 'continuous DFE', scale: Literal['log', 'linear'] = 'lin', ylim: float = 1e-2, scale_density: bool = False, kwargs_legend: dict = dict(prop=dict(size=8)), **kwargs ) -> plt.Axes: """""" Plot DFEs using a line plot. By default, the PDF is plotted as is. Due to the logarithmic scale on the x-axis, we may get a wrong intuition on how the mass is distributed, however. To get a better intuition, we can optionally scale the density by the x-axis interval size using ``scale_density = True``. This has the disadvantage that the density now changes for x, so that even a constant density will look warped. :param ylim: y-axis limit :param scale: Scale of y-axis :param bins: Array of bin boundaries :param title: Title of the plot :param labels: Labels for the DFEs :param errors: Array of errors :param values: Array of values :param file: File path to save plot to :param show: Whether to show plot :param scale_density: Whether to scale the density by the bin size :param ax: Axes to plot on. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. :return: Axes """""" from .discretization import Discretization n_bins = len(bins) - 1 n_dfes = len(values) # get interval sizes _, interval_sizes = Discretization.get_midpoints_and_spacing(bins) for i in range(n_dfes): x = np.arange(n_bins) # plot DFE ax.plot(x, values[i] if scale_density else values[i] / interval_sizes, label=labels[i] if labels is not None else None) # visualize errors if errors is not None and errors[i] is not None: ax.fill_between( x=x, y1=(values[i] - errors[i][0]) if scale_density else (values[i] - errors[i][0]) / interval_sizes, y2=(values[i] + errors[i][1]) if scale_density else (values[i] + errors[i][1]) / interval_sizes, alpha=0.2 ) # customize x-ticks Visualization.adjust_ticks_show_s(bins) # use log scale if specified if scale == 'log': ax.set_yscale('log') ax.set_ylim(bottom=ylim) # show legend if labels were given if labels is not None: ax.legend(**kwargs_legend) # remove x-margins ax.set_xmargin(0) ax.set_title(title) return ax @staticmethod def adjust_ticks_show_s(s: np.ndarray): """""" Adjust x-ticks to show bin values. :return: Array of selection coefficients """""" n_bins = len(s) - 1 ax = plt.gca() ticks = ax.get_xticks() ticks_new = [""{:.0e}"".format(s[int(l)]) if 0 <= int(l) < n_bins else None for l in ticks] ax.set_xticks(ticks) ax.set_xticklabels(ticks_new) @staticmethod def name_to_label( key: str, param_names: Sequence = None, vals: Sequence = None ) -> str: """""" Map parameter name to label. :param key: Parameter name :param param_names: Parameter names :param vals: Parameter values :return: Label """""" # define new names for some parameters label_mapping = dict( alpha='α', eps='ε' ) # map to new name label = label_mapping[key] if key in label_mapping else key # wrap in math mode tags if param_names is None: return '$' + label + '$' # get index of parameter k = np.where(np.array(param_names) == key)[0][0] # check parameter value and add minus sign if negative if vals[k] >= 0: return '$' + label + '$' return '$-' + key + '$' @staticmethod @clear_show_save def plot_inferred_parameters( ax: plt.Axes, values: Dict[str, np.ndarray], labels: Sequence, param_names: Sequence, errors: Dict[str, np.ndarray | None], file: str = None, show: bool = True, title: str = 'parameter estimates', legend: bool = True, scale: Literal['lin', 'log', 'symlog'] = 'log', kwargs_legend: dict = dict(prop=dict(size=8), loc='upper right') ) -> plt.Axes: """""" Visualize the inferred parameters and their confidence intervals. using a bar plot. Note that there problems with parameters that span 0 (which is usually note the case). :param labels: Unique labels for the DFEs :param param_names: Labels for the parameters :param scale: Whether to use a linear or log scale :param title: Title of the plot :param legend: Whether to show the legend :param errors: Dictionary of errors with the parameter in the same order as ``labels`` :param values: Dictionary of parameter values with the parameter in the same order as ``labels`` :param file: File path to save plot to :param show: Whether to show plot :param ax: Axes to plot on. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. :return: Axes """""" labels = list(labels) n_types = len(values) width_total = 0.9 width = width_total / n_types # number of parameters n_params = len(param_names) # iterate over types for i, vals, errs in zip(range(n_types), values.values(), errors.values()): x = np.arange(n_params) + i * width # get labels for parameters xlabels = np.array([Visualization.name_to_label(key, param_names, vals) for key in param_names]) # flip errors for negative parameters if errs is not None: errs = np.array([err if vals[i] >= 0 else err[::-1] for i, err in enumerate(errs.T)]).T # Plot bars. # Note that we plot the absolute value of the parameter bars = ax.bar( x=x, height=np.abs(vals), yerr=errs, error_kw=dict( capsize=width * 7 ), label=labels[i], width=width, linewidth=0, hatch=Visualization.get_hatch(i, labels), color=Visualization.get_color(labels[i], labels) if labels is not None else None ) Visualization.darken_edge_colors(bars) # customize x-ticks x = np.arange(n_params) ax.set_xticks([i + (width_total - width) / 2 for i in x], x) ax.set_xticklabels(xlabels) # show legend if specified if legend: ax.legend(**kwargs_legend) # set title ax.set_title(title) # change to log-scale if specified if scale in ['log', 'symlog']: ax.set_yscale('symlog', linthresh=1e-3) # add y-margin at top ax.set_ylim(top=ax.get_ylim()[1] * 2) # remove x-margins ax.autoscale(tight=True, axis='x') return ax @staticmethod def plot_inferred_parameters_boxplot( values: Dict[str, pd.DataFrame], param_names: Sequence, file: str = None, show: bool = True, title: str = 'parameter estimates' ) -> plt.Axes: """""" Visualize the inferred parameters using a boxplot. :param values: Type-indexed dictionary of dataframes with parameters as columns and values as rows :param param_names: Parameters to plot :param title: Title of the plot :param file: File path to save plot to :param show: Whether to show plot :return: Axes """""" plt.close() # create a subplot with number of parameters axes fig, axs = plt.subplots(len(param_names), 1, figsize=(6, 1.4 * len(param_names))) axs[0].set_title(title) for i, param_name in enumerate(param_names): ax = axs[i] # Prepare a dataframe for seaborn df_list = [] for t, df in values.items(): subset = df[[param_name]].copy() subset['Type'] = t df_list.append(subset) df_plot = pd.concat(df_list) # plot sns.boxplot(x='Type', y=param_name, data=df_plot, ax=ax) ax.set_ylabel( Visualization.name_to_label(param_name, param_names, df_plot[param_name].abs().values), rotation=0, labelpad=20 ) ax.set_xlabel(None) if i < len(param_names) - 1: ax.set(xticklabels=[]) ax.tick_params(bottom=False) else: [l.set_rotation(90) for l in ax.get_xticklabels()] # show and save plot return Visualization.show_and_save(file, show, pad=0.3) @staticmethod def get_color( label: str, labels: List[str], get_group: Callable = lambda x: x.split('.')[-1] ) -> str: """""" Get color for specified label. :param label: Label to get color for :param labels: List of labels :param get_group: Function to get group from label :return: Color string """""" # determine unique groups groups = np.unique(np.array([get_group(l) for l in labels])) # determine group of current label group = get_group(label) # determine index of group i = np.where(groups == group)[0][0] if sum(groups == group) > 0 else 0 # return color return f'C{i}' @staticmethod def get_hatch(i: int, labels: List[str] = None) -> str | None: """""" Get hatch style for specified index i. :param labels: List of labels :param i: Index :return: Hatch style """""" # determine whether hatch style should be used if labels is None or len(labels) < 1 or '.' not in labels[i]: return # determine unique prefixes prefixes = set([label.split('.')[0] for label in labels if '.' in label]) hatch_styles = ['/////', '\\\\\\\\\\', '***', 'ooo', 'xxx', '...'] prefix = labels[i].split('.')[0] prefix_index = list(prefixes).index(prefix) return hatch_styles[prefix_index % len(hatch_styles)] @staticmethod def plot_spectra( ax: plt.Axes, spectra: List[List[float]] | np.ndarray, labels: List[str] | np.ndarray = [], colors: List[str] | np.ndarray = None, log_scale: bool = False, use_subplots: bool = False, show_monomorphic: bool = False, title: str = None, n_ticks: int = 10, file: str = None, show: bool = True, kwargs_legend: dict = dict(prop=dict(size=8)) ) -> plt.Axes: """""" Plot the given 1D spectra. :param show_monomorphic: Whether to show monomorphic site counts :param n_ticks: Number of x-ticks to use :param ax: Axes to plot on. :param ax: Axes to plot on. Only for Python visualization backend and if ``use_subplots`` is ``False``. :param title: Title of plot :param spectra: List of lists of spectra or a 2D array in which each row is a spectrum in the same order as ``labels`` :param colors: List of colors for each spectrum. :param labels: List of labels for each spectrum :param log_scale: Whether to use logarithmic y-scale :param use_subplots: Whether to use subplots :param file: File to save plot to :param show: Whether to show the plot :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. :return: Axes """""" if len(spectra) == 0: logger.warning('No spectra to plot.') return ax if use_subplots: # clear current figure plt.close() n_plots = len(spectra) n_rows = int(np.ceil(np.sqrt(n_plots))) n_cols = int(np.ceil(np.sqrt(n_plots))) fig = plt.figure(figsize=(6.4 * n_cols ** (1 / 3), 4.8 * n_rows ** (1 / 3))) axes = fig.subplots(ncols=n_cols, nrows=n_rows, squeeze=False).flatten() # plot spectra individually for i in range(n_plots): Visualization.plot_spectra( spectra=[spectra[i]], labels=[labels[i]] if len(labels) else [], colors=[colors[i]] if colors else None, ax=axes[i], n_ticks=15 // min(2, n_cols), log_scale=log_scale, show_monomorphic=show_monomorphic, show=False ) # set title axes[i].set_title(labels[i] if i < len(labels) else '') # make empty plots invisible [ax.set_visible(False) for ax in axes[n_plots:]] # show and save plot return Visualization.show_and_save(file, show) if ax is None: plt.close() _, ax = plt.subplots() # determine sample size and width n = len(spectra[0]) - 1 width_total = 0.9 width = width_total / len(spectra) x = np.arange(n + 1) if show_monomorphic else np.arange(1, n) # iterator over spectra and draw bars for i, sfs in enumerate(spectra): bars = ax.bar( x=x + i * width, height=sfs if show_monomorphic else sfs[1:-1], width=width, label=labels[i] if len(labels) else None, color=colors[i] if colors else None, linewidth=0, hatch=Visualization.get_hatch(i, labels) ) Visualization.darken_edge_colors(bars) # adjust ticks ax.xaxis.set_major_locator(MaxNLocator(integer=True)) indices_ticks = x # filter ticks if n > n_ticks: indices_ticks = indices_ticks[indices_ticks % max(int(np.ceil(n / n_ticks)), 1) == 1] ax.set_xticks([i + (width_total - width) / 2 for i in indices_ticks], indices_ticks) ax.set_xlabel('frequency') # remove x-margins ax.autoscale(tight=True, axis='x') if log_scale: ax.set_yscale('log') # set title ax.set_title(title) # show legend if more than one label if len(labels) > 1: ax.legend(**kwargs_legend) # show and save plot return Visualization.show_and_save(file, show) @staticmethod def darken_edge_colors(bars: BarContainer): """""" Darken the edge color of the given bars. :param bars: Bars to darken """""" for bar in bars: color = bar.get_facecolor() edge_color = Visualization.darken_color(color, amount=0.75) bar.set_edgecolor(edge_color) @staticmethod def darken_color(color, amount=0.5) -> tuple: """""" Darken a color. :param color: Color to darken :param amount: Amount to darken :return: Darkened color as tuple """""" c = mcolors.to_rgba(color) return c[0] * amount, c[1] * amount, c[2] * amount, c[3] @staticmethod @clear_show_save def plot_pdf( model: Parametrization, params: dict, ax: plt.Axes, s: np.ndarray = np.linspace(-100, 100, 1000), file: str = None, show: bool = True ) -> plt.Axes: """""" Plot PDF of given parametrization. :param model: DFE parametrization :param params: Parameters to be used for parametrization :param s: Selection coefficients :param file: File to save plot to :param show: Whether to show plot :param ax: Axes to plot on. :return: Axes """""" ax.plot(np.arange(len(s)), model.get_pdf(**params)(s)) # customize x-ticks Visualization.adjust_ticks_show_s(s) # remove x-margins ax.margins(x=0) return ax @staticmethod @clear_show_save def plot_cdf( model: Parametrization, params: dict, ax: plt.Axes, s: np.ndarray = np.linspace(-100, 100, 1000), file: str = None, show: bool = True ) -> plt.Axes: """""" Plot CDF of given parametrization. :param model: DFE parametrization :param params: Parameters to be used for parametrization :param s: Selection coefficients :param ax: Axes to plot on. :param file: File to save plot to :param show: Whether to show plot :return: Axes """""" ax.plot(np.arange(len(s)), model.get_cdf(**params)(s)) # customize x-ticks Visualization.adjust_ticks_show_s(s) # remove x-margins ax.margins(x=0) return ax @staticmethod @clear_show_save def plot_scatter( values: Sequence, file: str, show: bool, ax: plt.Axes, title: str | None = None, scale: Literal['lin', 'log', 'symlog'] = 'lin', ylabel: str = 'lnl' ) -> plt.Axes: """""" A scatter plot. :param scale: Scale of y-axis :param values: Values to plot :param file: File to save plot to :param show: Whether to show plot :param title: Title of plot :param ax: Axes to plot on. :param ylabel: Label of y-axis :return: Axes """""" # plot sns.scatterplot(x=range(len(values)), y=values, ax=ax) ax.set(ylabel=ylabel) # set title ax.set_title(title) if scale == 'log': ax.set_yscale('symlog') return ax @staticmethod @clear_show_save def plot_buckets_sizes( n_intervals: int, bins: Sequence, sizes: Sequence, title: str, file: str, show: bool, ax: plt.Axes ) -> plt.Axes: """""" A line plot of the bucket sizes. :param bins: Bins of the histogram :param n_intervals: Number of intervals :param sizes: Sizes of the buckets :param title: Title of plot :param file: File to save plot to :param show: Whether to show plot :param ax: Axes to plot on. :return: Axes """""" # plot line ax.plot(np.arange(n_intervals), sizes) # use log scale ax.set_yscale('log') ax.set_title(title) # customize x-ticks Visualization.adjust_ticks_show_s(bins) # remove x-margins ax.set_xmargin(0) return ax @staticmethod @clear_show_save def plot_nested_models( P: np.ndarray, labels_x: Sequence, labels_y: Sequence, ax: plt.Axes, file: str = None, show: bool = True, cmap: str = None, title: str = None, vmin: float = 1e-10, vmax: float = 1, ) -> plt.Axes: """""" Plot p-values of nested likelihoods. :param P: Matrix of p-values :param labels_x: Labels for x-axis :param labels_y: Labels for y-axis :param file: File to save plot to :param show: Whether to show plot :param cmap: Colormap to use :param title: Title of plot :param ax: Axes to plot on. :param vmin: Minimum value for colorbar :param vmax: Maximum value for colorbar :return: Axes """""" def format_number(x: float | int | None) -> float | int | str: """""" Format number to be displayed. :param x: Number to format :return: Formatted number """""" if x == 0 or x is None: return 0 if x < 0.0001: return ""{:.1e}"".format(x) return np.round(x, 4) # determine values to display annotation = np.vectorize(lambda x: str(format_number(x)))(P) annotation[np.equal(P, None)] = '-' # change to 1 to get a nicer color P[np.equal(P, None)] = 1 # keep within color bar bounds P[P < vmin] = vmin P[P > vmax] = vmax # make the cbar have the same height as the heatmap cbar_ax = make_axes_locatable(ax).new_horizontal(size=""4%"", pad=0.15) plt.gcf().add_axes(cbar_ax) # default color map if cmap is None: cmap = colors.LinearSegmentedColormap.from_list('_', plt.get_cmap('inferno')(np.linspace(0.3, 1, 100))) # plot heatmap sns.heatmap( P.astype(float), ax=ax, cbar_ax=cbar_ax, cmap=cmap, norm=LogNorm( vmin=vmin, vmax=vmax ), annot=annotation, fmt="""", square=True, linewidths=0.5, linecolor='#cccccc', cbar_kws=dict( label='p-value' ) ) # adjust tick labels ax.set_xticklabels([l.replace('_', ' ') for l in labels_x], rotation=45) ax.set_yticklabels([l.replace('_', ' ') for l in labels_y], rotation=0) # set title ax.set_title(title) return ax @staticmethod @clear_show_save def plot_interval_density( ax: plt.Axes, density: np.ndarray, intervals: Sequence = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), interval_labels: List[str] = None, file: str = None, show: bool = True, color: str = 'C0', ) -> plt.Axes: """""" Plot density of the discretization intervals chosen. :param density: Discretized density. :param color: Color of the bars. :param file: File to save plot to. :param show: Whether to show plot. :param interval_labels: Labels for the intervals. :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. :param ax: Axes to plot on. :return: Axes object """""" # number of intervals n_intervals = len(intervals) # x-values x = np.arange(n_intervals - 1) # plot plot sns.barplot(x=x, y=density / density.sum(), color=color, ax=ax) # set labels ax.set(xlabel='S', ylabel='fraction') # determine x-labels if interval_labels is None: xlabels = [Visualization.interval_to_string(intervals[i - 1], intervals[i]) for i in range(1, n_intervals)] else: xlabels = interval_labels # adjust x-ticks ax.set_xticks(x) ax.set_xticklabels(xlabels) # set title ax.set_title('interval density') # remove x-margins ax.autoscale(tight=True, axis='x') return ax @staticmethod @clear_show_save def plot_covariate( covariates: Sequence, values: Sequence, xlabel: str, ylabel: str, labels: Sequence = None, errors: Sequence = None, file: str = None, show: bool = True, title: str = 'likelihoods', ax: plt.Axes = None ) -> plt.Axes: """""" :param covariates: The covariate values. :param values: The MLE parameter values. :param xlabel: X-axis label. :param ylabel: Y-axis label. :param labels: Labels for the different types :param errors: The errors on the MLE parameter values. :param labels: Labels for the different types :param file: File to save plot to :param show: Whether to show plot :param title: Title of plot :param ax: Axes to plot on. :return: Axes """""" ax.scatter(x=covariates, y=np.array(values)) # plot error bars if errors is not None: ax.errorbar( x=covariates, y=np.array(values), yerr=np.array(errors), fmt='none', capsize=3 ) # set labels ax.set(xlabel=xlabel, ylabel=Visualization.name_to_label(ylabel)) # set title ax.set_title(title) # Add second x-axis on top of the plot to show the labels if labels is not None: ax2 = ax.twiny() ax2.set_xticks(covariates) ax2.set_xticklabels(labels, rotation=45, ha='left') ax2.set_xlim(ax.get_xlim()) return ax ","Python" "Allele","Sendrowski/fastDFE","fastdfe/polydfe_utils.py",".py","5286","203",""""""" Utilities for parsing polyDFE files. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" import logging import os from typing import TextIO, List, Tuple import pandas as pd from .spectrum import Spectrum # get logger logger = logging.getLogger('fastdfe').getChild('polydfe') #: model mapping models = dict( DisplacedGammaParametrization='A', GammaDiscreteParametrization='B', GammaExpParametrization='C', DiscreteParametrization='D' ) # leading column names in init file columns = [ 'eps', 'eps_deprecated', 'lambda', 'theta_bar', 'a' ] class ParamMode: """""" Parameter modes in polyDFE input files. """""" independent = 0 fixed = 1 shared = 2 def create_sfs_config( file: str, sfs_neut: Spectrum, sfs_sel: Spectrum ): """""" Create a sfs config file for polyDFE. :param sfs_sel: Selected sfs :param sfs_neut: Neutral sfs :param file: Path to config file """""" def write_line(f: TextIO, sfs: Spectrum, sep: str = '\t'): """""" Concatenate given array and write to stream. :param sfs: SFS :param f: File stream :param sep: separator """""" # SFS and number of mutational target sites # we ignore divergence data here data = list(sfs.polymorphic) + [sfs.n_sites] f.write(sep.join(map(str, data)) + os.linesep) # number of spectra per time m_neut = 1 m_sel = 1 with open(file, 'w') as fh: fh.write(' '.join(map(str, [m_neut, m_sel, sfs_sel.n])) + os.linesep) write_line(fh, sfs_neut) write_line(fh, sfs_sel) def parse_init_file( dfe_params: list, file: str, id: int = 1, ignore: list = ['eps_deprecated', 'r'] ) -> Tuple[dict, dict]: """""" Parse polyDFE init file. This will define the initial parameters and which ones will be held fixed during the optimization. We do not support fixing some of the polyDFE's parameters like theta and the nuisance parameters. Some other parameters are not supported altogether. :param dfe_params: List of dfe parameters :param file: Path to init file :param id: Init id :param ignore: List of parameters to ignore :return Dictionary of fixed parameters and dictionary of initial values """""" logger.info('Parsing init file.') # columns except for nuisance parameters cols = columns + list(dfe_params) # load init file into dataframe df = pd.read_csv(file, delimiter=r""\s+"", comment='#', header=None, index_col=0) # check if id is present if id not in df.index: raise Exception(f'Id {id} not found in init file. Possible ids: {str(df.index.to_list())}.') # extract row with specified id data = df.loc[id] # Retrieve parameters and their modes. # Note that the parameter order is important # when recreating the init file. params, params_mode = {}, {} for i, col in enumerate(cols): params[col] = data[2 * i + 2] params_mode[col] = int(data[2 * i + 1]) # assign nuisance parameters params['r'] = list(data[2 * len(cols) + 1:]) params_mode['r'] = int(data[2 * len(cols) + 1]) # determine fixed parameters and initial conditions fixed_params = {} x0 = {} for param in params_mode.keys(): if param not in ignore: # here we don't distinguish between shared and independent parameters if params_mode[param] == ParamMode.fixed: fixed_params[param] = params[param] x0[param] = params[param] # issue notice logger.info(f""Found initial params: {x0} and fixed params: {fixed_params} when parsing init file."") return fixed_params, x0 def create_init_file( file: str, fixed_params: List, x0: dict, dfe_params: List, n: int, id: int = 1 ): """""" Create an init file for polyDFE. :param id: Init id :param n: SFS sample size :param dfe_params: List of dfe parameters :param x0: Dictionary of initial values :param fixed_params: List of fixed parameters :param file: File path to write init file to """""" cols = columns + list(dfe_params) + ['r'] # copy dict to avoid modification x0 = x0.copy() if 'r' in x0: # assign existing nuisance parameters x0['r'] = ' '.join([str(r) for r in x0['r']]) else: # make up initial nuisance parameters x0['r'] = ' '.join(['1'] * (n - 1)) # create list of initial parameters params = [] for col in cols: if col in x0: params += [x0[col]] else: params += [0] # create list of parameter modes params_mode = [] for col in cols: if col in fixed_params: params_mode += [ParamMode.fixed] else: params_mode += [ParamMode.independent] # concatenate parameters and their modes params_with_mode = [str(a) + ' ' + str(b) for a, b in zip(list(params_mode), params)] # prepend an id value and join line = '\t'.join([str(id)] + params_with_mode) # write line to file with open(file, 'w') as fh: fh.write(line) ","Python" "Allele","Sendrowski/fastDFE","fastdfe/parser.py",".py","50339","1370",""""""" A VCF parser that can be used to extract the site frequency spectrum (SFS) from a VCF file. Stratifying the SFS is supported by providing a list of :class:`Stratification` instances. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-26"" import functools import itertools import logging import random from abc import ABC, abstractmethod from collections import Counter, defaultdict from typing import List, Callable, Literal, Optional, Dict, Tuple, Union import numpy as np from Bio.SeqRecord import SeqRecord from scipy.stats import hypergeom from tqdm import tqdm from .annotation import Annotation, SynonymyAnnotation, DegeneracyAnnotation, AncestralAlleleAnnotation from .filtration import Filtration, PolyAllelicFiltration, SNPFiltration from .io_handlers import bases, get_called_bases, FASTAHandler, NoTypeException, \ DummyVariant, MultiHandler, VCFHandler, is_monomorphic_snp from .settings import Settings from .spectrum import Spectra # logger logger = logging.getLogger('fastdfe') def _count_valid_type(func: Callable) -> Callable: """""" Decorator for counting the number of sites that had a valid type. """""" @functools.wraps(func) def wrapper(self, variant: Union['cyvcf2.Variant', DummyVariant]): """""" Wrapper function. :param self: Class instance :param variant: The vcf site :return: The result of the decorated function """""" res = func(self, variant) self.n_valid += 1 return res return wrapper class Stratification(ABC): """""" Abstract class for Stratifying the SFS by determining a site's type based on its properties. """""" def __init__(self): """""" Create instance. """""" self._logger = logger.getChild(self.__class__.__name__) #: Parser instance self.parser: Optional['Parser'] = None #: The number of sites that didn't have a type. self.n_valid: int = 0 def _setup(self, parser: 'Parser'): """""" Provide the stratification with some context by specifying the parser. This should be done before calling :meth:`get_type`. :param parser: The parser """""" self.parser = parser def _rewind(self): """""" Rewind the stratification. """""" self.n_valid = 0 def _teardown(self): """""" Perform any necessary post-processing. """""" self._logger.info(f""Number of sites with valid type: {self.n_valid}"") @abstractmethod def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> Optional[str]: """""" Get type of given Variant. Only the types given by :meth:`get_types()` are valid, or ``None`` if no type could be determined. :param variant: The vcf site :return: Type of the variant """""" pass @abstractmethod def get_types(self) -> List[str]: """""" Get all possible types. :return: List of types """""" pass class SNPStratification(Stratification, ABC): """""" Abstract class for stratifications that can only handle SNPs. We need to issue a warning in this case. """""" def _setup(self, parser: 'Parser'): """""" Set up the stratification. :param parser: The parser """""" super()._setup(parser) # issue warning if we have an SNP stratification self._logger.warning(f""{self.__class__.__name__} can only handle SNPs and not mono-allelic sites. "" ""This means you have to update the number of mono-allelic sites manually."") class BaseContextStratification(Stratification, FASTAHandler): """""" Stratify the SFS by the base context of the mutation. The number of flanking bases can be configured. Note that we attempt to take the ancestral allele as the middle base. If ``skip_non_polarized`` is set to ``False``, we use the reference allele as the middle base. """""" def __init__( self, fasta: str, n_flanking: int = 1, aliases: Dict[str, List[str]] = {}, cache: bool = True ): """""" Create instance. Note that we require a fasta file to be specified for base context to be able to be inferred :param fasta: The fasta file path, possibly gzipped or a URL :param n_flanking: The number of flanking bases :param aliases: Dictionary of aliases for the contigs in the VCF file, e.g. ``{'chr1': ['1']}``. This is used to match the contig names in the VCF file with the contig names in the FASTA file and GFF file. :param cache: Whether to cache files that are downloaded from URLs """""" Stratification.__init__(self) FASTAHandler.__init__(self, fasta, cache=cache, aliases=aliases) #: The number of flanking bases self.n_flanking: int = n_flanking #: The current contig self.contig: Optional[SeqRecord] = None def _rewind(self): """""" Rewind the stratification. """""" Stratification._rewind(self) FASTAHandler._rewind(self) self.contig = None @_count_valid_type def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: """""" Get the base context for a given mutation :param variant: The vcf site :return: Base context of the mutation """""" pos = variant.POS - 1 # get the ancestral allele aa = self.parser._get_ancestral(variant) # get aliases aliases = self.get_aliases(variant.CHROM) # check if contig is up-to-date if self.contig is None or self.contig.id not in aliases: self._logger.debug(f""Fetching contig '{variant.CHROM}'."") # fetch contig self.contig = self.get_contig(aliases) # check if position is valid if pos < 0 or pos >= len(self.contig): raise NoTypeException(""Invalid position: Position must be within the bounds of the sequence."") # get upstream bases upstream_start = max(0, pos - self.n_flanking) upstream_bases = str(self.contig.seq[upstream_start:pos]) # get downstream bases downstream_end = min(len(self.contig), pos + self.n_flanking + 1) downstream_bases = str(self.contig.seq[pos + 1:downstream_end]) return f""{upstream_bases}{aa}{downstream_bases}"" def get_types(self) -> List[str]: """""" Create all possible base contexts. :return: List of contexts """""" return [''.join(c) for c in itertools.product(bases, repeat=2 * self.n_flanking + 1)] class BaseTransitionStratification(SNPStratification): """""" Stratify the SFS by the base transition of the mutation, i.e., ``A>T``. .. warning:: This stratification only works for SNPs. You thus need to update the number of mono-allelic sites manually. """""" @_count_valid_type def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: """""" Get the base transition for the given variant. :param variant: The vcf site :return: Base transition :raises NoTypeException: if not type could be determined """""" if variant.is_snp: ancestral = self.parser._get_ancestral(variant) derived = variant.REF if variant.REF != ancestral else variant.ALT[0] if ancestral in bases and derived in bases and ancestral != derived: return f""{ancestral}>{derived}"" raise NoTypeException(""Not a valid base transition."") raise NoTypeException(""Site is not a SNP."") def get_types(self) -> List[str]: """""" Get all possible base transitions. :return: List of contexts """""" return ['>'.join([a, b]) for a in bases for b in bases if a != b] class TransitionTransversionStratification(BaseTransitionStratification): """""" Stratify the SFS by whether we have a transition or transversion. .. warning:: This stratification only works for SNPs. You thus need to update the number of mono-allelic sites manually. """""" @_count_valid_type def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: """""" Get the mutation type (transition or transversion) for a given mutation. :param variant: The vcf site :return: Mutation type """""" if variant.is_snp: if variant.ALT[0] not in bases: raise NoTypeException(""Invalid alternate allele: Alternate allele must be a valid base."") if (variant.REF, variant.ALT[0]) in [('A', 'G'), ('G', 'A'), ('C', 'T'), ('T', 'C')]: return ""transition"" else: return ""transversion"" raise NoTypeException(""Site is not a SNP."") def get_types(self) -> List[str]: """""" All possible mutation types (transition and transversion). :return: List of mutation types """""" return [""transition"", ""transversion""] class AncestralBaseStratification(Stratification): """""" Stratify the SFS by the base context of the mutation: the reference base. If ``skip_non_polarized`` is set to ``False``, we use the reference allele as ancestral base. By default, we use the ``AA`` tag to determine the ancestral allele. Any subclass of :class:`~fastdfe.parser.AncestralAnnotation` can be used to annotate the ancestral allele. """""" @_count_valid_type def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: """""" Get the type which is the reference allele. :param variant: The vcf site :return: reference allele """""" return self.parser._get_ancestral(variant) def get_types(self) -> List[str]: """""" The possible base types. :return: List of contexts """""" return bases class DegeneracyStratification(Stratification): """""" Stratify SFS by degeneracy. We only consider sides which 4-fold degenerate (neutral) or 0-fold degenerate (selected) which facilitates counting. :class:`~fastdfe.annotation.DegeneracyAnnotation` can be used to annotate the degeneracy of a site. """""" def __init__( self, custom_callback: Callable[['cyvcf2.Variant'], str] = None, ): """""" Initialize the stratification. :param custom_callback: Custom callback to determine the type of mutation """""" super().__init__() #: Custom callback to determine the degeneracy of mutation self.get_degeneracy = custom_callback if custom_callback is not None else self._get_degeneracy_default @staticmethod def _get_degeneracy_default( variant: Union['cyvcf2.Variant', DummyVariant] ) -> Optional[Literal['neutral', 'selected']]: """""" Get degeneracy based on 'Degeneracy' tag. :param variant: The vcf site :return: Type of the mutation """""" degeneracy = variant.INFO.get('Degeneracy') if degeneracy is None: raise NoTypeException(""No degeneracy tag found."") else: if degeneracy == 4: return 'neutral' if degeneracy == 0: return 'selected' raise NoTypeException(f""Degeneracy tag has invalid value: '{degeneracy}' at {variant.CHROM}:{variant.POS}"") @_count_valid_type def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> Literal['neutral', 'selected']: """""" Get the degeneracy. :param variant: The vcf site :return: Type of the mutation :raises NoTypeException: If the mutation is not synonymous or non-synonymous """""" return self.get_degeneracy(variant) def get_types(self) -> List[str]: """""" Get all possible degeneracy type (``neutral`` and ``selected``). :return: List of contexts """""" return ['neutral', 'selected'] class SynonymyStratification(SNPStratification): """""" Stratify SFS by synonymy (neutral or selected). :class:`~fastdfe.annotation.SynonymyAnnotation` can be used to annotate the synonymy of a site. .. warning:: This stratification only works for SNPs. You thus need to update the number of mono-allelic sites manually. """""" def get_types(self) -> List[str]: """""" Get all possible synonymy types (``neutral`` and ``selected``). :return: List of contexts """""" return ['neutral', 'selected'] @_count_valid_type def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> Literal['neutral', 'selected']: """""" Get the synonymy using the custom synonymy annotation. :param variant: The vcf site :return: Type of the mutation, either ``neutral`` or ``selected`` """""" synonymy = variant.INFO.get('Synonymy') if synonymy is None: raise NoTypeException(""No synonymy tag found."") else: if synonymy == 1: return 'neutral' if synonymy == 0: return 'selected' raise NoTypeException(f""Synonymy tag has invalid value: '{synonymy}' at {variant.CHROM}:{variant.POS}"") class VEPStratification(SynonymyStratification): """""" Stratify SFS by synonymy (neutral or selected) based on annotation provided by VEP. .. warning:: This stratification only works for SNPs. You thus need to update the number of mono-allelic sites manually. """""" #: The tag used by VEP to annotate the synonymy info_tag = 'CSQ' def get_types(self) -> List[str]: """""" Get all possible synonymy types (``neutral`` and ``selected``). :return: List of contexts """""" return ['neutral', 'selected'] @_count_valid_type def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> Literal['neutral', 'selected']: """""" Get the synonymy of a site. :param variant: The vcf site :return: Type of the mutation, either ``neutral`` or ``selected`` """""" synonymy = variant.INFO.get(self.info_tag, '') if 'synonymous_variant' in synonymy: return 'neutral' if 'missense_variant' in synonymy: return 'selected' raise NoTypeException(f""Synonymy tag has invalid value: '{synonymy}' at {variant.CHROM}:{variant.POS}"") class SnpEffStratification(VEPStratification): """""" Stratify SFS by synonymy (neutral or selected) based on annotation provided by SnpEff. .. warning:: This stratification only works for SNPs. You thus need to update the number of mono-allelic sites manually. """""" #: The tag used by SnpEff to annotate the synonymy info_tag = 'ANN' class GenomePositionDependentStratification(Stratification, ABC): pass class ContigStratification(GenomePositionDependentStratification): """""" Stratify SFS by contig. """""" def __init__(self, contigs: List[str] = None): """""" Initialize the stratification. :param contigs: List of contigs to stratify by. Defaults to all contigs in the VCF file. """""" super().__init__() #: List of contigs self.contigs: List[str] = contigs @_count_valid_type def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: """""" Get the contig. :param variant: The vcf site :return: The contig name """""" if self.contigs is not None and variant.CHROM not in self.contigs: raise NoTypeException(f""Contig '{variant.CHROM}' not in list of contigs."") return variant.CHROM def get_types(self) -> List[str]: """""" Get all possible contig type. :return: List of contexts """""" return self.contigs or list(self.parser._reader.seqnames) class ChunkedStratification(GenomePositionDependentStratification): """""" Stratify SFS by creating ``n`` contiguous chunks of roughly equal size. .. note:: Since the total number of sites is not known in advance, we cannot create contiguous chunks of exactly equal size. """""" def __init__(self, n_chunks: int): """""" Initialize the stratification. :param n_chunks: Number of sites per window """""" super().__init__() #: Number of chunks self.n_chunks: int = int(n_chunks) #: List of chunk sizes self.chunk_sizes: Optional[List[int]] = None #: Number of sites seen so far self.counter: int = 0 def _setup(self, parser: 'Parser'): """""" Set up the stratification. :param parser: The parser """""" super()._setup(parser) # compute base chunk size and remainder base_chunk_size, remainder = divmod(parser.n_sites, self.n_chunks) # create list of chunk sizes self.chunk_sizes = [base_chunk_size + (i < remainder) for i in range(self.n_chunks)] def get_types(self) -> List[str]: """""" Get all possible window types. :return: List of contexts """""" return [f'chunk{i}' for i in range(self.n_chunks)] @_count_valid_type def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: """""" Get the type. :param variant: The vcf site :return: The type """""" # find the index of the chunk to which the current site belongs chunk_index = next(i for i, size in enumerate(self.chunk_sizes) if self.counter < sum(self.chunk_sizes[:i + 1])) # get the type t = f'chunk{chunk_index}' # update the counter self.counter += 1 return t class RandomStratification(Stratification): """""" Stratify the SFS randomly into a fixed number of bins. Can be used to analyze expected sampling variance between different stratifications. """""" def __init__(self, n_bins: int, seed: Optional[int] = 0): """""" Initialize random stratification. :param n_bins: Number of bins to randomly assign sites to. """""" super().__init__() if n_bins < 1: raise ValueError(""n_bins must be at least 1."") #: Number of bins self.num_bins: int = n_bins #: Random seed for reproducibility self.seed: Optional[int] = seed #: Random generator instance self.rng = random.Random(seed) @_count_valid_type def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: """""" Assign the variant to a random bin. :param variant: The VCF site :return: Randomly chosen bin label """""" return f""bin{self.rng.randint(0, self.num_bins - 1)}"" def get_types(self) -> List[str]: """""" Get all possible bin labels. :return: List of bin labels """""" return [f""bin{i}"" for i in range(self.num_bins)] class TargetSiteCounter: """""" Class for counting the number of target sites when parsing a VCF file that does not contain monomorphic sites. This class is used in conjunction with :class:`~fastdfe.parser.Parser` and samples sites from the given fasta file that are found in between variants on the same contig that were parsed in the VCF. Ideally, we obtain the SFS by parsing VCF files that contain both mono- and polymorphic sites. This is because we need to know about the number of mutational opportunities for synonymous and non-synonymous sites which contain plenty of information on the strength of selection. It is recommended to use a SNPFiltration when using this class to avoid biasing the result by monomorphic sites present in the VCF file. .. warning:: This class is not compatible with stratifications based on info tags that are pre-defined in the VCF file, as opposed to those added dynamically using the ``annotations`` argument of the parser. We also need to stratify mono-allelic sites which, in this case, won't be present in the VCF file so that they have no info tags when sampling from the FASTA file, and are thus ignored by the stratifications. However, using the ``annotations`` argument of the parser, the info tags the stratifications are based on are added on-the-fly, also for monomorphic sites sampled from the FASTA file. """""" def __init__( self, n_target_sites: int, n_samples: int = int(1e5), ): """""" Initialize counter. :param n_target_sites: The total number of sites (mono- and polymorphic) that would be present in the VCF file if it contained monomorphic sites. This number should be considerably larger than the number of polymorphic sites in the VCF file. This value is not extremely important for the DFE inference, the ratio of synonymous to non-synonymous sites being more informative, but the order of magnitude should be correct, in any case. :param n_samples: The number of sites to sample from the fasta file. Many sampled sites will not be valid as they are non-coding. To obtain good estimates, a few thousand sites should be sampled per type of site (depending on the stratifications used). """""" #: The logger self._logger = logger.getChild(self.__class__.__name__) #: The total number of sites considered when parsing the VCF self.n_target_sites: int | None = int(n_target_sites) #: Number of samples self.n_samples: int = int(n_samples) #: The spectra before inferring the number of target sites self._sfs_polymorphic: Spectra | None = None def _setup(self, parser: 'Parser'): """""" Set up the counter. :param parser: The parser """""" self.parser = parser # require fasta file self.parser._require_fasta(self.__class__.__name__) # check if we have a SNPFiltration if not any([isinstance(f, SNPFiltration) for f in self.parser.filtrations]): self._logger.warning(""It is recommended to use SNPFiltration together with "" ""TargetSiteCounter to avoid biasing the result by monomorphic sites."") # check if have degeneracy stratification but no degeneracy annotation if any([isinstance(s, DegeneracyStratification) for s in self.parser.stratifications]) \ and not any([isinstance(a, DegeneracyAnnotation) for a in self.parser.annotations]): self._logger.warning(""When using TargetSiteCounter with DegeneracyStratification, "" ""make sure to provide DegeneracyAnnotation to make sure the "" ""sites sampled from the FASTA file have a degeneracy tag."") def _teardown(self): """""" Perform any necessary post-processing. """""" # tear down parser self.parser._teardown() def _suspend_snp_filtration(self): """""" Suspend SNP filtration to make sure we sample can actually sample monomorphic sites. """""" # store original filtrations self._filtrations = self.parser.filtrations # remove SNPFiltration self.parser.filtrations = [f for f in self.parser.filtrations if not isinstance(f, SNPFiltration)] def _resume_snp_filtration(self): """""" Resume SNP filtration. """""" # restore original filtrations self.parser.filtrations = self._filtrations def count(self): """""" Count the number of target sites. :return: The number of target sites """""" # rewind parser components self.parser._rewind() # suspend SNP filtration self._suspend_snp_filtration() # rewind fasta iterator FASTAHandler._rewind(self.parser) # initialize random number generator rng = np.random.default_rng(self.parser.seed) # initialize progress bar pbar = tqdm( total=self.n_samples, desc=f'{self.__class__.__name__}>Sampling target sites', disable=Settings.disable_pbar ) # get array of ranges per contig of parsed variants ranges = np.array(list(self.parser._contig_bounds.values())) # get range sizes range_sizes = ranges[:, 1] - ranges[:, 0] # determine sampling probabilities probs = range_sizes / np.sum(range_sizes) # sample number of sites per contig samples = rng.multinomial(self.n_samples, probs) # keep track of SFS before update self._sfs_polymorphic = Spectra(self.parser.sfs) # initialize counter i = 0 # iterate over contigs for contig, bounds, n in zip(self.parser._contig_bounds.keys(), ranges, samples): # get aliases aliases = self.parser.get_aliases(contig) # make sure we have a valid range if bounds[1] > bounds[0] and n > 0: self._logger.debug(f""Sampling {n} sites from contig '{contig}'."") # fetch contig record = self.parser.get_contig(aliases, notify=False) # get positions # we sort in ascending order as the parser expects the positions to be sorted positions = np.sort(rng.integers(*bounds, size=n)) # sample sites for pos in positions: # create dummy variant variant = DummyVariant( ref=record.seq[pos - 1], # fasta is 0-based pos=pos, # VCF is 1-based chrom=contig ) # check if site was included in the SFS if self.parser._process_site(variant): i += 1 # update progress bar pbar.update() # close progress bar pbar.close() # resume SNP filtration self._resume_snp_filtration() # tear down self._teardown() # notify on number of sites included in the SFS self._logger.info(f""{i} out of {self.n_samples} sampled sites were valid."") def _update_target_sites(self, spectra: Spectra) -> Spectra: """""" Update the target sites of the spectra. :param spectra: The spectra, including the sampled monomorphic sites. :return: The updated spectra. """""" # copy spectra spectra = spectra.copy() # cast to float to avoid implicit type conversion later on spectra.data = spectra.data.astype(float) # subtract by monomorphic counts of original spectra # we only want to consider the monomorphic sites sampled from the FASTA file spectra.data.iloc[[0, -1], :] -= self._sfs_polymorphic.data.iloc[[0, -1], :] # get number of monomorphic and polymorphic sites sampled from the FASTA and VCF file n_monomorphic = spectra.data.iloc[0, :].sum() n_polymorphic = spectra.data.iloc[1:, :].sum().sum() # check if we have enough target sites if self.n_target_sites < n_polymorphic: self._logger.warning(f""Number of polymorphic sites ({n_polymorphic}) exceeds the total "" f""number of target sites ({self.n_target_sites}) which does not make sense. "" f""The number of target sites unchanged is left unchanged."") elif n_monomorphic == 0: self._logger.warning(f""Number of monomorphic sites is zero which should only happen "" f""if there are very few sites considered. Failed to adjust "" f""the number of monomorphic sites."") else: # compute multiplicative factor to scale the total number of sites # to the number of target sites plus the number of polymorphic sites x = (self.n_target_sites + self._sfs_polymorphic.n_polymorphic.sum() - n_polymorphic) / n_monomorphic # extrapolate monomorphic counts using scaling factor spectra.data.iloc[0, :] *= x # subtract polymorphic counts from original spectra, # so that the total number of sites is equal to the number of target sites # we do this to correct for the fact that, for a type, we have relatively # fewer monomorphic sites if we have more polymorphic sites # TODO include monomorphic sites here from VCF? spectra.data.iloc[0, :] -= self._sfs_polymorphic.n_polymorphic return spectra class Parser(MultiHandler): """""" Parse site-frequency spectra from VCF files. By default, the parser looks at the ``AA`` tag in the VCF file's info field to retrieve the correct polarization. Polymorphic sites for which this tag is not well-defined are by default ignored (see ``skip_non_polarized``). This class also offers on-the-fly annotation of the VCF sites such as site degeneracy and ancestral allele state. This is done by providing a list of annotations to the parser which are applied in the order they are provided. The parser also allows to filter sites based on site properties which is done by passing a list of filtrations. By default, we filter out poly-allelic sites as sites are assumed to be at most bi-allelic. In addition, the parser allows to stratify the SFS by providing a list of stratifications. This is useful to obtain the SFS for different types of sites for which we can jointly infer the DFEs using :class:`~fastdfe.joint_inference.JointInference`. To correctly determine the number of target sites when parsing a VCF file that does not contain monomorphic sites, we can use a :class:`~fastdfe.parser.TargetSiteCounter`. This class is used in conjunction with the parser and samples sites from the given FASTA file that are found in between variants on the same contig that were parsed in the VCF. Note that we assume the sites in the VCF file to be sorted by position in ascending order (per contig). Example usage: :: import fastdfe as fd # Parse selected and neutral SFS from human chromosome 1. p = fd.Parser( vcf=""https://ngs.sanger.ac.uk/production/hgdp/hgdp_wgs.20190516/"" ""hgdp_wgs.20190516.full.chr21.vcf.gz"", fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"", gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", aliases=dict(chr21=['21']), # mapping for contig names n=10, # SFS sample size # we use a target site counter to infer the number of target sites. target_site_counter=fd.TargetSiteCounter( n_samples=1000000, # determine number of target sites by looking at total length of coding sequences n_target_sites=fd.Annotation.count_target_sites( ""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"" )['21'] ), # add degeneracy annotation for sites annotations=[ fd.DegeneracyAnnotation() ], filtrations=[ # exclude non-SNPs as we infer monomorphic sites with target site counter fd.SNPFiltration(), # filter out sites not in coding sequences fd.CodingSequenceFiltration() ], # stratify by 4-fold/0-fold degeneracy stratifications=[fd.DegeneracyStratification()], info_ancestral='AA_ensembl' ) sfs = p.parse() sfs.plot() """""" def __init__( self, vcf: str, n: int, gff: str | None = None, fasta: str | None = None, info_ancestral: str = 'AA', info_ancestral_prob: str = 'AA_prob', skip_non_polarized: bool = True, stratifications: List[Stratification] = [], annotations: List[Annotation] = [], filtrations: List[Filtration] = None, include_samples: List[str] = None, exclude_samples: List[str] = None, max_sites: int = np.inf, seed: int | None = 0, cache: bool = True, aliases: Dict[str, List[str]] = {}, target_site_counter: TargetSiteCounter = None, subsample_mode: Literal['random', 'probabilistic'] = 'probabilistic', polarize_probabilistically: bool = False ): """""" Initialize the parser. :param vcf: The path to the VCF file, can be gzipped or a URL. :param gff: The path to the GFF file, possibly gzipped or a URL. This file is optional and depends on the stratifications, annotations and filtrations that are used. :param fasta: The path to the FASTA file, possibly gzipped or a URL. This file is optional and depends on the annotations and filtrations that are used. :param n: The size of the resulting SFS. We down-sample to this number by drawing without replacement from the set of all available genotypes per site. Sites with fewer than ``n`` genotypes are skipped. :param info_ancestral: The tag in the INFO field that contains ancestral allele information. Consider using an ancestral allele annotation if this information is not available yet. :param skip_non_polarized: Whether to skip poly-morphic sites that are not polarized, i.e., without a valid info tag providing the ancestral allele. If ``False``, we use the reference allele as ancestral allele (only recommended if working with folded spectra). :param stratifications: List of stratifications to use. :param annotations: List of annotations to use. :param filtrations: List of filtrations to use. By default, we use :class:`~fastdfe.filtration.PolyAllelicFiltration`. :param include_samples: List of sample names to consider when determining the SFS. If ``None``, all samples are used. Note that this restriction does not apply to the annotations and filtrations. :param exclude_samples: List of sample names to exclude when determining the SFS. If ``None``, no samples are excluded. Note that this restriction does not apply to the annotations and filtrations. :param max_sites: Maximum number of sites to parse from the VCF file. :param seed: Seed for the random number generator. Use ``None`` for no seed. :param cache: Whether to cache files downloaded from URLs. :param aliases: Dictionary of aliases for the contigs in the VCF file, e.g. ``{'chr1': ['1']}``. This is used to match the contig names in the VCF file with the contig names in the FASTA file and GFF file. :param target_site_counter: The target site counter. If ``None``, we do not sample target sites. :param subsample_mode: The subsampling mode. For ``random``, we draw once without replacement from the set of all available genotypes per site. For ``probabilistic``, we add up the hypergeometric distribution for all sites. This will produce a smoother SFS, especially when a small number of sites is considered. :param polarize_probabilistically: Whether to probabilistically polarize sites. In addition to the ``AA`` tag (see ``info_ancestral``), we use the ``AA_prob`` tag (see ``info_ancestral_prob``) to polarize sites probabilistically. For example, if the ancestral allele is ``A`` with a probability of 0.8 and the derived allele is ``G``, we assign 0.8 probability mass to the ancestral allele and 0.2 to the derived allele. This should enhance accuracy, especially for small datasets. Whenever the ancestral probability tag is not present, we assume a probability of 1 for the ancestral allele. """""" MultiHandler.__init__( self, vcf=vcf, gff=gff, fasta=fasta, info_ancestral=info_ancestral, max_sites=max_sites, seed=seed, cache=cache, aliases=aliases ) # warn if SynonymyAnnotation is used if any(isinstance(a, SynonymyAnnotation) for a in annotations): logger.warning(""SynonymyAnnotation is not recommended to be used with the parser as "" ""it is not possible to determine the synonymy of monomorphic sites. "" ""Consider using DegeneracyAnnotation instead."") #: The target site counter self.target_site_counter: TargetSiteCounter | None = target_site_counter #: The number of individuals in the sample self.n: int = int(n) #: The list of samples to include self.include_samples: List[str] | None = include_samples #: The list of samples to exclude self.exclude_samples: List[str] | None = exclude_samples #: The mask of samples to use self._samples_mask: np.ndarray | None = None #: Whether to skip sites that are not polarized, i.e., without a valid info tag providing the ancestral allele self.skip_non_polarized: bool = skip_non_polarized #: List of stratifications to use self.stratifications: List[Stratification] = stratifications #: List of annotations to use self.annotations: List[Annotation] = annotations #: List of filtrations to use self.filtrations: List[Filtration] = [PolyAllelicFiltration()] if filtrations is None else filtrations #: The number of sites that were skipped for various reasons self.n_skipped: int = 0 # The number of sites with a valid ancestral allele probability self.n_aa_prob: int = 0 #: The number of sites that were skipped because they had no valid ancestral allele self.n_no_ancestral: int = 0 #: Dictionary of SFS indexed by joint type self.sfs: Dict[str, np.ndarray] = defaultdict(lambda: np.zeros(self.n + 1)) #: 1-based positions of lowest and highest site position per contig (only when target_site_counter is used) # noinspection PyTypeChecker self._contig_bounds: Dict[str, Tuple[int, int]] = defaultdict(lambda: (np.inf, -np.inf)) if subsample_mode not in ['random', 'probabilistic']: raise ValueError(f""Subsampling mode '{subsample_mode}' is not valid. "" f""Valid modes are 'random' and 'probabilistic'."") #: The subsampling mode self.subsample_mode: Literal['random', 'probabilistic'] = subsample_mode #: The tag in the INFO field that contains the ancestral allele probability self.info_ancestral_prob: str = info_ancestral_prob #: Whether to probabilistically polarize sites self.polarize_probabilistically: bool = polarize_probabilistically def _get_ancestral(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: """""" Determine the ancestral allele. :param variant: The vcf site :return: Ancestral allele :raises NoTypeException: If the site is not polarized and ``skip_non_polarized`` is ``True`` or if the ancestral allele or reference allele (in case of monomorphic sites) is not a valid base. """""" if variant.is_snp: # obtain ancestral allele aa = variant.INFO.get(self.info_ancestral) # return the ancestral allele if it is a valid base if aa in bases: return aa # if we skip non-polarized sites, we raise an error here if self.skip_non_polarized: raise NoTypeException(""No valid AA tag found"") # if we don't skip non-polarized sites, or if the site is not an SNP # we return the reference allele if valid if variant.REF in bases: return variant.REF # if the reference allele is not a valid base, we raise an error raise NoTypeException(""Reference allele is not a valid base"") def _get_ancestral_prob(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> float: """""" Determine the ancestral allele probabilistically. :param variant: The vcf site :return: The probability of the ancestral allele being the true ancestral allele """""" if variant.is_snp and self.polarize_probabilistically and variant.INFO.get( self.info_ancestral_prob) is not None: self.n_aa_prob += 1 return variant.INFO[self.info_ancestral_prob] return 1.0 def _parse_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Parse a single site. :param variant: The variant. :return: Whether the site was included in the SFS. """""" # check `is_snp` property for performance reasons but site may still be monomorphic if variant.is_snp: # obtain called bases genotypes = get_called_bases(variant.gt_bases[self._samples_mask]) # number of samples n_samples = len(genotypes) # skip if not enough samples if n_samples < self.n: self._logger.debug(f'Skipping site due to too few samples at {variant.CHROM}:{variant.POS}.') return False try: # determine ancestral allele aa = self._get_ancestral(variant) except NoTypeException: self.n_no_ancestral += 1 return False # determine ancestral allele probability aa_prob = self._get_ancestral_prob(variant) # count called bases counter = Counter(genotypes) # determine ancestral allele count n_aa = counter[aa] if len(counter) > 2: self._logger.debug(f'Site has more than two alleles at {variant.CHROM}:{variant.POS} ({dict(counter)})') return False # determine down-projected allele count. if self.subsample_mode == 'random': m = np.zeros(self.n + 1) k = hypergeom.rvs(M=n_samples, n=n_samples - n_aa, N=self.n, random_state=self.rng) m[k] += aa_prob m[self.n - k] += 1 - aa_prob else: # subsample probabilistically drawing from the hypergeometric distribution (without replacement) m = hypergeom.pmf(k=range(self.n + 1), M=n_samples, n=n_samples - n_aa, N=self.n) # polarize probabilistically if site is bi-allelic if len(counter) == 2: m = aa_prob * m + (1 - aa_prob) * m[::-1] # if we have a mono-allelic SNPs elif is_monomorphic_snp(variant): # if we don't have an SNP, we assume the reference allele to be the ancestral allele, # so the derived allele count is 0 # The polarization of monomorphic sites is not important for DFE inference with fastDFE, in any case m = np.zeros(self.n + 1) m[0] = 1 else: # skip other types of sites self._logger.debug(f'Site is not a valid single nucleotide site at {variant.CHROM}:{variant.POS}.') return False # try to obtain type try: # create joint type t = '.'.join([s.get_type(variant) for s in self.stratifications]) or 'all' # add mass self.sfs[t] += m except NoTypeException as e: self._logger.debug(e) return False return True def _process_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: """""" Handle a single variant. :param variant: The variant :return: Whether the site was included in the SFS. """""" # filter the variant for filtration in self.filtrations: if not filtration.filter_site(variant): return False # apply annotations for annotation in self.annotations: annotation.annotate_site(variant) # parse site return self._parse_site(variant) def _rewind(self): """""" Rewind the filtrations, annotations and stratifications, and fasta handler. """""" FASTAHandler._rewind(self) for f in self.filtrations: f._rewind() for a in self.annotations: a._rewind() for s in self.stratifications: s._rewind() def _setup(self): """""" Set up the parser. """""" # set up target site counter if self.target_site_counter is not None: self.target_site_counter._setup(self) # make parser available to stratifications for s in self.stratifications: s._setup(self) # create a string representation of the stratifications representation = '.'.join(['[' + ', '.join(s.get_types()) + ']' for s in self.stratifications]) or ""[all]"" # log the stratifications self._logger.info(f'Using stratification: {representation}.') # prepare samples mask self._prepare_samples_mask() # setup annotations for annotation in self.annotations: annotation._setup(self) # setup filtrations for f in self.filtrations: f._setup(self) def _prepare_samples_mask(self): """""" Prepare the samples mask. """""" # determine samples to include if self.include_samples is None: mask = np.ones(len(self._reader.samples)).astype(bool) else: mask = np.isin(self._reader.samples, self.include_samples) # determine samples to exclude if self.exclude_samples is not None: mask &= ~np.isin(self._reader.samples, self.exclude_samples) self._samples_mask = mask def _teardown(self): """""" Tear down parser components. """""" # tear down all objects for f in self.filtrations: f._teardown() for s in self.stratifications: s._teardown() for a in self.annotations: a._teardown() def parse(self) -> Spectra: """""" Parse the VCF file. :return: The spectra for the different stratifications """""" # set up parser self._setup() pbar = self.get_pbar( total=self.n_sites, desc=f""{self.__class__.__name__}>Processing sites"" ) # iterate over variants for i, variant in enumerate(self._reader): # handle site if self._process_site(variant): if self.target_site_counter is not None: # update bounds low, high = self._contig_bounds[variant.CHROM] self._contig_bounds[variant.CHROM] = (min(low, variant.POS), max(high, variant.POS)) else: self.n_skipped += 1 # update progress bar pbar.update() # explicitly stopping after ``n`` sites fixes a bug with cyvcf2: # 'error parsing variant with `htslib::bcf_read` error-code: 0 and ret: -2' if i + 1 == self.n_sites or i + 1 == self.max_sites: break # close progress bar pbar.close() # tear down components self._teardown() # inform about number of sites without ancestral tag if self.n_no_ancestral > 0: self._logger.info(f'Skipped {self.n_no_ancestral} sites without ancestral allele information.') if len(self.sfs) == 0: self._logger.warning(f""No sites were included in the spectra. If this is not expected, "" ""please check that all components work as expected. You can also "" ""set the log level to DEBUG."") # warn that sites might not be polarized if self.skip_non_polarized and not any(isinstance(a, AncestralAlleleAnnotation) for a in self.annotations): self._logger.warning(""Your variants might not be polarized and are thus not included in the spectra. "" ""If this is the case, consider annotating the ancestral states or setting "" ""'Parser.skip_non_polarized' to False."") else: n_included = self.n_sites - self.n_skipped self._logger.info(f'Included {n_included} out of {self.n_sites} sites in total from the VCF file.') if self.polarize_probabilistically: self._logger.info(f'Considered {self.n_aa_prob} sites with valid ancestral allele probability.') # close VCF reader VCFHandler._rewind(self) # count target sites if self.target_site_counter is not None and self.n_skipped < self.n_sites: # count target sites self.target_site_counter.count() # update target sites self.sfs = self.target_site_counter._update_target_sites(Spectra(dict(self.sfs))).to_dict() return Spectra(dict(self.sfs)).sort_types() ","Python" "Allele","Sendrowski/fastDFE","fastdfe/utils.py",".py","1264","57",""""""" Utilities for fastDFE. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2025-12-19"" from abc import ABC from typing_extensions import Self import jsonpickle class Serializable(ABC): """""" Mixin class for serializable objects. """""" def to_json(self) -> str: """""" Serialize object. :return: JSON string """""" return jsonpickle.encode(self, indent=4, warn=True) def to_file(self, file: str): """""" Save object to file. :param file: File to save to """""" with open(file, 'w') as fh: fh.write(self.to_json()) @classmethod def from_json(cls, json: str, classes=None) -> Self: """""" Unserialize object. :param classes: Classes to be used for unserialization :param json: JSON string """""" return jsonpickle.decode(json, classes=classes) @classmethod def from_file(cls, file: str, classes=None) -> Self: """""" Load object from file. :param classes: Classes to be used for unserialization. :param file: File to load from """""" with open(file, 'r') as fh: return cls.from_json(fh.read(), classes) ","Python" "Allele","Sendrowski/fastDFE","fastdfe/parametrization.py",".py","40992","1193",""""""" DFE parametrizations. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" import logging import warnings from abc import abstractmethod, ABC from functools import wraps from typing import Callable, List, Union, Dict, Tuple, Literal, Sequence, Optional import numpy as np import pandas as pd from scipy.stats import gamma, expon from fastdfe.utils import Serializable # get logger logger = logging.getLogger('fastdfe') def _from_string(model: Union['Parametrization', str]) -> 'Parametrization': """""" Return Parametrization from class name string. :param model: Class name string or parametrization object :return: Parametrization object """""" if isinstance(model, Parametrization): return model if isinstance(model, str): return globals()[model]() raise ValueError(f'Unknown parametrization: {model}') def _to_string(model: Union['Parametrization', str]) -> str: """""" Return class name string from Parametrization. :param model: Class name string or Parametrization object :return: Class name string """""" if isinstance(model, Parametrization): return model.__class__.__name__ return model class Parametrization(Serializable, ABC): """""" Base class for DFE parametrizations. Note that :func:`get_pdf` is not required to be implemented, provided that the linearized mode of fastDFE is used (which is highly recommended). """""" #: Default initial parameters x0: Dict[str, float] = {} #: Default parameter bounds bounds: Dict[str, Tuple[float, float]] = {} #: Scales over which to optimize the parameters, either 'log' or 'lin' scales: Dict[str, Literal['lin', 'log']] = {} #: The kind of submodels supported by holding some parameters fixed submodels: Dict[str, Dict[str, float]] = dict( full=dict(), dele=dict() ) def __init__( self, bounds: Optional[Dict[str, Tuple[float, float]]] = None, scales: Optional[Dict[str, Literal['lin', 'log']]] = None, x0: Optional[Dict[str, float]] = None ): """""" Initialize parametrization. :param bounds: Custom parameter bounds merging with defaults :param scales: Custom scales merging with defaults :param x0: Custom initial parameters merging with defaults """""" self._logger = logger.getChild(self.__class__.__name__) # merge custom settings if bounds is not None: self.bounds = self.bounds | bounds if scales is not None: self.scales = self.scales | scales if x0 is not None: self.x0 = self.x0 | x0 #: argument names self.param_names: List = list(self.x0.keys()) @staticmethod def _accepts_scalars(func: Callable) -> Callable[[np.ndarray | float], np.ndarray | float]: """""" Make func accept scalar values. :return: Function that accepts scalars """""" @wraps(func) def wrapper(S: np.ndarray, *args, **kwargs) -> np.ndarray: """""" Wrapper function. :param S: Array of selection coefficients :param args: Positional arguments :param kwargs: Keyword arguments :return: Output of func """""" if isinstance(S, (int, float)): return func(np.array([S]), *args, **kwargs)[0] else: return func(S, *args, **kwargs) return wrapper @abstractmethod def get_pdf(self, **kwargs) -> Callable[[np.ndarray], np.ndarray]: """""" Get probability distribution function of DFE. :return: Function that accepts an array of selection coefficients and returns their probability density """""" pass @abstractmethod def get_cdf(self, **kwargs) -> Callable[[np.ndarray], np.ndarray]: """""" Get probability distribution function of DFE. :return: Function that accepts an array of selection coefficients and returns their cumulative probability """""" pass def _discretize( self, params, bins: np.ndarray, warn_mass: bool = True ) -> np.ndarray: """""" Discretize by using the CDF. :param params: Parameters of the parametrization :param bins: Bins to use for discretization :param warn_mass: Whether to warn if the total mass is not near 1. :return: Histogram """""" x = self.get_cdf(**params)(bins) # issue warning if values at bounds are outside [0, 1] if warn_mass and (not -1e-5 < x[0] < 1e-5 or not 1 - 1e-5 < x[-1] < 1 + 1e-5): self._logger.warning(f'CDF evaluates to {(x[0], x[-1])} at the lower and upper ' f'bounds, which is a bit off from the expected (0, 1). ' f'Used parameters: {params}.') # compute histogram hist = x[1:] - x[:-1] return hist def _normalize(self, params: dict) -> dict: """""" Normalize parameters. :param params: Parameters of the parametrization :return: Normalized parameters """""" # do nothing by default return params def plot( self, params: dict, intervals: Sequence = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), file: str = None, show: bool = True, title: str = 'discretized DFE', ax: 'plt.Axes' = None ) -> 'plt.Axes': """""" Plot the discretized DFE. :param params: Parameters of the parametrization :param intervals: Intervals to use for discretization. :param file: File to save the plot to. :param show: Whether to show the plot. :param title: Title of the plot. :param ax: Axes to use for the plot. :return: Axes """""" from .visualization import Visualization values = self._discretize(params, np.array(intervals), warn_mass=False) # check for nan values if np.isnan(values).any(): self._logger.warning(f'NaN values in discretized DFE. Are the parameters valid?') return Visualization.plot_discretized( values=[values], file=file, show=show, intervals=np.array(intervals), title=title, ax=ax ) def freeze( self, params: Dict[str, float] ) -> 'DFE': """""" Freeze parameters to create a DFE object. :param params: Parameters of the parametrization :return: DFE object """""" return DFE(model=self, params=params) class GammaExpParametrization(Parametrization): r"""""" Parametrization for mixture of a gamma and exponential distribution. This corresponds to model C in polyDFE. We have the following probability density function: .. math:: \phi(S; S_d, b, p_b, S_b) = (1 - p_b) f_\Gamma(-S; S_d, b) \cdot \mathbf{1}_{\{S < 0\}} + p_b f_e(S; S_b) \cdot \mathbf{1}_{\{S \geq 0\}} where: * :math:`S_d` is the mean of the DFE for :math:`S < 0` * :math:`b` is the shape of the gamma distribution * :math:`p_b` is the probability that :math:`S \geq 0` * :math:`S_b` is the mean of the DFE for :math:`S \geq 0` * :math:`f_\Gamma(x; m, b)` is the density of the gamma distribution with mean :math:`m` and shape :math:`b` * :math:`f_e(x; m)` is the density of the Exponential distribution with mean :math:`m` * :math:`\mathbf{1}_{\{A\}}` denotes the indicator function, which is 1 if :math:`A` is true, and 0 otherwise. The DFE has often been observed to be multi-modal for negative selection coefficients. A gamma distribution provides a good amount of flexibility to accommodate this. Note that all :math:`S` parameters are population-scaled selection coefficients, i.e. :math:`S = 4N_es`. """""" #: Default initial parameters x0: Dict[str, float] = dict( S_d=-1000, b=0.4, p_b=0.05, S_b=1 ) #: Default parameter bounds, using non-zero lower bounds for S_d and S_b due to log-scaled scales bounds: Dict[str, Tuple[float, float]] = dict( S_d=(-1e5, -1e-2), b=(0.01, 10), p_b=(0, 0.5), S_b=(1e-4, 100) ) #: Scales over which to optimize the parameters scales: Dict[str, Literal['lin', 'log']] = dict( S_d='log', b='log', p_b='lin', S_b='log' ) #: The kind of submodels supported by holding some parameters fixed submodels: Dict[str, Dict[str, float]] = dict( full=dict(), dele=dict( p_b=0, S_b=1 ) ) @staticmethod def get_pdf(S_d: float, b: float, p_b: float, S_b: float, **kwargs) -> Callable[[np.ndarray], np.ndarray]: """""" Get PDF. :param S_d: Mean selection coefficient for deleterious mutations :param b: Shape parameter for gamma distribution :param p_b: Probability of a beneficial mutation :param S_b: Mean selection coefficient for beneficial mutations :return: Function that accepts an array of selection coefficients and returns their probability density """""" @Parametrization._accepts_scalars def pdf(S: np.ndarray) -> np.ndarray: """""" The PDF. :param S: Selection coefficients :return: Probability density """""" x = np.zeros_like(S, dtype=float) # The gamma distribution may approach infinity as S -> 0 # so in order to evaluate this function at s = 0, # we use--unlike polyDFE--the exponential mixture # distribution at this point. negative = S < 0 # positive S x[negative] = (1 - p_b) * gamma.pdf(-S[negative], b, scale=-S_d / b) # Allow for S_b == 0 when p_b == 0 as well # which would produce an error otherwise. if S_b == 0 and p_b == 0: x[~negative] = 0 else: # non-negative S x[~negative] = p_b * expon.pdf(S[~negative], scale=S_b) return x return pdf @staticmethod def get_cdf(S_d: float, b: float, p_b: float, S_b: float, **kwargs) -> Callable[[np.ndarray], np.ndarray]: """""" Get CDF. :param S_d: Mean selection coefficient for deleterious mutations :param b: Shape parameter for gamma distribution :param p_b: Probability of a beneficial mutation :param S_b: Mean selection coefficient for beneficial mutations :return: Function that accepts an array of selection coefficients and returns their cumulative probability """""" @Parametrization._accepts_scalars def cdf(S: np.ndarray) -> np.ndarray: """""" The CDF. :param S: Selection coefficients :return: Cumulative probability """""" x = np.zeros_like(S, dtype=float) negative = S < 0 # positive S x[negative] = (1 - p_b) - ((1 - p_b) * gamma.cdf(-S[negative], b, scale=-S_d / b)) # Allow for S_b = 0 when p_b = 0 as well # which would produce an error otherwise. if S_b == 0 and p_b == 0: x[~negative] = 1 else: # non-negative S x[~negative] = (1 - p_b) + p_b * expon.cdf(S[~negative], scale=S_b) return x return cdf class DisplacedGammaParametrization(Parametrization): r"""""" Parametrization for a reflected displaced gamma distribution. We have the following probability density function: .. math:: \phi(S; \hat{S}, b, S_{max}) = f_\Gamma(S_{max} - S; S_{max} - \hat{S}, b) \cdot \mathbf{1}_{\{S \leq S_{max}\}} where: * :math:`\hat{S}` is the mean of the DFE * :math:`b` is the shape of the gamma distribution * :math:`S_{max}` is the maximum value that :math:`S` can take * :math:`f_\Gamma(x; m, b)` is the density of the gamma distribution with mean :math:`m` and shape :math:`b` * :math:`\mathbf{1}_{\{A\}}` denotes the indicator function, which is 1 if :math:`A` is true, and 0 otherwise. This parametrization uses a single gamma distribution for both positive and negative selection coefficients. This is a less flexible parametrization, which may produce results similar to the other models while requiring fewer parameters. Note that all :math:`S` parameters are population-scaled selection coefficients, i.e. :math:`S = 4N_es`. .. warning:: This model does not allow for a purely deleterious sub-parametrization, so :meth:`Inference.compare_nested_models` won't work as expected. """""" #: Default initial parameters x0: Dict[str, float] = dict( S_mean=-100, b=1, S_max=1 ) #: Default parameter bounds bounds: Dict[str, Tuple[float, float]] = dict( S_mean=(-100000, -0.01), b=(0.01, 10), S_max=(0.001, 100) ) #: Scales over which to optimize the parameters scales: Dict[str, Literal['lin', 'log']] = dict( S_mean='log', b='lin', S_max='log' ) #: The kind of submodels supported by holding some parameters fixed submodels: Dict[str, Dict[str, float]] = dict( full=dict(), dele=dict() ) @staticmethod def get_pdf(S_mean: float, b: float, S_max: float, **kwargs) -> Callable[[np.ndarray], np.ndarray]: """""" Get PDF. :return: Function that accepts an array of selection coefficients and returns their probability density """""" @Parametrization._accepts_scalars def pdf(S: np.ndarray) -> np.ndarray: """""" The PDF. :param S: Selection coefficients :return: Probability density """""" x = np.zeros_like(S, dtype=float) # calculate the probability density for S <= S_max is_lower = S <= S_max x[is_lower] = gamma.pdf(S_max - S[is_lower], b, scale=max(S_max - S_mean, 1e-16) / b) return x return pdf @staticmethod def get_cdf(S_mean: float, b: float, S_max: float, **kwargs) -> Callable[[np.ndarray], np.ndarray]: """""" Get CDF. :return: Function that accepts an array of selection coefficients and returns their cumulative probability """""" @Parametrization._accepts_scalars def cdf(S: np.ndarray) -> np.ndarray: """""" The CDF. :param S: Selection coefficients :return: Cumulative probability """""" x = np.zeros_like(S, dtype=float) # calculate the cumulative probability for S <= S_max is_lower = S <= S_max x[is_lower] = 1 - gamma.cdf(S_max - S[is_lower], b, scale=max(S_max - S_mean, 1e-16) / b) # set the cumulative probability to 1 for S > S_max x[~is_lower] = 1 return x return cdf class GammaDiscreteParametrization(Parametrization): r"""""" Parametrization for a mixture of a gamma and discrete distribution. This corresponds to polyDFE's model B. We have the following probability density function: .. math:: \phi(S; S_d, b, p_b, S_b) = (1 - p_b) f_{\Gamma}(S; S_d, b) \cdot \mathbf{1}_{\{S < 0\}} + p_b \cdot S_b \cdot \mathbf{1}_{\{0 \leq S \leq 1 / S_b\}} where: * :math:`S_d` is the mean of the DFE for :math:`S < 0` * :math:`b` is the shape of the gamma distribution * :math:`p_b` is the probability that :math:`S \geq 0` * :math:`S_b` is the shared selection coefficient of all positively selected mutations up to :math:`1/S_b` * :math:`f_\Gamma(x; m, b)` is the density of the gamma distribution with mean :math:`m` and shape :math:`b` This parametrization is similar to :class:`GammaExpParametrization`, but uses a constant mass for positive selection coefficients. The results should be rather similar in most cases. Note that all :math:`S` parameters are population-scaled selection coefficients, i.e. :math:`S = 4N_es`. """""" #: Default initial parameters x0: Dict[str, float] = dict( S_d=-1000, b=0.4, p_b=0.05, S_b=1 ) #: default parameter bounds bounds: Dict[str, Tuple[float, float]] = dict( S_d=(-1e5, -1e-2), b=(0.01, 10), p_b=(0, 0.5), S_b=(1e-4, 100) ) #: scales over which to optimize the parameters scales: Dict[str, Literal['lin', 'log']] = dict( S_d='log', b='log', p_b='lin', S_b='log' ) #: The kind of submodels supported by holding some parameters fixed submodels: Dict[str, Dict[str, float]] = dict( full=dict(), dele=dict( p_b=0, S_b=1 ) ) @staticmethod def get_pdf(S_d: float, b: float, p_b: float, S_b: float, **kwargs) -> Callable[[np.ndarray], np.ndarray]: """""" Get PDF. :param S_d: Mean of the DFE for S < 0 :param b: Shape of the gamma distribution :param p_b: Probability that S > 0 :param S_b: Shared selection coefficient of all positively selected mutations up to S_b :return: Function that accepts an array of selection coefficients and returns their probability density """""" @Parametrization._accepts_scalars def pdf(S: np.ndarray) -> np.ndarray: """""" The PDF. :param S: Selection coefficients :return: Probability density """""" x = np.zeros_like(S, dtype=float) negative = S < 0 x[negative] = (1 - p_b) * gamma.pdf(-S[negative], b, scale=-S_d / b) equal_to_S_b = (0 <= S) & (S <= 1 / S_b) x[equal_to_S_b] = p_b * S_b # the density is 0 for all other cases, no need to explicitly set it return x return pdf @staticmethod def get_cdf(S_d: float, b: float, p_b: float, S_b: float, **kwargs) -> Callable[[np.ndarray], np.ndarray]: """""" Get CDF. :param S_d: Mean of the DFE for S < 0 :param b: Shape of the gamma distribution :param p_b: Probability that S > 0 :param S_b: Shared selection coefficient of all positively selected mutations up to S_b :return: Function that accepts an array of selection coefficients and returns their cumulative probability """""" @Parametrization._accepts_scalars def cdf(S: np.ndarray) -> np.ndarray: """""" The CDF. :param S: Selection coefficients :return: Cumulative probability """""" x = np.zeros_like(S, dtype=float) negative = S < 0 x[negative] = (1 - p_b) - ((1 - p_b) * gamma.cdf(-S[negative], b, scale=-S_d / b)) within_S_b = (0 <= S) & (S <= 1 / S_b) x[within_S_b] = (1 - p_b) + p_b * S_b * S[within_S_b] greater_than_S_b = S > 1 / S_b x[greater_than_S_b] = 1 return x return cdf class DiscreteParametrization(Parametrization): r"""""" Parametrization for a discrete distribution. This corresponds to polyDFE's model D. By default we use 6 bins, but this can be changed by passing a different array to the constructor. The resulting parameter names are :math:`S_1, S_2, \dots, S_k`, where :math:`k` is the number of bins. That is, the probability density function is given by: :math:`\phi(S; S_1, S_2, \dots, S_k) = \sum_{i=1}^{k} S_i/c_i \cdot \mathbf{1}_{\{S \in B_i\}}` such that :math:`\sum_{i=1}^{k} S_i = 1,` where :math:`B_i` and :math:`c_i` are interval :math:`i` and the width of interval :math:`i`, respectively. This parametrization has the advantage of not imposing a shape on the DFE. For a reasonably fine parametrization, the number of parameters is larger than those of the other models, however. We generally also observe larger confidence intervals for this parametrization, and the optimization procedure may well be less efficient as we have to re-normalize the parameters to make sure they sum up to 1. Note that all :math:`S` parameters are population-scaled selection coefficients, i.e. :math:`S = 4N_es`. """""" def __init__( self, intervals: Sequence = np.array([-100000, -100, -10, -1, 0, 1, 1000]), bounds: Optional[Dict[str, Tuple[float, float]]] = None, scales: Optional[Dict[str, Literal['lin', 'log']]] = None, x0: Optional[Dict[str, float]] = None ): """""" Constructor. :param intervals: The intervals of the discrete distribution. :param bounds: Custom parameter bounds merging with defaults :param scales: Custom scales merging with defaults :param x0: Custom initial parameters merging with defaults """""" super().__init__() # deprecation warning self._logger.warning( 'DiscreteParametrization is deprecated. Use DiscreteFractionalParametrization instead, which ' 'has better optimization properties.' ) #: Intervals self.intervals: np.ndarray = np.concatenate(([-np.inf], intervals, [np.inf])) #: Interval sizes self.interval_sizes: np.ndarray = self.intervals[1:] - self.intervals[:-1] #: Number of intervals, including the two infinite ones self.k: int = self.intervals.shape[0] - 1 #: All parameter names, including the fixed ones self.params: np.ndarray = np.array([f""S{i}"" for i in range(self.k)]) #: Parameter names that are not fixed self.param_names: List[str] = self.params[1:-1].tolist() #: Fixed parameters self.fixed_params: Dict[str, int] = {self.params[0]: 0, self.params[-1]: 0} #: Default initial parameters self.x0: Dict[str, float] = dict((p, 1 / (self.k - 2)) for p in self.param_names) | (x0 or {}) #: Default parameter bounds self.bounds: Dict[str, Tuple[float, float]] = dict((p, (0, 1)) for p in self.param_names) | (bounds or {}) #: Scales # noinspection all self.scales: Dict[str, Literal['lin', 'log']] = dict((p, 'lin') for p in self.param_names) | (scales or {}) #: Submodels self.submodels: Dict[str, Dict[str, float]] = dict( full=dict(), dele=dict((p, 0) for p in self.params[1:-1][self.intervals[1:-2] >= 0]) ) def _normalize(self, params: dict) -> dict: """""" Add params for boundaries and normalize so that the parameters sum up to 1. :param params: Parameter values :return: Dict of normalized values plus remaining parameters """""" # make sure we only include parameter used for this parametrization filtered = dict((k, v) for k, v in params.items() if k in self.param_names) # sum up s = np.sum(list(filtered.values())) # normalize and include remaining parameters return params | dict((k, v / s) for k, v in filtered.items()) def get_pdf(self, **kwargs) -> Callable[[np.ndarray], np.ndarray]: """""" Get PDF. :param kwargs: Parameter values S1, S2, ..., Sk :return: Function that computes the PDF for given S values """""" # normalize and add boundary parameters values = self._normalize(kwargs) | self.fixed_params @Parametrization._accepts_scalars def pdf(S: np.ndarray) -> np.ndarray: """""" The PDF. :param S: Selection coefficients :return: Probability density """""" x = np.zeros_like(S, dtype=float) # iterate over parameters and assign values for i, p in enumerate(self.params): x[(self.intervals[i] < S) & (S <= self.intervals[i + 1])] = values[p] / self.interval_sizes[i] return x return pdf def get_cdf(self, **kwargs) -> Callable[[np.ndarray], np.ndarray]: """""" Get CDF. :param kwargs: Parameter values S1, S2, ..., Sk :return: Function that computes the CDF for given S values """""" # normalize and add boundary parameters values = self._normalize(kwargs) | self.fixed_params # convert to numpy arrays intervals = np.array(self.intervals) interval_sizes = np.array(self.interval_sizes) # convert to ordered array values vals = np.array([values[self.params[i]] for i in range(self.k)]) @Parametrization._accepts_scalars def cdf(S: np.ndarray) -> np.ndarray: """""" The CDF. :param S: Selection coefficients :return: Cumulative probability """""" # iterate over parameters and assign values cum = np.cumsum([values[self.params[i]] for i in range(self.k)]) # obtain bin indices i = np.sum(self.intervals[:, None] <= S[None, :], axis=0) - 1 # make sure we don't go out of bounds which can happen if S is np.inf i[i >= self.k] = self.k - 1 # cumulative probability up to previous bin cum_prev = cum[np.maximum(i - 1, np.zeros_like(S, dtype=int))] with warnings.catch_warnings(): warnings.simplefilter(""ignore"", RuntimeWarning) # probability in current bin cum_within = np.abs(intervals[i] - S) / interval_sizes[i] * vals[i] cum_within[np.isnan(cum_within)] = 0 # return cumulative probability return cum_prev + cum_within return cdf class DiscreteFractionalParametrization(Parametrization): r"""""" Same model as :class:`DiscreteParametrization`, but re-parametrized by :math:`\hat{S}_1, \hat{S}_2, \dots, \hat{S}_{k-1}`, so that the mass in the ith interval :math:`S_i` is determined by the sum of masses to the left, i.e. :math:`S_i = \hat{S}_i \sum_{j= 0]) ) def to_nominal(self, params: Dict[str, float]) -> Dict[str, float]: """""" Convert representation of fraction of total mass to the left to representation of fractions which sum to 1. :param params: Parameter values S1, S2, ..., Sk :return: Converted parameters """""" # converted parameters converted = params.copy() # cumulative sum up to the previous parameter mass = 0 # take mass of current bin to be fraction of mass assigned to the previous bins for p in self.params[1:-2]: converted[p] = params[p] * (1 - mass) mass += converted[p] # assign remaining mass to last bin converted[self.params[-2]] = 1 - mass return converted def to_fractional(self, params: Dict[str, float]) -> Dict[str, float]: """""" Invert the to_nominal operation: Convert representation of fractions which sum to 1 back to representation of fraction of total mass to the left. :param params: Converted parameters (nominal space) :return: Original parameters (parameter space) """""" # converted parameters converted = params.copy() # cumulative sum up to the previous parameter mass = 0 # Iterate over parameters for p in self.params[1:-2]: # Calculate original parameter value converted[p] = params[p] / (1 - mass) # update cumulative sum mass += params[p] # last parameter is simply what's left converted[self.params[-2]] = 1 - mass return converted def get_pdf(self, **kwargs) -> Callable[[np.ndarray], np.ndarray]: """""" Get PDF. :param kwargs: Parameter values S1, S2, ..., Sk-1 :return: Function that computes the PDF for given S values """""" # normalize and add boundary parameters values = self.to_nominal(kwargs | self.fixed_params) @Parametrization._accepts_scalars def pdf(S: np.ndarray) -> np.ndarray: """""" The PDF. :param S: Selection coefficients :return: Probability density """""" x = np.zeros_like(S, dtype=float) # iterate over parameters and assign values for i, p in enumerate(self.params): x[(self.intervals[i] < S) & (S <= self.intervals[i + 1])] = values[p] / self.interval_sizes[i] return x return pdf def get_cdf(self, **kwargs) -> Callable[[np.ndarray], np.ndarray]: """""" Get CDF. :param kwargs: Parameter values S1, S2, ..., Sk-1 :return: Function that computes the CDF for given S values """""" # normalize and add boundary parameters values = self.to_nominal(kwargs | self.fixed_params) # convert to numpy arrays intervals = np.array(self.intervals) interval_sizes = np.array(self.interval_sizes) # convert to ordered array values vals = np.array([values[self.params[i]] for i in range(self.k)]) @Parametrization._accepts_scalars def cdf(S: np.ndarray) -> np.ndarray: """""" The CDF. :param S: Selection coefficients :return: Cumulative probability """""" # iterate over parameters and assign values cum = np.cumsum([values[self.params[i]] for i in range(self.k)]) # obtain bin indices i = np.sum(self.intervals[:, None] <= S[None, :], axis=0) - 1 # make sure we don't go out of bounds which can happen if S is np.inf i[i >= self.k] = self.k - 1 # cumulative probability up into previous bin cum_prev = cum[np.maximum(i - 1, np.zeros_like(S, dtype=int))] with warnings.catch_warnings(): warnings.simplefilter(""ignore"", RuntimeWarning) # probability in current bin cum_within = np.abs(intervals[i] - S) / interval_sizes[i] * vals[i] cum_within[np.isnan(cum_within)] = 0 # return cumulative probability return cum_prev + cum_within return cdf class DFE(Serializable): """""" Frozen parametrization of a DFE. Wraps a :class:`Parametrization` instance together with fixed parameter values. """""" def __init__( self, params: dict, model: Parametrization = None, bootstraps: Optional[pd.DataFrame] = None ): """""" :param params: Frozen parameter values. :param model: Parametrization instance used to generate the DFE. Defaults to :class:`GammaExpParametrization`. :param bootstraps: Optional bootstrap DataFrame (same format as AbstractInference.bootstraps). """""" #: Underlying parametrization model self.model: Parametrization = model or GammaExpParametrization() #: Frozen parameters self.params: Dict[str, float] = params #: Optional bootstrap samples self.bootstraps: Optional[pd.DataFrame] = bootstraps def get_bootstrap_dfes(self) -> List['DFE']: """""" Get DFEs for all bootstrap samples. :return: List of DFE instances for each bootstrap sample. """""" if self.bootstraps is None: return [] dfes = [] for _, row in self.bootstraps.iterrows(): params = row.to_dict() dfes.append(DFE(model=self.model, params=params)) return dfes def pdf(self, S: np.ndarray | float) -> np.ndarray | float: """""" Evaluate the frozen PDF. :param S: Selection coefficient(s) :return: Probability density """""" return self.model.get_pdf(**self.params)(S) def cdf(self, S: np.ndarray | float) -> np.ndarray | float: """""" Evaluate the frozen CDF. :param S: Selection coefficient(s) :return: Cumulative probability """""" return self.model.get_cdf(**self.params)(S) def discretize( self, bins: np.ndarray, warn_mass: bool = True, confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'mean' ) -> Tuple[np.ndarray, Optional[np.ndarray]]: """""" Discretize the DFE with optional bootstrap confidence intervals. :param bins: Intervals to use for discretization. :param warn_mass: Whether to warn if mass is lost during discretization. :param confidence_intervals: Whether to compute confidence intervals. :param ci_level: Confidence interval level (e.g., 0.05 for 95% CI). :param bootstrap_type: Type of bootstrap confidence intervals ('percentile' or 'bca'). :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :return: Center values and (optionally) errors for each bin. """""" from .abstract_inference import Inference # no bootstraps -> plain histogram if not confidence_intervals or self.bootstraps is None: return self.model._discretize(self.params, bins, warn_mass=warn_mass), None return Inference.get_stats_discretized( params=self.params, bootstraps=self.bootstraps, model=self.model, ci_level=ci_level, intervals=bins, bootstrap_type=bootstrap_type, point_estimate=point_estimate )[:2] @staticmethod def plot_many( dfes: Sequence['DFE'], labels: Optional[Sequence[str]] = None, intervals=np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), file=None, show=True, title=""discretized DFE"", ax=None, confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'mean', kwargs_legend: dict = dict(prop=dict(size=8)), ): """""" Plot several DFE instances in a single discretized plot. :param dfes: Sequence of DFE instances to plot. :param labels: Labels for the DFEs. :param intervals: Intervals to use for discretization. :param file: File to save the plot to. :param show: Whether to show the plot. :param title: Title of the plot. :param ax: Axes to use for the plot. :param confidence_intervals: Whether to plot confidence intervals. :param ci_level: Confidence interval level (e.g., 0.05 for 95% CI). :param bootstrap_type: Type of bootstrap confidence intervals ('percentile' or 'bca'). :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :param kwargs_legend: Additional keyword arguments for the legend. :return: Matplotlib Axes object. """""" from .visualization import Visualization intervals = np.array(intervals) values = [] errors = [] for d in dfes: vals, errs = d.discretize( bins=intervals, confidence_intervals=confidence_intervals, ci_level=ci_level, bootstrap_type=bootstrap_type, point_estimate=point_estimate ) values.append(vals) errors.append(errs) return Visualization.plot_discretized( ax=ax, values=values, errors=errors, labels=labels, file=file, show=show, intervals=intervals, title=title, kwargs_legend=kwargs_legend ) def plot( self, intervals=np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), file=None, show=True, title=""discretized DFE"", ax=None, confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'mean', kwargs_legend: dict = dict(prop=dict(size=8)) ): """""" Plot this DFE instance in a discretized plot. :param intervals: Intervals to use for discretization. :param file: File to save the plot to. :param show: Whether to show the plot. :param title: Title of the plot. :param ax: Axes to use for the plot. :param confidence_intervals: Whether to plot confidence intervals. :param ci_level: Confidence interval level (e.g., 0.05 for 95% CI). :param bootstrap_type: Type of bootstrap confidence intervals ('percentile' or 'bca'). :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :param kwargs_legend: Additional keyword arguments for the legend. :return: Matplotlib Axes object. """""" return DFE.plot_many( dfes=[self], intervals=intervals, file=file, show=show, title=title, ax=ax, confidence_intervals=confidence_intervals, ci_level=ci_level, bootstrap_type=bootstrap_type, point_estimate=point_estimate, kwargs_legend=kwargs_legend ) ","Python" "Allele","Sendrowski/fastDFE","fastdfe/config.py",".py","14008","343",""""""" Configuration class. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" import json import logging from typing import List, Literal, Dict, Tuple, Callable import numpy as np import yaml from .discretization import Discretization from .io_handlers import download_if_url from .json_handlers import CustomEncoder from .optimization import Covariate from .optimization import SharedParams, merge_dicts from .parametrization import Parametrization, _from_string, _to_string from .polydfe_utils import create_sfs_config, parse_init_file, create_init_file, models from .spectrum import Spectra, parse_polydfe_sfs_config, Spectrum logger = logging.getLogger('fastdfe').getChild('Config') class Config: """""" Configuration class to be used for :class:`~fastdfe.base_inference.BaseInference` and :class:`~fastdfe.joint_inference.JointInference`. """""" def __init__( self, polydfe_spectra_config: str = None, polydfe_init_file: str = None, polydfe_init_file_id: int = 1, sfs_neut: Spectra | Spectrum = None, sfs_sel: Spectra | Spectrum = None, intervals_del: Tuple[float, float, int] = (-1.0e+8, -1.0e-5, 1000), intervals_ben: Tuple[float, float, int] = (1.0e-5, 1.0e4, 1000), intervals_h: Tuple[float, float, int] = (0.0, 1.0, 21), h_callback: Callable[[np.ndarray], np.ndarray] = None, integration_mode: Literal['midpoint', 'quad'] = 'midpoint', linearized: bool = True, model: Parametrization | str = 'GammaExpParametrization', seed: int = 0, x0: Dict[str, Dict[str, float]] = {}, bounds: Dict[str, Tuple[float, float]] = {}, scales: Dict[str, Literal['lin', 'log', 'symlog']] = {}, loss_type: Literal['likelihood', 'L2'] = 'likelihood', opts_mle: dict = {}, method_mle: str = 'L-BFGS-B', n_runs: int = 10, fixed_params: Dict[str, Dict[str, float]] = None, shared_params: List[SharedParams] = [], covariates: List[Covariate] = [], do_bootstrap: bool = True, n_bootstraps: int = 100, n_bootstrap_retries: int = 2, parallelize: bool = True, **kwargs ): """""" Create config object. :param polydfe_spectra_config: Path to polyDFE SFS config file. :param polydfe_init_file: Path to polyDFE init file. :param polydfe_init_file_id: ID of polyDFE init file. :param sfs_neut: Neutral SFS. Note that we require monomorphic counts to be specified in order to infer the mutation rate. :param sfs_sel: Selected SFS. Note that we require monomorphic counts to be specified in order to infer the mutation rate. :param intervals_del: ``(start, stop, n_interval)`` for deleterious population-scaled selection coefficients. The intervals will be log10-spaced. Decreasing the number of intervals to ``100`` provides nearly identical results while increasing speed, especially when precomputing across dominance coefficients. :param intervals_ben: Same as ``intervals_del`` but for positive selection coefficients. Decreasing the number of intervals to ``100`` provides nearly identical results while increasing speed, especially when precomputing across dominance coefficients. :param intervals_h: ``(start, stop, n_interval)`` for dominance coefficients which are linearly spaced. This is only used when inferring dominance coefficients. Values of ``h`` between the edges will be interpolated linearly. :param h_callback: A function mapping the scalar parameter ``h`` and the array of selection coefficients ``S`` to dominance coefficients of the same shape, allowing models where ``h`` depends on ``S``. The default is ``lambda h, S: np.full_like(S, h)``, keeping ``h`` constant. Expected allele counts for a given dominance value are obtained by linear interpolation between precomputed values in ``intervals_h``. The inferred parameter is still named ``h``, even if transformed by ``h_callback``, and its bounds, scales, and initial values can be set via ``bounds``, ``scales``, and ``x0``. The fitness of heterozygotes and mutation homozygotes is defined as ``1 + 2hs`` and ``1 + 2s``, respectively. :param integration_mode: Integration mode when computing expected SFS under semidominance. ``quad`` is not recommended. :param linearized: Whether to discretize and cache the linearized integral mapping DFE to SFS or use ``scipy.integrate.quad`` in each call. ``False`` not recommended. :param model: Parametrization of the DFE. :param seed: Seed for the random number generator. Use ``None`` for no seed. :param x0: Dictionary of initial values in the form ``{type: {param: value}}`` :param bounds: Bounds for the optimization in the form {param: (lower, upper)} :param scales: Scales for the optimization in the form {param: scale} :param loss_type: Loss function to use. :param opts_mle: Options for the optimization. :param method_mle: Method to use for optimization. See ``scipy.optimize.minimize`` for available methods. :param n_runs: Number of independent optimization runs out of which the best one is chosen. The first run will use the initial values if specified. Consider increasing this number if the optimization does not produce good results. :param fixed_params: Fixed parameters for the optimization. :param shared_params: Shared parameters for the optimization. :param covariates: Covariates for the optimization. :param do_bootstrap: Whether to do bootstrapping automatically. :param n_bootstraps: Number of bootstraps. :param n_bootstrap_retries: Number of optimization runs for each bootstrap sample. This parameter previously defined the number of retries per bootstrap sample when subsequent runs failed, but now it defines the total number of runs per bootstrap sample, taking the most likely one. :param parallelize: Whether to parallelize the optimization. :param kwargs: Additional keyword arguments which are ignored. """""" # save options self.data = dict( model=model, intervals_del=intervals_del, intervals_ben=intervals_ben, intervals_h=intervals_h, h_callback=h_callback, integration_mode=integration_mode, linearized=linearized, seed=seed, opts_mle=opts_mle, method_mle=method_mle, n_runs=n_runs, x0=x0, bounds=bounds, scales=scales, fixed_params=fixed_params, shared_params=shared_params, covariates=covariates, sfs_neut=Spectra.from_spectrum(sfs_neut) if isinstance(sfs_neut, Spectrum) else sfs_neut, sfs_sel=Spectra.from_spectrum(sfs_sel) if isinstance(sfs_sel, Spectrum) else sfs_sel, do_bootstrap=do_bootstrap, n_bootstraps=n_bootstraps, n_bootstrap_retries=n_bootstrap_retries, parallelize=parallelize, loss_type=loss_type ) # parse spectra file if specified if polydfe_spectra_config is not None: self.parse_polydfe_sfs_config(polydfe_spectra_config) # parse init file if specified if polydfe_init_file is not None: self.parse_polydfe_init_file(polydfe_init_file, polydfe_init_file_id) def update(self, **kwargs) -> 'Config': """""" Update config with given data. :param kwargs: Data to update. :return: Updated config. """""" # convert spectrum to spectra objects for key in ['sfs_neut', 'sfs_sel']: if key in kwargs and isinstance(kwargs[key], Spectrum): kwargs[key] = Spectra.from_spectrum(kwargs[key]) self.data |= kwargs return self def parse_polydfe_init_file(self, file: str, id: int = 1, type='all'): """""" Parse polyDFE init file. This will define the initial parameters and which ones will be held fixed during the optimization. :param type: Type of parameters to parse for. :param id: ID of the init file. :param file: Path to the init file. """""" fixed_params, x0 = parse_init_file(_from_string(self.data['model']).param_names, file, id) # merge with existing config self.data['fixed_params'] = merge_dicts( self.data['fixed_params'] if isinstance(self.data['fixed_params'], dict) else {}, dict(all=fixed_params) ) self.data['x0'] |= {type: x0} def create_polydfe_init_file(self, file: str, n: int, type: str = 'all'): """""" Create an init file for polyDFE. :param type: Type to use for the init file. :param n: SFS samples size. :param file: Path to the init file to be created. """""" create_init_file( file=file, fixed_params=list(self.data['fixed_params'][type].keys()) if type in self.data['fixed_params'] else [], x0=self.data['x0'][type] if type in self.data['x0'] else {}, dfe_params=_from_string(self.data['model']).param_names, n=n ) def parse_polydfe_sfs_config(self, file: str): """""" Parse frequency spectra and mutational target site from polyDFE configuration file. :param file: Path to the polyDFE config file. """""" spectra = parse_polydfe_sfs_config(file) # merge into data dictionary self.data |= dict( sfs_neut=Spectra.from_spectrum(spectra['sfs_neut']), sfs_sel=Spectra.from_spectrum(spectra['sfs_sel']) ) def create_polydfe_sfs_config(self, file: str): """""" Create a sfs config file for polyDFE. :param file: Path to the sfs config file to be created. """""" create_sfs_config( file=file, sfs_neut=self.data['sfs_neut'].all if isinstance(self.data['sfs_neut'], Spectra) else self.data['sfs_neut'], sfs_sel=self.data['sfs_sel'].all if isinstance(self.data['sfs_sel'], Spectra) else self.data['sfs_sel'] ) def to_dict(self) -> dict: """""" Represent config as dictionary. :return: Dictionary representation of config. """""" return self.data def to_json(self) -> str: """""" Create JSON representation of object. :return: JSON string """""" return json.dumps(self.data, indent=4, cls=CustomEncoder) def to_yaml(self) -> str: """""" Create YAML representation of object. :return: YAML string """""" return yaml.dump(json.loads(self.to_json()), sort_keys=False) def to_file(self, file: str): """""" Save object to file. :param file: Path to file. """""" with open(file, 'w') as fh: fh.write(self.to_yaml()) @staticmethod def from_dict(data: dict) -> 'Config': """""" Load config from dictionary. :return: Config object. """""" # recreate spectra objects for sfs in ['sfs_neut', 'sfs_sel']: if sfs in data and data[sfs] is not None: data[sfs] = Spectra.from_dict(data=data[sfs]) # recreate SharedParams objects if 'shared_params' in data and data['shared_params'] is not None: data['shared_params'] = [SharedParams(**p) for p in data['shared_params']] # recreate Covariate objects if 'covariates' in data and data['covariates'] is not None: data['covariates'] = [Covariate(**c) for c in data['covariates']] # cast to tuple of (float, float, int) # useful when restoring from YAML file for key in ['intervals_ben', 'intervals_del', 'intervals_h']: if key in data: data[key] = (float(data[key][0]), float(data[key][1]), int(data[key][2])) return Config(**data) @staticmethod def from_json(data: str) -> 'Config': """""" Load config from JSON str. :param data: JSON string. :return: Config object. """""" return Config.from_dict(json.loads(data)) @staticmethod def from_yaml(data: str) -> 'Config': """""" Load config from YAML str. :param data: YAML string. :return: Config object. """""" return Config.from_dict(yaml.load(data, Loader=yaml.Loader)) @classmethod def from_file(cls, file: str, cache: bool = True) -> 'Config': """""" Load object from file. :param file: Path to file, possibly gzipped or a URL. :param cache: Whether to use the cache if available. :return: Config object. """""" with open(download_if_url(file, cache=cache, desc=f'{cls.__name__}>Downloading file'), 'r') as fh: return Config.from_yaml(fh.read()) def get_polydfe_model(self) -> str: # pragma: no cover """""" Get the model name in polyDFE that corresponds to the configured DFE parametrization. :return: polyDFE model name. """""" # get name of configured model name = _to_string(self.data['model']) # return polyDFE model name if it exists if name in models: return models[name] # raise error otherwise raise NotImplementedError(f'There is no polyDFE equivalent of {name}') ","Python" "Allele","Sendrowski/fastDFE","fastdfe/annotation.py",".py","171968","4500",""""""" VCF annotations and an annotator to apply them. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-05-09"" import itertools import logging import re import subprocess import tempfile from abc import ABC, abstractmethod from collections import Counter, defaultdict from enum import Enum from functools import cached_property from io import StringIO from itertools import product from typing import List, Optional, Dict, Tuple, Callable, Literal, Iterable, cast, Any, Generator, Union import Bio.Data.CodonTable import jsonpickle import numpy as np import pandas as pd from Bio import Phylo from Bio.Phylo.BaseTree import Clade, Tree from Bio.Seq import Seq from Bio.SeqRecord import SeqRecord from scipy.stats import hypergeom from tqdm import tqdm from .io_handlers import DummyVariant, MultiHandler, FASTAHandler from .io_handlers import GFFHandler, get_major_base, get_called_bases from .optimization import parallelize as parallelize_func, check_bounds from .settings import Settings from .spectrum import Spectra # get logger logger = logging.getLogger('fastdfe') # order of the bases important bases = np.array(['A', 'C', 'G', 'T']) # base indices base_indices = {'A': 0, 'C': 1, 'G': 2, 'T': 3} # codon table codon_table = Bio.Data.CodonTable.standard_dna_table.forward_table # stop codons stop_codons = Bio.Data.CodonTable.standard_dna_table.stop_codons # start codons start_codons = ['ATG'] # include stop codons in codon table for c in stop_codons: codon_table[c] = 'Σ' # The degeneracy of the site according to how many unique amino acids # are coding for when changing the site within the codon. # We count the third position of the isoleucine codon as 2-fold degenerate. # This is the only site that would normally have 3-fold degeneracy # (https://en.wikipedia.org/wiki/Codon_degeneracy) unique_to_degeneracy = {0: 0, 1: 2, 2: 2, 3: 4} class Annotation(ABC): """""" Base class for annotations. """""" def __init__(self): """""" Create a new annotation instance. """""" #: The logger. self._logger = logger.getChild(self.__class__.__name__) #: The annotator. self._handler: Annotator | None = None #: The number of annotated sites. self.n_annotated: int = 0 def _setup(self, handler: MultiHandler): """""" Provide context by passing the annotator. This should be called before the annotation starts. :param handler: The handler. """""" self._handler = handler def _rewind(self): """""" Rewind the annotation. """""" self.n_annotated = 0 def _teardown(self): """""" Finalize the annotation. Called after all sites have been annotated. """""" self._logger.info(f'Annotated {self.n_annotated} sites.') @abstractmethod def annotate_site(self, variant: Union['cyvcf2.Variant', DummyVariant]): """""" Annotate a single site. :param variant: The variant to annotate. :return: The annotated variant. """""" pass @staticmethod def count_target_sites(file: str, remove_overlaps: bool = False, contigs: List[str] = None) -> Dict[str, int]: """""" Count the number of target sites in a GFF file. :param file: The path to The GFF file path, possibly gzipped or a URL :param remove_overlaps: Whether to remove overlapping target sites. :param contigs: The contigs to count the target sites for. :return: The number of target sites per chromosome/contig. """""" return GFFHandler(file)._count_target_sites( remove_overlaps=remove_overlaps, contigs=contigs ) class DegeneracyAnnotation(Annotation): """""" Degeneracy annotation. We annotate the degeneracy by looking at each codon for coding variants. This also annotates mono-allelic sites. This annotation adds the info fields ``Degeneracy`` and ``Degeneracy_Info``, which hold the degeneracy of a site (0, 2, 4) and extra information about the degeneracy, respectively. To be used with :class:`~fastdfe.parser.DegeneracyStratification`. For this annotation to work, we require a FASTA and GFF file (passed to :class:`~fastdfe.parser.Parser` or :class:`~fastdfe.annotation.Annotator`). Example usage: :: import fastdfe as fd ann = fd.Annotator( vcf=""http://ftp.1000genomes.ebi.ac.uk/vol1/ftp/data_collections/"" ""1000_genomes_project/release/20181203_biallelic_SNV/"" ""ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz"", fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"", gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", output='sapiens.chr21.degeneracy.vcf.gz', annotations=[fd.DegeneracyAnnotation()], aliases=dict(chr21=['21']) ) ann.annotate() """""" #: The genomic positions for coding sequences that are mocked. _pos_mock: int = 1e100 def __init__(self): """""" Create a new annotation instance. """""" Annotation.__init__(self) #: The current coding sequence or the closest coding sequence downstream. self._cd: Optional[pd.Series] = None #: The coding sequence following the current coding sequence. self._cd_next: Optional[pd.Series] = None #: The coding sequence preceding the current coding sequence. self._cd_prev: Optional[pd.Series] = None #: The current contig. self._contig: Optional[SeqRecord] = None #: The variants that could not be annotated correctly. self.mismatches: List['cyvcf2.Variant'] = [] #: The variant that were skipped because they were not in coding regions. self.n_skipped: int = 0 #: The variants for which the codon could not be determined. self.errors: List['cyvcf2.Variant'] = [] def _setup(self, handler: MultiHandler): """""" Provide context to the annotator. :param handler: The handler. """""" # require FASTA and GFF files handler._require_fasta(self.__class__.__name__) handler._require_gff(self.__class__.__name__) # call super super()._setup(handler) # touch the cached properties to make for a nicer logging experience # noinspection PyStatementEffect self._handler._cds # noinspection PyStatementEffect self._handler._ref handler._reader.add_info_to_header({ 'ID': 'Degeneracy', 'Number': '.', 'Type': 'Integer', 'Description': 'n-fold degeneracy' }) handler._reader.add_info_to_header({ 'ID': 'Degeneracy_Info', 'Number': '.', 'Type': 'Integer', 'Description': 'Additional information about degeneracy annotation' }) def _rewind(self): """""" Rewind the annotation. """""" Annotation._rewind(self) self._cd = None self._cd_next = None self._cd_prev = None self._contig = None def _parse_codon_forward(self, variant: Union['cyvcf2.Variant', DummyVariant]): """""" Parse the codon in forward direction. :param variant: The variant. :return: Codon, Codon position, Codon start position, Position within codon, and relative position. """""" # position relative to start of coding sequence pos_rel = variant.POS - (self._cd.start + int(self._cd.phase)) # position relative to codon pos_codon = pos_rel % 3 # inclusive codon start, 1-based codon_start = variant.POS - pos_codon # the codon positions codon_pos = [codon_start, codon_start + 1, codon_start + 2] if (self._cd_prev is None or self._cd_next.start == self._pos_mock) and codon_pos[0] < self._cd.start: raise IndexError(f'Codon at site {variant.CHROM}:{variant.POS} overlaps with ' f'start position of current CDS and no previous CDS was given.') # Use final positions from previous coding sequence if current codon # starts before start position of current coding sequence if codon_pos[1] == self._cd.start: codon_pos[0] = self._cd_prev.end if self._cd_prev.strand == '+' else self._cd_prev.start elif codon_pos[2] == self._cd.start: codon_pos[1] = self._cd_prev.end if self._cd_prev.strand == '+' else self._cd_prev.start codon_pos[0] = self._cd_prev.end - 1 if self._cd_prev.strand == '+' else self._cd_prev.start + 1 if (self._cd_next is None or self._cd_next.start == self._pos_mock) and codon_pos[2] > self._cd.end: raise IndexError(f'Codon at site {variant.CHROM}:{variant.POS} overlaps with ' f'end position of current CDS and no subsequent CDS was given.') # use initial positions from subsequent coding sequence if current codon # ends before end position of current coding sequence if codon_pos[2] == self._cd.end + 1: codon_pos[2] = self._cd_next.start if self._cd_next.strand == '+' else self._cd_next.end elif codon_pos[1] == self._cd.end + 1: codon_pos[1] = self._cd_next.start if self._cd_next.strand == '+' else self._cd_next.end codon_pos[2] = self._cd_next.start + 1 if self._cd_next.strand == '+' else self._cd_next.end - 1 # seq uses 0-based positions codon = ''.join([str(self._contig[int(pos - 1)]) for pos in codon_pos]).upper() return codon, codon_pos, codon_start, pos_codon, pos_rel def _parse_codon_backward(self, variant: Union['cyvcf2.Variant', DummyVariant]): """""" Parse the codon in reverse direction. :param variant: The variant. :return: Codon, Codon position, Codon start position, Position within codon, and relative position. """""" # position relative to end of coding sequence pos_rel = (self._cd.end - int(self._cd.phase)) - variant.POS # position relative to codon end pos_codon = pos_rel % 3 # inclusive codon start, 1-based codon_start = variant.POS + pos_codon # the codon positions codon_pos = [codon_start, codon_start - 1, codon_start - 2] if (self._cd_prev is None or self._cd_next.start == self._pos_mock) and codon_pos[2] < self._cd.start: raise IndexError(f'Codon at site {variant.CHROM}:{variant.POS} overlaps with ' f'start position of current CDS and no previous CDS was given.') # Use final positions from previous coding sequence if current codon # ends before start position of current coding sequence. if codon_pos[1] == self._cd.start: codon_pos[2] = self._cd_prev.end if self._cd_prev.strand == '-' else self._cd_prev.start elif codon_pos[0] == self._cd.start: codon_pos[1] = self._cd_prev.end if self._cd_prev.strand == '-' else self._cd_prev.start codon_pos[2] = self._cd_prev.end - 1 if self._cd_prev.strand == '-' else self._cd_prev.start + 1 if (self._cd_next is None or self._cd_next.start == self._pos_mock) and codon_pos[0] > self._cd.end: raise IndexError(f'Codon at site {variant.CHROM}:{variant.POS} overlaps with ' f'end position of current CDS and no subsequent CDS was given.') # use initial positions from subsequent coding sequence if current codon # starts before end position of current coding sequence if codon_pos[0] == self._cd.end + 1: codon_pos[0] = self._cd_next.start if self._cd_next.strand == '-' else self._cd_next.end elif codon_pos[1] == self._cd.end + 1: codon_pos[1] = self._cd_next.start if self._cd_next.strand == '-' else self._cd_next.end codon_pos[0] = self._cd_next.start + 1 if self._cd_next.strand == '-' else self._cd_next.end - 1 # we use 0-based positions here codon = ''.join(str(self._contig[int(pos - 1)]) for pos in codon_pos) # take complement and convert to uppercase ('n' might be lowercase) codon = str(Seq(codon).complement()).upper() return codon, codon_pos, codon_start, pos_codon, pos_rel def _parse_codon(self, variant: Union['cyvcf2.Variant', DummyVariant]): """""" Parse the codon for the given variant. :param variant: The variant to parse the codon for. :return: Codon, Codon position, Codon start position, Position within codon, and relative position. """""" if self._cd.strand == '+': return self._parse_codon_forward(variant) return self._parse_codon_backward(variant) @staticmethod def _get_degeneracy(codon: str, pos: int) -> int: """""" Translate codon into amino acid. :param codon: The codon :param pos: The position of the variant in the codon, 0, 1, or 2 :return: The degeneracy of the codon, 0, 2, or 4 """""" amino_acid = codon_table[codon] # convert to list of characters codon = list(codon) # get the alternative bases alt = [] for b in bases[bases != codon[pos]]: codon[pos] = b alt.append(codon_table[''.join(codon)]) # noinspection PyTypeChecker return unique_to_degeneracy[sum(amino_acid == np.array(alt))] @staticmethod def _get_degeneracy_table() -> Dict[str, str]: """""" Create codon degeneracy table. :return: dictionary mapping codons to degeneracy """""" codon_degeneracy = {} for codon in product(bases, repeat=3): codon = ''.join(codon) codon_degeneracy[codon] = ''.join( [str(DegeneracyAnnotation._get_degeneracy(codon, pos)) for pos in range(0, 3)] ) return codon_degeneracy def _fetch_cds(self, v: Union['cyvcf2.Variant', DummyVariant]): """""" Fetch the coding sequence for the given variant. :param v: The variant to fetch the coding sequence for. :raises LookupError: If no coding sequence was found. """""" # get the aliases for the current chromosome aliases = self._handler.get_aliases(v.CHROM) # only fetch coding sequence if we are on a new chromosome or the # variant is not within the current coding sequence if self._cd is None or self._cd.seqid not in aliases or v.POS > self._cd.end: # reset coding sequences to mocking positions self._cd_prev = None self._cd = pd.Series({'seqid': v.CHROM, 'start': self._pos_mock, 'end': self._pos_mock}) self._cd_next = pd.Series({'seqid': v.CHROM, 'start': self._pos_mock, 'end': self._pos_mock}) # filter for the current chromosome on_contig = self._handler._cds[(self._handler._cds.seqid.isin(aliases))] # filter for positions ending after the variant cds = on_contig[(on_contig.end >= v.POS)] if not cds.empty: # take the first coding sequence self._cd = cds.iloc[0] self._logger.debug(f'Found coding sequence: {self._cd.seqid}:{self._cd.start}-{self._cd.end}, ' f'reminder: {(self._cd.end - self._cd.start + 1) % 3}, ' f'phase: {int(self._cd.phase)}, orientation: {self._cd.strand}, ' f'current position: {v.CHROM}:{v.POS}') # filter for positions ending after the current coding sequence cds = on_contig[(on_contig.start > self._cd.end)] if not cds.empty: # take the first coding sequence self._cd_next = cds.iloc[0] # filter for positions starting before the current coding sequence cds = on_contig[(on_contig.end < self._cd.start)] if not cds.empty: # take the last coding sequence self._cd_prev = cds.iloc[-1] if self._cd.start == self._pos_mock and self.n_annotated == 0: self._logger.warning(f""No coding sequence found on all of contig '{v.CHROM}' and no previous "" f'sites were annotated. Are you sure that this is the correct GFF file ' f'and that the contig names match the chromosome names in the VCF file? ' f'Note that you can also specify aliases for contig names in the VCF file.') # check if variant is located within coding sequence if self._cd is None or not (self._cd.start <= v.POS <= self._cd.end): raise LookupError(f""No coding sequence found, skipping record {v.CHROM}:{v.POS}"") def _fetch_contig(self, v: Union['cyvcf2.Variant', DummyVariant]): """""" Fetch the contig for the given variant. :param v: The variant to fetch the contig for. """""" aliases = self._handler.get_aliases(v.CHROM) # check if contig is up-to-date if self._contig is None or self._contig.id not in aliases: self._logger.debug(f""Fetching contig '{v.CHROM}'."") # fetch contig self._contig = self._handler.get_contig(aliases) def _fetch(self, variant: Union['cyvcf2.Variant', DummyVariant]): """""" Fetch all required data for the given variant. :param variant: The variant to fetch the data for. :raises LookupError: if some data could not be found. """""" self._fetch_cds(variant) try: self._fetch_contig(variant) except LookupError: # log error as this should not happen self._logger.warning(f""Could not fetch contig '{variant.CHROM}'."") raise def annotate_site(self, v: Union['cyvcf2.Variant', DummyVariant]): """""" Annotate a single site. :param v: The variant to annotate. """""" v.INFO['Degeneracy'] = '.' try: self._fetch(v) except LookupError: self.n_skipped += 1 return # skip locus if not a single site if len(v.REF) != 1: self.n_skipped += 1 return # annotate if record is in coding sequence if self._cd.seqid in self._handler.get_aliases(v.CHROM) and self._cd.start <= v.POS <= self._cd.end: try: # parse codon codon, codon_pos, codon_start, pos_codon, pos_rel = self._parse_codon(v) except IndexError as e: # skip site on IndexError self._logger.warning(e) self.errors.append(v) return # make sure the reference allele matches with the position on the reference genome if str(self._contig[v.POS - 1]).upper() != v.REF.upper(): self._logger.warning( f""Reference allele does not match with reference genome at {v.CHROM}:{v.POS}, skipping site."" ) self.mismatches.append(v) return degeneracy = '.' if 'N' not in codon: degeneracy = self._get_degeneracy(codon, pos_codon) # increment counter of annotated sites self.n_annotated += 1 v.INFO['Degeneracy'] = degeneracy v.INFO['Degeneracy_Info'] = f""{pos_codon},{self._cd.strand},{codon}"" self._logger.debug(f'pos codon: {pos_codon}, pos abs: {v.POS}, ' f'codon start: {codon_start}, codon: {codon}, ' f'strand: {self._cd.strand}, ref allele: {self._contig[v.POS - 1]}, ' f'degeneracy: {degeneracy}, codon pos: {str(codon_pos)}, ' f'ref allele: {v.REF}') class SynonymyAnnotation(DegeneracyAnnotation): """""" Synonymy annotation. This class annotates a variant with the synonymous/non-synonymous status. This annotation adds the info fields ``Synonymous`` and ``Synonymous_Info``, which hold the synonymy (Synonymous [0] or non-synonymous [1]) and the codon information, respectively. To be used with :class:`~fastdfe.parser.SynonymyStratification`. For this annotation to work, we require a FASTA and GFF file (passed to :class:`~fastdfe.parser.Parser` or :class:`~fastdfe.annotation.Annotator`). This class was tested against `VEP `_ and `SnpEff `_ and provides the same annotations in almost all cases. .. _VEP: https://www.ensembl.org/info/docs/tools/vep/index.html .. _SnpEff: https://pcingola.github.io/SnpEff/ .. warning:: Not recommended for use with :class:`~fastdfe.parser.Parser` as we also need to annotate mono-allelic sites. Consider using :class:`~fastdfe.annotation.DegeneracyAnnotation` and :class:`~fastdfe.parser.DegeneracyStratification` instead. """""" def __init__(self): """""" Create a new annotation instance. """""" super().__init__() #: The number of sites that did not match with VEP. self.vep_mismatches: List['cyvcf2.Variant'] = [] #: The number of sites that did not math with the annotation provided by SnpEff self.snpeff_mismatches: List['cyvcf2.Variant'] = [] #: The number of sites that were concordant with VEP. self.n_vep_comparisons: int = 0 #: The number of sites that were concordant with SnpEff. self.n_snpeff_comparisons: int = 0 def _setup(self, handler: MultiHandler): """""" Provide context to the annotator. :param handler: The handler. """""" # require FASTA and GFF files handler._require_fasta(self.__class__.__name__) handler._require_gff(self.__class__.__name__) Annotation._setup(self, handler) # touch the cached properties to make for a nicer logging experience # noinspection PyStatementEffect self._handler._cds # noinspection PyStatementEffect self._handler._ref handler._reader.add_info_to_header({ 'ID': 'Synonymy', 'Number': '.', 'Type': 'Integer', 'Description': 'Synonymous (0) or non-synonymous (1)' }) handler._reader.add_info_to_header({ 'ID': 'Synonymy_Info', 'Number': '.', 'Type': 'String', 'Description': 'Alt codon and extra information' }) def _get_alt_allele(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str | None: """""" Get the alternative allele. :param variant: The variant to get the alternative allele for. :return: The alternative allele or None if there is no alternative allele. """""" if len(variant.ALT) > 0: # assume there is at most one alternative allele if self._cd.strand == '-': return Seq(variant.ALT[0]).complement().__str__() return variant.ALT[0] @staticmethod def mutate(codon: str, alt: str, pos: int) -> str: """""" Mutate the codon at the given position to the given alternative allele. :param codon: The codon to mutate. :param alt: The alternative allele. :param pos: The position to mutate. :return: Mutated codon. """""" return codon[0:pos] + alt + codon[pos + 1:] @staticmethod def is_synonymous(codon1: str, codon2: str) -> bool: """""" Check if two codons are synonymous. :param codon1: The first codon. :param codon2: The second codon. :return: True if the codons are synonymous, False otherwise. """""" # handle case where there are stop codons if codon1 in stop_codons or codon2 in stop_codons: return codon1 in stop_codons and codon2 in stop_codons return codon_table[codon1] == codon_table[codon2] def _parse_codons_vep(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> List[str]: """""" Parse the codons from the VEP annotation if present. :param variant: The variant. :return: The codons. """""" # match codons match = re.search(""([actgACTG]{3})/([actgACTG]{3})"", variant.INFO.get('CSQ')) if match is not None: if len(match.groups()) != 2: self._logger.info(f'VEP annotation has more than two codons: {variant.INFO.get(""CSQ"")}') return [m.upper() for m in [match[1], match[2]]] return [] @staticmethod def _parse_synonymy_snpeff(variant: Union['cyvcf2.Variant', DummyVariant]) -> int | None: """""" Parse the synonymy from the annotation provided by SnpEff :param variant: The variant. :return: The codons. """""" ann = variant.INFO.get('ANN') if 'synonymous_variant' in ann: return 1 if 'missense_variant' in ann: return 0 def _teardown(self): """""" Finalize the annotation. """""" super()._teardown() if self.n_vep_comparisons != 0: self._logger.info(f'Number of mismatches with VEP: {len(self.vep_mismatches)}') if self.n_snpeff_comparisons != 0: self._logger.info(f'Number of mismatches with SnpEff: {len(self.snpeff_mismatches)}') def annotate_site(self, v: Union['cyvcf2.Variant', DummyVariant]): """""" Annotate a single site. :param v: The variant to annotate. :return: The annotated variant. """""" v.INFO['Synonymy'] = '.' if v.is_snp: try: self._fetch(v) except LookupError: self.n_skipped += 1 return # annotate if record is in coding sequence if self._cd.start <= v.POS <= self._cd.end: try: # parse codon codon, codon_pos, codon_start, pos_codon, pos_rel = self._parse_codon(v) except IndexError as e: # skip site on IndexError self._logger.warning(e) self.errors.append(v) return # make sure the reference allele matches with the position in the reference genome if str(self._contig[v.POS - 1]).upper() != v.REF.upper(): self._logger.warning( f""Reference allele does not match with reference genome at {v.CHROM}:{v.POS}, skipping site."" ) self.mismatches.append(v) return # fetch the alternative allele if present alt = self._get_alt_allele(v) info = '' synonymy = '.' if alt is not None: # alternative codon, 'n' might not be uppercase alt_codon = self.mutate(codon, alt, pos_codon).upper() # whether the alternative codon is synonymous if 'N' not in codon and 'N' not in alt_codon: synonymy = int(self.is_synonymous(codon, alt_codon)) # append alternative codon to info field info += f'{codon}/{alt_codon}' # check if the alternative codon is a start codon if alt_codon in start_codons: info += ',start_gained' # check if the alternative codon is a stop codon if alt_codon in stop_codons: info += ',stop_gained' if v.INFO.get('CSQ') is not None: # fetch the codons from the VEP annotation codons_vep = self._parse_codons_vep(v) if len(codons_vep) > 0: # increase number of comparisons self.n_vep_comparisons += 1 # make sure the codons determined by VEP are the same as our codons. if set(codons_vep) != {codon, alt_codon}: self._logger.warning(f'VEP codons do not match with codons determined by ' f'codon table for {v.CHROM}:{v.POS}') self.vep_mismatches.append(v) return if v.INFO.get('ANN') is not None: synonymy_snpeff = self._parse_synonymy_snpeff(v) self.n_snpeff_comparisons += 1 if synonymy_snpeff is not None: if synonymy_snpeff != synonymy: self._logger.warning(f'SnpEff annotation does not match with custom ' f'annotation for {v.CHROM}:{v.POS}') self.snpeff_mismatches.append(v) return # increase number of annotated sites self.n_annotated += 1 # add to info field v.INFO['Synonymy'] = synonymy v.INFO['Synonymy_Info'] = info class AncestralAlleleAnnotation(Annotation, ABC): """""" Base class for ancestral allele annotation. """""" def _setup(self, handler: MultiHandler): """""" Add info fields to the header. :param handler: The handler. """""" super()._setup(handler) handler._reader.add_info_to_header({ 'ID': self._handler.info_ancestral, 'Number': '.', 'Type': 'Character', 'Description': 'Ancestral Allele' }) class MaximumParsimonyAncestralAnnotation(AncestralAlleleAnnotation): """""" Annotation of ancestral alleles using maximum parsimony. To be used with :class:`~fastdfe.parser.AncestralBaseStratification` and :class:`Annotator` or :class:`~fastdfe.parser.Parser`. Note that maximum parsimony is not a reliable way to determine ancestral alleles, so it is recommended to use this annotation together with the ancestral misidentification parameter ``eps`` or to fold spectra altogether. Alternatively, you can use :class:`~fastdfe.filtration.DeviantOutgroupFiltration` to filter out sites where the major allele among outgroups does not coincide with the major allele among ingroups. This annotation has the advantage of requiring no outgroup data. If outgroup data is available consider using :class`MLEAncestralAlleleAnnotation` instead. """""" def __init__(self, samples: List[str] = None): """""" Create a new ancestral allele annotation instance. :param samples: The samples to consider when determining the ancestral allele. If ``None``, all samples are considered. """""" super().__init__() #: The samples to consider when determining the ancestral allele. self.samples: List[str] | None = samples self.samples_mask: np.ndarray | None = None def _setup(self, handler: MultiHandler): """""" Add info fields to the header. :param handler: The handler. """""" super()._setup(handler) # create mask for ingroups if self.samples is None: self.samples_mask = np.ones(len(handler._reader.samples)).astype(bool) else: self.samples_mask = np.isin(handler._reader.samples, self.samples) def annotate_site(self, variant: Union['cyvcf2.Variant', DummyVariant]): """""" Annotate a single site. :param variant: The variant to annotate. :return: The annotated variant. """""" # assign the ancestral allele variant.INFO[self._handler.info_ancestral] = self._get_ancestral(variant, self.samples_mask) if variant.INFO[self._handler.info_ancestral] != '.': # increase the number of annotated sites self.n_annotated += 1 @staticmethod def _get_ancestral( variant: Union['cyvcf2.Variant', DummyVariant], mask: np.ndarray, ) -> str: """""" Get the ancestral allele for the given variant using maximum parsimony. :param variant: The variant to annotate. :param mask: The mask for the ingroups. :return: The ancestral allele or '.' if it could not be determined. """""" # take reference allele as ancestral if dummy variant if isinstance(variant, DummyVariant): return variant.REF # take only base to be ancestral if we have a monomorphic snv if not variant.is_snp and variant.REF in bases: b = list(set(get_called_bases(variant.gt_bases[mask]))) if len(b) == 1 and b[0] in bases: return b[0] # take major base to be ancestral if we have an SNP if variant.is_snp: return get_major_base(variant.gt_bases[mask]) or '.' return '.' class SubstitutionModel(ABC): """""" Base class for substitution models. """""" #: The possible transitions _transitions: np.ndarray = np.array([ (base_indices['A'], base_indices['G']), (base_indices['G'], base_indices['A']), (base_indices['C'], base_indices['T']), (base_indices['T'], base_indices['C']) ]) #: The possible transversions _transversions: np.ndarray = np.array([ (base_indices['A'], base_indices['C']), (base_indices['C'], base_indices['A']), (base_indices['G'], base_indices['T']), (base_indices['T'], base_indices['G']), (base_indices['A'], base_indices['T']), (base_indices['T'], base_indices['A']), (base_indices['C'], base_indices['G']), (base_indices['G'], base_indices['C']) ]) def __init__( self, bounds: Dict[str, Tuple[float, float]] = {}, pool_branch_rates: bool = False, fixed_params: Dict[str, float] = {} ): """""" Create a new substitution model instance. :param bounds: The bounds for the parameters. :param pool_branch_rates: Whether to pool the branch rates. By default, each branch has its own rate which is optimized using MLE. If ``True``, the branch rates are pooled and a single rate is optimized. This is useful if the number of sites used is small. :param fixed_params: The fixed parameters. Parameters that are not fixed are optimized using MLE. """""" #: The logger. self._logger = logging.getLogger(self.__class__.__name__) # validate bounds self.validate_bounds(bounds) #: Whether to pool the branch rates. self.pool_branch_rates: bool = pool_branch_rates #: The fixed parameters. self.fixed_params: Dict[str, float] = fixed_params.copy() #: Parameter bounds. self.bounds: Dict[str, Tuple[float, float]] = bounds.copy() #: Cache for the probabilities. self._cache: Dict[Tuple[int, int, int], float] | None = None def _setup(self, ann: 'MaximumLikelihoodAncestralAnnotation'): """""" Set up the substitution model. :param ann: The ancestral allele annotation. """""" pass def cache(self, params: Dict[str, float], n_branches: int): """""" Cache the probabilities for the given parameters. :param params: The parameters. :param n_branches: The number of branches. """""" self._cache = {} for (b1, b2, i) in itertools.product(range(0, 4), range(0, 4), range(n_branches)): self._cache[(b1, b2, i)] = self._get_prob(b1, b2, i, params) @staticmethod def get_x0(bounds: Dict[str, Tuple[float, float]], rng: np.random.Generator) -> Dict[str, float]: """""" Get the initial values for the parameters. :param bounds: The bounds for the parameters. :param rng: The random number generator. :return: The initial values. """""" x0 = {} # draw initial values from a uniform distribution for key, (lower, upper) in bounds.items(): x0[key] = rng.uniform(lower, upper) return x0 def get_bounds(self, n_outgroups: int) -> Dict[str, Tuple[float, float]]: """""" Get the bounds for the parameters. :param n_outgroups: The number of outgroups. :return: The bounds. """""" return self.bounds @staticmethod def validate_bounds(bounds: Dict[str, Tuple[float, float]]): """""" Make sure the lower bounds are positive and the upper bounds are larger than the lower bounds. :param bounds: The bounds to validate :raises ValueError: If the bounds are invalid """""" for param, (lower, upper) in bounds.items(): if lower <= 0: raise ValueError(f'All lower bounds must be positive, got {lower} for {param}.') if lower > upper: raise ValueError(f'Lower bounds must be smaller than upper bounds, got {lower} > {upper} for {param}.') @abstractmethod def _get_prob(self, b1: int, b2: int, i: int, params: Dict[str, float]) -> float: """""" Get the probability of a branch using the substitution model. :param b1: First nucleotide state. :param b2: Second nucleotide state. :param i: The index of the branch. :param params: The parameters for the model. :return: The probability of the branch. """""" pass def _get_cached_prob(self, b1: int, b2: int, i: int, params: Dict[str, float]) -> float: """""" Get the probability of a branch using the substitution model with caching. :param b1: First nucleotide state. :param b2: Second nucleotide state. :param i: The index of the branch. :param params: The parameters for the model. :return: The probability of the branch. """""" if self._cache is None: return self._get_prob(b1, b2, i, params) # return cached value return self._cache[(b1, b2, i)] class JCSubstitutionModel(SubstitutionModel): """""" Jukes-Cantor substitution model. """""" def __init__( self, bounds: Dict[str, Tuple[float, float]] = {'K': (1e-5, 10)}, pool_branch_rates: bool = False, fixed_params: Dict[str, float] = {} ): """""" Create a new substitution model instance. :param bounds: The bounds for the parameters. K is the branch rate. :param pool_branch_rates: Whether to pool the branch rates. By default, each branch has its own rate which is optimized using MLE. If ``True``, the branch rates are pooled and a single rate is optimized. This is useful if the number of sites used is small. If ``False``, each branch has its own rate denoted by ""K{i}"", where i is the branch index. If ``True``, the branch rate is denoted by ""K"". :param fixed_params: The fixed parameters. Parameters that are not fixed are optimized using MLE. """""" super().__init__( bounds=bounds, pool_branch_rates=pool_branch_rates, fixed_params=fixed_params ) def get_bound(self, param: str) -> Tuple[float, float]: """""" Get the bounds for a parameter. :param param: The parameter. :return: The lower and upper bounds. """""" # check if the parameter is fixed if param in self.fixed_params: return self.fixed_params[param], self.fixed_params[param] # return the bounds if they are defined if param in self.bounds: return self.bounds[param] # attempt to get the bounds for the branch rates by removing the branch index param_no_index = re.sub(pattern=r'\d', repl='', string=param) return self.bounds[param_no_index] def get_bounds(self, n_outgroups: int) -> Dict[str, Tuple[float, float]]: """""" Get the bounds for the parameters. :param n_outgroups: The number of outgroups. :return: The lower and upper bounds. """""" if self.pool_branch_rates: # pool the branch rates return {'K': self.get_bound('K')} # get the bounds for the branch lengths return {f""K{i}"": self.get_bound(f""K{i}"") for i in range(2 * n_outgroups - 1)} def _get_prob(self, b1: int, b2: int, i: int, params: Dict[str, float]) -> float: """""" Get the probability of a branch using the substitution model. :param b1: First nucleotide state. :param b2: Second nucleotide state. :param i: The index of the branch. :param params: The parameters for the model. :return: The probability of the branch. """""" # evolutionary rate parameter for the branch K = params['K'] if self.pool_branch_rates else params[f'K{i}'] if b1 == b2: return np.exp(-K) + (1 / 6) * K ** 2 * np.exp(-K) return (1 / 3) * K * np.exp(-K) + (1 / 9) * K ** 2 * np.exp(-K) class K2SubstitutionModel(JCSubstitutionModel): """""" Kimura 2-parameter substitution model. """""" def __init__( self, bounds: Dict[str, Tuple[float, float]] = {'K': (1e-5, 10), 'k': (0.1, 10)}, pool_branch_rates: bool = False, fixed_params: Dict[str, float] = {}, fix_transition_transversion_ratio: bool = False ): """""" Create a new substitution model instance. :param bounds: The bounds for the parameters. ``K{i}`` are the branch rates. ``k`` is the transition/transversion ratio. :param pool_branch_rates: Whether to pool the branch rates. By default, each branch has its own rate which is optimized using MLE. If ``True``, the branch rates are pooled and a single rate is optimized. This is useful if the number of sites used is small. :param fixed_params: The fixed parameters. Parameters that are not fixed are optimized using MLE. :param fix_transition_transversion_ratio: Whether to fix the transition/transversion ratio to the ratio observed in the data. """""" super().__init__( bounds=bounds, pool_branch_rates=pool_branch_rates, fixed_params=fixed_params ) #: Whether to fix the transition/transversion ratio to the ratio observed in the data. self.fix_transition_transversion_ratio: bool = fix_transition_transversion_ratio def _setup(self, ann: 'MaximumLikelihoodAncestralAnnotation'): """""" Set up the substitution model. :param ann: The ancestral allele annotation. """""" if self.fix_transition_transversion_ratio: # fix the transition/transversion ratio to the ratio observed in the data self.fixed_params['k'] = ann.get_observed_transition_transversion_ratio() def get_bounds(self, n_outgroups: int) -> Dict[str, Tuple[float, float]]: """""" Get the bounds for the parameters. :param n_outgroups: The number of outgroups. :return: The lower and upper bounds. """""" bounds = super().get_bounds(n_outgroups) # add bounds for the transition/transversion ratio bounds[""k""] = self.get_bound(""k"") return bounds def _get_prob(self, b1: int, b2: int, i: int, params: Dict[str, float]) -> float: """""" Get the probability of a branch using the K2 model. :param b1: First nucleotide state. :param b2: Second nucleotide state. :param i: The index of the branch. :param params: The parameters for the model. :return: The probability of the branch. """""" # evolutionary rate parameter for the branch K = params['K'] if self.pool_branch_rates else params[f'K{i}'] # transition/transversion ratio k = params[""k""] # if the ancestral and descendant nucleotide states are the same if b1 == b2: return np.exp(-K) * (1 + 0.5 * K ** 2 * (2 + k ** 2) / (k ** 2 + 4 * k + 4)) # if we have a transition if (b1, b2) in [(0, 2), (2, 0), (1, 3), (3, 1)]: return K * np.exp(-K) * (k / (k + 2) + K * 1 / (k ** 2 + 4 * k + 4)) # if we have a transversion return K * np.exp(-K) * (1 / (k + 2) + K * k / (k ** 2 + 4 * k + 4)) class SiteConfig: """""" Ancestral allele site configuration for a single subsample. """""" def __init__( self, n_major: int, major_base: int, minor_base: int, outgroup_bases: np.ndarray, multiplicity: float = 1.0, sites: np.ndarray = None, p_minor: float = np.nan, p_major: float = np.nan ): """""" Create a new site configuration instance. """""" #: The number of major alleles. self.n_major: int = n_major #: The major allele base index. self.major_base: int = major_base #: The minor base index. self.minor_base: int = minor_base #: The outgroup base indices. self.outgroup_bases: np.ndarray = outgroup_bases #: The multiplicity of the site. self.multiplicity: float = multiplicity #: The site indices. self.sites: np.ndarray = np.array([]) if sites is None else sites #: The probability of the minor allele. self.p_minor: float = p_minor #: The probability of the major allele. self.p_major: float = p_major class SiteInfo: """""" Ancestral allele information on a single site. """""" def __init__( self, n_major: Dict[int, float], major_base: str, minor_base: str, outgroup_bases: List[str], p_minor: float = np.nan, p_major: float = np.nan, p_major_ancestral: float = np.nan, major_ancestral: str = '.', p_bases_first_node: Dict[str, float] = None, p_first_node_ancestral: float = np.nan, first_node_ancestral: str = '.', rate_params: Dict[str, float] = None ): #: Dictionary mapping number of major alleles to its probability of observation. self.n_major: Dict[int, float] = n_major #: The major allele base. self.major_base: str = major_base #: The minor base index. self.minor_base: str = minor_base #: The outgroup base indices. self.outgroup_bases: List[str] = outgroup_bases #: The probability of the minor allele being the ancestral allele (without prior). self.p_minor: float = p_minor #: The probability of the major allele being the ancestral allele (without prior). self.p_major: float = p_major #: The probability of the major allele being the ancestral allele rather than the minor allele #: (possibly with prior if specified). self.p_major_ancestral: float = p_major_ancestral #: The predicted ancestral base based on comparing major and minor allele. self.major_ancestral: str = major_ancestral #: The probability of each base being the ancestral base for the first internal node. self.p_bases_first_node: Dict[str, float] = {} if p_bases_first_node is None else p_bases_first_node #: The probability that the mostly likely base for the first internal node is the ancestral base. self.p_first_node_ancestral: float = p_first_node_ancestral #: The ancestral base index for the first internal node. self.first_node_ancestral: str = first_node_ancestral #: The branch rates. self.rate_params: Dict[str, float] = {} if rate_params is None else rate_params def plot_tree( self, ax: 'plt.Axes' = None, show: bool = True, ): """""" Plot the tree for a site. Only Python visualization is supported. :param self: The site information. :param ax: Axes to plot on. :param show: Whether to show the plot. """""" import matplotlib.pyplot as plt if ax is None: ax = plt.gca() if 'K' in self.rate_params: branch_lengths = {f'K{i}': self.rate_params['K'] for i in range(len(self.outgroup_bases) * 2 - 1)} else: branch_lengths = self.rate_params n_outgroups = len(self.outgroup_bases) # Create major, minor, and ingroup clades major_clade = Clade(name=self.major_base, branch_length=0) minor_clade = Clade(name=self.minor_base, branch_length=0) ingroup = Clade( name=""ingroup"", clades=[major_clade, minor_clade], branch_length=branch_lengths['K0'] if n_outgroups > 0 else 0 ) current = ingroup # Create and attach outgroup clades to major and minor clades for i in range(n_outgroups): # last outgroup has half the branch length to the root # as we have no internal node if i < n_outgroups - 1: outgroup_length = branch_lengths[f""K{2 * i + 1}""] else: outgroup_length = branch_lengths[f""K{2 * i}""] / 2 # create outgroup clade outgroup = Clade( name=self.outgroup_bases[i], branch_length=outgroup_length ) # determine the branch length to the next node if i < n_outgroups - 2: node_length = branch_lengths[f""K{2 * i + 2}""] elif i == n_outgroups - 2: node_length = branch_lengths[f""K{2 * i + 2}""] / 2 else: node_length = 0 # create internal node / root current = Clade( name=f""internal {i + 1}"" if i < n_outgroups - 1 else None, clades=[outgroup, current], branch_length=node_length ) # create a tree object and visualize tree = Tree(root=current) Phylo.draw(tree, axes=ax, do_show=False) # remove Y-axis ax.axes.get_yaxis().set_visible(False) # remove frame for pos in ['top', 'right', 'left']: ax.spines[pos].set_visible(False) if show: plt.show() class _TooFewIngroupsSiteError(ValueError): """""" Raised when there are too few ingroups to consider a site for ancestral allele annotation. """""" pass class _PolyAllelicSiteError(ValueError): """""" Raised when a site has more than two alleles. """""" pass class BaseType(Enum): """""" The base type, either major or minor. """""" MINOR: int = 0 MAJOR: int = 1 class PolarizationPrior(ABC): """""" Base class for priors used with :class:MaximumLikelihoodAncestralAnnotation. These priors incorporate information about the general probability of the major allele being ancestral across all sites with the same minor allele count. Prior thus take ingroup allele frequencies into account, when making predictions about the ancestral state of a site. This is useful because it enhances ancestral allele probability estimates, especially when outgroup information is unavailable for a particular site. Knowing the likelihood of the major allele being ancestral in general allows for more informed estimations. """""" def __init__(self, allow_divergence: bool = False): """""" Create a new instance. :param allow_divergence: Whether to allow divergence. If ``True``, the probability of the minor allele being ancestral, which is not contained in the ingroup subsample but rather in all specified ingroups or among the outgroup, is taken to be the same as if it was present in the ingroup subsample with frequency 1. This is a hack, but allows us to consider alleles that are not present in the ingroup subsample. .. warning:: Setting this to ``True`` greatly increases the probability of high-frequency derived alleles which introduces a strong bias in the distribution of frequency counts, e.g., the SFS. Only use this if you're interested in handling divergence counts, i.e., sites where the ingroup is mono-allelic. """""" #: The logger. self._logger = logger.getChild(self.__class__.__name__) #: Whether to allow divergence. self.allow_divergence: bool = allow_divergence #: The polarization probabilities. self.probabilities: np.ndarray | None = None def _add_divergence(self): """""" Add divergence to the polarization probabilities. """""" # take divergence probabilities to be the same as alleles of frequency 1 if self.allow_divergence: self.probabilities[0] = self.probabilities[1] self.probabilities[-1] = self.probabilities[-2] else: # set divergence probabilities to 0 self.probabilities[0] = 1 self.probabilities[-1] = 0 @abstractmethod def _get_prior(self, configs: pd.DataFrame, n_ingroups: int) -> np.ndarray: """""" Get the polarization probabilities. :param configs: The site configurations. :param n_ingroups: The number of ingroups. """""" pass def plot( self, file: str = None, show: bool = True, title: str = 'polarization probabilities', scale: Literal['lin', 'log'] = 'lin', ax: 'plt.Axes' = None, ylabel: str = 'p' ) -> 'plt.Axes': """""" Visualize the polarization probabilities using a scatter plot. :param scale: y-scale of the plot. :param title: Plot title. :param file: File to save plot to. :param show: Whether to show plot. :param ax: Axes to plot on. Only for Python visualization backend. :param ylabel: y-axis label. :return: Axes object """""" from .visualization import Visualization if self.probabilities is None: raise ValueError('Polarization probabilities have not been calculated yet.') return Visualization.plot_scatter( values=self.probabilities, file=file, show=show, title=title, scale=scale, ax=ax, ylabel=ylabel ) class KingmanPolarizationPrior(PolarizationPrior): """""" Prior based on the standard Kingman coalescent. To be used with :class:`MaximumLikelihoodAncestralAnnotation`. """""" def _get_prior(self, configs: pd.DataFrame, n_ingroups: int) -> np.ndarray: """""" Get the polarization probabilities. :param configs: The site configurations. :param n_ingroups: The number of ingroups. """""" self.probabilities = np.zeros(n_ingroups + 1) # calculate polarization probabilities for i in range(1, n_ingroups): self.probabilities[i] = 1 / i / (1 / i + 1 / (n_ingroups - i)) # add divergence probabilities self._add_divergence() return self.probabilities class AdaptivePolarizationPrior(PolarizationPrior): """""" Adaptive prior. To be used with :class:`MaximumLikelihoodAncestralAnnotation`. This is the same prior as used in the EST-SFS paper. This prior is adaptive in the sense that the most likely polarization probabilities given the site configurations are found. This is the most accurate prior, but requires a lot of sites in order to work properly. You can check that the polarization probabilities are smooth enough across frequency counts by calling :meth:`~fastdfe.annotation.PolarizationPrior.plot`. If they are not smooth enough, you can increase the number of sites, decrease the number of ingroups, or use :class:`~fastdfe.annotation.KingmanPolarizationPrior` instead. .. note:: In practice, this prior provides very similar results to :class:`KingmanPolarizationPrior` in most cases. """""" def __init__( self, n_runs: int = 1, parallelize: bool = True, allow_divergence: bool = False, seed: int | None = 0 ): """""" Create a new adaptive prior instance. :param n_runs: The number of runs to perform when determining the polarization parameters. One run should be sufficient as only one parameter is optimized. :param parallelize: Whether to parallelize the optimization. :param allow_divergence: Whether to allow divergence. See :class:`PolarizationPrior` for details. :param seed: The seed for the random number generator. """""" super().__init__(allow_divergence=allow_divergence) #: The number of runs to use for the adaptive prior. self.n_runs: int = n_runs #: Whether to parallelize the optimization. self.parallelize: bool = parallelize #: The seed for the random number generator. self.seed: int | None = seed #: The random number generator. self.rng: np.random.Generator = np.random.default_rng(seed=self.seed) def _get_prior( self, configs: pd.DataFrame, n_ingroups: int ) -> np.ndarray: """""" Get the polarization probabilities. :param configs: The site configurations. :param n_ingroups: The number of ingroups. :return: The polarization probabilities. """""" from scipy.optimize import minimize, OptimizeResult # folded frequency bin indices # if the number of polymorphic bins is odd, the middle bin is fixed freq_indices = range(1, (n_ingroups + 1) // 2) # get the likelihood functions funcs = dict((i, self._get_likelihood(i, configs, n_ingroups)) for i in freq_indices) def optimize_polarization(args: List[Any]) -> OptimizeResult: """""" Optimize the likelihood function for a single run. :param args: The arguments. :return: The optimization results. """""" # unpack arguments i, _, x0 = args # optimize using scipy return minimize( fun=funcs[int(i)], x0=np.array([x0]), bounds=[(0, 1)], method=""L-BFGS-B"" ) # prepare arguments data = np.array(list(itertools.product(freq_indices, range(self.n_runs)))) # get initial values initial_values = np.array([self.rng.uniform() for _ in range(data.shape[0])]) # add initial values data = np.hstack((data, initial_values.reshape((-1, 1)))) # run the optimization in parallel for each frequency bin over n_runs results: np.ndarray = parallelize_func( func=optimize_polarization, data=data, parallelize=self.parallelize, pbar=True, desc=f""{self.__class__.__name__}>Optimizing polarization priors"", dtype=object ).reshape(len(freq_indices), self.n_runs) # get the likelihoods for each run and frequency bin likelihoods = np.vectorize(lambda r: r.fun)(results) # choose run with the best likelihood for each frequency bin i_best = likelihoods.argmin(axis=1) # check for successful optimization if not np.all(np.vectorize(lambda r: r.success)(results[:, i_best])): # get the failure messages failures = [r.message for r in results[:, i_best] if not r.success] # raise an error raise RuntimeError(""Polarization probability optimizations failed with messages: "" + "", "".join(failures)) # get the probabilities for each frequency bin # noinspection all probs = np.array([results[i, j].x[0] for i, j in enumerate(i_best)]) # check for zeros or ones if np.any(probs == 0) or np.any(probs == 1): # get the number of bad frequency bins n_bad = np.sum((probs == 0) | (probs == 1)) self._logger.fatal(f""Polarization probabilities are 0 for {n_bad} frequency bins which "" f""can be a real problem as it means that there are no sites "" f""for those bins. This may be due to ``n_ingroups`` "" f""being too large, or the number of provided sites being very "" f""small. If you can't increase the number of sites or decrease "" f""``n_ingroups``, consider using a the Kingman prior instead."") # if the number of ingroups is even if n_ingroups % 2 == 0: # noinspection all self.probabilities = np.concatenate(([1], probs, [0.5], 1 - probs[::-1], [0])) else: # if the number of ingroups is odd # noinspection all self.probabilities = np.concatenate(([1], probs, 1 - probs[::-1], [0])) # add divergence probabilities self._add_divergence() return self.probabilities @staticmethod def _get_likelihood( i: int, configs: pd.DataFrame, n_ingroups: int ) -> Callable[[List[float]], float]: """""" Get the likelihood function. :param i: The ith frequency bin. :param configs: The site configurations. :param n_ingroups: The number of ingroups. The likelihood function evaluated for the ith frequency bin. """""" def compute_likelihood(params: List[float]) -> float: """""" Compute the negative log likelihood of the parameters. :param params: The probability of polarization. :return: The negative log likelihood. """""" # get the probability of polarization for the ith frequency bin pi = params[0] # mask for sites that have i minor alleles i_minor = n_ingroups - configs.n_major == i # weight the sites by the probability of polarization p_configs = pi * configs.p_major[i_minor] + (1 - pi) * configs.p_minor[i_minor] # return the negative log likelihood return -(np.log(p_configs) * configs.multiplicity[i_minor]).sum() return compute_likelihood class _OutgroupAncestralAlleleAnnotation(AncestralAlleleAnnotation, ABC): """""" Abstract class for annotation of ancestral alleles using outgroup information. """""" def __init__( self, outgroups: List[str], n_ingroups: int, ingroups: List[str] | None = None, exclude: List[str] = [], seed: int | None = 0, subsample_mode: Literal['random', 'probabilistic'] = 'random' ): """""" Create a new ancestral allele annotation instance. :param outgroups: The outgroup samples to consider when determining the ancestral allele. A list of sample names as they appear in the VCF file. :param n_ingroups: The minimum number of ingroups that must be present at a site for it to be considered for ancestral allele inference. :param ingroups: The ingroup samples to consider when determining the ancestral allele. A list of sample names as they appear in the VCF file. If ``None``, all samples except the outgroups are considered. :param exclude: Samples to exclude from the ingroup. A list of sample names as they appear in the VCF file. :param seed: The seed for the random number generator. :param subsample_mode: The subsampling mode. Either 'random' or 'probabilistic'. """""" # make sure the number of ingroups is at least 2 if n_ingroups < 2: raise ValueError(""The number of ingroups must be at least 2."") # check subsample mode if subsample_mode not in ['random', 'probabilistic']: raise ValueError(f""Invalid subsample mode: {subsample_mode}"") super().__init__() #: The ingroup samples to consider when determining the ancestral allele. self.ingroups: List[str] | None = ingroups #: The samples excluded from the ingroup. self.exclude: List[str] = exclude #: The outgroup samples to consider when determining the ancestral allele. self.outgroups: List[str] = outgroups #: The number of ingroups. self.n_ingroups: int = int(n_ingroups) #: The number of outgroups. self.n_outgroups: int = len(outgroups) #: The seed for the random number generator. self.seed: int | None = seed #: The subsampling mode. self.subsample_mode: Literal['random', 'probabilistic'] = subsample_mode #: The random number generator. self.rng: np.random.Generator = np.random.default_rng(seed=self.seed) #: The outgroup mask. self._outgroup_mask: np.ndarray | None = None #: The outgroup indices. self._outgroup_indices: np.ndarray | None = None #: The ingroup mask. self._ingroup_mask: np.ndarray | None = None #: 1-based positions of lowest and highest site position per contig (only when target_site_counter is used) # noinspection PyTypeChecker self._contig_bounds: Dict[str, Tuple[int, int]] = defaultdict(lambda: (np.inf, -np.inf)) def _prepare_masks(self, samples: List[str]): """""" Prepare the masks for ingroups and outgroups. :param samples: All samples. """""" # create mask for ingroups if self.ingroups is None: self._ingroup_mask = ~ np.isin(samples, self.outgroups) & ~ np.isin(samples, self.exclude) else: self._ingroup_mask = np.isin(samples, self.ingroups) & ~ np.isin(samples, self.exclude) # create mask for outgroups self._outgroup_mask = np.isin(samples, self.outgroups) # make sure all specified outgroups are present if np.sum(self._outgroup_mask) != len(self.outgroups): # get missing outgroups missing = np.array(self.outgroups)[~np.isin(self.outgroups, samples)] raise ValueError(f""The specified outgroups ({', '.join(missing)}) are not present in the VCF file."") # outgroup indices # we ignore the order when using the mask self._outgroup_indices = np.array([samples.index(outgroup) for outgroup in self.outgroups]) # inform of the number of ingroups self._logger.info(f""Subsampling {self.n_ingroups} ingroup haplotypes "" + (""randomly "" if self.subsample_mode == ""random"" else ""probabilistically "") + f""from {np.sum(self._ingroup_mask)} individuals in total."") # inform on outgroup samples self._logger.info(f""Using {np.sum(self._outgroup_mask)} outgroup samples ({', '.join(self.outgroups)})."") def _setup(self, handler: MultiHandler): """""" Add info fields to the header. :param handler: The handler. """""" super()._setup(handler) # add AA info field handler._reader.add_info_to_header({ 'ID': self._handler.info_ancestral + '_info', 'Number': '.', 'Type': 'String', 'Description': 'Additional information about the ancestral allele.' }) # add AA probability field handler._reader.add_info_to_header({ 'ID': self._handler.info_ancestral + '_prob', 'Number': '.', 'Type': 'Float', 'Description': 'Probability that the predicted ancestral allele is correct, as opposed to the other allele.' }) # set reader self._reader = self._handler.load_vcf() # prepare masks self._prepare_masks(handler._reader.samples) @staticmethod def _subsample( genotypes: np.ndarray, size: int, rng: np.random.Generator ) -> np.ndarray: """""" Subsample a set of bases. :param genotypes: A list of bases. :param size: The size of the subsample. :return: A subsample of the bases. """""" if genotypes.shape[0] == 0: return np.array([]) subsamples = rng.choice( a=genotypes.shape[0], size=min(size, genotypes.shape[0]), replace=False ) return genotypes[subsamples] @staticmethod def _get_outgroup_bases( genotypes: np.ndarray, n_outgroups: int ) -> np.ndarray: """""" Get the outgroup bases for a variant. :param genotypes: The VCF genotype strings. :param n_outgroups: The number of outgroups. :return: The outgroup bases. """""" outgroup_bases = np.full(n_outgroups, '.') for i, genotype in enumerate(genotypes): called_bases = get_called_bases([genotype]) if len(called_bases) > 0: outgroup_bases[i] = called_bases[0] return outgroup_bases @classmethod def _subsample_site( cls, mode: Literal['random', 'probabilistic'], n: int, samples: np.ndarray, rng: np.random.Generator ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: """""" Subsample a site, either randomly or probabilistically. :param mode: The subsampling mode. :param n: The number of ingroups to subsample to. :param samples: The samples. :return: Major alleles, major allele counts, and multiplicities, possibly including zero multiplicities. """""" if mode == 'random': # subsample ingroups samples = cls._subsample(samples, size=n, rng=rng) # get the major allele count most_common = Counter(samples).most_common() if mode == 'random': major_alleles = [most_common[0][0]] n_majors = [most_common[0][1]] m = [1] # if there is only one allele, probabilistic # subsampling is trivial elif len(most_common) < 2: major_alleles = [most_common[0][0]] n_majors = [n] m = [1] else: ref_allele = most_common[0][0] n_ref = most_common[0][1] alt_allele = most_common[1][0] # get the major allele counts n_majors = np.arange(n + 1) major_alleles = np.full(n + 1, ref_allele) m = hypergeom.pmf(k=n_majors, M=len(samples), n=n_ref, N=n) # flip alleles where the ref allele is not the major allele flip = n_majors < (n + 1) // 2 n_majors[flip] = n - n_majors[flip] major_alleles[flip] = alt_allele return major_alleles, n_majors, m def _parse_variant(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> List[SiteConfig]: """""" Parse a VCF variant. We only consider sites that are at most bi-allelic in the in- and outgroups. :param variant: The variant. :return: List of site configurations containing a single element if subsample_mode is ``random`` or multiple elements if subsample_mode is ``probabilistic`` or ``None`` if the site is not valid. :raises _TooFewIngroupsSiteError: If there are too few ingroups to consider a site for ancestral allele annotation. _PolyAllelicSiteError: If a site has more than two alleles. """""" # get the called ingroup bases ingroups = get_called_bases(variant.gt_bases[self._ingroup_mask]) # get the numer of called ingroup and outgroup bases n_ingroups = len(ingroups) # make sure we have enough ingroups if n_ingroups < self.n_ingroups: raise _TooFewIngroupsSiteError() # get the called outgroup bases # the order does not matter here outgroups = get_called_bases(variant.gt_bases[self._outgroup_mask]) # get total base counts counts = Counter(np.concatenate((ingroups, outgroups))) # make sure we have at most two alleles if len(counts) > 2: raise _PolyAllelicSiteError() # get the bases b: List[str] = list(counts.keys()) # subsample ingroups either randomly or probabilistically major_alleles, n_majors, multiplicities = self._subsample_site( mode=self.subsample_mode, n=self.n_ingroups, samples=ingroups, rng=self.rng ) # Get the outgroup bases. # The outgroup order is important, so we can't use the mask here. outgroup_bases = self.get_base_index(self._get_outgroup_bases( genotypes=np.array([variant.gt_bases[i] for i in self._outgroup_indices]), n_outgroups=self.n_outgroups )) # create site configurations sites = [] for i, (major_allele, n_major, multiplicity) in enumerate(zip(major_alleles, n_majors, multiplicities)): if multiplicity > 0: if len(counts) == 2: # Take the other allele as the minor allele. We keep track of the minor allele # even if it wasn't contained in the ingroup subsample. minor_base: str = b[0] if b[0] != major_allele else b[1] else: minor_base: str = '.' # create site configuration site = SiteConfig( major_base=base_indices[major_allele], n_major=n_major, minor_base=self.get_base_index(minor_base), outgroup_bases=outgroup_bases, multiplicity=multiplicity ) sites.append(site) return sites @staticmethod def get_base_string(indices: int | np.ndarray) -> str | np.ndarray: """""" Get base string(s) from base index/indices. :param indices: The base index/indices. :return: Base string(s). """""" if isinstance(indices, np.ndarray): if len(indices) == 0: return np.array([]) is_valid = indices != -1 base_strings = np.full(indices.shape, '.', dtype=str) base_strings[is_valid] = bases[indices[is_valid]] return base_strings # assume integer if indices != -1: return bases[indices] return '.' @classmethod def get_base_index(cls, base_string: str | np.ndarray) -> int | np.ndarray: """""" Get base index/indices from base string(s). :param base_string: The base string(s). :return: Base index/indices. """""" if isinstance(base_string, np.ndarray): return np.array([cls.get_base_index(b) for b in base_string], dtype=int) # assume string if base_string in bases: return base_indices[base_string] return -1 class MaximumLikelihoodAncestralAnnotation(_OutgroupAncestralAlleleAnnotation): """""" Annotation of ancestral alleles following the probabilistic model of EST-SFS (https://doi.org/10.1534/genetics.118.301120). Note that only bi-allelic SNPs are supported by this model. By default, the info field ``AA`` (see :attr:`Annotator.info_ancestral`) is added to the VCF file, which holds the ancestral allele. To be used with :class:`Annotator` or :class:`~fastdfe.parser.Parser`. The info field ``AA_prob`` holds the probability that the predicted ancestral allele (``AA`` tag) is correct, as opposed to the other allele. This probability can be also be used by :class:`~fastdfe.parser.Parser` to polarize the SFS according to the ancestral allele probability. In addition to the ancestral allele, the info field ``AA_info`` is added, which contains additional information about the ancestral allele (see :class:`SiteInfo` for an overview of the available information). This class can also be used independently, see the :meth:`from_dataframe`, :meth:`from_data` and :meth:`from_est_sfs` methods. Initially, the branch rates are determined using MLE. Similar to :class:`Parser`, we can also specify the number of mutational target sites (see the ``n_target_sites`` argument) in case our VCF file does not contain the full set of monomorphic sites. This is necessary to obtain realistic branch rate estimates. You can also choose a prior for the polarization probabilities (see :class:`PolarizationPrior`). Eventually, for every site, the probability that the major allele is ancestral is calculated. When annotating the variants of a VCF file, we check the most likely ancestral allele against a naive ad-hoc ancestral allele annotation, and record the sites for which we have disagreement. You might want to sanity-check the mismatches to make sure the model has been properly specified (see :attr:`mismatches`). .. note:: * The polarization prior corresponds to the Kingman coalescent probability by default. Using an adaptive prior, as in the EST-SFS paper, is also possible, but this is only recommended if the number of sites used for the inference is large (see :attr:`prior`). * The model can only handle sites that have at most 2 alleles across the in- and outgroups, so sites with more than 2 alleles are ignored. Only variants that are at most bi-allelic in the provided in- and outgroups are annotated. * The model determines the probability of the major allele being ancestral opposed to the minor allele. This can be problematic if the actual ancestral allele is not contained in the ingroup (possibly due to subsampling). To avoid this issue, we also keep track of potential minor alleles at frequency 0. If we were to ignore this, it would be impossible to infer divergence, i.e. fixed derived allele that are no longer observed in the ingroups (see :attr:`PolarizationPrior.allow_divergence`). That said, divergence counts are not informative on DFE inference with fastDFE and allow_divergence should not be set to ``True`` if interested in the SFS. * The model assumes a single coalescent topology for all sites, in which all outgroups coalesce first with the ingroup and not with each other. It is important to specify the outgroups in order of increasing divergence and not to select outgroups that are not much more closely related to each other than to the ingroup (as this would give rise to a different coalescent topology than the one assumed). You can call :meth:`get_outgroup_divergence` after the inference to check the estimated branch rates for each outgroup. The assumption of a single fixed topology should be good enough provided that in- and outgroups are sufficiently diverged. Example usage: :: import fastdfe as fd ann = fd.Annotator( vcf=""https://github.com/Sendrowski/fastDFE/"" ""blob/dev/resources/genome/betula/all."" ""with_outgroups.subset.10000.vcf.gz?raw=true"", annotations=[fd.MaximumLikelihoodAncestralAnnotation( outgroups=[""ERR2103730""], n_ingroups=15 )], output=""genome.polarized.vcf.gz"" ) ann.annotate() """""" #: The data types for the data frame _dtypes = dict( n_major=np.int8, multiplicity=np.float64, sites=object, major_base=np.int8, minor_base=np.int8, outgroup_bases=object, p_major_ancestral=np.float64, p_minor=np.float64, p_major=np.float64 ) #: The columns to group by. _group_cols = ['major_base', 'minor_base', 'outgroup_bases', 'n_major'] def __init__( self, outgroups: List[str], n_ingroups: int = 11, ingroups: List[str] | None = None, exclude: List[str] | None = None, n_runs: int = 10, model: SubstitutionModel = None, parallelize: bool = True, prior: PolarizationPrior | None = '', max_sites: int = 10000, seed: int | None = 0, confidence_threshold: float = 0, n_target_sites: int | None = None, n_samples_target_sites: int | None = 100000, adjust_target_sites: bool = True, subsample_mode: Literal['random', 'probabilistic'] = 'probabilistic' ): """""" Create a new ancestral allele annotation instance. :param outgroups: The outgroup samples to consider when determining the ancestral allele in the order of increasing divergence. A list of sample names as they appear in the VCF file. The order of the outgroups is important as it determines the order of the branches in the tree, whose rates are optimized, and whose topology is predetermined. The first outgroup is the closest outgroup to the ingroups, and the last outgroup is the most distant outgroup. More outgroups lead to a more accurate inference of the ancestral allele, but also increase the computational cost. Using more than 1 outgroup is recommended, but more than 3 is likely not necessary. Sites where these outgroups are not present are not included when optimizing the rate parameters. Due to assumptions on the tree topology connecting the in- and outgroups, it is important that the outgroups are not much more closely related to each other than to the ingroups. Ideally, the optimized branch rates are show markedly different values, and in any case, they should be monotonically increasing with the outgroups (see :meth:`get_outgroup_divergence`). :param n_ingroups: The minimum number of ingroups that must be present at a site for it to be considered for ancestral allele inference. The ingroup subsampling is necessary since our model requires an equal number of ingroups for all sites. Note that a larger number of ingroups does not necessarily improve the accuracy of the ancestral allele inference (see ``prior``). A larger number of ingroups can lead to a large variance in the polarization probabilities, across different frequency counts. ``n_ingroups`` should thus only be large if the number of sites used for the inference is also large. A sensible value for a reasonably large number of sites (a few thousand) is 10 or perhaps 20 for a larger numbers of sites. Very small values can lead to the ingroup subsamples not being representative of the actual allele frequencies at a site, especially when not using probabilistic subsampling (see ``subsample_mode``). This value also influences the number of frequency bins used for the polarization probabilities, and should thus not be too small. Note that if ``ingroups`` is an even number, the major allele is chosen arbitrarily if the number of major alleles is equal to the number of minor alleles. To avoid this, you can use an odd number of ingroups. :param ingroups: The ingroup samples to consider when determining the ancestral allele. If ``None``, all (non-outgroup) samples are considered. A list of sample names as they appear in the VCF file. Has to be at least as large as ``n_ingroups``. :param exclude: Samples to exclude from the ingroup. A list of sample names as they appear in the VCF file. :param n_runs: The number of optimization runs to perform when determining the branch rates. You can check that the likelihoods of the different runs are similar by calling :meth:`plot_likelihoods`. :param model: The substitution model to use. By default, :class:`K2SubstitutionModel` is used. :param parallelize: Whether to parallelize the computation across multiple cores. :param prior: The prior to use for the polarization probabilities. See :class:`KingmanPolarizationPrior` and :class:`AdaptivePolarizationPrior` for more information. By default, :class:`KingmanPolarizationPrior` is used. Use ``''`` for no prior. :param max_sites: The maximum number of sites to consider. This is useful if the number of sites is very large. Choosing a reasonably large subset of sites (on the order of a few thousand bi-allelic sites) can speed up the computation considerably as parsing can be slow. This subset is then used to calibrate the rate parameters, and possibly the polarization priors. :param seed: The seed for the random number generator. If ``None``, a random seed is chosen. By default, the seed is set to 0. :param confidence_threshold: The confidence threshold for the ancestral allele annotation. Only if the probability of the major allele being ancestral as opposed to the minor allele is not within ``((1 - confidence_threshold) / 2, 1 - (1 - confidence_threshold) / 2)``, the ancestral allele is annotated. This is useful to avoid annotating sites where the ancestral allele state is not clear. Use values close to ``0`` to annotate as many sites as possible, and values close to ``1`` to annotate only sites where the ancestral allele state is very clear. .. warning:: This threshold introduces a bias by excluding more sites with high-frequency derived alleles and should thus be kept at ``0`` if the distribution of frequency counts is important, e.g., if the SFS is to be determined. :param n_target_sites: The total number of target sites if this class is used in conjunction with :class:`Parser` or :class:`Annotator`. This is useful if the provided set of sites only consists of bi-allelic sites. Specify here the total number of sites underlying the given dataset, i.e., both mono- and bi-allelic sites. Ignoring mono-allelic sites will lead to overestimation of the rate parameters. For this to work, a FASTA file must be provided from which the mono-allelic sites can be sampled. Sampling takes place between the variants of the last and first site on every contig considered in the VCF file. Use ``None`` to disable this feature. Note that the number of target sites is automatically carried over if not specified and this class is used together with :class:`Parser`. In order to use this feature, you also need to specify a FASTA file to :class:`Parser` or :class:`Annotator`. Also note that by default we extrapolate the number of mono-allelic sites to be sampled from the FASTA file based on the ratio of sites with called outgroup bases parsed from the VCF file (``adjust_target_sites``). :param n_samples_target_sites: The number of sites to sample from the FASTA file when determining the number of target sites (``n_target_sites``). From this the total number of target sites is extrapolated. :param adjust_target_sites: Whether to adjust the number of target sites based on the parsed VCF sites relative to the total number of sites in the VCF. Defaults to ``True``. :param subsample_mode: The subsampling mode. For ``random``, we draw once without replacement from the set of all available ingroup genotypes per site. For ``probabilistic``, we integrate over the hypergeometric distribution when parsing and computing the ancestral probabilities. Probabilistic subsampling requires a bit more time, but produces much more stable results, while requiring far fewer sites, so it is highly recommended. """""" super().__init__( ingroups=ingroups, exclude=exclude, outgroups=outgroups, n_ingroups=n_ingroups, seed=seed, subsample_mode=subsample_mode ) # check that we have at least one outgroup if len(outgroups) < 1: raise ValueError(""Must specify at least one outgroup. If you do not have any outgroup "" ""information, consider using MaximumParsimonyAncestralAnnotation instead."") # check that we have enough ingroups specified if specified at all if ingroups is not None and len(ingroups) * 2 < n_ingroups: self._logger.warning(""The number of specified ingroup samples is smaller than the "" ""number of ingroups (assumed diploidy). Please make sure to "" ""provide sufficiently many ingroups."") # raise warning on bias if confidence_threshold > 0: self._logger.warning(""Please be aware that a confidence threshold of greater than 0 biases the SFS "" ""towards fewer high-frequency derived alleles."") #: Whether to parallelize the computation. self.parallelize: bool = parallelize #: Maximum number of sites to consider self.max_sites: int = max_sites #: The confidence threshold for the ancestral allele annotation. self.confidence_threshold: float = confidence_threshold #: The prior to use for the polarization probabilities. self.prior: PolarizationPrior | None = KingmanPolarizationPrior() if prior == '' else prior #: Number of random ML starts when determining the rate parameters self.n_runs: int = int(n_runs) #: The substitution model. self.model: SubstitutionModel = K2SubstitutionModel() if model is None else model #: The VCF reader. self._reader: 'cyvcf2.VCF' | None = None #: The data frame holding all site configurations. self.configs: pd.DataFrame | None = None #: The probability of all sites per frequency bin. self.p_bins: Dict[str, np.ndarray | None] = None #: The total number of valid sites parsed (including sites not considered for ancestral allele inference). self.n_sites: int | None = None #: The parameter names in the order they are passed to the optimizer. self.param_names: List[str] = list(self.model.get_bounds(self.n_outgroups).keys()) #: The log likelihoods for the different runs when optimizing the rate parameters. self.likelihoods: np.ndarray | None = None #: The best log likelihood when optimizing the rate parameters. self.likelihood: float | None = None #: Optimization result of the best run. self.result: Optional['scipy.optimize.OptimizeResult'] = None #: The MLE parameters. self.params_mle: Dict[str, float] | None = None #: The MLE parameters for all runs. self.params_mle_runs: pd.DataFrame | None = None #: Mismatches between the most likely ancestral allele and the ad-hoc ancestral allele. # This is only computed when annotating a VCF file, and only contains the mismatches # for sites that were actually annotated. self.mismatches: List[SiteInfo] = [] #: The total number of target sites. self.n_target_sites: int | None = n_target_sites #: The number of sites to sample from the FASTA file when determining the number of target sites. self.n_samples_target_sites: int = n_samples_target_sites #: Whether to adjust the number of target sites based on the number of sites parsed from the VCF file. self.adjust_target_sites: bool = adjust_target_sites #: The monomorphic site counts sampled from the FASTA file. self._monomorphic_samples: Dict[str, int] = {'A': 0, 'C': 0, 'G': 0, 'T': 0} def _setup(self, handler: MultiHandler): """""" Parse the VCF file and perform the optimization. :param handler: The handler. """""" from .parser import Parser, TargetSiteCounter super()._setup(handler) # try to carry over n_target_sites and fasta file from Parser if isinstance(handler, Parser) and isinstance(handler.target_site_counter, TargetSiteCounter): if self.n_target_sites is None: self.n_target_sites = handler.target_site_counter.n_target_sites self._logger.debug(f""Using n_target_sites={self.n_target_sites} from Parser."") if self.n_target_sites is not None: # check that we have a fasta file if we sample mono-allelic sites handler._require_fasta(self.__class__.__name__) # load data self._parse_vcf() # sample mono-allelic sites if necessary if self.n_target_sites is not None: self._sample_mono_allelic_sites() # notify on statistics self._log_stats() # set up substitution model self.model._setup(self) # infer ancestral alleles self.infer() def _log_stats(self): """""" Log statistics about the ancestral allele annotation. """""" configs = self._get_mle_configs() n_sites = int(np.round(configs.multiplicity.sum())) n_monomorphic = int(np.round(configs[configs.minor_base == -1].multiplicity.sum())) n_polymorphic = n_sites - n_monomorphic self._logger.info( f""Included {n_sites} sites for the inference ({n_polymorphic} polymorphic, {n_monomorphic} monomorphic)."" ) def _get_n_target_sites_adjusted(self) -> int: """""" Get the number of target sites adjusted by the number of sites parsed. This assumed that the sites have not been sampled yet. """""" if self.adjust_target_sites: ratio = self._get_mle_configs().multiplicity.sum() / self.n_sites else: ratio = 1 return int(ratio * (self.n_target_sites - self.n_sites)) def _get_n_sites(self) -> int: """""" Get the number of sites to consider. """""" return int(self.configs.multiplicity.sum()) def _sample_mono_allelic_sites(self): """""" Sample mono-allelic sites from the FASTA file. """""" # inform self._logger.info(f""Sampling mono-allelic sites."") if self.n_target_sites < self.n_sites: raise ValueError(f""The number of target sites ({self.n_target_sites}) must be at least "" f""as large as the number of sites parsed ({self.n_sites})."") # check that we have enough sites to sample if self.n_samples_target_sites <= 0 or len(self._contig_bounds) == 0: self._logger.info(""No mono-allelic sites to sample, skipping."") return # initialize progress bar pbar = tqdm( total=self.n_samples_target_sites, desc=f'{self.__class__.__name__}>Sampling mono-allelic sites', disable=Settings.disable_pbar ) # get array of ranges per contig of parsed variants ranges = np.array(list(self._contig_bounds.values())) # get range sizes range_sizes = ranges[:, 1] - ranges[:, 0] # determine sampling probabilities probs = range_sizes / np.sum(range_sizes) # sample number of sites per contig sample_counts = self.rng.multinomial(self.n_samples_target_sites, probs) # sampled bases samples = dict(A=0, C=0, G=0, T=0) # iterate over contigs for contig, bounds, n in zip(self._contig_bounds.keys(), ranges, sample_counts): # get aliases aliases = self._handler.get_aliases(contig) # make sure we have a valid range if bounds[1] > bounds[0] and n > 0: self._logger.debug(f""Sampling {n} sites from contig '{contig}'."") # fetch contig record = self._handler.get_contig(aliases, notify=False) # sample sites i = 0 while i < n: pos = self.rng.integers(*bounds) base = record.seq[pos - 1] if base in bases: # increase counters samples[base] += 1 i += 1 pbar.update() # close progress bar pbar.close() # rewind fasta iterator FASTAHandler._rewind(self._handler) n_target_sites = self._get_n_target_sites_adjusted() if self.adjust_target_sites: self._logger.info(f""Extrapolating to {n_target_sites} mutational target sites "" f""based on the number of sites parsed."") else: self._logger.info(f""Extrapolating to {self.n_target_sites} mutational target sites."") # ratio for extrapolating to the total number of target sites ratio = n_target_sites / self.n_samples_target_sites # extrapolate the number of monomorphic sites vec = np.array([samples[k] for k in bases], dtype=float) scaled = vec * ratio floors = np.floor(scaled).astype(int) remainder = n_target_sites - int(floors.sum()) if remainder > 0: order = np.argsort(scaled - floors)[::-1] floors[order[:remainder]] += 1 self._monomorphic_samples = {k: int(v) for k, v in zip(bases, floors)} # add monomorphic site counts to data frame self.configs = self._add_monomorphic_sites(self._monomorphic_samples) # update number of sites self.n_sites = self._get_n_sites() def _add_monomorphic_sites(self, samples: Dict[str, int]): """""" Add monomorphic sites to the data frame holding the site configurations. :param samples: The samples. :return: The data frame. """""" # get indices for new sites sites = np.concatenate(([self.n_sites], self.n_sites + np.cumsum(list(samples.values())))) # construct data frame of new sites df = pd.DataFrame(dict( n_major=self.n_ingroups, major_base=base_indices[base], minor_base=-1, outgroup_bases=(base_indices[base],) * self.n_outgroups, multiplicity=count, sites=list(range(sites[i], sites[i + 1])), n_outgroups=self.n_outgroups ) for i, (base, count) in enumerate(samples.items())) # add to data frame configs = pd.concat((self.configs, df)) # aggregate return configs.groupby(self._group_cols + ['n_outgroups'], as_index=False, dropna=False).sum() def _teardown(self): """""" Teardown the annotation. """""" super()._teardown() # inform on mismatches self._logger.info(f""There were {len(self.mismatches)} mismatches between the most likely "" f""ancestral allele and the ad-hoc ancestral allele annotation."") @classmethod def _parse_est_sfs(cls, data: pd.DataFrame) -> pd.DataFrame: """""" Parse EST-SFS data. :param data: The data frame. :return: The site configurations. """""" # extract the number of outgroups n_outgroups = data.shape[1] - 1 # retain site index data['sites'] = data.index data['sites'] = data.sites.apply(lambda x: [x]) # the first column contains the ingroup counts, split them ingroup_data = data[0].str.split(',', expand=True).astype(np.int8).to_numpy() # determine the number of major alleles per site data['n_major'] = ingroup_data.max(axis=1) # sort by the number of alleles data_sorted = ingroup_data.argsort(axis=1) # determine the number of major alleles per site data['major_base'] = data_sorted[:, -1] data['major_base'] = data.major_base.astype(cls._dtypes['major_base']) # determine the mono-allelic sites poly_allelic = (ingroup_data > 0).sum(axis=1) > 1 # determine the minor alleles minor_bases = np.full(data.shape[0], -1, dtype=np.int8) minor_bases[poly_allelic] = data_sorted[:, -2][poly_allelic] # assign the minor alleles data['minor_base'] = minor_bases # extract outgroup data outgroup_data = np.full((data.shape[0], n_outgroups), -1, dtype=np.int8) for i in range(n_outgroups): # get the genotypes genotypes = data[i + 1].str.split(',', expand=True).astype(np.int8).to_numpy() # determine whether the site has an outgroup has_outgroup = genotypes.sum(axis=1) > 0 # determine the outgroup allele indices provided the site has an outgroup outgroup_data[has_outgroup, i] = genotypes[has_outgroup].argmax(axis=1) # assign the outgroup data, convert to tuples for hashing data['outgroup_bases'] = [tuple(row) for row in outgroup_data] # return new columns only return data.drop(range(n_outgroups + 1), axis=1) @classmethod def from_est_sfs( cls, file: str, prior: PolarizationPrior | None = '', n_runs: int = 10, model: SubstitutionModel = None, parallelize: bool = True, seed: int = 0, chunk_size: int = 100000 ) -> 'MaximumLikelihoodAncestralAnnotation': """""" Create instance from EST-SFS input file. :param file: File containing EST-SFS-formatted input data. :param prior: The prior to use for the polarization probabilities (see :meth:`__init__`). :param n_runs: Number of runs for rate estimation (see :meth:`__init__`). :param model: The substitution model (see :meth:`__init__`). :param parallelize: Whether to parallelize the runs (see :meth:`__init__`). :param seed: The seed to use for the random number generator. :param chunk_size: The chunk size for reading the file. :return: The instance. """""" # define an empty dataframe to accumulate the data data = None n_ingroups = 0 # iterate over the file in chunks for i, chunk in enumerate(pd.read_csv(file, sep=r""\s+"", header=None, dtype=str, chunksize=chunk_size)): # determine the number of ingroups n_ingroups = np.max(np.array(chunk.iloc[0, 0].split(','), dtype=int)) # parse the data parsed = cls._parse_est_sfs(chunk) if data is None: # parse the data data = parsed else: # concatenate with previous data if available data = pd.concat([data, parsed]) data = data.groupby(cls._group_cols, as_index=False, dropna=False).sum() # check if there is data if data is None: raise ValueError(""No data found."") # determine the multiplicity data['multiplicity'] = data['sites'].apply(lambda x: len(x)) # create from dataframe return cls.from_dataframe( data=data, n_runs=n_runs, model=model, parallelize=parallelize, prior=prior, n_ingroups=n_ingroups, grouped=True, seed=seed ) def to_est_sfs(self, file: str): """""" Write the object's state to an EST-SFS formatted file. :param file: The output file name. """""" # get config indices for each site indices = self._get_site_indices() # remove sites that are not included indices = indices[indices != -1] # get the sites sites = self.configs.iloc[indices] with open(file, 'w') as f: # iterate over rows for i, site in sites.iterrows(): # ingroup counts ingroups = np.zeros(4, dtype=int) # major allele count ingroups[site['major_base']] = site['n_major'] # minor allele count if not mono-allelic if site['minor_base'] != -1: ingroups[site['minor_base']] = self.n_ingroups - site['n_major'] # write ingroup counts outgroups = np.zeros((self.n_outgroups, 4), dtype=int) # fill outgroup counts for j, base in enumerate(site['outgroup_bases']): if base != -1: outgroups[j, base] = 1 # write line f.write( ','.join(ingroups.astype(str)) + '\t' + '\t'.join([','.join(o) for o in outgroups.astype(str)]) + '\n' ) # break if we reached the maximum number of sites if i + 1 >= self.max_sites: break def to_file(self, file: str): """""" Save object to file. .. note:: References to the handler and the reader are discarded. :param file: File path. """""" with open(file, 'w') as fh: fh.write(self.to_json()) @classmethod def from_file(cls, file: str) -> 'MaximumLikelihoodAncestralAnnotation': """""" Load object from file. .. note:: The handler and the reader are not restored, so serialization is mostly useful for analyzing the results in detail, not for further processing. :param file: File path. :return: The object. """""" with open(file, 'r') as fh: return cls.from_json(fh.read()) def to_json(self) -> str: """""" Serialize object. .. note:: References to the handler and the reader are discarded. :return: JSON string """""" self._reader = None self._handler = None return jsonpickle.encode(self, indent=4, warn=True) @classmethod def from_json(cls, json: str) -> 'MaximumLikelihoodAncestralAnnotation': """""" Load object from file. .. note:: The handler and the reader are not restored, so serialization is mostly useful for analyzing the results in detail, not for further processing. :param json: JSON string. :return: The object. """""" anc = jsonpickle.decode(json) # convert index to int if necessary if 'index' in anc.configs: anc.configs.index = anc.configs.index.astype(int) return anc @classmethod def from_data( cls, n_major: Iterable[int], major_base: Iterable[str | int], minor_base: Iterable[str | int], outgroup_bases: Iterable[Iterable[str | int]], n_ingroups: int, n_runs: int = 10, model: SubstitutionModel = None, parallelize: bool = True, prior: PolarizationPrior | None = '', seed: int = 0, pass_indices: bool = False, confidence_threshold: float = 0 ) -> 'MaximumLikelihoodAncestralAnnotation': """""" Create an instance by passing the data directly. :param n_major: The number of major alleles per site. Note that this number has to be lower than ``n_ingroups``, as we consider the number of major alleles of subsamples of size ``n_ingroups``. :param major_base: The major allele per site. A string representation of the base or the base index according to ``['A', 'C', 'G', 'T']`` if ``pass_indices`` is ``True``. Use ``None`` if the base is not defined when ``pass_indices`` is ``False`` and ``-1`` when ``pass_indices`` is ``True``. :param minor_base: The minor allele per site. A string representation of the base or the base index according to ``['A', 'C', 'G', 'T']`` if ``pass_indices`` is ``True``. Use ``None`` if the base is not defined when ``pass_indices`` is ``False`` and ``-1`` when ``pass_indices`` is ``True``. :param outgroup_bases: The outgroup alleles per site. A string representation of the base or the base index if ``pass_indices`` is ``True``. This should be a list of lists, where the outer list corresponds to the sites and the inner list to the outgroups per site. All sites are required to have the same number of outgroups. Use ``None`` if the base is not defined when ``pass_indices`` is ``False`` and ``-1`` when ``pass_indices`` is ``True``. :param n_ingroups: The number of ingroup samples (see :meth:`__init__`). :param n_runs: The number of runs for rate estimation (see :meth:`__init__`). :param model: The substitution model (see :meth:`__init__`). :param parallelize: Whether to parallelize the runs. :param prior: The prior to use for the polarization probabilities (see :meth:`__init__`). :param seed: The seed for the random number generator. :param pass_indices: Whether to pass the base indices instead of the bases. :param confidence_threshold: The confidence threshold for the ancestral allele annotation (see :meth:`__init__`). :return: The instance. """""" # convert to numpy arrays n_major = np.array(list(n_major), dtype=np.int8) # make sure that the number of major alleles is not larger than the number of ingroups if np.any(n_major > n_ingroups): raise ValueError(""Major allele counts cannot be larger than the number of ingroups."") # convert to base indices if not pass_indices: major_base = cls.get_base_index(np.array(list(major_base))) minor_base = cls.get_base_index(np.array(list(minor_base))) outgroup_bases = cls.get_base_index(np.array(list(outgroup_bases))).reshape(len(major_base), -1) # create data frame data = pd.DataFrame({ 'n_major': n_major, 'major_base': major_base, 'minor_base': minor_base, 'outgroup_bases': list(outgroup_bases) }) # create from dataframe return cls.from_dataframe( data=data, n_runs=n_runs, model=model, parallelize=parallelize, prior=prior, n_ingroups=n_ingroups, seed=seed, confidence_threshold=confidence_threshold ) @classmethod def _from_vcf( cls, file: str, outgroups: List[str], n_ingroups: int, ingroups: List[str] = None, exclude: List[str] = None, n_runs: int = 10, model: SubstitutionModel = K2SubstitutionModel(), parallelize: bool = True, prior: PolarizationPrior | None = KingmanPolarizationPrior(), max_sites: int = np.inf, seed: int | None = 0, confidence_threshold: float = 0, subsample_mode: Literal['random', 'probabilistic'] = 'probabilistic' ) -> 'MaximumLikelihoodAncestralAnnotation': """""" Create an instance from a VCF file. In most cases, it is recommended to use the :class:`Annotator` or :class:`~fastdfe.parser.Parser` classes instead. :param file: The VCF file. :param outgroups: Same as in :meth:`__init__`. :param n_ingroups: Same as in :meth:`__init__`. :param ingroups: Same as in :meth:`__init__`. :param exclude: Same as in :meth:`__init__`. :param n_runs: Same as in :meth:`__init__`. :param model: Same as in :meth:`__init__`. :param parallelize: Same as in :meth:`__init__`. :param prior: Same as in :meth:`__init__`. :param max_sites: Same as in :meth:`__init__`. :param seed: Same as in :meth:`__init__`. :param confidence_threshold: Same as in :meth:`__init__`. :param subsample_mode: Same as in :meth:`__init__`. :return: The instance. """""" # create instance anc = MaximumLikelihoodAncestralAnnotation( outgroups=outgroups, n_ingroups=n_ingroups, ingroups=ingroups, exclude=exclude, n_runs=n_runs, model=model, parallelize=parallelize, prior=prior, max_sites=max_sites, seed=seed, confidence_threshold=confidence_threshold, subsample_mode=subsample_mode ) # set up the handler super(cls, anc)._setup(MultiHandler( vcf=file, max_sites=max_sites, seed=seed )) # parse the variants anc._parse_vcf() return anc @classmethod def from_dataframe( cls, data: pd.DataFrame, n_ingroups: int, n_runs: int = 10, model: SubstitutionModel = None, parallelize: bool = True, prior: PolarizationPrior | None = '', seed: int = 0, grouped: bool = False, confidence_threshold: float = 0 ) -> 'MaximumLikelihoodAncestralAnnotation': """""" Create an instance from a dataframe. :param data: Dataframe with the columns: ``major_base``, ``minor_base``, ``outgroup_bases``, ``n_major`` of type ``int``, ``int``, ``list`` and ``int``, respectively. The outgroup bases should have the same length for every site. :param n_ingroups: The number of ingroups (see :meth:`__init__`). :param n_runs: Number of runs for rate estimation (see :meth:`__init__`). :param model: The substitution model (see :meth:`__init__`). :param parallelize: Whether to parallelize computations. :param prior: The prior to use for the polarization probabilities (see :meth:`__init__`). :param seed: The seed for the random number generator. If ``None``, a random seed is chosen. :param grouped: Whether the dataframe is already grouped by all columns (used for internal purposes). :param confidence_threshold: The confidence threshold for the ancestral allele annotation (see :meth:`__init__`). :return: The instance. """""" # check if dataframe is empty if data.empty: raise ValueError(""Empty dataframe."") if not grouped: # only keep the columns that are needed data = data[cls._group_cols] # disable chained assignment warning with pd.option_context('mode.chained_assignment', None): # retain site index data['sites'] = data.index # convert outgroup bases to tuples data['outgroup_bases'] = data['outgroup_bases'].apply(tuple) # group by all columns in the chunk and keep track of the site indices data = data.groupby(cls._group_cols, as_index=False, dropna=False).agg(list).reset_index(drop=True) # determine the multiplicity data['multiplicity'] = data['sites'].apply(lambda x: len(x)) # add missing columns with NA as default value for col in cls._dtypes: if col not in data.columns: data[col] = None # convert to the correct dtypes data = data.astype(cls._dtypes) # determine the number of outgroups data['n_outgroups'] = np.sum(np.array(data.outgroup_bases.to_list()) != -1, axis=1) # determine the number of outgroups n_outgroups = data.n_outgroups.max() anc = MaximumLikelihoodAncestralAnnotation( n_runs=n_runs, model=model, parallelize=parallelize, prior=prior, outgroups=[str(i) for i in range(n_outgroups)], # pseudo names for outgroups ingroups=[str(i) for i in range(n_ingroups)], # pseudo names for ingroups n_ingroups=n_ingroups, seed=seed, confidence_threshold=confidence_threshold, subsample_mode='random' ) # assign data frame anc.configs = data # convert outgroup bases to tuples of native integers anc._convert_outgroup_bases_to_native_types() # set the number of sites (which coincides with number of sites parsed) anc.n_sites = anc._get_n_sites() # notify on statistics anc._log_stats() # set up substitution model anc.model._setup(anc) return anc def _convert_outgroup_bases_to_native_types(self): """""" Convert outgroup bases to tuples of native integers numpy types cause problems when serializing """""" self.configs.outgroup_bases = self.configs.outgroup_bases.apply(lambda x: tuple(int(i) for i in x)) def _parse_vcf(self): """""" Parse variants from VCF file. """""" # initialize data frame self.configs = pd.DataFrame(columns=list(self._dtypes.keys())) self.configs.astype(self._dtypes) # columns to use as index index_cols = ['major_base', 'minor_base', 'outgroup_bases', 'n_major'] # set index to initial site configuration self.configs.set_index(keys=index_cols, inplace=True) # determine the total number of sites to be parsed total = min(self._handler.n_sites, self.max_sites) # initialize counter in case we do not parse any sites i = -1 # create progress bar with self._handler.get_pbar(desc=f""{self.__class__.__name__}>Parsing sites"", total=total) as pbar: # iterate over sites for i, variant in enumerate(self._reader): # parse the site try: configs = self._parse_variant(variant) except (_PolyAllelicSiteError, _TooFewIngroupsSiteError): pass else: if self.n_target_sites is not None: # update bounds low, high = self._contig_bounds[variant.CHROM] self._contig_bounds[variant.CHROM] = (min(low, variant.POS), max(high, variant.POS)) for config in configs: index = ( config.major_base, config.minor_base, tuple(config.outgroup_bases), config.n_major ) if index in self.configs.index: # get the site data site_data = self.configs.loc[index].to_dict() # update the site data site_data['multiplicity'] += config.multiplicity site_data['sites'] += [i] # update the site data # Note that there were problems updating the data frame directly self.configs.loc[index] = site_data else: self.configs.loc[index] = config.__dict__ | {'sites': [i]} pbar.update() # explicitly stopping after ``n`` sites fixes a bug with cyvcf2: # 'error parsing variant with `htslib::bcf_read` error-code: 0 and ret: -2' if i + 1 == self._handler.n_sites or i + 1 == self._handler.max_sites or i + 1 == self.max_sites: break # reset the index self.configs.reset_index(inplace=True, names=index_cols) # create column for number of outgroups self.configs['n_outgroups'] = None if len(self.configs) > 0: # determine number of outgroups self.configs['n_outgroups'] = np.sum(np.array(self.configs.outgroup_bases.to_list()) != -1, axis=1) # convert outgroup bases to tuples of native integers self._convert_outgroup_bases_to_native_types() # total number of sites considered self.n_sites = i + 1 def infer(self): """""" Infer the ancestral allele probabilities for the data provided. This method is only supposed to be called manually if the data is provided directly, e.g. using :meth:`from_data`, :meth:`from_dataframe` or :meth:`from_est_sfs`. If the data is provided using a VCF file, this method is called automatically. """""" from scipy.optimize import minimize, OptimizeResult # get the bounds bounds = self.model.get_bounds(self.n_outgroups) # get the likelihood function # this will raise an error if no data is available fun = self._get_likelihood() # log warning if unusually low number of monomorphic sites if self.configs[self.configs.minor_base == -1].multiplicity.sum() / self.n_sites < 0.75: self._logger.warning(""The number of monomorphic sites is unusually low. Please note that "" ""including monomorphic sites is necessary to obtain realistic "" ""branch rate estimates."") if self.n_target_sites is None: self._logger.warning(""If your dataset does not contain any monomorphic sites, consider "" ""using the `n_target_sites` argument."") def optimize_rates(x0: Dict[str, float]) -> OptimizeResult: """""" Optimize the likelihood function for a single run. :param x0: The initial values. :return: The optimization results. """""" # optimize using scipy return minimize( fun=fun, x0=np.array(list(x0.values())), bounds=list(bounds.values()), method=""L-BFGS-B"" ) # run the optimization in parallel results = parallelize_func( func=optimize_rates, data=[self.model.get_x0(bounds, self.rng) for _ in range(self.n_runs)], parallelize=self.parallelize, pbar=True, desc=f""{self.__class__.__name__}>Optimizing rates"", dtype=object ) # get the likelihoods for each run self.likelihoods = -np.array([result.fun for result in results]) # get the best likelihood self.likelihood = np.max(self.likelihoods) # get the MLE parameters for each run self.params_mle_runs = pd.DataFrame([result.x for result in results], columns=self.param_names) # get the best result self.result: OptimizeResult = cast(OptimizeResult, results[np.argmax(self.likelihoods)]) # check if the optimization was successful if not self.result.success: raise RuntimeError(f""Optimization failed with message: {self.result.message}"") # get dictionary of MLE parameters self.params_mle = dict(zip(self.param_names, self.result.x)) # check if the MLE parameters are near the bounds near_lower, near_upper = check_bounds( params=self.params_mle, bounds=bounds, scale='log', fixed_params=self.model.fixed_params ) # warn if the MLE parameters are near the bounds if len(near_lower | near_upper) > 0: self._logger.warning(f'The MLE estimate for the rates is near the upper bound for ' f'{near_upper} and lower bound for {near_lower}. (The tuples denote ' f'(lower, value, upper) for every parameter.)') # check if the outgroup divergence is monotonically increasing if not self.is_monotonic(): self._logger.warning(""The outgroup rates are not monotonically increasing. This might indicate "" ""that the outgroups were not specified in the order of increasing divergence. "" f""rates: {dict(zip(self.outgroups, self.get_outgroup_divergence()))}"") # cache the branch probabilities for the MLE parameters self._renew_cache() # renew site configuration cache self._update_configs() def _update_configs(self): """""" Renew site configuration cache. """""" # obtain the probability for each site and minor allele under the MLE rate parameters self.configs.p_minor = self.get_p_configs( configs=self.configs, model=self.model, base_type=BaseType.MINOR, params=self.params_mle ) # obtain the probability for each site and major allele under the MLE rate parameters self.configs.p_major = self.get_p_configs( configs=self.configs, model=self.model, base_type=BaseType.MAJOR, params=self.params_mle ) # calculate the ancestral probabilities, i.e. probability of the major allele being ancestral # opposed to the minor allele self.configs.p_major_ancestral = self._calculate_p_major_ancestral( p_minor=self.configs['p_minor'].values, p_major=self.configs['p_major'].values, n_major=self.configs['n_major'].values ) def set_mle_params(self, params: Dict[str, float]): """""" Set the MLE parameters and update the cache and site configurations. Use this method if you want to use different parameters for the annotation. :param params: The new parameters. """""" # set the parameters self.params_mle = params # renew cache self._renew_cache() # renew site configuration cache self._update_configs() def is_monotonic(self) -> bool: """""" Whether the outgroups are monotonically increasing in divergence. :return: Whether the outgroups are monotonically increasing in divergence. """""" # get the outgroup divergence div = self.get_outgroup_divergence() # check if the outgroup divergence is monotonically increasing return all(div[i] <= div[i + 1] for i in range(len(div) - 1)) @cached_property def p_polarization(self) -> np.ndarray | None: """""" Get the polarization probabilities or ``None`` if ``prior`` is ``no``. """""" if isinstance(self.prior, PolarizationPrior): return self.prior._get_prior( configs=self.configs, n_ingroups=self.n_ingroups ) @staticmethod def get_p_tree( base: int, n_outgroups: int, internal_nodes: List[int] | np.ndarray, outgroup_bases: List[int] | np.ndarray, params: Dict[str, float], model: SubstitutionModel ) -> float: """""" Get the probability of a tree. :param base: An observed ingroup base index. :param n_outgroups: The number of outgroups. :param internal_nodes: The internal nodes of the tree. We have ``n_outgroups - 1`` internal nodes. :param outgroup_bases: The observed base indices for the outgroups. :param params: The parameters of the model. :param model: The model to use. Either 'K2' or 'JC'. """""" if n_outgroups < 1: return 0.0 # get the number of branches n_branches = 2 * n_outgroups - 1 # the probability for each branch p_branches = np.zeros(n_branches, dtype=float) # iterate over the branches for i in range(n_branches): # if we are on the first branch if i == 0: # combine ingroup base either with only outgroup or with first internal node b1 = base b2 = outgroup_bases[0] if n_outgroups == 1 else internal_nodes[0] # if we are on intermediate branches elif i < n_branches - 1: # every internal node that is not the last one combines either # with the next internal node or with an outgroup i_internal = (i - 1) // 2 # get internal base b1 = internal_nodes[i_internal] # either connect to outgroup or next internal node b2 = outgroup_bases[i_internal] if i % 2 == 1 else internal_nodes[i_internal + 1] else: # last branch connects to last internal node and last outgroup b1 = internal_nodes[-1] b2 = outgroup_bases[-1] # get the probability of the branch p_branches[i] = model._get_cached_prob(b1, b2, i, params) # take product of all branch probabilities prod = p_branches.prod() return prod @classmethod def get_p_config( cls, config: SiteConfig, base_type: BaseType, params: Dict[str, float], model: SubstitutionModel = K2SubstitutionModel(), internal: np.ndarray | None = None ) -> float: """""" Get the probability for a site configuration. :param config: The site configuration. :param base_type: The base type. :param params: The parameters for the substitution model. :param model: The substitution model to use. :param internal: Base indices of internal nodes of the tree if fixed. If ``None``, the internal nodes are considered as free parameters. -1 also indicates a free parameter. The number of internal nodes is the number of outgroups minus one. :return: The probability for a site. """""" n_outgroups = len(config.outgroup_bases) # get the focal base base = config.major_base if base_type == BaseType.MAJOR else config.minor_base # if the focal base is missing we return a probability of 0 if base == -1: return 0.0 # number of free nodes n_free = 0 # get internal node possibilities combs_internal = [] for i in range(n_outgroups - 1): if internal is not None and internal[i] != -1: combs_internal.append([internal[i]]) else: combs_internal.append([0, 1, 2, 3]) n_free += 1 # get outgroup possibilities combs_outgroup = [] for i in range(n_outgroups): if config.outgroup_bases[i] != -1: combs_outgroup.append([config.outgroup_bases[i]]) else: combs_outgroup.append([0, 1, 2, 3]) n_free += 1 # initialize the probability for each tree p_trees = np.zeros(4 ** n_free, dtype=float) # iterator over all possible internal node combinations for i, nodes in enumerate(itertools.product(*(combs_internal + combs_outgroup))): # get the probability of the tree p_trees[i] = cls.get_p_tree( base=base, n_outgroups=n_outgroups, internal_nodes=np.array(nodes[:n_outgroups - 1]), outgroup_bases=np.array(nodes[n_outgroups - 1:]), params=params, model=model ) return p_trees.sum() @classmethod def get_p_configs( cls, configs: pd.DataFrame, model: SubstitutionModel, base_type: BaseType, params: Dict[str, float] ) -> np.ndarray: """""" Get the probabilities for each site configuration. :param configs: The site configurations. :param model: The substitution model. :param base_type: The base type. :param params: A dictionary of the rate parameters. :return: The probability for each site. """""" # the probabilities for each site p_configs = np.zeros(shape=(configs.shape[0]), dtype=float) # iterate over the sites for i, config in enumerate(configs.itertuples()): # get the log likelihood of the site p_configs[i] = cls.get_p_config( config=cast(SiteConfig, config), base_type=base_type, params=params, model=model ) return p_configs def evaluate_likelihood(self, params: Dict[str, float]) -> float: """""" Evaluate the likelihood function for the rate parameters. :param params: A dictionary of parameters. :return: The log likelihood. """""" # cache the branch probabilities self._renew_cache(params) # compute the likelihood ll = -self._get_likelihood()([params[name] for name in self.param_names]) # restore cached branch probabilities if necessary if self.params_mle is not None: self._renew_cache() return ll def _renew_cache(self, params: Dict[str, float] = None): """""" Renew the cache of branch probabilities. :param params: The model parameters to use for caching. If ``None``, the MLE parameters are used. """""" # cache the branch probabilities self.model.cache(params if params is not None else self.params_mle, 2 * self.n_outgroups - 1) def _get_mle_configs(self) -> pd.DataFrame: """""" Get the site configurations used for the MLE with only included sites with the correct number of outgroups. """""" # only consider sites with the full number of outgroups return self.configs[self.configs.n_outgroups == self.n_outgroups] def _get_likelihood(self) -> Callable[[List[float]], float]: """""" Get the likelihood function for the rate parameters. :return: The likelihood function. """""" if self.configs is None: raise RuntimeError(""No sites available. Note that you can't call infer() yourself "" ""when using this class with Parser or Annotator."") # only consider sites with the correct number of outgroups configs = self._get_mle_configs() # Set the minor base to -1 if the major allele is fixed. # We don't want to consider minor allele not present in the subsample # when optimizing the branch rates. configs.loc[configs.n_major == self.n_ingroups, 'minor_base'] = -1 # make variables available in the inner function model = self.model param_names = self.param_names n_outgroups = self.n_outgroups def compute_likelihood(params: List[float]) -> float: """""" Compute the negative log likelihood of the parameters. :param params: A list of rate parameters. :return: The negative log likelihood. """""" # unpack the parameters params = dict(zip(param_names, params)) # cache the branch probabilities model.cache(params, 2 * n_outgroups - 1) # the likelihood for each site p_sites = np.zeros(shape=(configs.shape[0], 2), dtype=float) # get the probability for each site and major allele p_sites[:, 0] = MaximumLikelihoodAncestralAnnotation.get_p_configs( configs=configs, model=model, base_type=BaseType.MAJOR, params=params ) # get the probability for each site and minor allele p_sites[:, 1] = MaximumLikelihoodAncestralAnnotation.get_p_configs( configs=configs, model=model, base_type=BaseType.MINOR, params=params ) # Return the negative log likelihood and take average over major and minor bases # Also multiply by the multiplicity of each site. # The final likelihood is the product of the likelihoods for each site. return -(np.log(p_sites.mean(axis=1)) * configs.multiplicity.values).sum() return compute_likelihood def _get_site_indices(self) -> np.ndarray: """""" Get the list of config indices for each site. :return: The list of config indices, use -1 for sites that are not included. """""" indices = np.full(self.n_sites, -1, dtype=int) for i, config in self.configs.iterrows(): for j in config.sites: indices[j] = i return indices def _get_ancestral_from_prob( self, p_major_ancestral: np.ndarray | float, major_base: np.ndarray | str, minor_base: np.ndarray | str ) -> np.ndarray | float: """""" Get the ancestral allele from the probability of the major allele being ancestral. :param p_major_ancestral: The probabilities of the major allele being ancestral. :param major_base: The major bases. :param minor_base: The minor bases. :return: Array of ancestral alleles. """""" # make function accept scalars if isinstance(p_major_ancestral, float): return self._get_ancestral_from_prob( np.array([p_major_ancestral]), np.array([major_base]), np.array([minor_base]) )[0] # initialize array ancestral_bases = np.full(p_major_ancestral.shape, -1, dtype=np.int8) ancestral_bases[p_major_ancestral >= 0.5] = major_base[p_major_ancestral >= 0.5] ancestral_bases[p_major_ancestral < 0.5] = minor_base[p_major_ancestral < 0.5] return ancestral_bases def _get_internal_prob( self, site: SiteConfig, internal: np.ndarray | None = None ) -> float: """""" Get the ancestral allele for each site. :param site: The site configuration. :param internal: Base indices of internal nodes of the tree if fixed. If ``None``, the internal nodes are considered as free parameters. -1 also indicates a free parameter. :return: The ancestral allele, probability for the major being ancestral, the first base being ancestral, the second base being ancestral. """""" # get the probability for the major allele p_minor = self.get_p_config( config=site, base_type=BaseType.MINOR, params=self.params_mle, model=self.model, internal=internal ) # get the probability for the minor allele p_major = self.get_p_config( config=site, base_type=BaseType.MAJOR, params=self.params_mle, model=self.model, internal=internal ) return p_minor + p_major def _get_internal_probs( self, site: SiteConfig, i_internal: int, ) -> np.ndarray: """""" Get the internal probabilities for the sites used to estimate the parameters. :param site: The site configuration. :param i_internal: The index of the internal node. :return: The probabilities for each base and site. """""" # number of outgroups considered n_outgroups = len(site.outgroup_bases) # no internal nodes if there are fewer than two outgroups if n_outgroups < 2: return np.full(4, self._get_internal_prob(site)) # initialize internal nodes internal = np.full(len(site.outgroup_bases), fill_value=-1, dtype=int) # initialize probabilities probs = np.zeros(shape=4, dtype=float) # get the internal node probabilities for j in range(4): internal[i_internal] = j probs[j] = self._get_internal_prob(site, internal=internal) return probs def get_inferred_site_info(self) -> Generator[SiteInfo, None, None]: """""" Get the site information for the sites included in the parsing process. The sites are in the same order as parsed. You can use :meth:`get_site_info` to get the site information for a specific site. :return: A generator yielding a dictionary with the site information (see :meth:`get_site_info`). :raises RuntimeError: If the subsample mode is ``probabilistic``. """""" # check if data is provided using a VCF file if self.subsample_mode == 'probabilistic': raise RuntimeError(""get_inferred_site_info() not implemented with probabilistic subsampling."") # get config indices for each site indices = self._get_site_indices() # remove sites that are not included indices = indices[indices != -1] # get the sites sites = self.configs.iloc[indices] # iterate over the sites for site in sites.itertuples(): yield self.get_site_info( n_major=site.n_major, major_base=site.major_base, minor_base=site.minor_base, outgroup_bases=site.outgroup_bases, pass_indices=True ) def _get_site_info(self, configs: List[SiteConfig]) -> SiteInfo: """""" Get information on the specified sites using the inferred parameters. :param configs: The site configurations with differing numbers of major alleles with their multiplicities summing up to 1. :return: The site information. """""" if self.params_mle is None: raise RuntimeError(""No maximum likelihood parameters available."") # use most likely configuration as reference i_max = np.argmax([c.multiplicity for c in configs]) ref = configs[i_max] # get the probability for the minor allele p_minor = self.get_p_config( config=ref, # use first config as representative base_type=BaseType.MINOR, params=self.params_mle, model=self.model ) # get the probability for the major allele p_major = self.get_p_config( config=ref, # use first config as representative base_type=BaseType.MAJOR, params=self.params_mle, model=self.model ) # get the probability that the major allele is ancestral rather than the minor allele p_major_ancestral_probs = self._calculate_p_major_ancestral( p_minor=np.array([p_minor if c.minor_base == ref.minor_base else p_major for c in configs]), p_major=np.array([p_major if c.major_base == ref.major_base else p_minor for c in configs]), n_major=np.array([c.n_major for c in configs]) ) # configs for which the minor allele turned out to be the major allele in the subsample alt_config = np.array([c.minor_base != ref.minor_base for c in configs]) p_major_ancestral_probs[alt_config] = 1 - p_major_ancestral_probs[alt_config] # take the weighted average weights = np.array([c.multiplicity for c in configs]) p_major_ancestral = (p_major_ancestral_probs * weights).sum() # get the ancestral alleles using p_major_ancestral major_ancestral = self.get_base_string(self._get_ancestral_from_prob( p_major_ancestral=p_major_ancestral, major_base=ref.major_base, minor_base=ref.minor_base )) # ancestral base probabilities for the first node p_bases_first_node = self._get_internal_probs(site=ref, i_internal=0) # get the base probabilities for the first node total = p_bases_first_node.sum() i_max = np.argmax(p_bases_first_node) p_first_node_ancestral = p_bases_first_node[i_max] / total if total > 0 else 0 first_node_ancestral = self.get_base_string(i_max) return SiteInfo( n_major={config.n_major: config.multiplicity for config in configs}, major_base=self.get_base_string(ref.major_base), minor_base=self.get_base_string(ref.minor_base), outgroup_bases=list(self.get_base_string(np.array(ref.outgroup_bases))), p_minor=p_minor, p_major=p_major, p_major_ancestral=p_major_ancestral, major_ancestral=major_ancestral, p_bases_first_node=dict(zip(bases, p_bases_first_node)), p_first_node_ancestral=p_first_node_ancestral, first_node_ancestral=first_node_ancestral, rate_params=self.params_mle ) def get_site_info( self, n_major: int, major_base: int | str, minor_base: int | str, outgroup_bases: List[int | str] | np.ndarray, pass_indices: bool = False ) -> SiteInfo: """""" Get information on the specified sites using the inferred parameters. :param n_major: The number of copies of the major allele. :param major_base: The major bases indices or strings. :param minor_base: The minor bases indices or strings. :param outgroup_bases: The outgroup base indices or strings. :param pass_indices: Whether to pass the indices as strings or convert them to integers. :return: The site information. """""" if not pass_indices: major_base = self.get_base_index(major_base) minor_base = self.get_base_index(minor_base) outgroup_bases = self.get_base_index(np.array(outgroup_bases)) # initialize site configuration config = SiteConfig( n_major=n_major, major_base=major_base, minor_base=minor_base, outgroup_bases=outgroup_bases ) return self._get_site_info([config]) def _calculate_p_major_ancestral( self, p_minor: float | np.ndarray, p_major: float | np.ndarray, n_major: int | np.ndarray ) -> float | np.ndarray: """""" Calculate the probability that the ancestral allele is the major allele. :param p_minor: The probability or probabilities of the minor allele. :param p_major: The probability or probabilities of the major allele. :param n_major: The number or numbers of major alleles. :return: The probability or probabilities that the ancestral allele is the major allele. """""" # return empty array if p_minor is empty if isinstance(p_minor, np.ndarray) and len(p_minor) == 0: return np.array([]) try: if self.prior is not None: # polarization prior for the major allele pi = self.p_polarization[self.n_ingroups - n_major] # get the probability that the major allele is ancestral return pi * p_major / (pi * p_major + (1 - pi) * p_minor) # get the probability that the major allele is ancestral return p_major / (p_major + p_minor) # only occurs when we deal with scalars except ZeroDivisionError: return np.nan @staticmethod def _is_confident(threshold: float, p: float) -> bool: """""" Whether we are confident enough about the ancestral allele state. :param threshold: Confidence threshold. :param p: Probability of the major allele being ancestral as opposed to the minor allele. :return: Whether we are confident enough. """""" return not (1 - threshold) / 2 < p < 1 - (1 - threshold) / 2 def annotate_site(self, variant: Union['cyvcf2.Variant', DummyVariant]): """""" Annotate a single site. :param variant: The variant to annotate. :return: The annotated variant. """""" # set default values ancestral_base = '.' ancestral_prob = '.' # use maximum parsimony if we don't have an SNP if isinstance(variant, DummyVariant) or not variant.is_snp: ancestral_base = MaximumParsimonyAncestralAnnotation._get_ancestral(variant, self._ingroup_mask) ancestral_info = 'monomorphic' # increase the number of annotated sites self.n_annotated += 1 else: try: configs = self._parse_variant(variant) except _PolyAllelicSiteError: ancestral_info = 'polyallelic' except _TooFewIngroupsSiteError: ancestral_info = 'too few ingroups' else: site = self._get_site_info(configs) # only proceed if the ancestral allele is known if site.major_ancestral in bases: # get site information dictionary site_dict = site.__dict__ # update info ancestral_info = str(site_dict) # only proceed with annotation if the confidence is high enough if self._is_confident(self.confidence_threshold, site.p_major_ancestral): # we take most likely configuration as reference ref = configs[np.argmax([c.multiplicity for c in configs])] # obtain ad hoc annotation for sanity checking site_info_ad_hoc = AdHocAncestralAnnotation._get_site_info(ref) # log warning if ad hoc and maximum likelihood annotation disagree if site_info_ad_hoc['ancestral_base'] != site.major_ancestral: self._logger.debug( ""Mismatch with ad hoc ancestral allele annotation: "" + str(dict( site=f""{variant.CHROM}:{variant.POS}"", ancestral_base_ad_hoc=site_info_ad_hoc['ancestral_base'], ) | site_dict) ) # append site to mismatches self.mismatches.append(site) # update ancestral base ancestral_base = site.major_ancestral # update ancestral probability if site.major_base == site.major_ancestral: ancestral_prob = site.p_major_ancestral else: ancestral_prob = 1 - site.p_major_ancestral # increase the number of annotated sites self.n_annotated += 1 else: ancestral_info = 'below confidence threshold' else: ancestral_info = 'invalid or unknown ancestral allele' # set the ancestral allele variant.INFO[self._handler.info_ancestral] = ancestral_base # set the ancestral allele probability variant.INFO[self._handler.info_ancestral + '_prob'] = ancestral_prob # set info field variant.INFO[self._handler.info_ancestral + ""_info""] = ancestral_info def plot_likelihoods( self, file: str = None, show: bool = True, title: str = 'rate likelihoods', scale: Literal['lin', 'log'] = 'lin', ax: 'plt.Axes' = None, ylabel: str = 'lnl' ) -> 'plt.Axes': """""" Visualize the likelihoods of the rate optimization runs using a scatter plot. :param scale: y-scale of the plot. :param title: Plot title. :param file: File to save plot to. :param show: Whether to show plot. :param ax: Axes to plot on. Only for Python visualization backend. :param ylabel: Label for y-axis. :return: Axes object """""" from .visualization import Visualization return Visualization.plot_scatter( values=self.likelihoods, file=file, show=show, title=title, scale=scale, ax=ax, ylabel=ylabel, ) def get_folded_spectra( self, groups: List[Literal['major_base', 'minor_base', 'outgroup_bases']] = ['major_base'], ) -> Spectra: """""" Get the folded spectra for the parsed sites (used to estimate the parameters). :param groups: The groups to group the spectra by. :return: Spectra object """""" configs = self._get_mle_configs() # group by n_major and groups grouped = configs.groupby(['n_major'] + groups).sum() if len(groups) == 0: index = np.arange(self.n_ingroups + 1) else: # new index to include all possible values for n_major index = pd.MultiIndex.from_product( [np.arange(self.n_ingroups + 1).tolist()] + grouped.index.levels[1:], names=['n_major'] + groups ) # reindex grouped = grouped.reindex(index, fill_value=0) # if we only group by n_major if len(groups) == 0: return Spectra.from_dict(dict(all=grouped.multiplicity[::-1].tolist())) # iterate over groups spectra = {} for i, group in grouped.groupby(level=groups): if not isinstance(i, tuple): name = f""{groups[0]}={self.get_base_string(i)}"" else: name = "", "".join([f""{a}={self.get_base_string(b)}"" for a, b in zip(groups, i)]) spectra[name] = group.multiplicity[::-1].tolist() return Spectra.from_dict(spectra) @staticmethod def _get_branch(params: Dict[str, float], i: int) -> float: """""" Get the branch rate for the given index. :param params: The parameters. :param i: The index. :return: The branch rate. """""" return params['K'] if 'K' in params else params[f'K{i}'] def get_outgroup_divergence(self) -> np.ndarray: """""" Get the inferred branch rates between the ingroup and outgroups by combining the inferred branch rates. :return: One rate for each outgroup. """""" if self.params_mle is None: raise RuntimeError(""No maximum likelihood parameters available."") # initialize array rates = np.zeros(self.n_outgroups, dtype=float) for i in range(self.n_outgroups): # if it's not the last outgroup if i < self.n_outgroups - 1: ingroup = [self._get_branch(self.params_mle, 2 * j) for j in range(i + 1)] outgroup = self._get_branch(self.params_mle, 2 * i + 1) else: ingroup = [self._get_branch(self.params_mle, 2 * j) for j in range(i)] outgroup = self._get_branch(self.params_mle, 2 * i) rates[i] = np.sum(ingroup + [outgroup]) return rates def get_observed_transition_transversion_ratio(self) -> float: """""" Get the observed transition/transversion ratio. Note that this may differ from the estimated ratio for :class:`K2SubstitutionModel`. :return: The observed transition/transversion ratio. """""" configs = self._get_mle_configs() if len(configs) == 0: raise RuntimeError(""No sites available to calculate the transition/transversion ratio."") tuples = configs[[""minor_base"", ""major_base""]].apply(tuple, axis=1) transitions = tuples.isin([tuple(e) for e in SubstitutionModel._transitions]) transversions = tuples.isin([tuple(e) for e in SubstitutionModel._transversions]) n_transitions = configs[transitions].multiplicity.sum() n_transversions = configs[transversions].multiplicity.sum() return n_transitions / n_transversions class AdHocAncestralAnnotation(_OutgroupAncestralAlleleAnnotation): """""" Ad-hoc ancestral allele annotation using simple rules. Used for testing and sanity checking. """""" @staticmethod def _get_site_info(config: SiteConfig) -> dict: """""" Get site information from the site configuration. :param config: The site configuration. :return: Dictionary of with the key 'ancestral_base', denoting the ancestral base string. """""" # get ingroup and outgroup bases # noinspection PyTypeChecker bases_combined = np.concatenate(([config.major_base], [config.minor_base], config.outgroup_bases)) # get scores for each base # noinspection PyTypeChecker scores = np.concatenate(([1.2], [1], [1 for _ in range(1, len(config.outgroup_bases) + 1)])) # get valid bases is_valid = bases_combined != -1 # remove missing bases valid_bases = bases_combined[is_valid] # get valid scores valid_scores = scores[is_valid] # return missing if no valid bases if len(valid_bases) == 0: return dict( ancestral_base='.' ) # get sum for each base score = np.array([np.sum(valid_scores[valid_bases == i]) for i in range(4)]) # take most common base as ancestral ancestral_base = bases[score.argmax()] return dict( ancestral_base=ancestral_base ) def annotate_site(self, variant: Union['cyvcf2.Variant', DummyVariant]): """""" Annotate a single site. Mono-allelic sites are assigned the major allele as ancestral. Sites with more than two alleles are ignored. :param variant: The variant to annotate. :return: The annotated variant. """""" ancestral_base = '.' # use maximum parsimony if we have a mono-allelic site if isinstance(variant, DummyVariant) or not variant.is_snp: ancestral_base = MaximumParsimonyAncestralAnnotation._get_ancestral(variant, self._ingroup_mask) ancestral_info = 'monomorphic' self.n_annotated += 1 else: try: # parse the site configs = self._parse_variant(variant) except _PolyAllelicSiteError: ancestral_info = 'polyallelic' except _TooFewIngroupsSiteError: ancestral_info = 'too few ingroups' else: # use config with the highest multiplicity ref = configs[np.argmax([c.multiplicity for c in configs])] # get site information dictionary site = self._get_site_info(ref) # only proceed if the ancestral allele is known if site['ancestral_base'] in bases: ancestral_base = site['ancestral_base'] ancestral_info = str(site) self.n_annotated += 1 else: ancestral_info = 'invalid or unknown ancestral allele' # set the ancestral allele variant.INFO[self._handler.info_ancestral] = ancestral_base # set info field variant.INFO[self._handler.info_ancestral + ""_info""] = ancestral_info class _ESTSFSAncestralAnnotation(AncestralAlleleAnnotation): # pragma: no cover """""" A wrapper around EST-SFS. Used for testing. """""" def __init__( self, anc: MaximumLikelihoodAncestralAnnotation ): """""" Create a new ESTSFSAncestralAnnotation instance. :param anc: """""" super().__init__() #: The ancestral annotation. self.anc = anc #: The likelihoods for each run. self.likelihoods: np.ndarray | None = None #: The minimum likelihood. self.likelihood: float | None = None #: The MLE parameters. self.params_mle: Dict[str, float] | None = None #: The probabilities for each site. self.probs: pd.DataFrame | None = None def create_seed_file(self, seed_file: str): """""" Create the seed file. :param seed_file: Path to the seed file. """""" with open(seed_file, 'w') as f: f.write(str(self.anc.seed)) def create_config_file(self, config_file: str): """""" Create the config file. :param config_file: Path to the config file. """""" models = dict( JCSubstitutionModel=0, K2SubstitutionModel=1 ) with open(config_file, 'w') as f: f.write(f""n_outgroup {self.anc.n_outgroups}\n"") f.write(f""model {models[self.anc.model.__class__.__name__]}\n"") f.write(f""nrandom {self.anc.n_runs}\n"") def infer( self, binary: str = 'EST_SFS', wd: str = None, execute: Callable = None, ): """""" Infer the ancestral allele using EST-SFS. :param binary: The path to the EST-SFS binary. :param wd: The working directory. :param execute: The function to execute the bash command. """""" # define default function for executing command if execute is None: def shell(command: str): """""" Execute shell command. :param command: Command string """""" return subprocess.run(command, check=True, cwd=wd, shell=True) execute = shell with tempfile.NamedTemporaryFile('w') as sites_file, \ tempfile.NamedTemporaryFile('w') as seed_file, \ tempfile.NamedTemporaryFile('w') as config_file, \ tempfile.NamedTemporaryFile('w') as out_sfs, \ tempfile.NamedTemporaryFile('w') as out_p: # create the sites file self.anc.to_est_sfs(sites_file.name) # create the seed file self.create_seed_file(seed_file.name) # create the config file self.create_config_file(config_file.name) # construct command string command = (f""{binary} "" f""{config_file.name} "" f""{sites_file.name} "" f""{seed_file.name} "" f""{out_sfs.name} "" f""{out_p.name} "") # log command signature self._logger.info(f""Running: '{command}'"") # execute command execute(command) self.parse_est_sfs_output(out_p.name) def parse_est_sfs_output(self, file: str): """""" Parse the output of the EST-SFS program containing the site probabilities. :param file: The file name. :return: The data frame. """""" # filter out lines starting with 0 filtered_lines = [] with open(file, 'r') as f: for i, line in enumerate(f): # strip line line = line.strip() if line.startswith('0'): if i == 4: # parse likelihoods self.likelihoods = np.array(line.split()[2:], dtype=float) self.likelihood = np.min(self.likelihoods) if i == 5: # parse MLE parameters data = np.array(line.split()[2:]) self.params_mle = dict(zip([d.upper() for d in data[::2]], data[1::2].astype(float))) if i == 6 and isinstance(self.anc.model, K2SubstitutionModel): # parse kappa self.params_mle['k'] = float(line.split()[2]) else: filtered_lines.append(line.strip()) # read into dataframe self.probs = pd.read_csv(StringIO('\n'.join(filtered_lines)), sep="" "", header=None) # drop the first column self.probs.drop(self.probs.columns[0], axis=1, inplace=True) # rename columns self.probs.rename(columns={1: 'config', 2: 'prob'}, inplace=True) def annotate_site(self, variant: Union['cyvcf2.Variant', DummyVariant]): """""" Not implemented. :param variant: The variant to annotate. :raises: NotImplementedError """""" raise NotImplementedError def to_file(self, file: str): """""" Save object to file (without reference to AncestralAlleleAnnotation object). :param file: File path. """""" self.anc = None with open(file, 'w') as fh: fh.write(self.to_json()) def to_json(self) -> str: """""" Serialize object. :return: JSON string """""" return jsonpickle.encode(self, indent=4, warn=True) @classmethod def from_json(cls, json: str, classes=None) -> 'Self': """""" Unserialize object. :param classes: Classes to be used for unserialization :param json: JSON string """""" return jsonpickle.decode(json, classes=classes) @classmethod def from_file(cls, file: str, classes=None) -> 'Self': """""" Load object from file. :param classes: Classes to be used for unserialization :param file: File to load from """""" with open(file, 'r') as fh: return cls.from_json(fh.read(), classes) class Annotator(MultiHandler): """""" Annotate a VCF file with the given annotations. Example usage: :: import fastdfe as fd ann = fd.Annotator( vcf=""http://ftp.1000genomes.ebi.ac.uk/vol1/ftp/data_collections/"" ""1000_genomes_project/release/20181203_biallelic_SNV/"" ""ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz"", fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"", gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", output='sapiens.chr21.degeneracy.vcf.gz', annotations=[fd.DegeneracyAnnotation()], aliases=dict(chr21=['21']) ) ann.annotate() """""" def __init__( self, vcf: str, output: str, annotations: List[Annotation], gff: str | None = None, fasta: str | None = None, info_ancestral: str = 'AA', max_sites: int = np.inf, seed: int | None = 0, cache: bool = True, aliases: Dict[str, List[str]] = {}, ): """""" Create a new annotator instance. :param vcf: The path to the VCF file, can be gzipped, urls are also supported :param output: The path to the output file :param annotations: The annotations to apply. :param gff: The path to the GFF file, can be gzipped, urls are also supported. Required for annotations that require a GFF file. :param fasta: The path to the FASTA file, can be gzipped, urls are also supported. Required for annotations that require a FASTA file. :param info_ancestral: The tag in the INFO field that contains the ancestral allele :param max_sites: Maximum number of sites to consider :param seed: Seed for the random number generator. Use ``None`` for no seed. :param cache: Whether to cache files downloaded from urls :param aliases: Dictionary of aliases for the contigs in the VCF file, e.g. ``{'chr1': ['1']}``. This is used to match the contig names in the VCF file with the contig names in the FASTA file and GFF file. """""" super().__init__( vcf=vcf, gff=gff, fasta=fasta, info_ancestral=info_ancestral, max_sites=max_sites, seed=seed, cache=cache, aliases=aliases ) #: The path to the output file. self.output: str = output #: The annotations to apply. self.annotations: List[Annotation] = annotations #: The VCF writer. self._writer: 'cyvcf2.Writer' | None = None def _setup(self): """""" Set up the annotator. """""" try: from cyvcf2 import Writer except ImportError: raise ImportError( ""VCF support in fastdfe requires the optional 'cyvcf2' package. "" ""Please install fastdfe with the 'vcf' extra: pip install fastdfe[vcf]"" ) for annotation in self.annotations: annotation._setup(self) # create the writer self._writer = Writer(self.output, self._reader) def _teardown(self): """""" Tear down the annotator. """""" for annotation in self.annotations: annotation._teardown() # close the writer and reader self._writer.close() self._reader.close() def annotate(self): """""" Annotate the VCF file. """""" self._logger.info('Start annotating') # set up the annotator self._setup() # get progress bar with self.get_pbar(desc=f""{self.__class__.__name__}>Processing sites"") as pbar: # iterate over the sites for i, variant in enumerate(self._reader): # apply annotations for annotation in self.annotations: annotation.annotate_site(variant) # write the variant self._writer.write_record(variant) # update the progress bar pbar.update() # explicitly stopping after ``n`` sites fixes a bug with cyvcf2: # 'error parsing variant with `htslib::bcf_read` error-code: 0 and ret: -2' if i + 1 == self.n_sites or i + 1 == self.max_sites: break # tear down the annotator self._teardown() ","Python" "Allele","Sendrowski/fastDFE","fastdfe/simulation.py",".py","18044","506",""""""" Simulate an SFS given a DFE. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2024-09-06"" import logging from typing import Tuple, Literal, Sequence, Callable import numpy as np from scipy.stats import hypergeom from tqdm import tqdm from .base_inference import BaseInference from .discretization import Discretization from .parametrization import Parametrization, DFE from .parametrization import _from_string from .spectrum import Spectrum, Spectra logger = logging.getLogger('fastdfe') class Simulation: """""" Simulate an SFS under selection given a DFE and a neutral SFS. Example usage: :: import fastdfe as fd # create simulation object by specifying neutral SFS and DFE sim = fd.Simulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), params=dict(S_d=-300, b=0.3, p_b=0.1, S_b=0.1), model=fd.GammaExpParametrization() ) # perform the simulation sim.run() # plot spectra sim.get_spectra().plot() """""" def __init__( self, sfs_neut: Spectrum, params: dict = None, model: Parametrization | str = 'GammaExpParametrization', intervals_del: Tuple[float, float, int] = (-1.0e+8, -1.0e-5, 1000), intervals_ben: Tuple[float, float, int] = (1.0e-5, 1.0e4, 1000), h_callback: Callable[[np.ndarray], np.ndarray] = None, integration_mode: Literal['midpoint', 'quad'] = 'midpoint', linearized: bool = True, discretization: Discretization = None, parallelize: bool = True ): """""" Create a simulation object. :param sfs_neut: Neutral SFS. This sfs is informative on the population sample size, population mutation rate, the number of sites, and demography. :func:`get_neutral_sfs` can be used to obtain a neutral SFS. :param params: Parameters of the DFE parametrization (see model) in addition to ancestral misidentification params ``eps`` and dominance ``h``. By default, `eps=0`, `h=0.5`, the default parameters of ``model`` will be used. :param model: DFE parametrization model :param intervals_del: ``(start, stop, n_interval)`` for deleterious population-scaled selection coefficients. The intervals will be log10-spaced. Decreasing the number of intervals to ``100`` provides nearly identical results while increasing speed, especially when precomputing across dominance coefficients. :param intervals_ben: Same as ``intervals_del`` but for positive selection coefficients. Decreasing the number of intervals to ``100`` provides nearly identical results while increasing speed, especially when precomputing across dominance coefficients. :param h_callback: A function mapping the scalar parameter ``h`` and the array of selection coefficients ``S`` to dominance coefficients of the same shape, allowing models where ``h`` depends on ``S``. The default is ``lambda h, S: np.full_like(S, h)``, keeping ``h`` constant. Expected allele counts for a given dominance value are obtained by linear interpolation between precomputed values in ``intervals_h``. The inferred parameter is still named ``h``, even if transformed by ``h_callback``, and its bounds, scales, and initial values can be set via ``bounds``, ``scales``, and ``x0``. The fitness of heterozygotes and mutation homozygotes is defined as ``1 + 2hs`` and ``1 + 2s``, respectively. :param integration_mode: Integration mode when computing expected SFS under semidominance. ``quad`` is not recommended. :param linearized: Whether to discretize and cache the linearized integral mapping DFE to SFS or use ``scipy.integrate.quad`` in each call. ``False`` not recommended. :param parallelize: Whether to parallelize computations """""" #: The DFE parametrization self.model: Parametrization = _from_string(model) #: Parameters for the DFE parametrization self.params: dict = self.model.x0 if params is None else params if 'eps' not in self.params: self.params['eps'] = 0 if 'h' not in self.params: self.params['h'] = 0.5 # check if parameters are within bounds self._check_bounds() #: Neutral SFS self.sfs_neut: Spectrum = sfs_neut #: Modelled SFS self.sfs_sel: Spectrum = None #: DFE instance self.dfe: DFE = DFE(model=self.model, params=self.params) #: SFS sample size self.n: int = self.sfs_neut.n #: Population mutation rate self.theta: float = self.sfs_neut.theta #: Number of sites self.n_sites: float = self.sfs_neut.n_sites if discretization is None: # create discretization instance #: Discretization instance self.discretization: Discretization = Discretization( n=self.n, h=self.params['h'], intervals_del=intervals_del, intervals_ben=intervals_ben, h_callback=h_callback, integration_mode=integration_mode, linearized=linearized, parallelize=parallelize ) else: # otherwise assign instance self.discretization: Discretization = discretization #: Logger self._logger = logger.getChild('Simulation') def run(self) -> Spectrum: """""" Simulate an SFS given a DFE. :return: Simulated SFS """""" self._logger.info(""Simulating SFS under selection using parameters: "" + ', '.join( [f""{k}={v:.4g}"" for k, v in self.params.items()] )) # obtain modelled selected SFS counts_modelled = self.discretization.model_selection_sfs(self.model, self.params) # adjust for mutation rate and mutational target size counts_modelled *= self.theta * self.n_sites # add contribution of demography and adjust polarization error counts_modelled = BaseInference._add_demography(self.sfs_neut, counts_modelled, eps=self.params['eps']) self.sfs_sel = Spectrum([self.n_sites - sum(counts_modelled)] + list(counts_modelled) + [0]) return self.sfs_sel def _check_bounds(self): """""" Check if the specified parameters are within the bounds of the DFE parametrization. """""" for k, v in self.params.items(): if k in self.model.bounds and not self.model.bounds[k][0] <= v <= self.model.bounds[k][1]: raise ValueError( f""Parameter {k}={v} is out of bounds {self.model.bounds[k]} "" f""for model {self.model.__class__.__name__}."" ) if not 0 <= self.params['eps'] <= 1: raise ValueError(f""Ancestral misidentification parameter eps={self.params['eps']} is out of bounds [0, 1]."") if not 0 <= self.params['h'] <= 1: raise ValueError(f""Dominance parameter h={self.params['h']} is out of bounds [0, 1]."") def get_spectra(self) -> Spectra: """""" Get the spectra used in the simulation. :return: Tuple of neutral SFS and selected SFS """""" return Spectra.from_spectra({ ""neutral"": self.sfs_neut, ""selected"": self.sfs_sel }) def get_alpha(self) -> float: """""" Get the proportion of adaptive substitutions (alpha) under the specified DFE and parameters. :return: Proportion of adaptive substitutions """""" return self.discretization.get_alpha(self.model, self.params) @staticmethod def get_neutral_sfs( theta: float, n_sites: float, n: int, r: Sequence[float] = None ) -> Spectrum: """""" Obtain a standard neutral SFS for a given theta and number of sites. :param theta: Population mutation rate :param n_sites: Number of total sites :param n: Number of frequency classes :param r: Nuisance parameters that account for demography. An array of length ``n-1`` whose elements are multiplied element-wise with the polymorphic counts of the Kingman SFS. By default, no demography effects are considered which is equivalent to ``r = [1] * (n-1)``. Note that non-default values of ``r`` will also affect estimates of the population mutation rate. :return: Neutral SFS """""" n = int(n) if r is None: r = np.ones(n + 1) else: r = list(r) if len(r) != n - 1: raise ValueError(f""The length of r must be n - 1 = {n - 1}; got {len(r)}."") r = np.array([1] + r + [1]) sfs: Spectrum = Spectrum.standard_kingman(n=n) * theta * n_sites # add demography sfs.data *= r # add monomorphic counts sfs.data[0] = n_sites - sfs.n_sites return sfs def get_wright_fisher( self, pop_size: int, generations: int ) -> 'WrightFisherSimulation': """""" Get a Wright-Fisher simulation object. :param pop_size: Effective population size :param generations: Number of generations to simulate :return: Wright-Fisher simulation object """""" return WrightFisherSimulation( params=self.params, model=self.model, sfs_neut=self.sfs_neut, pop_size=pop_size, n_generations=generations, ) class WrightFisherSimulation: # pragma: no cover """""" Simulate an SFS under selection given a DFE under the Wright-Fisher model. Example usage: :: import fastdfe as fd # create simulation object by specifying neutral SFS and DFE sim = fd.simulation.WrightFisherSimulation( sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e7, theta=1e-4), params=dict(S_d=-300, b=0.3, p_b=0.1, S_b=0.1), model=fd.GammaExpParametrization(), pop_size=100, n_generations=500 ) # perform the simulation sfs_sel = sim.run() # plot SFS sfs_sel.plot() """""" def __init__( self, params: dict = None, model: Parametrization | str = 'GammaExpParametrization', sfs_neut: Spectrum = None, pop_size: int = 1000, n_generations: int = 100, n_sites: int = None, theta: float = None, parallelize: bool = True, n_threads: int = 100 ): """""" Create a Wright-Fisher simulation object. :param params: Parameters for the DFE parametrization (see model). By default, the default parameters of ``model`` will be used. :param model: DFE parametrization model :param sfs_neut: Neutral SFS. This sfs is informative on the population sample size, population mutation rate, the number of sites, and demography. :func:`get_neutral_sfs` can be used to obtain a neutral SFS. :param pop_size: Effective population size :param n_generations: Number of generations to simulate :param n_sites: Number of sites in the simulated SFS. If not provided, the number of sites in ``sfs_neut`` will be used. :param theta: Population mutation rate. If not provided, the population mutation rate in ``sfs_neut`` will be used. :param parallelize: Whether to parallelize computations :param n_threads: Number of threads to use for parallelization """""" #: The DFE parametrization self.model: Parametrization = _from_string(model) #: Parameters for the DFE parametrization self.params: dict = self.model.x0 if params is None else params #: Neutral SFS self.sfs_neut: Spectrum = sfs_neut #: SFS sample size self.n: int = self.sfs_neut.n #: Population mutation rate self.theta: float = self.sfs_neut.theta if theta is None else theta #: Number of sites self.n_sites: int = self.sfs_neut.n_sites if n_sites is None else n_sites #: Effective population size self.pop_size: int = pop_size #: Number of generations to simulate self.n_generations: int = n_generations #: CDF of the DFE self.cdf: Callable[[np.ndarray], np.ndarray] = self.model.get_cdf(**self.params) #: Logger self._logger = logger.getChild('WrightFisherSimulation') #: Whether to parallelize computations self.parallelize: bool = parallelize #: Number of threads to use for parallelization self.n_threads: int = n_threads #: Tolerance for CDF bounds self.tol_bounds = 1e-6 #: Tolerance for bisection self.tol_bisect = 1e-6 #: Bounds for the CDF self.lower, self.upper = self._determine_cdf_bounds() def _determine_cdf_bounds(self) -> Tuple[float, float]: """""" Determine bounds for the CDF by identifying where the CDF approaches 0 and 1. :return: Lower and upper bounds for the CDF. """""" lower = -1e-4 upper = 1e-4 # Expand lower bound until CDF is close to 0 while self.cdf(lower) > self.tol_bounds: lower *= 2 # Expand upper bound until CDF is close to 1 while self.cdf(upper) < 1 - self.tol_bounds: upper *= 2 self._logger.debug(f""Bounded CDF between {lower} and {upper}."") return lower, upper def run(self) -> Spectrum: """""" Simulate an SFS using the Wright-Fisher model with per-individual, per-locus mutations and selection. :return: Simulated SFS. """""" rng = np.random.default_rng() # population mutation rate for all loci theta = int(self.sfs_neut.theta * self.n_sites / 2) # fixed total of mutations n_mut = int(self.n_generations * theta) self._logger.info(f'Pre-sampling selection coefficients for {n_mut} mutations.') # pre-sample selection coefficients for mutations selection_coefficients = self._sample_cdf( n=n_mut, desc=""Number of bisections"" ) / self.pop_size # log number of selection coefficients lower than -1 if (n_low := (selection_coefficients < -1).sum()) > 0: self._logger.debug( f""Number of selection coefficients lower than -1: {n_low}."" ) # selection coefficients per individual and locus s = np.zeros((self.pop_size, n_mut)) # initial allele frequencies per individual and locus freqs = np.zeros((self.pop_size, n_mut), dtype=np.int8) # pre-sample individuals for mutations across all generations individuals = rng.choice(self.pop_size, size=(self.n_generations, theta), replace=True) for g in tqdm(range(self.n_generations), desc=""Simulating generations""): # indices for mutations i_muts = np.arange(g * theta, (g + 1) * theta) # introduce mutations under assumption of infinite sites freqs[individuals[g], i_muts] = 1 s[individuals[g], i_muts] = selection_coefficients[i_muts] segregating = (freqs.sum(axis=0) > 0) & (freqs.sum(axis=0) < self.pop_size) n_segregating = segregating.sum() # selection w = 1 + s[:, segregating] probs = w / w.sum(axis=0) # selection probabilities u = rng.random((self.pop_size, n_segregating)) # Compute cumulative sums of probabilities along rows cumsum_probs = np.cumsum(probs, axis=0) idx = (cumsum_probs[:, None, :] < u).sum(axis=0) if g % 100 == 0: self._logger.debug(f""Number of mutations at generation {g}: {freqs.any(axis=0).sum()}"") freqs[:, segregating] = freqs[:, segregating][idx, np.arange(n_segregating)] # vectorize the hypergeometric PMF calculation values = hypergeom.pmf(k=np.arange(self.n + 1)[:, None], M=self.pop_size, n=freqs.sum(axis=0), N=self.n) sfs = Spectrum(values.sum(axis=1)) sfs.data[0] = self.n_sites - sfs.n_polymorphic sfs.data[-1] = 0 return sfs def _sample_cdf( self, n: int, seed: int = None, tolerance: float = 1e-13, desc: str = ""Bisection"" ) -> np.ndarray: """""" Sample the cdf of the dfe with a fully vectorized bisection method. :param n: Number of samples to draw :param seed: Random seed :param tolerance: Tolerance for the bisection method :return: Array of values x such that cdf(x) = u """""" # generate uniform samples samples = np.random.default_rng(seed=seed).uniform(0, 1, n) # initialize bounds lower = np.full(n, self.lower, dtype=float) upper = np.full(n, self.upper, dtype=float) pbar = tqdm(desc=desc) while np.mean(upper - lower) > tolerance: # compute midpoint mid = (lower + upper) / 2.0 # compute cdf at midpoint for all samples cdf_mid = self.cdf(mid) # update bounds vectorized lower_update = cdf_mid < samples lower = np.where(lower_update, mid, lower) upper = np.where(~lower_update, mid, upper) pbar.update(1) pbar.close() # return final approximated x values return (lower + upper) / 2.0 ","Python" "Allele","Sendrowski/fastDFE","fastdfe/abstract_inference.py",".py","20973","528",""""""" Abstract inference class and static utilities. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-03-12"" import logging from abc import ABC, abstractmethod from typing import List, Optional, Literal, Tuple, Dict, Sequence import jsonpickle import numpy as np import pandas as pd from typing_extensions import Self from .bootstrap import Bootstrap from .parametrization import Parametrization, _from_string from .utils import Serializable logger = logging.getLogger(""fastdfe"") class Inference: """""" Static utility methods for inference objects. """""" @staticmethod def plot_discretized( inferences: List['AbstractInference'], intervals: Sequence = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'mean', file: str = None, show: bool = True, title: str = 'discretized DFEs', labels: Sequence = None, ax: 'plt.Axes' = None, kwargs_legend: dict = dict(prop=dict(size=8)), **kwargs ) -> 'plt.Axes': """""" Visualize several discretized DFEs given by the list of inference objects. :param inferences: List of inference objects. :param intervals: Intervals over ``(-inf, inf)`` to use for discretization. :param confidence_intervals: Whether to plot confidence intervals. :param ci_level: Confidence level for confidence intervals. :param bootstrap_type: Type of bootstrap to use for confidence intervals. :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :param file: Path to file to save the plot to. :param show: Whether to show the plot. :param title: Title of the plot. :param labels: Labels for the DFEs. :param kwargs: Additional arguments for the plot. :param ax: Axes to plot on. Only for Python visualization backend. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :return: Axes of the plot. """""" from .visualization import Visualization # get data from inference objects values = [] errors = [] for i, inference in enumerate(inferences): val, errs = inference.get_discretized( intervals=np.array(intervals), confidence_intervals=confidence_intervals, ci_level=ci_level, bootstrap_type=bootstrap_type, point_estimate=point_estimate ) values.append(val) errors.append(errs) # plot DFEs return Visualization.plot_discretized( values=values, errors=errors, labels=labels, file=file, show=show, intervals=np.array(intervals), title=title, ax=ax, kwargs_legend=kwargs_legend ) @staticmethod def plot_continuous( inferences: List['AbstractInference'], intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', file: str = None, show: bool = True, title: str = 'continuous DFEs', labels: Sequence = None, scale: Literal['lin', 'log', 'symlog'] = 'lin', scale_density: bool = False, ax: 'plt.Axes' = None, kwargs_legend: dict = dict(prop=dict(size=8)), **kwargs ) -> 'plt.Axes': """""" Visualize several DFEs given by the list of inference objects. By default, the PDF is plotted as is. Due to the logarithmic scale on the x-axis, we may get a wrong intuition on how the mass is distributed, however. To get a better intuition, we can optionally scale the density by the x-axis interval size using ``scale_density = True``. This has the disadvantage that the density now changes for x, so that even a constant density will look warped. :param inferences: List of inference objects. :param intervals: Intervals to use for discretization. :param confidence_intervals: Whether to plot confidence intervals. :param ci_level: Confidence level for confidence intervals. :param bootstrap_type: Type of bootstrap to use for confidence intervals. :param file: Path to file to save the plot to. :param show: Whether to show the plot. :param title: Title of the plot. :param labels: Labels for the DFEs. :param scale: y-scale of the plot. :param scale_density: Whether to scale the density by the x-axis interval size. :param ax: Axes to plot on. Only for Python visualization backend. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :param kwargs: Additional arguments for the plot. :return: Axes of the plot. """""" from .visualization import Visualization # get data from inference objects values = [] errors = [] for i, inf in enumerate(inferences): val, errs = inf.get_discretized( intervals=intervals, confidence_intervals=confidence_intervals, ci_level=ci_level, bootstrap_type=bootstrap_type ) values.append(val) errors.append(errs) # plot DFEs return Visualization.plot_continuous( bins=intervals, **locals() ) @staticmethod def plot_inferred_parameters( inferences: List['AbstractInference'], labels: Sequence, confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'mean', file: str = None, show: bool = True, title: str = 'parameter estimates', scale: Literal['lin', 'log', 'symlog'] = 'log', ax: 'plt.Axes' = None, kwargs_legend: dict = dict(prop=dict(size=8), loc='upper right'), **kwargs ) -> 'plt.Axes': """""" Visualize several discretized DFEs given by the list of inference objects. Note that the DFE parametrization needs to be the same for all inference objects. :param inferences: List of inference objects. :param labels: Unique labels for the DFEs. :param scale: y-scale of the plot. :param confidence_intervals: Whether to plot confidence intervals. :param ci_level: Confidence level for confidence intervals. :param bootstrap_type: Type of bootstrap to use for confidence intervals. :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :param file: Path to file to save the plot to. :param show: Whether to show the plot. :param title: Title of the plot. :param ax: Axes to plot on. Only for Python visualization backend. :return: Axes of the plot. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :param kwargs: Additional arguments which are ignored. :raises ValueError: If no inference objects are given. """""" from .visualization import Visualization if len(inferences) == 0: raise ValueError('No inference objects given.') # get sorted list of parameter names param_names = sorted(list(inferences[0].get_bootstrap_param_names())) # get errors and values errors, values = Inference.get_errors_params_mle( bootstrap_type=bootstrap_type, ci_level=ci_level, confidence_intervals=confidence_intervals, inferences=inferences, labels=labels, param_names=param_names, point_estimate=point_estimate ) return Visualization.plot_inferred_parameters( values=values, errors=errors, param_names=param_names, file=file, show=show, title=title, labels=labels, scale=scale, legend=len(labels) > 1, kwargs_legend=kwargs_legend, ax=ax, ) @staticmethod def plot_inferred_parameters_boxplot( inferences: List['AbstractInference'], labels: Sequence, file: str = None, show: bool = True, title: str = 'parameter estimates', **kwargs ) -> 'plt.Axes': """""" Visualize several discretized DFEs given by the list of inference objects. Note that the DFE parametrization needs to be the same for all inference objects. :param inferences: List of inference objects. :param labels: Unique labels for the DFEs. :param file: Path to file to save the plot to. :param show: Whether to show the plot. :param title: Title of the plot. :param kwargs: Additional arguments for the plot. :return: Axes of the plot. :raises ValueError: If no inference objects are given or no bootstraps are found. """""" from .visualization import Visualization if len(inferences) == 0: raise ValueError('No inference objects given.') # get sorted list of parameter names param_names = sorted(list(inferences[0].get_bootstrap_param_names())) if inferences[0].bootstraps is None: raise ValueError('No bootstraps found.') # create dict of dataframes values = dict((k, inf.bootstraps) for k, inf in zip(labels, inferences)) return Visualization.plot_inferred_parameters_boxplot( values=values, param_names=param_names, file=file, show=show, title=title, ) @staticmethod def get_errors_params_mle( ci_level: float, confidence_intervals: bool, inferences: List['AbstractInference'], labels: Sequence, param_names: Sequence, bootstrap_type: Literal['percentile', 'bca'], point_estimate: Literal['original', 'mean', 'median'] = 'mean', ) -> Tuple[Dict[str, Tuple[np.ndarray, np.ndarray] | None], Dict[str, np.ndarray]]: """""" Get errors and values for MLE params of inferences. :param ci_level: Confidence level for confidence intervals. :param confidence_intervals: Whether to compute confidence intervals. :param inferences: List of inference objects. :param labels: Labels for the inferences. :param param_names: Names of the parameters to get errors and values for. :param bootstrap_type: Type of bootstrap to use. :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :return: dictionary of errors and dictionary of center values indexed by labels. """""" errors, values, center = {}, {}, {} for label, inf in zip(labels, inferences): values[label] = list(inf.get_bootstrap_params()[k] for k in param_names) # whether to compute errors if confidence_intervals and inf.bootstraps is not None: # compute errors center[label], errors[label], _ = Bootstrap.get_errors( values=values[label], bs=inf.bootstraps[param_names].to_numpy(), bootstrap_type=bootstrap_type, ci_level=ci_level, point_estimate=point_estimate, ) else: center[label] = np.array(values[label]) errors[label] = None return errors, center @staticmethod def get_discretized( inferences: List['AbstractInference'], labels: Sequence, intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'mean' ) -> Tuple[Dict[str, np.ndarray], Dict[str, Optional[np.ndarray]]]: """""" Get values and errors of discretized DFE. :param inferences: List of inference objects. :param labels: Labels for the DFEs. :param bootstrap_type: Type of bootstrap to use :param ci_level: Confidence interval level :param confidence_intervals: Whether to compute confidence intervals :param intervals: Array of interval boundaries over ``(-inf, inf)`` yielding ``intervals.shape[0] - 1`` bars. :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :return: Dictionary of values and dictionary of errors indexed by labels. """""" values = {} errors = {} for label, inf in zip(labels, inferences): if confidence_intervals and inf.bootstraps is not None: # get bootstraps and errors if specified values[label], errors[label], _ = Inference.get_stats_discretized( params=inf.get_bootstrap_params(), bootstraps=inf.bootstraps, model=inf.model, ci_level=ci_level, intervals=intervals, bootstrap_type=bootstrap_type, point_estimate=point_estimate ) else: # otherwise just get discretized values values[label] = Inference.compute_histogram( params=inf.get_bootstrap_params(), model=inf.model, intervals=intervals ) errors[label] = None return values, errors @staticmethod def get_stats_discretized( params: dict, bootstraps: pd.DataFrame, model: Parametrization | str, ci_level: float = 0.05, intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'mean' ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: """""" Compute errors and confidence interval for a discretized DFE. :param params: Parameters of the model :param bootstraps: Bootstrapped samples :param model: DFE parametrization :param ci_level: Confidence interval level :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. :param bootstrap_type: Type of bootstrap :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :return: Center values, errors around center, and confidence intervals. """""" # discretize MLE DFE values = Inference.compute_histogram(model, params, intervals) # calculate bootstrapped histograms # get discretized DFE per bootstrap sample bs = np.array([Inference.compute_histogram(model, dict(r), intervals) for _, r in bootstraps.iterrows()]) return Bootstrap.get_errors( values=values, bs=bs, bootstrap_type=bootstrap_type, ci_level=ci_level, point_estimate=point_estimate ) @staticmethod def compute_histogram( model: Parametrization | str, params: dict, intervals: np.ndarray ) -> np.ndarray: """""" Discretize the DFE given a DFE parametrization and its parameter values. :param model: DFE parametrization :param params: Parameters of the model :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. :return: Discretized DFE """""" # discrete DFE y = _from_string(model)._discretize(params, intervals) # return normalized histogram return y / y.sum() class AbstractInference(Serializable, ABC): """""" Base class for main Inference and polyDFE wrapper. """""" def __init__(self, **kwargs): """""" Initialize the inference. :param kwargs: Keyword arguments """""" self._logger = logger.getChild(self.__class__.__name__) self.bootstraps: Optional[pd.DataFrame] = None self.params_mle: Optional[dict] = None self.model: Optional[Parametrization] = None @abstractmethod def get_bootstrap_params(self) -> Dict[str, float]: """""" Get the parameters to be included in the bootstraps. :return: Parameters to be included in the bootstraps """""" pass def get_discretized( self, intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'mean' ) -> Tuple[np.ndarray, Optional[np.ndarray]]: """""" Get discretized DFE. :param intervals: Array of interval boundaries over ``(-inf, inf)`` yielding ``intervals.shape[0] - 1`` bins. :param confidence_intervals: Whether to return confidence intervals :param ci_level: Confidence interval level :param bootstrap_type: Type of bootstrap :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :return: Array of values and array of deviations """""" values, errors = Inference.get_discretized( inferences=[self], labels=['all'], intervals=intervals, confidence_intervals=confidence_intervals, ci_level=ci_level, bootstrap_type=bootstrap_type, point_estimate=point_estimate ) return values['all'], errors['all'] def plot_discretized( self, file: str = None, show: bool = True, intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), confidence_intervals: bool = True, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'mean', title: str = 'discretized DFE', ax: 'plt.Axes' = None, kwargs_legend: dict = dict(prop=dict(size=8)), ) -> 'plt.Axes': """""" Plot discretized DFE. :param file: File to save the plot to :param show: Whether to show the plot :param intervals: Array of interval boundaries over ``(-inf, inf)`` yielding ``intervals.shape[0] - 1`` bars. :param confidence_intervals: Whether to plot confidence intervals :param ci_level: Confidence interval level :param bootstrap_type: Type of bootstrap :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :param title: Title of the plot :param ax: Axes to plot on. Only for Python visualization backend. :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. :return: Axes """""" return Inference.plot_discretized( inferences=[self], file=file, show=show, intervals=intervals, confidence_intervals=confidence_intervals, ci_level=ci_level, bootstrap_type=bootstrap_type, point_estimate=point_estimate, title=title, kwargs_legend=kwargs_legend, ax=ax ) @abstractmethod def get_bootstrap_param_names(self) -> List[str]: """""" Get the names of the parameters to be included in the bootstraps. """""" pass ","Python" "Allele","Sendrowski/fastDFE","fastdfe/bootstrap.py",".py","5285","146",""""""" Bootstrap utilities. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" import logging from typing import Literal, Sequence, Tuple import numpy as np from scipy.stats import norm as normal # get logger logger = logging.getLogger('fastdfe').getChild('Bootstrap') class Bootstrap: """""" Bootstrap utilities. """""" @staticmethod def get_bounds_from_quantile(data: Sequence, a1: float, a2: float, n: int) -> Tuple[float, float]: """""" Get confidence interval bounds. :param data: Sorted data :param a1: Lower quantile :param a2: Upper quantile :param n: Number of data points :return: lower bound and upper bound """""" if np.isnan(a1) or np.isnan(a2): return [None, None] return data[max(round(a1 * n), 0)], data[min(round(a2 * n), n - 1)] @staticmethod def get_ci_percentile(bootstraps: Sequence, a: float) -> Tuple[float, float]: """""" Get the (1 - a)% confidence intervals using the percentile bootstrap. :param bootstraps: List of bootstraps :param a: Confidence level :return: lower bound and upper bound """""" if not 0 <= a <= 0.5: raise ValueError('Confidence level must be between 0 and 0.5.') return Bootstrap.get_bounds_from_quantile(np.sort(bootstraps), a, 1 - a, len(bootstraps)) @staticmethod def get_ci_bca(bootstraps: Sequence, original: float, a: float) -> Tuple[float, float]: """""" Get the (1 - a)% confidence intervals using the BCa method. cf. An Introduction to the Bootstrap, Bradley Efron, Robert J. Tibshirani, section 14.2. :param bootstraps: List of bootstraps :param original: Original value :param a: Confidence level :return: lower bound and upper bound """""" if len(bootstraps) == 0: return [0, 0] n = len(bootstraps) data = np.sort(np.array(bootstraps)) theta_hat_i = np.array([np.var(np.delete(data, i)) for i in range(n)]) theta_hat = sum(theta_hat_i) / n a_hat = sum((theta_hat - theta_hat_i) ** 3) / (6 * (sum((theta_hat - theta_hat_i) ** 2)) ** (3 / 2)) # we add epsilon here to avoid getting -inf when sum(data < original) / n is 0 z0_hat = normal.ppf(sum(data < original) / n + np.finfo(float).eps) z_a = normal.ppf(a) a1 = normal.cdf(z0_hat + (z0_hat + z_a) / (1 - a_hat * (z0_hat + z_a))) a2 = normal.cdf(z0_hat + (z0_hat - z_a) / (1 - a_hat * (z0_hat - z_a))) return Bootstrap.get_bounds_from_quantile(data, a1, a2, n) @staticmethod def get_errors( values: Sequence, bs: np.ndarray, ci_level: float = 0.05, bootstrap_type: Literal['percentile', 'bca'] = 'percentile', point_estimate: Literal['original', 'mean', 'median'] = 'original', ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: """""" Get error values and confidence intervals from the list of original values and its bootstraps for a list of parameters. :param values: The original values. :param bs: Array containing bootstraps as first and the values as second dimension. :param ci_level: The confidence level. :param bootstrap_type: The bootstrap type. :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. :return: Center values, errors around center, and confidence intervals. """""" # number of values n_values = len(values) # use mean of bootstraps instead of original values if point_estimate == 'mean': center = np.mean(bs, axis=0) elif point_estimate == 'median': center = np.median(bs, axis=0) else: center = np.array(values) # determine confidence intervals and errors on y axis if bootstrap_type == 'percentile': cis = np.array([Bootstrap.get_ci_percentile(bs[:, i], ci_level) for i in range(n_values)]).T elif bootstrap_type == 'bca': cis = np.array([Bootstrap.get_ci_bca(bs[:, i], values[i], ci_level) for i in range(n_values)]).T # raise warning if some confidence intervals could not be determined if np.sum(np.equal(cis, None)) > 0: logger.warning('Some confidence intervals could not be computed.') # set undefined confidence intervals to values mask = np.equal(cis, None) for j in range(cis.shape[1]): if mask[:, j].any(): cis[mask[:, j], j] = values[j] else: raise NotImplementedError(f""Bootstrap type {bootstrap_type} not supported."") # determine error relative to center errors = np.array([center - cis[0], cis[1] - center]) # issue notice if some errors are negative if np.sum(np.less(errors, 0)) > 0: logger.debug('Some computed errors were negative and were adjusted to 0.') # set negative errors to 0 errors[errors < 0] = 0 return center, errors, cis ","Python" "Allele","Sendrowski/fastDFE","fastdfe/io_handlers.py",".py","24131","820",""""""" Handlers the reading of VCF, GFF and FASTA files. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-05-29"" import gzip import hashlib import logging import os import shutil import tempfile import warnings from collections import Counter from functools import cached_property from typing import List, Iterable, TextIO, Dict, Optional, Tuple, Union, Sequence from urllib.parse import urlparse import numpy as np import pandas as pd import requests from Bio import SeqIO from Bio.SeqIO.FastaIO import FastaIterator from Bio.SeqRecord import SeqRecord from pandas.errors import SettingWithCopyWarning from tqdm import tqdm from .settings import Settings #: The DNA bases bases = [""A"", ""C"", ""G"", ""T""] # logger logger = logging.getLogger('fastdfe') def get_called_bases(genotypes: Sequence[str]) -> np.ndarray: """""" Get the called bases from a list of calls. :param genotypes: Array of genotypes in the form of strings. :return: Array of called bases. """""" # join genotypes joined_genotypes = ''.join(genotypes).replace('|', '/') # convert to numpy array of characters char_array = np.array(list(joined_genotypes)) # return only characters that are in the bases list return char_array[np.isin(char_array, bases)] def get_major_base(genotypes: Sequence[str]) -> str | None: """""" Get the major base from a list of calls. :param genotypes: Array of genotypes in the form of strings. :return: Major base. """""" # get the called bases bases = get_called_bases(genotypes) if len(bases) > 0: return Counter(bases).most_common()[0][0] def is_monomorphic_snp(variant: Union['cyvcf2.Variant', 'DummyVariant']) -> bool: """""" Whether the given variant is a monomorphic SNP. :param variant: The vcf site :return: Whether the site is a monomorphic SNP """""" return (not (variant.is_snp or variant.is_mnp or variant.is_indel or variant.is_deletion or variant.is_sv) and variant.REF in bases) def count_sites( vcf: str | Iterable['cyvcf2.Variant'], max_sites: int = np.inf, desc: str = 'Counting sites' ) -> int: """""" Count the number of sites in the VCF. :param vcf: The path to the VCF file or an iterable of variants :param max_sites: Maximum number of sites to consider :param desc: Description for the progress bar :return: Number of sites """""" # if we don't have a file path, we can just count the number of variants if not isinstance(vcf, str): return len(list(vcf)) i = 0 with open_file(vcf) as f: with tqdm(disable=Settings.disable_pbar, desc=desc) as pbar: for line in f: if not line.startswith('#'): i += 1 pbar.update() # stop counting if max_sites was reached if i >= max_sites: break return i def download_if_url(path: str, cache: bool = True, desc: str = 'Downloading file') -> str: """""" Download the VCF file if it is a URL. :param path: The path to the VCF file. :param cache: Whether to cache the file. :param desc: Description for the progress bar :return: The path to the downloaded file or the original path. """""" if FileHandler.is_url(path): # download the file and return path return FileHandler.download_file(path, cache=cache, desc=desc) return path def open_file(file: str) -> TextIO: """""" Open a file, either gzipped or not. :param file: File to open :return: stream """""" if file.endswith('.gz'): return gzip.open(file, ""rt"") return open(file, 'r') class FileHandler: """""" Base class for file handling. """""" #: The logger instance _logger = logger.getChild(__qualname__) def __init__(self, cache: bool = True, aliases: Dict[str, List[str]] = {}): """""" Create a new FileHandler instance. :param cache: Whether to cache files that are downloaded from URLs :param aliases: The contig aliases. """""" #: Whether to cache files that are downloaded from URLs self.cache: bool = cache #: The contig mappings self._alias_mappings, self.aliases = self._expand_aliases(aliases) @staticmethod def _expand_aliases(alias_dict: Dict[str, List[str]]) -> Tuple[Dict[str, str], Dict[str, List[str]]]: """""" Expand the contig aliases. """""" # map alias to primary alias mappings = {} # map primary alias to all aliases aliases = {} for contig, alias_list in alias_dict.items(): all_aliases = alias_list + [contig] aliases[contig] = all_aliases for alias in all_aliases: mappings[alias] = contig return mappings, aliases @staticmethod def is_url(path: str) -> bool: """""" Check if the given path is a URL. :param path: The path to check. :return: ``True`` if the path is a URL, ``False`` otherwise. """""" try: result = urlparse(path) return all([result.scheme, result.netloc]) except ValueError: return False def download_if_url(self, path: str) -> str: """""" Download the VCF file if it is a URL. :param path: The path to the VCF file. :return: The path to the downloaded file or the original path. """""" return download_if_url(path, cache=self.cache, desc=f'{self.__class__.__name__}>Downloading file') @staticmethod def unzip_if_zipped(file: str): """""" If the given file is gzipped, unzip it and return the path to the unzipped file. If the file is not gzipped, return the path to the original file. :param file: The path to the file. :return: The path to the unzipped file, or the original file if it was not gzipped. """""" # check if the file extension is .gz if file.endswith('.gz'): # create a new file path by removing the .gz extension unzipped = file[:-3] # unzip file with gzip.open(file, 'rb') as f_in: with open(unzipped, 'wb') as f_out: shutil.copyfileobj(f_in, f_out) return unzipped return file @staticmethod def get_filename(url: str): """""" Return the file extension of a URL. :param url: The URL to get the file extension from. :return: The file extension. """""" return os.path.basename(urlparse(url).path) @staticmethod def hash(s: str) -> str: """""" Return a truncated SHA1 hash of a string. :param s: The string to hash. :return: The SHA1 hash. """""" return hashlib.sha1(s.encode()).hexdigest()[:12] @classmethod def download_file(cls, url: str, cache: bool = True, desc: str = 'Downloading file') -> str: """""" Download a file from a URL. :param cache: Whether to cache the file. :param url: The URL to download the file from. :param desc: Description for the progress bar :return: The path to the downloaded file. """""" # extract the file extension from the URL filename = FileHandler.get_filename(url) # create a temporary file path path = tempfile.gettempdir() + '/' + FileHandler.hash(url) + '.' + filename # check if the file is already cached if cache and os.path.exists(path): cls._logger.info(f'Using cached file at {path}') return path cls._logger.info(f'Downloading file from {url}') # start the stream response = requests.get(url, stream=True) # check if the request was successful response.raise_for_status() # create a temporary file with the original file extension with tempfile.NamedTemporaryFile(delete=False) as tmp: total_size = int(response.headers.get('content-length', 0)) chunk_size = 8192 with tqdm(total=total_size, unit='B', unit_scale=True, desc=desc, disable=Settings.disable_pbar) as pbar: # write the file to disk for chunk in response.iter_content(chunk_size=chunk_size): if chunk: tmp.write(chunk) pbar.update(len(chunk)) # rename the file to the original file extension os.rename(tmp.name, path) if cache: cls._logger.info(f'Cached file at {path}') return path def get_aliases(self, contig: str) -> List[str]: """""" Get all aliases for the given contig alias including the primary alias. :param contig: The contig. :return: The aliases. """""" if contig in self._alias_mappings: return self.aliases[self._alias_mappings[contig]] return [contig] class FASTAHandler(FileHandler): def __init__(self, fasta: str | None, cache: bool = True, aliases: Dict[str, List[str]] = {}): """""" Create a new FASTAHandler instance. :param fasta: The path to the FASTA file. :param cache: Whether to cache files that are downloaded from URLs :param aliases: The contig aliases. """""" FileHandler.__init__(self, cache=cache, aliases=aliases) #: The path to the FASTA file. self.fasta: str = fasta #: The current contig. self._contig: SeqRecord | None = None @cached_property def _ref(self) -> FastaIterator | None: """""" Get the reference reader. :return: The reference reader. """""" if self.fasta is None: return return self.load_fasta(self.fasta) def load_fasta(self, file: str) -> FastaIterator: """""" Load a FASTA file into a dictionary. :param file: The path to The FASTA file path, possibly gzipped or a URL :return: Iterator over the sequences. """""" self._logger.info(""Loading FASTA file"") # download and unzip if necessary local_file = self.unzip_if_zipped(self.download_if_url(file)) return SeqIO.parse(local_file, 'fasta') def get_contig(self, aliases, rewind: bool = True, notify: bool = True) -> SeqRecord: """""" Get the contig from the FASTA file. Note that ``pyfaidx`` would be more efficient here, but there were problems when running it in parallel. :param aliases: The contig aliases. :param rewind: Whether to allow for rewinding the iterator if the contig is not found. :param notify: Whether to notify the user when rewinding the iterator. :return: The contig. """""" # if the contig is already loaded, we can just return it if self._contig is not None and self._contig.id in aliases: return self._contig # if the contig is not loaded, we can try to load it try: self._contig = next(self._ref) # iterate until we find the contig while self._contig.id not in aliases: self._contig = next(self._ref) except StopIteration: # if rewind is ``True``, we can rewind the iterator and try again if rewind: if notify: self._logger.info(""Rewinding FASTA iterator."") # renew fasta iterator FASTAHandler._rewind(self) return self.get_contig(aliases, rewind=False) raise LookupError(f'None of the contig aliases {aliases} were found in the FASTA file.') return self._contig def get_contig_names(self) -> List[str]: """""" Get the names of the contigs in the FASTA file. :return: The contig names. """""" return [contig.id for contig in self._ref] def _rewind(self): """""" Rewind the fasta iterator. """""" if hasattr(self, '_ref'): # noinspection all del self._ref class GFFHandler(FileHandler): """""" GFF handler. """""" def __init__(self, gff: str | None, cache: bool = True, aliases: Dict[str, List[str]] = {}): """""" Constructor. :param gff: The path to the GFF file. :param cache: Whether to cache the file. :param aliases: The contig aliases. """""" FileHandler.__init__(self, cache=cache, aliases=aliases) #: The logger self._logger = logger.getChild(self.__class__.__name__) #: The GFF file path self.gff = gff @cached_property def _cds(self) -> pd.DataFrame | None: """""" The coding sequences. :return: Dataframe with coding sequences. """""" if self.gff is None: return return self._load_cds() def _load_cds(self) -> pd.DataFrame: """""" Load coding sequences from a GFF file. :return: The DataFrame. """""" self._logger.info(f'Loading GFF file') # download and unzip if necessary local_file = self.unzip_if_zipped(self.download_if_url(self.gff)) # column labels for GFF file col_labels = ['seqid', 'source', 'type', 'start', 'end', 'score', 'strand', 'phase', 'attributes'] dtypes = dict( seqid='category', type='category', start=float, # temporarily load as float to handle NA values end=float, # temporarily load as float to handle NA values strand='category', phase='category' ) # load GFF file df = pd.read_csv( local_file, sep='\t', comment='#', names=col_labels, dtype=dtypes, usecols=['seqid', 'type', 'start', 'end', 'strand', 'phase'] ) # filter for coding sequences df = df[df['type'] == 'CDS'] # drop rows with NA values df = df.dropna() # convert start and end to int df['start'] = df['start'].astype(int) df['end'] = df['end'].astype(int) # drop type column df.drop(columns=['type'], inplace=True) # remove duplicates df = df.drop_duplicates(subset=['seqid', 'start', 'end']) # sort by seqid and start df.sort_values(by=['seqid', 'start'], inplace=True) return df def _count_target_sites(self, remove_overlaps: bool = False, contigs: List[str] = None) -> Dict[str, int]: """""" Count the number of target sites in a GFF file. :param remove_overlaps: Whether to remove overlapping coding sequences. :param contigs: The contigs to consider. :return: The number of target sites per chromosome/contig. """""" cds = self._add_lengths( cds=self._load_cds(), remove_overlaps=remove_overlaps, contigs=contigs ) # group by 'seqid' and calculate the sum of 'length' target_sites = cds.groupby('seqid', observed=False)['length'].sum().to_dict() # filter explicitly for contigs if necessary # as seqid is a categorical variable, groups were retained even if they were filtered out if contigs is not None: target_sites = {k: v for k, v in target_sites.items() if k in contigs} return target_sites @staticmethod def remove_overlaps(df: pd.DataFrame) -> pd.DataFrame: """""" Remove overlapping coding sequences. :param df: The coding sequences. :return: The coding sequences without overlaps. """""" with warnings.catch_warnings(): warnings.simplefilter(""ignore"", category=SettingWithCopyWarning) df['overlap'] = df['start'].shift(-1) <= df['end'] df = df[~df['overlap']] return df.drop(columns=['overlap']) @staticmethod def _add_lengths(cds: pd.DataFrame, remove_overlaps: bool = False, contigs: List[str] = None) -> pd.DataFrame: """""" Compute coding sequences lengths. :param cds: The coding sequences. :param remove_overlaps: Whether to remove overlapping coding sequences. :param contigs: The contigs to consider. :return: The coding sequences with lengths. """""" # filter for contigs if necessary if contigs is not None: cds = cds[cds['seqid'].isin(contigs)] # remove duplicates cds = cds.drop_duplicates(subset=['seqid', 'start']) # remove overlaps if remove_overlaps: cds = GFFHandler.remove_overlaps(cds) # catch warning when adding a new column to a slice of a DataFrame with warnings.catch_warnings(): warnings.simplefilter(""ignore"", category=SettingWithCopyWarning) # create a new column for the difference between 'end' and 'start' cds['length'] = cds['end'] - cds['start'] + 1 return cds class VCFHandler(FileHandler): """""" Base class for VCF handling. """""" def __init__( self, vcf: str | Iterable['cyvcf2.Variant'], info_ancestral: str = 'AA', max_sites: int = np.inf, seed: int | None = 0, cache: bool = True, aliases: Dict[str, List[str]] = {} ): """""" Create a new VCF instance. :param vcf: The path to the VCF file or an iterable of variants, can be gzipped, urls are also supported :param info_ancestral: The tag in the INFO field that contains the ancestral allele :param max_sites: Maximum number of sites to consider :param seed: Seed for the random number generator. Use ``None`` for no seed. :param cache: Whether to cache files that are downloaded from URLs :param aliases: The contig aliases. """""" FileHandler.__init__(self, cache=cache, aliases=aliases) #: The path to the VCF file or an iterable of variants self.vcf = vcf #: The tag in the INFO field that contains the ancestral allele self.info_ancestral: str = info_ancestral #: Maximum number of sites to consider self.max_sites: int = int(max_sites) if not np.isinf(max_sites) else np.inf #: Seed for the random number generator self.seed: Optional[int] = int(seed) if seed is not None else None #: Random generator instance self.rng = np.random.default_rng(seed=seed) @cached_property def _reader(self) -> 'cyvcf2.VCF': """""" Get the VCF reader. :return: The VCF reader. """""" return self.load_vcf() def _rewind(self): """""" Rewind the VCF iterator. """""" if hasattr(self, '_reader'): # noinspection all del self._reader def load_vcf(self) -> 'cyvcf2.VCF': """""" Load a VCF file into a dictionary. :return: The VCF reader. """""" try: from cyvcf2 import VCF except ImportError: raise ImportError( ""VCF support in fastdfe requires the optional 'cyvcf2' package. "" ""Please install fastdfe with the 'vcf' extra: pip install fastdfe[vcf]"" ) self._logger.info(""Loading VCF file"") return VCF(self.download_if_url(self.vcf)) @cached_property def n_sites(self) -> int: """""" Get the number of sites in the VCF. :return: Number of sites """""" return self.count_sites() def count_sites(self) -> int: """""" Count the number of sites in the VCF. :return: Number of sites """""" return count_sites( vcf=self.download_if_url(self.vcf), max_sites=self.max_sites, desc=f'{self.__class__.__name__}>Counting sites' ) def get_pbar(self, desc: str = ""Processing sites"", total: int | None = 0) -> tqdm: """""" Return a progress bar for the number of sites. :param desc: Description for the progress bar :param total: Total number of items :return: tqdm """""" return tqdm( total=self.n_sites if total == 0 else total, disable=Settings.disable_pbar, desc=desc ) class MultiHandler(VCFHandler, FASTAHandler, GFFHandler): """""" Handle VCF, FASTA and GFF files. """""" def __init__( self, vcf: str | Iterable['cyvcf2.Variant'], fasta: str | None = None, gff: str | None = None, info_ancestral: str = 'AA', max_sites: int = np.inf, seed: int | None = 0, cache: bool = True, aliases: Dict[str, List[str]] = {} ): """""" Create a new MultiHandler instance. :param vcf: The path to the VCF file or an iterable of variants, can be gzipped, urls are also supported :param fasta: The path to the FASTA file. :param gff: The path to the GFF file. :param info_ancestral: The tag in the INFO field that contains the ancestral allele :param max_sites: Maximum number of sites to consider :param seed: Seed for the random number generator. Use ``None`` for no seed. :param cache: Whether to cache files that are downloaded from URLs :param aliases: The contig aliases. """""" # initialize vcf handler VCFHandler.__init__( self, vcf=vcf, info_ancestral=info_ancestral, max_sites=max_sites, seed=seed, cache=cache, aliases=aliases ) # initialize fasta handler FASTAHandler.__init__( self, fasta=fasta, cache=cache, aliases=aliases ) # initialize gff handler GFFHandler.__init__( self, gff=gff, cache=cache, aliases=aliases ) def _require_fasta(self, class_name: str): """""" Raise an exception if no FASTA file was provided. :param class_name: The name of the class that requires a FASTA file. """""" if self.fasta is None: raise ValueError(f'{class_name} requires a FASTA file to be specified.') def _require_gff(self, class_name: str): """""" Raise an exception if no GFF file was provided. :param class_name: The name of the class that requires a GFF file. """""" if self.gff is None: raise ValueError(f'{class_name} requires a GFF file to be specified.') def _rewind(self): """""" Rewind the fasta and vcf handler. """""" FASTAHandler._rewind(self) VCFHandler._rewind(self) class NoTypeException(BaseException): """""" Exception thrown when no type can be determined. """""" pass class DummyVariant: """""" Dummy variant class to emulate a mono-allelic site. """""" #: Whether the variant is an SNP is_snp = False #: Whether the variant is an MNP is_mnp = False #: Whether the variant is an indel is_indel = False #: Whether the variant is a deletion is_deletion = False #: Whether the variant is a structural variant is_sv = False #: The alternate alleles ALT = [] def __init__(self, ref: str, pos: int, chrom: str): """""" Initialize the dummy variant. :param ref: The reference allele :param pos: The position :param chrom: The contig """""" #: The reference allele self.REF = ref #: The position self.POS = pos #: The contig self.CHROM = chrom #: Info field self.INFO = {} ","Python" "Allele","Sendrowski/fastDFE","fastdfe/json_handlers.py",".py","3912","166",""""""" JSON handlers. """""" __author__ = ""Janek Sendrowski"" __contact__ = ""sendrowski.janek@gmail.com"" __date__ = ""2023-02-26"" import json import logging import numpy as np import pandas as pd from jsonpickle.handlers import BaseHandler from .optimization import SharedParams, Covariate from .parametrization import Parametrization from .spectrum import Spectrum, Spectra # configure logger logger = logging.getLogger('fastdfe') class NumpyArrayHandler(BaseHandler): """""" Handler for numpy arrays. """""" def flatten(self, x: np.ndarray, data: dict) -> dict: """""" Convert Spectrum to dict. :param x: Numpy array :param data: Dictionary :return: Simplified dictionary """""" return data | dict(data=x.tolist()) def restore(self, data: dict) -> np.ndarray: """""" Restore Spectrum. :param data: Dictionary :return: Numpy array """""" return np.array(data['data']) class SpectrumHandler(BaseHandler): """""" Handler for spectrum objects. """""" def flatten(self, sfs: Spectrum, data: dict) -> dict: """""" Convert Spectrum to dict. :param sfs: Spectrum object :param data: Dictionary :return: Simplified dictionary """""" return data | dict(data=sfs.to_list()) def restore(self, data: dict) -> Spectrum: """""" Restore Spectrum. :param data: Dictionary :return: Spectrum object """""" return Spectrum.from_list(data['data']) class SpectraHandler(BaseHandler): """""" Handler for spectra objects. """""" def flatten(self, sfs: Spectra, data: dict) -> dict: """""" Convert Spectra to dict. :param sfs: Spectra object :param data: Dictionary :return: Simplified dictionary """""" return data | dict(data=sfs.to_dict()) def restore(self, data: dict) -> Spectra: """""" Restore Spectra. :param data: Dictionary :return: Spectra object """""" return Spectra.from_dict(data['data']) class DataframeHandler(BaseHandler): """""" There were also problems with dataframes, hence the custom handler. """""" def flatten(self, df: pd.DataFrame, data: dict) -> dict: """""" Convert dataframe to dict. :param df: Dataframe :param data: Dictionary :return: Simplified dictionary """""" return data | dict(data=df.to_dict()) def restore(self, data: dict) -> pd.DataFrame: """""" Restore dataframe. :param data: Dictionary :return: Dataframe """""" return pd.DataFrame(data['data']) class CustomEncoder(json.JSONEncoder): """""" Convert numpy arrays and objects to lists and primitives. """""" def default(self, obj): """""" Convert numpy arrays and objects to lists and primitives. :param obj: Object :return: Simplified object """""" from scipy.optimize._lbfgsb_py import LbfgsInvHessProduct if isinstance(obj, Spectrum): return obj.to_list() if isinstance(obj, Spectra): return obj.to_dict() if isinstance(obj, np.ndarray): return obj.tolist() if isinstance(obj, np.int64): return int(obj) if isinstance(obj, Parametrization): return type(obj).__name__ if isinstance(obj, SharedParams): return obj.__dict__ if isinstance(obj, Covariate): # Only include 'param' and 'values' to avoid cluttering # the config file. return dict(param=obj.param, values=obj.values) # there were serialization problems with this object if isinstance(obj, LbfgsInvHessProduct): return str(obj) return json.JSONEncoder.default(self, obj) ","Python" "Allele","Sendrowski/fastDFE","docs/conf.py",".py","1971","72","# Configuration file for the Sphinx documentation builder. # # For the full list of built-in configuration values, see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html import datetime import sys sys.path.append('..') # -- Project information ----------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information project = 'fastDFE' year = datetime.datetime.now().year copyright = f'{year}, Janek Sendrowski' author = 'Janek Sendrowski' release = '1.2.1' # -- General configuration --------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.viewcode', 'sphinx_autodoc_typehints', 'sphinx_copybutton', 'myst_nb', 'sphinxcontrib.bibtex', 'sphinx_book_theme' ] bibtex_bibfiles = ['refs.bib'] typehints_use_signature = True typehints_fully_qualified = False pygments_style = 'default' # disable notebook execution nb_execution_mode = 'off' templates_path = ['_templates'] exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] autodoc_default_options = { 'members': True, 'inherited-members': True, 'member-order': 'bysource', 'special-members': '__init__', 'undoc-members': True } add_module_names = False # -- Options for HTML output ------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output html_theme = 'sphinx_book_theme' html_theme_options = { 'search_bar_text': 'Search...', 'repository_url': 'https://github.com/Sendrowski/fastdfe', 'repository_branch': 'master', 'use_repository_button': True, 'use_edit_page_button': False, 'use_issues_button': False } html_static_path = ['_static'] html_css_files = [""custom.css""] html_logo = ""logo.png"" html_favicon = ""favicon.ico"" ","Python" "Allele","Sendrowski/fastDFE","docs/reference/R/parser.ipynb",".ipynb","66555","297","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# VCF parsing\n"", ""## Introduction\n"", ""fastDFE provides parser utilities that enable convenient parsing of frequency spectra from VCF files. By default, {class}`~fastdfe.parser.Parser` looks at the ``AA`` tag in the VCF file's info field to retrieve the correct polarization. Sites for which this tag is not well-defined are by default included (see {attr}`~fastdfe.parser.Parser.skip_not_polarized`). Note that non-polarized frequency spectra provide little information on the distribution of beneficial mutations, however.\n"", ""\n"", ""We might also want to stratify the SFS by some site properties, such as site-degeneracy. This is done by passing stratifications to the parser. In this example, we will stratify the SFS by 0-fold and 4-fold degenerate sites using a VCF file for ``Betula spp.``"" ] }, { ""cell_type"": ""code"", ""execution_count"": 7, ""metadata"": { ""editable"": true, ""is_executing"": true, ""slideshow"": { ""slide_type"": """" }, ""tags"": [] }, ""outputs"": [], ""source"": [ ""library(fastdfe)\n"", ""\n"", ""# load the fastdfe package\n"", ""fd <- load_fastdfe()\n"", ""\n"", ""# url to the GitHub repository of fastDFE\n"", ""url <- \""https://github.com/Sendrowski/fastDFE/blob/dev/\"""" ] }, { ""metadata"": { ""tags"": [ ""remove-cell"" ] }, ""cell_type"": ""code"", ""outputs"": [], ""execution_count"": null, ""source"": [ ""setwd(\""/Users/au732936/PycharmProjects/fastDFE\"")\n"", ""reticulate::use_condaenv(\""/Users/au732936/miniconda3/envs/dev-r-fastdfe\"", required = TRUE)\n"", ""source(\""R/fastdfe.R\"")\n"", ""fastdfe <- load_fastdfe()"" ] }, { ""cell_type"": ""code"", ""execution_count"": 9, ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2023-10-06T11:49:59.010Z"", ""start_time"": ""2023-10-06T11:49:58.962952Z"" } }, ""outputs"": [], ""source"": [ ""# instantiate parser\n"", ""p <- fd$Parser(\n"", "" n = 8,\n"", "" vcf = paste0(url, \""resources/genome/betula/biallelic.polarized.subset.50000.vcf.gz?raw=true\""),\n"", "" fasta = paste0(url, \""resources/genome/betula/genome.subset.1000.fasta.gz?raw=true\""),\n"", "" gff = paste0(url, \""resources/genome/betula/genome.gff.gz?raw=true\""),\n"", "" annotations = c(\n"", "" fd$DegeneracyAnnotation()\n"", "" ),\n"", "" stratifications = c(fd$DegeneracyStratification())\n"", "")\n"", ""\n"", ""# parse SFS\n"", ""spectra <- fd$Parser$parse(p)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 10, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nAAGKwyqM4iKAAAIIIBAJAv8PswT36m3q2ZIAAAAASUVORK5CYII="", ""text/plain"": [ ""plot without title"" ] }, ""metadata"": { ""image/png"": { ""height"": 192, ""width"": 276 } }, ""output_type"": ""display_data"" } ], ""source"": [ ""# visualize SFS\n"", ""p <- fd$Spectra$plot(spectra)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""fastDFE relies here on VCF info tags to determine the degeneracy of a site but this behavior can be customized (cf. {class}`~fastdfe.parser.DegeneracyStratification`)."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""## Stratifications\n"", ""We can use also several stratifications in tandem by specifying a list of stratifications. In this example, we will stratify the SFS by synonymy as well as base transitions type. The resulting spectra can be fed directly into fastDFE's inference routines. See {mod}`~fastdfe.parser` module for a complete list of available stratifications."" ] }, { ""cell_type"": ""code"", ""execution_count"": 11, ""metadata"": {}, ""outputs"": [], ""source"": [ ""# instantiate parser\n"", ""p <- fd$Parser(\n"", "" n = 8,\n"", "" vcf = paste0(url, \""resources/genome/betula/biallelic.polarized.subset.50000.vcf.gz?raw=true\""),\n"", "" fasta = paste0(url, \""resources/genome/betula/genome.subset.1000.fasta.gz?raw=true\""),\n"", "" gff = paste0(url, \""resources/genome/betula/genome.gff.gz?raw=true\""),\n"", "" annotations = c(\n"", "" fd$DegeneracyAnnotation()\n"", "" ),\n"", "" stratifications = c(\n"", "" fd$DegeneracyStratification(),\n"", "" fd$AncestralBaseStratification()\n"", "" )\n"", "")\n"", ""\n"", ""# parse SFS\n"", ""spectra <- fd$Parser$parse(p)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 12, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\n0f8ec4YkQAIkQAIkYDkC/w/Y0iAiaYCkuQAAAABJRU5ErkJggg=="", ""text/plain"": [ ""plot without title"" ] }, ""metadata"": { ""image/png"": { ""height"": 192, ""width"": 276 } }, ""output_type"": ""display_data"" } ], ""source"": [ ""# visualize SFS\n"", ""p <- fd$Spectra$plot(spectra)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Note that fastDFE requires the ancestral state of sites to be determined. The {class}`~fastdfe.parser.Parser` achieves this by examining the `AA` field, although this behavior can be customized.\n"", ""\n"", ""## Annotations\n"", ""fastDFE provides a number of annotations accessible directly during the parsing process. To annotate a VCF file directly, consider using the {class}`~fastdfe.annotation.Annotator` class.\n"", ""\n"", ""### Degeneracy Annotation\n"", ""{class}`~fastdfe.annotation.DegeneracyAnnotation` annotates the SFS by the degeneracy of the site. This annotation requires information from a FASTA and GFF file and is useful for stratifying the SFS by 0-fold and 4-fold degenerate sites which is what we often want to do when inferring the DFE (see {class}`~fastdfe.parser.DegeneracyStratification`)."" ] }, { ""cell_type"": ""code"", ""execution_count"": 14, ""metadata"": { ""collapsed"": false, ""jupyter"": { ""outputs_hidden"": false } }, ""outputs"": [], ""source"": [ ""# example for degeneracy annotation\n"", ""ann <- fd$Annotator(\n"", "" vcf = paste0(url, \""resources/genome/betula/biallelic.subset.10000.vcf.gz?raw=true\""),\n"", "" fasta = paste0(url, \""resources/genome/betula/genome.subset.1000.fasta.gz?raw=true\""),\n"", "" gff = paste0(url, \""resources/genome/betula/genome.gff.gz?raw=true\""),\n"", "" annotations = c(fd$DegeneracyAnnotation()),\n"", "" output = \""genome.deg.vcf.gz\""\n"", "")\n"", ""\n"", ""fd$Annotator$annotate(ann)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": { ""collapsed"": false, ""jupyter"": { ""outputs_hidden"": false } }, ""source"": [ ""### Ancestral Allele Annotation\n"", ""Currently, two ancestral allele annotations are available: {class}`~fastdfe.annotation.MaximumParsimonyAncestralAnnotation` and {class}`~fastdfe.annotation.MaximumLikelihoodAncestralAnnotation`. The former is straightforward but susceptible to errors, and only appropriate if no outgroup information is available. Alternatively, if outgroups are missing, DFE inference can also be performed on folded spectra, but please note that this will yield less precise estimates. Ideally, we would like to use {class}`~fastdfe.annotation.MaximumLikelihoodAncestralAnnotation`, which is more sophisticated and requires one or several outgroup to be specified. Its underlying model is very similar to [EST-SFS](https://doi.org/10.1534/genetics.118.301120)."" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""metadata"": { ""collapsed"": false, ""jupyter"": { ""outputs_hidden"": false } }, ""outputs"": [], ""source"": [ ""# example for ancestral allele annotation with outgroups\n"", ""ann <- fd$Annotator(\n"", "" vcf = paste0(url, \""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz?raw=true\""),\n"", "" annotations = c(fd$MaximumLikelihoodAncestralAnnotation(\n"", "" outgroups = list(\""ERR2103730\""),\n"", "" n_ingroups = 10\n"", "" )),\n"", "" output = \""genome.aa.vcf.gz\""\n"", "")\n"", ""\n"", ""fd$Annotator$annotate(ann)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": { ""collapsed"": false, ""jupyter"": { ""outputs_hidden"": false } }, ""source"": [ ""## Filtrations\n"", ""fastDFE also offers a number of filtrations which can be accessed immediately while parsing. Alternatively, to filter a VCF file directly, use the {class}`~fastdfe.filtration.Filterer` class. Some useful filtrations include {class}`~fastdfe.filtration.DeviantOutgroupFiltration`, {class}`~fastdfe.filtration.CodingSequenceFiltration`, and {class}`~fastdfe.filtration.BiasedGCConversionFiltration`. For a complete list of available filtrations, refer to the API reference."" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""metadata"": { ""collapsed"": false, ""jupyter"": { ""outputs_hidden"": false } }, ""outputs"": [], ""source"": [ ""# example for filtration\n"", ""f <- fd$Filterer(\n"", "" vcf = paste0(url, \""resources/genome/betula/biallelic.subset.10000.vcf.gz?raw=true\""),\n"", "" filtrations = c(fd$BiasedGCConversionFiltration()),\n"", "" output = \""genome.gc.vcf.gz\""\n"", "")\n"", ""\n"", ""fd$Filterer$filter(f)"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""R"", ""language"": ""R"", ""name"": ""ir"" }, ""language_info"": { ""codemirror_mode"": ""r"", ""file_extension"": "".r"", ""mimetype"": ""text/x-r-source"", ""name"": ""R"", ""pygments_lexer"": ""r"", ""version"": ""4.5.2"" } }, ""nbformat"": 4, ""nbformat_minor"": 4 } ","Unknown" "Allele","Sendrowski/fastDFE","docs/reference/R/inference.ipynb",".ipynb","547393","1124","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# DFE inference\n"", ""## Estimating the deleterious DFE\n"", ""A short overview of basic DFE inference and bootstrapping is available in the {doc}`quickstart guide <../R/quickstart>`. DFE inference requires one `neutral` and one `selected` SFS. In this example we use the bundled `Betula pendula` (silver birch) data. By default, bootstrapping is performed automatically, and the inference estimates only the deleterious component of the DFE using {class}`~fastdfe.parametrization.GammaExpParametrization`."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""is_executing"": true }, ""source"": [ ""library(fastdfe)\n"", ""\n"", ""# load the fastdfe package\n"", ""fd <- load_fastdfe()"" ], ""outputs"": [], ""execution_count"": null }, { ""metadata"": { ""is_executing"": true, ""tags"": [ ""remove-cell"" ], ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:39:30.125230Z"", ""start_time"": ""2026-01-04T10:39:02.664983Z"" } }, ""cell_type"": ""code"", ""source"": [ ""setwd(\""/Users/au732936/PycharmProjects/fastDFE\"")\n"", ""\n"", ""reticulate::use_condaenv(\""/Users/au732936/miniconda3/envs/dev-r-fastdfe\"", required = TRUE)\n"", ""reticulate::py_run_string(\""import numpy as np; np.set_printoptions(legacy='1.25')\"")\n"", ""\n"", ""source(\""R/fastdfe.R\"")\n"", ""fd <- load_fastdfe()\n"", ""\n"", ""fd$Settings$parallelize <- FALSE"" ], ""outputs"": [], ""execution_count"": 1 }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:39:37.871381Z"", ""start_time"": ""2026-01-04T10:39:30.133080Z"" } }, ""cell_type"": ""code"", ""source"": [ ""sfs_neut <- fd$Spectrum(c(177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 0))\n"", ""sfs_sel <- fd$Spectrum(c(797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 0))\n"", ""\n"", ""# create inference object\n"", ""inf <- fd$BaseInference(\n"", "" sfs_neut = sfs_neut,\n"", "" sfs_sel = sfs_sel\n"", "")\n"", ""\n"", ""# run inference\n"", ""sfs_modelled <- inf$run()\n"", ""\n"", ""p <- inf$plot_discretized();"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nAAEEEEAgWQL/D0LVEmI87kN7AAAAAElFTkSuQmCC"" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 2 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""It is always good practice to check the variability of estimates across optimization runs to ensure stability. Here, both the standard deviations across initial runs and across runs within each bootstrap sample are low, indicating stable estimates. Individual runs and bootstrap results can be inspected in the corresponding dataframes (cf. {attr}`~fastdfe.base_inference.BaseInference.runs` and {attr}`~fastdfe.base_inference.BaseInference.bootstraps`)."" }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:39:37.896717Z"", ""start_time"": ""2026-01-04T10:39:37.883877Z"" } }, ""cell_type"": ""code"", ""source"": ""inf$runs[sapply(inf$runs, is.numeric)]"", ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\t\n"", ""\t\n"", ""\n"", ""\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\n"", ""

A data.frame: 10 × 7
all.S_d	all.b	all.p_b	all.S_b	all.eps	all.h	likelihood
<dbl>	<dbl>	<dbl>	<dbl>	<dbl>	<dbl>	<dbl>
-33894.99	0.1305440	0	1	0	0.5	-35.43797
-33893.68	0.1305446	0	1	0	0.5	-35.43797
-33888.72	0.1305467	0	1	0	0.5	-35.43797
-33894.10	0.1305444	0	1	0	0.5	-35.43797
-33893.74	0.1305445	0	1	0	0.5	-35.43797
-33898.59	0.1305425	0	1	0	0.5	-35.43797
-33894.18	0.1305443	0	1	0	0.5	-35.43797
-33890.69	0.1305458	0	1	0	0.5	-35.43797
-33891.09	0.1305456	0	1	0	0.5	-35.43797
-33893.18	0.1305448	0	1	0	0.5	-35.43797

\n"" ], ""text/markdown"": ""\nA data.frame: 10 × 7\n\n| all.S_d <dbl> | all.b <dbl> | all.p_b <dbl> | all.S_b <dbl> | all.eps <dbl> | all.h <dbl> | likelihood <dbl> |\n|---|---|---|---|---|---|---|\n| -33894.99 | 0.1305440 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33893.68 | 0.1305446 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33888.72 | 0.1305467 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33894.10 | 0.1305444 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33893.74 | 0.1305445 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33898.59 | 0.1305425 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33894.18 | 0.1305443 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33890.69 | 0.1305458 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33891.09 | 0.1305456 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33893.18 | 0.1305448 | 0 | 1 | 0 | 0.5 | -35.43797 |\n\n"", ""text/latex"": ""A data.frame: 10 × 7\n\\begin{tabular}{lllllll}\n all.S\\_d & all.b & all.p\\_b & all.S\\_b & all.eps & all.h & likelihood\\\\\n & & & & & & \\\\\n\\hline\n\t -33894.99 & 0.1305440 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33893.68 & 0.1305446 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33888.72 & 0.1305467 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33894.10 & 0.1305444 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33893.74 & 0.1305445 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33898.59 & 0.1305425 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33894.18 & 0.1305443 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33890.69 & 0.1305458 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33891.09 & 0.1305456 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33893.18 & 0.1305448 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\\end{tabular}\n"", ""text/plain"": [ "" all.S_d all.b all.p_b all.S_b all.eps all.h likelihood\n"", ""1 -33894.99 0.1305440 0 1 0 0.5 -35.43797 \n"", ""2 -33893.68 0.1305446 0 1 0 0.5 -35.43797 \n"", ""3 -33888.72 0.1305467 0 1 0 0.5 -35.43797 \n"", ""4 -33894.10 0.1305444 0 1 0 0.5 -35.43797 \n"", ""5 -33893.74 0.1305445 0 1 0 0.5 -35.43797 \n"", ""6 -33898.59 0.1305425 0 1 0 0.5 -35.43797 \n"", ""7 -33894.18 0.1305443 0 1 0 0.5 -35.43797 \n"", ""8 -33890.69 0.1305458 0 1 0 0.5 -35.43797 \n"", ""9 -33891.09 0.1305456 0 1 0 0.5 -35.43797 \n"", ""10 -33893.18 0.1305448 0 1 0 0.5 -35.43797 "" ] }, ""metadata"": {}, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 3 }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:39:37.919246Z"", ""start_time"": ""2026-01-04T10:39:37.903943Z"" } }, ""cell_type"": ""code"", ""source"": ""head(inf$bootstraps[sapply(inf$bootstraps, is.numeric)], 10)"", ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\t\n"", ""\t\n"", ""\n"", ""\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\t\n"", ""\n"", ""

A data.frame: 10 × 10
	S_d	b	p_b	S_b	eps	h	likelihood	i_best_run	likelihoods_std	alpha
	<dbl>	<dbl>	<dbl>	<dbl>	<dbl>	<dbl>	<dbl>	<dbl>	<dbl>	<dbl>
1	-100000.000	0.1152711	0	1	0	0.5	-48.66672	0	3.088417e-09	0
2	-23100.329	0.1327666	0	1	0	0.5	-39.45439	0	4.049241e-10	0
3	-30897.031	0.1265250	0	1	0	0.5	-44.11652	1	2.611387e-10	0
4	-100000.000	0.1170411	0	1	0	0.5	-40.33266	0	2.842171e-14	0
5	-27266.630	0.1347701	0	1	0	0.5	-38.64248	1	1.068940e-09	0
6	-100000.000	0.1150590	0	1	0	0.5	-36.25929	1	2.541285e-01	0
7	-16452.728	0.1420235	0	1	0	0.5	-40.44355	1	3.198863e-10	0
8	-5995.290	0.1644735	0	1	0	0.5	-43.46204	0	8.127756e-10	0
9	-2350.228	0.1879434	0	1	0	0.5	-38.71198	0	8.384404e-12	0
10	-18057.937	0.1452631	0	1	0	0.5	-39.21888	0	1.087983e-10	0

\n"" ], ""text/markdown"": ""\nA data.frame: 10 × 10\n\n| | S_d <dbl> | b <dbl> | p_b <dbl> | S_b <dbl> | eps <dbl> | h <dbl> | likelihood <dbl> | i_best_run <dbl> | likelihoods_std <dbl> | alpha <dbl> |\n|---|---|---|---|---|---|---|---|---|---|---|\n| 1 | -100000.000 | 0.1152711 | 0 | 1 | 0 | 0.5 | -48.66672 | 0 | 3.088417e-09 | 0 |\n| 2 | -23100.329 | 0.1327666 | 0 | 1 | 0 | 0.5 | -39.45439 | 0 | 4.049241e-10 | 0 |\n| 3 | -30897.031 | 0.1265250 | 0 | 1 | 0 | 0.5 | -44.11652 | 1 | 2.611387e-10 | 0 |\n| 4 | -100000.000 | 0.1170411 | 0 | 1 | 0 | 0.5 | -40.33266 | 0 | 2.842171e-14 | 0 |\n| 5 | -27266.630 | 0.1347701 | 0 | 1 | 0 | 0.5 | -38.64248 | 1 | 1.068940e-09 | 0 |\n| 6 | -100000.000 | 0.1150590 | 0 | 1 | 0 | 0.5 | -36.25929 | 1 | 2.541285e-01 | 0 |\n| 7 | -16452.728 | 0.1420235 | 0 | 1 | 0 | 0.5 | -40.44355 | 1 | 3.198863e-10 | 0 |\n| 8 | -5995.290 | 0.1644735 | 0 | 1 | 0 | 0.5 | -43.46204 | 0 | 8.127756e-10 | 0 |\n| 9 | -2350.228 | 0.1879434 | 0 | 1 | 0 | 0.5 | -38.71198 | 0 | 8.384404e-12 | 0 |\n| 10 | -18057.937 | 0.1452631 | 0 | 1 | 0 | 0.5 | -39.21888 | 0 | 1.087983e-10 | 0 |\n\n"", ""text/latex"": ""A data.frame: 10 × 10\n\\begin{tabular}{r|llllllllll}\n & S\\_d & b & p\\_b & S\\_b & eps & h & likelihood & i\\_best\\_run & likelihoods\\_std & alpha\\\\\n & & & & & & & & & & \\\\\n\\hline\n\t1 & -100000.000 & 0.1152711 & 0 & 1 & 0 & 0.5 & -48.66672 & 0 & 3.088417e-09 & 0\\\\\n\t2 & -23100.329 & 0.1327666 & 0 & 1 & 0 & 0.5 & -39.45439 & 0 & 4.049241e-10 & 0\\\\\n\t3 & -30897.031 & 0.1265250 & 0 & 1 & 0 & 0.5 & -44.11652 & 1 & 2.611387e-10 & 0\\\\\n\t4 & -100000.000 & 0.1170411 & 0 & 1 & 0 & 0.5 & -40.33266 & 0 & 2.842171e-14 & 0\\\\\n\t5 & -27266.630 & 0.1347701 & 0 & 1 & 0 & 0.5 & -38.64248 & 1 & 1.068940e-09 & 0\\\\\n\t6 & -100000.000 & 0.1150590 & 0 & 1 & 0 & 0.5 & -36.25929 & 1 & 2.541285e-01 & 0\\\\\n\t7 & -16452.728 & 0.1420235 & 0 & 1 & 0 & 0.5 & -40.44355 & 1 & 3.198863e-10 & 0\\\\\n\t8 & -5995.290 & 0.1644735 & 0 & 1 & 0 & 0.5 & -43.46204 & 0 & 8.127756e-10 & 0\\\\\n\t9 & -2350.228 & 0.1879434 & 0 & 1 & 0 & 0.5 & -38.71198 & 0 & 8.384404e-12 & 0\\\\\n\t10 & -18057.937 & 0.1452631 & 0 & 1 & 0 & 0.5 & -39.21888 & 0 & 1.087983e-10 & 0\\\\\n\\end{tabular}\n"", ""text/plain"": [ "" S_d b p_b S_b eps h likelihood i_best_run likelihoods_std\n"", ""1 -100000.000 0.1152711 0 1 0 0.5 -48.66672 0 3.088417e-09 \n"", ""2 -23100.329 0.1327666 0 1 0 0.5 -39.45439 0 4.049241e-10 \n"", ""3 -30897.031 0.1265250 0 1 0 0.5 -44.11652 1 2.611387e-10 \n"", ""4 -100000.000 0.1170411 0 1 0 0.5 -40.33266 0 2.842171e-14 \n"", ""5 -27266.630 0.1347701 0 1 0 0.5 -38.64248 1 1.068940e-09 \n"", ""6 -100000.000 0.1150590 0 1 0 0.5 -36.25929 1 2.541285e-01 \n"", ""7 -16452.728 0.1420235 0 1 0 0.5 -40.44355 1 3.198863e-10 \n"", ""8 -5995.290 0.1644735 0 1 0 0.5 -43.46204 0 8.127756e-10 \n"", ""9 -2350.228 0.1879434 0 1 0 0.5 -38.71198 0 8.384404e-12 \n"", ""10 -18057.937 0.1452631 0 1 0 0.5 -39.21888 0 1.087983e-10 \n"", "" alpha\n"", ""1 0 \n"", ""2 0 \n"", ""3 0 \n"", ""4 0 \n"", ""5 0 \n"", ""6 0 \n"", ""7 0 \n"", ""8 0 \n"", ""9 0 \n"", ""10 0 "" ] }, ""metadata"": {}, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 4 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""We can also plot the parameter distributions across bootstrap samples to visualize uncertainty. We see that the mean strength of deleterious selection `S_d` often reaches the lower bounds of `-1e5`. Perhaps a different DFE parameterization or a more complex DFE model would be more appropriate here. It should also be noted that the spectra used in this example are far from exemplary, as they contain few SNPs and have a small sample size."" }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:39:38.109436Z"", ""start_time"": ""2026-01-04T10:39:37.927917Z"" } }, ""cell_type"": ""code"", ""source"": ""hist(inf$bootstraps$S_d); hist(inf$bootstraps$b)"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""Plot with title “Histogram of inf$bootstraps$S_d”"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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"" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } }, { ""data"": { ""text/plain"": [ ""Plot with title “Histogram of inf$bootstraps$b”"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\n2Ung/wCgciJKCaytYAAAAABJRU5ErkJggg=="" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 5 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""We can also inspect how parameters covary."" }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:39:38.129070Z"", ""start_time"": ""2026-01-04T10:39:38.113586Z"" } }, ""cell_type"": ""code"", ""source"": ""plot(abs(inf$bootstraps$S_d), inf$bootstraps$b, log=\""x\"")"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nB1TFCCIAnhulAAAAAElFTkSuQmCC"" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 6 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""We observe a slight dependence between the mean `S_d` and the shape parameter `b` of {class}`~fastdfe.parametrization.GammaExpParametrization`. This is because a large fraction of moderately deleterious mutations and a smaller fraction of strongly deleterious mutations can leave a similar signal in the SFS. Spectra with larger sample sizes might facilitate disentangling the two."" }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""## Estimating beneficial effects\n"", ""Parameters can be held fixed during maximum-likelihood optimization, and this was already done internally in the example above. By default, fastDFE infers only the deleterious DFE, fixes the ancestral-allele misidentification rate `eps`, and assumes semi-dominant mutations (`h = 0.5`) (see {attr}`~fastdfe.base_inference.BaseInference.fixed_params`). Here, we estimate the full DFE, allowing for beneficial mutations by letting the parameters `S_b` and `p_b` of {class}`~fastdfe.parametrization.GammaExpParametrization` vary, while `eps` and `h` remain fixed. The fixed parameters are wrapped in a dictionary under the key `all`, meaning these settings apply to all SFS types, which matters when running joint inference (cf. {class}`~fastdfe.joint_inference.JointInference`)."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""is_executing"": true, ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:39:56.190042Z"", ""start_time"": ""2026-01-04T10:39:38.136123Z"" } }, ""source"": [ ""# create inference object\n"", ""inf <- fd$BaseInference(\n"", "" sfs_neut = sfs_neut,\n"", "" sfs_sel = sfs_sel,\n"", "" fixed_params = list(all = list(eps = 0, h = 0.5))\n"", "")\n"", ""\n"", ""# run inference\n"", ""sfs_modelled <- inf$run()\n"", ""\n"", ""p <- inf$plot_discretized();"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\npAUIUJKmY0MEEEAAAQQQSJfA/wPKP3gn9TW3MQAAAABJRU5ErkJggg=="" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 7 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""The inferred full DFE shows substantial uncertainty, which is expected with a small sample and few SNPs. This is most pronounced for the [-1, 0] and [0, 1] bins, where many mutations are effectively neutral and provide little signal. Adjusting the discretization intervals can help reveal the structure more clearly (cf. {func}`~fastdfe.base_inference.BaseInference.plot_discretized`)."" }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:39:56.328396Z"", ""start_time"": ""2026-01-04T10:39:56.202507Z"" } }, ""cell_type"": ""code"", ""source"": ""p <- inf$plot_discretized(intervals = c(-Inf, -100, -10, -1, 1, Inf));"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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"" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 8 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": [ ""## Ancestral-allele misidentification\n"", ""We can also adjust for ancestral-allele misidentification by letting parameter `eps` vary. `eps` is the probability that an allele is misidentified as derived when it is actually ancestral, and vice versa (cf. {func}`~fastdfe.spectrum.Spectrum.misidentify`). This can correct biases to the SFS caused by mis-polarization, but `eps` is somewhat difficult to interpret because it is applied simultaneously to both the neutral and selected SFS. In addition, `eps` assumes the fraction of ancestral misidentification to be constant across site classes, but in practise errors may differ across classes. Nevertheless, below, we infer the full DFE while allowing `eps` to vary."" ] }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:40:17.167462Z"", ""start_time"": ""2026-01-04T10:39:56.333306Z"" } }, ""cell_type"": ""code"", ""source"": [ ""inf <- fd$BaseInference(\n"", "" sfs_neut = sfs_neut,\n"", "" sfs_sel = sfs_sel,\n"", "" fixed_params = list(all = list(h=0.5))\n"", "")\n"", ""\n"", ""sfs_modelled <- inf$run()"" ], ""outputs"": [], ""execution_count"": 9 }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:40:17.190224Z"", ""start_time"": ""2026-01-04T10:40:17.177731Z"" } }, ""cell_type"": ""code"", ""source"": ""hist(inf$bootstraps$eps)"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""Plot with title “Histogram of inf$bootstraps$eps”"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nFArWAAAAAElFTkSuQmCC"" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 10 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""`eps` is estimated to be rather low, indicating that ancestral-allele misidentification is not a major issue in this dataset, or, at least, that including it that does not significantly improve the model fit. We can also check this in a more principled way by performing a likelihood-ratio test as done below."" }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""## Nested model comparison\n"", ""We can automatically check for the significance of include ancestral-allele misidentification and beneficial fitness affects using likelihood ratio tests. This is done with {func}`~fastdfe.base_inference.BaseInference.plot_nested_models`. The LRTs are performed by comparing the likelihood of the inferred DFE to the likelihood of a nested model where some parameters are held fixed. Alternatively, we can use {func}`~fastdfe.base_inference.BaseInference.compare_nested` to directly compare two nested models."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""is_executing"": true, ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:40:20.133385Z"", ""start_time"": ""2026-01-04T10:40:17.194912Z"" } }, ""source"": ""p <- inf$plot_nested_models();"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nQKQE/gcS15eirh3MZwAAAABJRU5ErkJggg=="" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 11 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": ""Including ancestral allele misidentification or beneficial mutations does not appear to improve the fit significantly."" }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": [ ""## Dominance effects\n"", ""By default, fastDFE assumes semi-dominance (`h = 0.5`), which is more or less appropriate depending on the organism and type of mutations considered. We can change the dominance coefficient to a different value of `h` if we believe this is more appropriate. However, in practise, `h` often depends on the strength of selection, with more deleterious mutations being more recessive. To model this, we can specify a callback function that returns the dominance coefficient as a function of the selection coefficient `S = 4Ne`.\n"", ""\n"", ""In the example below, we use an exponential decay: `h` is about 0.4 for neutral mutations and approaches 0 for strongly deleterious ones. The callback also receives `h` itself, allowing the dominance function to be parametrized and optimized; for simplicity, this parameter is still called `h`. Its bounds can be set via {attr}`~fastdfe.base_inference.BaseInference.bounds`."" ] }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:40:53.729928Z"", ""start_time"": ""2026-01-04T10:40:20.144689Z"" } }, ""cell_type"": ""code"", ""source"": [ ""inf <- fd$BaseInference(\n"", "" sfs_neut = sfs_neut,\n"", "" sfs_sel = sfs_sel,\n"", "" fixed_params = list(all = list(eps = 0, h = 0, p_b = 0, S_b = 1)),\n"", "" h_callback=function(h, S) { 0.4 * exp(-0.1 * abs(S)) }\n"", "")\n"", ""\n"", ""sfs_modelled <- inf$run()"" ], ""outputs"": [], ""execution_count"": 12 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""Let's compare the inferred DFE under this dominance relationship to that of the default semi-dominant model."" }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:40:59.882806Z"", ""start_time"": ""2026-01-04T10:40:53.740932Z"" } }, ""cell_type"": ""code"", ""source"": [ ""inf2 <- fd$BaseInference(\n"", "" sfs_neut = sfs_neut,\n"", "" sfs_sel = sfs_sel,\n"", "" fixed_params = list(all = list(eps = 0, h = 0.5, p_b = 0, S_b = 1))\n"", "")\n"", ""\n"", ""sfs_modelled <- inf2$run()"" ], ""outputs"": [], ""execution_count"": 13 }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:41:00.051362Z"", ""start_time"": ""2026-01-04T10:40:59.893382Z"" } }, ""cell_type"": ""code"", ""source"": ""p <- fd$DFE$plot_many(c(inf$get_dfe(), inf2$get_dfe()), labels=c('partly recessive', 'h=0.5'))"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl\nR2VuZXJpY1JHQgAAOI2NVV1oHFUUPpu5syskzoPUpqaSDv41lLRsUtGE2uj+ZbNt3CyTbLRB\nkMns3Z1pJjPj/KRpKT4UQRDBqOCT4P9bwSchaqvtiy2itFCiBIMo+ND6R6HSFwnruTOzu5O4\na73L3PnmnO9+595z7t4LkLgsW5beJQIsGq4t5dPis8fmxMQ6dMF90A190C0rjpUqlSYBG+PC\nv9rt7yDG3tf2t/f/Z+uuUEcBiN2F2Kw4yiLiZQD+FcWyXYAEQfvICddi+AnEO2ycIOISw7UA\nVxieD/Cyz5mRMohfRSwoqoz+xNuIB+cj9loEB3Pw2448NaitKSLLRck2q5pOI9O9g/t/tkXd\na8Tbg0+PszB9FN8DuPaXKnKW4YcQn1Xk3HSIry5ps8UQ/2W5aQnxIwBdu7yFcgrxPsRjVXu8\nHOh0qao30cArp9SZZxDfg3h1wTzKxu5E/LUxX5wKdX5SnAzmDx4A4OIqLbB69yMesE1pKojL\njVdoNsfyiPi45hZmAn3uLWdpOtfQOaVmikEs7ovj8hFWpz7EV6mel0L9Xy23FMYlPYZenAx0\nyDB1/PX6dledmQjikjkXCxqMJS9WtfFCyH9XtSekEF+2dH+P4tzITduTygGfv58a5VCTH5Pt\nXD7EFZiNyUDBhHnsFTBgE0SQIA9pfFtgo6cKGuhooeilaKH41eDs38Ip+f4At1Rq/sjr6NEw\nQqb/I/DQqsLvaFUjvAx+eWirddAJZnAj1DFJL0mSg/gcIpPkMBkhoyCSJ8lTZIxk0TpKDjXH\nliJzZPO50dR5ASNSnzeLvIvod0HG/mdkmOC0z8VKnzcQ2M/Yz2vKldduXjp9bleLu0ZWn7vW\nc+l0JGcaai10yNrUnXLP/8Jf59ewX+c3Wgz+B34Df+vbVrc16zTMVgp9um9bxEfzPU5kPqUt\nVWxhs6OiWTVW+gIfywB9uXi7CGcGW/zk98k/kmvJ95IfJn/j3uQ+4c5zn3Kfcd+AyF3gLnJf\ncl9xH3OfR2rUee80a+6vo7EK5mmXUdyfQlrYLTwoZIU9wsPCZEtP6BWGhAlhL3p2N6sTjRdd\nuwbHsG9kq32sgBepc+xurLPW4T9URpYGJ3ym4+8zA05u44QjST8ZIoVtu3qE7fWmdn5LPdqv\ngcZz8Ww8BWJ8X3w0PhQ/wnCDGd+LvlHs8dRy6bLLDuKMaZ20tZrqisPJ5ONiCq8yKhYM5cCg\nKOu66Lsc0aYOtZdo5QCwezI4wm9J/v0X23mlZXOfBjj8Jzv3WrY5D+CsA9D7aMs2gGfjve8A\nrD6mePZSeCfEYt8CONWDw8FXTxrPqx/r9Vt4biXeANh8vV7/+/16ffMD1N8AuKD/A/8leAvF\nY9bLAAAAOGVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAACoAIABAAAAAEAAAIooAMA\nBAAAAAEAAAGAAAAAANfxKOcAAEAASURBVHgB7Z0J3FXT/v+/zaVIgxRpIIlQhgwXl6JuXSlT\n1yxDXCRDmeVSMt2QIUOU5Bri5h9CcSNKyBwNEiI0aFBJNJ7//qz72+fuc54zPs95njO91+t1\nOnuvvfYa3mv37M9Z67u+q1LIC0aAAAQgAAEIQAACOUSgcg7VhapAAAIQgAAEIAABRwCBwoMA\nAQhAAAIQgEDOEUCg5FyXUCEIQAACEIAABBAoPAMQgAAEIAABCOQcAQRKznUJFYIABCAAAQhA\nAIHCMwABCEAAAhCAQM4RQKDkXJdQIQhAAAIQgAAEECg8AxCAAAQgAAEI5ByBqjlXoyxW6OKL\nL7bZs2fbk08+aTvuuKOtX7/eunbtag0bNrR///vfWaxZ6Yv+7rvvrEWLFuEMcq1N0czDFY1x\n8N5779l1111X4kqVKlVsq622sp122slOPvlkO+yww0qkUcT1119v7777bsxrwchtttnGXnzx\nRRf16aefWv/+/YOXEx4/88wz1rhx44RpuAgBCEAAAskJIFACjD755BPTS3DdunUudsuWLfbW\nW285sRJIlheHa9assb///e+2cuVKe+2118J1zrU2RTMPVzTGwfLly11/xLgUjnrwwQft8MMP\nt4cfftjatGkTjtfBrFmzkt6vdPXr19eXC7/88ktK9/jp//jjD/+QbwhAAAIQKAMBBEoCeNWq\nVbNbb73Vtt566wSpcvPSN998Y2PHjrXOnTtHVDCf2+Q3ZJ999rGXXnrJP7WNGzfa6tWr7bPP\nPrPbbrvN3n77bevVq5d99NFHVqNGjXA6/2Do0KFupMU/j/6uXLnkzKfEzn/+85/opCXOmzRp\nUiKOCAhAAAIQSJ8AAiUBs6pVq9q1116bIEX+XSqENkl0NG3atAT89u3bO+GhEZQPPvjATenc\neeedJdLVq1cv5v0lEgYiJOxilRlIwiEEIAABCGSQQFEKFO2PqF/Xr776qmkIXzYLxx57bAms\nmzZtspEjR1rt2rXtjDPOiLgu2wTZKXz//fe2/fbb2x577GHdu3ePmB4I3vD111/blClTbMaM\nGc6mRS/Rbt26hZPINmT06NG2yy672P7772+PPPKIaUqjR48eduihh1qlSpVc2l9//dWVq9GC\n3377zdq1a2d//etfrVmzZuG8NC31+uuvu/Mff/zRTXfsvPPO1qVLF4tuk6aCnn766fC98Q40\nItGgQYPw5VTqEU7sHaTKPHhPaY5r1qzpbIhat25tw4YNs0suuSSCTWny5B4IQAACEMgCAe1m\nXEzBsxEIHXzwwdrB2X28EQX37b3kQ3vttZc7/uqrrxwSzxbFnXsGsxGIPGNLF688vF/W4eMd\ndtgh5ImDiLQ6ufDCC8Npguk9wRBSfRRWrFjh0hx33HGhgw46KJzeEz8hbwrDpXnnnXdCLVu2\ndNc8wRKqXr26O/aMOkNPPPGES6N/zj333PD9fjtPPPFEdz26TZ5wKpHWvyf4/fnnn4fzT7Ue\n/g3pMPfvifXtTeu4uopPsuCJTpd2woQJ4aSe2HNxnugMxyU7eOONN9w9ejYIEIAABCBQcQT0\ny7aogv/y/tvf/hb66aefQhs2bAi9/PLLIW+ljnsR6aWcSKB4UwcunfcLPaQXtV6+P/zwQ8hb\nXeLi27ZtG8Hz5ptvdvF/+tOfQl988UVo8+bNoenTp4dFyOWXX+7S+wLFGwEISXAMHDgwdPvt\nt4eGDx/uri9atCjk2cKEvOmN0L333hvyRjBC3qhLaNKkSSHP7sGVoXwVPHuMkDeC4uK8kZrQ\n4sWLQ95IkbsWLVDU/rlz55b4eDYsoaOOOsrlcdppp7l79U869fBvSoe5f0+s73QESr9+/Vzd\n77jjjnBWvkDxRqdC3khSzI/6Jxh8geKNkIU8g+OEH7ElQAACEIBAZggUlUDxVui4l5bERfSL\n6JVXXnHXkgkUiQOl8YxnI3pA+Un0eFNB7iWmixJASuvZPIRWrVoVkX7mzJkhzxgz5E2buBES\nX6Ao/ahRoyLS6uSss85yeXkGniWuSWDpPm9qKHzNWx3j4jwj2XCcDqIFSsTFwMnVV1/t7vem\nl8KjPLqcbj3SZR6oQonDdATKLbfc4urfu3fvcD6+QBGreJ/o0RlfoMRLH4y/6qqrwmVxAAEI\nQAACZSNQVDYoWtKq0KdPH4teqSE7Dm/6xBYsWODSxPvHG+p3l2Tf0KhRI+vZs6ezKVF+zz77\nbMRtshNR8EYgrG7duhHX9t57b/NGLtwSZhmuBoPsTqKDJ0KcHco555wTfcnZlsjwU3Y1nhCy\nbbfdtkSadCJGjBhh3siDs4cZP358xEqYdOuRCebp1N1Pq5U9CrLtiQ7yUxLdH36a5s2b+4cR\n37Vq1XL2PhGRUSdBO6CoS5xCAAIQgECaBCLfjGnenG/JvVELV2UZjMYKu+66a1KBIoPaU045\nxeSQS0Ln/PPPt/32288ZqsqQ1JviCWctQ1oFGb7GCjLkjA4SF3IMFwwSHTKYlUMyGbrGCv4L\nef78+dahQ4dYSVKKk+Fw3759TYLHG1WKqEtp6pEJ5ilVPCqRllkrSHRGhyFDhpg37RQdnfC8\nVatWzkdOwkRchAAEIACBjBEo6fAhY1nnXkZLly51lZKn0FghWhjESqPRjqeeesp9tApHS14/\n/PBDGzRokO25557O66g33eNuXbhwofuO92s9Vv7BlTL+db/enlGsG/nRaE30Z/fdd3fCxJvC\n8W9L+1uC6qSTTnJ5P//887bbbrtF5FGaevj3lIV5RCVSPPEFSjwxmmI2JIMABCAAgSwRKKoR\nFC3J1dJgz6g1Ju4lS5bEjI+O1JLfU0891X08I1mbOnWqcxymJcma+vEMYs1bNWP+dIFnWBqd\nhTvXy1svbk0fJAqaOlCZEkPy71EeQWLq6KOPtrVr19pjjz1mHTt2LFFMaeqRKeYlKpMgQuJE\n011idsghhyRIySUIQAACEMhVAkU1giL/IgrTpk0r0R8SGt4qmxLx0REaPdH0gG9fIr8bmnbx\nVts4nxtKL8GioCkjhViiQlMymhrSHjLykZIoSMBIHGiKxbfpCKb3VuLYRRdd5ByTeca2wUsp\nHcsLq8SJt9rHrrnmGjv77LNj3leaemSCeczKJIgcMGCAiYn80mhkiQABCEAAAvlHoKgEin5N\ny7BVmwF+/PHHEb0lj6PLli2LiIt1MmfOHDfCcMMNN5S4LKdtCho1UNALUhvYeb44SmxSJ4Na\nb5WPc/Am+4ZkwVs265LI8Vj0NM5NN91kDz30kI0bNy7sKE7CSSFZmySUTjjhBLdPjWxr5No/\nUUi3Hplgnqg+/jUJEglMjVxplEztv/HGG/3LfEMAAhCAQJ4RKKopHm0C98ILL7jpiz//+c+m\nnXQ1yuEtJXUrcLS6I9k0j+d0zXmX1WqWAw44wIkQjSzIc6vykVGmVvYoKF5TPt7yYzvyyCNN\n92pPFxmi6iP36Y8++mhKj4yEiTy+er5OTHvReMt93R5BMmTVHjGyT9FGeZrWUNBuzLJT0UiP\nyta0k+eTpURZnq8VV2/Z1uil7i3LdStfvMVhEWk9B3LOODjdemSCeURFvBPZyvijU7omj7rq\nN7/O4q69ejRClakwb968iDLj5XvppZe65yredeIhAAEIQCBFAmVbpZyfd8ufhjyNeqti9BZ2\njtE8N/Mhz67EnSdy1KYWey/9UKdOnVxa3a+P91IMyc+Gt9qmBBRvSinkTTVEpJdDtzfffDOc\n1veD4q34CcdFH8gp3JVXXhmqU6dORF7eqp3QlClTopM7h25y+qb6yQOtQrQfFE9wROTltyf6\n29uTKJx/uvXQjakyDxcS48D3gxJdN3nn9abAnIdgb4VOyLPtiXF3yPWP7i2NJ9noMuOdDx48\nOGbZREIAAhCAQHoEKim598e2KIPnGdRkwKp9dDTakG7Q/ZrW0eiFRka0DDhR0L4/WgasTec8\nt/iJkia8pi777rvv3PRNixYt3LRVvBuUVlNJWqHkT/vES5tufDr18PMuK3M/H74hAAEIQKCw\nCRS1QCnsrqV1EIAABCAAgfwlkP6wQf62lZpDAAIQgAAEIJAnBBAoedJRVBMCEIAABCBQTAQQ\nKMXU27QVAhCAAAQgkCcEECh50lFUEwIQgAAEIFBMBBAoxdTbtBUCEIAABCCQJwQQKHnSUVQT\nAhCAAAQgUEwEECjF1Nu0FQIQgAAEIJAnBBAoedJRVBMCEIAABCBQTAQQKMXU27QVAhCAAAQg\nkCcEECh50lFUEwIQgAAEIFBMBBAoxdTbtBUCEIAABCCQJwQQKHnSUVQTAhCAAAQgUEwEqhZL\nY2fMmGEXXnih1alTp1iaTDshAIECJLBhwwY7/vjj7aqrrirA1tEkCPyPQNEIlC1btljnzp3t\njjvu+F/rOYIABCCQZwQmTpxoM2fOzLNaU10IpE+AKZ70mXEHBCAAAQhAAALlTACBUs6AyR4C\nEIAABCAAgfQJIFDSZ8YdEIAABCAAAQiUMwEESjkDJnsIQAACEIAABNIngEBJnxl3QAACEIAA\nBCBQzgQQKOUMmOwhAAEIQAACEEifAAIlfWbcAQEIQAACEIBAORNAoJQzYLKHAAQgAAEIQCB9\nAgiU9JlxBwQgAAEIQAAC5UwAgVLOgMkeAhCAAAQgAIH0CSBQ0mfGHRCAAAQgAAEIlDOBotmL\nJxWOP/zwgx1wwAEWCoXCyStVqmSzZs2yBg0ahOM4gAAEIAABCECgfAkwghLgKzFSs2ZN27hx\noy1dutQ2b97szgNJOIQABCAAAQhAoAIIIFACkJs2bWoLFiywIUOGuNi7777bnTN6EoDEIQQg\nAAEIQKACCCBQKgAyRUAAAhCAAAQgkB4BBEp6vEgNAQhAAAIQgEAFEECgVABkioAABCAAAQhA\nID0CRbWKZ9M702xt79OSEvpj3lcuzR8jHrK1kyclTa8EdcY8lVI6EkEAAhCAAAQgkJwAIyjJ\nGZECAhCAAAQgAIEKJoBAqWDgFAcBCEAAAhCAQHICCJQAo59//92OmzzFHvnyv1M8986e685X\nb9gQSMUhBCAAAQhAAALlTaCobFCSwVy3abNNXrQ4nGz2qlWmz4bNW8JxHEAAAhCAAAQgUP4E\nECgBxs3r1LYfTz4xEPPfw22qVSsRRwQEIAABCEAAAuVHAIESYCtX93WrVw/EcAgBCEAAAhCA\nQDYIYIOSDeqUCQEIQAACEIBAQgIIlIR4uAgBCEAAAhCAQDYIIFCyQZ0yIQABCEAAAhBISACB\nkhAPFyEAAQhAAAIQyAYBBEo2qFMmBCAAAQhAAAIJCSBQEuLhIgQgAAEIQAAC2SCAQMkGdcqE\nAAQgAAEIQCAhAQRKQjxchAAEIAABCEAgGwQQKNmgTpkQgAAEIAABCCQkgEBJiIeLEIAABCAA\nAQhkgwACJRvUKRMCEIAABCAAgYQEECgJ8WT24plnnmk1a9a0GjVquI+Or7jiiswWQm4QgAAE\nIACBAiCAQKnATmzatKntsccetnnzZtPGhDpu3LhxBdaAoiAAAQhAAAL5QYDdjCuwn2699VbT\np379+taoUSP75JNPKrB0ioIABCAAAQjkDwFGUPKnr6gpBCAAAQhAoGgIIFCKpqtpKAQgAAEI\nQCB/CCBQ8qevqCkEIAABCECgaAggUIqmq2koBCAAAQhAIH8IIFDyp6+oKQQgAAEIQKBoCCBQ\niqaraSgEIAABCEAgfwggUPKnr6gpBCAAAQhAoGgIIFCKpqtpKAQgAAEIQCB/CCBQ8qevqCkE\nIAABCECgaAhk3ZPsr7/+atOnTzd9H3jggdasWbOE8Lds2WLvvfeeffPNN7bXXntZu3btrHLl\n7Ousxi9PSljv4MVVGzbamrVrLZ17lnTvGsyCYwhAAAIQgEBBE8jqm33BggXWs2dPGzdunM2a\nNcvOOecce//99+MC37hxo1111VV2991326JFi2zQoEHuHokWAgQgAAEIQAAChUMgqyMot912\nm/Xo0cMuvfRSt3nemDFjbNiwYTZ27Fh3Ho359ddft3nz5tno0aOtYcOGtn79ejvxxBPtjTfe\nsM6dO0cn5xwCEIAABCAAgTwlkLURlBUrVtjcuXPdCIp29lXo3r27GxmZM2dOTJzjx493gkTi\nRKFGjRpOrBx88MEx0xMJAQhAAAIQgEB+EsjaCMqSJUscsR122CFMrkGDBla9enX7+eefrW3b\ntuF4/2DhwoWm9Bpp0U7A9erVs9NPP91atWrlJwl/K/8NGzaEz1etWhU+5gACEIAABCAAgdwm\nkDWBsnjxYjcColGQYNh6663tl19+CUa543Xr1tnvv//uxMl2221nhx56qJva+fvf/26jRo2y\nFi1aRNzTp08fmz9/fjhu9913t13CZxxAAAIQgAAEIJDLBLImUKpVq2abNm0qwWbz5s221VZb\nxYxXZJ06dZydio5lf3LCCSfY008/bdddd52iwqFjx44mUeIHjcz88dbP/infEIAABCAAAQjk\nMIGsCRTZkUiMaGQkKEjWrFljTZo0KYFMIysabTniiCPC12S7IvsTrQaKDgMGDIiI0tLkcW9N\niYjjBAIQgAAEIACB3CSQNSPZpk2bWtWqVW327NlhMjKa1ZLhoF1K+KJ30LJlS/NtV/z4b7/9\n1po3b+6f8g0BCEAAAhCAQAEQyJpAqVu3rnXp0sWtwlnrOS37448/bOTIkda1a1eTjYnC1KlT\nbeLEiWHMp5xyik2YMME++ugjN/qiZcda8dOpU6dwGg4gAAEIQAACEMh/Almb4hG6Cy64wDlb\nO+aYY9z0jbzC9uvXL0x18uTJbtlxt27dXJyEiFb4XHvttRYKhaxWrVrWv39/69ChQ/geDiAA\nAQhAAAIQyH8CWRUoWiZ8zz33mOxOqlSpYrVr144gOnjw4IhznZx88snWq1cvW758uTVq1Cim\nQ7cSNxEBAQhAAAIQgEBeEciqQPFJbbPNNv5hSt8SM9tvv31KaUkEAQhAAAIQgED+EciaDUr+\noaLGEIAABCAAAQhUFAEESkWRphwIQAACEIAABFImgEBJGRUJIQABCEAAAhCoKAIIlIoiTTkQ\ngAAEIAABCKRMAIGSMioSQgACEIAABCBQUQQQKBVFmnIgAAEIQAACEEiZAAIlZVQkhAAEIAAB\nCECgogggUCqKNOVAAAIQgAAEIJAygZxw1JZybfM84a+jR9mGjz+ykLeD8+b1f9iKiy+0mh07\nWe0TeuV5y6g+BCAAAQhAILMEECiZ5Zkwty2rV9mmJYvNqldz6XS8xXPzT4AABCAAAQhAIJIA\nAiWSR7me1b1sgOlDgAAEIAABCEAgMQFsUBLz4SoEIAABCEAAAlkggEDJAnSKhAAEIAABCEAg\nMQEESmI+XIUABCAAAQhAIAsEEChZgE6REIAABCAAAQgkJoBAScyHqxCAAAQgAAEIZIEAAiUL\n0CkSAhCAAAQgAIHEBBAoiflwFQIQgAAEIACBLBBAoGQBOkVCAAIQgAAEIJCYAAIlMR+uQgAC\nEIAABCCQBQIIlCxAp0gIQAACEIAABBITQKAk5sNVCEAAAhCAAASyQACBkgXoFAkBCEAAAhCA\nQGICCJTEfLgKAQhAAAIQgEAWCCBQsgCdIiEAAQhAAAIQSEwAgZKYD1chAAEIQAACEMgCAQRK\nFqBTJAQgAAEIQAACiQkgUBLz4SoEIAABCEAAAlkggEDJAnSKhAAEIAABCEAgMQEESmI+XIUA\nBCAAAQhAIAsEEChZgE6REIAABCAAAQgkJoBAScyHqxCAAAQgAAEIZIEAAiUL0CkSAhCAAAQg\nAIHEBBAoiflwFQIQgAAEIACBLBBAoGQBOkVCAAIQgAAEIJCYAAIlMR+uQgACEIAABCCQBQII\nlCxAp0gIQAACEIAABBITQKAk5sNVCEAAAhCAAASyQACBkgXoFAkBCEAAAhCAQGICCJTEfLgK\nAQhAAAIQgEAWCCBQsgCdIiEAAQhAAAIQSEwAgZKYD1chAAEIQAACEMgCAQRKFqBTJAQgAAEI\nQAACiQkgUBLz4SoEIAABCEAAAlkggEDJAnSKhAAEIAABCEAgMQEESmI+XIUABCAAAQhAIAsE\nEChZgE6REIAABCAAAQgkJoBAScyHqxCAAAQgAAEIZIFA1SyUSZEQgAAEIJCHBN555x2bOHGi\nfffdd3bIIYdYnz597JZbbrHOnTvboYce6lr00EMPWaNGjWynnXayBx54wHbffXc799xzbbvt\ntrPff//dRo4caR999JFt3rzZ2rVrZ+edd55tu+22YRq6p3r16i4+HOkdPPHEE7Z8+XLr37+/\ni54/f749+eSTdtFFF9mbb75pr7/+utWrV8+OPvpoO+KII6xKlSrB2znOQwKMoORhp1FlCEAA\nAhVN4I477rDDDjvMXn75ZVu/fr0NGjTIunTpYoMHDzYJFz888sgjNnz4cOvevbsTENdff71t\n2LDBFi1aZHvssYddccUVtnjxYlu9erXLY88997SPP/7Yv90efvhhGzVqVPjcP/jXv/5l9957\nr39qEigq++yzz7Z+/fq5+FmzZtlRRx1lV155ZTgdB/lLAIGSv31HzSEAAQhUCIG33nrLrrvu\nOicEPvvsMxs3bpzNnj3bVq5cGbN8pT/jjDNs7dq1NmfOHNtxxx3dKMrSpUtt2rRpbrRjwoQJ\n9sknn9imTZvsrLPOct8xM0sSqdGYDz/80EaPHu3yvfXWW23YsGE2fvz4JHdyOdcJIFByvYeo\nHwQgAIEsE3j++eetVq1abjqnUqVKrjYNGza0m2++OWbNKleu7NLqnt12281+/PFHmzRpkpu2\nOeCAA8L3tG7d2q6++mrTyMfbb78djk/n4LLLLrOWLVuGbxkwYICpbqozIb8JIFDyu/+oPQQg\nAIFyJ6ApmF122cW23nrriLL23XffiHP/RPYnNWvW9E9t7ty57jgoTvyLBx54oDv88ssv/ai0\nvv37/Ztkv9KmTRv79NNP/Si+85QAAiVPO45qQwACEKgoAsuWLXOGq9HlaYQkVmjQoEFE9IoV\nK9z5NttsExGvkzp16ri4jRs3lrgWjJBRbawQNLD1r2+11VbOxsU/5zs/CSBQ8rPfqDUEIACB\nCiPQqlUrt3InFApFlPntt99GnMc70eiLglb/RAc/rn379u6SVt/EEisLFy6MvtWda/ooOnz/\n/fcWb3QnOi3nuUsAgZK7fUPNIAABCOQEgeOPP94t8R07dmxEfe6///6I83gnWmqsJcCPP/64\nRYucxx57zN3mCxSNiEhgrFu3LpydhJDiYoXoOn3wwQc2b948izWdFOt+4nKXQKn8oMj46K67\n7nIPjNa1Rz9wau4vv/ySu62mZhCAAAQgkDIBLeUdMWKEW20j2w4Zt7766qvO8FWZ+Iaz8TLU\nNM6QIUOsb9++JrFz1VVXuSkjLUl+8cUXTStv/Kmav/zlL85gVquA5OPkhx9+cAa3EjixwrPP\nPmvNmjWz008/3b755hu30kijJ76/lFj3EJcfBNIWKO+++66ddNJJzqJbTnbkkCfZw5kfKKgl\nBCAAAQjEIlC1alUnGuRfRMt3tbz4z3/+s1tuLMdotWvXjnVbRJzEhmxWtGrnT3/6k7smoXP3\n3Xfb5ZdfHk576aWX2ldffWXye/L//t//c4a5AwcOdL5TdB4dtPz5mWeesX/+85/OMLdjx47O\nGZzsUAj5TSBtgfLvf//bPQRav77rrrvmd+upPQQgAAEIJCWwZMkSJ0IefPDBiLRTpkxx51rW\n64dEq2c0EqOPRkVka7LDDjv4t4W/JSzk00QeZWV3oveM7xVW/k2iw3777edGZxYsWOB+MKci\nlqLz4Dw3CaRtgyIPgPvvvz/iJDf7k1pBAAIQyDgBuZnXChyNoAfDbbfd5kbQ5fY+naBlyLHE\nSTAPCRUtF/bFSfBarGP5QkGcxCKTv3FpCxSJE42eBA2Y8rf51BwCEIAABJIR0LS+lg7Lff3J\nJ59smobZa6+9bPLkySY7EgkOAgQyTSBtgSKXxFK+N910k9tfIdMVIj8IQAACEMgtAs2bN7fP\nP//c2XnIH4lWyhx55JHOSFYbBmYjyH3+aaedhjjKBvwKKjNtGxTNOWpXyqFDh9p9991nTZs2\njTmsNnPmzApqAsVAAAIQgEB5E9APU4mRbAmS6PZpkYZ2MyYULoG0BYqWD2snyw4dOhQuFVoG\nAQhAAAIQgEBWCaQtUM4//3zThwABCEAAAhCAAATKi0DaAsWviLbI1pba8tgnt8TyAqiP72zH\nT8c3BCAAAQhAAAIQSJdAqQSKdraUsay2yI4O8gh47bXXRkdzDgEIQAACEIAABFImkLZAWbVq\nlfXs2dM0giIPgNrqWm6MteGT9lSQVz9tsx30DJioNr/++qtNnz7d9K285LI41SCncfvss49p\nIysCBCAAAQhAAAKFQyDtZcaPPvqoSaRMnTrViRC5LN57772tR48e9sILLzj7lIceeiglQvL8\nJ7Ezbtw4Nxpzzjnn2Pvvv5/SvRMmTHCriL7++uuU0pMIAhCAAAQgAIH8IZC2QNHy4SOOOMJt\nFhWrmTKgnT9/vi1atCjW5Yg4eSGUsJHoGTRokGlzKLkyjrX5YPBGba8t50DVqlULRnMMAQhA\nAAIQgECBEEh7ikduhzds2BC3+f41OfNJFFasWGFz58519ir+ZoPyUjhy5EibM2eOtW3bNubt\nmlq6+eabrXfv3m6/Bv/emImJhAAEIACBjBBY2/u0jOSTSiZ1xjyVSjLSFDiBtAWKXN1fccUV\nzpPgAQccEIFHIx/aUVIbRyVzfazNpxSC+zHIlXL16tXt559/jitQxowZY9qj4YQTTnACJaIC\ngRONxPhlKJrRlgAcDiEAAQhAAAI5TiBtgSIvgjKO1TTPeeedZxIp2kRKRrKPP/6426dHxrLJ\ngjYdrFGjhvsE02699dYmZ3CxglYNyc5F+ScbOXnjjTfcVJOfz+677267+Cd8QwACEIAABCCQ\n0wTSFii1atVyq27OPfdcZ6QabF29evXcFtnaTjtZ0IiGpmuig6aGNEISHbQ5oaZ2tEmVXO0n\nCyNGjIiYitK00Zu33pLsNq5DAAIQgAAEIJADBNIWKKqzpmUmTpxoMlaVHYnsSXbZZRfTKIWW\nHKcSNA0kMSLhERQka9assSZNmpTI4qWXXrLly5fbf/7zH/dRgt9++82effZZ00qevn37Rtyj\njaSCITjdE4znGAIQgAAEIACB3CNQKoHiN0MbBepTmqD7qlatarNnzw7v6yOxs2XLlgi7FD/v\nPfbYw84880z/1H1/9NFHLm2LFi0i4jmBAAQgAAEIQCC/CZRJoJSl6XXr1rUuXbo4Q1eNvEis\naAVP165dw1M48rWiUZJu3bo5XyvytxIMzz33nB122GH2l7/8JRjNMQQgAAEIQAACeU4gqUCR\nPxMJCTlkk++RBx54wFJxxBbLDX40qwsuuMD5PznmmGOcsay2z+7Xr1842eTJk50/FQkUAgQg\nAAEIQAACxUMgqUCpXLmysyuR+3oFLQNO1c4kGUYZ1d5zzz0muxP5V6ldu3bELYMHD444jz55\n5ZVXoqM4hwAEIAABCJSZgN5LWqG6fv16u/32202ezpO5zyhzoVnMQDahQ4YMcaYULVu2zGJN\n/ld0UoHSuHHjCPfzWlqsTyaDHgICBCAAAQhAIBcIXHzxxaZ338CBA+2PP/6wm266yTp37lwU\nAkVmE7kiUNJ2df/EE0/YVVddFfcZkp+S5s2b2++//x43DRcgAAEIQAACuUpgxowZuVq1cquX\nZkc2btxonTp1Krcy0s046QiKMly2bFnYp8inn37qvMj+9NNPJcqSm/tXX33VFi5c6FSnfKYQ\nIAABCEAAAuVBQJvLyvXEIYcc4mwk9ZKVl3FtQusHTdHce++99uGHHzpzgt12280GDBjgfkjr\nmkZLtIecpnHkLkN+tuR49MUXX3SmBxdddJGflX322Wf24IMPuj3jgiYJ119/vR111FHWsWPH\ncFodTJ8+3aZNm2Y777yzPfnkk3b66afb3/72N1cPeV3XSlSVd9ZZZ9mRRx4ZvlcuNbRoRPdr\n25devXrZfvvtF76ugYKXX37ZvWdVpmw3tdBEQZv5Dh061LVXZhQa+ZHfMt+5qbyxjx8/3r3T\nZfd55ZVXWv369Z1fsgsvvNCxkf2nHKkGZ0vkS0wc9ZHJh1jIJvX77783rbLVwEXQM3y4smU4\nSGkEZfTo0W45sZYGy2bk3XffDZ/7S431rU7Qxn/t27c3gSFAAAIQgAAEyouANqa98847nd2E\nvJprWubUU0+1Z555JlykVnmOHTvWCQAtuHjzzTfdKIFcWmjEQEJA9+iFrJe7XrYSH/KlpeNg\nkIB56qmnnEdzP/7LL780bXwby93FV1995cSMBMy2227rZha0MlViQ77EJKQkLI4++mj717/+\n5bL0V67qXKtaJaIkwBYsWOCuy1mpBNauu+7qFq9I6Jx44ol+dZwImjJlimtThw4dnACR+FKQ\nsLn88svd6teTTjrJsZCwUhAPsdDggwTItdde6/i4i94/WiQj3romhgcffLCtXbvWiSeNOGmV\nbSqbBPv5pfKd0giKGiSvr+pMNVyKSYovOgi0hInUHgECEIAABCBQ3gRkzCpB8te//tUVpQUX\nl1xyiZ1yyinOiWijRo3cylO5s1DQCIrSambAHwXRC14iww+yOdG+cxIQq1ev9qNNW7EorUZD\nTjvtv5sn6qX/5z//Oa7dhvaWkxjZd999XT4qR1u9aPRE7jY0atG6dWsnJDTCMmrUKFu6dKlz\nQKoRIQXNTmhU4/DDD7fhw4e78tU+BdVHYuXtt9921zWAoDL8d3SbNm2cU1Sl1YiM2tW/f383\noiJ7E40USQT5IyxKJ/EiITRp0iTTKlu9/8VYYlBB+/FJ7PlCUCMtat+tt97q6ucSZeCflASK\n3NJfd911rjg1VkM9N954YwaKJwsIQAACEIBA6Qlo5EN7w/lBbjE0YvDDDz84o1b5y9J0hPaK\nmzdvnsm/loLsJH2BcuCBB/q3J/3Wi1/TJhIREj8SK4lWnKp+mlXwwwcffOBGeoKCSKMWyk/e\n2WVGIeHgixPdp6kUhaefftq0Ka+mq2bOnOni9I9W1krwSMD07t3bNC2lERgJMYksTRMpnHzy\nyU5YtGrVyl3r3r17eHpIIsgPvhDTaJEEymuvveamkzR9JjGjsuXx/ZprrvFvcdNhqkMmQ0pT\nPMECpawkTjSV8/rrr4cvPf/88+4hkVIkQAACEIAABCqCgGw4gtulyJ5CQdMPWoGjaRKNcGia\nR+n8kY9g3Ro0aBA8TXgsMdSsWTO3zcpbb71lK1eujJhiib5ZUzty1+EHbYareijO/2j5sqZU\ndC6h4gsn/x7/W1NQmqmQ6PHv1bdsUHwRMmzYMDcqopGi++67z/bcc8+wkJC9isSahMo777zj\n2EicKd/ooD31tMXMr7/+6sSObGdUb41YaTpIoihYB4k2CZhMhpRGUIIFappH81pSUFJ1UqsK\nGlaTqtNcmhSl5vQIEIAABCAAgfIkoFEH2UZomkNBUyF6wesFrdET7Wz/7bffhpcIa6Wpgl6y\npQmaCtEoxbhx49yIjKZY0vENptEL/biXzxG94BW++eYbN/0isSVbzi+++CKianfffbfbt052\nNnoHa1RDzlMV5L9Ehq+aJtLedtqfTiMj+qiN2mT3lltuMU1baRpIoyM610ejNcpTIyTHHXdc\nRJkajdEoiaZxJFTEVUF1lGsQGcRqSscPapNmWzIZ/ifrUsxVilHwZEEctG4+9thj3ZCaVJTm\nt0rb+SlWg2QQgAAEIAABR0BTLLL1kLGmbDg0DaOXv4xm9QLXqISC7CdlsKqg0ZV4QSMq2htO\ntiKxggTKe++950SKjtMJf//7391UzqBBg0yjKSpDozp6p2paRytuNLqhkRAZzGrEQyJDtiMa\nAZHw+sc//uH2sfN9tFx99dVONGjlrFYZaepFoyKaxpKtjQx+ZdyqgYUzzjjDCTpNFWkTXdmX\nyPg3OkiIiaPMOzTC4wsipZPdjKaQJFzEV9NmmkrS6qNMhrQFigxqpKw0UhIdNLR22WWXuYfB\ntziOTsM5BCAAAQhAIFMEZGgquwhNu+gFrhe5VpsqHHHEEc4DrJbwajRAth16uWvaRaMH8YJ+\ncGuERKMLsYJW7GjaSFMeKiOdoBkI2XY8/PDDrk6y65SAuP/++102++yzj1ttoxEWCaUePXo4\no19NVWmEQu9gjZTstdde1rBhQzdCJLGgY4kKGdFqREZ56p2skQ+ZYCjIeFht0gocjaTIZEPL\nhsUsVpD4kojSdE8wyMxD00QaPVI+SqflypleIFPJU1GhYMHJjrVmXMNpGhKKFaRgDzroIOcL\nJZfcAju1e8UAG9SqfFz4tup1RiwcGYtb0r1rxvIiIwhAIH8JyM5Pv4SDBooV0Zq1vf+7aqUi\nyqoz5qmUitGLWatM9ct9xYoVTjDE8r8lA1ClScdPh+7R6IJESKyg2QKJlBtuuCHW5ZTiZByr\nKZOgQax/o17Nui6hEVxh41/X6iLVL579jGxwNIKi/KODZjiUt9yDxMo7On28c003aXRK+ZRH\nSNsGRQpV66G1XElrs4NBjZaDGFk255I4CdaRYwhAAAIQKDwC8V7UaqkEQDrixL8nlnDQlMvH\nH3/spmFkb1mWIPERL0g4JHrxa+QoUZBdTDzbGE1/ZeIdrRGdRHVMVL9UrqUtUOT0Rla/GtaS\nVa+WT2mIR2pMQ2JyWqPhKwIEIAABCECgPAnIriLWCEF5limfH1quPGLECNt+++3Ls6iizztt\ngSJFJtfCcg2suTCty/aDFJnOfQcyfjzfEIAABCAAgUwTkM1Dpu0ektVR7vU1/eK7lk+Wnuul\nJ5C2QFFRUq3ynqdOkjGsRk+0+2G8ubLSV487IQABCEAAArlDQC41CBVDIO1VPMFqaY5Ma7Zl\nGe0b20i0aHMkAgQgAAEIQAACECgtgVKNoDz22GPOSZvWncuKV0HCRBbF8jqnOJ0TIAABCEAA\nAhCAQGkIpC1QNDrSp08f5zlWxrJazaOdGeUwRsuPZR380EMPlaYu3AMBCEAAAjlKINWlvzla\nfaqVhwTSnuKRtzuJENmeyNudtqPWap5Zs2Y5z3ayamaOLg+fBKoMAQhAAAIQyCECaQsUeaiT\nFzp/7bO83smqWUF7DNxxxx02cODAHGoiVYEABCAAAQhAIN8IpD3FU69ePbebod9Q7QsgmxQ/\nyF+/bFO0gZMvYvxrfEMAAhCAQH4SaPzypAqrOJ6zKwx1TheU9giK9g2Q23h/8yVN8Xz33XfO\ntb1aOnv2bDcFlOldDXOaIpWDAAQgAAEIQCCjBNIWKGeeeaZprwNtba2tmzt16uS2tj7hhBPc\n1svaq0dTQHjYy2g/kRkEIAABCECgqAikLVDkVnj8+PEm2xOt3NGUj1btaH8CbWP9ww8/2KWX\nXlpUEGksBCAAAQhAAAKZJZC2DcqyZcushbfVtEZPfF8nZ5xxhnXp0sVtX922bduMbEKU2WaS\nGwQgAAEIQAAC+UQg7RGUUaNGWbNmzdxmScFtmjWl07VrV8RJPvU+dYUABCAAAQjkKIG0Bcrc\nuXNdUzKxVXOOMqFaEIAABCAAAQhkmUDaAqVv377WoEEDu+GGG5wNSpbrT/EQgAAEIAABCBQg\ngbRtUGQEKzuTu+++2+655x43pSPBEh0+/vjj6CjOIQABCEAAAhkj8Pnnn9trr71mV155ZZny\n3Lx5s7OrnDFjhu2///7WuXPnhPmp3C+++CIiTePGje3II4+MiOOkbATSFigykl21apW1b98+\nXPKWLVvCxxxAAAIQgAAEKoLAzJkznffysggUiRO5xtD2LT179nQ/vE888US3IW68NgwdOtRe\neuklt4rVTyMnpQgUn0ZmvpMKFNmc3HXXXXbzzTdbkyZN7JxzzrHevXs7XyiZqQK5QAACEIAA\nBLJDYNiwYe5Ht7Zx2WabbezLL790swR612kj3Fjh008/tSFDhli/fv1iXSYuQwSSCpSvvvrK\ntHJHHSGBcsstt9jUqVNtypQpGaoC2UAAAhCAAARKT0AmBffdd5+tXLnSjWLIF5dWmf7yyy/2\n4osvxsxYUzJaeaqRkFNPPdWJEyWUt3SNhjzzzDMxBYr8f0nExBMvMQsjslQEkgqUXXbZxWWs\nIa3zzz/fFi9ebGvXrrVPPvkkYYH77rtvwutchAAEIAABCJSVwOrVq+2UU05x7yftA3fddde5\nBRzXXHONySRBMwCxQocOHZxA0dTOzjvvHJFE57K3jBVmzZplmhaaOHGi++Gu8jUldNNNN1nN\nmjVj3UJcKQkkFSgyiD3ssMPsqaeech+/nGTq0Xfi5qfnGwIQgAAEIJBpAps2bbKxY8ea/6P4\n+++/t7feesskUFq3bl3CmDVY/saNG23RokVuZWowvn79+nF/hMtrusLvv/9ud955p02ePNke\nfPBBtz/d6NGjg9lwXEYCSQWKhsneeOMN1wk//fSTc3P/9ddf2+WXX17GorkdAhCAAAQgUDYC\nGrUILtqQUHnyySddpv50TKwS6tSpY5ohqFy5skmoBMOGDRvCUz7BeB2ffvrpdtRRRzmP6jrv\n2LGjVa1a1QYPHuxGayRuCJkhkFSgqBjtTNytWzdX4vr1603zfRdccEFmakAuEIAABCAAgVIS\nqF27thMZ/u0SHH6QDaX2jYsVjjjiCGdLKVsU2a4Eg85beFu6xAoSRNHX9H6UQNHoDQIlFrXS\nxf2vJ1O8X47aHnvssRRTkwwCEIAABCCQHQJ77723aQoo1kczAwp77rmnvf/++xEVlD8U3/4y\n4oJ3cv/999sxxxwTET1t2jQnkqKFS0QiTtImkLZASbsEboAABCAAAQhkiUCVKlUs1scfabnk\nkkucDcsHH3zgNsAdPny4aabg7LPPDtf4jjvuMIkWhaOPPtomTZpkI0aMcFNDb775pj388MN2\n5plnRvhFCd/MQakJIFBKjY4bIQABCEAg3wloeqZ///5uMUjdunWdW40xY8aYjv0gg1sZ3ipo\nhY9WBg0YMMDZqWipsqaLHnroIXedfzJHoJK32iaUuexyN6f33nvPxl0xwAa1alkulWzV64xy\nydfPdEn3rv4h3xCAQBET0PJWeVDVS7MiQ+OXJ1VYcdn4e6dRE9meyN9XKkGGtVqKvOOOO1qN\nGjVSuYU0aRJIyUg2zTxJDgEIQAACEMgrAhIZqYoTNUyLR6L9p+RVg/Ogskzx5EEnUUUIQAAC\nEIBAsRFAoBRbj9NeCEAAAhCAQB4QQKDkQSdRRQhAAAIQgECxEUCgFFuP014IQAACEIBAHhBA\noORBJ1FFCEAAAhCAQLERYBVPsfU47YUABCBQCgLZWPpbimpySwERYASlgDqTpkAAAhCAAAQK\nhQACpVB6knZAAAIQgAAECogAAqWAOpOmQAACEIAABAqFAAKlUHqSdkAAAhCAAAQKiAACpYA6\nk6ZAAAIQgAAECoUAAqVQepJ2QAACEIAABAqIAAKlgDqTpkAAAhCAAAQKhQACpVB6knZAAAIQ\ngAAECogAAqWAOpOmQAACEIAABAqFAAKlUHqSdkAAAhCAAAQKiAACpYA6k6ZAAAIQgAAECoUA\nAqVQepJ2QAACEIAABAqIAAKlgDqTpkAAAhCAAAQKhQACpVB6knZAAAIQgAAECogAAqWAOpOm\nQAACEIAABAqFAAKlUHqSdkAAAhCAAAQKiEDVAmoLTYEABAIElixZYueee24g5r+HzzzzjG2z\nzTYl4omAAAQgkEsEECi51BvUBQIZJLBu3Tp79dVXS+S4YcOGEnFEQAACEMg1Akzx5FqPUB8I\nZIhAixYtbOXKlTZ06FCX48MPP+zOGzRokKESyAYCEIBA+RFgBKX82JIzBLJKoHLlylavXj3b\naqutXD1q167tzrNaKQqHAAQgkCIBRlBSBEUyCEAAAhCAAAQqjkDWR1B+/fVXmz59uun7wAMP\ntGbNmiVs/ZYtW+yLL76wzz77zLbffnvr2LGj1ahRI+E9XIQABCAAAQhAIL8IZFWgLFiwwK0y\n2HnnnW3HHXe0ESNG2JAhQ+yggw6KSXH58uXWp08fJ0jatWtn48aNszFjxrj7WJUQExmRBUyg\n8cuTUmrdui9mu3R9P51pV2zbMKV7lnTvmlI6EkEAAhAoLwJZFSi33Xab9ejRwy699FKrVKmS\nExvDhg2zsWPHuvPoRkuQ7LDDDvbggw+6S7///rsdf/zx9uyzz9p5550XnZxzCEAAAhCAAATy\nlEDWbFBWrFhhc+fOtZ49e4bFSPfu3W3RokU2Z86cmDhl7HfmmWeGr9WqVcvatGnj7glH/t+B\nRlsWL14c/qxZsyY6CecQgAAEIAABCOQogayNoMiJlIJGRPyg5Y/Vq1e3n3/+2dq2betHh7+D\n4kSRWkL56aefWt++fcNp/IOzzjrL5s+f75/a7rvvbruEzziAAAQgAAEIQCCXCWRNoGh0Q8at\n0QauW2+9tf3yyy9JmcnZ1E033WTNmze3Y489tkT6ww47zFq1ahWOr1mzpm1c9nP4nAMIQAAC\nEIAABHKXQNYESrVq1WzTpk0lyGzevDnst6HExf+L0HTNtddea/qWzYryig5XX311RNR7771n\n46ZNjYjjBAIQgAAEIACB3CSQNRuUhg0bmsSI3HEHg0RHkyZNglERx7Itueiii5y4GT58uCkf\nAgQgAAEIQAAChUUgawKladOmVrVqVZs9+79LIIVVRrPycxK0SwniXrp0qRMnO+20k913331W\nt27d4GWOIQCBAIGQ9wNg05LFtmXNahe7ZdUqdx7y/o8RIAABCOQ6gaxN8UhcdOnSxUaPHu0M\nWCVWRo4caV27drXtttvOcZs6dar99ttv1q1bN3d+1113uVGXXr162ZdffhlmKx8oLVu2DJ9z\nAAEImG32bK5WnHdOGMXax0aaPts96S3jR9yHuXAAAQjkJoGsCRThuOCCC2zQoEF2zDHHhJ2v\n9evXL0xq8uTJbgmxBIqWH8uOREF+U4JBHmjvvPPOYBTHECh6ApW9Zfg1D+9YkoO3Uo4AAQhA\nINcJZFWgaCOze+65xxm7VqlSxbSZWTAMHjw4fKppn2nTpoXPOYAABBITqFx3W6t7xVWJE3EV\nAhCAQI4SyKpA8Zngpt4nwTcEIAABCEAAAiKQNSNZ8EMAAhCAAAQgAIF4BHJiBCVe5YiHQKET\nWLhwoWnpfDBo6XyyXb2D6TmGAAQgUIgEECiF2Ku0KW8IyM5q1KhREfXVxpePPPJIRBwnEIAA\nBIqNAAKl2Hqc9uYUgU6dOpm2YXj88cfdppm9e/e2Qw45JKfqSGUgAAEIZIMAAiUb1CkTAv9H\n4NRTTzV9XnjhBatcubLJOzIBAhCAAAQwkuUZgAAEIAABCEAgBwmwiicHO4UqQQACEIAABIqd\nAFM8xf4E0P5yI7C292kp571l5UrzjFAsnXus1xkp509CCEAAAvlGgBGUfOsx6gsBCEAAAhAo\nAgKMoBRBJ9PE3CXw7LcLbMay5bZ6wwa3iqf/jA/t4EbbWa+WLXK30tQMAhCAQAUQQKBUAORC\nLWLChAn2/PPPRzSvbdu2duWVV0bEcRKfwNQlS+2Jr78NJ3h03nzbuGULAiVMhAMIQKBYCSBQ\nirXnM9Duzz//3MaMGROR05FHHolAiSCS+OTadnvZ+bu1jkjUoGaNiHNOIAABCBQjAQRKMfZ6\nhtp84YUXWq9evZwfj48//thmz55tbPyYHtym3g7e+hAgAAEIQCCSAAIlkgdnaRCoX7++6bPV\nVlu5u1q3bm1Vq/JIpYGQpBCAAAQgEIcAq3jigCEaAhCAAAQgAIHsEUCgZI89JUMAAhCAAAQg\nEIcAAiUOGKIhAAEIQAACEMgeAQRK9thTMgQgAAEIQAACcQggUOKAIRoCEIAABCAAgewRQKBk\njz0lQwACEIAABCAQhwACJQ4YoiEAAQhAAAIQyB4BBEr22FMyBCAAAQhAAAJxCCBQ4oAhGgIQ\ngAAEIACB7BFAoGSPPSVDAAIQgAAEIBCHAAIlDhiiIQABCEAAAhDIHgEESvbYUzIEIAABCEAA\nAnEIIFDigCEaAhCAAAQgAIHsEUCgZI89JUMAAhCAAAQgEIcAAiUOGKIhAAEIQAACEMgeAQRK\n9thTMgQgAAEIQAACcQhUjRNPNASKjsDy5ctt5syZEe2uUaOGHXrooRFxnEAAAhCAQPkTQKCU\nP+O8LKHxy5NSrvfKFStd2h1fec0qVamS0n1LundNKV1FJnr33XetZ8+eEUVuv/32tmTJkog4\nTiAAAQhAoPwJIFDKnzEl5AmB1q1b28CBA23ixIn28ccfW58+faxVq1Z5UnuqCQEIQKCwCCBQ\nCqs/aU0ZCLRp08ZuvvlmW7FihRMoffv2tfbt25chR26FAAQgAIHSEsBItrTkuA8CEIAABCAA\ngXIjwAhKuaEt/IxDmzebbdlsoS1bXGNDGzeahUJWqSqPVeH3Pi2EAAQgUL4EeJOUL9+s537a\naafZ+vXrI+ohO4tMTF38Nu45++3JJ8J5L+t1nFVv197qDbktHMcBBCAAAQhAoDQEECiloZYj\n96ztfVrSmjz99NMl0uz73TfWqu0eJeIjInqdEXEa66RKo0ZWbc+9Ii5VbblzxDknEIAABCAA\ngdIQQKCUhloe3XNc82a2XlMxgfDnxo0DZ6U/rNXxSNOHAAEIQAACEMg0AQRKponmWH5PHI6T\nsRzrEqoDAQhAAAIpEGAVTwqQSAIBCEAAAhCAQMUSQKBULG9KgwAEIAABCEAgBQJM8aQAiSSF\nQSBV9/1rvlvoGnzk1OlW7cfU3Nznouv+wug1WgEBCBQrAUZQirXnaTcEIAABCEAghwkwgpLD\nnUPVKpbAhrlz7bennrBNP/7oCl7zwP1WZbtGtu0111VsRSgNAhCAAAQMgcJDkFcE7r//flu4\n8L9TMH7Fjz32WDvkkEP801J/b1mz2jbM/Cx8/6av5tmWn5eGzzmAAAQgAIGKI4BAqTjWlJQB\nArfffrstWrQoIqe1a9dmRKDU2L+DNfr3+Ii8OYEABCAAgewQQKBkhzulxiCQimfcbdf9ZpHy\nxKzhe+9aKvdaEu+4lapUMdOHAAEIQAACWSeAQMl6F1CBdAhM6NzJ84z7380J/fvq1ajuH/IN\nAQhAAAIFQgCBUiAdWSzNaFSrVrE0lXZCAAIQKGoCLDMu6u6n8RCAAAQgAIHcJIBAyc1+oVYQ\ngAAEIACBoiaAQCnq7qfxEIAABCAAgdwkgEDJzX6hVhCAAAQgAIGiJoBAKerup/EQgAAEIACB\n3CSAQMnNfqFWEIAABCAAgaImgEAp6u6n8RCAAAQgAIHcJIBAyc1+oVYQgAAEIACBoiaAQCnq\n7qfxEIAABCAAgdwkgEDJzX6hVhCAAAQgAIGiJoBAKerup/EQgAAEIACB3CSAQMnNfqFWEIAA\nBCAAgaImgEAp6u6n8RCAAAQgAIHcJIBAyc1+oVYQgAAEIACBoiaAQCnq7qfxEIAABCAAgdwk\ngEDJzX6hVhCAAAQgAIGiJlA1263/9ddfbfr06abvAw880Jo1a5awSps3b7bPPvvM5syZY23a\ntLEOHTokTM9FCEAAAhCAAATyj0BWR1AWLFhgPXv2tHHjxtmsWbPsnHPOsffffz8uRYmTCy64\nwG688Ub76aefbPDgwXb33XfHTc8FCEAAAhCAAATyk0BWR1Buu+0269Gjh1166aVWqVIlGzNm\njA0bNszGjh3rzqORPvfcc7Z27Vp79tlnrXbt2vb999/bGWecYUcffbTttttu0ck5hwAEIAAB\nCEAgTwlkbQRlxYoVNnfuXDeCInGi0L17d1u0aJGbvonF85133rHOnTs7caLrzZs3tz333NP+\n85//xEpOHAQgAAEIQAACeUogayMoS5Yscch22GGHMLoGDRpY9erV7eeff7a2bdsWMzdAAAAS\n1UlEQVSG4/2DxYsXWzC94nWu9NHh/vvvt6VLl4ajq1SpYjO90Zch334XjsvkQa3nxmYyuxJ5\nDXz/nRJxm8qpLSqo0NpT3m2q6P7JRntUZrLw+eef27x58yKSbb311ta1a9eIuNKePP/887Zl\ny5aI2w8++GBr2rRpRFymThYuXGgzZsyIyE5/S44//viIuNKeTJw40Y0KB++Xbd1ee+0VjIo4\n/vHHH539XUQkJxAoQAJZEygSGzVq1HCfIFf9Mfvll1+CUe5406ZNtnz5cttmm20irun8q6++\niojTyWuvvWbz588Px++///52w333h88zefDqq6/avl9/7Wxo6tSpk8msE+fljSaVR9Af5H29\nj+yDNEpVYaGc2vO11zfqo0v2aWf77rtvhTXHG+4rl7L0/+Nf//qXndasqRtRLJdCSpnpjjvu\naE2aNIm4Wz88NPKZKOgHRaNGjeykk05KlMz9bdDfgmDo2LFjiTKD18tyrBHdWrVqRWRRrVq1\npO155plnbOXKlda3b9+Ie6NPZFendMHQvn1722OPPYJRJY7LS5CVKIgICGSRQNYEiv6TR/+h\nEQf9h91qq61KINGvlsqVK5e4R3nIHiU6DB8+3NavXx+OVp477bRT+DyTB76Rr0TQ9ttvn8ms\ns5KXfgXLaPmyyy6zww47LCt1yGShf/zxh2uPbJUOP/zwTGadlby+/fZb155dd90159pTWr4X\nXnihhUKhpO0pbf5l6ahTTjkl7dtlvK9+SlbfZNfTLpgbIFBABLImUBo2bOjEyLp16yIEyZo1\na2L+GpKdSv369d1y5CB/pW/cuHEwyh23aNGiRBwREIAABCAAAQjkB4GsGclqiLJq1ao2e/bs\nMCkZzWp+OdrOxE+w8847R6RXvPyhaFiZAAEIQAACEIBA4RDImkCpW7eudenSxUaPHu2MxDQM\nP3LkSGdMt9122znCU6dONRmR+eHEE0+0yZMnO1Gi4WAZzG3YsMH++te/+kmy8q36ylZD01CF\nEOrVq+faEz33nq9t0xSg+ifafilf26PpUbXH/3+Sr+0I1lvtibZdCV7Pt2P9aFKbCBCAQOkJ\nVPJe9KHS3162O2XsN2jQIJs5c6Yzlm3Xrp1df/314RfJP/7xD7fsWMLFD4899pgzENQfaf0R\nkBGabD8IEIAABCAAAQgUDoGsChQfo+xINPoQy9jVTxP81qiJ7pEdCwECEIAABCAAgcIjkBMC\npfCw0iIIQAACEIAABMpCIGs2KGWpNPdCAAIQgAAEIFDYBKrc5IVCaaI2GpTTtpYtW5Zokvyr\nPP74485PiZzBpRJkpCuHS1optN9++6VyS9w0Kl/OtbQSSQ7qgkHeKmUMLKdQ8qOi3Z2nTJli\nn376qWm5tHy9+OequwyMFbTiSXsXaZm1jIdjed+NzlueeoMh2fVg2nSPxU9OqKKNH7VzdbA9\nSjN+/HjXXrVdPmvktCteSMQyOm+fVby80omP1Z6XXnrJNm7cmLC+wTLUbr/t6ttkhsjaFFNO\nB2P1bTDfWMfx+tZ/buS0TivpMhVkH6ZnVpuA7r777i7bTPVHLA7yMyI22u4iE0H19p9D5Rd8\nbhM9c/HKLuvfHLU5nWcrXj2Ih0C+EiiYERT9R37kkUdsn332idkX+qP8xBNPmDzYphLkrlsG\nu/LTkglblwcffNCtUtJmh8Eg0aINDyWCtBmiHFZNmjTJvcT0x/27776Lu+OzHNfJN4w2W9Qf\n6ugQK++gl95k16PzS+f8s88+Mxk5q13BEGsH69dff931jdqrl/YDDzzgnHYF7wsex2MZK+9E\nu2MH80x2HK89Eq7J6hvM+8033wz3rZ7JREHPyjXXXBOzbxPdp2uJ+lbPjV6+cjCYqSBbe63I\nk/fm3377zWWbqf6Ix0FiX6Lxhx9+yEgzVF/9jdBzGHTyqMzjPXOJCi7r35x0n61EdeEaBPKS\ngFbxFELwdjgOeS+KjDXFc40e8pZBh7xfQWXK09tzKHTFFVeEOnXqFDr00END3q+icH7ebswh\nz013yPvV6eI8kRU699xzQ57nytCtt97q4s4777yQN0oS8v7YuXNvFCj0t7/9zZ17L9+QtyeI\ny/ess84K56uDeHk/9NBDLl2y6xGZpXGiNni/pF27jjjiiNCTTz4ZcXes9hxzzDEhzxV6ON3N\nN98c8jaADJ/7B4lYKk2svH1Wfh7pfidrj/KLV99YZQ0cODDct7Gu+3F+3+q50TORTkilb71l\n/aFevXqFVq1alU7WcdPq+dTz/d5774XTZKI/knHwNhANXXvtteEyy3LwxhtvRDyHyivZM1eW\n8qLvjfU3J51nKzo/ziGQ7wQKYgRFv3jGjBljRx11VFyRqGmSO+64w7w/3i6NfKhoz5lXXnnF\nvD9wduONN9pHH33krr399tv28ssvuymUoUOHOrficTNOcuH22293owEqOzp88MEHzimd9t5Q\n0HC7NlXzNz9MtOOz6nrddddZt27drFWrVm6fomD+8fL2d35Odj2YVzrH2vNGTD2BVWJrgXjt\n0ahOcDRB/ajRMI2KBUMilvHyTrQ7djDveMeJ2uPfE6++/vV0v/U8+31bGjfrqfStphk12qhp\nz/IImeiPVDgceOCBptEtbc9QHiHRM5esvEz8zcn0s5WszlyHQC4RKAiB8sknn1jNmjWtdevW\ncdl6StKJjmXLlrk0+iMu8aEXkIZS9YLs37+/mz+X/YOGwOVrRXPpZbFj0BD9nXfeGdOplqab\nor3gyouuhpdV30Q7Pq9evdpNCfXp08c5hNIf82CIl7c2XFRbk10P5pXO8SGHHGJjx461gw46\nqMRt8dqjJeZqrx/k10Z2KfIsHAyJWMbL298dO5hPOseJ2uPnE6++/vV0v2WXouk+9W1pbERS\n7Vu1TfYw5REy0R+pcBAfiZTyakeiZy4Zt0z8zcn0s5WszlyHQC4RKAiBImO50uzuqT+A2kVV\nHmrlME4GqBqZkCiR0ziJnh49epQYCUinAxNtHqg/4tHeTX0DXvl60Ysm3o7P8gOjXWIVJKBk\nkBcUKfHyljiRuEl2PZ02BtOqTvFeqvHao34IChTdL4Eo+5tgSMQyXt7iGbS7CeaXynGi9vj3\nx6uvfz3db+Xn92269yp9qn2rzTM10hF8bkpTXqx7MtEfqXJQO6KflVh1Kk1comeuNPml+zcn\n089WaerMPRDIFoHMmfBnqwVeuTJuC676kGfa4K9vjZDI+DI67Lbbbm6HZMXLcFCuw3///ffo\nZCmda0ooaAB77LHHOoGT6OZYOzprWFhBf5h0XdMcGpHwg9opMRLc8blOnTrusjjsvffe7jhR\n3ro32XW/vHjfsRhrd91EIVaZSh+c3tG5WKqNMvyVkXJpWSqvaFaKixVK055gPuoX8U8naJRI\nBsJ+UB6ezYl/WurvWJz95yr43Pgv3+BzU+pCo26MVQclSbU/orJLeKp2vPjiiwnT5MrF0vzN\nKc2zlSvtpR4QKAuBghAoeon5Iw+CoZUjEyZMCHPR3jKxBIp+zQSDREppg5b5+rYjykO2JBqB\nSRS0Oij6l59GRvTHXdMeuq6X9wsvvBAWUm3atHFedINLIP16i4Mf4uUtFhqVSXbdzyfedyzG\nyQSKytQLSvUMviglCtVmP4ilpuL0AtfoR6osY+UtnkFWfhnR36VpTzAPTSUF+QevxTvWSJaW\nKftBfZsJgZJq30oEK6Rbb7++ib7j9XWq/ZEo7+hrenZK+8MiOq/yPi/N35zSPFvl3Q7yh0BF\nECgIgSLbky+++CLMS4aF0caF0QaX4cQZOrjnnnvSzkn+WrSkWL9u/ZeFdnf2/4j5Oz4PGDDA\nOnTo4PLXyJAMXYM7PuuPvkJQIMTL27d5SXbdZZjgn1iMEyR3l/z2qI3B9mh6xxdZSiiWp59+\nuhs50fRbKiFe3hJ4QVbx8ipNe4J5aamrRnrSCeqDp59+Op1bUkqbat/++OOPLr/gc5NSASkk\nKmt/pFBEOInYy1C8UENpnq1CZUG7iotA6YcMcoiTBIqcUpVn0DD4U089ldFfm/6qI+WrF6ls\naWS06++CKtuSZDs+q83eUlE34hK0W4iXt3yuKCS7rtEI1evLL7906TPxT7z2yN6nUqVK4SIk\n2PTyTGT0HE78fwfx8tboi7/r71tvvVUqnyLRZUWfl6a+0Xmkc56sb5L1rV+W/s/omQk+N/61\nsn6n0h+Z+j+llXmaOqnokKwfMlGfin62MlFn8oBApggUhEDRHydNB+hFXV5BHmoffvjhjAoU\nTbV4fg6c90q9SC+//HLz/JpEvDAuuOAC0xCv5yvE/ULXSEu/fv0imqlpkOjppHh5/+lPf3L3\nJruuP75qb6aXb8Zqj9oeDPrFqFGVdH/Zx8o7yEreejVdlulQ2vqWth7J+iZZ3/rlShCX54s9\nWX9k6v9UebfD5xX9nawfotOX5ryin63S1JF7IFBuBLwXQUEEbxok5PlCKde2yOGat7qmXMrw\nVl6EncLFcubl2SuEPCPcEmXLkZictb377rslrvkRwbz9uOB3vOue2++Q5/k0mDRjx8H2RDvI\nkmO6W265pdRlBfMOZiKnZJ5322BURo7TqW+svi1NJVLtm3h9m8pzk069vBHAEo7a/Pvj9Yeu\nl/X/lGfcHPJW2oU877V+caX+jn4OU8ko1X5IJa9YadJ5tmLdTxwE8plAQYygSL1dfPHFbiQi\n2kV1ppSdbFx22WWXCGPOTOWtfLQSIWiHoRVBGoL3bWe0HLl27dolipQ9imwODj744BLX/Ijo\nvP14/zvWdQ0ty1eM/DCUR4huj6a41F59vBeFnX/++aUuNjpvPyO5dtey8UwGjdqlW9/ovk23\nPun0Tay+VXmpPDfp1kvpZdysJcbBEK8/MvF/yvNU7J6VoNF1sOx0j/3n0BNVSW9Npx+SZhYj\nQWmerRjZEAWBvCVQSeoqb2sfVXEZV8p+47jjjou6UvZTYQraSZQ9x/g53HbbbeaNiLgEw4cP\nD9ukRN+hOp199tnOC65ESqZDRbV52rRp9s9//tNVXyJQHk579+6d6ea4aaNM9+GoUaOcgXOq\n9U21b5M1vix9Ux7PjfL0xZ/8kmjvmmShLG1Q3pra8Uba7NFHH40Q98nKjXc9+ByefPLJdtpp\np8VLGo4vaxvCGcU4SPfZipEFURDIawIFJVD0i0YjKLFGGvK6l+JUXr/29Gtcv1ALJchpmH4N\na5l1PoR8q6+YFspzo//raou/6i0fnpd06piPz1Y67SMtBJIRKCiBkqyxXIcABCAAAQhAID8I\nFIwNSn7gppYQgAAEIAABCKRCoCActaXSUNJAoDwJaHpx3rx5zt29lkfrEzR6Ls+yyRsCEIBA\nIRJgBKUQe5U2VSgBGb5qq4U999zT+auRy3qdDxkyJGITxAqtFIVBAAIQyHMCjKDkeQdS/ewS\n6N+/v3m+Kuykk04yeenVXkfTp093Gx7ecMMNbq+lkSNHZreSlA4BCEAgDwlgJJuHnUaVc4OA\nPIlqp1nt9aPdkINTOrqmkRS5Ydcmkttuu21uVJpaQAACEMgTAkzx5ElHUc3cI7B8+XK3xcIe\ne+wRIU5UUy2Tlm8Xjaz89NNPuVd5agQBCEAgxwkwgpLjHUT1cpvA3nvvbdph+q677nI7MNev\nXz+3K0ztIAABCOQJAQRKnnQU1cxNAtrtuVu3bs7WRFM8HTp0sI4dO1rnzp3t8MMPzxuHc7lJ\nl1pBAALFTACBUsy9T9szQkC7ST/++OP20ksvuS0KvA0lXb5y2//8889bu3btMlIOmUAAAhAo\nJgIIlGLqbdpa7gTWrVvnVvFoY0LtpVKjRg3THi/77rtvuZdNARCAAAQKiQBGsoXUm7SlQglo\nemf8+PFuPxi/YO0jpOmdESNGuBEVCZZnn33Wv8w3BCAAAQikSACBkiIokkEgmsCECRPs+OOP\ndyMk0dd03qVLFzeCMn/+/FiXiYMABCAAgQQEECgJ4HAJAokI9OjRw12+/vrrbdmyZSWSauRE\nO+7+5S9/KXGNCAhAAAIQSEwAG5TEfLgKgYQEBg4caLfccotz1ibB0r59e9O0zowZM+y5556z\n/fff31577TXnYTZhRlyEAAQgAIEIAgiUCBycQCB9AmPHjrWhQ4fanDlz7I8//nAZNGnSxLp3\n72733nuv1apVK/1MuQMCEIBAkRNAoBT5A0DzM0dA7u2/+eYbq1OnjhtRyVzO5AQBCECg+Agg\nUIqvz2kxBCAAAQhAIOcJYCSb811EBSEAAQhAAALFRwCBUnx9ToshAAEIQAACOU8AgZLzXUQF\nIQABCEAAAsVHAIFSfH1OiyEAAQhAAAI5TwCBkvNdRAUhAAEIQAACxUcAgVJ8fU6LIQABCEAA\nAjlPAIGS811EBSEAAQhAAALFRwCBUnx9ToshAAEIQAACOU8AgZLzXUQFIQABCEAAAsVHAIFS\nfH1OiyEAAQhAAAI5T+D/A178eZRzoLKYAAAAAElFTkSuQmCC"" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 14 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": [ ""We see that assuming mutations are partly recessive leads to a more deleterious inferred DFE since stronger selection is necessary to remove a similar amount of recessive mutations.\n"", ""\n"", ""We can also let `h` vary when inferring the DFE (cf. the {doc}`simulation guide <../R/simulation>`)."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""## Folded inference\n"", ""To infer the DFE from a folded SFS, simply pass folded spectra to {class}`~fastdfe.base_inference.BaseInference`. Folded inference is performed whenever the spectra are folded, i.e., when all entries where the derived allele is the major allele are zero. Folded spectra contain little information on beneficial mutations so we only infer the deleterious part of the DFE here."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""is_executing"": true, ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:41:06.583674Z"", ""start_time"": ""2026-01-04T10:41:00.056878Z"" } }, ""source"": [ ""# create inference object\n"", ""inf <- fd$BaseInference(\n"", "" sfs_neut = sfs_neut$fold(),\n"", "" sfs_sel = sfs_sel$fold()\n"", "")\n"", ""\n"", ""# run inference\n"", ""sfs_modelled <- inf$run()\n"", ""\n"", ""p <- inf$plot_discretized(intervals = c(-Inf, -100, -10, -1, 0));"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nS5tWTVhuISQAAAAASUVORK5CYII="" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 15 }, { ""cell_type"": ""code"", ""metadata"": { ""is_executing"": true, ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:41:06.769324Z"", ""start_time"": ""2026-01-04T10:41:06.594849Z"" } }, ""source"": ""p <- inf$plot_sfs_comparison();"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nlBSEAAIIIIAAAhUl8P8Bo1Ey3dEel4YAAAAASUVORK5CYII="" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 16 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": [ ""## Serialization\n"", ""Inference objects can be serialized to JSON files for later use (cf. {func}`~fastdfe.base_inference.BaseInference.to_file`)."" ] }, { ""metadata"": { ""is_executing"": true, ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:41:06.817857Z"", ""start_time"": ""2026-01-04T10:41:06.774213Z"" } }, ""cell_type"": ""code"", ""source"": [ ""# save the inference object to a file\n"", ""# unserialize with BaseInference$from_file\n"", ""inf$to_file(\""serialized.json\"")\n"", ""\n"", ""# we can also save a short summary to fa ile\n"", ""inf$get_summary()$to_file(\""summary.json\"")"" ], ""outputs"": [], ""execution_count"": 17 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""## Joint inference\n"", ""fastDFE supports joint inference of several SFS types, where any parameters can be shared between types. In this example, we create a {class}`~fastdfe.joint_inference.JointInference` object with two types, where we share ``eps``, the rate of ancestral misidentification and ``S_d``, the mean selection coefficient for deleterious mutations (cf. {class}`~fastdfe.parametrization.GammaExpParametrization`). For more complex stratifications, see the {class}`~fastdfe.parser.Parser`) module."" ] }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:41:33.575105Z"", ""start_time"": ""2026-01-04T10:41:06.821782Z"" } }, ""cell_type"": ""code"", ""source"": [ ""# neutral SFS for two types\n"", ""sfs_neut <- fd$Spectra(list(\n"", "" pendula = c(177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 0),\n"", "" pubescens = c(172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 0)\n"", ""))\n"", ""\n"", ""# selected SFS for two types\n"", ""sfs_sel <- fd$Spectra(list(\n"", "" pendula = c(797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 0),\n"", "" pubescens = c(791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 0)\n"", ""))\n"", ""\n"", ""# create inference object\n"", ""inf <- fd$JointInference(\n"", "" sfs_neut = sfs_neut,\n"", "" sfs_sel = sfs_sel,\n"", "" shared_params = list(fd$SharedParams(types = c(\""pendula\"", \""pubescens\""), params = list(\""S_d\"")))\n"", "")\n"", ""\n"", ""# run inference\n"", ""sfs_modelled <- inf$run()"" ], ""outputs"": [], ""execution_count"": 18 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""{class}`~fastdfe.joint_inference.JointInference` both runs the joint inference and marginal inference where each type is inferred separately. To see this better we can plot the inferred parameters for the different inference types."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""is_executing"": true, ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:41:33.823404Z"", ""start_time"": ""2026-01-04T10:41:33.585544Z"" } }, ""source"": ""p <- inf$plot_inferred_parameters();"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nSUVORK5CYII="" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 19 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""``marginal.pendula`` and ``marginal.pubescens`` are the marginal inferences for the respective type. ``marginal.all`` is the marginal inference obtaining by adding up the spectra of all types. ``joint.pendula`` and ``join.pubescens`` are the joint inferences for the respective type. We can see that ``eps`` and ``S_d`` are indeed shared between the two. The parameter ``alpha`` in the plot denotes the proportion of beneficial non-synonymous substitutions. Each marginal inference is a {class}`~fastdfe.base_inference.BaseInference` object itself and can be accessed via ``inf.marginal_inferences[type]``.\n"", ""\n"", ""We can now also investigate to what extent the inferred DFEs differ:"" ] }, { ""cell_type"": ""code"", ""metadata"": { ""is_executing"": true, ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:41:34.010647Z"", ""start_time"": ""2026-01-04T10:41:33.828588Z"" } }, ""source"": ""p <- inf$plot_discretized();"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nBNpHQA5K+/pEGomACIiACIjA4An8Cx6pBnwSHmT2AAAAAElFTkSuQmCC"" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 20 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Model comparison\n"", ""We can obtain information about the goodness of fit achieved by sharing the parameter by performing a likelihood ratio test (cf. {func}`~fastdfe.joint_inference.JointInference.perform_lrt_shared`). This compares the likelihood of the joint inference with the product of the marginal likelihoods."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""is_executing"": true, ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:41:34.023128Z"", ""start_time"": ""2026-01-04T10:41:34.016254Z"" } }, ""source"": ""inf$perform_lrt_shared()"", ""outputs"": [ { ""data"": { ""text/html"": [ ""0.509749259118573"" ], ""text/markdown"": ""0.509749259118573"", ""text/latex"": ""0.509749259118573"", ""text/plain"": [ ""[1] 0.5097493"" ] }, ""metadata"": {}, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 21 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""The test is not significant, indicating that the simpler model of sharing the parameters explains the data sufficiently well. Indeed, we do not observe a lot of differences between the inferred parameters of joint and the marginal inferences."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""## Covariates\n"", ""{class}`~fastdfe.joint_inference.JointInference` also supports the inclusion of covariates associates with the different SFS types. This provides more powerful model testing and reduces the number of parameters that need to be estimated for the joint inference. For a more interesting example we stratify the SFS of `B. pendula` by the sites' reference base as is described in more detail in the {mod}`~fastdfe.parser` module."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""is_executing"": true, ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:43:11.789241Z"", ""start_time"": ""2026-01-04T10:41:34.027105Z"" } }, ""source"": [ ""# instantiate parser\n"", ""p <- fd$Parser(\n"", "" n = 10,\n"", "" vcf = paste0(\n"", "" \""https://github.com/Sendrowski/fastDFE/\"",\n"", "" \""blob/dev/resources/genome/betula/\"",\n"", "" \""all.polarized.deg.subset.200000.vcf.gz?raw=true\""\n"", "" ),\n"", "" stratifications = list(fd$DegeneracyStratification(), fd$AncestralBaseStratification())\n"", "")\n"", ""\n"", ""# parse SFS\n"", ""s <- p$parse()\n"", ""\n"", ""# visualize spectra\n"", ""p <- s$plot();"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nAAAASUVORK5CYII="" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 22 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""We now create the inference object from the spectra. In this contrived example we make up some covariates that covary with ``S_d``, the mean strength of negative selection. Covariates introduce a linear relationship by default but this can be modified by specifying a custom callback function (see {class}`~fastdfe.optimization.Covariate`)."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""is_executing"": true, ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:44:16.011902Z"", ""start_time"": ""2026-01-04T10:43:11.813818Z"" } }, ""source"": [ ""# create inference object\n"", ""inf <- fd$JointInference(\n"", "" sfs_neut = s$select('neutral.*')$merge_groups(1),\n"", "" sfs_sel = s$select('selected.*')$merge_groups(1),\n"", "" covariates = list(fd$Covariate(param = 'S_d', values = list(A = 1, C = 2, T = 3, G = 4))),\n"", "" n_runs = 50 # increase number of initial runs for stability\n"", "")\n"", ""\n"", ""# run inference\n"", ""sfs_modelled <- inf$run()"" ], ""outputs"": [], ""execution_count"": 23 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Let's visualize the inferred parameters"" ] }, { ""cell_type"": ""code"", ""metadata"": { ""is_executing"": true, ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:44:16.342497Z"", ""start_time"": ""2026-01-04T10:44:16.035756Z"" } }, ""source"": ""p <- inf$plot_inferred_parameters();"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\ngg=="" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 24 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": ""We observe that ``S_d`` shows little variation across the jointly inferred types, because it does not change linearly with respect to the arbitrary covariates specified. Indeed, the median of the covariate across all bootstrap replicates is close to zero. Note that covariates are named ``c0``, ``c1``, etc., by default."" }, { ""cell_type"": ""code"", ""metadata"": { ""is_executing"": true, ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:44:16.359309Z"", ""start_time"": ""2026-01-04T10:44:16.348411Z"" } }, ""source"": ""median(inf$bootstraps[['A.c0']])"", ""outputs"": [ { ""data"": { ""text/html"": [ ""0"" ], ""text/markdown"": ""0"", ""text/latex"": ""0"", ""text/plain"": [ ""[1] 0"" ] }, ""metadata"": {}, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 25 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Model comparison\n"", ""We can perform a likelihood ratio test to see whether including the covariates produces a significantly better fit than simply sharing the parameter in question among the types (cf. {func}`~fastdfe.joint_inference.JointInference.perform_lrt_covariates`)."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""is_executing"": true, ""ExecuteTime"": { ""end_time"": ""2026-01-04T10:44:30.067234Z"", ""start_time"": ""2026-01-04T10:44:16.363152Z"" } }, ""source"": ""inf$perform_lrt_covariates()"", ""outputs"": [ { ""data"": { ""text/html"": [ ""1"" ], ""text/markdown"": ""1"", ""text/latex"": ""1"", ""text/plain"": [ ""[1] 1"" ] }, ""metadata"": {}, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 26 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""As expected, the specified covariates do not improve the fit significantly."" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""R"", ""language"": ""R"", ""name"": ""ir"" }, ""language_info"": { ""codemirror_mode"": ""r"", ""file_extension"": "".r"", ""mimetype"": ""text/x-r-source"", ""name"": ""R"", ""pygments_lexer"": ""r"", ""version"": ""4.3.1"" } }, ""nbformat"": 4, ""nbformat_minor"": 4 } ","Unknown" "Allele","Sendrowski/fastDFE","docs/reference/R/spectra.ipynb",".ipynb","186532","350","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# Working with SFS\n"", ""## Subtypes\n"", ""fastDFE offers a set of utilities for handling and manipulating site-frequency spectra (SFS) data, especially when there are multiple types. The {class}`~fastdfe.spectrum.Spectra` class is designed to hold and manipulate spectra of multiple types. It provides a number of methods and properties for creating, accessing, and manipulating the spectra data. Usually we would obtain already stratified spectra from {class}`~fastdfe.parser.Parser`, but we can also create them manually."" ] }, { ""cell_type"": ""code"", ""execution_count"": 14, ""outputs"": [], ""source"": [ ""library(fastdfe)\n"", ""\n"", ""# load the fastdfe package\n"", ""fd <- load_fastdfe()"" ], ""metadata"": { ""collapsed"": false, ""ExecuteTime"": { ""end_time"": ""2023-08-20T13:49:41.777182Z"", ""start_time"": ""2023-08-20T13:49:41.765783Z"" } } }, { ""metadata"": { ""tags"": [ ""remove-cell"" ], ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:46:12.179064Z"", ""start_time"": ""2025-11-30T10:46:08.231657Z"" } }, ""cell_type"": ""code"", ""source"": [ ""setwd(\""/Users/au732936/PycharmProjects/fastDFE\"")\n"", ""reticulate::use_condaenv(\""/Users/au732936/miniconda3/envs/dev-r-fastdfe\"", required = TRUE)\n"", ""source(\""R/fastdfe.R\"")\n"", ""fd <- load_fastdfe()\n"", ""# set plot size\n"", ""options(repr.plot.width = 7, repr.plot.height = 3)"" ], ""outputs"": [], ""execution_count"": 10 }, { ""cell_type"": ""code"", ""source"": [ ""# create spectra with two subtypes and two types\n"", ""sfs <- fd$Spectra$from_spectra(list(\n"", "" subtype1.type1=fd$Spectrum$standard_kingman(10) * 1,\n"", "" subtype1.type2=fd$Spectrum$standard_kingman(10) * 2,\n"", "" subtype2.type1=fd$Spectrum$standard_kingman(10) * 3\n"", ""))\n"", ""\n"", ""# plot spectra\n"", ""p <- fd$Spectra$plot(sfs)"" ], ""metadata"": { ""collapsed"": false, ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:46:12.292823Z"", ""start_time"": ""2025-11-30T10:46:12.190045Z"" } }, ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nRU5ErkJggg=="" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"" } ], ""execution_count"": 11 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""We access types by their index from which we obtain a {class}`~fastdfe.spectrum.Spectrum` object."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:46:12.388087Z"", ""start_time"": ""2025-11-30T10:46:12.304095Z"" } }, ""source"": [ ""sub <- fd$Spectra$select(sfs, \""subtype1.type1\"")\n"", ""\n"", ""p <- fd$Spectrum$plot(sub)"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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"" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"" } ], ""execution_count"": 12 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""We can also use wildcards to access multiple types at once."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:46:12.501769Z"", ""start_time"": ""2025-11-30T10:46:12.402431Z"" } }, ""source"": [ ""subtypes <- fd$Spectra$select(sfs, \""subtype1.*\"")\n"", ""\n"", ""p <- fd$Spectra$plot(subtypes)"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nKZpZYhbCAAAAAElFTkSuQmCC"" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"" } ], ""execution_count"": 13 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Grouping\n"", ""To get rid of the subtypes, we can merge the spectra over the specified number of groups."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:46:12.615478Z"", ""start_time"": ""2025-11-30T10:46:12.512197Z"" } }, ""source"": [ ""merged <- fd$Spectra$merge_groups(sfs, 1)\n"", ""\n"", ""p <- fd$Spectra$plot(merged)"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nlGcLSQnOpQoAAAAASUVORK5CYII="" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"" } ], ""execution_count"": 14 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""All subtypes for each type are merged into a single spectrum by adding them upp."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Serialization\n"", ""We can also save the spectra to a file and restore them again."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:46:12.640578Z"", ""start_time"": ""2025-11-30T10:46:12.634094Z"" } }, ""source"": [ ""sfs$to_file(\""spectra.csv\"")\n"", ""\n"", ""sfs2 <- fd$Spectra$from_file(\""spectra.csv\"")"" ], ""outputs"": [], ""execution_count"": 15 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Prefixing\n"", ""Here we prefix the spectra with a string to distinguish them and then combine them into a single spectra object."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:46:12.758027Z"", ""start_time"": ""2025-11-30T10:46:12.649226Z"" } }, ""source"": [ ""sfs <- fd$Spectra$prefix(sfs, 'original')\n"", ""sfs2 <- fd$Spectra$prefix(sfs2, 'restored')\n"", ""\n"", ""combined <- fd$Spectra$combine(sfs, sfs2)\n"", ""\n"", ""p <- combined$plot()"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl\nR2VuZXJpY1JHQgAAOI2NVV1oHFUUPpu5syskzoPUpqaSDv41lLRsUtGE2uj+ZbNt3CyTbLRB\nkMns3Z1pJjPj/KRpKT4UQRDBqOCT4P9bwSchaqvtiy2itFCiBIMo+ND6R6HSFwnruTOzu5O4\na73L3PnmnO9+595z7t4LkLgsW5beJQIsGq4t5dPis8fmxMQ6dMF90A190C0rjpUqlSYBG+PC\nv9rt7yDG3tf2t/f/Z+uuUEcBiN2F2Kw4yiLiZQD+FcWyXYAEQfvICddi+AnEO2ycIOISw7UA\nVxieD/Cyz5mRMohfRSwoqoz+xNuIB+cj9loEB3Pw2448NaitKSLLRck2q5pOI9O9g/t/tkXd\na8Tbg0+PszB9FN8DuPaXKnKW4YcQn1Xk3HSIry5ps8UQ/2W5aQnxIwBdu7yFcgrxPsRjVXu8\nHOh0qao30cArp9SZZxDfg3h1wTzKxu5E/LUxX5wKdX5SnAzmDx4A4OIqLbB69yMesE1pKojL\njVdoNsfyiPi45hZmAn3uLWdpOtfQOaVmikEs7ovj8hFWpz7EV6mel0L9Xy23FMYlPYZenAx0\nyDB1/PX6dledmQjikjkXCxqMJS9WtfFCyH9XtSekEF+2dH+P4tzITduTygGfv58a5VCTH5Pt\nXD7EFZiNyUDBhHnsFTBgE0SQIA9pfFtgo6cKGuhooeilaKH41eDs38Ip+f4At1Rq/sjr6NEw\nQqb/I/DQqsLvaFUjvAx+eWirddAJZnAj1DFJL0mSg/gcIpPkMBkhoyCSJ8lTZIxk0TpKDjXH\nliJzZPO50dR5ASNSnzeLvIvod0HG/mdkmOC0z8VKnzcQ2M/Yz2vKldduXjp9bleLu0ZWn7vW\nc+l0JGcaai10yNrUnXLP/8Jf59ewX+c3Wgz+B34Df+vbVrc16zTMVgp9um9bxEfzPU5kPqUt\nVWxhs6OiWTVW+gIfywB9uXi7CGcGW/zk98k/kmvJ95IfJn/j3uQ+4c5zn3Kfcd+AyF3gLnJf\ncl9xH3OfR2rUee80a+6vo7EK5mmXUdyfQlrYLTwoZIU9wsPCZEtP6BWGhAlhL3p2N6sTjRdd\nuwbHsG9kq32sgBepc+xurLPW4T9URpYGJ3ym4+8zA05u44QjST8ZIoVtu3qE7fWmdn5LPdqv\ngcZz8Ww8BWJ8X3w0PhQ/wnCDGd+LvlHs8dRy6bLLDuKMaZ20tZrqisPJ5ONiCq8yKhYM5cCg\nKOu66Lsc0aYOtZdo5QCwezI4wm9J/v0X23mlZXOfBjj8Jzv3WrY5D+CsA9D7aMs2gGfjve8A\nrD6mePZSeCfEYt8CONWDw8FXTxrPqx/r9Vt4biXeANh8vV7/+/16ffMD1N8AuKD/A/8leAvF\nY9bLAAAAOGVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAACoAIABAAAAAEAAANIoAMA\nBAAAAAEAAAFoAAAAAFPiRRYAAEAASURBVHgB7N0JvNTT/8fxT6kU2pT2aLdFSUkhIhXa/FCR\nFNooCtkjQqkQUYmobBUVEgpRkVJKkr81ZW/TrrT/vQ/fMXea7d47d2buzOs8HreZ+S7ne87z\ne/1+87mfc843z/6/i1EQQAABBBBAAAEEEEAAAQQsLwYIIIAAAggggAACCCCAAAL/CBAg8ZuA\nAAIIIIAAAggggAACCPwrQIDErwICCCCAAAIIIIAAAggg8K8AARK/CggggAACCCCAAAIIIIDA\nvwIESPwqIIAAAggggAACCCCAAAL/ChAg8auAAAIIIIAAAggggAACCPwrQIDErwICCCCAAAII\nIIAAAggg8K8AARK/CggggAACCCCAAAIIIIDAvwL5cqvEhAkTbMyYMbm1+bQbAQQQQAABBFJU\nYOzYsXbkkUemaO/oFgKpL5BrA6QtW7ZY586drX379ql/l+ghAggggAACCOQKgW7dutnu3btz\nRVtpJAIIBBfItQGSupM3b17Lnz9/8J6xFQEEEEAAAQQQiLNAnjx54nxFLocAArEWYA5SrEWp\nDwEEEEAAAQQQQAABBHKtAAFSrr11NBwBBBBAAAEEEEAAAQRiLUCAFGtR6kMAAQQQQAABBBBA\nAIFcK0CAlGtvHQ1HAAEEEEAAAQQQQACBWAsQIMValPoQQAABBBBAAAEEEEAg1woQIOXaW0fD\nEUAAAQQQQAABBBBAINYCBEixFqU+BBBAAAEEEEAAAQQQyLUCBEi59tbRcAQQQAABBBBAAAEE\nEIi1AAFSrEWpDwEEEEAAAQQQQAABBHKtAAFSrr11NBwBBBBAAAEEEEAAAQRiLUCAFGtR6kMA\nAQQQQAABBBBAAIFcK0CAlGtvHQ1HAAEEEEAAAQQQQACBWAsQIMValPoQQAABBBBAAAEEEEAg\n1woQIOXaW0fDEUAAAQQQQAABBBBAINYCBEixFqU+BBBAAAEEEEAAAQQQyLUCBEi59tbRcAQQ\nQAABBBBAAAEEEIi1AAFSrEWpDwEEEEAAAQQQQAABBHKtAAFSrr11NBwBBBBAAAEEEEAAAQRi\nLUCAFGtR6kMAAQQQQAABBBBAAIFcK5Av0S3ftGmTzZ071/bv32+nnHKKlS1bNtFN4voIIIAA\nAggggAACCCCQpgIJzSC9//77dvHFF9uCBQts9uzZ1rlzZ/v000/T9FbQbQQQQAABBBBAAAEE\nEEi0QMIySLt377Ynn3zSunTpYu3bt3cOgwYNsqefftrq1q2baBeujwACCCCAAAIIIIAAAmko\nkLAM0t69e61Xr17WqlUrH3vx4sVtw4YNvs+8QQABBBBAAAEEEEAAAQTiKZCwDFLBggWtUaNG\nrq9//PGHLVy40F599VW7+uqrD+i/sk1Dhw7NsH3z5s124oknZtjGBwQQQAABBBBAAAEEEEAg\nOwIJC5D8Gz1gwABbtmyZlStXzs444wz/Xe79nj17bPz48Rm2a0GHrAZIZabVzFBX4IfVrZYH\nbor686YmK0IeW+y9qiH3sQMBBBBAAAEEEEAAAQQSL5AUAdJjjz1mWs1O8486duxoU6ZMsaJF\ni/p0Dj74YHv55Zd9n/Xm3XffzfCZDwgggAACCCCAAAIIIIBAdgUSNgcpsOHFihWzbt26meYm\nzZ8/P8PuvHnzWq1atTL8FC5cOMMxfEAAAQQQQAABBBBAAAEEsiuQsABp1apVdtFFF9lvv/3m\n68Nff/3lAiQ9E4mCAAIIIIAAAggggAACCMRbIGEBUqVKlax06dJuqW8tuLBmzRobOXKkG1p3\n6qmnxtuB6yGAAAIIIIAAAggggAAClrAASfY33HCDrVixwtq0aWNt27a1lStXutXqtNw3BQEE\nEEAAAQQQQAABBBCIt0BCF2moXr26vfjii7Z27VrLly+fHX744fHuP9dDAAEEEEAAAQQQQAAB\nBHwCCQ2QvFaUKlXKe8srAggggAACCCCAAAIIIJAwgYQOsUtYr7kwAggggAACCCCAAAIIIBBE\ngAApCAqbEEAAAQQQQAABBBBAID0FCJDS877TawQQQAABBBBAAAEEEAgiQIAUBIVNCCCAAAII\nIIAAAgggkJ4CBEjped/pNQIIIIAAAggggAACCAQRIEAKgsImBBBAAAEEEEAAAQQQSE8BAqT0\nvO/0GgEEEEAAAQQQQAABBIIIECAFQWETAggggAACCCCAAAIIpKcAAVJ63nd6jQACCCCAAAII\nIIAAAkEECJCCoLAJAQQQQAABBBBAAAEE0lOAACk97zu9RgABBBBAAAEEEEAAgSACBEhBUNiE\nAAIIIIAAAggggAAC6SlAgJSe951eI4AAAggggAACCCCAQBABAqQgKGxCAAEEEEAAAQQQQACB\n9BQgQErP+06vEUAAAQQQQAABBBBAIIgAAVIQFDYhgAACCCCAAAIIIIBAegoQIKXnfafXCCCA\nAAIIIIAAAgggEESAACkICpsQQAABBBBAAAEEEEAgPQUIkNLzvtNrBBBAAAEEEEAAAQQQCCJA\ngBQEhU0IIIAAAggggAACCCCQngIESOl53+k1AggggAACCCCAAAIIBBHIF2QbmxBAAAEEEEAA\nAQRymcBHH31kb7/9tq1atcpOO+0069Kliz3wwAN27rnn2umnn25ff/21TZgwwXr16mVPPvmk\nO65t27bWrFkz19NFixbZpEmTbOXKlVapUiU777zzrEmTJhkURowYYQUKFLCuXbtm2P7cc8/Z\n+vXr7cYbb3Tbn3rqKStatKjVr1/fnn32Wfvuu++sUaNG1qpVKytfvnyGc/mAQLIJkEFKtjtC\nexBAAAEEEEAAgUwKDB482M444wybPn267dy50+69915r2rSpDRgwwBQ4qXzzzTfuc8+ePe3u\nu++2cePG2auvvur23X///S6Y0eeDDjrIZs6c6QKrHj16uP3ePwqsnnnmGe+j7/X555+3xx57\nzPd5zJgxNmjQIGvYsKF98MEHduihh9p9991nJ554ogvAfAfyBoEkFCCDlIQ3hSYhgAACCCCA\nAALRCsyePdvuuOMOu+6661yQkidPHpfNOfvss4NWoYDlyy+/tLJly9quXbvs448/tv79+1u7\ndu1MmaD8+fPb/v37rW/fvvbII49Y48aN3b6glYXZ+Pnnn7s6hg4d6o5as2aN1atXz/73v//Z\nkiVLTO2kIJCMAmSQkvGu0CYEEEAAAQQQQCBKgSlTplihQoXccDov6ChZsqTL2ASrQsPjjjvu\nOCtevLiVLl3aDYFT1kgZIAVHKqpHw/NKlSplTzzxRLBqIm5T/ffcc4/vOF3rhhtusKVLl9qK\nFSt823mDQLIJECAl2x2hPQgggAACCCCAQCYEFi9ebFWrVrXChQtnOKtOnToZPnsfatSo4b11\nr1999ZUdddRRLhjy31GwYEGrVauWm7vkvz3a98cff7wbWud/vIbYqXz22Wf+m3mPQFIJECAl\n1e2gMQgggAACCCCAQOYE1q1b5xZOCDxLWaVgpUSJEhk2//HHH1akSJEM27wPhx12mO3evdv7\nGPJ17969B+wrVqzYAdsOOeQQt23z5s0H7GMDAskiQICULHeCdiCAAAIIIIAAAlkQqFatmluR\nTvOG/MsPP/zg/zHke2Wffvzxx6D7tSJe7dq1ffs0FC9YwPTTTz/5jvHe/PLLL95b36t3nVDZ\nLd+BvEEggQIESAnE59IIIIAAAggggEB2BbTogZbYnjhxYoaqHn/88QyfQ33QkuDKIr3++usZ\nDtEwOM0XOumkk3zblRVSkLN9+3bfNgViXuDj2/j3m2XLlpmG7/kXLQKhzFbNmjX9N/MegaQS\nIEBKqttBYxBAAAEEEEAAgcwJXHnllXbyySdb586d7ZZbbjEtsa2gSYs3qHgLN4SqVQsnaA6S\nztcS3gpqXnnlFWvZsqVVrlzZbrrpJt+pemaSgqmOHTvarFmz3FLh2qYFGQLLvn37rHXr1jZj\nxgzTinbXXnute69r6FlKFASSVYBlvpP1ztAuBBBAAAEEEEAgCoF8+fLZnDlz7Oabb3bPNdqw\nYYN7KOvkyZPtggsuOGChhMAqldGZN2+ede/e3bp162YKbPTcIj1XafTo0VahQgXfKb1797Zv\nv/3W9NyjqVOnuoUh+vXrZ7///rv77Dvw7zdaKU8PqVWgtWfPHqtSpYoNHz7cLr30Uv/DeI9A\n0gkQICXdLaFBCCCAAAIIIIBA9AKrV692Ac3IkSMznKTnHaloyW8VZXMC5ym5HX//U758efeQ\n2R07drj5TJrX5C357R2jVy2yMHbsWBsxYoRp3lH16tXdg2W1b9iwYXrxFQVujz76qA0cONDU\nRgVIFARygwBD7HLDXaKNCCCAAAIIIIBACAHN69EqdHrgq38ZNGiQG16nOUbRFmWTjj322KDB\nkX8dCpSOOeYYX3Dkvy/wvY4lOApU4XMyC5BBSua7Q9sQQAABBBBAAIEIAu3atbMhQ4ZYixYt\nrGnTpu7hr++//759+eWX9tRTT1nFihUj1MBuBBDwFyBA8tfgPQIIIIAAAgggkMsEtMCCVox7\n6623bObMmbZw4UI755xz7OGHH3YBUyK607x5czfvKBHX5poIZFeAACm7gpyPAAIIIIAAAggk\nWKBcuXLWpUsX95PgprjLDxgwIBmaQRsQyJIAc5CyxMZJCCCAAAIIIIAAAgggkIoCBEipeFfp\nEwIIIIAAAggggAACCGRJgAApS2ychAACCCCAAAIIIIAAAqkoQICUineVPiGAAAIIIIAAAggg\ngECWBAiQssTGSQgggAACCCCAAAIIIJCKAgRIqXhX6RMCCCCAAAIIIIAAAghkSYBlvrPExkkI\nIIAAAggggEDyCGzr1CEujTls/ItxuQ4XQSCRAmSQEqnPtRFAAAEEEEAAAQQQQCCpBAiQkup2\n0BgEEEAAAQQQQAABBBBIpAABUiL1uTYCCCCAAAIIIIAAAggklQABUlLdDhqDAAIIIIAAAggg\ngAACiRQgQEqkPtdGAAEEEEAAAQQQQACBpBIgQEqq20FjEEAAAQQQQAABBBBAIJECBEiJ1Ofa\nCCCAAAIIIIAAAgggkFQCBEhJdTtoDAIIIIAAAgggkL4CEydOtOnTp0cF8MUXX9iQIUOiOjaa\ng55//nmbOXNmNIdm+piXXnrJ3nrrrbDnbdmyJez+nNr56quv2uzZsyNWn+zti9iBTBxAgJQJ\nLA5FAAEEEEAAAQQQyDmBl19+OWIg4V1dAdJDDz3kfcz2qwKkGTNmZLueYBVECpAUPDVv3jzY\nqTm6be7cudauXTtbuHBh2Oske/vCNj4LOwmQsoDGKQgggAACCCCAAAKxF5g6daqNHDkyqoov\nu+wyW7t2bVTHJvtBy5cvtz///DNuzdy9e7cNGDDAmjZtanny5Il43WRvX8QOZPIAAqRMgnE4\nAggggAACCCCAQHQCH3/8sXXq1MnOPfdc6927t/3888++E4cPH+4yNjfeeKN16NDBvvnmGxsx\nYoS98MILvmN++OEHu/vuu+3888+3/v3724cffug+64BPPvnE+vTp447VF/6uXbuajr/tttus\nWbNm1qtXL/v99999denNG2+8YVdddZWdc845dsUVV9jbb7+dYX+4D+PHj7c2bdq4ttx+++22\nYcMGd/iOHTvctVesWOE7/ZdffnHbNm3a5Nu2b98+e/TRR+28886z7t27u/5q55w5c2zKlCnm\nnaOsTrdu3Q4ImO6880774IMPbMGCBXbffffZ+++/b+3bt3f9eP31133X8d4899xz1rZtW2vV\nqpUNGzbM9uzZ4+2ycePG2bPPPmuvvfaa1ahRw7c92Jtkb1+wNmd3GwFSdgU5HwEEEEAAAQQQ\nQOAAAQUjZ5xxhm3evNkuuugimzdvnp1wwgkuiNHBGs6mQODTTz+1bdu22WGHHWbvvPOOffTR\nR66uP/74wwUy7777rvuSry/qLVu2tFdeecXt//77703D4lT27t1rY8aMccHLmjVr3PGzZs1y\nGRJ3wN//KPhS1qlKlSouaNu+fbs7ftGiRd4hIV8VbNxwww2uPxqSpuCkSZMm7vhdu3a5a+u6\nXlHb1R5dwysKSlRP69atXXBUr149Ux9KlSplFSpUsEMOOcROOeUUF7C8+OKLLnjxzv36669t\n0KBBVqlSJfvuu+/c0EIFeDq+TJkyrl8TJkzwDnfB6E033WTVq1e3hg0burlaF198sW+/HFVP\nNMP6kr19vk7F8E2+GNZFVQgggAACCCCAAAIIOIHrr7/efXH3gpgePXpY5cqVrV+/fqY5OSqF\nChVyWZGDDjrIffb/R/OLFGAoC6VhYDr/+OOPN2ViQhVlTDR0TOXoo492mStlkcqWLeuG4z38\n8MMuKNN+BUtHHHGEy8goWAlXFNzVrVvXlO1SWxT4KWuzc+fOcKdl2HfwwQe7uT758uVzfTnq\nqKNs6NChNnr0aKtfv74LlpQFU1Ewo0yaMmsqCqwaNWrk/BRAasEEBUTKrKnIT96XXnqpffvt\nt/bEE0+48/VZRfUpWFKQeeaZZ7qgyu2I4p9jjz02qdsXRRcyfQgBUqbJOAEBBBBAAAEEEEAg\nnMDGjRtt1apVNnDgwAyHtWjRIsNKcSeffLL7cp/hoH8/KLOk4Wj+c2R0/rRp04Id7rYpo+KV\nI4880r315vbce++9bsid5jkpI/P555+bhsf99ddf3ikhXzWUTW2pVq2aC0rUjuuuu84U7ERz\nvirWsD8d7xVloNTHYKVz584uuFNWShkcBUte4KfjFWydddZZvlM1l+jBBx90QxhV5/79+02Z\nMfXRK8rQaZ8CpOyWZG9fdvvHELvsCnI+AggggAACCCCAQAYBb+5N+fLlM2wvXbq0Gw7nbSxR\nooT39oBXDVOrWLFihu3FihXL8Dnww6GHHurblDfvP19zFSyoaP6PMlgaqqbFHZRVUfARTWnc\nuLEtXbrUzflRBkdD05T18fqpOrzr6L3mRAWWwL7IIlQGSsGPArxJkya5Jbg138l/iJwyXxqS\n55XDDz/cvdVQRbVJgZiCKBl4PwrolIGLRUn29mW3j/+FsdmtifMRQAABBBBAAAEEEPhbQF/u\nCxQo4OYZaWiYV/Scodq1a3sfw77qy/ySJUsyHJPV5xQpU3Trrbe6uTsKFFQ0b6ljx45hh+x5\nF9d1CxcubA888ID7+eyzz9z8H23XIggqCk68ouxZYFGA5V8038pbIME/S6Zj9FmLW0yePNnN\nV1JwpAyQV7Sgg+YQadicynvvvWcKDjWsUAthKEDTPCPNP1JRX7XIhHc9tzET/yR7+zLRlagO\nJYMUFRMHIYAAAggggAACCEQroDkxWoBBQ8P0DB0FKE8//bSb73PJJZdEVY0WRVAAosUGli1b\n5lax01ygrBRlVJStWr16tQuINLdJc3aUwQk1RG7w4MFupTxdT0PVFEwpKFGmSPVoVbiqVau6\neVRaZOGZZ56xrVu3ukUo7r///gOaqcyTgiIFL7JQ8NezZ093nDJAmiul+UPeanMKkObPn++C\nJL0PLBpyp0yYVvPTtTXsTdkiZbsUKGn1vy+//NL175577nEBYpEiRQKrCfpZQxDVfy9Dlmzt\nC9roGG4kQIohJlUhgAACCCCAAAII/COgoWxa3lsZluLFi7s5NI8//rgbphaNUZ06ddx8I60Y\nd/rpp7tAoEuXLlawYMFoTs9wTP78+d1KbhMnTnTD6rTymzIymlukbFCwouXCZ8+e7XYpmNL8\npgYNGrhMklaye+yxx9zCDTpg1KhRplXz1E8t5tC3b193nv8/CgwVEBUtWtQtTy4LLTeuoiyb\ngkoFNt68JK1Yp+0aSqchbf5FdSi4U6ZOAZGuqSGEKuqrFpBQEKhVA0uWLOnapsUy9D6aoofw\nqv/eUubJ1r5o+pCdY/L8HQX/MzAzO7Uk4Fyt+KFfbG91j8w0ocy0mmEPX91qedj94XZuavLf\nGviBxxV7r2rgJj4jgAACCCCAQAoJ6Bk7el6NMgvxLNs6/bPaWU5f87DxL2b6Evoiv27dOreU\ndWZOVtZG82iOOeYY32kKVPS8pKwOtVNFGp6mAMl/wQTfBSK80Qp6v/76q+tL4LAzb5/mXXnz\nn4JVF+76ytj4z7NSgKng5K677vJVpUBH2bX169eb5mkpgNJqgMGKllhXRircXK9g54Xaluzt\nC9XuzG5nDlJmxTgeAQQQQAABBBBAIGoBBTkagpbZoofCKjCYPn261apVy2Vz9GwhLWGdnZKV\ntnjXU+ATuNhCNPu8Y/Qa7vpecKT5SosXL3bPhPJ/cK5/PXofKfBRpimWJdnbF6u+EiDFSpJ6\nEEAAAQQQQAABBGImoOceacEBzWXSnBgtMKBFEpSlS/Wi5yEpU6YRU1rtzr9oiKFWsUtkSfb2\nZdeGACm7gpyPAAIIIIAAAgggEHMBDYHTQgH60TA9ZaLSpSxYsMAtBhFsGKDmMkW70EVOeSV7\n+7LbbwKk7ApyPgIIIIAAAggggECOCqRTcCRILdiQzCXZ25ddO1axy64g5yOAAAIIIIAAAggg\ngEDKCBAgpcytpCMIIIAAAggggAACCCCQXQECpOwKcj4CCCCAAAIIIIAAAgikjABzkFLmVtIR\nBBBAAAEEEEhXgaw8nyhdreg3ApEEyCBFEmI/AggggAACCCCAAAIIpI0AGaS0udV0FAEEEEAA\nAQRSVWDSYwXi0rV2vXfF5TpcBIFECpBBSqQ+10YAAQQQQAABBBBAAIGkEiBASqrbQWMQQAAB\nBBBAAAEEEEAgkQIESInU59oIIIAAAggggAACCCCQVAIESEl1O2gMAggggAACCCCAAAIIJFKA\nACmR+lwbAQQQQAABBBBAAAEEkkqAACmpbgeNQQABBBBAAAEEEEAAgUQKJHyZ7+3bt9vHH39s\nv/32m9WsWdPq1KmTSA+ujQACCCCAAAIIIIAAAmkskNAM0owZM6xly5Y2ffp0+/rrr+3GG2+0\nhx56KI1vB11HAAEEEEAAAQTSV2DixInue2E0Al988YUNGTIkmkOjOub555+3mTNnRnVsZg96\n6aWX7K233gp72pYtW8Luz6mdr776qs2ePTti9fFu39atW02/DwMHDrQPPvggYvtieUDCAqR9\n+/bZ+PHjrUePHvboo4+6zg8YMMBef/11+/7772PZR+pCAAEEEEAAAQQQyAUCL7/8csRAwuuG\nAqRY/mFdAZL+eJ8TJVKApOCpefPmOXHpsHXOnTvX2rVrZwsXLgx7XLzbp3tRunRpGzNmjC1a\ntMiaNWtm11xzTdg2xnJnwgKkDRs2WL169ezcc8/19eekk05y7zXcjoIAAggggAACCCCQXgJT\np061kSNHRtXpyy67zNauXRvVscl+0PLly+3PP/+MWzN3795tSkw0bdrU8uTJE/G68Wyfkij3\n3XefDRo0yN577z1ThmvSpEn25JNP2ueffx6xrbE4IGEBUsmSJd2QumLFivn6MWvWLDvooIPs\n6KOP9m3Tm7/++ssaNmyY4eeTTz7JcAwfEEAAAQQQQAABBJJLQPPMO3Xq5P4g3rt3b/v55599\nDRw+fLjL2GiKRYcOHeybb76xESNG2AsvvOA75ocffrC7777bzj//fOvfv799+OGH7rMO0HfB\nPn36uGP1hb9r166m42+77TaXcejVq5f9/vvvvrr05o033rCrrrrKzjnnHLviiivs7bffzrA/\n3AeNfGrTpo1ry+233276Y7/Kjh073LVXrFjhO/2XX35x2zZt2uTbpi/+GjV13nnnWffu3V1/\ntXPOnDk2ZcoU885RVqdbt24HBEx33nmnG2q2YMECF0C8//771r59e9cPjcAKLM8995y1bdvW\nWrVqZcOGDbM9e/b4Dhk3bpw9++yz9tprr1mNGjV824O9iXf7Vq9e7QI3/U545ayzznKB3MqV\nK71NOfqasAApsFf6pRo9erT7D0QpNf+iyLZQoUIZfhRIhSuTHitgoX7CnRdp34WDzML9RDqf\n/QgggAACCCCAQDoIKBg544wzbPPmzXbRRRfZvHnz7IQTTnBBjPqv4WwKBD799FPbtm2bHXbY\nYfbOO+/YRx995Hj++OMPF8i8++677ku+vqhr7vorr7zi9mtKhoZiqezdu9cNx1IgtWbNGne8\n/vCuDIlXFHwp61SlShUXtGmhMB2vIVyRioKNG264wfVHQ9IUnDRp0sSdtmvXLndtXdcraruG\nh+kaXlFQonpat27tgiONpFIfSpUqZRUqVLBDDjnETjnlFBewvPjiiy548c7VXH1lVCpVqmTf\nffedG1qoAE/HlylTxvVrwoQJ3uGmYPSmm26y6tWruwSD5mpdfPHFvv1yVD3RDOuLd/vKlStn\nTzzxhCmZ4hVlkPTd/+STT/Y25ehrwlexU++WLVvmov2zzz7brr766gM6fPDBB5t+yf2LgikK\nAggggAACCCCAQHIKXH/99e6LuxfEaN555cqVrV+/fqY5OSr6A7gm4Af7w7fmF3mrHeuP5Tr/\n+OOPN2ViQhVlTDR0TEUjkjSVQ1mksmXLuuF4Dz/8sAvKtF/B0hFHHGHKyChYCVcU3NWtW9eN\nflJbFPgpa7Nz585wp2XYp++zmuuTL18+15ejjjrKhg4d6hIE9evXd8GSsmAqCmaUSfOyKAqs\nGjVq5PwUQGrBBAVECvBU5CfvSy+91L799lsXYOh8fVZRfQqWFGSeeeaZLqhyO6L459hjj7V4\nt8+/WZprpozdrbfeahUrVvTflWPvEx4g6SYrZapfaKUbKQgggAACCCCAAAK5W2Djxo22atUq\ntwiXf09atGiRYaU4ZQSCBUc6R5klDUfznyOj86dNm+ZfZYb3yqh45cgjj3Rvvbk99957rwuW\nNM9JGRnNZ9HwOE3liFQ0lE1tqVatmgtK1I7rrrvOBTvRnK/6tdCAgiOvKAOlPgYrnTt3dsGd\nslLK4CjY8QI/Ha9gS8POvKJM2YMPPuiGMKrO/fv3u8yY/5wdZei0TwFSdku82qc4QRk3Ze38\n+5/d9kc6P6FD7PQXA40rVcRLcBTpVrEfAQQQQAABBBDIHQLe3Jvy5ctnaLCmUWg4nFdKlCjh\nvT3gVcPUAjMG/nPXDzjh7w2HHnqob3PevP98zVWwoKL5P8pgaaiaFndQVkXBRzSlcePGtnTp\nUjfnR1/aNTRNWRWvn6rDu47ea05UYAnsiyxCZaAU/CjA09AyLcGt+U7+Q+SU+dKQPK8cfvjh\n7q2GKqpNCsQURMnA+1FApwxcLEo82qdAWBlAxQhaoMG7n7Fof6Q6/gtjIx0Z4/36pVekK2CN\np/SPcPUL5N3oGF+W6hBAAAEEEEAAAQRyWEBf7gsUKODmGWlomFf0nKHatWt7H8O+6sv8kiVL\nMhyT1ecUKVOkIVoatqdAQUWBWseOHcMO2fMurusWLlzYHnjgAffz2Wefufk/2q5FEFQUnHhF\n2bPAogDLv2i+lbdAgn+WTMfosxa3mDx5spuvpOBIGSCvaEEHzSHSsDkVrfam4FDDCrUQhgI0\nzTPSImcq6qsWmfCu5zZm4p94t0/zzHRvHnvssYQkURKWQdKqIRpXqol3WmXE/2f+/PmZuGUc\nigACCCCAAAIIIJBMAho2pwUYNDRMz9BRgPL000+7+T6XXHJJVE3VoggKQLTYgOara0qG5gJl\npSijomyVVkjTHCZ9B9UIJmVwQg2RGzx4sFspT9fTH/L1hV1BiTJFqkerwlWtWtXNo9IiC888\n84zp4aZaSe/+++8/oJnKPCkoUvAiCwV/PXv2dMcpMaC5Upo/5K02pwBJ34kVJOl9YNGQM2XC\ntJqfrq1hb8qyKNulQEmjtL788kvXv3vuuccFiEWKFAmsJuhnDUFU/70MWTzbJ9suXbq4jNlx\nxx3nVi7U6oX68V8II2jDY7QxYQHS5ZdfnqHDXsf1esEFF8Soe1SDAAIIIIAAAgggkAgBDWXT\nECllWIoXL+7mkDz++ONumFo07alTp46bb6QV404//XQXCOiLc8GCBaM5PcMx+fPnN63kNnHi\nRDesTiu/KSOjuUXKBgUrWi5cw9tUFExpflODBg1cJklzYpTd0MINKqNGjXILiqmf2ta3b1+3\n3f8fBYYKiIoWLeqWJ5eFlhtXUZZNQaUCG29ekkZYabuG0mnElX9RHQrulKlTQKRragihivqq\nBSQUBGrVQK0Gp8XOtFiG/8pw/vUFvtfCCOq/t5R5PNun1f60CIVW8tN1/X/efPPNwKbmyOc8\nf0fB/wzMzJHqc65SrWKnX2xvdY/AK2mJ71Cld+UaoXa57atbLQ+5X0t8hytjZ/23Bn7gccXe\nqxq4ic8IIIAAAgggkEICesaOnlejzEI8S7jvPbFsR7veuzJdnb7Ir1u3zi1lnZmTlbXRPJpj\njjnGd5oCFT0vKatD7VSRhqcpQPJfMMF3gQhvlH369ddfXV8Ch515+zTvKtx8mXDXV8bGf56V\nAkwFCHfddZevZQp0lF1bv369acqKAiitBhisaIl1ZaTCzfUKdl6obcnevlDtzuz2hM1BymxD\nOR4BBBBAAAEEEEAg9wkoyNEQtMwWjSpSYDB9+nSrVauWy+bo2UJ6Rk52Slba4l1PgU/gYgvR\n7POO0Wu463vBkeYrLV682D0TSsMUQ5VIgY8yTbEsyd6+WPWVAClWktSDAAIIIIAAAgggEDMB\nPfdICw5oLpPmxGiBAS2SoCxdqhc9D0mZMo2Y0mp3/kVDDLWKXSJLsrcvuzYESNkV5HwEEEAA\nAQQQQACBmAtoCJwWCtCPhukpE5UuRQ+v1SyYYMMANZcp2oUucsor2duX3X4TIGVXkPMRQAAB\nBBBAAAEEclQgnYIjQYZ6eG6OImei8mRvXya6EvTQhK1iF7Q1bEQAAQQQQAABBBBAAAEEEihA\ngJRAfC6NAAIIIIAAAggggAACySVAgJRc94PWIIAAAggggAACCCCAQAIFmIOUQHwujQACCCCA\nAAIIxEIgK88nisV1qQOBVBQgg5SKd5U+IYAAAggggAACCCCAQJYEyCBliY2TEEAAAQQQQACB\n5BEoM61mXBqzutXyuFyHiyCQSAEySInU59oIIIAAAggggAACCCCQVAIESEl1O2gMAggggAAC\nCCCAAAIIJFKAACmR+lwbAQQQQAABBBBAAAEEkkqAACmpbgeNQQABBBBAAAEEEEAAgUQKECAl\nUp9rI4AAAggggAACCCCAQFIJECAl1e2gMQgggAACCCCAAAIIIJBIAQKkROpzbQQQQAABBBBA\nAAEEEEgqAQKkpLodNAYBBBBAAAEEEEhfgYkTJ9r06dOjAvjiiy9syJAhUR0bzUHPP/+8zZw5\nM5pDM33MSy+9ZG+99VbY87Zs2RJ2f6x3bt261eQ9cOBA++CDDyJWH+/2eQ169dVXbfbs2d7H\nuLwSIMWFmYsggAACCCCAAAIIRBJ4+eWXIwYSXh0KkB566CHvY7ZfFSDNmDEj2/UEqyBSgKTg\nqXnz5sFOzZFt6mvp0qVtzJgxtmjRImvWrJldc801Ia8V7/Z5DZk7d661a9fOFi5c6G2KyysB\nUlyYuQgCCCCAAAIIIIBAJIGpU6fayJEjIx3m9l922WW2du3aqI5N9oOWL19uf/75Z1yauW/f\nPrvvvvts0KBB9t5775kyNJMmTbInn3zSPv/886BtiGf71IDdu3fbgAEDrGnTppYnT56gbcrJ\njQRIOalL3QgggAACCCCAQBoLfPzxx9apUyc799xzrXfv3vbzzz/7NIYPH+4yNjfeeKN16NDB\nvvnmGxsxYoS98MILvmN++OEHu/vuu+3888+3/v3724cffug+64BPPvnE+vTp447VF+quXbua\njr/ttttcRqRXr172+++/++rSmzfeeMOuuuoqO+ecc+yKK66wt99+O8P+cB/Gjx9vbdq0cW25\n/fbbbcOGDe7wHTt2uGuvWLHCd/ovv/zitm3atMm3TYHJo48+auedd551797d9Vc758yZY1Om\nTDHvHGVNunXrdkDAdOedd7qhcAsWLHABzvvvv2/t27d3/Xj99dd91/HePPfcc9a2bVtr1aqV\nDRs2zPbs2eN2rV692gUeMvfKWWed5QKRlStXept8r/Funy48btw4e/bZZ+21116zGjVq+NoS\nrzcESPGS5joIIIAAAggggEAaCSgYOeOMM2zz5s120UUX2bx58+yEE05wQYwYNJxNgcCnn35q\n27Zts8MOO8zeeecd++ijj5zSH3/84QKZd999133J1xf1li1b2iuvvOL2f//996ahYip79+51\nw8UUSK1Zs8YdP2vWLBcIuAP+/kfBl7JOVapUcUHb9u3bXbCjIWaRioKNG264wfVHQ74UnDRp\n0sSdtmvXLndtXdcraruGr+kaXtGXftXTunVrFxzVq1fP1IdSpUpZhQoV7JBDDrFTTjnFBQQv\nvviiCw68c7/++muX8alUqZJ99913bmihAjwdX6ZMGdevCRMmeIe7YPSmm26y6tWrW8OGDd1c\nrYsvvtjtL1eunD3xxBNWsmRJ3/HKIB100EF28skn+7Z5b+LdPl1X91n9jOewQ6+/es3n/4H3\nCCCAAAIIIIAAAgjEQuD66693X9y9IKZHjx5WuXJl69evn2lOjkqhQoVcVkRfzgOL5hcpwFAW\nSsOsdP7xxx9vysSEKsqYaGiWytFHH+0yV8oilS1b1g3He/jhh11Qpv0Klo444ghTRkbBSrii\n4K5u3bqmbJfaosBPWZudO3eGOy3DvoMPPtjNpcmXL5/ry1FHHWVDhw610aNHW/369V2wpCyY\nioIZZdK8LI8Cq0aNGjk/BZBaMEEBkQJCFfnJ+9JLL7Vvv/3WBUA6X59VVJ+CJQWZZ555ptvm\n/aO5XMqI3XrrrVaxYkVvs+/12GOPjXv7FPQlshAgJVKfayOAAAIIIIAAAikosHHjRlu1apVb\nIc2/ey1atMiwUpwyFsGCI52jzJKGo/nPQdH506ZN868yw3tlVLxy5JFHurfe3J57773XDbnT\nPCdlZDTfRsPj/vrrL++UkK8ayqa2VKtWzQUlasd1111nCnaiOV8VayEEHe8VZaDUx2Clc+fO\nLrhTVkoZHAU7XuCn4xVsaVicVzRX58EHH3RDGFXn/v373eIL/nOKlKHTPv8AScGWMlrKivnX\n79Ub6jVe7Qt1/ZzezhC7nBamfgQQQAABBBBAIM0EvLk35cuXz9BzrZym4XBeKVGihPf2gFcN\nUwvMaBQrVuyA4/w3HHroob6PefP+8zVXwYKK5v8og6XFCbS4g7IqCj6iKY0bN7alS5e6OT8K\nKjT0S1kfr5+qw7uO3mtOVGAJ7IssQmWgFPwowNPQNy1xrflO3hA51avMl4bkeeXwww93bzVU\nUW1SIKYgSgbejwI6ZeC8okBTc8M0H0oLNHhe3v5wr/FoX7jr5/S+/8LYnL4S9SOAAAIIIIAA\nAgikhYC+3BcoUMDNM9LQMK/oOUO1a9f2PoZ91Zf5JUuWZDgmq88pUqZIQ8g0bE+BgooCtY4d\nO4YdsuddXNctXLiwPfDAA+7ns88+c/N/tF2LIKgoOPGKsmeBRQGWf9F8K28BAv8smY7RZy1u\nMXnyZDdfScGRMkBe0YIOmqOjYXMqWo1OwaGGFWohDAVomsej+Ucq6qsWmfCup3lc6vtjjz3m\nAiR3UJh/4t2+ME2Jyy4ySHFh5iIIIIAAAggggED6CGjYnBZg0NAwPUNHAcrTTz/t5vtccskl\nUUFoUQQFIFpsYNmyZW4VO80FykpRRkXZKq3gpjlMmtukOTvK4IQaIjd48GC3Up6up6FqCigU\nlChTpHq0KlzVqlXdPCotsvDMM8+YHr6qlfTuv//+A5qpzJOCIgUvslDw17NnT3ecMkCaK6X5\nQ95qcwqQ5s+f74IkvQ8sGhKnTJhW89O1NexNWSBluxQoafW/L7/80vXvnnvucQFikSJFXNu7\ndOniMlLHHXecWxlQqwPqx1toQkMQ1X8vQxbP9gX2MxGfCZASoc41EUAAAQQQQACBFBfQUDYN\n4VKGpXjx4m6Oy+OPP+6GqUXT9Tp16rj5Rlox7vTTT3eBgL7YFyxYMJrTMxyTP39+t5LbxIkT\n3bA6LQKgjIzmFikbFKxouXANb1NRMKX5TQ0aNHCZJM3ZUfZFCzeojBo1yrRqnvqpbX379nXb\n/f9RYKiAqGjRom55cllouXEVZdkUVCqw8eYlacU6bddQOg1p8y+qQ8GdMnUKiHRNDSFUUV+1\ngISCQK0aqNXq1DYtlqH3Wk1PizxopTzV7//z5ptvujq0cIP67y1lHs/2uQYk+J88f0fB/wzM\nTHBDMnt5rfihX2xvdY/A8yc9ViBwk+9z78o1fO+DvVndanmwzW7bhYNC7nI7xs76bw38wCOL\nvVc1cBOfEUAAAQQQQCCFBPSMHT2vRpmFeJYy02rG5XLhviOFaoC+yK9bt84tZR3qmGDblbXR\nPJpjjjnGt1uBip6XlNWhdqpIw9MUIPkvmOC7QIQ3yj79+uuvri+Bw868fZp3FW4+T7jrK2Pj\nP89KAaaCk7vuusvXMgU6yq6tX7/eNE9LAZRWAwxWtMS6MlLh5noFOy/UtmRvX6h2Z3Y7c5Ay\nK8bxCCCAAAIIIIAAAlELKMjRELTMFg35UmAwffp0q1Wrlsvm6NlCeoZPdkpW2uJdT4FP4GIL\n0ezzjtFruOt7wZHmKy1evNg9E0rDFEOVSIGPMk2xLMnevlj1lQApVpLUgwACCCCAAAIIIBAz\nAT33SAsOaC6T5sRogQEtkqAsXaoXPQ9JmTKNmNJqd/5FQwy1il0iS7K3L7s2BEjZFeR8BBBA\nAAEEEEAAgZgLaAicFgrQj4bpKROVLkUPr9UsmGDDADWXKdqFLnLKK9nbl91+EyBlV5DzEUAA\nAQQQQAABBHJUIJ2CI0GGenhujiJnovJkb18muhL0UFaxC8rCRgQQQAABBBBAAAEEEEhHAQKk\ndLzr9BkBBBBAAAEEEEAAAQSCCjDELigLGxFAAAEEEEAAgdwjkJXlt3NP72gpAvEVIIMUX2+u\nhgACCCCAAAIIIIAAAkksQAYpiW9OTjUt3MPksvMXqE1NQj8kV33hQbk5dUepFwEEEEAAAQQQ\nQCBWAgRIsZKkHgQQQAABBBBAIEECZabPiMuVV7doHpfrcBEEEinAELtE6nNtBBBAAAEEEEAA\nAQQQSCoBAqSkuh00BgEEEEAAAQQQQAABBBIpQICUSH2ujQACCCCAAAIIIIAAAkklQICUVLeD\nxiCAAAIIIIAAAggggEAiBQiQEqnPtRFAAAEEEEAAAQQQQCCpBAiQkup20BgEEEAAAQQQQAAB\nBBBIpAABUiL1uTYCCCCAAAIIIIAAAggklQABUlLdDhqDAAIIIIAAAgggEEpg165d9tdff4Xa\nnSPb16xZY/fee69t27Yt5vV//vnn9tBDD0Wsd8uWLRGPifUBe/futfvvv982bNgQtupE3BM1\nKNr2hW18iJ0ESCFg2IwAAggggAACCCCQPAIbN260E0880X766ae4Nmr16tV2zz335EiAtHTp\nUhsyZEjY/vTq1cuGDx8e9pic2HnzzTfbXXfdZZs3bw5ZfaLuiRoUTftCNjzCDgKkCEDsRgAB\nBBBAAAEEEEi8wKZNm+ybb75JfEPi3IJPPvkkrlf8+eef7YILLrBRo0ZFvG4i7klm2hexAyEO\nIEAKAcNmBBBAAAEEEEAAgawLKOsxY8YMu/HGG61Dhw6+4EZZk65du1rTpk2tT58+9ttvv/ku\noi/cd955p9vXrl07GzNmjO3fv9/+/PNPu/32291x/fr1s3fffde91/A3ZRJUV8eOHW3mzJm+\nunbu3Omus2jRIrvooovslltusX379pmGq6mO5s2bu3NmzZrlO0dvNGTsiSeesNatW9s111xj\nv/zyS4b9gR9CtVnHffjhh+66/ue89tprNnjwYP9NNmfOHGvbtq1dcskl9sorr/j2Pfzww7Zq\n1Sp7/fXXbdCgQc5j2LBhvv16o4xat27dXL/U7jfffNMeeeQRF+Tceuut9tVXX2U4Ppy/Drz6\n6qud0xtvvJHhvMAPwe6J7leytC+wvZn5TICUGS2ORQABBBBAAAEEEIhKQMGRvrh/+umnbnja\nYYcdZu+//741aNDAfVYwoOyIhs15QdLll19uH3zwgV122WVWr149F/w8+OCDli9fPqtVq5a7\n7gknnGBlypQxDe+qU6eOvfXWW9aqVSv3pb5ly5a+zMfu3btdQKG6Dj74YFMgs2PHDjv55JPt\n7bffdgGQ6lW25Pnnn/f1qWfPnm7uTcOGDV2wpOAuXAnVZp3z9ddf20svvZThdHlMmzbNt039\nUDCo/h1xxBEuaHv88cfd/mOOOcYOPfRQK1++vB133HEmwzvuuMMFQ14F48ePNwU9RYoUcQFi\n586dbdKkSda+fXtbvny5NW7c2H799Vd3eCR/HaQgRz4VKlTwLhH0Ndg9Sab2BW10lBvzRXkc\nhyGAAAIIIIAAAgggkCmBQoUKuYDnoIMOcucpgDnvvPNswoQJ7rMySQpyBg4c6LI2H3/8scuU\n6Eu+igIETcZXgKMv/AoOFEzUqFHDZWa2bt1qK1eutAIFCpjm6iiQuO2228w7X3VcfPHFrk69\nVxbm999/d0Fb0aJFXYZIdSkLpUDniy++sGeeecYFFgpIVI4//ni76aab3Ptg/4Rqc7Bjg23b\ns2ePjRs3zmW0tP+QQw5xi0Jce+21LnjT/Ke6deu6gE4LVCirNWXKFLvyyitddQrulInzijJg\n8+bNc0GlsmrVqlVzviNGjLC+ffuG9VcdRx55pFdV2Ndg96R69epJ076wjY+wkwApAhC7EUAA\nAQQQQAABBLImoGyNFxxpyJtWbStbtqwLYrwatV9ZFZVOnTqZAgN96T///PNdUKAAJVhZsmSJ\nNWnSxAVH3n4FYEOHDnXD+RQYqNSvX9/bbQsXLnTZJwVKXlF2RUP1NJROmZjSpUu7bI23X0Px\nwgVImWmzV6f/qwKis846y7fp3HPPNQ2t+/HHH61KlSq+7XpTsGBBu/TSS+2FF15wAdL8+fPd\nEDsFj16RibI7XtHww8WLF1s0/t45WX1N9vZF2y+G2EUrxXEIIIAAAggggAACmRIoUaKE73jN\n/dEcIA3Dyps3r+9HAYHmCKlo/orm2xx99NFu5baaNWtmCKZ8lf39RqurKWPkXxTcqCjr5BX/\nNmg4mwIS/+tXrFjRzW/SNg3DUxs178kr/sGGt83/NVKb/evSeRr6519KlizpAh9vW6lSpdxb\nBTTBijJHs2fPdsPmFEgqKDz88MN9h1aqVMn3Xm+0T/OFovHPcGIWPyR7+6Lp1n/hZTRHcwwC\nCCCAAAIIIIAAAlkQ0PwazZMpV66cG/LlVfHOO+9Y/vz5bfv27W7uTIsWLUw/ClTuu+8+e+CB\nB0zDzPLkyeNO8QIOZYg0z8m/6LMCGgVWgYGIjtM5up6e76OASGXFihVuSJrap+F+a9eudZmk\nk046ye0PXMTBbfz3n0ht1jC0wOcnaUigf9EiCwrcihcv7jZrAQpl1SpXrux/mO+95mYde+yx\nNnnyZJs6daobEujb+fcbzTPyL6pP/Yrk739OtO8D74nOS6b2RduPwOPIIAWK8BkBBBBAAAEE\nEEAgRwQ0f0ZZDy1SoCzP3Llz3TC69evXm+YrjRw50mWMvAUV1q1b57JEGrrlZUk0XEzZox49\netj333/vhtRpLpLqGj16tFuwQYFJsNK9e3c3lE4PflVQovlIWoRh+vTpbqie5vpoSN+AAQPc\nccuWLbOnnnoqQ1VahU4LI6hEarPmNylzo+MVsKnfulZgUSCo/RoypzlQXbp08WWVlAHTSnRq\nq1eUpdHiFQpQmjVr5m12rxrGOHbsWLcghV41bFDDAFXC+bsDovhHK/B5S48H3hPv9ES2z2tD\ndl4JkLKjx7kIIIAAAggggAACUQv079/fLbaghRMKFy7svrhrgQStaKcv+1qmWhkdDZ3Tl+/3\n3nvPLUigCyj7pPlACmgUwJx55pkumNB8ImVHNGepdu3a9uKLL4Zsj7Ib2v/kk0+6uVBaBELX\n8laNUyCmAEar6inbdMopp7h6/SvUqnTe8ZHafOqpp9p1113nls5WMKXATItI+BcNJ9TDaIsV\nK2annXaa64PmUXmlTZs2LluktnhFC0ooqNRr4BBAzWdS1k31aTlzPc/o7LPPdqeG8/fqjvSq\n9muIn0rgPXEb//4nke3z2pCd1zx/pyn/G2SZnZrifK7+QqAxrKGWXpz0WIGQLepduUbIfdqx\nutXykPsv/G9OX9Bjxs5aEXS7NhZ7r2rIffHcUWZazZCXC9f3kCf9u2NTk9B91yHJ0v9I/WA/\nAggggAACWRW46qqr3HN8qlaN7//nl5mecahZVtsf6bzVLZpHOiSq/cqWaGGEUEtJa1ialuRW\n4BNYlC3SPCJv8Qd9ldUCC1r6W0P1oi1anEH1awW8YEXZKwVxCpqiKeHarKF4arc3RypYfRs2\nbHB90up6gUUr02m1O/VbRcMANXdK2SIFeV7RfCRtVyZO/dNwRm8YnHeMXiP5+x8bzfvAe5Js\n7YumD/7HMAfJX4P3CCCAAAIIIIAAAjkuoEAmVHCki+uP4PoJVhS0+BcFAAoKMlsCF3gIPD9Y\ncBZ4jP/ncG1WYOMFN/7n+L/3hqv5b/PeK4jTj4br6dlKymA1atQoQ3DkHeu9hutfJH+vjmhf\nvXuSrO2Lth/ecQRIngSvCCCAAAIIIIAAAggksYCG1WnYnrfYRGBTNazOC1YC98Xjc7K3L1oD\nAqRopTgOAQQQQAABBBBAAIEECui5SBquF2rYnxbASGRJ9vZFa8MiDdFKcRwCCCCAAAIIIIAA\nAgkWCBUcJbhZvssne/t8DQ3zhgApDA67EEAAAQQQQAABBBBAIL0ECJDS637TWwQQQAABBBBA\nAAEEEAgjwBykMDjsQgABBBBAAAEEcoNArJbfzg19pY0I5LQAGaScFqZ+BBBAAAEEEEAAAQQQ\nyDUCBEi55lbRUAQQQAABBBBAAAEEEMhpAYbY5bQw9SOAAAIIIIAAAjkscOGgHL7Av9W/ent8\nrsNVEEikABmkROpzbQQQQAABBBBAAAEEEEgqAQKkpLodNAYBBBBAAAEEEEAAAQQSKUCAlEh9\nro0AAggggAACCCCAAAJJJUCAlFS3g8YggAACCCCAAAIIIIBAIgUIkBKpz7URQAABBBBAAAEE\nEEAgqQQIkJLqdtAYBBBAAAEEEEAAAQQQSKQAAVIi9bk2AggggAACCCCAAAIIJJUAAVJS3Q4a\ngwACCCCAAAIIIBBKYNeuXfbXX3+F2p0j29esWWP33nuvbdu2Leb1f/755/bQQw9FrHfLli0R\nj4n1AXv37rX777/fNmzYELbqRNyTlStX2rBhw+zxxx83vY91IUCKtSj1IYAAAggggAACCMRc\nYOPGjXbiiSfaTz/9FPO6w1W4evVqu+eee3IkQFq6dKkNGTIk3OWtV69eNnz48LDH5MTOm2++\n2e666y7bvHlzyOoTcU8uueQSq1Wrli1ZssTGjh1rxx13nL311lsh25iVHUkTIM2dO9c+++yz\nrPSBcxBAAAEEEEAAAQRSXGDTpk32zTffpHgvD+zeJ598cuDGHNzy888/2wUXXGCjRo2KeJV4\n3xMFRa+++qr93//9nz3//PMuSLrwwgutT58+EduamQOSIkBS9Hz33Xe7zmam8RyLAAIIIIAA\nAgggkJwCynrMmDHDbrzxRuvQoYMvuNH3vq5du1rTpk3dF9vffvvN1wF94b7zzjvdvnbt2tmY\nMWNs//799ueff9rtt9/ujuvXr5+9++677r2GvynTobo6duxoM2fO9NW1c+dOd51FixbZRRdd\nZLfccovt27fPNFxNdTRv3tydM2vWLN85eqMhY0888YS1bt3arrnmGvvll18y7A/8EKrNOu7D\nDz901/U/57XXXrPBgwf7b7I5c+ZY27ZtTdmRV155xbfv4YcftlWrVtnrr79ugwaN37JgAAAx\n4ElEQVQNch4aWuZflFHr1q2b65fa/eabb9ojjzzigpxbb73VvvrqK//DLZy/Drz66qud0xtv\nvJHhvMAPwe6J7ldOtk/3e8CAAVahQgVfcxo3bmw//vij+z3xbczmm4QGSHv27HGpMf2HkydP\nnmx2hdMRQAABBBBAAAEEkkVAwZG+uH/66adueNphhx1m77//vjVo0MB9VjCg7IiGzXlB0uWX\nX24ffPCBXXbZZVavXj0X/Dz44IOWL18+N6xKfTvhhBOsTJkypuFdderUccOrWrVq5b7Ut2zZ\n0pf52L17twsoVNfBBx9sCmR27NhhJ598sr399tsuAFK9ypYoG+GVnj17urk3DRs2dMGSgrtw\nJVSbdc7XX39tL730UobT5TFt2jTfNvVDwaCGjR1xxBEuaNPcGpVjjjnGDj30UCtfvrwbSibD\nO+64wwVDXgXjx493QU+RIkVcgNi5c2ebNGmStW/f3pYvX24KIH799Vd3eCR/HaQgRz7+QYh3\nLf/XYPckp9t33nnnuf77t2PixInudyWWsUQ+/wvE+73GCyrKHThwoI0cOTLel+d6CCCAAAII\nIIAAAjkoUKhQIRfwHHTQQe4qCmD0JXfChAnuszJJCnL0XVDZj48//thlSvQlX0UBghYLUICj\nL/wKDhRM1KhRw2Vmtm7d6ibpFyhQwM3VUSBx2223mXe+6rj44otdnXqvLMzvv//ugraiRYu6\nDJHqUhZKgc4XX3xhzzzzjAssNLdF5fjjj7ebbrrJvQ/2T6g2Bzs22DYlDMaNG+cyWtp/yCGH\nuEUhrr32Whe8af5T3bp1XUCnBSqU1ZoyZYpdeeWVrjoFd/5DzJQBmzdvngsqlVWrVq2a8x0x\nYoT17ds3rL8qPPLII129kf4Jdk+qV6+e4+3zb5eyVZqms2DBAv/N2X6f0ADptNNOs/PPP9/d\nwHABktKhCxcuzNBZ/RVAUSoFAQQQQAABBBBAIDkFlK3xgiMNedOqbWXLlnVBjNdi7VdWRaVT\np06mwEBf+vUdUcPcFKAEK5qP0qRJE1Nw5BUFYEOHDnXD+RQYqNSvX9/b7b5PKvukQMkryq5o\n6JaG0mn4WenSpV22xtuvoXjhAqTMtNmr0/9VAdFZZ53l23TuueeahtZp2FiVKlV82/WmYMGC\ndumll9oLL7zgAqT58+e7RSsUPHpFJsrueEXDDxcvXmzR+HvnZPU1nu3TyoIaqjh16lSXFcxq\nm4Od959esL05vK1EiRJRXUE3VL98/uWUU06JmPrzP573CCCAAAIIIIAAAvEV8P+up7k/+qO3\n/sCdN+9/szwUEBQvXtw1TBmBc845x03E1xwmzUfSPBoNswssWl3t2GOPzbBZwY2Ksk5e8W+D\nhrMpIPG/fsWKFd38Jm3TH+DVRs178oZs+QcbXp3+r5HarLr8i4b++ZeSJUu6wMfbVqpUKfdW\n33+DFWWOTj31VDdsToGkgsLDDz/cd2ilSpV87/VG+zRfKBr/DCdm8UNOt0/3R1k0Da3TUMAz\nzzwziy0NfVpCA6TQzcq4R7+Y3bt3z7Bx/fr1tvO5cbbtnRDL+tXJcHimPpSZPiPk8Q2sech9\nybJj0mP//SUlaJsq1wi6OZqNF/73B5cDDh97wJbk21BmWs2wjVrdannY/eF2bmqyIuTuYu9V\nDbmPHQgggAACCKSDgObXaJ5MuXLl3JAvr8/vvPOO5c+f37Zv3+7mzrRo0cL0oy/C9913nz3w\nwAOmYWZewOIFHMoQaZ6Tf9FnfW+sWbOmBQYiOk7n6Hp6vo8XJK1YscINSVP7NNxv7dq1LpN0\n0kknuaoDF3Hwv16kNmsYWuDzkwKf26NFFhS4eUGiFqBQVq1y5cr+l/K919wsBYaTJ0922RMN\nCfQvmmfkX1Sf+hXJ3/+caN8H3hOdl9Pt07BBDavTMELd55wo/4XvOVF7jOrUfzRayMH/56ij\njopR7VSDAAIIIIAAAgggEA8B/eVfWQ8tUqAsj77oahid/vCt+UqacqE5RN6CCuvWrXMLFGjo\nlpcl0XAxZY969Ohh33//vRtSp7lIqmv06NGmBRsUmAQr+oO7htJpeJaCEs1H0iIM06dPd0P1\nNNdHQ/q0UpqOW7ZsmT311FMZqtIqdFoYQSVSmzW/SZkbHa+ATf3WtQKLAkHt15A5BTxdunTx\nZZWUAdNKdGqrV5SlUVZNAUqzZs28ze5Vwxj1fCAtSKFXDRv0RmKF889QSZgPGtbmLT0eeE+8\n03KqfXLU/DWtfq37p1UCvR//rKHXjqy+5ooAKaud4zwEEEAAAQQQQACB5BHo37+/W2xBCycU\nLlzYfXHXAgla0U5f9rVQgzI6WmxBX77fe+89tyCBeqDsk+YDKaBRAKOhVQomNJ9I2RHNWapd\nu7a9+OKLITus7Ib2P/nkk24ulBaB0LW8VeMUiCmA0ap6yjZpSofq9S9alc47PlKbNRTuuuuu\nc0tnK5hSYKYA0L8cffTRpofRFitWzDQ/X33QPCqvtGnTxmWL1BavaEEJBZV6DRwCqPlMyrqp\nPi1nrucZnX322e7UcP5e3ZFe1f7Zs2e7wwLviXduTrVPwy6VQdTqiI0aNcrwo4AwViXP3xfJ\nODAyVjVnsp4rrrjCRcCRllL0qtVfCPJPnWxty/wzTtPb7r2+Wee/NeS9bd5r70hDzPI+5B16\nwGuDL8IPsRs7K/HDrCINsQvX/0hDzMIOsQvTd0EmwzAzhtgd8CvNBgQQQACBGApcddVVbt5M\n1arxHVod7v+fY9g9e/WfRxFlu0plS7QwQqilpDUsTV94FfgEFmWLNI/IW/xBX2WV7dHiCxp1\nFG3R4gyq33+RB/9zlb1SEKegKZoSrs0aiqd2e3OkgtW3YcMG1yetrhdYtDKdVrtTv1U0DFBz\np5QtUpDnFc1H0nZl4tQ/DWf0hsF5x+g1kr//sdG8D7wnyda+aPrgf0yumIPk32DeI4AAAggg\ngAACCORuAQUyoYIj9UwLOYRarVhBi39RAKCgILNFmaNwJVhwFu74cG1WYOMFN6Hq8IarBduv\nIE4/Gq6nZyspg6UMin9wFHheuP5F8g+sK9Jn754ka/sitT9wf9IESM8991xg2/iMAAIIIIAA\nAggggAAC/wpoWJ2G7XmLTQTCaFidF6wE7ovH52RvX7QGSRMgRdtgjkMAAQQQQAABBBBAIB0F\n9FwkDdcLNexPC2AksiR7+6K1YZGGaKU4DgEEEEAAAQQQQACBBAuECo4S3Czf5ZO9fb6GhnlD\ngBQGh10IIIAAAggggAACCCCQXgIESOl1v+ktAggggAACCCCAAAIIhBFgDlIYHHYhgAACCCCA\nAAK5QSBWy2/nhr7SRgRyWoAMUk4LUz8CCCCAAAIIIIAAAgjkGgEySLnmVtFQBBBAAAEEEEAg\nuMCmJqEfVB/8jKxtTYaHvmet5ZyFQPQCZJCit+JIBBBAAAEEEEAAAQQQSHEBAqQUv8F0DwEE\nEEAAAQQQQAABBKIXIECK3oojEUAAAQQQQAABBBBAIMUFCJBS/AbTPQQQQAABBBBAAAEEEIhe\ngAApeiuORAABBBBAAAEEEEAAgRQXIEBK8RtM9xBAAAEEEEAAAQQQQCB6AQKk6K04EgEEEEAA\nAQQQQAABBFJcgAApxW8w3UMAAQQQQAABBFJFYNeuXfbXX3/FtTtr1qyxe++917Zt2xbz637+\n+ef20EMPRax3y5YtEY+J5QErV660YcOG2eOPP256H64k4p6oPXv37rX777/fNmzYEK55WdpH\ngJQlNk5CAAEEEEAAAQQQiKfAxo0b7cQTT7Sffvopnpe11atX2z333JMjAdLSpUttyJAhYfvT\nq1cvGz58eNhjYrnzkksusVq1atmSJUts7Nixdtxxx9lbb70V9BKJuidqzM0332x33XWXbd68\nOWjbsrMxX3ZO5lwEEMhdAmWm1QzZ4NWtlofcF2lHpCe48+T1SILsRwABBBCIJLBp0yb75ptv\nIh2Wcvs/+eQTa926dVz6paDo1VdftVWrVlmFChXcNS+77DLr06ePnX/++Qe0IRH35Oeff7Ye\nPXrY+++/f0B7YrWBDFKsJKkHAQQQQAABBBBAwCegrMeMGTPsxhtvtA4dOviCG2VNunbtak2b\nNnVfvH/77TffOfrCfeedd7p97dq1szFjxtj+/fvtzz//tNtvv90d169fP3v33Xfdew1/UyZB\ndXXs2NFmzpzpq2vnzp3uOosWLbKLLrrIbrnlFtu3b59puJrqaN68uTtn1qxZvnP0RkPGnnji\nCReUXHPNNfbLL79k2B/4IVSbddyHH37orut/zmuvvWaDBw/232Rz5syxtm3bmrI3r7zyim/f\nww8/7IKV119/3QYNGuQ8NPTNvyij1q1bN9cvtfvNN9+0Rx55xC644AK79dZb7auvvvI/3ML5\ny3PAgAG+4EgnNm7c2H788Ud3H/wrCnZPdL9ysn26/tVXX+3u4xtvvOHfnJi+J0CKKSeVIYAA\nAggggAACCEhAwZG+uH/66adueNphhx3m/urfoEED91nBgLIjGjbnBUmXX365ffDBB6asRb16\n9Vzw8+CDD1q+fPncsC/Ve8IJJ1iZMmVMw7vq1Knjhn+1atXKfWlu2bKljRo1SofZ7t27XUCh\nug4++GBTILNjxw47+eST7e2333YBkOpVIPH888+7c/RPz5493dyWhg0bumBJwV24EqrNOufr\nr7+2l156KcPp8pg2bZpvm/qhYFDD2o444ggXtGnuj8oxxxxjhx56qJUvX94NdZPhHXfc4YIh\nr4Lx48e7oKdIkSIuQOzcubNNmjTJ2rdvb8uXL3cBzq+//uoOV9YlnP95553n6vfq1uvEiRPd\nvciTJ4//5qD3JKfbpwYoCNP98zJcGRoVow8MsYsRJNUggAACCCCAAAIIZBQoVKiQC3gOOugg\nt0MBjL6ET5gwwX1WJklBzsCBA13W5uOPP3aZEn3JV1GAoMn4CnD0hV/BgYKJGjVquMzM1q1b\n3SICBQoUMM3VUSBx2223mXe+6rj44otdnXqvLMzvv//ugraiRYuaMkSqS1koBTpffPGFPfPM\nMy6w0NwbleOPP95uuukm9z7YP6HaHOzYYNv27Nlj48aNcxkt7T/kkEPcohDXXnutC940/6lu\n3bouoNMCFWrzlClT7Morr3TVKbjTEDivKAM2b948F8Aoq1atWjXnO2LECOvbt29Yf68O71XZ\noLlz59qCBQu8Tb7XYPekevXqOd6+I4880teGnHpDgJRTstSLAAIIIIAAAgikuYCyNV5wpCFv\nWrWtbNmyLojxaLRfWRWVTp06mQIDfenXnBfNvVGAEqxovkyTJk1MwZFXFIANHTrUDedTYKBS\nv359b7ctXLjQZZ8UKHlF2RUNLdNQOg0/K126tMvWePs1FC9cgJSZNnt1+r8qIDrrrLN8m849\n91zT0DoNa6tSpYpvu94ULFjQLr30UnvhhRdcgDR//ny3aIWCR6/IRJkxr2j44eLFiy0af+8c\nvWrlPg0FnDp1qsu6+e8L9T6e7QvVhlhsZ4hdLBSpAwEEEEAAAQQQQOAAgRIlSvi2ae6P5gBp\nGFbevHl9PwoINEdIRRkLzbc5+uij3cptNWvWzBBM+Sr7+41WL1PGyL8ouFFR1skr/m3QcDYF\nJP7Xr1ixopvfpG0ahqc2at6TV/yDDW+b/2ukNvvXpfM09M+/lCxZ0gU+3rZSpUq5twpoghVl\njmbPnm0K7BRIKig8/PDDfYdWqlTJ915vtE/zhaLx1/Hqf/fu3d08Jg1lU/2ZKTndvsy0JavH\n/hdeZrUGzkMAAQQQQAABBBBAIIKA5tdonky5cuXckC/v8Hfeecfy589v27dvd3NnWrRoYfrR\nF/X77rvPHnjgAdMwM28OjBdwKEOkeU7+RZ8V0CiwCgxEdJzO0fX0/BwFRCorVqxwQ9LUPg33\nW7t2rcsknXTSSW5/4CIObuO//0Rqs4ahBT4/KfC5QlpkQYFb8eLFXa1agEJZtcqVK/tfyvde\nc7OOPfZYmzx5ssvuaEigfwlc3U31qV+R/L06NCxPw+o0TE+O4UrgPdGxOd2+cO2J1T4ySLGS\npB4EEEAAAQQQQACBsAKaP6OshxYpUJZHX8Q1jG79+vWm+UojR450GSNvQYV169a5LJGGbnlZ\nEg0XU/ZISz1///33bkid5iKprtGjR5sWbFBgEqwoM6KhdBo+pqBE85G0CMP06dPdUD3N9dGQ\nPq3kpuOWLVtmTz31VIaqtAqdFkZQidRmzW9S5kbHK2BTv3WtwKJAUPs1ZE4BT5cuXXxZJWXA\ntBKd2uoVZWm0eIUClGbNmnmb3auGMer5RVqQQq8aNqhhgCrh/LVf7dT8sLvvvtv5aBU+78fL\nymnYnRbXUAm8J27j3//kVPu8+nP6lQxSTgtTf9wFJj3231jkAy5eucYBm6LdcOF/w5WDnjI2\n6FY2IoAAAggggIAn0L9/f5dR0cIJyvRoSJwWSNCKdipaplpLU2vonBYvUBZFCxKoKPuk+UAK\naLR0uObpKJjQwgN6YKjqU7AVmFFxJ//7j7IbL774olvUQF/0FUhpzo63apwCMQUwWgjCm8Ok\n+UcKMryiVel++OEHF3QoQAnX5lNPPdWuu+46tzS1lqfWSnVaRMJ/OXINJ9TDaIsVK+aCGllo\nHpVX2rRpY71793YBoJ4BpKIFJVSPFmcIHAKo+UzKuimA1PA9rep39tlnu/Mi+WtpdmXotPpg\nYFEQquGRuq6CM83tCnZPdF5OtS+wTTn1Oc/fCP8Nssypq+RAvfoLQf6pk61tmX/GaQZe4s06\n/60hH7ivd6QvyXkfCjzF97nBF81974O9GTtrRbDNblu8HpYZNkD4uyXh+h/pYaHhgoRwfRdA\nMvQ/XN/VxnD9D9d3nRuu//Hqu9oRrvCg2HA67EMAAQSyL3DVVVe55/hUrVo1+5VlooZID+zO\nRFVhD43V/58pW6KFEUIt1axhacqAaFhYYNEXdc0j8hZ/0FdZZXu09LeG6kVbNIdH9fsv8uB/\nrrJXhQsX9mVy/PcFex+uzRqKp3Z7c6SCnb9hwwbXJ62uF1i0Mp0CRvVbRcMANXdK2SKt9OcV\nzRfSdmXi1D8NZ/SGwXnH6DWSv/+x0bwPvCfJ1r5o+uB/DBkkfw3eI4AAAggggAACCOS4gAKZ\nUMGRLq5MhX6CFQUt/kUBgIKCzJbABR4Czw8WnAUe4/85XJsV2HjBjf85/u+94Wr+27z3CuL0\no+F6eraSMl6NGjXKEBx5x3qv4foXyd+rI9pX754ka/ui7Yd3HAGSJ8ErAggggAACCCCAAAJJ\nLKC5Whq25y02EdhUDdPzgpXAffH4nOzti9aAAClaKY5DAAEEEEAAAQQQQCCBAnoukobraa5U\nsKIFMBJZkr190dqwil20UhyHAAIIIIAAAggggECCBUIFRwlulu/yyd4+X0PDvCGDFAaHXQgg\nkDoC4RaoUC/DLdARSSHc5OhYTWiO1Ab2I4AAAggggEBsBMggxcaRWhBAAAEEEEAAAQQQQCAF\nBAiQUuAm0gUEEEAAAQQQQAABBBCIjQBD7GLjSC0IIIAAAggggEDCBBjOmzB6LpyCAmSQUvCm\n0iUEEEAAAQQQQAABBBDImgABUtbcOAsBBBBAAAEEEEAAAQRSUIAAKQVvKl1CAAEEEEAAAQQQ\nQACBrAkQIGXNjbMQQAABBBBAAAEEEEAgBQUIkFLwptIlBBBAAAEEEEAAAQQQyJoAq9hlzS3h\nZ23r1CF0G+qE3hVpT5npM8Ie0sCah93PzsQLTHqsQOhGVK4Rel+EPRcOCn3A2NC72JMkAuEe\nlJtTD8lV11lZK0l+AWgGAggggEDUAmSQoqbiQAQQQAABBBBAAAEEEEh1AQKkVL/D9A8BBBBA\nAAEEEEAAAQSiFiBAipqKAxFAAAEEEEAAAQQQQCDVBQiQUv0O0z8EEEAAAQQQQAABBBCIWoAA\nKWoqDkQAAQQQQAABBBBAAIFUF2AVu1S/w/QPAQQQSHOBcCv4iSanVvFjBb80/8Wj+wggkGsF\nyCDl2ltHwxFAAAEEEEAAAQQQQCDWAgRIsRalPgQQQAABBBBAAAEEEMi1Agyxy7W3joYjgECg\nQCIekqs28KDcwDvBZwQQQAABBHKvABmk3HvvaDkCCCCAAAIIIIAAAgjEWIAMUoxBqQ4BBBBA\nAIFkEgi3SEVOLVCh/rNIRTL9FtAWBBDIjAAZpMxocSwCCCCAAAIIIIAAAgiktAABUkrfXjqH\nAAIIIIAAAggggAACmREgQMqMFscigAACCCCAAAIIIIBASgswBymlb2/qdm5bpw6hO1cn9K5I\ne8pMnxHykAbWPOQ+diCQDAKJWMWPFfyS4c7ThnAC8Z6DtWft9nDNYR8CCOQCATJIueAm0UQE\nEEAAAQQQQAABBBCIjwABUnycuQoCCCCAAAIIIIAAAgjkAgECpFxwk2giAggggAACCCCAAAII\nxEeAOUjxceYqCCCAAAI5KJCI+VfqDnOwcvCmUjUCCCCQIAEySAmC57IIIIAAAggggAACCCCQ\nfAIESMl3T2gRAggggAACCCCAAAIIJEiAAClB8FwWAQQQQAABBBBAAAEEkk+AOUjJd09oEQJh\nBcI+A0pnZvE5UOGeAaVqeQ6UFCgIJKdAIuZgMf8qOX8XaBUCCGRfgAxS9g2pAQEEEEAAAQQQ\nQAABBFJEgAxSitxIuoEAAggggEA6CoTNngmkco0ssVw4KPxpZNDC+7AXgdwsQAYpN9892o4A\nAggggAACCCCAAAIxFSCDFFNOKkMAgZwWCDsHK4vzr9TmcHOwmH+V03eV+hFAAAEEEEgeATJI\nyXMvaAkCCCCAAAIIIIAAAggkWIAAKcE3gMsjgAACCCCAAAIIIIBA8ggwxC557gUtQQABBMIK\nhB1eqDOzOMQw3PBCVcsQQylQEEAAAQTSRYAMUrrcafqJAAIIIIAAAggggAACEQXIIEUk4gAE\nEEAAgWQQCJtBy2L2TP0Kl0Eje5YMd542IIAAAvEVIIMUX2+uhgACCCCAAAIIIIAAAkksQAYp\niW8OTUMAAQQQQEACYbNnOiCLGbRw2TNVSwZNChQEEEg3AQKkdLvj9BcBBBBAAIFcJhA2QMxi\ncCiCcAEiwWEu+yWhuQjEUIAhdjHEpCoEEEAAAQQQQAABBBDI3QIESLn7/tF6BBBAAAEEEEAA\nAQQQiKEAAVIMMakKAQQQQAABBBBAAAEEcrcAAVLuvn+0HgEEEEAAAQQQQAABBGIokPBFGrZu\n3Wrz5s0zvdavX9+OPPLIGHaPqhBAAAEEEEAAAQQQQACB6AUSmkFauXKltW7d2iZPnmzLly+3\nq666yhYsWBB96zkSAQQQQAABBBBAAAEEEIihQEIzSIMGDbJWrVpZ7969LU+ePDZ+/HgbNmyY\nTZw40X2OYT+pCgEEEEAAAQQQQAABBBCIKJCwDNIff/xhX331lcsgKThSadGihf3222/2f//3\nfxEbzgEIIIAAAggggAACCCCAQKwFEpZBWr16tetLuXLlfH0qUaKEFShQwNauXWvHH3+8b/uu\nXbtswIABvs96s3PnTvtx/Qb7dvv2DNu9Dz9tLuG9PeC10OI9B2zLuGFixo9+n37b+JHfpwPf\nDtyw9cCN/24p0K9wyH2Z3bHnh1UhTwnXd50Uvv+h+65zw/U/XN91bjL0P3zf1crQ/Q/Xd50Z\nrv/x6rvaEe7+h+9/6L6r3nD9D9d3nRuv/me972pl6P6H67vODNf/ePVd7ch6/0P3XfWG63+4\nvuvcePU/631XK0P3P1zfdWa4/ser72pH1vsfuu+qN1z/w/Vd58ar/+H6rnZk9X/3wvVd9Ybq\n/8o9P2k3BQEEcrFAnv1/l0S0/7333rMHH3zQ9Opf2rRpY1dccYX973//823esWOH1a5d2/dZ\nby699FJr3Lhxhm3Z/bBlyxYbN26cHX300dasWbPsVpfrzp81a5Z9+eWX1qFDB1Owmk5l+9+B\n9pgxY6xKlSouk5lOfVdf586da0uXLrV27dpZ6dKl06r7u3fvtlGjRlnFihXtwgsvTKu+q7Pz\n58+3RYsWuf/NrVChQtr1f/jw4VamTBlr27Zt2vVd9133v2XLlla5cuW06//IkSOtWLFidtll\nl8W876eccooVKlQo5vVSIQIIxEcgYRmk/Pnz2549B2Zy9u7da4ccckiG3hcsWNCmTZuWYZu+\nwJcsWTLDtux++Pnnn91iEZUqVbIzzzwzu9XluvPfffdd1/8TTjjBqlevnuvan50Ga8hnnz59\nXHCQjvf+o48+cve+f//+duKJJ2aHMtedq+C4Z8+eVrhw4bT8737x4sXu3t9888126qmn5rr7\nl90Gd+vWzQ466KC0vPca5q4Fknr16pWW/df8Z/1hJB3/Nz+7/91wPgKpLpCwAEnBjYIhfTnx\nD4iUxSlbtmwGd81RUlaHggACCCCAAAIIIIAAAgjkpEDCFmnQUI58+fK5IV1eB/XXrH379pn/\nvCRvH68IIIAAAggggAACCCCAQE4LJCxAKlq0qDVt2tTGjh1r27Zts7/++svNAWnevLkdccQR\nOd3voPVr2N9RRx2VsOsHbVQcN2rYovqvhTLSrWiIjfpeqlSpdOu66+/hhx+etvc+b968ru/p\nNvfK+0UvXry463+6zpfQf/eBoxY8m1R/1f8Pq//+ozhSvc/+/dOD6fmDrL8I7xFAwBNI2CIN\nasDGjRvt3nvvtc8//9wOPvhgq1Wrlt15551WpEgRr328IoAAAggggAACCCCAAAJxE0hogOT1\nUvOO9Bf8Qw891NvEKwIIIIAAAggggAACCCAQd4GkCJDi3msuiAACCCCAAAIIIIAAAggEEUjY\nHKQgbWETAggggAACCCCAAAIIIJBQgYQt853QXoe5uJYef+GFF9wDI9NpLpSWW//444/tt99+\ns5o1a1qdOnXCKKXerhUrVtiCBQusfPnyVr9+/bR8wN/69evd88Y6derkhrym3l0+sEfff/+9\n/fDDDxl2aMGKunXrZtiWqh82bdrk/rvXMOczzjjD/f6nal/9+7Vs2TL7/fff/Tf53p9++ulp\nMdxbz4j/4osvTKvH6t6n02IFWi33ww8/tFWrVtlxxx3nHkSvRZooCCCAgCfAEDtP4t/Xxx9/\n3F5++WWbNGlS2vwfxowZM2zo0KGmB8RqNSMFSi1atLC+ffsG6KTmx3vuucf0sMyGDRuavjjJ\n4JFHHjGt8JQuRV+WdL8XLlxos2bNSpuVDO+77z7TQ3L1kFiv6L8DPTA31Yv+KKB7rhXctILf\nnDlzrGPHjnbllVemetdt+PDhNnfu3Az93Lp1q3su3+TJk51Hhp0p9kEPxtbDkfWMQf2+67+B\nk046yfTfg1Z1TOWiP4Lq9/6zzz5zgeG3337r/jd/1KhRpofSUxBAAAEJkEH69/dgzZo19tBD\nD9mSJUvS6jdDf0kbP3689ejRwy655BLXd31x0GqCbdq0sWrVqqW0h/6COnv2bJswYYL7orhr\n1y6XPXz77betffv2Kd13/87pS+H//d//+W9Ki/f6ctS1a1e7+OKL06K//p3UF8Jjjz3WBg4c\n6DYrg6rAUBb+AaP/Oany/vrrrzf9eEUZ9M6dO1vLli1TPjhSn6dOneqCwSlTppgyJ/rv4Oqr\nr3Z/KKpXr57HkpKv06dPt08//dSeffZZq169untgfZ8+fdwfxe64446U7DOdQgCBzAuk9p+K\nMuHx4IMPmv6KPnjw4EyclfsP3bBhg+n/EM8991xfZ/SXRBUNt0v1UrJkSXfPveeg6OHFGlop\nl3QpK1eudEHyNddcky5ddv3cuXOn/fTTT3b00UenVb/VWf23/cknn7g/jHid19BSPZcuHf+K\nPnLkSDestlu3bh5HSr/qD0F6/pU3rKxMmTJuWO2OHTtSut/qnB4rcswxx7jgSJ+1gq7+/++D\nDz6wPXv2aBMFAQQQIIPk/Q7cdttt7i+HP/74o7cpLV4VINx4440Z+qohVvo/jXT44qjAyAuO\nNB/lrbfess2bN1uzZs0ymKTqh927d7tnkemLoeZfpVNRYKgMqjInjz76qHtgdePGjd0QMz2X\nLZXLzz//7P4b1xArDa/V/+5pLoayKN6X5lTuv3/fNNTq9ddft2eeeSZthpbqf980tPqJJ55w\n8+1ee+0198DYdJl7pz+E+Rc9qF4/+sNYuj4s3N+D9wggYEYG6d/fAo3Bp5hpXsLo0aOtQ4cO\naTHUxLvn69atc2PyX3nlFTvzzDOtYsWK3q6Ufn366afdF4JWrVqldD+Dde67775zm5VJ0nyM\nc845x31Rfvjhh4MdnlLbtCCHMkU333yzm4dy8skn2zvvvGMaaqSgMZ2K5ptqUZoaNWqkTber\nVKlirVu3dnNt77rrLps/f751797dzcVJdYTatWvb8uXL3Rwk9VV/EJs5c6brtoZaUhBAAAEJ\nZPwzCiZpLaAFCpRJO/vss9149HTCOOKII9z/SSqLpInK/fr1syFDhqQ0gebbaa6V5qClY2na\ntKn767mXQdSXZGVOx40bZ7169XJDLVPVRUOJ/vzzT7vqqqusbdu2rpvKHlx77bVu6F2DBg1S\ntesZ+qVAUcHBgAEDMmxP9Q9ahEbzcJ566ik31GzevHlu3qmCJf3vfyqXCy64wC1KoTloVatW\ntV9++cX0ByLNwypUqFAqd52+IYBAJgTIIGUCK5UP1SpGN9xwg/urov6qnOorGYW6l1qUQl8Y\ntZqbvkCmclGmUCv2ad7drbfeasomqSg41BK4qV40jM4Ljry+nnrqqe7t6tWrvU0p+ao/CKgo\nW+oVLe+v+Xf6wpgu5c0337QSJUrYaaedli5ddhlCLUzzv//9zy3SoeFm+j3QKp7KIqZ60R9B\n9L95Glar/63XH0S0zLn+P69YsWKp3n36hwACUQqQQYoSKpUP0+RUZU169+7tAqRU7mtg3zS8\nRnNQhg0b5tulwEjDjDQ/I5WL/pK6ceNGXxc1cf/LL790E5j1LKBUL1q5b9GiRRkWZtEEbt33\nwMAp1SwqVarkuqRA0BterGGmeh6St+//2zvP0Ci6Lo4fFWNJNPYaS+waGypqUENEwaCIDQsx\ndmzYEP1g+/CiooIFY8dujBpFjEZFhBg7BBXsYqzYNRY0xK7Mc/8HZpndN8/jRrIRZ/8Xdmfu\nnTN35v4mWfbsaW5bc17rQaIK1D3yjUnJS9ZNY4i3CQ0N9VoSFAc8f7e3rKwsLedgZ23FepHZ\nDokb3B576PZny/WRQEESoAWpIGn+hXOhHgYy+MXGxuoXI3xBtF/BkMkN60aQ9uHDhzWDEdaO\n1LcYh3XFzQ1uJSgKa7/gcoaWkJAgUVFRbl66rg2/mOMLMgL04XKGWljYj4uLc32aaxQFxd94\nYmKi4DMAcRhIUoAA9WB49vYfNwqFRkZG2t2g2MJSgmeflJSk1kL87aO0A15ud6/DA8aPP0hx\nj3p/aPj8T0tL80r7rgf4RgIkENQEWCjW5/EjmxO+IAZLodjk5GRNyuCDQbuIR4KVwe0tNTVV\nkOYXViOkv0XKV2T2CwsLc/vSvdYHBQFB+sFUKBZJORCHgWePApLI7oVnHwy/JKMw6uLFi/WL\nIqwHyGKIWJxgsSDBeoofCZDJrVWrVl7/C27v5ObmCpKRpKena7IO/P0jMQ+KBLvdco5ni8/8\nlJQUtaAjk2t8fLwWR3f7c+f6SIAE/CdABcl/VpR0MQH8igp3I8QjMFDXxQ86j6Xh2WdnZwu+\nKIWEhOQh4e4hZO6Cy1UwuFW6+0nmf3XO1NbB5mYIWrCe4jOfjQRIgAR8CVBB8iXCPgmQAAmQ\nAAmQAAmQAAmQQNASKBq0K+fCSYAESIAESIAESIAESIAESMCHABUkHyDskgAJkAAJkAAJkAAJ\nkAAJBC8BKkjB++y5chIgARIgARIgARIgARIgAR8CVJB8gLBLAiRAAiRAAiRAAiRAAiQQvARY\nKDZ4nz1XTgJ/hMD79++1/hCyZkVHR7u+3tQfgcyLkgAJkAAJkAAJ/DYBKki/jY4nkgAJ5JfA\n0aNHtfYM6q6gPXnyhApSfiFSngRIgARIgARIIKAEmOY7oHg5OQmQgJNAhw4d5MaNG4ICrbVr\n15bmzZs7D3OfBEiABEiABEiABP44ASpIf/wR8AZIIHgIRERESKNGjSQjIyN4Fs2VkgAJkAAJ\nkAAJ/FUEiv3PtL/qjnmzJEACfx2BW7duyZo1a+TkyZN672/evJFv377Jjx8/ZPXq1WpJWrFi\nhSQlJUnJkiWlQYMGKnf9+nU9b926dZKZmSnFixeXyMjI/1v/qVOnZP369bJz505BjFPjxo1l\n4cKFUq5cOalevbrKr127Vq5evSpt27b1Oh/XPHHihMZD2QdwX1u2bJENGzbI3r175eHDhxIV\nFaX3ZsvcvXtXVq1aJS1atJCzZ8/qOjDX48ePpXXr1nqvtiy2WAvuDxyeP3+u9xUeHi45OTmy\naNEi+fDhgzRp0sR5irx48UKWLVsmYWFhUrNmTa9j7JAACZAACZAACQSIgMVGAiRAAgEmcPr0\naSs2NtYKCQmxKlasqPtGobEOHjxomY82a+DAgbotWrSoNX78eL0bo5yoPM7p3bu31aZNG5WZ\nOXOm190uX75cxzt16mSNGjXKMgqR1bdvXx3bunWrR9a481nGxc/Tt3e6d+9uGXc/u2tlZ2db\n7dq10/ONtUvnMoqWVadOHevmzZseORNPpTKjR4/WrVGKLKOY6T7u9efPnx5ZrLNYsWJWvXr1\ndK3VqlVTOeNqqDJGybJq1aplmdgszznYMYqTVaRIEev+/fte4+yQAAmQAAmQAAkEjoAEbmrO\nTAIkQALeBKpWrarKjj1qK0iVKlVS5ePdu3fWy5cvLWOdUeWoa9eu1uvXr21xa+7cuapYpKen\n69iZM2csKFVTpkzxyLx69coyFiiV+x0FyVZ4Dhw44Jnz0aNHqnh16dLFM2YrSFiTsQ55xseN\nG6fXPn78uI6ZmCurVKlSVp8+fayvX7/qmLFQqbJmrGHWly9fLGM903OMhc0zD3aMRcmKiYnx\nGmOHBEiABEiABEggsARYBylAljlOSwIk4D+BsWPHSrNmzaR8+fJiFA6BSx1c8GbNmiVGefJM\nNGPGDHVdg7sc2pEjR8QoSOL0FK5SpYrMmTPHc05+duCet23bNnW369evn+dUJJSIj49XV7pr\n1655xrEzceJEr2QTxhqmx41SpVujKMnnz59l6dKlYqxhOmasSeq+Z6xh6mI3dOhQXVdycrIe\nx9vFixfl9u3bMnLkSM8Yd0iABEiABEiABAJPgGm+A8+YVyABEvgFASRucLasrCwxrmWyceNG\n2bx5s/OQpgW/c+eOjl2+fFlq1KghFSpU8JJp3769V9/fDuKKzG9SqrQMGjTI67SnT59qH9du\n2bKl55gdL2UPQEFDg1KEduXKFQkNDZWGDRtq335DnBJeduvVq5fs379fY5QQh4V4JpxnK1y2\nHLckQAIkQAIkQAKBJUALUmD5cnYSIAE/CJi4JC8pJHEoUaKEoJgsLETOV1xcnHTs2FHl3759\nq0qE18mmA0uUv83ECnlEcV004xLndU1cH1akwYMHS5kyZTzy2CldurRXH4odGhQttGfPnmmS\nBe38x5uJn9JEDbCKff/+XVJSUmTAgAF+nfsf0/IQCZAACZAACZBAPgnQgpRPYBQnARIIPAGT\nzEAuXLgg8+fP17TgzisiwxwUJzRYb1B8FsqIrZhgHFnifBvc2qB4+DZknbMbrosGi9auXbvs\nYd1CkcIc+W3Iuocse7g2svDZzcRayaFDh6Rbt266jp49ewqsT/v27VMlDMraiBEjbHFuSYAE\nSIAESIAECokALUiFBJqXIQES8J+AyUinwnAzczbE/yDl9bRp03QYysXHjx/VNc0pt2fPHmdX\n95HyG3FBnz598hx78OCBjtkDUJBMhjlJTU1VNzt7HFvECdlzOMd/tR8dHS0mO50Wx3XKJiYm\nyoQJE8R23YPSl5CQIMeOHVMlyWTNE5OkwnkK90mABEiABEiABAqBABWkQoDMS5AACeSPgEn1\nLU2bNpWVK1cKFAmTXlt2794tQ4YMUQVp3rx5OuGYMWM0HshkjtOYHcgtWbJE6xP5XrFHjx4C\nl7xhw4Zp3aPt27cLxpzueLDwIJkC4odMqnAx6ck1WQKSQ6Ae0tSpUwWKS34arECooTR58mTB\nNaHk4R6RiKJz585iMuN5poObXW5uruzYsUOGDx/uZRXzCHGHBEiABEiABEggoAToYhdQvJyc\nBEjgdwhAUYFyMmnSJEGmN7jVoSHRAaxDlStX1j5c3jIyMgSKBV6w1KCg6oIFC2T27NkqY7/B\n6oQECyjWalJ4qxsbFC0UY0XfbrDiINvc9OnTJTY2Vodh3THpv8VWzGxZf7Y4F4VoofRBocM9\novXv31+L2zrd9kytJjE1mOTSpUt0r/MHLmVIgARIgARIIAAEiiCLeADm5ZQkQAIkUCAEkO77\n3r17Eh4erhnrnLFGzgvk5OSIKfKq8Tznz59X64ypg6SKk1MOLnaIO4Ky5VROnDL2PuKEYHWq\nW7dunskgbDl/t7BMwa0vIiJC15PXeXDJg4IGBZGNBEiABEiABEig8AnQglT4zHlFEiCBfBCA\nsoAaSb9qZcuWFbx+1ZB1zhRg/ZWYHkc8El4F1ZAdD+52/9bOnTsnmZmZ4qyH9G+yHCcBEiAB\nEiABEggMAcYgBYYrZyUBEiABvwls2rRJYmJiNCYKLnZIJ85GAiRAAiRAAiTwZwhQQfoz3HlV\nEiCBABJAjBKyztWvXz+AVym4qVFjCa5/KAqblpbmSWNecFfgTCRAAiRAAiRAAv4SYAySv6Qo\nRwIkQAIkQAIkQAIkQAIk4HoCtCC5/hFzgSRAAiRAAiRAAiRAAiRAAv4SoILkLynKkQAJkAAJ\nkAAJkAAJkAAJuJ4AFSTXP2IukARIgARIgARIgARIgARIwF8CVJD8JUU5EiABEiABEiABEiAB\nEiAB1xOgguT6R8wFkgAJkAAJkAAJkAAJkAAJ+EuACpK/pChHAiRAAiRAAiRAAiRAAiTgegJU\nkFz/iLlAEiABEiABEiABEiABEiABfwn8AybbtQl0q989AAAAAElFTkSuQmCC"" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"" } ], ""execution_count"": 16 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""For a complete reference of the available methods and properties, see {class}`~fastdfe.spectrum.Spectra` and {class}`~fastdfe.spectrum.Spectrum`."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""## Folded spectra\n"", ""{class}`Spectrum` and {class}`Spectra` objects can also be folded by collapsing the bins corresponding to the derived allele counts onto the bins corresponding to the ancestral allele counts. Basing the DFE inference on folded spectra, we have less information to work with, which is particularly noticeable when including beneficial mutations. However, folded spectra are easier to obtain, and are robust to misspecification of the ancestral state, which is often unknown. DFE inference is based on folded spectra whenever spectrum.is_folded is ``True``."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:46:12.872606Z"", ""start_time"": ""2025-11-30T10:46:12.768548Z"" } }, ""source"": [ ""# fold spectra object\n"", ""folded <- fd$Spectra$fold(sfs)\n"", ""\n"", ""p <- folded$plot()"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl\nR2VuZXJpY1JHQgAAOI2NVV1oHFUUPpu5syskzoPUpqaSDv41lLRsUtGE2uj+ZbNt3CyTbLRB\nkMns3Z1pJjPj/KRpKT4UQRDBqOCT4P9bwSchaqvtiy2itFCiBIMo+ND6R6HSFwnruTOzu5O4\na73L3PnmnO9+595z7t4LkLgsW5beJQIsGq4t5dPis8fmxMQ6dMF90A190C0rjpUqlSYBG+PC\nv9rt7yDG3tf2t/f/Z+uuUEcBiN2F2Kw4yiLiZQD+FcWyXYAEQfvICddi+AnEO2ycIOISw7UA\nVxieD/Cyz5mRMohfRSwoqoz+xNuIB+cj9loEB3Pw2448NaitKSLLRck2q5pOI9O9g/t/tkXd\na8Tbg0+PszB9FN8DuPaXKnKW4YcQn1Xk3HSIry5ps8UQ/2W5aQnxIwBdu7yFcgrxPsRjVXu8\nHOh0qao30cArp9SZZxDfg3h1wTzKxu5E/LUxX5wKdX5SnAzmDx4A4OIqLbB69yMesE1pKojL\njVdoNsfyiPi45hZmAn3uLWdpOtfQOaVmikEs7ovj8hFWpz7EV6mel0L9Xy23FMYlPYZenAx0\nyDB1/PX6dledmQjikjkXCxqMJS9WtfFCyH9XtSekEF+2dH+P4tzITduTygGfv58a5VCTH5Pt\nXD7EFZiNyUDBhHnsFTBgE0SQIA9pfFtgo6cKGuhooeilaKH41eDs38Ip+f4At1Rq/sjr6NEw\nQqb/I/DQqsLvaFUjvAx+eWirddAJZnAj1DFJL0mSg/gcIpPkMBkhoyCSJ8lTZIxk0TpKDjXH\nliJzZPO50dR5ASNSnzeLvIvod0HG/mdkmOC0z8VKnzcQ2M/Yz2vKldduXjp9bleLu0ZWn7vW\nc+l0JGcaai10yNrUnXLP/8Jf59ewX+c3Wgz+B34Df+vbVrc16zTMVgp9um9bxEfzPU5kPqUt\nVWxhs6OiWTVW+gIfywB9uXi7CGcGW/zk98k/kmvJ95IfJn/j3uQ+4c5zn3Kfcd+AyF3gLnJf\ncl9xH3OfR2rUee80a+6vo7EK5mmXUdyfQlrYLTwoZIU9wsPCZEtP6BWGhAlhL3p2N6sTjRdd\nuwbHsG9kq32sgBepc+xurLPW4T9URpYGJ3ym4+8zA05u44QjST8ZIoVtu3qE7fWmdn5LPdqv\ngcZz8Ww8BWJ8X3w0PhQ/wnCDGd+LvlHs8dRy6bLLDuKMaZ20tZrqisPJ5ONiCq8yKhYM5cCg\nKOu66Lsc0aYOtZdo5QCwezI4wm9J/v0X23mlZXOfBjj8Jzv3WrY5D+CsA9D7aMs2gGfjve8A\nrD6mePZSeCfEYt8CONWDw8FXTxrPqx/r9Vt4biXeANh8vV7/+/16ffMD1N8AuKD/A/8leAvF\nY9bLAAAAOGVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAACoAIABAAAAAEAAANIoAMA\nBAAAAAEAAAFoAAAAAFPiRRYAAEAASURBVHgB7d0JvFVT/8fxX3WbFE1Kg5T+SIoMGXo0oSiR\nEmnQU0TI8OBBMqUMIRmTIoRQKlEKSchUmUkiTaJJJUSz+7/f5e7z7Hs693buufcM9+zPer1u\nZ589rvXepzq/u9b67WKZWcUoCCCAAAIIIIAAAggggAACVhwDBBBAAAEEEEAAAQQQQACBfwQI\nkPgkIIAAAggggAACCCCAAALZAgRIfBQQQAABBBBAAAEEEEAAgWwBAiQ+CggggAACCCCAAAII\nIIBAtgABEh8FBBBAAAEEEEAAAQQQQCBbgACJjwICCCCAAAIIIIAAAgggkC1AgMRHAQEEEEAA\nAQQQQAABBBDIFiBA4qOAAAIIIIAAAggggAACCGQLZBRViRdeeMFGjx5dVKtPvRFAAAEEEEAg\nYAItWrSwgQMHBqzVNBeBoidQZAOk33//3Xr37m1du3YteurUGAEEEEAAAQQCJfD111/bU089\nFag201gEiqpAkQ2QBF68eHErWbJkUbWn3ggggAACCCAQEIGMjCL9lSsgd4lmIvCPAHOQ+CQg\ngAACCCCAAAIIIIAAAtkCBEh8FBBAAAEEEEAAAQQQQACBbAECJD4KCCCAAAIIIIAAAggggEC2\nAAESHwUEEEAAAQQQQAABBBBAIFuAAImPAgIIIIAAAggggAACCCCQLUCAxEcBAQQQQAABBBBA\nAAEEEMgWIEDio4AAAggggAACCCCAAAIIZAsQIPFRQAABBBBAAAEEEEAAAQSyBQiQ+CgggAAC\nCCCAAAIIIIAAAtkCBEh8FBBAAAEEEEAAAQQQQACBbAECJD4KCCCAAAIIIIAAAggggEC2AAES\nHwUEEEAAAQQQQAABBBBAIFuAAImPAgIIIIAAAggggAACCCCQLUCAxEcBAQQQQAABBBBAAAEE\nEMgWIEDio4AAAggggAACCCCAAAIIZAsQIPFRQAABBBBAAAEEEEAAAQSyBQiQ+CgggAACCCCA\nAAIIIIAAAtkCBEh8FBBAAAEEEEAAAQQQQACBbAECJD4KCCCAAAIIIIAAAggggEC2AAESHwUE\nEEAAAQQQQAABBBBAIFuAAImPAgIIIIAAAggggAACCCCQLUCAxEcBAQQQQAABBBBAAAEEEMgW\nIEDio4AAAggggAACCCCAAAIIZAsQIPFRQAABBBBAAAEEEEAAAQSyBTKQyL9ApyH5P8Y7YvIA\nb4lXBBBAAAEEEEAAAQQQSDUBepBS7Y5QHwQQQAABBBBAAAEEEEiaAAFS0ui5MAIIIIAAAggg\ngAACCKSaAAFSqt0R6oMAAggggAACCCCAAAJJEyBASho9F0YAAQQQQAABBBBAAIFUEyBASrU7\nQn0QQAABBBBAAAEEEEAgaQIESEmj58IIIIAAAggggAACCCCQagIESKl2R6gPAggggAACCCCA\nAAIIJE2AAClp9FwYAQQQQAABBBBAAAEEUk2AACnV7gj1QQABBBBAAAEEEEAAgaQJECAljZ4L\nI4AAAggggAACCCCAQKoJECCl2h2hPggggAACCCCAAAIIIJA0AQKkpNFzYQQQQAABBBBAAAEE\nEEg1AQKkVLsj1AcBBBBAAAEEEEAAAQSSJkCAlDR6LowAAggggAACCCCAAAKpJkCAlGp3hPog\ngAACCCCAAAIIIIBA0gQIkJJGz4URQAABBBBAAAEEEEAg1QQIkFLtjlAfBBBAAAEEEEAAAQQQ\nSJoAAVLS6LkwAggggAACCCCAAAIIpJoAAVKq3RHqgwACCCCAAAIIIIAAAkkTIEBKGj0XRgAB\nBBBAAAEEEEAAgVQTIEBKtTtCfRBAAAEEEEAAAQQQQCBpAhlJu3L2hTdu3GizZ8+2zMxMO+aY\nY6xGjRrJrhLXRwABBBBAAAEEEEAAgYAKJLUHadasWXbWWWfZnDlz7J133rHevXvbJ598EtBb\nQbMRQAABBBBAAAEEEEAg2QJJ60Havn27jRw50i644ALr2rWrcxgyZIg9/vjj1qRJk2S7cH0E\nEEAAAQQQQAABBBAIoEDSepB27txpl112mXXo0CHEXqlSJduwYUPoPQsIIIAAAggggAACCCCA\nQCIFktaDVKZMGWvRooVr6/r1623evHk2efJk69Onzy7tVzA1derUHOvXrl1r5cuXz7GONwgg\ngAACCCCAAAIIIIBAQQSSFiD5Kz148GD76quvrGbNmta8eXP/Jre8bds269+/f471SuhQr169\nHOt4gwACCCCAAAIIIIAAAggURCAlAqQHH3zQlM1O84969uxpkyZNsgoVKoTaVbJkSRs4cGDo\nvRa+//77HO95gwACCCCAAAIIIIAAAggUVCAlAiQ1omLFita3b1+bPn26ffTRR9a2bdtQ2zIy\nMqx79+6h91oYNWpUjve8QQABBBBAAAEEEEAAAQQKKpC0JA3Lli2zzp0728qVK0Nt2LJli2m+\nkZ6JREEAAQQQQAABBBBAAAEEEi2QtACpbt26ts8++7hU37/99putWbPGRowY4YbWHXfccYl2\n4HoIIIAAAggggAACCCCAgCUtQJL9VVddZYsXL7aOHTtaly5dbOnSpTZ06FBTum8KAggggAAC\nCCCAAAIIIJBogaTOQTrwwAPtueeeM6Xs1jyjypUrJ7r9XA8BBBBAAAEEEEAAAQQQCAkkNUDy\nalGtWjVvkVcEEEAAAQQQQAABBBBAIGkCSR1il7RWc2EEEEAAAQQQQAABBBBAIIIAAVIEFFYh\ngAACCCCAAAIIIIBAMAUIkIJ532k1AggggAACCCCAAAIIRBAgQIqAwioEEEAAAQQQQAABBBAI\npgABUjDvO61GAAEEEEAAAQQQQACBCAIESBFQWIUAAggggAACCCCAAALBFCBACuZ9p9UIIIAA\nAggggAACCCAQQYAAKQIKqxBAAAEEEEAAAQQQQCCYAgRIwbzvtBoBBBBAAAEEEEAAAQQiCBAg\nRUBhFQIIIIAAAggggAACCARTgAApmPedViOAAAIIIIAAAggggEAEAQKkCCisQgABBBBAAAEE\nEEAAgWAKECAF877TagQQQAABBBBAAAEEEIggQIAUAYVVCCCAAAIIIIAAAgggEEwBAqRg3nda\njQACCCCAAAIIIIAAAhEECJAioLAKAQQQQAABBBBAAAEEgilAgBTM+06rEUAAAQQQQAABBBBA\nIIIAAVIEFFYhgAACCCCAAAIIIIBAMAUIkIJ532k1AggggAACCCCAAAIIRBAgQIqAwioEEEAA\nAQQQQAABBBAIpgABUjDvO61GAAEEEEAAAQQQQACBCAIESBFQWIUAAggggAACCCCAAALBFCBA\nCuZ9p9UIIIAAAggggAACCCAQQYAAKQIKqxBAAAEEEEAAAQQQQCCYAgRIwbzvtBoBBBBAAAEE\nEEAAAQQiCBAgRUBhFQIIIIAAAggggAACCARTgAApmPedViOAAAIIIIAAAggggEAEAQKkCCis\nQgABBBBAAAEEEEAAgWAKECAF877TagQQQAABBBBAAAEEEIggQIAUAYVVCCCAAAIIIIAAAggg\nEEwBAqRg3ndajQACCCCAAAIIIIAAAhEECJAioLAKAQQQQAABBBBAAAEEgilAgBTM+06rEUAA\nAQQQQAABBBBAIIIAAVIEFFYhgAACCCCAAAIIIIBAMAUIkIJ532k1AggggAACCCCAAAIIRBAg\nQIqAwioEEEAAAQQQQAABBBAIpgABUjDvO61GAAEEEEAAAQQQQACBCAIZEdaxCgEEEEAAAQQQ\nQCBNBH755RebNm2azZw502rUqGE9evSwDRs22AcffGA333yza+Wjjz5q1apVs9q1a9sjjzxi\nDRo0sD59+ljVqlVt8+bNNnr0aPvkk09s586d1rhxY7vwwgutYsWKIaEFCxbY+PHjrWfPnnbA\nAQeE1q9YscId27FjRzviiCNs0aJFNnbsWOvXr5/NmjXLZsyYYZUqVbL27dtbq1atrESJEqFj\nWUAgWQL0ICVLnusigAACCCCAAAJxFlBw1KRJE7v88stt06ZN9tFHH9m//vUvGzBggN1xxx2h\nqz/22GM2fPhwO+2001wAc+ONN9q2bdts5cqVdsghh9g111xjq1atst9++80GDRpkjRo1sk8/\n/TR0/LfffmuDBw+2H374IbROCz/++KNb/8UXX7j1CpC033nnnefqpJXz58+31q1b27XXXuv2\n4Q8Eki1AD1Ky7wDXRwABBBBAAAEE4iTQtWtX++OPP1wwc9BBB7mrKBi66KKLrHTp0jmu+s47\n79jVV19tt99+uwtsatWqZe3atbM1a9bYe++9Z8ccc4zb//vvv7cWLVpY79697fPPP7eMjPx/\nnVRv1Mcff2z777+/O+eQIUPshhtusObNm1unTp1y1Is3CCRagB6kRItzPQQQQAABBBBAIAEC\n69atc8PY1HvkBUe6bN++fe3www/fpQbFixd3vUply5a1+vXr208//WSvv/66G07nBUc6SOfq\n37+/6/l59913dzlPNCuuvPLKUHCk/f/73//a3nvvbZMmTYrmcPZBIK4CBEhx5eXkCCCAAAII\nIIBAcgQ+++wzd+FIwdCRRx65S6U0/6hMmTKh9Ro2p+IPjryNxx57rFtcuHChtypfr97x3kGl\nSpWygw8+2PVIeet4RSBZAgRIyZLnuggggAACCCCAQBwFNP9IRcFHeFEvUXipUqVKjlXr1693\n7/faa68c6/WmfPnybt327dt32eZfoaQOkYo/wYO3fY899nBznLz3vCKQLAECpGTJc10EEEAA\nAQQQQCCOAl42uSVLluxylUjrwnf6v//7P7dq2bJl4ZvMW+f1TnnZ58IDJiVpiFQ0fC+8LF++\n3CL1bIXvx3sE4i1AgBRvYc6PAAIIIIAAAggkQUDBRt26dW3UqFHmD1w0LO7NN9/cbY2U6lsp\nuMeMGWOZmZk59n/yySfdey9A8nqEvGF53s5K5R2pjBs3LsfqefPm2XfffRdxOF+OHXmDQAIE\n8p92JAGV4hIIIIAAAggggAACBRMoWbKkDR061JTJrlmzZi7r3MaNG+3+++83bQsPesKvpmF0\nymh36aWX2plnnmnXXXedG66nLHivvPKK3XnnnaFnIWmekoIkpQ5XUKXep5deesleffXV8NO6\n93pm0n777WfnnnuuLV682KX8VkCnLHoUBJItQA9Ssu8A10cAAQQQQAABBOIkcNZZZ7mHxCr5\ngp599Pzzz9ttt91mbdu2tXLlyu32qnqgq3qL9FBZPT9Jz1RSOvD77rvPnc87geYPTZw40TRf\nSVnyTjrpJJs7d657OK23j/9VKb21/2GHHWbdunWzQw891KZOnWo6DwWBZAvQg5TsO8D1EUAA\nAQQQQACBOAgoQcKKFSusTZs2dsopp+S4ggIlpdX2ip5nlFvRQ131o3NprlHNmjUj7qqgSPto\nfpJ6n7zzR+qpOuqoo1zv1NKlS61atWpRBWsRL8pKBOIgQA9SHFA5JQIIIIAAAgggkGwBPdeo\nUaNG7mGv/rq8//777sGveihrforSgOcWHPnPo3lPXnDkXx9pWQ+KjaYnK9KxrEMgXgL0IMVL\nlvMigAACCCCAAAJJFChWrJhdfPHFNmzYMDv66KOtZcuWtmjRInv77bfd0La77747ibXj0gik\nrgA9SKl7b6gZAggggAACCCBQIIF77rnHBUStW7c29RwpOcPAgQPd3KDKlSsX6NyxHFyrVi3r\n0aOHqTeKgkCqCtCDlKp3hnohgAACCCCAAAIFFNAwu1atWrmfAp6qUA5v3LixjR07tlDOxUkQ\niJcAPUjxkuW8CCCAAAIIIIAAAgggUOQECJCK3C2jwggggAACCCCAAAIIIBAvAQKkeMlyXgQQ\nQAABBBBAAAEEEChyAgRIRe6WUWEEEEAAAQQQQAABBBCIl0BgkzRUn9IoZtOmNj/mYzkQAQQQ\nQAABBBBAAAEEUleAHqTUvTfUDAEEEEAAAQQQQAABBBIsQICUYHAuhwACCCCAAAIIIIAAAqkr\nENghdql7S6gZAggggAACCCBQOAKbevUonBNFcZbyTz8XxV7sgkDqC9CDlPr3iBoigAACCCCA\nAAIIIIBAggQIkBIEzWUQQAABBBBAAAEEEEAg9QUIkFL/HlFDBBBAAAEEEEAAAQQQSJAAAVKC\noLkMAggggAACCCCAAAIIpL4AAVLq3yNqiAACCCCAAAIIIIAAAgkSIEBKEDSXQQABBBBAAAEE\nEEAAgdQXIEBK/XtEDRFAAAEEEEAAAQQQQCBBAgRICYLmMggggAACCCCAAAKxCezcudMGDRpk\nS5cujeoE48aNs1dffTWqfXe309atW921V6xYsbtd8739yy+/tHvvvXe3x/3++++73aewd5D5\n7bffbhs2bMjz1Nu2bbMtW7bkuU88NkZbv1iuTYAUixrHIIAAAggggAACCCRMwPsyHG2A9OKL\nL9r06dMLpX768n/rrbdaPAKkL774wu65554863nZZZfZQw89lOc+8dh47bXX2s0332y//fZb\nrqf/9ddf7bDDDrMff/wx133itSGa+sV67YxYDyys4/766y/78MMPbeXKldaoUSM78sgjC+vU\nnAcBBBBAAAEEEEAgDQRKlSpl27dvj7olL730UtT7pvqOc+fOtTPOOCNh1VQgePHFF9usWbN2\ne82NGzfad999t9v9CnOH/NQv1usmtQfp9ddft9NPP911gS5cuNCuvvrqqLoZY20sxyGAAAII\nIIAAAggkX0A9QiNHjrROnTpZhw4d7L777gsFQBrSduGFF9rHH39snTt3tuuuu840jEvr9H1R\nRfuMGDHCOnbsaH369LFvv/3Wbf/555/d9kceecTGjh3rlufMmWN33HGHffLJJ27fU0891YYN\nG2aqg1eWLFliV155pbVt29bOPPNMGzp0qLumtz2vVwUJN954o5188sl2zjnn2OjRoy0zM9Md\n8t5777n6+49/+eWX7e677/avsnfffde6dOliZ599tk2YMCG0TfVctmyZvfLKKzZkyBB37vvv\nvz+0XQvqvenbt69pGN7w4cNt2rRpzrN9+/bWv39/Z+M/QL1WslR91WZ1UviLPP/++2+bOnWq\nf/Uuy3/++acNGDDArb/pppvszTffTKn67VLhfKxIWoAk+KefftpFqA888IDdeeedNnjwYPcB\n+OGHH/LRBHZFAAEEEEAAAQQQKEoC559/vl1//fV24IEHWpMmTeyuu+6ydu3aucBCPUUKMrp3\n726lS5c2BSAqWucFQP369XPfG4877jhT71KrVq3cdg35UpkxY4a9//77bnnRokWm75o9e/a0\n2rVrm4654YYbXNCkHTRsT8PENNdG+6hOt912m+lLfzTl3HPPtbffftvV9+ijjzYN/VJ7VBTQ\nPf/88zlOo0BtypQpoXWqswKrxo0bW9WqVV0dHn74Ybf94IMPtnLlylmtWrXskEMOsfLly7u6\n++ck6fu0gp699trL3njjDevdu7eNHz/eunbtavPnz7cTTjgh5KZeoaZNm9qmTZtcMKbeKbXd\nHyTJ+bXXXrN99903VMdICxkZGa7O2nbooYda9erVU6p+keoc7bqkDbHTh1AfojZt2oTqesQR\nR7hl3aQDDjggtJ4FBBBAAAEEEEAAgfQQUM/QM888434prt4jFQVHxxxzjFvXunVrt+6ss85y\nvSZ6ox4kr3z22Wf25JNPuqBEgZGKvpxrnpDXc+NW+v5Yt26dGzKmL/IqCrTU43HLLbe4IWIK\nUB5//HErXry49ejRw3755RdTz1M0RVNF1LujwERFQY2/d8qtzOOPHTt22JgxY1zvlXbbY489\nXFIIBYHqBVK7FERqmJ3mQ11yySU2adIkO++889xZn332WdcT5F1CVh988IEpgFHAp+/U6ohQ\nr9o111zjrF944QW3u3qSNL1F29X7pLLffvu51939oeBVQZiCTfkddNBBLrhMlfrtrv55bc/I\na2M8t+29995uSJ3/Gm+99ZaVKFHC6tev71/t/lLoBvtLlSpV7Pjjj/evYhkBBBBAAAEEEEAg\nxQU+//xz1zN00kknhWqqAEBBjoInL0A69thjQ9v9C+qBqVChgjVr1iy02gskQivCFsqWLet6\nObzVCgLmzZvn3mpYnQIt9a5oqN6CBQts5syZrj7e/nm99urVyxTMKFDR8D0FMg0bNszrkBzb\nFBDp+l5R54GG1i1fvtzq1avnrXavZcqUsW7durnhgwqQPvroIzfEToGKV+Sn4MgrGkr36aef\numGJyppXo0YN13vnbdd3b5kWRkn1+kXbxv/pRXtEnPZbvHixjRo1ykXt++yzT46rKApX16G/\n6LcMFAQQQAABBBBAAIGiJaAhcxUrVnRDx7yaFytWzKpVq5aj50W/DI9UNApJ3xX9QYDOl1dR\nEOIv6inyepu++uorO+WUU9xQvebNm7tfwGsIWrTJBzQnSMHe5MmTXbY5zUfS3B9vmJ13He/6\n4ckm1GmgwMIrclDRPKtIRYGRhgmqF0xBmebzV65cObRr3bp1Q8ta0DbNF9KwPE1x0TA9td8r\nCsgqVarkvS3wa6rXL5oGpkSApA+mxqGeeOKJbvJceMUV9Yd/SBVMURBAAAEEEEAAAQSKloCG\nfK1Zs8b98vvwww93lV+1apXp+6CGa+2uqHdGvSsKlLzAQHNvYi0awqZhceo1Um+KiuYvRTNM\nTtmYNd/ntNNOcz8KQDR/SUkhdF4NQ1Ow5S/hqcqVZEHzkLwgRUP/VI/999/ff1hoWVNUGjRo\nYBMnTjRl63viiSdC27QQnn1O59MwOs1v0jylmjVruiF13kGar1WyZEnvbb5eFdiq+IPAVKpf\nvhrj2/l/4aNvZSIX9QG86qqrXHekJrX5I9pE1oNrIYAAAggggAACCMRfQPON6tSp4+b/KIHC\nTz/95Hpc1HPSokWL3VZAw9g09EzZ5pT9TfNplAUv1qKhfQq2Nm/e7L7oK2Ocgo/cenCUhU6J\nEVT0S3xl09Mv+tUzpnNo/pKSKqhXSPNy1HOj/dVzpOQMkR5gq6BK2zVkTgHPBRdcEOpVUk+a\nhv4piPSKemnUQ6UARb1f/qJhdE899ZSri141CkvDAFU0P0i9TqqHAsDZs2e77+CaoxVtUQY+\nJXdQ8QJUDeHzPy8pmfWLth157ZfUAEkZPzQ57oorrrCLLroor3qyDQEEEEAAAQQQQCANBBRU\nKIW0hoip50Y9Spr3o7nomh+zu6LeFfX27Lnnni7Nt4ILPUxVRefOb9FjZjSnScP2NNxNGeSU\n5lvTP/zZ4rzzKiudl2VOAYqSG2hfBUUKGFQ3JVFQ0VC4yy+/3I2QUt0GDRqUY/6P9tHc+9Wr\nV7thh5pfr141Xd8rSmWugM0/vUSZ8xTU6NU/1FDHaD6TerA07FCZ+B599FE3SkvbBg4c6BIr\nKAGG/BQ4qYNC6cWjLQoG33nnHbe7eqQ0h0uJLZSN2ivJrJ9Xh4K8FsvqEvsnUXtBzhLDsevX\nr3fpEPVBCH/4lVIwehFpbqfWEDuNodQNiaVUn9IolsPcMU2/mR/zsZMHxHwoByKAAAIIIIBA\nERXQ8DFlSfO+WCeqGZt6xfY9KZb6lX/6uXwfpp4bBRne8LJoTqAeGqWvViDgDfHS84Zatmzp\nhqop2Iml6LupUoYrcIilaCidepA0lC28aCjeH3/84YKw8G3ee1ko+ItUf2WmU7Y7by7V2rVr\nXcpy9RYpyPSK5iPpe7R6tRSAajidZ+Tto1f1VmmY4+5SefuPyWtZbVPdvCGKqVa/vOoeaVvS\n5iApv7o+LBoXqR9/UWSqbCQUBBBAAAEEEEAAgfQV2N0vxCO1XF/ulVhAqbWVplpzePQwWQ01\nixRcRDpHpHW5JYWItG+kdfrFvX4iFQUPXnATabvW5WWhwE0/6tHSs5UUaGs4oj84Cj+verRy\nK5pzVFjBka7hBZWpWr/cHHJbn7QASV1v+qEggAACCCCAAAIIIBCtgHpFNMxNo4luvvlml3hA\nqa0fe+yxaE9RZPfTsDoN29OwRCVXCC8aVucFK+HbEvE+1esXrUHSAqRoK8h+CCCAAAIIIIAA\nAgj4Bbp06WL6USIFZYoLSlFyCo3A8qcF97ddCRiSWVK9ftHaJDVJQ7SVZD8EEEAAAQQQQAAB\nBMIFghQceW3PLTjytif7NdXrF40PAVI0SuyDAAIIIIAAAggggAACgRBgiF0gbnPhNrLTkNjP\nRxa/2O04EgEEEEAAAQQQQCD+AgRI8TfmCggggAACCCCAQFIEYkm9nZSKclEEUkiAIXYpdDOo\nCgIIIIAAAggggAACCCRXgB6k5PpzdQQQQAABBBBAIG4C1ac0itu5w0+8usP88FW8R6BICtCD\nVCRvG5VGAAEEEEAAAQQQQACBeAgQIMVDlXMigAACCCCAAAIIIIBAkRQgQCqSt41KI4AAAggg\ngAACCCCAQDwECJDioco5EUAAAQQQQAABBBBAoEgKECAVydtGpRFAAAEEEEAAAQQQQCAeAgRI\n8VDlnAgggAACCCCAAAIIIFAkBQiQiuRto9IIIIAAAggggAACCCAQDwECpHiock4EEEAAAQQQ\nQACBQhPYuXOnDRo0yJYuXRrVOceNG2evvvpqVPvubqetW7e6a69YsWJ3u+Z7+5dffmn33nvv\nbo/7/fffd7tPYe8g89tvv902bNiQ56m3bdtmW7ZsyXOfwt6oz8H9999vDz/8cNSfifzUgQAp\nP1rsiwACCCCAAAIIIJBwAe/LerQB0osvvmjTp08vlHrqy/+tt95q8QiQvvjiC7vnnnvyrOdl\nl11mDz30UJ77xGPjtddeazfffLP99ttvuZ7+119/tcMOO8x+/PHHXPcp7A1nn322NW7c2D77\n7DN76qmn7JBDDim0e+3VNcNb4BUBBBBAAAEEEEAAgVQUKFWqlG3fvj3qqr300ktR75vqO86d\nO9fOOOOMhFVTgeDFF19ss2bN2u01N27caN99991u9yusHRQUTZ482ZYtW2b77ruvO2337t3t\nyiuvtFNPPbWwLmP0IBUaJSdCAAEEEEAAAQQQiEZAPUIjR460Tp06WYcOHey+++4LBUAa0nbh\nhRfaxx9/bJ07d7brrrvONIxL6xYuXOhOr31GjBhhHTt2tD59+ti3337rtv/8889u+yOPPGJj\nx451y3PmzLE77rjDPvnkE7evvkgPGzbMVAevLFmyxH3Jbtu2rZ155pk2dOhQd01ve16vChJu\nvPFGO/nkk+2cc86x0aNHW2Zmpjvkvffec/X3H//yyy/b3Xff7V9l7777rnXp0sXUOzJhwoTQ\nNtVTwcArr7xiQ4YMcefW0DJ/Ue9N3759TcPwhg8fbtOmTXOe7du3t/79+zsb//7qtZKl6qvA\nYuXKlf7Nzujvv/+2qVOn5lgf/ubPP/+0AQMGuNU33XSTvfnmm3Gv35o1a2zw4MGh4EgXP+GE\nE2z58uUh8/B6xvKeACkWNY5BAAEEEEAAAQQQiFng/PPPt+uvv94OPPBAa9Kkid11113Wrl07\n9yVXPUUKMtQzULp0aVMAoqJ1XgDUr18/90X5uOOOM/UutWrVym3XkC+VGTNm2Pvvv++WFy1a\nZA888ID17NnTateubTrmhhtucEGTdtCwPQ0T01wb7aM63XbbbaYv/dGUc889195++21X36OP\nPto0NE3tUVFA9/zzz+c4jQK1KVOmhNapzgqsNGysatWqrg6aW6Ny8MEHW7ly5axWrVpuKFn5\n8uVd3f1zkp5++mlT0LPXXnvZG2+8Yb1797bx48db165dbf78+S6A8NzUK9S0aVPbtGmTC8bU\nO6W2+4MkOb/22ms5gpBQZX0LGRkZrs5adeihh1r16tUt3vXTZ0T3zl8030zuxYoV868u0DJD\n7ArEx8EIIIAAAggggAAC+RFQz9AzzzzjekXUe6SiL77HHHOMW9e6dWu37qyzznK9JnqjHiSv\naJjVk08+6YISBUYq+nKueUJez41b6ftj3bp1bsiYvsirKGBQj8ctt9zihogpQHn88cetePHi\n1qNHD/vll19MPU/RlA8//NDVU4GJioIaf++UW5nHHzt27LAxY8aYeq9U9thjD5cUQkGgeoHU\nLgWRGman+VCXXHKJTZo0yc477zy3/7PPPut6gtybrD9k9cEHH5gCGAV8BxxwgN15552mXrVr\nrrnGWb/wwgtud/UkHXnkkW67ep9U9ttvP/e6uz8UvCoIU8Aiv4MOOsgFl/Gun79e6k2bPXt2\n1PfKf2xeywRIeemwDQEEEEAAAQQQQKBQBT7//HPXM3TSSSeFzqsAQEGOgicvQDr22GND2/0L\n6oGpUKGCNWvWLLTaCyRCK8IWypYt63o5vNUKAubNm+feKjBRoKXeFQ3VW7Bggc2cOdPVx9s/\nr9devXqZghkFKhq+p0CmYcOGeR2SY5sCIl3fK23atHFDADVsrF69et5q91qmTBnr1q2bGz6o\nAOmjjz5yCRIUqHhFfgqOvKKhdJ9++qlpWKKy5tWoUcP13nnbS5Qo4YYfeu8L8prI+imroYYq\nar7ZUUcdVZBq73Ls//R22cQKBBBAAAEEEEAAAQQKV0BD5ipWrOiGjnln1vCoatWq5eh5qVKl\nirc5x6uGwu2zzz45ggCdL6+iIMRf1FPk9TZ99dVXdsopp7ihes2bN7fjjz/eDUGLNvmAejEU\n7Cl5gLLNaT6S5v54w+y863jXD082sffee5sCC6/IQUUBTaSiwEjDBNULpqDs9NNPt8qVK4d2\nrVu3bmhZC9qm+UIalqe5RRoGp/Z7RQFZpUqVvLcFfo13/dQG9VJpaJ2GArZs2bLAdQ4/AQFS\nuAjvEUAAAQQQQAABBOImoCFfmmyveTOHH364u86qVatMgUr4/JJIlVDvjHpXFCh5gYHm3sRa\nNIRNw+LUa6TeFBXNX4pmmNxff/3l5vucdtppph99edf8JSWF0Hk1DE3zffwlPFW5kixoHpIX\npGjon+qx//77+w8LLWu+TYMGDWzixImu9+SJJ54IbdNCePY5nU/D6DS/SfOUatas6YbUeQdp\nvlbJkiW9t/l69eb9+IPAeNdPwwY1rE7DCBs1apSv+ka78//Cx2iPYD8EEEAAAQQQQAABBGIU\n0HyjOnXquPk/SqDw008/uR4X9Zy0aNFit2fVMDYNPVO2OWV/03waZcGLtWhon4KtzZs3u14l\nZYxT8JFbD46y0CkxgoqG7imbnhJOqGdM59D8JSVVUK+Q5uWo50b7q+dIyRkiPcBWQZW2a8ic\nAp4LLrgg1KuknjQN/VMQ6RX10qiHSgGKer/8RcPo9Hwg1UWvCkQ1DFBFPS/qdVI9FAAq0NCQ\nQM3RirZoWJuSO6h4AaqG8PmflxSv+slR91tzxxRUKkug9xNNQBttGwmQopViPwQQQAABBBBA\nAIECCyioUAppDRFTz416lDTv56233nLzY3Z3AfWuqLdnzz33dGm+FVzoYaoqOnd+y9VXX+3m\nNGnYnoa7KYOc0nwvXrzYBTfh51NWOi/LnAIUJTfQvgqKFDCobkqioKKhcJdffrlLna26ad6M\ngil/qV+/vq1evdoNO9TwPvWq6fpeUSpzBWxKYuEVZc5TUKNX/3wjbdd8JvVgadihMvE9+uij\nduKJJ7pDBw4c6BIrKAGG/BQ4Keue0otHW1T/d955x+2uHinN4VJiC6Xf9kq86qchjOqtUlpz\nBdP+HwWEhVWKZV3kn0TthXXGBJ1n1KhRbgylbkgspfqU2Lvkmn4zP5ZLumMm/5MuPubjU+HA\nTkNir0U6tD/21nMkAggggEBQBTR8TFnSvC/WiXIoyPed/NZxdYf8fz9Sz42CDG94WTTXVA+N\n0lcrEPCGeKkXQXNR1KugBA6xlPXr17t5SAocYikaSqcv6RrKFl40FO+PP/5wc6fCt3nvZaHg\nL1L9lZlO2e68uVRr1651KcvVW6Qg0yuaj6RU5urVUgCq4XSekbePXtVbpWGO3sNW/dtiWVbb\nVDdviGKq1S+/bWIOUn7F2B8BBBBAAAEEEECgUAS8IVr5OZm+3CuxgB6cqjTVmsOjh8lqqFmk\n4CLac+eWFCLa45X8QD+RioIHL7iJtF3r8rLQs570o+F6eraSAm31nviDo/Dzqkcrt6I5R4UV\nHOkaXlCZqvXLzSG39cVz28B6BBBAAAEEEEAAAQRSTUC9Ihrm9vrrr7tU3EprrYQGEyZMSLWq\nFnp9NKxOw/Y0B0g9kuFFw+q8YCV8WyLep3r9ojWgBylaKfZDAAEEEEAAAQQQSAmBLl26mH6U\nSEGZ4oJSlJxCw/X8acH9bVcChmSWVK9ftDb0IEUrxX4IIIAAAggggAACKSUQpODIg88tOPK2\nJ/s11esXjQ8BUjRK7IMAAggggAACCCCAAAKBECBACsRtppEIIIAAAggggAACCCAQjQABUjRK\n7IMAAggggAACCCCAAAKBECBJQyBuM41EAAEEEEAAgSAKxPJsoiA60WYE/AL0IPk1WEYAAQQQ\nQAABBBBAAIFAC9CDFOjbT+MRQAABBBBAIJ0FOg1JXOsmD0jctbgSAvEUoAcpnrqcGwEEEEAA\nAQQQQAABBIqUAAFSkbpdVBYBBBBAAAEEEEAAAQTiKUCAFE9dzo0AAggggAACCCCAAAJFSoAA\nqUjdLiqLAAIIIIAAAggggAAC8RQgSUM8dTl3WgoUZMIrE1jT8iNBoxBAAAEEEEAgjQToQUqj\nm0lTEEAAAQQQQAABBBBAoGACBEgF8+NoBBBAAAEEEEAAAQQQSCMBAqQ0upk0BQEEEEAAAQQQ\nSEeBnTt32qBBg2zp0qVRNW/cuHH26quvRrXv7nbaunWru/aKFSt2t2u+t3/55Zd277337va4\n33//fbf7FOYOcr7//vvt4Ycf3q35tm3bbMuWLYV5+ajOpc/E7bffbhs2bIhq//zsRICUHy32\nRQABBBBAAAEEEEi4gPdlONoA6cUXX7Tp06cXSj315f/WW2+1eARIX3zxhd1zzz151vOyyy6z\nhx56KM99CnPj2WefbY0bN7bPPvvMnnrqKTvkkENytfz111/tsMMOsx9//LEwqxDVua699lq7\n+eab7bfffotq//zsRJKG/GixLwIIIIAAAggggEDCBUqVKmXbt2+P+rovvfRS1Pum+o5z5861\nM844IyHVVFA0efJkW7Zsme27777umt27d7crr7zSTj311F3qsHHjRvvuu+92WR/PFQpUL774\nYps1a1bcLkMPUtxoOTECCCCAAAIIIIBAJAH1CI0cOdI6depkHTp0sPvuuy8UAGlI24UXXmgf\nf/yxde7c2a677jrTMC6tW7hwoTud9hkxYoR17NjR+vTpY99++63b/vPPP7vtjzzyiI0dO9Yt\nz5kzx+644w775JNP3L76oj9s2DBTHbyyZMkSFwS0bdvWzjzzTBs6dKi7prc9r1cFCTfeeKOd\nfPLJds4559jo0aMtMzPTHfLee++5+vuPf/nll+3uu+/2r7J3333XunTpYuq9mTBhQmib6qlg\n5ZVXXrEhQ4a4c2vom7+o96Zv376mYXjDhw+3adOmOc/27dtb//79nY1/f/VayVL1VeCzcuXK\n0OY1a9bY4MGDQ8GRNpxwwgm2fPnyUJu8nf/8808bMGCAe3vTTTfZm2++Gff66WK633///bdN\nnTrVq0qhvxIgFTopJ0QAAQQQQAABBBDIS+D888+366+/3g488EBr0qSJ3XXXXdauXTv3JVw9\nRQoy1HNRunRpUwCionVeANSvXz/3Rf64444z9S61atXKbdeQL5UZM2bY+++/75YXLVpkDzzw\ngPXs2dNq165tOuaGG25wQZN20LA9DRPTXBbtozrddtttpi/90ZRzzz3X3n77bVffo48+2jT0\nS+1RUUD3/PPP5ziNArUpU6aE1qnOCqw0rK1q1aquDpr7o3LwwQdbuXLlrFatWm6oW/ny5V3d\n/XOSnn76aVPQs9dee9kbb7xhvXv3tvHjx1vXrl1t/vz5LsDx3NTr0rRpU9u0aZMLxtQ7pbZ7\nQZLugWz8RfO51K5ixYr5V1tGRoars1YeeuihVr16dYt3/XQtfQ5ee+21HEGc1hdmYYhdYWpy\nLgQQQAABBBBAAIE8BdQz9Mwzz7heEfUeqeiL+THHHOPWtW7d2q0766yzXK+J3qgHySsaBvbk\nk0+6oESBkYq+nGuekNdz41b6/li3bp0bkqUv8ioKGNTjccstt7ghYgpQHn/8cStevLj16NHD\nfvnlF1PPUzTlww8/dPVUYKKioMbfO+VW5vHHjh07bMyYMabeK5U99tjDJYVQEKheILVLQaSG\n2Wk+1CWXXGKTJk2y8847z+3/7LPPup4g9ybrD1l98MEHLoBRwHfAAQfYnXfeaepVu+aaa5z1\nCy+84HZXT9KRRx7ptqv3Kbyot2r27NkRLRS8KghTQCW/gw46yAWX8a7ffvvtF17NQn9PgFTo\npJwQAQQQQAABBBBAIDeBzz//3PUMnXTSSaFdFAAoyFHw5AVIxx57bGi7f0E9MBUqVLBmzZqF\nVnuBRGhF2ELZsmVdL4e3Wl+y582b594qMFGgpd4VDdVbsGCBzZw509XH2z+v1169epmCGQUq\nGr6nQKZhw4Z5HZJjmwIiXd8rbdq0cUMANaytXr163mr3WqZMGevWrZsbPqgA6aOPPnIJEhSo\neEV+6t3xiobSffrpp6ZhicqaV6NGDdd7520vUaKEG37ovfdelTVQQwE1n+uoo47yVuf5msj6\n5VmRAm78n14BT8ThCCCAAAIIIIAAAgjsTkBD5ipWrOiGjnn7avhWtWrVcvS8VKlSxduc41VD\n4fbZZ58cQYDOl1dREOIv6inyepu++uorO+WUU9xQvebNm9vxxx/vhqBFm3xAvSwK9pTcQNnm\nNB9Jc3+8YXbedbzrhyeb2HvvvU2BhVfkoKKAJlJRYKRhguoFU1B2+umnW+XKlUO71q1bN7Ss\nBW3TfCENy9PcHQ2DU/u9ooCsUqVK3lu3j3qBNLROQ9latmwZ2hbNQrzrF00dCroPAVJBBTke\nAQQQQAABBBBAIGoBDflSMgDNmzn88MPdcatWrTIFKuHzXyKdVL0z6l1RoOQFBpp7E2vREDYN\ni1OvkXpTVDR/KZphcn/99Zeb73PaaaeZfhSAaP6SkkLovBqGpvk+/hKeqlxJFjQPyQtSNPRP\n9dh///39h4WWNR+oQYMGNnHiRNe788QTT4S2aSE8u5vOp2F0mt+keUo1a9Z0Q+q8gzRfq2TJ\nkt5bNwdKw+o0TK9Ro0ah9ZEWvHlJ/iAw3vWLVI/CXve/8LGwz8z5EEAAAQQQQAABBBAIE9B8\nozp16rj5P0qg8NNPP7keF/WctGjRImzvXd9qGJuGninbnLK/aT6NsuDFWjS0T8HW5s2bXa+S\nMsYp+MitB0dZ6JQYQUVD95RNTwkn1DOmc2j+kpIqqFdI83LUc6P91XOk5AyRHmCroErbNWRO\nAc8FF1wQ6lVST5qG/imI9Ip6adRDpQBFvV/+omF0en6R6qJXBaIaBqiiniH1OqkeCgAVCGlI\noOZoqaie8tTcLAVtysLn/XgBo4bdKbmDihegagif/3lE8aqfu2gC/iBASgAyl0AAAQQQQAAB\nBBD4R0BBhVI0a4iYem7Uo6R5P2+99ZabH7M7J/WuqLdnzz33dGm+FVzoYaoqOnd+y9VXX+3m\nNGnYnoa7KYOc0nwvXrzYBTfh51NWOi/LnAIUJTfQvgqKFDCobkqioKKhcJdffrlLTa26aV6P\ngil/qV+/vq1evdoNO9TwPvWq6fpeUSpzBWxKYuEVZc5TUKNX/3wjbdd8JvVgadihMvE9+uij\nduKJJ7pDBw4c6BIrKAGG/BQ4Keue0ouraIigeoOUNlzBqv9HAZeK6v/OO++4ZfVIaQ6XElso\nPbhX4lU/7/zxfi2WhfBPovZ4X6mQzz9q1Cg3hlI3JJZSfUreXYZ5nbPpN/Pz2pzntsn/pIvP\nc59EbAx6+wti3GlI7Eenyv2PvQVmQW9/Qew4FgEEgiug4WPKkuZ9sU6UREH+zc5vHWP5P049\nNwoyvOFl0VxTPTRKX61AwBvipV4OzZVRr4cSOMRS1q9f7+YhKXCIpWgonYIIDWULLxqK98cf\nf7i5U+HbvPeyUPAXqf7KTKdsd95cqrVr17qU5eotUpDpFc1HUipz9WopANVwOs/I20ev6q3S\nMEfvYbD+bbEsq22qmzdEMdXql982MQcpv2LsjwACCCCAAAIIIFAoAt4QrfycTF/ulVhAD05V\nmmrN4dHDZDXULFJwEe25c0sKEe3xSn6gn0hFwYMX3ETarnV5WehZT/rRcD09W0mBtnp3/MFR\n+HnVo5Vb0ZyjwgqOdA0vqEzV+uXmkNv64rltYD0CCCCAAAIIIIAAAqkmoF4RDXN7/fXXXSpu\npbVWQoMJEyakWlULvT4aVqdhe5oDpB7J8KJhdV6wEr4tEe9TvX7RGtCDFK0U+yGAAAIIIIAA\nAgikhECXLl1MP0qkoExxQSlKTqHhev604P62KwFDMkuq1y9aG3qQopViPwQQQAABBBBAAIGU\nEghScOTB5xYceduT/Zrq9YvGhwApGiX2QQABBBBAAAEEEEAAgUAIECAF4jbTSAQQQAABBBBA\nAAEEEIhGgAApGiX2QQABBBBAAAEEEEAAgUAIkKQhELeZRiKAAAIIIIBAEAVieTZREJ1oMwJ+\nAXqQ/BosI4AAAggggAACCCCAQKAFCJACfftpPAIIIIAAAggggAACCPgFCJD8GiwjgAACCCCA\nAAIIIIBAoAWK9Bykrc+MsU0zpsd2AzvHdhhHIYAAAggggAACCCCAQPoK0IOUvveWliGAAAII\nIIAAAggggEA+BQiQ8gnG7ggggAACCCCAAAIIIJC+AikTIM2ePds+//zz9JWmZQgggAACCCCA\nAAIIIJDyAikRIH3xxRd2yy232IIFC1IejAoigAACCCCAAAIIIIBA+gokNUnDjh077Nlnn3U/\nxYoVS19lWoYAAggggAACCCCAAAJFQiCpPUjTp0+3adOm2Z133mm1a9cuEmBUEgEEEEAAAQQQ\nQAABBNJXIKk9SMcff7ydeuqplpGRYSNGjMhVOTMz0xYuXJhj+6ZNm6xSjjW8QQABBBBAAAEE\nEEAAAQQKJpDUAKlKlSpR1X7Lli3WsWPHHPsec8wxdkKONbxBAAEEEEAAAQQQQAABBAomkNQA\nKdqqq4epW7duOXb/66+/zNauzrGONwgggAACCCCAAAIIIIBAQQSKRIBUsmRJu/XWW3O0c9So\nUWZfkhY8BwpvEEAAAQQQQAABBBBAoEACSU3SUKCaczACCCCAAAIIIIAAAgggUMgCBEiFDMrp\nEEAAAQQQQAABBBBAoOgKFIkhdkWXl5qnqkD1KY1irlpTmx/zsRyIAAIIIIAAAgggkNoCKRMg\nPfPMM6ktRe0QQAABBBBAAAEEEEAg7QUYYpf2t5gGIoAAAggggAACCCCAQLQCBEjRSrEfAggg\ngAACCCCAAAIIpL0AAVLa32IaiAACCCCAAAIIIIAAAtEKECBFK8V+CCCAAAIIIIAAAgggkPYC\nBEhpf4tpIAIIIIAAAggggAACCEQrQIAUrRT7IYAAAggggAACCCCAQNoLECCl/S2mgQgggAAC\nCCCAAAIIIBCtQMo8BynaCrMfAggUXIAH5RbckDMggAACCCCAQHoK0IOUnveVViGAAAIIIIAA\nAggggEAMAgRIMaBxCAIIIIAAAggggAACCKSnAAFSet5XWoUAAggggAACCCCAAAIxCBAgxYDG\nIQgggAACCCCAAAIIIJCeAgRI6XlfaRUCCCCAAAIIIIAAAgjEIECAFAMahyCAAAIIIIAAAggg\ngEB6ChAgped9pVUIIIAAAggggAACCCAQgwABUgxoHIIAAggggAACCCCAAALpKUCAlJ73lVYh\ngAACCCCAAAIIIIBADAIESDGgcQgCCCCAAAIIIIAAAgikpwABUnreV1qFAAIIIIAAAggggAAC\nMQgQIMWAxiEIIIAAAggggAACCCCQngIESOl5X2kVAggggAACCCCAAAIIxCBAgBQDGocggAAC\nCCCAAAIIIIBAegoQIKXnfaVVCCCAAAIIIIAAAgggEIMAAVIMaByCAAIIIIAAAggggAAC6SmQ\nkZ7NCkarNvXqEXtDO8d+KEcigAACCCCAAAIIIJCuAvQgpeudpV0IIIAAAggggAACCCCQbwF6\nkPJNxgEIIBB0gU5DYheYPCD2YzkSAQQQQAABBOIvQA9S/I25AgIIIIAAAggggAACCBQRAQKk\nInKjqCYCCCCAAAIIIIAAAgjEX4AAKf7GXAEBBBBAAAEEEEAAAQSKiAABUhG5UVQTAQQQQAAB\nBBBAAAEE4i9AgBR/Y66AAAIIIIAAAggggAACRUSAAKmI3CiqiQACCCCAAAIIIIAAAvEXIECK\nvzFXQAABBBBAAAEEEEAAgSIiQIBURG4U1UQAAQQQQAABBBBAAIH4CxAgxd+YKyCAAAIIIIAA\nAggggEAREcgoIvWkmgjsIrCpV49d1kW9onPUe7IjAggggAACCCCAQIAE6EEK0M2mqQgggAAC\nCCCAAAIIIJC3AAFS3j5sRQABBBBAAAEEEEAAgQAJECAF6GbTVAQQQAABBBBAAAEEEMhbgAAp\nbx+2IoAAAggggAACCCCAQIAESNIQoJtNU9NLgCQV6XU/aQ0CCCCAAAIIpIYAPUipcR+oBQII\nIIAAAggggAACCKSAAD1IKXATqAICCCReoPqURjFftKnNj/lYDkQAAQQQQACB1BagBym17w+1\nQwABBBBAAAEEEEAAgQQKECAlEJtLIYAAAggggAACCCCAQGoLECCl9v2hdggggAACCCCAAAII\nIJBAAQKkBGJzKQQQQAABBBBAAAEEEEhtAQKk1L4/1A4BBBBAAAEEEEAAAQQSKECAlEBsLoUA\nAggggAACCCCAAAKpLUCAlNr3h9ohgAACCCCAAAIIIIBAAgUIkBKIzaUQQAABBBBAAAEEEEAg\ntQUIkFL7/lA7BBBAAAEEEEAAAQQQSKAAAVICsbkUAggggAACCCCAAAIIpLYAAVJq3x9qhwAC\nCCCAAAIIIIAAAgkUIEBKIDaXQgABBBBAAAEEEEAAgdQWIEBK7ftD7RBAAAEEEEAAAQQQQCCB\nAgRICcTmUggggAACCCCAAAIIIJDaAgRIqX1/qB0CCCCAAAIIIIAAAggkUCAjgdfiUggggECh\nCmzq1SP283WO/VCORAABBBBAAIH0FaAHKX3vLS1DAAEEEEAAAQQQQACBfAoQIOUTjN0RQAAB\nBBBAAAEEEEAgfQUIkNL33tIyBBBAAAEEEEAAAQQQyKcAAVI+wdgdAQQQQAABBBBAAAEE0leA\nACl97y0tQwABBBBAAAEEEEAAgXwKECDlE4zdEUAAAQQQQAABBBBAIH0FCJDS997SMgQQQAAB\nBBBAAAEEEMinAAFSPsHYHQEEEEAAAQQQQAABBNJXgAApfe8tLUMAAQQQQAABBBBAAIF8ChAg\n5ROM3RFAAAEEEEAAAQQQQCB9BTKS3bQ//vjDPvjgA9Prsccea/vtt1+yq8T1EUAAAQQQQAAB\nBBBAIKACSe1BWrp0qZ1xxhk2ceJEmz9/vp1//vk2Z86cgN4Kmo0AAggggAACCCCAAALJFkhq\nD9KQIUOsQ4cO9p///MeKFStmTz/9tN1///02btw49z7ZOFwfAQQQQAABBBBAAAEEgiWQtB6k\n9evX27fffut6kBQcqZx22mm2cuVKW7BgQbDuAq1FAAEEEEAAAQQQQACBlBBIWg/S6tWrHUDN\nmjVDEFWqVLFSpUrZ2rVrrWHDhqH127Zts8GDB4fea2Hr1q22fN0G+/6vv3Ksj/ZN2Yk7ot11\nl/1W/nrTLuuiXXFT7IfucokdS5btsi7aFbSf+x/tZyV8v1T5/KteQf87EH5veI8AAqkr8Ouv\nv1rx4kn7vXTqwlAzBFJQIGkB0qpVq6x06dLux++y5557mv4R8ZedO3fahAkT/Kvk/Eo7AAAU\nn0lEQVSsW7dudul99+VYl5837XLZecyYMbZjxw674IILctkjhVa3aRNzZXJr/6xZs9x8sO7d\nu9vee+8d8/kTcmAc2v/DDz/Y9OnTrVmzZnbkkUcmpBkxXyQO7dcvI0aOHOmSpXTs2DHmqiXs\nwDgYjB8/3v2S5vLLL09YM1LpQh999JF9/PHH1qlTJ6tdu3YqVS0hdfn5559t0qRJ1qRJE/vX\nv/6VkGum2kWGDx/u/v3v2rVrqlUtIfWZMmWKLVu2zPr27WtlypQp1GtWrVq1UM/HyRBAID4C\nSQuQSpYs6QKR8GYpGNpjjz1yrNY/UPoHy1/U2xSPL/Dqqdq8ebO1bNnSf7nALM+cOdMFSI0a\nNbL69esHpt1eQ3XvlTCkffv2gfwMbNq0yS677DKrWLFiINuvz8HDDz/sPgNB/Tfgs88+c+2/\n5pprrGnTpt5fjcC8zps3z7VfwVFQPwP9+vVz//4Htf1jx451nwFl1tW/hRQEEAieQNICJAU3\nCob+yhoi5w+Ifv/9d6tRo0aOO6E5SkH8sp4DgTcIIIAAAggggAACCCAQd4GkDYbdd999LSMj\nw7755ptQI5W04e+//zb/vKTQRhYQQAABBBBAAAEEEEAAgTgLJK0HqUKFCnbyySfbU089ZQ0a\nNHDB0ujRo61t27aWzDG6Cty2bNkSZ/bUPb169urUqeOSZaRuLeNXs3Llyrn277XXXvG7SAqf\nWROIdf/32WefFK5lfKumX9BoqGFQS6VKldxnoGzZsoEk0JBu/R2QQ1CL2h8+kiNIFvr3TwYl\nSpQIUrNpKwII+ASKZWYV3/uELioZw6BBg+zLL790yRoaN25sN954owX1y2lC8bkYAggggAAC\nCCCAAAII7CKQ1ADJq43mHek3NfrtPQUBBBBAAAEEEEAAAQQQSJZASgRIyWo810UAAQQQQAAB\nBBBAAAEE/AJJS9LgrwTLCCCAAAIIIIAAAggggEAqCCQtSUMqND5SHZR6XM9A0EMSgzYXSinX\nP/zwQ1u5cqXpOUgp/6DUSDewAOv0gGA9IHPJkiV26KGH2mGHHVaAsxXtQz/55BPbuHGjtW7d\numg3JB+1/+OPP0wPSQ0vJ5xwgum5bUEouuf6N0DDnps3b261atUKQrNdG998802XRTW8weXL\nl7fjjz8+fHXavl+zZo29++67duCBB9rhhx9uesxGkMr333/v/h/Qsxb1HKQgJ+sI0n2nrQiE\nCzDELkxED4l88cUXbfz48YFKN/7666/b0KFDXWCg51LpS9Jpp51melhkEIq+GP773/92Dx+u\nV6+evffee3b66ae7h6YGof3+NuoLUq9evUxJU+6++27/prRefv/99+2mm27a5QHUyrS55557\npnXb1bjFixe7v+/KXqYsXvqS3LNnTzvvvPPSvu1qYPfu3W3btm052rpu3Tr3DL5Ro0blWJ+u\nb+68806bPXu2NWvWzL777jv3nEL9nxiUR29MmjTJHnzwQXfP9XdeCaQeeugha9iwYbrectqF\nAAK5CNCDlA2jL4X33nuv6SnyQSt69tTTTz9tF198sZ199tmu+fpPUhkFO3bsaAcccEDakzz7\n7LMura33RWjOnDl27bXXOo8gpbzWZ+G2224L3G+N9QFftGiR+yL0yCOPpP3nPVIDH330UffI\nBX1JVtHfgYEDB9pZZ50ViADx+eefz8Gi/wuuvvpqu/TSS3OsT9c3P/zwg7322mt2//33W5Mm\nTUwJbrt16+ZGVFx33XXp2uxQuxQM6+/+ueeea3379nXrJ0yY4P4ffO6550giFZJiAYFgCDAH\nKfs+33XXXe4/hCD9xtz7iG/YsMGOPvpoa9OmjbfKjjjiCLes4XZBKC1btjT/lwBvWIVS0Qep\nvPDCCy44OvHEE4PUbNdWBUj169cPXLvVYP09nzt3rvsliQeg4UXqPdNzgYJWNNx4yJAhrlcp\nKENtt2/f7m5ztWrV3KuG1um5gJs3bw7E7deD6mWgkQNe0RBj/R8QxF+cega8IhBUAXqQsu/8\n9ddf74aVLF++PHCfBT0cVr8p9Ze33nrLpV4PyhdG70vQ1q1b7YsvvnA9alp30EEH+VnSellD\nahQg6YHNmocXtKIAqXTp0qZ/CxYuXOh6Uy677LJAzMNZsWKF+/uuL8Uaaqt/Bw855BDr3bt3\nYOZf+T/vI0eOdJ+F888/3786rZf1b72G1er+d+3a1dSjNH/+fPN6FNO68dmN0+ff/3BYBUzq\nVf/555+D0HzaiAACPgF6kLIxgjSMynf/Iy5qLoKGmvXo0cMFjRF3StOVU6ZMsZtvvtm++eYb\nO+ecc6x48WD8FVFgqKF1Gk5UvXr1NL27uTdLCRpWr15tGmbToUMHu+CCC2zVqlXOY9OmTbkf\nmCZb1G71FGlYqb4kHnXUUTZjxgy78sorIyYuSJNmR2yGPgvTpk1zQwszMoLzO0T9W3fRRRe5\nXw7ceuut7hclJ510kguaIkKl2coGDRq4XwaMGzfOlLBHCZteeukl10r1KFIQQCBYAsH51z9Y\n9zXm1n711VfuN+gaYtWnT5+Yz1NUD9QcLGUwVJIGTdi/4YYbrG3btkW1OVHXW2Pv69SpY+3a\ntYv6mHTaUZnKNN+gcuXKVqpUKdc09aAoWYV6U88444x0au4ubdEXwj///NPUY9KlSxe3XfNQ\n+vXr54beNW3adJdj0nWFAkMFRieffHK6NjFiu5S5UiMJ1IOq4dbqRVTv0aBBg2zw4MERj0mn\nlRpJccUVV7g5WLNmzXI9Sfvvv7/7d7Fs2bLp1FTaggACUQgQIEWBFJRdlMVLk7L1BUm/SQxq\n0ZcjpXbWb5HffvvttA+QlKBk8uTJLoNh//793W1XL6Iyeun9gAEDrGLFimn9cVCvSXjPmbIZ\nVq1a1fUkpXXjsxqndqpoLp5XlOpfjzr46aefvFWBeJ06dar7RYGyeQap6N86ZWs79dRTXbOV\nnEeZ/e644w6XzS4IHvpFiObffv3111a7dm3noURFSvlNQQCBYAkEY/xQsO5pTK3Vf4633HKL\n+w1aEIMjDSVSD4K/aGiVMjmle9FvRzWkTJPy1WuiHyWpUK+KloPwDKBly5a53iLNxfGKhtj9\n8ssvgZiDVLduXddsDTP0itqu5yF527z16fy6fv16l+7cHyimc3v9bduyZcsumdo0H0e9ixqC\nm+5F7R8zZoz7d699+/buOXiah/Xbb78F+pl46X7faR8CuQkQIOUmE6D1+lKgLH6tWrVyX4b0\n7AfvRxnuglD0IEilclXPib4MvPLKK24eUhCGnKmXQEPJ/D+asK3foGpduXLl0v4joCBAc3A0\nOV9ZqxQcjRgxwgWKmoeR7kXPudHffz0DRv8e6EvhE088YcpoFqRnwChQVtHQqqAVDavWMLuZ\nM2e6eWf6t1D/JqpHxcvqmc4m+vuvbHVPPvmk+z9A/w4o5bl60cJ7l9PZgbYhgMA/Agyx45Pg\nnn2hSah6krx+/EXj0fXbtHQvmpivYRXK2qU5KBpmd9VVV7mhdunedtr3j4Dut+ZaaA6aiobY\nDR8+3IIwtEjtVZp7pbbu3Lmzm39Rq1YtGzZsWGDaLwMFSAoG0n1IqdoaXvRLIs3BURY7Pe5C\nPSrqVdb/AUEpSlKjv/NK9a2e8+bNm7ve9aC0n3YigMD/BIplDSFK/zFE/2svSwjkKaBhdRpW\npKyG/nSveR7ExrQSUEY3fTmqUKFCWrUr2sbolyX6cqyEFZTgCSittYZaKkgMyi8Hwu/yxo0b\n3VC7IGUxDDfgPQJBFyBACvongPYjgAACCCCAAAIIIIBASIA5SCEKFhBAAAEEEEAAAQQQQCDo\nAgRIQf8E0H4EEEAAAQQQQAABBBAICRAghShYQAABBBBAAAEEEEAAgaALECAF/RNA+xFAAAEE\nEEAAAQQQQCAkQJrvEAULCCCQaAFli5o7d65Lq960adPAZs1KtDvXQwABBBBAAIHcBQiQcrdh\nCwIIxFFg2rRppudPKa2wyooVKwiQ4ujNqRFAAAEEEEAgOgHSfEfnxF4IIFDIAnoI5fz5823C\nhAm23377WaNGjQr5CpwOAQQQQAABBBDIvwABUv7NOAIBBApBYN9997WDDjrIZs2aVQhn4xQI\nIIAAAggggEDhCJS4NasUzqk4CwIIILB7gQULFtjw4cPt7bffdjuvW7fOtm3bZjt27LCHH37Y\n9STdd9999swzz1iZMmXsgAMOcPtp+xNPPGEjR4608ePH29KlS61hw4ZuH/9V165da88//7zp\nHJ999pkpEPv4449t6tSppnlOKo888oh9+eWXdtRRR/kPddd86623Qvt5G7/++mtX5xEjRtic\nOXOsZMmStv/++3ubbdGiRfbQQw/ZoYceau+9955rh+r/448/2uGHH+72D+2ctbBp0yZXH51v\n+vTpbrt60UqUKGFTpkxx9T/yyCN3aZva9dprr9nxxx/vPx3LCCCAAAIIIFCYApkUBBBAIIEC\n7777bmarVq0yS5UqlVmlShW3/Oijj2a+/PLLmVn/tmWeffbZ7rV48eKZF110katZVtCT2aRJ\nE7c+q9cps2PHjpkVK1bMrFOnTuY333wTqv0vv/ySmRW4ZFauXDnz3//+d2abNm3ccosWLTKz\nApDQflnD+TKzhviF3nsLrVu3zrGf1mcFZK6uqu/pp5+emRW4uHpcc8013mGZWfOp3Lrzzz/f\nvWYFRZn169d3y9p/586doX03b96c2axZs8ysICvz5JNPzjzhhBMy1dbGjRtnZgWBmZMmTXLH\nPf7446FjtKDjKlSokNmrV68c63mDAAIIIIAAAoUrYIV7Os6GAAIIRCewzz77uIDD29sLkPbe\ne28X9GzYsCFz9erVbrMXeLz00kve7pnLly/PrFGjRmbz5s1D6xQQKYhYsmRJaN2wYcNcwBFL\ngJTVM+SCIwUxCr68cuONN7pzzpw5063yAiS1Kau3ydsts2/fvm6/N954I7SuZ8+emRkZGZnv\nv/9+aN2rr77q9hs1alTm1q1bM2XQsmXL0HYtjBs3zu2TNSQxx3reIIAAAggggEDhCvAcpMLs\njuNcCCBQYIELL7zQDjnkEKtUqZJlBRymVOBPPfWUG/bWqVOn0Pk1JK179+5uSNtXX31lf/75\np2l4XJ8+fXIMf/vPf/6T433oBFEsaAichv9df/31lhW0hI7473//64bFaaiev1xyySU5kk1k\n9Ya5zVnBnHvN+ufbXnnlFevSpUuOYXLt27d3w/7q1q1rWT1V1qNHD5s9e7YbouedX0P2tD2r\n981bxSsCCCCAAAIIxEGANN9xQOWUCCAQu4ASN/iL5vcosPj9999dYOHf9tNPP7m333//vZvX\no5Th4dnwNK9Hc43mzZvnPzSq5e+++86KFStmjz32mI0ePTrHMXvssYfpuv7izZfy1lWrVs0t\nZg2Pc6+aN6V2aF5SeOnXr19o1XnnnWcPPvigm4uk4GzNmjU2Y8YMu+GGG1x9QjuygAACCCCA\nAAKFLkAPUqGTckIEECiIQNa8pByHK4mDStmyZS1rrk6OH/UinXPOObbnnnva+vXr3X7lypVz\nr/4/1BsVTcmaK5RjN127dOnS7kG24ddu27atHXfccTn2V9DkLwquVBTgqfz888/uVfXNq2TN\nR7IjjjjCxo4d63ZTcgbVLWv+UV6HsQ0BBBBAAAEECkGAHqRCQOQUCCAQP4F69eq5k6tn6bnn\nnstxIQUN6iFS+fbbb92rN5zNvcn+Y+XKlf637pjt27fnWKc3yjrnL7q2ep4GDx7sUpL7tymr\nXtZcIv+q3S57me+8QMl/QNYcLBcEde7c2a1WL9IVV1xhyvr34osvWlZiB/Ms/MexjAACCCCA\nAAKFK0APUuF6cjYEEChkAQUF1atXt8mTJ7vhaf7Ta65OVjY7U1Ck4W1ZWe1cqm6vx0b7ania\nl1LcO9Y75q+//vJWWVZiB3ee0IqsBS+dtub/+IvmPJUvX940vyk/pVatWla7dm2bOHGiaTig\nV7ISUrh5R0pz7hXNr9J8JKU1nzt3rvXu3dvbxCsCCCCAAAIIxFGAACmOuJwaAQQKLqBnDg0d\nOtQ0jycrvbdlpQl3zzVSogQ9D0m9LAqMvP3mz59vSo6gZx9pXyVA8AdCqtEpp5zihuRlZZRz\niR3GjBnj1oUPxctKM24NGjSwBx54wM0Jykop7uYFde3a1QVIN910U74aqCF3d999ty1cuNDN\np1Lgo+cadevWzbWvf//+ofNpqGFWWnFToggNL/QSPoR2YAEBBBBAAAEE4iKQv/EhcakCJ0UA\nAQTyFjj33HNdb8pVV10VyuKm4W1Z6b/NH6QoiMhKh22XXnqpZT1PyA2l07wdzQ3yD71Tz48S\nLDz77LOWlTrczWHSeVatWuXee7VR0KUgS+fLeu6Re5itth144IH2wgsvWNWqVb1do35VMKQe\nLrVFdVRRtj7NN2rXrl2O82iYnfbRsLvdzVvKcSBvEEAAAQQQQCBmgWJZ/1H/M3s45lNwIAII\nIJA4gaxnI7neH6W8jpSQQTXRP2uLFy92gYcCi6znI7mAyB8kaT/1LGnekQIeby6T1kcqSvf9\nww8/WNZzlqxmzZqFkk1uxYoVLo245iYpCUR4yXp+kikZRNazjyzrWUzhm3mPAAIIIIAAAnEQ\nIECKAyqnRACB1BLILUBKrVrmrI3mKKlHadmyZW5InpcRL+devEMAAQQQQACBwhZgiF1hi3I+\nBBBAoAAC6v1q1aqVG+6nHisNsSM4KgAohyKAAAIIIJBPAQKkfIKxOwIIFD2Bk046yRo2bFgk\nKq5gSHOSFCjpwbCdOnUqEvWmkggggAACCKSLAEPs0uVO0g4EEEAAAQQQQAABBBAosMCus4IL\nfEpOgAACCCCAAAIIIIAAAggUTQECpKJ536g1AggggAACCCCAAAIIxEGAACkOqJwSAQQQQAAB\nBBBAAAEEiqYAAVLRvG/UGgEEEEAAAQQQQAABBOIgQIAUB1ROiQACCCCAAAIIIIAAAkVTgACp\naN43ao0AAggggAACCCCAAAJxECBAigMqp0QAAQQQQAABBBBAAIGiKfD/AwonMiOZMm4AAAAA\nSUVORK5CYII="" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"" } ], ""execution_count"": 17 } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""R"", ""language"": ""R"", ""name"": ""ir"" }, ""language_info"": { ""codemirror_mode"": ""r"", ""file_extension"": "".r"", ""mimetype"": ""text/x-r-source"", ""name"": ""R"", ""pygments_lexer"": ""r"", ""version"": ""4.2.3"" } }, ""nbformat"": 4, ""nbformat_minor"": 1 } ","Unknown" "Allele","Sendrowski/fastDFE","docs/reference/R/quickstart.ipynb",".ipynb","82153","216","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# Quickstart\n"", ""The easiest way to get started is by using the {class}`~fastdfe.base_inference.BaseInference` class which infers the DFE from a single pair of frequency spectra, one `neutral` and one `selected`. In this example we create {class}`~fastdfe.spectrum.Spectrum` objects holding the SFS counts and pass them to {class}`~fastdfe.base_inference.BaseInference`. Note that we are required to specify the number of monomorphic sites (the last and first entries of the specified counts which correspond to the number of mono-allelic sites where the ancestral and derived allele is fixed, respectively). By default, only the deleterious part of the DFE is inferred (cf. {attr}`~fastdfe.base_inference.BaseInference.fixed_params`)."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""tags"": [], ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:38:54.543415Z"", ""start_time"": ""2025-11-30T10:38:50.343961Z"" } }, ""source"": [ ""library(fastdfe)\n"", ""\n"", ""# load the fastdfe package\n"", ""fd <- load_fastdfe()"" ], ""outputs"": [], ""execution_count"": 11 }, { ""metadata"": { ""tags"": [ ""remove-cell"" ], ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:39:44.148868Z"", ""start_time"": ""2025-11-30T10:39:40.364824Z"" } }, ""cell_type"": ""code"", ""source"": [ ""setwd(\""/Users/au732936/PycharmProjects/fastDFE\"")\n"", ""reticulate::use_condaenv(\""/Users/au732936/miniconda3/envs/dev-r-fastdfe\"", required = TRUE)\n"", ""source(\""R/fastdfe.R\"")\n"", ""fd <- load_fastdfe()"" ], ""outputs"": [], ""execution_count"": 17 }, { ""cell_type"": ""code"", ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:39:44.749545Z"", ""start_time"": ""2025-11-30T10:39:44.162784Z"" } }, ""source"": [ ""# configure inference\n"", ""inf <- fd$BaseInference(\n"", "" sfs_neut = fd$Spectrum(c(177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 0)),\n"", "" sfs_sel = Spectrum(c(797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 0)),\n"", "" do_bootstrap = False\n"", "")\n"", ""\n"", ""# run inference\n"", ""sfs_models <- fd$BaseInference$run(inf)"" ], ""outputs"": [], ""execution_count"": 18 }, { ""cell_type"": ""markdown"", ""metadata"": { ""slideshow"": { ""slide_type"": """" }, ""tags"": [] }, ""source"": ""fastDFE uses maximum likelihood estimation (MLE) to find the DFE. By default, 10 local optimization runs are carried out to make sure a reasonably good global optimum has been bound. The DFE furthermore needs to parametrized where {class}`~fastdfe.parametrization.GammaExpParametrization` is used by default. We also report the standard deviation across optimization runs to give an idea of the reliability of the estimates. In this case, the standard deviations are low, indicating that the estimates are stable."" }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""We can now plot the inferred DFE in discretized form (cf. {func}`~fastdfe.base_inference.BaseInference.plot_discretized`)."" ] }, { ""cell_type"": ""code"", ""metadata"": { ""tags"": [], ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:39:44.904067Z"", ""start_time"": ""2025-11-30T10:39:44.794296Z"" } }, ""source"": ""p <- fd$BaseInference$plot_discretized(inf)"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nrQA4AAAAAElFTkSuQmCC"" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"" } ], ""execution_count"": 19 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": ""We can also plot a comparison of the `selected` modelled and observed SFS (cf. {func}`~fastdfe.base_inference.BaseInference.plot_sfs_comparison`)."" }, { ""cell_type"": ""code"", ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:39:45.014626Z"", ""start_time"": ""2025-11-30T10:39:44.915448Z"" } }, ""source"": ""p <- fd$BaseInference$plot_sfs_comparison(inf)"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\n/6QZPfhmM1wrAAAAAElFTkSuQmCC"" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"" } ], ""execution_count"": 20 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""## Bootstrapping\n"", ""\n"", ""To quantify uncertainly we can perform parametric bootstrapping (cf. {func}`~fastdfe.base_inference.BaseInference.bootstrap`)"" ] }, { ""cell_type"": ""code"", ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-11-30T10:39:46.688618Z"", ""start_time"": ""2025-11-30T10:39:45.026173Z"" } }, ""source"": [ ""bs <- inf$bootstrap()\n"", ""\n"", ""# redo the plotting\n"", ""p <- fd$BaseInference$plot_discretized(inf)"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nEKAkTMeCCCCAAAIIIJAqgf8FIb/+2ymUZ+MAAAAASUVORK5CYII="" }, ""metadata"": { ""image/png"": { ""width"": 276, ""height"": 192 } }, ""output_type"": ""display_data"" } ], ""execution_count"": 21 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""By default, we perform 2 optimization runs per bootstrap sample taking the best result (cf. {attr}`~fastdfe.base_inference.BaseInference.n_bootstrap_retries`). The standard deviation across runs is computed for each bootstrap sample, and the average of these standard deviations across all samples is reported to summarize the uncertainty of the bootstrap estimates. In this case, we can see that the uncertainty is quite low indicating reliable bootstrap estimates."" } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""R"", ""language"": ""R"", ""name"": ""ir"" }, ""language_info"": { ""codemirror_mode"": ""r"", ""file_extension"": "".r"", ""mimetype"": ""text/x-r-source"", ""name"": ""R"", ""pygments_lexer"": ""r"", ""version"": ""4.3.3"" } }, ""nbformat"": 4, ""nbformat_minor"": 4 } ","Unknown" "Allele","Sendrowski/fastDFE","docs/reference/R/parametrizations.ipynb",".ipynb","43676","148","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# DFE parametrizations\n"", ""\n"", ""The DFE needs to be parametrized in some way in order to be amenable to maximum likelihood estimation. {class}`~fastdfe.parametrization.GammaExpParametrization` is used by default. Other parametrizations are also implemented (cf. {mod}`~fastdfe.parametrization`). You can also create your own parametrization by subclassing {class}`~fastdfe.parametrization.Parametrization`.\n"", ""\n"", ""To see how the parametrization affects the shape of the DFE, we use our example data for `B. pendula`."" ] }, { ""cell_type"": ""code"", ""metadata"": {}, ""source"": [ ""library(fastdfe)\n"", ""\n"", ""# load the fastdfe package\n"", ""fd <- load_fastdfe()"" ], ""outputs"": [], ""execution_count"": null }, { ""metadata"": { ""tags"": [ ""remove-cell"" ], ""ExecuteTime"": { ""end_time"": ""2025-12-12T12:22:47.836082Z"", ""start_time"": ""2025-12-12T12:22:40.714119Z"" } }, ""cell_type"": ""code"", ""source"": [ ""setwd(\""/Users/au732936/PycharmProjects/fastDFE\"")\n"", ""reticulate::use_condaenv(\""/Users/au732936/miniconda3/envs/dev-r-fastdfe\"", required = TRUE)\n"", ""source(\""R/fastdfe.R\"")\n"", ""fd <- load_fastdfe()\n"", ""fd$Settings$parallelize <- FALSE\n"", ""# set plot size\n"", ""options(repr.plot.width = 6, repr.plot.height = 3)"" ], ""outputs"": [], ""execution_count"": 1 }, { ""cell_type"": ""code"", ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-12-12T12:23:46.701447Z"", ""start_time"": ""2025-12-12T12:22:47.841053Z"" } }, ""source"": [ ""# the different DFE parametrizations\n"", ""parametrizations = c(\n"", "" fd$GammaExpParametrization(),\n"", "" fd$DiscreteParametrization(),\n"", "" fd$GammaDiscreteParametrization(),\n"", "" fd$DisplacedGammaParametrization()\n"", "")\n"", ""\n"", ""inferences <- vector(\""list\"", length = 4)\n"", ""\n"", ""for(i in seq_along(parametrizations)) {\n"", "" # create inference object\n"", "" inference <- fd$BaseInference(\n"", "" sfs_neut = fd$Spectrum(c(177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 0)),\n"", "" sfs_sel = fd$Spectrum(c(797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 0)),\n"", "" fixed_params = list(all = list(h = 0.5, eps = 0)),\n"", "" model = parametrizations[[i]]\n"", "" )\n"", ""\n"", "" # run inference\n"", "" inference$run()\n"", ""\n"", "" inferences[[i]] <- inference\n"", ""}"" ], ""outputs"": [], ""execution_count"": 2 }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-12-12T12:23:47.307243Z"", ""start_time"": ""2025-12-12T12:23:46.718841Z"" } }, ""cell_type"": ""code"", ""source"": [ ""# plot the inferred DFEs\n"", ""p <- fd$Inference$plot_discretized(\n"", "" inferences = inferences,\n"", "" labels = c(\""GammaExp\"", \""Discrete\"", \""GammaDiscrete\"", \""DisplacedGamma\""),\n"", "" intervals = c(-Inf, -100, -10, -1, 1, Inf),\n"", "")"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAtAAAAFoCAYAAAB+JswZAAAEDmlDQ1BrQ0dDb2xvclNwYWNl\nR2VuZXJpY1JHQgAAOI2NVV1oHFUUPpu5syskzoPUpqaSDv41lLRsUtGE2uj+ZbNt3CyTbLRB\nkMns3Z1pJjPj/KRpKT4UQRDBqOCT4P9bwSchaqvtiy2itFCiBIMo+ND6R6HSFwnruTOzu5O4\na73L3PnmnO9+595z7t4LkLgsW5beJQIsGq4t5dPis8fmxMQ6dMF90A190C0rjpUqlSYBG+PC\nv9rt7yDG3tf2t/f/Z+uuUEcBiN2F2Kw4yiLiZQD+FcWyXYAEQfvICddi+AnEO2ycIOISw7UA\nVxieD/Cyz5mRMohfRSwoqoz+xNuIB+cj9loEB3Pw2448NaitKSLLRck2q5pOI9O9g/t/tkXd\na8Tbg0+PszB9FN8DuPaXKnKW4YcQn1Xk3HSIry5ps8UQ/2W5aQnxIwBdu7yFcgrxPsRjVXu8\nHOh0qao30cArp9SZZxDfg3h1wTzKxu5E/LUxX5wKdX5SnAzmDx4A4OIqLbB69yMesE1pKojL\njVdoNsfyiPi45hZmAn3uLWdpOtfQOaVmikEs7ovj8hFWpz7EV6mel0L9Xy23FMYlPYZenAx0\nyDB1/PX6dledmQjikjkXCxqMJS9WtfFCyH9XtSekEF+2dH+P4tzITduTygGfv58a5VCTH5Pt\nXD7EFZiNyUDBhHnsFTBgE0SQIA9pfFtgo6cKGuhooeilaKH41eDs38Ip+f4At1Rq/sjr6NEw\nQqb/I/DQqsLvaFUjvAx+eWirddAJZnAj1DFJL0mSg/gcIpPkMBkhoyCSJ8lTZIxk0TpKDjXH\nliJzZPO50dR5ASNSnzeLvIvod0HG/mdkmOC0z8VKnzcQ2M/Yz2vKldduXjp9bleLu0ZWn7vW\nc+l0JGcaai10yNrUnXLP/8Jf59ewX+c3Wgz+B34Df+vbVrc16zTMVgp9um9bxEfzPU5kPqUt\nVWxhs6OiWTVW+gIfywB9uXi7CGcGW/zk98k/kmvJ95IfJn/j3uQ+4c5zn3Kfcd+AyF3gLnJf\ncl9xH3OfR2rUee80a+6vo7EK5mmXUdyfQlrYLTwoZIU9wsPCZEtP6BWGhAlhL3p2N6sTjRdd\nuwbHsG9kq32sgBepc+xurLPW4T9URpYGJ3ym4+8zA05u44QjST8ZIoVtu3qE7fWmdn5LPdqv\ngcZz8Ww8BWJ8X3w0PhQ/wnCDGd+LvlHs8dRy6bLLDuKMaZ20tZrqisPJ5ONiCq8yKhYM5cCg\nKOu66Lsc0aYOtZdo5QCwezI4wm9J/v0X23mlZXOfBjj8Jzv3WrY5D+CsA9D7aMs2gGfjve8A\nrD6mePZSeCfEYt8CONWDw8FXTxrPqx/r9Vt4biXeANh8vV7/+/16ffMD1N8AuKD/A/8leAvF\nY9bLAAAAOGVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAACoAIABAAAAAEAAALQoAMA\nBAAAAAEAAAFoAAAAAPd97vwAAEAASURBVHgB7J0FmBXV+8ffZenubululFCQbvyDCgISIoKA\nCGKAKIIKIhIqyk9F6RBBQEC6uwSU7u5uWOD+53t0hrl3797YvX2/7/PMzsyZMyc+Z3b3nXfe\n854IiyZCIQESIAESIAESIAESIAEScIlAPJdyMRMJkAAJkAAJkAAJkAAJkIAiQAWaDwIJkAAJ\nkAAJkAAJkAAJuEGACrQbsJiVBEiABEiABEiABEiABKhA8xkgARIgARIgARIgARIgATcIUIF2\nAxazkgAJkAAJkAAJkAAJkAAVaD4DJEACJEACJEACJEACJOAGASrQbsBiVhIgARIgARIgARIg\nARKgAs1ngARIgARIgARIgARIgATcIBDfjbwhn7Vbt26ye/dumTRpkmTLlk3u378vdevWlfTp\n08tvv/0WlP0/duyY5M6d22h7oPXJlrnRUDsHGzZskL59+0a7EhkZKUmTJpUcOXJIixYtpGrV\nqtHyIOHDDz+U9evX271mTkyZMqXMmTNHJW3fvl169eplvuzweOrUqZI5c2aHeXiRBEiABEiA\nBEgguAlQgTaN319//SVQ0u7cuaNSHz9+LCtXrlTKtClbUBzeuHFD3njjDbly5YosWrTIaHOg\n9cmWudFQOweXLl1S42HnkpH0/fffy3PPPSf/+9//pFChQkY6Dnbt2uX0fuRLmzYtdkquXr3q\n0j16/nv37umH3JMACZAACZAACYQoASrQDgY2QYIEMmjQIEmRIoWDXIF56fDhwzJt2jSpVauW\nVQODuU96R0qXLi1//PGHfipRUVFy/fp12bFjhwwePFhWrVolL774omzdulUSJUpk5NMPhg4d\nqizV+rntPl686J5NUMaXLFlimzXaeZYsWaKlMYEESIAESIAESCC0CFCBdjCe8ePHlz59+jjI\nEXyXQqFPUIqzZ88eDX6pUqWUYgwL9ObNm5XLxldffRUtX5o0aezeHy2jKQEvHvbqNGXhIQmQ\nAAmQAAmQQJgQCEsF2mKxKOvkn3/+KfhED5/Zpk2bRhvyhw8fypgxYyRZsmTSpk0bq+vwjYWf\n7PHjxyVTpkxSpEgRadiwodXnf/MNhw4dkhUrVsimTZuUTzWUvHr16hlZ4Js8duxYeeqpp6Rc\nuXLy448/ClwWGjduLFWqVJGIiAiV9+bNm6peWFtv374tJUuWlPr160vOnDmNsuB2snjxYnV+\n6tQp5c6QN29eqV27ttj2Ca4eU6ZMMe6N6QAW3XTp0hmXXWmHkVk7cJW5+Z7YHCdOnFj5sBco\nUEBGjBghb731lhWb2JQZl3vgDoQvATt37lTjVbhwYalYsaIa07iUy3tJgARIgARIgAT8SEBT\nbMJKNB9VyzPPPGPRkKtNs8iqvaaEWooXL66ODxw4oJhoyo861yYUWjHSJqOpdJShWSaN46xZ\ns1o05dUqL066dOli5DHn1xRaC9oDuXz5ssrzwgsvWJ5++mkjv6acWzQXBZVn7dq1ljx58qhr\nmkJtSZgwoTrWJr1ZJkyYoPLgx2uvvWbcr/ezefPm6rptnzTFPlpe/R7z/u+//zbKd7Ud+g3u\nMNfvsbfX3DZUW8HHmWgvRSrv3Llzjazay4hK016KjDRnB8uWLVP34NlwV7QJnBY8OzpH89i3\nb9/eor00uVsk85MACZAACZAACQQAgejOntp/+1CWrl27qomCL730kpw+fVpNGJw3b5765P/P\nP/847fqWLVvk888/F1g4NUVSYIk9efKkig5x5swZQflm+eyzz2T06NFSqVIlQfmYZLZu3TrR\nlEBlJbZ1EVmwYIHs2bNH+vXrJ1988YV89NFHAreLs2fPKos16vj6668FlmPUvXDhQmUhf/XV\nV40IE8OHDzcs0LB0496ffvrJ3CzjGJbrvXv3RtvgQ12zZk2Vr1WrVqIpkOrYnXbolcSVuV6O\nO3u4c0DA0lYwkfLRo0d2N1yzJ8iPrxWOtrt371rd+uabb6pnbMCAAepLBb4Y4CtEvnz51NcG\nsx+31Y08IQESIAESIAESCGwCAaDE+6wJWoQNZQ3UlF+LphBZ1Tt//nzDUujIAq0pryqfNrnQ\n6n6UpynlFs3Vw6JFvlDXNAVd5dV8bi3Xrl2zyq990rdok9UsmluEsjDrFmjtabH8/PPPVnlx\n0q5dO1WWNgEu2jXtBUBd01w/jGtadAuVpk0iNNJwYGuBtrpoOnn//ffV/Zr7iGElx2V32+Eu\nc1MToh26Y4HWXnJU+9u2bWuUo1ugwTimzda6rVugY8pvTn/vvfeMunCQOnVqixZez/iCoF9E\nPzR3H8v48eP1JO5JgARIgARIgASCiEBY+UAjZBqkY8eOYhtpAX7EmnuEHD16VOWJ6YduiYV/\nbcaMGaVJkybKpxnl/frrr1a3wU8ZAgtuqlSprK6VKFFCWX0RbxoWZrPA79lWYCWHH3SHDh1s\nLynfZkyMQ9QJTVEXTXGLlsedhB9++EGGDBmi/LFnzZplFcnC3XZ4grk7bdfzIjIHBL7ltoI4\nzbbjoefJlSuXfmi1T5IkifI3t0q0OTH7oeMSxnj16tXSunVrFUsavu14Tho1aqQ2m9t5SgIk\nQAIkQAIkECQErDW3IGl0bJuJiVwQTKizJ/nz53eqQGPCYcuWLQULZkAR79Spk5QtW1ZN5MNE\nu6JFixpFY6IhBBMD7QncQGwFyi8WbjELlGJMKMSCIZgIaE90hfHgwYNSvnx5e1lcSsPESrhc\nQCHXrPJWbYlNOzzB3KWG22SCCwoEL0W2ArcazU/cNtnhOdwuECPcHYGrD16G8GKFDZMw69Sp\no5RnpGPxFwoJkAAJkAAJkEDwEQgrH+jz58+rEcJKc/bEVnG1lwfW4smTJ6sNUTQQUg1+0fBz\nLVasmLI0wl8WcuLECbWPydqpLtr8MEe60C/p7dYmDSoLJqyYthuiO0BxRtSH2AoU/pdfflmV\nPXPmTClYsKBVUbFph35PXJhbNcLFE12BjullycVi4pQN0VO2bdsmvXv3FrycaW46KuIJXsAQ\ntUV/wYpTJbyZBEiABEiABEjA5wTCygKNkG8IPYdJf/bk3Llz9pKjpcGV4pVXXlEbJgXiMz0m\nhCHkHVw7MGFQi3ohujsAJv7ZEyiXUCzhHuBI4BqAOqGsI76xNwTKfoMGDeTWrVvyyy+/SPXq\n1aNVE5t2eIp5tMY4SIDyDHcWMKtcubKDnN6/BAs4Fm7BduTIETXpExM64d6D0IhYHZFCAiRA\nAiRAAiQQXATCygINH1TImjVroo0SFGFXonDA+ozP/7p/M+IOw61i1KhRKuYwCoZCDYHVEWJP\n6YXLBVw/8BkfMaIdCRRsKK9wodB9is35Hzx4IIj4oIXXU1ZO8zVXjrGKH5RnRNj44IMPRAux\nZve22LTDE8ztNsZB4jvvvCNggrjcsMz7QxB/GywRRUUXWMMxTojRjXHfvXt3rMZLL497EiAB\nEiABEiAB/xAIKwUa1khM/Js0aZL6tG5GjhXrLl68aE6ye4ywaLDQmhUjPSMWVYHA6gqBApcj\nRw7RYhEbIebUBe0HfGIRRg+f8uFf60y6d++usmBhEFs3jU8++USFypsxY4axkAsUe4izPkGR\nb9asmbKEwrUAS5c7Enfb4QnmjtqjX4PCjBcgWP7xlQH979+/v37Z53u47SDcIPytYQ03y4UL\nFwQh7/Bs2HPZMeflMQmQAAmQAAmQQOARCCsXjrRp08rs2bOVe8Kzzz4r3bp1U1ZiLVSZUmgR\nncGZG4e2KIpy1UA0igoVKiglGZZZWBVRDj7ZIzIHBOlw6UDM6Ro1agjuLVSokGCiHjZtYY0Y\n4zPbPipQnLFiIGJIly5dWrRwcpIiRQo10W/JkiUC/+jvv/9euS3gXkT3gJ80LOWoG24ln376\nqW2xKtY02g3fbiidWtg3FblCiyRjlVdb4EVNnnS3HZ5gbtUQ7QS+w7p1H9cQXxnjprcZ3OFS\nAwu/p2T//v1WdcZUbo8ePdRzhbHp1auXeiHBFwpEecEEVLQdzw7airwUEiABEiABEiCBICQQ\nRCH3PNZUxOHFSnVaVAtoiRas5Kcto23R/JrVuaM40GiEppRann/+eZUX92PTlDYL4gxr0TKi\ntVNzGbForgRW+bVoHZbly5cbefU40FrEDiPN9gAr+r377ruW5MmTW5WlTR60aAt02Ga3IGY1\n+ob2aYq9um4bB1pTiK3K0vtju9cWfDHKd7cduNFV5kYldg5Qhm27cI4V/jQXF7XCpGbxtWi+\n5XbutqjxQf7YrERor157aQMHDjTq1hZlsWgvLRbtJcKq3Wir5gpk5OMBCZAACZAACZBAcBGI\nQHM1RSAsRVvwRDDBD24UsNa6K7gfbhuw/sKyjDBzjgSr2CHMXPbs2UVb9ttRVofXMGTaMtHK\nPSN37tzKLSWmG5AXriKIMKK7dcSU1910d9qhlx1X5no5wbSHmwwmrsJ1A5Zzum0E0+ixrSRA\nAiRAAiQQnUBYK9DRcTCFBEiABEiABEiABEiABBwTcN/s6rg8XiUBEiABEiABEiABEiCBkCZA\nBTqkh5edIwESIAESIAESIAES8DQBKtCeJsrySIAESIAESIAESIAEQpoAFeiQHl52jgRIgARI\ngARIgARIwNMEqEB7mijLIwESIAESIAESIAESCGkCVKBDenjZORIgARIgARIgARIgAU8ToALt\naaIsjwRIgARIgARIgARIIKQJUIEO6eFl50iABEiABEiABEiABDxNgAq0p4myPBIgARIgARIg\nARIggZAmQAU6pIeXnSMBEiABEiABEiABEvA0ASrQnibK8kiABEiABEiABEiABEKaABXokB5e\ndo4ESIAESIAESIAESMDTBOJ7usBALW/Tpk3SpUsXSZ48eaA2ke0iARIgARIggYAgkDRpUlm4\ncGFAtIWNIIFAJBA2CvTjx4+lVq1aMmTIkEAcB7aJBEiABEiABAKCQFRUlNStWzcg2sJGkECg\nEqALR6CODNtFAiRAAiRAAiRAAiQQkASoQAfksLBRJEACJEACJEACJEACgUqACnSgjgzbRQIk\nQAIkQAIkQAIkEJAEqEAH5LCwUSRAAiRAAiRAAiRAAoFKgAp0oI4M20UCJEACJEACJEACJBCQ\nBKhAB+SwsFEkQAIkQAIkQAIkQAKBSoAKdKCODNtFAiRAAiRAAiRAAiQQkASoQAfksLBRJEAC\nJEACJEACJEACgUqACnSgjgzbRQIkQAIkQAIkQAIkEJAEwmYlQn/Rv3PnjmAVRF3ixYsnWCKV\nQgIkQAIkQAIkQAIkEJwEaIH28riVKlVKUqRIYWw4p5AACZAACZAACZAACQQvASrQXh67ypUr\nS5EiRVQt2OOcQgIkQAIkQAIkQAIkELwEqEB7eezGjh0rvXr1UrVgj3MKCZAACZAACZAACZBA\n8BKgAh28Y8eWkwAJkAAJkAAJkAAJ+IEAFWg/QGeVJEACJEACJEACJEACwUuACnTwjh1bTgIk\nQAIkQAIkQAIk4AcCVKD9AJ1VkgAJkAAJkAAJkAAJBC8BKtDBO3ZsOQmQAAmQAAmQAAmQgB8I\nUIH2A3RWSQIkQAIkQAIkQAIkELwEqEAH79ix5SRAAiRAAiRAAiRAAn4gQAXaD9BZJQmQAAmQ\nAAmQAAmQQPASoAIdvGPHlpMACZAACZAACZAACfiBABVoP0BnlSRAAiRAAiRAAiRAAsFLgAp0\n8I4dW04CJEACJEACJEACJOAHAlSg/QCdVZIACZAACZAACZAACQQvASrQ/41dVFSUFC1a1Gp7\n++23A3JkX3nlFUmSJImxJU2aVB48eBCQbWWjSIAESIAESIAESCDUCMQPtQ7FpT8nT56U+/fv\nK2UUSumlS5fiUpzX7s2SJYvkyJFDDh48KOnTp5ds2bJJRESE1+pjwSRAAiRAAiRAAiRAAk8I\n0AL9H4sECRLIjRs3pEuXLipl+fLlMmnSpCekAuho2LBhRttatWolO3bsELQ/LjJhwgSpUaOG\n1QYFnUICJEACJEACJEACJGBNgBZoax5he3bkyBHBS4NZ8EJBIQESIAESIAESIAESsCZAC7Q1\nj7A969evn+Gy8txzz8mdO3ekTJkyYcuDHScBEiABEiABEiCBmAjQAh0TmTBLjx8/vpqUiG5H\nRkYax2GGgd0lARIgARIgARIgAacEaIF2iogZSIAESIAESIAESIAESOAJASrQT1jwiARIgARI\ngARIgARIgAScEqAC7RQRM5AACZAACZAACZAACZDAEwJUoJ+w4BEJkAAJkAAJkAAJkAAJOCVA\nBdopImYgARIgARIgARIgARIggScEqEA/YcEjEiABEiABEiABEiABEnBKgAq0U0TMQAIkQAIk\nQAIkQAIkQAJPCFCBfsKCRyRAAiRAAiRAAiRAAiTglAAVaKeImIEESIAESIAESIAESIAEnhDw\n+0qEN2/elHXr1gn2FStWlJw5cz5pnZ2jx48fy4YNG+Tw4cNSvHhxKVmypMSLx/cAO6iYRAIk\nQAIkQAIkQAIk4AUCftU8jx49Kk2aNJEZM2bIrl27pEOHDrJx48YYuxkVFSXvvfeeDB8+XM6c\nOSMDBgxQ90CpppAACZAACZAACZAACZCALwj41QI9ePBgady4sfTo0UMiIiJk/PjxMmLECJk2\nbZo6twWwePFi2b9/v4wdO1bSp08v9+/fl+bNm8uyZcukVq1attl5TgIkQAIkQAIkQAIkQAIe\nJ+A3C/Tly5dl7969ygIN5RnSsGFDZVnes2eP3Y7OmjVLKcxQniGJEiVSyvQzzzwTLf+5c+fk\n5MmTxnbt2rVoeZhAAiRAAiRAAiRAAiRAAu4S8JsFGgouJGvWrEab06VLJwkTJpQLFy5I0aJF\njXT94MSJEyo/LNV//fWXpEmTRlq3bi358uXTsxj7jh07ysGDB43zwoULS8GCBY1zHpAACZAA\nCZAACZAACZBAbAj4TYE+e/assiDDimyWFClSyNWrV81J6vjOnTty9+5d5eaRIUMGqVKlinLd\neOONN+Tnn3+W3LlzW91TvXp1KVSokJGGeh4+fGic84AESIAESIAESIAESIAEYkPAbwp0ggQJ\n7Cq0jx49kqRJk0brC9IhyZMnV37SOIb/c7NmzWTKlCnSt29fJBnyzjvvGMc4QOSO2bNnW6Xx\nhARIgARIgARIgARIgATcJeA3BRp+zFCKYVk2K8w3btyQLFmyROsHLNOwIlerVs24Bt9p+D8j\nmkcoSeZ5C512J+rAfpXnpyPHZJoL+c81rOu0TGYgARIgARIgARIgARJwTsBvCnT27Nklfvz4\nsnv3bilfvrxqKSYVIiSd2S/a3IU8efKI7jutpx85ciSa+4Z+zXb/cO0audW2lW2y1fmDzdvU\n+Z0BH8utDP9OVrTKYHOSfPxkm5TAPF3c1nm77v3n4XJZm8PpSv7a452XyRwkQAIkQAIkQAIk\nEGoE/BaFI1WqVFK7dm0VRePWrVty7949GTNmjNStW1fg4wxZvXq1LFiwwGDesmVLmTt3rmzd\nulVZrxHWDhE7nn/+eSMPD0iABEiABEiABEiABEjAmwT8ZoFGpzp37qwWQ2nUqJFyz8Cqgt27\ndzf6u3TpUhXWrl69eioNijIidPTp00csFoskSZJEevXqZViwjRt5QAIkQAIkQAIkQAIkQAJe\nIuBXBRph6EaOHCnwe46MjJRkyZJZdXPgwIFW5zhp0aKFvPjii3Lp0iXJmDGj3QVXot3EBBIg\nARIgARIgARIgARLwEAG/KtB6H1KmTKkfurSHsp0pUyaX8jITCZAACZAACZAACZAACXiSgN98\noD3ZCZZFAiRAAiRAAiRAAiRAAr4iQAXaV6RZDwmQAAmQAAmQAAmQQEgQoAIdEsPITpAACZAA\nCZAACZAACfiKQED4QPuqs96op9vEBE6L3bPhscozeUMn2Z6ws9P8kmau8zzMQQIkQAIkQAIk\nQAIk4BcCtED7BTsrJQESIAESIAESIAESCFYCVKCDdeTYbhIgARIgARIgARIgAb8QoALtF+ys\nlARIgARIgARIgARIIFgJUIEO1pFju0mABEiABEiABEiABPxCgAq0X7CzUhIgARIgARIgARIg\ngWAlQAU6WEeO7SYBEiABEiABEiABEvALASrQfsHOSkmABEiABEiABEiABIKVABXoYB05tpsE\nSIAESIAESIAESMAvBKhA+wU7KyUBEiABEiABEiABEghWAlSgg3Xk2G4SIAESIAESIAESIAG/\nEKAC7RfsrJQESIAESIAESIAESCBYCcQP1oaz3SRAAiRAAiRAAqFF4OLFizJ//nxZunSpZMmS\nRVq1aiVXrlyRdevWyUcffaQ6O3r0aMmYMaPkyJFDvvvuOylcuLC89tprkiFDBnV9y5Yt8uuv\nv8rRo0cld+7cUq9ePalZs6YBas+ePep6mzZtJF++fEb6yZMnZcyYMdK0aVMpXbq0HDx4UCZN\nmiRvvvmmLF++XBYvXixp0qSRBg0aSLVq1SQyMtK4lwfhR4AW6PAbc/aYBEiABEiABAKOAJTn\ncuXKSffu3eXWrVuyYcMGqVSpkvTp00c+//xzo70//vijjBo1Sho2bKgU3A8//FAePHigrn/2\n2WdSsWJFmTVrllJwFy1aJLVq1ZLOnTsb9+/du1cGDhwohw4dMtJwcOLECZW+Y8cOlQ4FGvna\nt2+v2oTEXbt2KWX83XffVXn4I3wJUIEO37Fnz0mABEiABEggYAi0aNFCbt68Kdu2bZPZs2fL\n2rVrZeTIkbJ58+ZobVy5cqXAggxFGxblbNmyyfr166V///7y8ssvy759+2T69Onyzz//SK9e\nveSHH35QVudoBbmQsHXrVoFVe+zYscoKPWjQIBkxYoRS0l24nVlClAAV6BAdWHaLBEiABEiA\nBIKFwKVLl5SbBKzPBQoUMJrdqVMnKVWqlHGuH8SLF09ZpZMkSSIFCxZUyb/88ouyOn/99deS\nIEEClRYREaHyweUDVuvYyNtvvy158uQxbn3nnXckffr0MnPmTCONB+FHgAp0+I05e0wCJEAC\nJEACAUXgr7/+Uu2xpyyXKVMmWlvh/5w4cWKrdLhm5MqVS/lHmy8gX8mSJZVV2pzu6jFcQsyS\nMGFCKVSokGzfvt2czOMwI0AFOswGnN0lARIgARIggUAjAP9nCJRTW4GV2VbSpUtnmySXL1+W\nlClTRktHQvLkySUqKsruNT3x0aNH+qHVPnXq1FbnOEmaNKlcv349WjoTwocAFejwGWv2lARI\ngARIgAQCkoAeDePIkSPR2mcvLVomLeGpp56S48eP27skx44dM1xB9OgZtgo1JhHak1OnTkVL\nRj32LOPRMjIhZAlQgQ7ZoWXHSIAESIAESCA4CEAZRcg5TPYzK7aYDLhkyRKXOlG5cmVlhZ4z\nZ45VfrhaILIGQtNBdIsyXD7MglB19mTatGlWyZjUuH//fqlQoYJVOk/CiwDjQIfXeLO3JEAC\nJEACJBBwBDDpb+jQoYJIHFWqVJF27drJtWvXVLQLXLNYLE7b3LNnT0GIO9z71VdfqRB4CDuH\ndEwCxOQ/CBRfKNEIjYe4zrBc//777zJv3jy7dSCmdM6cOaV169Zy+PBhFdIOCj+ie1DClwAt\n0EE49nfm/SG3pk5WLb+//S+5PmKYWGLw3QrC7rHJJEACJEACYUigefPmahEVTPpD7OcpU6bI\np59+KnXr1pVkyZI5JQJfaSy4Aks0oncUKVJExXAuXry4rFixQrJnz67KgP/yjBkzlL808tWo\nUUM2bdqkFm+xV0nfvn1V/hIlSkjLli0F5c2dO1f5QdvLz7TwIEALdBCO84O/d8qDrVtUyx+d\nOinYUnbrLlr8niDsDZtMAiRAAiQQ7gQwgQ8rAWLRkzp16ljhgCKNsHG6OIp+gXjQsCTfvXtX\n+T3Dt1oPaaffjz2UZtQH32hMMNTLt2fpLlu2rGCBFqxsiHB4rijz5rp4HJoEqEAH4bim6NxV\nkrdtb93y+P/GvLRO5BkJkAAJkAAJBD4BxHUuVqyYsh5j9UBdsJjKmjVr1FLdepore1ijscS3\nM4HftatijgXt6j3MF7oEqED/N7aPNf+q6UePyYH/wtIsOX1G7j9+LFUyZQy40Y9Mm1ZrEzYK\nCZAACZAACQQ/ASx4guW2hw0bJuXLl5fnnntOsJQ2XC/gOjFkyJDg7yR7EFIE6AP933A+1JTl\n19dukGVnz6mUwX/vktF794XUYDvqzJbTC+THrf9OsDh944B8v/ktuXD7pKNbeI0ESIAESIAE\nPEbgyy+/VApzzZo11TLecL3A0txLly6VtMpw5LGqXCoI7iCtWrUSLNpCIQFbArRA/0ckvvb5\naFiFclZ88qZIbnUeyif7Lm6S+Qf+p7p46c4pmbPvW6n1VFvJmIx/OEJ53Nk3EiABEggUAnDj\nqFatmtoCoU1YvXDSpEmB0BS2IQAJUIH+b1DiaZ+POhUqEIBD5Jsm1S/QSSpmb2hVWY5Uzv3H\nrG7gCQmQAAmQAAmQAAmEAQEq0GEwyK50MV3SrIKNQgIkQAIkQAIkQAIk4JgAfaAd8+FVEiAB\nEiABEiABEiABErAiQAXaCgdPSIAESIAESIAESIAESMAxASrQjvnwKgmQAAmQAAmQAAmQAAlY\nEaACbYWDJyRAAiRAAiRAAiRAAiTgmAAnETrmw6skQAIkQAIkQAI+IHCrbSsf1PJvFcnHT/ZZ\nXawoNAnQAh2a48pekQAJkAAJkAAJkAAJeIkAFWgvgWWxJEACJEACJEACJEACoUmACnRojit7\nRQIkQAIkQAIkQAIk4CUCVKC9BJbFkgAJkAAJkAAJkAAJhCYBKtChOa7sFQmQAAmQAAmQAAmQ\ngJcIUIH2ElgWSwIkQAIkQAIkQAIkEJoEqECH5riyVyRAAiRAAiRAAiRAAl4iwDjQXgLLYkmA\nBEiABEiABEKHwIULF2TdunWydu1auX37tpQoUUJeeOEFyZIlS1B1cuXKlbJq1aoY2/zuu+9K\n0qRJY7zOC/8SoALNJ4EESIAESIAESIAEHBBYtmyZNGjQQAoWLCgVKlSQePHiybfffiv9+/eX\nKVOmSK1atRzcHViXVqxYIUOGDJHKlSvbbViPHj2oQNslY51IBdqaB89IgARIgARIgARIwCCw\nefNmadq0qQwaNEh69uwpERER6trDhw+lU6dO0rFjRzl8+LDEjx88KlWmTJkELwWU2BMIntGO\nfR95JwmQAAmQAAmQAAnEisDAgQOlatWq0qtXL6v7oTB/8cUX8tZbb8nZs2clR44c6vrcuXNl\n1qxZcvz4ccmWLZu0bNlS6tWrp65t3LhRYAGuVq2a/PDDD3Lr1i1p27atuj506FBZv369uta+\nfXtJmzatuJsfldy/f1++/vpr2bJli9y4cUNZzd955x3JlSuXaoMrPxYsWCCzZ8+Wzz//XNKn\nT69uGTFihHJd6devn4waNUry5Mkj+/fvV4p4sWLFpF27dlK4cGFXig+JPJxEGBLDyE6QAAmQ\nAAmQAAl4gwCU2JhcNDJmzCjTpk0zlOfvvvtOXnnlFcmbN69SjO/cuSP169dXyizadvDgQRk2\nbJiyXJcqVUoSJEggzZo1k7p168qOHTukTp068s033ygXi9jkxz0oA22qUaOGUsyXL18uzz//\nvDx+/BiXleAYfty2G5RvCF4YYKHGywEELwXvvfeeKgfnixYtUgrzr7/+Ki1atJBdu3ZJ9erV\n5fTp07gcFkILdFgMMztJAiRAAiRAAiTgLoFDhw7J5cuXBRZWs/z2228SFRVlJGFCIfJgoqGu\nIOMilOkMGTIoS3L58uVVfpS3ePFiKVOmjCpjzpw5AkV76dKl6rrFYpHvv//eUKLdyY+8UOpH\njx5tWIPhtw0l/uLFiwLXDcipU6ckefLk6tj8o0mTJsryjGuTJ0+WKlWqSM2aNeWDDz6QAQMG\nSKVKlYzsDx48UJMqYYlv06aN5MuXT7m54CUiHIQKdDiMMvtIAiRAAiRAAiTgNgG4L8Dn+cyZ\nM1b3fvzxx0rpRSKu4RwKNJRMuHP8/vvvsm/fPtm5c6fcvXtX7t27Z9wPhbNkyZLqHBZouH7A\nAq0LFG6UoYs7+dOlSyfTp09X1uxx48YpF4vVq1erotAOXTJnziwLFy7UT419ypQpjeOKFSsK\n3DVee+01Zc2GEm0WKNZomy61a9eWbdu26achv3/Scze6OnPmTPWGBf8eDAjelmzl6tWrtkk8\nJwESIAESIAESIIGgIZA6dWopUqSIcsGAr7Iue/fu1Q+Vu4Z+MnLkSGWtLV68uIpy0bx5c9mw\nYYN+We1TpUolkZGRRhoUdLPiqk9S1DO4kx+KOiY8wpca1mJE2mjVqpU618vDPmHChIYSb063\nPUb/IWZru54nd+7c+qHaw2cbLiHhIm4r0BiUl19+WZIkSaLg41OB7WCHCzz2kwRIgARIgARI\nILQJIHzdjz/+KJjYV7ZsWavOwoCIaBwQGBTff/99+eqrr6R79+4q7dGjR8q9wex/rC546Qcm\n/sF3+ciRI4ZfNtIg7rZh9+7d6mUAEwY/+eQT+fLLL9W53nT4VptlyZIlyi3FnBbKx24r0PD7\nSZw4sfz111+SP3/+UGbDvpEACZAACZAACYQ5AUSiOHbsmJpI+NFHH6kJdsmSJVPuCrA4nz9/\nXgoVKqTcGeBCce7cOaWswhqMRUkwMc/swuFNnHDNgNKONsE1BJ4CH374oarS3AYcr1mzxm5T\nEEkDFnFYrhs1aiRdu3ZVEUFggccExdKlS6v74J4yduxYNYkQkxYxCXLw4MF2ywzFRLcVaPjl\nlCtXjspzKD4N7BMJkAAJkAAJkIAVAfj5YkId/JunTp2qolHA6gyXBUS3gPKICXQQWGmxuApC\n1GGSXZcuXZSCuX37dqsyvXWC8HgdOnRQPstYTRA+1giP17lzZ0Eb4I4CwWTHZ5991m4zZsyY\nIZs2bVK+3bAqQxCKD77VUKp1P2fUhZcLlA1fcUxcBI9wkQjt80N0B2YHvcenCcRExBtWMC31\nCB+kGb3fkQH58jjonfuXPqg53elNe1Y9lhU/P5bqr8WTIs/Fc5p/Rpq5TvO4m2HCb08mKLh7\nb0z5a4+P6QrTSYAESIAEgpUA/F0xqc3XC23catvKZ8iSj58c67rg53vt2jUV4zmmQhDlAtZg\n8yS7mPJ6Ix3K+6VLlyRr1qzeKF5ZpmHhRrQQhK5DPeHmzutcm7NBj0DZAAV/GAwQhQRIgARI\ngARIgATChQDcN7BAiiPJnj2735RntAuTBL2lPNv2GyzCTXkGA7ddOLCCDkKs4JMAgn3jIcHD\nZCvwjaGQAAmQAAmQAAmQAAmEFgFE50iRIkVodcrN3ritQCM8HRzi9YDgbtbH7CRAAiRAAiRA\nAiRAAkFMYOLEiUHces803W0FulOnTmoJSs9UH/ql3L1hkft3/nUzxx7nSVJGhH7H2UMSIAES\nIAESIAESCFECbivQOgfMQF25cqVa5QYTDrCmOzY96LaeL9z3Mz99JNfP/0th/VSL7F7+SFoP\njTX2cMfJ/pMACZAACZAACZCA3wnESpNDCBNMJty1a1e0DgwaNEj69OkTLT2mhJs3b6q11LHH\nspE5c+aMKWu0dMSkRjxCPXxMtAwBkJCzeITczvGkIcn+XdTnSQKPSIAESIAESIAESIAEgoqA\n2wo0Qrc0adJErbwzfPhwpfQmT55cBRn/5ZdfpG/fvmqhlZ49ezoFcfToUbXGet68edWMVsRN\n/Oyzz+Tpp592eu/cuXPVJEYECA9kBfrZVyOd9oUZSIAESIAESIAESIAEgoeA2wr0Tz/9pOIf\nYiXCAgUKGD0tUaKENG7cWN544w0VTNsVBRor1uCeHj16qBAo48ePlxEjRqig5I5CoiC+IpbV\nRIBwCgmQAAmQAAmQQPATiEts5uDvPXsQbATcjgON8HRYfcasPJs7jUmGBw8eVCvYmNNtjy9f\nvix79+5V1mxdWW7YsKG6b8+ePbbZjXP4Xn/66aeCJSWTJEkSlrEHDRg8IAESIAESIAESIAES\n8DkBty3QkZGRDhdQ0RdXwVrsjgQrGULMgb6xhjyCf2OJyaJFi9q9HVZqrIDYrFkztQa73Uxa\nYvPmzZUir1+Hwu+6d7V+F/ckQAIkQAIkQAK+INBtou++Ko9qE+WLLrGOECbgtgW6XLlysmrV\nKtm8eXM0LFgVHOvAY010LPHoSM6ePSuJEiVSmzkfAnMj1rQ9waTF2bNnKz9r3WptLx/SsIQm\nJiTqG6ODxESK6SRAAiRAAiRAAiRAAu4QcNsC3bFjR8HkQbhxvP7661KhQgVJmTKlmkQ4btw4\ngW80JhM6E/gvwx3DVmC5hoXZVu7cuaNcN+AvjZUQncmoUaOssmzYsEFm9H7HKo0nJEACJEAC\nJEACJEACJOAuAbcVaPgdr1u3TkXPwFLeZkmTJo1899130r59e3Oy3WNYqaEsQzE2K8w3btyQ\nLFmyRLvnjz/+kEuXLsmSJUvUhgy3b9+WX3/9VQ4dOiRdu3aNdg8TSIAESIAESIAESIAESMDT\nBNxWoNEA+C0vWLBAEA0DEwExIfCpp56SwoULC0LauSLZs2eX+PHjy+7du41lwVHW48ePrfyi\n9bKKFCkir776qn6q9lu3blV5c+fObZXOExIgARIgARIgARIgARLwFoFYKdB6Y6AEY4uNpEqV\nSmrXrq0mAkLxhjI9ZswYqVu3ruGisXr1amVlrlevniBMHjazTJ8+XapWrSp16tQxJ/OYBEiA\nBEiABEiABEiABLxGwO1JhJ5sSefOnVXUjUaNGknTpk2VEt29e3ejiqVLl8rMmTONcx6QAAmQ\nAAmQAAmQAAmQgL8JOLVAnzlzRlmKK1WqpBYvgY/z6NGjnbbb3jLftjfBZ3rkyJECv2eEx0uW\nLJlVloEDB1qd257Mnz/fNonnJEACJEACJEACJEACJOBVAk4V6Hjx4im/5sSJE6uGIE6zq37O\nrrYcUTwoJEACJEACJEACJBBoBBAwwRxeFy6ocF/FSsrQiXT5559/1Pyw9957T0/y6R7rcGAe\nma6v+bTyMKzMqQKNeMobN2400CB0HTYKCZAACZAACZAACYQ6AXwph2KKYAlY7+L8+fMqdG/a\ntGkFc7GeeeYZhQAK9FdffSX+UKCh4KMdiFgW00rRoT5Ovu6f2z7QEyZMcPhwYKGTXLlyyd27\nd33dF9ZHAiRAAiRAAiRAAh4n0KpVK1m2bJksX75cRQ87fvy4CrnbunVruXXrlqrvlVdeUSsp\ne7xyFwq8du2a7N+/34WczOIpAi4p0BcvXpTTp0+rbfv27SoOtH5u3h89elT+/PNPOXHihNy7\nd89TbWQ5JEACJEACJEACJBAwBLCWBay9R44cURHE0LBNmzbJ22+/bbQR+hLWxahRo4b6cm+7\ngvOWLVukV69eyhXk22+/VZZt3Iy1Nr744gtl3YabCKzckB07dqhyEMEM9WCOGgRrYvTp00cd\n9+vXz1grA/PLcI7oZm3atFEvACoTf3iEgEsK9NixY5W/D3x+8Clj/fr1xrkeyg77vHnzyk8/\n/SSlSpUSTBCkkAAJkAAJkAAJkEAoEoCLK9ahgOsGBIu6TZw4UR3DzQMrNsMfGW6vERERUrly\nZdm3b5+6DmUbijUU8BdeeEF+//13adasmbp24MABGTFihHz44YeSOnVq9UUflm+4aMDa/eKL\nLyplHaF9oUQjDHDJkiXVvcWLFxe0C0p12bJllU92kyZNVJ4GDRoY7VOZ+SNOBJz6QKP0nj17\nqmW3o6KiZMWKFYJPF+3atYtWMQYRijMGl0ICJEACJEACJEACoUygTJkyAoXXVhCJDCstDxgw\nQDJmzCgvv/yyWmwOPtSQ3r17q8XhRo0apc4Rzvell14yFOwLFy4o5RflQ7DHmhhTp05V51DK\nkTZo0CBBGS1atJC+ffuqeuADPXjwYDl79qxgwTlMeuzSpYvyjX733XcFbidQ6ClxI+CSAp0g\nQQI1MKiqUKFCsmfPHunfv3/caubdJEACJEACJEACJBDEBOAmAQXVVipWrKgmHebPn1+FAoby\ni9WU06VLpyYiwh0DSrQucAmBlRmyYcMGSZQokfqaj/P79+/Lzp07lc/1Bx98gCQlCP8LBdme\nwF0Elmgo0rrA5RaWcawinSNHDj2Z+1gScMmFw1w23qKgPMNVY/HixcYlLHiCzxVY4ptCAiRA\nAiRAAiRAAqFMANZkTNxDdA5bQbhfKLFQYGGJfvPNN5WbK77iw70Crhi2a1+Yy4DrBsIIQ6Ck\nIwoIykSavtWqVctw+zDfi2NE5UiaNKmRF/dAaYavtF6u7T08d4+ASxZoc5Fw4yhfvrx6G8Ki\nKnBmh+BNCA7x8LGZNGmSYDYqhQRIgARIgARIgARCkQB0nZMnTyqXCNv+wa0DOhEUZ2xQgqEv\nwd0CBke4dUD5rlmzproVCjJcOMyrMetlZsiQQbBeRtasWZXLhp4OIyY8BCC6S4buIpIvXz5l\n5Pzss88Mhfnw4cNqgiLKo8SdgNsW6JUrVyqH+Xnz5qmHQm8CluLGg4Q3IswqxcNAIQESIAES\nIAESIIFgJwD9Zs2aNbJ69WqlAMOS27lzZ2nbtq0yKtrrH+aKzZgxQx49eqQUaFiFdWs1fJgR\nMxpKMBZAQRSOtWvXxlgWfJgxQRGRP1Ae2oHJgZcuXVJVIyY1ZNu2bXL9+nV54403lKsGfLBR\nL/yhEYoPupt58Rd1E3/EioDbFug5c+bIc889pyzNtjViABFapX79+oKQdvqDYpuP5yRAAiRA\nAiRAAiQQLASgvOoRNuDzjKhjn3/+uV2LMfqEiXxQkBFGDoo0/Jih8OIcgggbCBEMfQlWZEwI\nRMQzuF3YE7jOwu2jefPmKqJGpkyZBBMC9aANsFAjXB2UZBgxhw0bJpMnT1Y62ZAhQ5RPNazd\nUNQpniEQoZn7/50S6mJ53bp1k4MHD8qiRYvs3oHQLE8//bSKBR1ITupwyp/R+x0ZkC+P3XbH\nNvGDmv/GZ4zt/fbum5Fmrr3kOKVN+K1unO63d3Pt8fZSmUYCJEACJBDMBOCqCWUMC4f4UrpN\n/NcdwRd1jmoT5YtqVB3nzp1T4ejsLbENxRqLoEAhdkUwNpgIiNDB9uTmzZtKCYdbrS6YPAi3\nDVqedSKe2bvtwlG9enUVyg6Bvm0FbhtDhw5Vvj2BpDzbtpPnJEACJEACJEACJOALAoiGYU95\nRt2ItuGq8oz8sFbHpDzjeooUKdScNBzrki1bNirPOgwP7t124ahTp44gPEs1LeIGHN6xaAoG\nDG848PVBkHB8NqCQAAmQAAmQAAmQAAmQQCgScFuBRhiVJUuWSKdOnQT+0FOmTDG4wOqM85Yt\nWxppPCABEiABEiABEiABEiCBUCLgtgKNzuNTxIQJE1QwcEwWhPU5T548gs8EeiiVUILEvpAA\nCZAACZAACZAACZCATsBtH2j9RuyhLGMmatWqVZVPDs4xJxGhXigkQAIkQAIkQAIkQAIkEIoE\nYmWB/uWXXwSLqGCtdswIhUBxfvjwoWAGKNLcDO4RimzZJxIgARIgARIgARIggRAk4LYCDety\nx44d1SxPTCZENI6yZcvKvXv3VHg7LBE5evToEETFLpEACZAACZAACXiLgC9Dy3mrDyw3fAi4\n7cKBVWygJMP3GavmFClSREXj2LVrl+zevVuFYzHHHwwflOwpCZAACZAACZAACZBAOBBw2wKN\ntdSfeeYZIw5h6dKlZePGjYoV1l7Hijc9evQQLFNJIQF/EcAKUHv37jWqRwB5fhkxcPCABEiA\nBEiABEggDgTcVqDTpEmj1nTX6yxYsKDAJ1qXSpUqKd/oU6dOGUq2fo17EvAVgT///FMt+KPX\nlyRJEirQOgzuSYAESCAACWSet9BnrTrX0POr8/qs8awoIAi47cJRqFAhwbLYWEoSAheOY8eO\nqaW7cQ43Drh4YLUcCgn4i8C4cePkxx9/VNV37dpVtm/f7q+msF4SIAESIAESIIEQI+C2Av3q\nq68KrHn58+eXVatWyfPPPy/JkiWTZs2ayaBBg6Rbt27KxcOdpSlDjCm7EwAEcubMKdggGTJk\nEHwpoZAACZAACZAACZCAJwi4rUBDGZk1a5bA9xmRN+DSAd/SHTt2yIcffignT55UPtCeaBzL\nIAESIAESIAESIAESIIFAI+C2D/TFixcld+7cyvqsx3pu06aN1K5dW30mL1q0qGBJbwoJkAAJ\nkAAJkAAJkAAJhCIBty3QP//8s/o0vn//fqtlu+GyUbduXSrPofiUsE8kQAIkQAIkQAIkQAIG\nAbcVaD00GK3MBkMekAAJkAAJkAAJkAAJhBEBtxVoRDRIly6dfPTRR8oHOoxYsaskQAIkQAIk\nQAIkQAIkIG77QGOSIPychw8fLiNHjlQuG1CobWXbtm22STwnARIgARIgARIggaAkcOHCBVm3\nbp1ahfn27dtSokQJeeGFFyRLlixB1Z+lS5eqfuiNRmS19OnTS506dSRbtmx6svzzzz+yYMEC\nee+994w0Xx48ePBAHj9+LIkTJ/ZltS7X5bYFGpMIr127JqVKlVIPD6JwoIO2m8stYEYSIAES\nIAESIAESCGACy5YtU/O/PvnkE7WYHIIofPvtt0oPWrJkSQC3PHrToEBj1ejVq1erbcaMGfLB\nBx/IU089JYMHDzZugAKNVX39IVevXlVsT5w44Y/qXarTqQUaPs/Dhg2TTz/9VL1ldejQQdq2\nbatiQbtUAzORAAmQAAmQAAmQQJAS2Lx5szRt2lStddGzZ08jgMLDhw+lU6dO0rFjRzl8+LDE\nj+9UpQoYAtmzZxe8FJgFSjTCET/99NNSvXp1eeWVV9RmzuOrYxhqEawikMWpBfrAgQOCyBv4\ndAH5/PPPpX79+oHcJ7aNBEiABEiABEiABDxCYODAgVK1alXp1auXoTyjYCjMX3zxhVo87uzZ\ns0Zdc+fOFRgba9SoIVh8Dm4QumzcuFFZebGic7t27aR58+aC/FDGYf1t1KiRMlpeuXJF3eJu\nftx0//59+fLLL+XFF19UbhlvvfWWHD9+XG9CjHv0pUqVKtKvXz+VZ9OmTfL2228b+bGib/v2\n7VW/Xn/9dcGLhVm2bNmiGDVu3FhZ5/UVq+H2grKnT58uuIY95MaNG6ouRHBDOGRdoYd7TJ8+\nfVQetEW38MeUX2X0ww+nCjRM+pChQ4cqUz8eklu3bslff/3lcPNDX1glCZAACZAACZAACXiU\nAJTYWrVq2S0zY8aMMm3aNCOE73fffaestnnz5lVf6+/cuaOMjlAuIQcPHlQKMizXcIVNkCCB\nWskZSiQWpIMf8jfffKNcLGKTH/egDLQJCny9evVk+fLlatVouNo6k2eeeUZ27dqlsh06dEgm\nTpyojqEMV6tWTfkjQ3mOiIiQypUry759+9R1KNuo78iRI8ov/Pfff1f9wkUYYkeMGKGs26lT\np5a7d+8KlOSyZcuql4smTZqol5EGDRqo+vBiUrJkSVVu8eLFJXPmzA7zq4x++OH0ewMmDOLN\na/LkyWrT24iOOxJ9kRVHeXiNBEiABEiABEiABAKVAJTIy5cvS7Fixaya+Ntvv0lUVJSRhgmF\nyIOv9XB7hYIMgRsEVnCGEl6+fHmVhvIWL14sZcqUUWXMmTNHoGjDNxkC/en77783lGh38iMv\nlHqsEF24cGFVXsGCBZUSjzlsWLPDkaBNsPSaLerID6UabRwwYIAq/+WXX1bl67pe7969lbV9\n1KhRqnhY0l966SVDwQYXWOJRPgTWdtSxdetWSZUqlXTp0kUKFCgg7777rrRu3VpatGghffv2\nFdSDdGf5odD7Wpwq0GgUzOoY2NOnT6tlvPFAwQ+IQgIkQAIkQAIkQAKhSgDRKaAHnTlzxqqL\nH3/8sVIokYhrOIcCDQUTiiEssLDO7ty5U1lc7927Z9xvtrDCAo11NWCB1gUKt1mBdSc/oqLB\nRQLW7HHjxik/YkwWhMDy60yuX7+uskCpNUvFihXVJMP8+fOrladh2YZ7CuqDEo36oETrAm6w\nfEPgrpIoUSJlcdevw/0DlmXzpEXomLB0nzp1Ss9m7J3l98faJE4VaLQeAwxYEPjWIERd586d\n1Tl/kAAJkAAJkAAJkEAoEoDLQZEiRQQuGAigoIu+qBzO4a6hC8L7YjIeXA/g4gAfZyiQZoFy\nGhkZaSRBQU+ZMqXVuXGiHbiTH4o6JjyuX79eKlWqpNrQqlUrdW4uM6ZjKP0Iy5c0aVKrLMmT\nJ1c+z5MmTZL58+fLm2++qQyps2fPVpZ1uPYmS5bM6h7zCTjGi/fEaxhRNlCHOQ1KMHyfzWl6\nGe7m1+/z5t4lBdrcACykQiEBEiABEiABEiCBcCAA39wff/xRTaCzdV+F9RUTACGw8L7//vsq\n9Fv37t1V2qNHj9QEOVf8j9UNcfwBhRZeA/BF1q2ySIM4awPcLBA0Qnc/MTcFfsx4iYDijA1u\nHrVr1xa4bMycOVO5dSBqRs2aNY264MKhczCXheN8+fIpN5bPPvvMUJgRyQQTDmGB1y3+uouI\ns/y25fvi/MnrgC9qYx0kQAIkQAIkQAIkEEQEEH0MyiImEmIyHPx2YYGGNRZ+zXA7KFSokJoI\nB5eGc+fOKWUVPsOIgIEv92YXDm92HW4RUNr1CBiIvoHQdBBzG6Dsr1mzRm3wTYYiDIs52g8/\nZHuCqCGIGY3yoUDDKqwHmsDEQsSMhm83FkBBjOy1a9caft+25b3xxhvKVQMuLygHLiuwlM+b\nN08SJkwoadOmVbfA4wFuJc7y25bvi3Mq0L6gzDpIgARIgARIgASCkgB8kBFIAV/gp06dqsLW\nwa2jR48ekidPHtm9e7cKGQd3V4SPQwQMTOSDMgvXB0yIQwg4XwgiZegh9OCKgSAQ8M+GC4W5\nDfAzfvbZZ9WG1RTxYoCXBCjVaLutYCIfFGSElYNLCfoNNxU95B2UdNyPMMe4Dj/ssWPHRnMF\n0cvFiweY/u9//1MuI3gBwSqIULwhcGmBXziUaoQRdJZfL9eX+wjNPG7xZYX+qgs+SDN6vyMD\n8uXxaBM+qPlvPENPFjojzVxPFqfKmvDbkwkKniq89nhPleSdchYtWqR+AT/55BPp37+/dyph\nqSRAAiQQYgQQXQLKix6X11fdyzxvoa+qknMNY/8/ESHYsNCHedlr24ZDQYUCDeXbHwIr8KVL\nlyRr1qwerx4Wdijk9pbYhrUdbJxF+zA3CpMH4bYBy7Ot3Lx5UynhZp9xR/lt7/fmuX9G1ps9\nYtkkQAIkQAIkQAIk4CUCmCznaMIcqsVKf/4UKKPeUJ7RJ7wYxCSItuGO8oxyHL2IpEiRIlpV\njvJHy+zFBLpweBEuiyYBEiABEiABEiABEgg9ArRAh96YskckQAJhRmDMmDHKN9PcbaTBT5FC\nAiRAAiTgeQJUoD3PlCWSAAmQgE8JIPyTvmiBXjHislJIgARIgAS8Q4AuHN7hylJJgARIwGcE\nMEsdE2sgmAmPSU62Sw/7rDGsiARIgATCgAAt0GEwyOwiCZBAaBNA+Cx95TDMVtePQ7vX7B0J\nkAAJ+I8AFWj/sWfNJEACJEACJEAC/xGIS2g5QiQBXxOgC4evibM+EiABEiABEiABEiCBoCZA\nBTqoh4+NJwESIAESIAESIAES8DUBunD4mjjrIwESIAESIAESiEZgcdtoSV5LCPSVdL3WcRbs\nMQK0QHsMJQsiARIgAecEXnzxRTXJDxP9sDlb0cx5id7JMWvWLLWSWZYsWQQbVjVDGoUESIAE\nSECECjSfAhLwI4HZs2dL+fLlrbbVq1f7sUWs2tsEdIX07t27kjx5csmXL5+3q4xV+fHixRMs\nB3zx4kW14RhpFBIgARIgARG6cPApIAE/Erh8+bLs2LFDHj58qFoRP358uX79uh9bxKq9TeCb\nb74RWKGfffZZadeunXz55ZferjJW5Tdp0kSw5ciRQ91/7NixWJXDm0iABEggFAmWRdflAAAs\nD0lEQVTQnBCKo8o+BQ2B1157TaKioiRNmjRSsGBBddyoUaOgaT8bSgIkQAIkQALhSIAW6HAc\n9QDr8/Dhw+XOnTtGq7Jlyybt27c3znlAAiRAAiRAAiRAAoFEgAp0II1GmLZl8ODBcunSJaP3\nFSpUoAJt0OABCZAACZAACZBAoBGgC0egjUgYtmfq1KnSoUMH1fO+ffvKiBEjwpACu0wCJEAC\nJEACJBAsBGiBDpaRCuF21qxZU02kQxfLli0rlSpVCuHesmskQAIkQALBRAATf69evWo0OVWq\nVJI9e3Zp3LixilSjX/jnn39kwYIF8t577+lJsd5PnDhRMmbMKHXq1Il1GXG5cdSoUYKvwdh0\nuXfvnmzevFnWrVsn+/fvV/N2nn/+ealYsaKeJaz2VKDDarjZWRIgARLwH4GzZ8/KoEGDrBpQ\nu3Zt4cRZKyQ8CTACI0eOlMePH8tTTz0lFotFzp8/L4hKkzZtWpk+fbo888wzqsVQoL/66iuP\nKdBFixb1mwL97bffSteuXQ0F+sqVK/Lcc8/JhQsX1B5zlZYvXy79+vWTd999V7744osAGzXv\nN4cKtPcZs4YQIYA/Ftu2bbPqTadOnQTWCAoJkIBzApjrAMuWWVKkSEEF2gyExwFJoFWrVvL5\n558bbcOzXL9+fWndurXs3LlTxXR/5ZVXBFuoya1bt6RevXrK6r5mzRpJnTq10cU//vhDhbvE\nS3DlypWN9HA4oAIdDqPMPnqEwJw5cwSf8szSrFkzKtBmIDwmAQcEsGjM1q1bpXv37rJhwwZZ\nsWKFFChQwMEdvEQCgUkgffr0AuURCyONGTNG3n77bdm0aZNgTg8s1pDt27er/xknTpyQvHnz\nyuuvv25YdPEimSdPHuUKsWzZMilWrJiKC1+4cGG7HT5y5Igqa9++fWoFU1i9e/ToYbiQQKFH\nO+BeAcs1Ys3DJVKXCRMmyLx58wRuGNWrV1e/g1h3QJfFixfLr7/+Kjdu3JCOHTvqyWr/+++/\nC6zrsLqblWdchBtLr169rAIB3L9/X77++mvZsmWLKg8hWt955x3JlSuXCtX65ptvKiv9Tz/9\nJLt27VJum3369JGFCxfK+PHjFVOEeC1RooSqH6zwd+Lo0aMyf/58gfUbVm8s7DR06FBlFX/5\n5ZelefPmKj9+zJ07V62cevz4cZW/ZcuW6iXAyOCBA79PIrx586aC9ttvvwkeMmeCzyh42wNk\nwMZAUUjAFwTwC41feMjTTz8t+KOSOXNmX1TNOkggJAgkSZJE/VPXv9qUKlVKLREeEp1jJ8KO\nAP7+586dWymX6PyhQ4cEvssQuHlUq1ZNEidOrBTniIgIZaGFAgxZtGiRUpihtLZo0UIpklBs\nT58+ra6bf0BxhDIJN4o2bdpI/vz55dNPP1XuE8h3+/ZtpRyi7rp16yq9CNZg3AeBog0FFvdh\njhEWbzIrm9CloAjDPaVcuXJqUj8UT13Wr18v+F2FT7Y9GTZsmLJC69fgtz1t2jSpUaOGahe+\n3sJXGvrbo0ePlKKPPJGRkcp/Gu1Buz/++GPVPnBs2rSpXpxihf+/UIoxZ2rt2rXqqxXypEyZ\nUgoVKiRQoPUvxN999536EoCXlrZt26owufhaAIXek/Lk9cOTpbpYFgYXUNBJvFH88MMP8tln\nnynlxF4ReMPCm1GiRImkZMmSMmPGDKVI4z5ApJCANwngD1i6dOlUFXheX3jhBW9Wx7JJwCDQ\nbWIC4zimg/u3LerS7tMLxZX8o9pExVQU00mABFwkUKZMGTlw4EC03LCsYn2DAQMGKMUTCh6s\ny1BSdXnw4IGyGMMSDMUYX2gwRwAKoFkwYQ/3w4ADqyvcSS5evCgbN25U2X7++WelsEPxTJgw\noUpD2UuXLlX+yrDgTpo0SWCFhUB5hjK9atUqdR3Wc0TAggILeemll6y+DMGyXr58eXVN/4E0\nWMX1/uCluEGDBoLVdaFojx49WvUX+WGBhgKLNusvz+gPQthC0D9Y7k+ePKncRNBOvJzA6l28\neHGVJ1myZDJ79mwBK6yO+n//93+CNSR69uyprqMv+EoMqzv8tKHUw8USAreaDBkyKF62/VAZ\nYvnDrwo04OGtB29HeDuDVRkhzPDmgnNbgcKcNWtW+f7779Wlu3fvKoh4g8OnEQoJkIB/CeB3\nGH9YzYJJNUmTJjUn8ZgESIAEQoIAXB50pdDcIUSmwKRDKKqYKAsf4ldffdUwwiAvrKlmNwrk\n062o5rJgnYU1G5bcvXv3yp49e5RyrH8BhatI1apVDeUZ9+pK+JQpU5SSC+srvt7rkjx5cuVO\nBYvzwYMHlYVYvwbXErNrFRRiW8s4vAawQa5duyY5c+ZUCjSMTJhYuWPHDhk3bpxSjlevXq3y\nQWfTWaFeXcAJLiyIbAKBewzk3LlzhgINo6nOCvkh4KILFGTkh+ClBROW8ZUYFn/0G3XDfcWT\nEs+ThblTFt5S8CA0adLEUJYbNmwoZ86cUQ+HvbLwTxgPoC74HAjTPe6hkAAJ+J8AfPlgeTBv\ndLPy/7iwBSRAAp4nAOsrrKe6QmeuAQoqQr7BUAhLNPx+8bUdfv+6wP3DLIjqAXcMW/n777+V\nvzS+2MNAga+hiIihC9xFYKG1J1BuoXjiyz2s1/qGeQjwlYYbLVwrHj58aHV7ggRPvnrBHQRz\nF8wCwwjcPLB17tzZuAQlFYrts88+q4yh0NtgMbcV9NUsmEysiz0Dqv71V8+DfUyeB/BBx0sA\n2MMaDYt7TO4n5vLcPfabBVp/U4BFWRcAwucHdBgDaytm5RnX4A+ENy+EWrGV3r17W/lU440m\niW0mnpMACXiUAFyw8FUJE1jg4oJPgjH9kfNoxSyMBEiABHxMAG4RcDtAJA5bgVsHrL5QnLHB\nUg0LM9wp4OsMgUXZLEuWLBG4hNjKJ598ooyFcMmA3zAEfsDwJ4ZAMYe7g1ng3gDFHXGco6Ki\nlM+wvsYC7sPXQliZYcXGhkmEsHJD4GoBpV0X+CsPHDhQhgwZIu+//76ebOzhLqIL3CxgSIF7\nB1wtIEiDQFH3tsDSjDZCwcdLAgT9hYuMp+v3mwUa5nW8EWEzC95CzAHLzdfMxxgwPFSY1Wl2\nNtfz6GZ7mO6x0Uqtk+GeBLxHAJ/x8FUIghdiTDzR/+B7r1aWTAIkQALeJQBFGSHc4I4wc+ZM\nQdQIWF4xSS0mv9p27dqpuVpQ4KBAQ7cxW6uhm4wdO1a5F2APtweUZytQcGEwhHIIqzd8feHS\nqn/dg2UaCjVcYGHBRjmYZAg3CSjr8EGGMWP37t3KjQG6E5RM3biBdsLVY+XKlaqN/fv3N3yb\n0Ra4o0Dh/vDDD6VLly4qgMMxLSLHn3/+qSYcIjoVXCwgaCv6C6s4BBZq3AfxtAuFKtTmB6zt\n+N8DIy0UZrxEvPXWW4qVp+v3mwUanwdsPxmAA8A785fEg4iHF3s8MOZPDTpLhGsxC0Imzej9\njjmJxyRAAiQQtgQyz1voUt8v3v3Xb9DV/OcaPvFLdKkCZiKBICCACBd6hA348cLqi7jQupXT\ntguw7sIKioVGoKBC2YXLKs51gcUXZUARx1dyuL4hWoWtIEwcJiVmypRJRfUoXbq0Ct8GJRh6\nEM4Rpg6KInQjuCvgWPcRhsLdvn175U8M/QouIOiL7muMNiBIAyYBQgeDpdzWEg43DNyLiYyI\nGnL9+nVlAEVZ8DVG3yDoU4cOHVQEDuSHfoZQc+gjPAbAzZuC+hDVAy8BCDABYyuUfrQZ9XtS\n/KZAY+AwUHg7MCvMeBgQVzEmwSBjxij8ffApRHdIjyk/00mABEjAlwRutY3u72db/53zF1TS\ngz/nya3zp20vRz+vGT2JKSRAAr4hAHcEVwRKptnfFwESsMEaivjJCGlnFnytgxsHJujBndXs\n+wuXCl0QnQOWb8wdg5ur7i8MJVkX1ItoEygLUaLMZcECjVB0UHphuLT1J4ZfNBRjrD6IRVN0\nxVovW9/DLQ8bLLsIO4xJf/rEPj0P9ohHjWAP0Nd0N11E3dBFj9yhn8Najk0XtMecB+HrzAKl\n3Xwd1/BVQBe41GA7deqUsojba6OeNy77eHG5OS736uDxSUEXTCrEwOjA9XR9j08C8CWCXw0+\nGVB51slwTwIkQAIkQAIkEIgE4NZgqzyb22mr8JqvmY+h+OrKszldP4bSDN3KrDzr17CHzmSr\nPJuvo40xKc/mfFBwMQHSkWIKRT8mXc5cljePdT3TW3X4zQKNgcRnAvj9IDYiBgJvLfjkgHAk\nELxx6QHCcY64frBaY4KSHowc6fDjwYxLCgmQAAmQAAmQAAkEOgFYpB0pw4HefrZPxG8KNODD\nJwbx+rCGur44itmfCDNOMfkP8ROxhx8zBJ9EzAIHd/gaUUiABEiABEiABEgg0Ano/tSB3k62\nL2YCflWg06RJo9aMh98zZurbxjFE2BRd8CkAM2ApJEACJEACJEACJEACJOBPAn5VoPWO66FU\n9HPuSYAESIAESIAESIAESCBQCQSEAh2ocNguEiABEiAB9wgsjh7GNloBl/5bo2F5F5HkCaNd\njpZQe3y0JCaQAAmQgF8JUIH2K35WTgIkQAIkQAIkAAJ8UeJzEEwE/BbGLpggsa0kQAIkQAIk\nQAIkQAIkoBOgAq2T4J4ESIAESIAESIAESIAEXCBABdoFSMxCAiRAAiRAAiRAAiRAAjoBKtA6\nCe5JgARIgARIgARIgARIwAUCVKBdgMQsJEACJEACJEACJEACJKAToAKtk+CeBEiABEjAIGB5\n9Egs9+6JxWL5d8OxlkYhARIgARIQoQLNp4AESIAESCAagXtrVsuFF18Qy5XLasMx0igkQAIk\nQAIijAPNp4AESIAEfEig9+atsvjUGVXj5ENHZOnps7KxcX0ftsC1qiLTpJGEJUtZZUYahQRI\ngARIgAo0nwESIAES8CmB83fuyrm7dyVxZKTcfvhQjty8Gef6dy56LLtXPFblnD1gkal9H0q9\ntyIldeaIWJcN5dlWgY51YbyRBEiABEKMAC3QITag7A4JkEBgE5hYrarHG3jvtkVuXtIsItqy\n2BZNj75xQeTRQ49XwwJJgARIgAT+I0AFmo8CCZAACQQ5gYr/FykV/y/IO8HmkwAJkEAQEeAk\nwiAaLDaVBEiABEiABEiABEjA/wSoQPt/DNgCEiABEiABEiABEiCBICJAF44gGiw2NfgILG7r\nWpujbovcPiviav7a410rl7lIgARIgARIgAQ8T4AKtOeZskQbArfatrJJiX56f/delXj3m5Fy\na87M6BlsUpKPn2yTwlMSIAESIAESIAES8A0BKtC+4cxagoBA5nkLnbby0WUt1IEm886eE1fy\nT5C6TstkBhIgARIgARIggeAiQAU6uMaLrf2PQLeJCZyyOPH3v3Fx5+8cKBcnfuY0v6SZ6zwP\nc5AACZAACZAACYQ9AU4iDPtHgABIgARIgARIgARIgATcIUAF2h1azEsCJEACJEACJEACJBD2\nBKhAh/0jQAAkQAIkQAIkQAIkQALuEKAPtDu0mJcEQojAzZs35eHDJ+s9x4sXT1KlShVwPfzl\nl19k2LBhVu2aMGGClC1b1iqNJyRAAiRAAiTgKwJUoH1FmvWQQIARePbZZ2XHjh1Gq7JmzSqn\nT582zgPlAIr+qVOn5MaNGxIZGSnJkiWT+/fvB0rz2A4SIAESIIEwJEAXjjAcdHaZBECgatWq\nUqpUKQWjSJEiUqNGjYAE06NHD7l+/bpqW/ny5dVxpUqVArKtbBQJkAAJkEB4EKACHR7jzF6S\nQDQC33zzjbz//vsq/Y033hC4RYSLPHjwQM6fP2+13b17N1y6z36SAAmQAAnEkQAV6DgC5O0k\nQALBR2DZsmWSOXNmqw2+1hQSIAESIAEScIUAFWhXKDEPCZBASBHIlCmTNG3aVFKmTKn8qnGc\nN2/ekOojO0MCJEACJOA9AlSgvceWJZMACQQogTJlysisWbMkV65ckjhxYnVcr169AG0tm0UC\ncSNw9epVSZgwoSRIkMDYOnToELdCeTcJhDkBKtBh/gCw+yRAAiRAAqFNANFrSpQoIalTp1ah\nKwsUKCA5cuQI7U6zdyTgZQJUoL0MmMWTAAmQAAmQgD8JwFVp69atym0J7Zg+fboMGDDAn01i\n3SQQ9ASoQAf9ELIDJEACJEACJEACJEACviRABdqXtFkXCZAACZAACZAACZBA0BOgAh30Q8gO\nBDOBw1d2yq+7hsiDR/fkxv3L6vj0jUPB3CW2nQRIgARIgARCngAV6JAfYnbQUwQenjwpD/7e\nqYp7rM1qv79tq1jiuKT0/kub5Ze/PtAU6LuaAn1JHR+/tttTTWY5JEACJEACJEACXiAQ3wtl\nskgScIvAnOMnZeeVK+qe9RcuSPIE8aVG1ixuleGLzHcWzJO7c/9QVUXt3SPXPvlI0v30i8TP\nHPu2ls1aW/pXm23V/EIZKlqd84QESIAESIAESCCwCFCBDqzxCMvW9Ni4WS7/Z8n9fu9+2XTh\nUkAq0InKVZB4KVJajVG85Cmszt09yZQ8l2ALFuk2MYHTpl4+ZVF51h38WbpNHOc0/6g2UU7z\nMAMJkAAJkAAJBBIBKtCBNBph2pZPypSUew8fGb3PlCSJcRxIB4nKlBVslMAnsLita228eVLk\n4X0RV/PXHu9aucxFAiRAAiQQ2gSoQIf2+AZF79rlzxcU7WQjSYAESIAESIAESAAEqEDzOSAB\nEvArgczzFrpc/7ar18SV/BOkrstlMiMJkAAJkAAJuEuACrS7xJifBIKEwK22rZy29N7RYyrP\n/UkT5Na2TU7zS03nWZiDBEiABEiABEKdAMPYhfoIs38kQAIkECAELtw6IQNWvCCHrvylWjRk\nTStZdmRygLSOzSABEiAB1wlQgXadFXOSAAmECIFbD67J7gvrtMmrt+Wx5ZE6vnL3XIj0LnC7\ncTvquqw/OVuu3bugGrn59J/CuOeBO15sGQmQQMwE6MIRMxteIQESCFECey9ukH7L6hu967Ww\ninStMEoaF+pqpPHA8wRypios0160flFJHD+Z5ytiiSRAAiTgZQJUoL0MmMWTAAkEHoHMyfNK\n8yK9rRr2VNrSVuc88TyByHjxJU2STJ4vmCWSAAmQgI8JUIH2MXBWRwIk4H8COVIVlNfLDfV/\nQ9gCEiABEiCBoCRAH+igHDY2mgRIgARIgARIgARIwF8EqED7izzrJQESIAESIAESIAESCEoC\nVKCDctjYaBIgARIgARIgARIgAX8RoALtL/KslwRIgARIgARIgARIICgJUIEOymFjo0mABEiA\nBEiABEiABPxFgAq0v8izXhIgARIgARIgARIggaAkQAU6KIeNjSYBEiABEiABEiABEvAXASrQ\n/iLPekmABEiABEiABEiABIKSABXooBw2NpoESIAESIAESIAESMBfBKhA+4s86yUBEiABEvAZ\ngZ49e0qKFCmMLWXKlHLmzBmf1c+KSIAEQosAFejQGk/2hgRIgARIwA6BtGnTSpYsWeTWrVsS\nGRkpOXPmVHs7WZlEAiRAAk4JxHeagxlIgARIgARIIMgJfPTRR9K6dWvJmzevNGjQQCZPnhyQ\nPTp37pzMmzfPqm0VK1aU4sWLW6XxhARIwL8EqED7lz9rJwESIAESIAGDwIEDB+T11183znHw\n5ZdfUoG2IsITEvA/Abpw+H8M2AISIAESIIEgJHD9+nWBwmve7ty5E6eeFChQQMaMGSN58uRR\n5eC4bt26cSqTN5MACXieABVozzNliSRAAiRAAmFAYNKkSVKwYEGrbdWqVXHqeebMmeW1116T\njBkzqnJwTPeNOCHlzSTgFQJ+d+G4efOmrFu3TrCHnxcmdjiSR48eyY4dO2TPnj1SqFAhKV++\nvKPsvEYCJBADgUE7/pY15y+oq9OPHpMTt2/L4HJlYsjtv+Q7ixbKnd9nqAZEHTksl97oKKl6\nvycJ8hfwX6NYMwloBPA/qG3btsqfOnny5NKkSRPJnj27X9gsbuu82lPr/82zrq/I6dQx53/0\nWOTelZiv8woJkICIXy3QR48eVX9wZsyYIbt27ZIOHTrIxo0bYxwXKM+dO3eW/v37y+nTp2Xg\nwIEyfPjwGPPzAgmQQMwE5p08JWv/U6C3XrosM44ejzmzP688uC+Pb1yXCE1BiUiUSB1bHj7y\nZ4tYNwkoAjVq1JBx48ZJIu25zJEjhzqmtZgPBwmEBwG/WqAHDx4sjRs3lh49ekhERISMHz9e\nRowYIdOmTVPntkMwffp0FYLo119/lWTJksnx48elTZs2akY1PqNRSIAEXCcwtfqzck97KdUl\nQTy/vk/rzYi2T9qoiWCjkAAJkAAJkECgEPCbAn358mXZu3ev9OnTx1CWGzZsqCZPwD2jaNGi\n0RitXbtWatWqpZRnXMyVK5cUK1ZMlixZonzQot3ABBIggRgJ5NIsuhQSCBUCt9q2ctqV2zdv\nqTxRG9aJK/k/qDndaZnIcD/qoZy++o90m5jApfwz0sx1mu/y1WsqT+Z5C53mRYYJwomGLoFi\nJhLwEAG/KdCIdQnJmjWr0ZV06dJJwoQJ5cKFC3YV6LNnz1rl1+9Hflv59ttv5fz580YyAufv\n1ALof3bkmJHmiYM989N7ohirMpIknGZ17omTqUfXeqIYqzJW97M6jfHkoYeZoyJn3C+ftMit\nKxZtIo7I+b9Flh2LkCwFImJsIy4EC3e01RX2/uB+7axFbl4WjbvGX/MIWTo8QjLni5B4kWi1\nfSF3+1zMqc6ed3NeV4+9wR11++tvjbPn/fCNm3JS8/PH5LztmsJbb8NmKZc+vSSKjPnLizPu\nt69a5Lr27yddGovEs/z7vKfNHiGJkzkeBUfsH9+5LQ8198Z02t6itTWyfz+J1CYWRqZz/L/G\nEfdHjx/Knosb5Oq9c6r/3+3SJikmyynZU9mfR2CxaJ2hkAAJOCTgNwUayjD8xrCZBUutXr16\n1Zykjh8+fCiXLl0SLL9qFpwjhJCtLFq0SA4ePGgklytXTj765lvj3FMH9TxV0H/lTJ06VdJp\n1vlu3bp5uGQ/Fqd9NfC0OOOOZwLP0f379yVBggTqOStTJuYJcnPnzpU02j8txF9NkiSJp5vr\nn/L8wP3YsWPqBfjevXsSP3589UIM7vFicA9ZsWKFpPnnH2nZsqVkyJDBP5w8XasfuLvbhS1b\ntsiGDRukUaNGRrg0d8sIuPxOuJ84cUIZVe7evWs8myVLllR/H2Lqi7O/MxcvXlSuhAhdh2c8\nceLEgjB0tv+n9PLx1RVfTP+vSrkYI2tgpcR9+/YJfoceP34sSZMmVf7VmTJl0otxe4/5Q9u3\nZ5AHDx4I/peinXiRyJ07d4xlJUlCt6kY4fACCWgE/KZAQ6nBL7Kt4BcdfzBsBRZk/IGyvQfn\n8Ie2lVGjRinlSU/X/wjp54G6HzlypHoheO655wK1iUHRLnf5we8eE1krVKggWPKXEjsC7nJf\nuXKl4l6kSBHBRvENAShyeN67du0q7o6Zb1oYmrXgpR7cmzdv7pA7Vkr0tDz//POeLpLlkUBY\nE/CbAp1e+3QGZRlv7maF+caNG5IlS5Zog4JJhlBsEO7OLMiPuJm24ujN2jYvz0mABEiABEiA\nBEiABEjAVQIxO3+5WkIs8yFWJj7x7t692ygBVhF8sjL7RRsXtYO8efNa5cc1TDjMli2bORuP\nSYAESIAESIAESIAESMBrBPymQKdKlUpq164tY8eOVaHp4O+lL1mq+0KuXr1aFixYYHQen72W\nLl2qlGZMcpg5c6by6apfv76RJ9gP8PKA6CIU3xKAPyC4w1WI4jsC+KoE7rZzIXzXgvCsCX9/\nwd389S88Sfi213A3BPeYfKR92xrWRgIkEBcCEZoi6rfptvAHGzBggOzcuVP9A8WEjg8//ND4\n4/Lxxx/LmTNnlGKtd/KXX36RiRMnqokfsDzDhw8TBCkkQAIkQAIkQAIkQAIk4AsCflWg9Q7C\njxmWP3uTAfU85j1mEuMe+FFTSIAESIAESIAESIAESMCXBAJCgfZlh1kXCZAACZAACZAACZAA\nCcSFgN98oOPSaN5LAiRAAiRAAiRAAiRAAv4iEPmJJv6qPJDr/emnn1TwentuJQi/N27cOEFg\neyz84opgQiQWSUHUkLJly7pyS4x5Tp8+LVgoxt5y51gsABMv4TuO9mFlR7PEdB3RT0aMGCFY\n9ALRUXwtWFAD2/bt21Vwf2eLmYDnlStXooU8/HfBgO2ybNkyNcHUNkKLs+tx6TfKhn8+osXY\nTooLVO7O+uvuuMTl2XTWlpiu2+Pu7+c5prZ6Ih3zQPB7clRb+Kdw4cJOi4zpd8Xpjf9lsDem\nR44cUX+DihUr5moxQZ3PEfPY8MVkeCwmljNnTpe4YIGiSZMmqUVY8ufPL/j/5K+/1S41mJlI\nIAwI0AJtZ5ARWu/w4cNqpSY7l1WovQkTJqg/gPau26bt379fTY5EzOu4+m1jlaoPPvhA/fOy\nrQfKW5s2bZSSPn36dOnSpYvVqo6OrmORGsTfnjFjhm2xPjlfvny5UqAR5xvKjyPZsWOHYIIp\nXkbMAkWqc+fO0r9/f8E//YEDB8rw4cONLM6uGxljefD999+rCa8YI7MEMndzO+0duzMucXk2\n7dXtapo97v5+nl1tu7v5MOcbkYuwyuptbVlqZxLT74qz+/TrMY0pXhKhOJ48eVLPGrJ7R8xj\nyxe/Vxs3bnSZ2fvvvy9bt26VNGnSKKONP/9Wu9xoZiSBUCeAKBwUawKa4mnRlDPrxDic/fnn\nnxYtZJ9FU+DiUIrFov3Btfzf//2fRVtRyvLaa69ZlXX8+HFL9erVLZplSqVHRUWpPKNHj1bn\nzq4jkxZK0PLiiy9arl27pu7x5Y9+/fpZBg0a5LBK9EmzBKl+VqtWzaJZZKzyT5kyxdKiRQuL\n9k9fpWtWG0vVqlUt2rK46tzZdavC3Dg5d+6cpXfv3mpcqlSpYtGUd+PuQOduNDSGA1fGBbfG\n5dmMoWqnyY6442Z/Ps9OGx/LDNrLpQXPmLYMt8MSnP2uOLz5v4uOxhRZ1q5da+nTp48rRQV1\nHnvMPcHXVSh4jm3HPBSfbVd5MB8JBAoBWqBt3pBWrVqlXAMcfRrF8uFDhgwRTTlSS4vjGC4T\n//vf/6RXr17K6nnp0iVVMsqbN2+esqoOHTpULeNqU6VLp7DM9u3bV+rVqyctW7aMds/mzZvV\nAjSlSpVS1+CGUbduXfXJDwnOriMP3A5Kly6t3FNwHmiivYjI/PnzRVO0lXuNbfu0f+hSq1Yt\nI5oL4q3iE/OSJUtUVmfXbctz9fyLL74Q7RdaPRO294QCd9s+2Z7H9dm0Lc/Vc0fcUUagP8+u\n9jM2+Zz9rjgr09mY4v6KFSsKLLB///23s+JC7npc+f7+++/GV0R88Rw/frxoL/oyePBg0V7G\nZdq0aWql3vPnz8tXX32l+M2ePdv4QhjOz3bIPUzsUNASoAJtM3T4tKa97dukWp9CWYJSfPHi\nRfVHDsf4owefXNy7bds2pUjjLizQgc9tCRIkUP6KWMAgNgKfYLhldOzY0a6PMvzpbP19sSgL\nFHm4RDi7rrepcuXKypVCPw+kPdqGfyxPP/203Wahj7arWOL8woULKr+z63YLdSERLjX4J6cv\nAGS+JRS4m/tj7ziuz6a9Ml1Jc8Rdvz+Qn2e9jd7YO/tdcVanszHF/XhJhxINP/lwk7jyxYu1\n/uIBN5jffvtNPv30UzVvBXNbfvjhB4GbIBTlAgUKKLy5c+e2MhyE67Mdbs8a+xu4BKhA24wN\nJuZgmXF3RXOrUBZizcVCevbsqSb4QHmFJRsLxCROnFgaN25s9QfQnTrwzypdunQx3qJ9zjYW\noNEzYYIjlOfr16+Ls+v6PTly5JDLly8LLFCBJuh/TBMc8VUAvG1X+MI5XmycXY9LXzFZMyYJ\nBe4x9U1Pj+uzqZfj7t4Rd72sQH6e9TZ6Y+/od8WV+pyNqV4G+GquUvpp2OzjytcWFP5GY85G\nhw4dpH379oLVdbds2SKpU6dWx8gP4wxeWHQJ12db7z/3JOBvAr4Pt+DvHjuoH0oWrAGwGuuC\nVRL37t2rn6oIGrAE2IrZ5UO/X/NTs83m0jks2uaJaE2bNlUKuKObYeFG+82in2O5XmfX9ft0\npQQvEiVKlNCTfbqHwrt48WKjTvDEC4ojwUI8mDim91nPi3NEUnF2Xc/vaO+NcdHrCwTuelsc\n7b3JIKZ67f0OIhKBKxIsXF3pi708sfldsVdObNPAd86cObG9nff9RwDRkp566imDB/7m2U6S\nNi7+dxDqz7Ztf3lOAoFGgAq0aUSwwiEULnPoN/wRmzt3rpELs6DtKdDmsGtQ5CBw9YiNIMSR\n7naA++HLDAu2I0F0D1tLEFZrRHvxGdDZdb1s3cKLiCH+Elhj/vjjD6P6QoUKOVWgIyIiJG3a\ntNEs52CQOXNmcXbdqMzBgTfGRa8uELjrbXG09yaDmOq19zvoqgIdLFxj6ruz9Nj8rjgr053r\neDG/e/euO7cwrx0Ctn/f8T/E2f+PUH+27WBiEgkEFAEq0KbhgKUW7huI2VuuXDl1BRP2bCft\naTOwTXd5/nDkyJFuF5onTx5ZuHChegHQ/7BicoruF+3sul7hqVOn1KGrCop+nyf3aKsWMcPt\nIhFaC31u0KCBcS+Ur+bNm6tzZ9eNm2I48Ma46FUFAne9LY723mQQU732fgdjymubHixcbdvt\n6nlsf1dcLd9ZPnyxy5cvn7NsvO4FAqH+bHsBGYskAY8SoA+0DU5M2PB2bFO4R0yePFk8aeWt\nWbOm6gnKhd8zFjrATHHEhYY4u64yaT/w8gD/PmzBJlCUYSGF0gzrzcyZM9ViKvAnhDi7jjjR\n4IfZ8J6ScODujJUzBt7grrcpmJ9nvQ/e2HvqbxAiERUsWNAbTQzqMj3F1xEEPtuO6PAaCXif\nABVoG8b4Z4BFVLwpBw4cUCHvPKlAw00Ds7j/v737h4XliwI4fn4kvELQKEiUOhJRSEiERGIj\nohAJCQWVZhONUqFSoNpEJLIdChKxNaJBRK/ypxCUIhINUXhz7i/7InZnZmd3xs7Mfqfx3tzZ\nmXs/d7LvuO/eezKZjJnyoQsZdUFjb2+vaYpbeba9GnhH9R9E3Z3D2gdaksmkJBIJs1OKtY+x\n1NXVmea5lWsgp1sRZlfHZ01K+VkJ7m4+bgZBuGfrFOX3OduGIH769R2Eb/7e8cs3/93/P4u9\nkw5lCPyCgDVSx/FNwNqaziQ90QQYQR6aeMOacx3IIzTBhBWU2N7brlyTA2iilouLC9vPBlVQ\naMKOQp7/8fHxpf1odziVW7+AfFlbGdp9tKTzYXR3a5Cf/aLPsjMIwr2c77Oba7Hl+ZJ6FHuv\nUr+DrMWdX9bOQl9WRsRiqxCJzxVrXqqvE04c322n9lKGQBgFGIH+8UuKLrabnp42/5X/o8i3\nv15dXZkV17oAJ4hDV2dnFzLmu79duSYc0TmVPT09+T4W+DndeUT/W7LUOea6CNQpZbpduS4g\n1f1Zs/Pf/W5wWN3d2ulXv+hz8hkE5V7u99nNtZRy3YNe9xgv9vDjO8jKBCpzc3Oia0cq4fBi\n7oevk2mc322ndlOGQJgE/tOoPkwVCkNdrBFKsxdnKpXKmxyj1Doque4KEaZD66T7jy4tLZkg\n+rfrphm4rJFv89j19XXRLILlOH67b8rt7mb8W/3it3vYXd3c7cq1XbqfvB66D/DGxobdpY7n\nS/XW6QPLy8uSTqcdf1l3rERECosxL9XXiUbvXc7vaqe6UYZAJQkQQNv0ts5P1t0svm9pZ3Np\nLE7rwkMdafyZiCQWjQtxI3APpnNwDcY1e1cdZFDj79t3Zsv4GawA73awvtwdgUIFCKALleI6\nBBBAAAEEEEAAAQQsAeZA8xoggAACCCCAAAIIIOBBgEQqHrC4FAEE/BN4fn4WTdOti2k1bXxj\nY6N/N+dOCCCAAAIIBCjACHSAuNwaAQRyBXSf9a6uLrNAV5Os9Pf3m5Tzeu729jb3A5xBAAEE\nEEAgZALMgQ5Zh1AdBOIsoJnrOjs7zeKzxcVFM/KsI9GHh4eyv78vmlTl7OxM2tvb48xA2xBA\nAAEEIi7AFI6IdyDVRyBKAgcHB/L6+iqbm5syMTHxr+pjY2Mma+bMzIxsbW3J6urqvzL+gAAC\nCCCAQNgECKDD1iPUB4EYC2SnaHR0dOS0cmpqSk5OTqShoSGnjBMIIIAAAgiESYApHGHqDeqC\nQMwFdAR6fHxc+vr6ZG1tTbq7u0OXVCjmXUDzEEAAAQR8ECCA9gGRWyCAQGECmkVN5z5rhkM9\nmpqaZHBwUAYGBmR0dFRaWloKuxFXIYAAAgggUEYBAugy4vNoBCpV4PT0VLa3t+Xo6EgeHh4M\nQ1VVlSwsLJjgurq6ulJpaDcCCCCAQAQECKAj0ElUEYE4C9zd3cnx8bGkUim5vr6WyclJ2d3d\njXOTaRsCCCCAQMQFCKAj3oFUH4GoCLy/v4uOPDc3N0u+RYRaPjQ0JJeXl6Jb29XX10eladQT\nAQQQQKDCBEikUmEdTnMRKJeATsvQrevm5+fzVuHPnz8mgP78/JT7+/u813ASAQQQQACBMAgQ\nQIehF6gDAhUgoCm7h4eHzSj0zs5OTovf3t4kk8nYjlDnfIATCCCAAAIIlEmAKRxlguexCFSi\ngM5xHhkZEU3nnUgkTPKU1tZWubm5kb29PXl8fJR0Oi2zs7OVyEObEUAAAQQiIkAAHZGOopoI\nxEXg5eVFksmknJ+fy9PTk2lWTU2NmRe9srJitrWLS1tpBwIIIIBAPAUIoOPZr7QKgUgIaFpv\nDaLb2tqktrY2EnWmkggggAACCBBA8w4ggAACCCCAAAIIIOBBgEWEHrC4FAEEEEAAAQQQQAAB\nAmjeAQQQQAABBBBAAAEEPAgQQHvA4lIEEEAAAQQQQAABBAigeQcQQAABBBBAAAEEEPAgQADt\nAYtLEUAAAQQQQAABBBAggOYdQAABBBBAAAEEEEDAgwABtAcsLkUAAQQQQAABBBBAgACadwAB\nBBBAAAEEEEAAAQ8CBNAesLgUAQQQQAABBBBAAAECaN4BBBBAAAEEEEAAAQQ8CPwFkvDrG7JB\no/8AAAAASUVORK5CYII="" }, ""metadata"": { ""image/png"": { ""width"": 360, ""height"": 180 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 3 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": ""The overall shape is similar, but {class}~fastdfe.parametrization.DiscreteParametrization shows noticeably wider confidence intervals. In general, estimating the full DFE with a sample size of 10 and the limited SNP count used here leads to substantial uncertainty."" } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""R"", ""language"": ""R"", ""name"": ""ir"" }, ""language_info"": { ""codemirror_mode"": ""r"", ""file_extension"": "".r"", ""mimetype"": ""text/x-r-source"", ""name"": ""R"", ""pygments_lexer"": ""r"", ""version"": ""4.2.3"" } }, ""nbformat"": 4, ""nbformat_minor"": 1 } ","Unknown" "Allele","Sendrowski/fastDFE","docs/reference/R/simulation.ipynb",".ipynb","291046","445","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": { ""collapsed"": false, ""jupyter"": { ""outputs_hidden"": false } }, ""source"": [ ""# SFS simulation\n"", ""fastDFE provides a {class}`~fastdfe.simulation.Simulation` module to generate an expected SFS under a specific DFE, and potentially demographic nuisance parameters. In fact, when inferring the DFE with fastDFE, the expected SFS is repeatedly simulated for different parameters to find the maximum likelihood estimates. Below, we illustrate how to use the simulation module to generate SFS data under a given DFE. To do this, we need to specify a neutral SFS ({attr}`~fastdfe.simulation.Simulation.sfs_neut`), which is informative on the population sample size, population mutation rate, the number of sites, and possibly demography. {func}`~fastdfe.simulation.Simulation.get_neutral_sfs` can be used to obtain a neutral SFS under a constant panmictic population. We also specify the DFE parameters and parametrization. By default, we assume not ancestral misidentification (`eps=0`) and mutation are assumed to be semi-dominant (`h=0.5`)."" ] }, { ""metadata"": {}, ""cell_type"": ""code"", ""source"": [ ""library(fastdfe)\n"", ""\n"", ""# load the fastdfe package\n"", ""fd <- load_fastdfe()"" ], ""outputs"": [], ""execution_count"": null }, { ""metadata"": { ""tags"": [ ""remove-cell"" ], ""ExecuteTime"": { ""end_time"": ""2025-12-12T12:39:55.590290Z"", ""start_time"": ""2025-12-12T12:39:48.829119Z"" } }, ""cell_type"": ""code"", ""source"": [ ""setwd(\""/Users/au732936/PycharmProjects/fastDFE\"")\n"", ""reticulate::use_condaenv(\""/Users/au732936/miniconda3/envs/dev-r-fastdfe\"", required = TRUE)\n"", ""source(\""R/fastdfe.R\"")\n"", ""fd <- load_fastdfe()\n"", ""options(repr.plot.width = 7, repr.plot.height = 3)"" ], ""outputs"": [], ""execution_count"": 1 }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-12-12T12:39:55.618753Z"", ""start_time"": ""2025-12-12T12:39:55.598913Z"" } }, ""cell_type"": ""code"", ""source"": [ ""# create simulation object by specifying neutral SFS and DFE\n"", ""sim <- fd$Simulation(\n"", "" sfs_neut = fd$Simulation$get_neutral_sfs(n = 20, n_sites = 1e8, theta = 1e-4),\n"", "" params = list(S_d = -300, b = 0.3, p_b = 0, S_b = 1),\n"", "" model = fd$GammaExpParametrization()\n"", "")"" ], ""outputs"": [], ""execution_count"": 2 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""Let's plot the DFE we are going to use for the simulation which is purely deleterious and follows a gamma distribution."" }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-12-12T12:39:56.100130Z"", ""start_time"": ""2025-12-12T12:39:55.624085Z"" } }, ""cell_type"": ""code"", ""source"": ""p <- sim$dfe$plot()"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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"" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 3 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""Let's now run the simulation and plot the expected SFS for both neutral (specified) and selected (simulated) sites."" }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-12-12T12:39:56.779859Z"", ""start_time"": ""2025-12-12T12:39:56.108834Z"" } }, ""cell_type"": ""code"", ""source"": [ ""sfs_sel <- sim$run()\n"", ""p <- sim$get_spectra()$plot()"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl\nR2VuZXJpY1JHQgAAOI2NVV1oHFUUPpu5syskzoPUpqaSDv41lLRsUtGE2uj+ZbNt3CyTbLRB\nkMns3Z1pJjPj/KRpKT4UQRDBqOCT4P9bwSchaqvtiy2itFCiBIMo+ND6R6HSFwnruTOzu5O4\na73L3PnmnO9+595z7t4LkLgsW5beJQIsGq4t5dPis8fmxMQ6dMF90A190C0rjpUqlSYBG+PC\nv9rt7yDG3tf2t/f/Z+uuUEcBiN2F2Kw4yiLiZQD+FcWyXYAEQfvICddi+AnEO2ycIOISw7UA\nVxieD/Cyz5mRMohfRSwoqoz+xNuIB+cj9loEB3Pw2448NaitKSLLRck2q5pOI9O9g/t/tkXd\na8Tbg0+PszB9FN8DuPaXKnKW4YcQn1Xk3HSIry5ps8UQ/2W5aQnxIwBdu7yFcgrxPsRjVXu8\nHOh0qao30cArp9SZZxDfg3h1wTzKxu5E/LUxX5wKdX5SnAzmDx4A4OIqLbB69yMesE1pKojL\njVdoNsfyiPi45hZmAn3uLWdpOtfQOaVmikEs7ovj8hFWpz7EV6mel0L9Xy23FMYlPYZenAx0\nyDB1/PX6dledmQjikjkXCxqMJS9WtfFCyH9XtSekEF+2dH+P4tzITduTygGfv58a5VCTH5Pt\nXD7EFZiNyUDBhHnsFTBgE0SQIA9pfFtgo6cKGuhooeilaKH41eDs38Ip+f4At1Rq/sjr6NEw\nQqb/I/DQqsLvaFUjvAx+eWirddAJZnAj1DFJL0mSg/gcIpPkMBkhoyCSJ8lTZIxk0TpKDjXH\nliJzZPO50dR5ASNSnzeLvIvod0HG/mdkmOC0z8VKnzcQ2M/Yz2vKldduXjp9bleLu0ZWn7vW\nc+l0JGcaai10yNrUnXLP/8Jf59ewX+c3Wgz+B34Df+vbVrc16zTMVgp9um9bxEfzPU5kPqUt\nVWxhs6OiWTVW+gIfywB9uXi7CGcGW/zk98k/kmvJ95IfJn/j3uQ+4c5zn3Kfcd+AyF3gLnJf\ncl9xH3OfR2rUee80a+6vo7EK5mmXUdyfQlrYLTwoZIU9wsPCZEtP6BWGhAlhL3p2N6sTjRdd\nuwbHsG9kq32sgBepc+xurLPW4T9URpYGJ3ym4+8zA05u44QjST8ZIoVtu3qE7fWmdn5LPdqv\ngcZz8Ww8BWJ8X3w0PhQ/wnCDGd+LvlHs8dRy6bLLDuKMaZ20tZrqisPJ5ONiCq8yKhYM5cCg\nKOu66Lsc0aYOtZdo5QCwezI4wm9J/v0X23mlZXOfBjj8Jzv3WrY5D+CsA9D7aMs2gGfjve8A\nrD6mePZSeCfEYt8CONWDw8FXTxrPqx/r9Vt4biXeANh8vV7/+/16ffMD1N8AuKD/A/8leAvF\nY9bLAAAAOGVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAACoAIABAAAAAEAAANIoAMA\nBAAAAAEAAAFoAAAAAFPiRRYAAEAASURBVHgB7d0JvNVz/sfxT7vqat+UUJo2IZEWpEaRsgvR\nRv6jRpaZMCJbNbKNTE0ZRjRNRTVlTRjZi4SRpaSSFtoUWpHq/M/7O/1O59z93u75/X73nNf3\n8bid81u/39/ze/rd87nf5VciEk1GQgABBBBAAAEEEEAAAQQQsJIYIIAAAggggAACCCCAAAII\n/E+AAIlPAgIIIIAAAggggAACCCCwT4AAiY8CAggggAACCCCAAAIIILBPgACJjwICCCCAAAII\nIIAAAgggsE+AAImPAgIIIIAAAggggAACCCCwT4AAiY8CAggggAACCCCAAAIIILBPgACJjwIC\nCCCAAAIIIIAAAgggsE+AAImPAgIIIIAAAggggAACCCCwT6A0EoUX6N27t61bt67wJ+BIBBBA\nAAEEEEAAAV8EmjZtauPGjfMlLzIp3gIESAdQfwqOZs2aZaVLw3gAjByKAAIIIIAAAggkVWDz\n5s02aNCgpObByVNHgG/2B1iXZcqUIUA6QEMORwABBBBAAAEEkinAH7OTqZt652YMUurVKVeE\nAAIIIIAAAggggAAChRQgQCokHIchgAACCCCAAAIIIIBA6gkQIKVenXJFCCCAAAIIIIAAAggg\nUEgBAqRCwnEYAggggAACCCCAAAIIpJ4AAVLq1SlXhAACCCCAAAIIIIAAAoUUIEAqJByHIYAA\nAggggAACCCCAQOoJECClXp1yRQgggAACCCCAAAIIIFBIAQKkQsJxGAIIIIAAAggggAACCKSe\nAAFS6tUpV4QAAggggAACCCCAAAKFFCBAKiQchyGAAAIIIIAAAggggEDqCRAgpV6dckUIIIAA\nAggggAACCCBQSAECpELCcRgCCCCAAAIIIIAAAgikngABUurVKVeEAAIIIIAAAggggAAChRQg\nQCokHIchgAACCCCAAAIIIIBA6gkQIKVenXJFCCCAAAIIIIAAAgggUEgBAqRCwnEYAggggAAC\nCCCAAAIIpJ4AAVLq1SlXhAACCCCAAAIIIIAAAoUUIEAqJByHIYAAAggggAACCCCAQOoJECCl\nXp1yRQgggAACCCCAAAIIIFBIgdKFPK7ID3v77bft4IMPtuOOOy7h3Nu2bbN58+aZXtu0aWOH\nHXZYwvY9e/bYwoULbfHixda0aVNr3bp1gbZr59WrV9u7775r1apVs/bt21tGRkbCOVhAAAEE\nEEAAAQQQQACB9BAIRQuSApw77rjDBTnx7F9//bWde+65NmPGDPv888+tf//+Nn/+/NguCo4G\nDhxod955p3377bc2fPhwGzVqVL63a8dJkyZZnz59XN7Tp0+33//+9/bDDz/EzsEbBBBAAAEE\nEEAAAQQQSB+BQFuQdu/e7QIUBSklSpTIon7PPffYOeecY9dff73bPnHiRHvooYds6tSpblkB\nzfbt223atGlWsWJFW7VqlQt2unfvbk2aNLG8tqvlaMKECTZ69Ghr2bKlqTwKuHQ+vZIQQAAB\nBBBAAAEEEEAgvQQCbUGaPXu2vfjiizZy5EirX79+gvzmzZvtiy++cC1IXvB01lln2dq1a2Mt\nTXPnzrUuXbq44EgHH3744daiRQt79dVX3bny2r5gwQKrW7euC450QOnSpa1r166x491J+AcB\nBBBAAAEEEEAAAQTSRiDQFqSTTjrJunXr5gKThx9+OAF9/fr1blkBjJeqV69uZcuWtY0bN9pR\nRx1l69atcwGOt12v2l/blfKzvV69em5f7x8dv2nTJtu7d6+VLLk/fvzggw+yBE7ah4QAAggg\ngAACCCCAAAKpIxBogKSAJ6ek4KZcuXLuJ34fTeSgMULqDqdAplKlSvGb3fLSpUvz3K6DFIRl\nPl7nV+CzZcsWq1q1auzcmgRCXfziU61o+bb372uls+keGL+f9z5j4hTvLa8IIIAAAggggAAC\nCCAQQoFAA6TcPMqUKeOCnMz7aGKGChUqWKlSpVwLjwKl+KRljUfKa7uOyS4P73zKIz5pXJPG\nKcWn6/v2jV/kPQIIIIAAAggggAACCBRzgdAGSDVq1DAFQzt37nQBkee8detWO+SQQ9wkDZqW\nW9N/xydtr1OnTp7bdYzyWLlyZfzhpuPVcqTWq/ikffUTn7yxUfHreI8AAggggAACCCCAAALF\nV2D/IJuQXcOhhx7qxiYtWrQoVjJN2qDub964pIYNG1r8du2ornDeuKK8tjdo0MCWLFmS0FKl\n83nHxzLmDQIIIIAAAggggAACCKSFQGgDpMqVK9vpp5/upuHWVN4///yzjR8/3s0yV7NmTVc5\nPXr0sDlz5rigKBKJ2MyZM23Xrl1u4gftkNf2zp07u/NMmTLFBV4rVqwwzayn5yKREEAAAQQQ\nQAABBBBAIP0EQtvFTlWhZxENGzbMzj77bNfl7dhjj7Vrr702Vktt27a1nj172qBBg9x4IrX8\n3HbbbZaRkeH2yWu7utGNGDHC5aEgqXz58nbBBRdY+/btY3nwBgEEEEAAAQQQQAABBNJHoES0\n5SUS9svVuCBNuqDJF7JLajXSPpnHCHn75rVd+23YsMHUMhU/tbd3fE6vnaKTNjxzTHNmscsJ\niPUIIIAAAggggEAIBDTz8YABA1xvoxAUhyKEXCDULUieXeapuL313quejZRTcKR98tqufWrX\nrq0XEgIIIIAAAggggAACCKSxQGjHIKVxnXDpCCCAAAIIIIAAAgggEJAAAVJA8GSLAAIIIIAA\nAggggAAC4RMgQApfnVAiBBBAAAEEEEAAAQQQCEiAACkgeLJFAAEEEEAAAQQQQACB8AkQIIWv\nTigRAggggAACCCCAAAIIBCRAgBQQPNkigAACCCCAAAIIIIBA+AQIkMJXJ5QIAQQQQAABBBBA\nAAEEAhIgQAoInmwRQAABBBBAAAEEEEAgfAIESOGrE0qEAAIIIIAAAggggAACAQkQIAUET7YI\nIIAAAggggAACCCAQPgECpPDVCSVCAAEEEEAAAQQQQACBgAQIkAKCJ1sEEEAAAQQQQAABBBAI\nnwABUvjqhBIhgAACCCCAAAIIIIBAQAIESAHBky0CCCCAAAIIIIAAAgiET4AAKXx1QokQQAAB\nBBBAAAEEEEAgIAECpIDgyRYBBBBAAAEEEEAAAQTCJ0CAFL46oUQIIIAAAggggAACCCAQkAAB\nUkDwZIsAAggggAACCCCAAALhEyBACl+dUCIEEEAAAQQQQAABBBAISIAAKSB4skUAAQQQQAAB\nBBBAAIHwCRAgha9OKBECCCCAAAIIIIAAAggEJECAFBA82SKAAAIIIIAAAggggED4BAiQwlcn\nlAgBBBBAAAEEEEAAAQQCEiBACgiebBFAAAEEEEAAAQQQQCB8AgRI4asTSoQAAggggAACCCCA\nAAIBCRAgBQRPtggggAACCCCAAAIIIBA+AQKk8NUJJUIAAQQQQAABBBBAAIGABAiQAoInWwQQ\nQAABBBBAAAEEEAifAAFS+OqEEiGAAAIIIIAAAggggEBAAgRIAcGTLQIIIIAAAggggAACCIRP\ngAApfHVCiRBAAAEEEEAAAQQQQCAgAQKkgODJFgEEEEAAAQQQQAABBMInQIAUvjqhRAgggAAC\nCCCAAAIIIBCQAAFSQPBkiwACCCCAAAIIIIAAAuETIEAKX51QIgQQQAABBBBAAAEEEAhIgAAp\nIHiyRQABBBBAAAEEEEAAgfAJECCFr04oEQIIIIAAAggggAACCAQkQIAUEDzZIoAAAggggAAC\nCCCAQPgECJDCVyeUCAEEEEAAAQQQQAABBAISIEAKCJ5sEUAAAQQQQAABBBBAIHwCBEjhqxNK\nhAACCCCAAAIIIIAAAgEJECAFBE+2CCCAAAIIIIAAAgggED4BAqTw1QklQgABBBBAAAEEEEAA\ngYAECJACgidbBBBAAAEEEEAAAQQQCJ8AAVL46oQSIYAAAggggAACCCCAQEACBEgBwZMtAggg\ngAACCCCAAAIIhE+AACl8dUKJEEAAAQQQQAABBBBAICABAqSA4MkWAQQQQAABBBBAAAEEwidA\ngBS+OqFECCCAAAIIIIAAAgggEJAAAVJA8GSLAAIIIIAAAggggAAC4RMgQApfnVAiBBBAAAEE\nEEAAAQQQCEiAACkgeLJFAAEEEEAAAQQQQACB8AkQIIWvTigRAggggAACCCCAAAIIBCRAgBQQ\nPNkigAACCCCAAAIIIIBA+AQIkMJXJ5QIAQQQQAABBBBAAAEEAhIoHVC+eWa7ceNG+/jjj7Pd\nr1GjRnbkkUe6bfPmzbMdO3Yk7NesWTOrX7++W7dnzx5buHChLV682Jo2bWqtW7dO2FcLq1ev\ntnfffdeqVatm7du3t4yMjCz7sAIBBBBAAAEEEEAAAQRSXyC0AZKClsceeyyhBnbv3m2bN2+2\na665xgVICn7uuOMOO/jgg6106f2XctVVV7kASdsHDhxo69ats5NPPtmmT59unTp1ssGDB8fO\nO2nSJBs/frydeuqptnbtWtPymDFjrGrVqrF9eIMAAggggAACCCCAAALpIbA/qgjZ9Z5wwgk2\nY8aMhFKNGjXKPvzwQzv33HPd+jVr1tiuXbvs8ccft+rVqyfsqwUFRNu3b7dp06ZZxYoVbdWq\nVdanTx/r3r27NWnSxLUcTZgwwUaPHm0tW7Y0BWAKqLS/XkkIIIAAAggggAACCCCQXgLFZgyS\nAqMXXnjBtRgddNBBrpaWLVtmNWrUyDY40g5z5861Ll26uOBIy4cffri1aNHCXn31VS3aggUL\nrG7dui440rJaobp27RrbrnUkBBBAAAEEEEAAAQQQSB+B0LYgxVfBL7/8Yvfee6/17NnTjSPy\nti1fvtx1r1PLksYiqVtc3759rUOHDm4Xda1TABSftKzxTUraXq9evfjNbv9NmzbZ3r17rWTJ\n/fGjgqlXXnklYd+9kUjCMgsIIIAAAggggAACCCBQvAWKRYD05ptvmoKWHj16JGgvXbrUvv/+\ne2vcuLGbXOGll16yoUOH2v333+8mY9AxlSpVSjhGyzpOaf369Vm2azyTgqMtW7YkjEP64osv\nbPLkyQnnqlWuXMIyCwgggAACCCCAAAIIIFC8BYpFgKSudZpEIfM4o7vuussFM96ECm3btjW1\nKmkMkd6rBUjjiuKTljUeSalMmTLZbte2ChUq6CWWNG7puOOOiy3rzXXR8UwkBBBAAAEEEEAA\nAQQQSB2B0AdIms3uk08+sbFjx2ZRr1y5cpZ17dq1s3feecdKlCjhpu3etm1bwj5bt261OnXq\nuHUav7Ry5cos2xVwlcvUOqR99ROflAcJAQQQQAABBBBAAAEEUkdg/yCbkF7T+++/b1WqVLFj\njz02SwlvvvnmLDPdKZjyxh01bNjQFi1alHCcnofkjTtq0KCBLVmyJKEVSft72xMOZAEBBBBA\nAAEEEEAAAQRSXiD0AZKm5lYgk11Slzc9t0iz2Wkih5kzZ7qA5+KLL3a7a8zSnDlz3ENiI9EJ\nFbRd04J369bNbe/cubN7nTJliuuqt2LFCps9e7abCjy7/FiHAAIIIIAAAggggAACqS0Q+i52\n6gLXqFGjbGtBz0P69NNPrX///la2bFnXLU6TNKibnZLGIWnmu0GDBrnxRmoZuu222ywjI8Nt\nVze6ESNG2LBhw0xBUvny5e2CCy5wEz64HfgHAQQQQAABBBBAAAEE0kqgRLRlpdjPVb1jxw7T\nWKPatWu7sUeZa1CtRhp7lHkMUfx+GzZssJo1ayZM7R2/Pbv3naIPl33mmOZWOp9jkTImTsnu\nNKxDAAEEEEAAAQQQSKKAZjYeMGCA602UxGw4dYoIhL4FKT/OmpXOm5kuu/3VupRbcKRjFFyR\nEEAAAQQQQAABBBBAIL0FQj8GKb2rh6tHAAEEEEAAAQQQQAABPwUIkPzUJi8EEEAAAQQQQAAB\nBBAItQABUqirh8IhgAACCCCAAAIIIICAnwIESH5qkxcCCCCAAAIIIIAAAgiEWoAAKdTVQ+EQ\nQAABBBBAAAEEEEDATwECJD+1yQsBBBBAAAEEEEAAAQRCLUCAFOrqoXAIIIAAAggggAACCCDg\npwABkp/a5IUAAggggAACCCCAAAKhFiBACnX1UDgEEEAAAQQQQAABBBDwU4AAyU9t8kIAAQQQ\nQAABBBBAAIFQC5QOdekoHAIIIIAAAggggAACxVjgu+++sxdffNHmzJljhxxyiPXq1cu+//57\nmzdvnt1+++3uyv7+979brVq1rH79+jZu3Dhr1qyZXXnllVazZk376aefbPz48fbhhx/anj17\n7Nhjj7Xf/e53VqVKlZjK4sWLbdq0adanTx9r1KhRbP2aNWvcseedd54dd9xxtmzZMps8ebJd\nffXV9vrrr9t//vMfq1q1qnXv3t06duxopUqVih2bzm9oQUrn2ufaEUAAAQQQQAABBJImoODo\nhBNOsGuvvda2b99u7733nrVv395uueUWu/vuu2P5/uMf/7CxY8faWWed5QKYoUOH2q5du2zt\n2rXWvHlzu/HGG23dunW2ZcsWGzZsmLVo0cI++uij2PFffPGFDR8+3JYvXx5bpzerV6926xcu\nXOjWK0DSfldccYUrk1Z+/vnn1rlzZ7vpppvcPvxjRgsSnwIEEEAAAQQQQAABBJIg0LNnT9u2\nbZsLZho3buxyUDA0YMAAK1euXEKOb775pg0ePNj+/Oc/u8CmXr16duaZZ9qGDRvsnXfesRNP\nPNHtv3TpUuvQoYNdfvnl9vHHH1vp0gX/Oq/WqA8++MAaNGjgznnPPffYrbfeaqeccoqdf/75\nCeVKxwVakNKx1rlmBBBAAAEEEEAAgaQKbNq0yXVjU+uRFxwpw6uuuspatmyZJe+SJUu6VqXy\n5ctbkyZN7JtvvrGXX37ZdafzgiMdpHPdfPPNruXnrbfeynKe/Kz4wx/+EAuOtP8NN9xgNWrU\nsJkzZ+bn8JTfhwAp5auYC0QAAQQQQAABBBDwW+C///2vyzK7YKhVq1ZZiqPxRwcddFBsvbrN\nKcUHR97GNm3auLdLlizxVhXo1TveO6hs2bLWtGlT1yLlrUvnVwKkdK59rh0BBBBAAAEEEEAg\nKQIaf6Sk4CNzUitR5lS9evWEVZs3b3bLlSpVSlivhYyMDLfu119/zbItfoUmdcguxU/w4G2v\nUKGCG+PkLafzKwFSOtc+144AAggggAACCCCQFAFvNrkVK1ZkOX926zLvdOSRR7pVK1euzLzJ\nvHVe65Q3+1zmgEmTNGSX1H0vc1q1apVl17KVeb90WCZASoda5hoRQAABBBBAAAEEfBVQsHHE\nEUfYo48+avGBi7rFvfrqq3mWRVN9awruf/7znxaJRBL2f+KJJ9yyFyB5LUJetzxvZ03lnV2a\nOnVqwuoFCxbYl19+mW13voQd02Sh4NNepAkMl4kAAggggAACCCCAQGEFypQpYw888IBpJruT\nTz7ZzTr3448/2kMPPWTaljnoyZyPutFpRrtBgwbZBRdcYH/6059cdz3Ngvfcc8/ZyJEjY89C\n0jglBUmaOlxBlVqfnn76aZs1a1bm07plPTPpsMMOs969e9tXX33lpvxWQKdZ9EhmtCDxKUAA\nAQQQQAABBBBAIAkCPXr0cA+J1eQLevbRk08+aSNGjLCuXbtaxYoV88xRD3RVa5EeKqvnJ+mZ\nSpoOfNSoUe583gk0fmjGjBmm8UqaJe+0006z999/3z2c1tsn/lVTemv/Y445xi699FI7+uij\n7YUXXjCdh8RzkPgMIIAAAggggAACCCBQ5AKaIGHNmjXWpUsXO+OMMxLOr0BJ02p7Sc8zyinp\noa760bk01qhu3brZ7qqgSPtofJJan7zzZ9dSdfzxx7vWqa+//tpq1aqVr2At20xTdCUtSCla\nsVwWAggggAACCCCAQHACeq5RixYt3MNe40sxd+5c9+BXPZS1IEnTgOcUHMWfR+OevOAofn12\n7/Wg2Py0ZGV3bCqvYwxSKtcu14YAAggggAACCCAQiECJEiVs4MCB9uCDD1rr1q3t1FNPtWXL\nltkbb7zhurbdd999gZSLTPMWoAUpbyP2QAABBBBAAAEEEECgwAL333+/C4g6d+5sajnS5Ax3\n3nmnGxtUrVq1Ap/vQA+oV6+e9erVy9QaRcpZgBaknG3YggACCCCAAAIIIIBAoQXUza5jx47u\np9AnKcIDjz32WJs8eXIRnjE1T0ULUmrWK1eFAAIIIIAAAggggAAChRAgQCoEGocggAACCCCA\nAAIIIIBAagoQIKVmvXJVCCCAAAIIIIAAAgggUAgBAqRCoHEIAggggAACCCCAAAIIpKYAAVJq\n1itXhQACCCCAAAIIIIAAAoUQIEAqBBqHIIAAAggggAACCCCAQGoKECClZr1yVQgggAACCCCA\nAAIIIFAIAZ6DVAg0DkEAAQQQQAABBBBAIC+B7f165bVLkW3PmDilyM6V7ieiBSndPwFcPwII\nIIAAAggggAACCMQECJBiFLxBAAEEEEAAAQQQQACBdBcgQEr3TwDXjwACCCCAAAIIIIAAAjEB\nAqQYBW8QQAABBBBAAAEEEEAg3QUIkNL9E8D1I4AAAggggAACCCCAQEyAAClGwRsEEEAAAQQQ\nQAABBBBIdwECpHT/BHD9CCCAAAIIIIAAAgggEBMgQIpR8AYBBBBAAAEEEEAAAQSKQmDr1q0H\ndJr//ve/NmrUqAM6R2EPJkAqrBzHIYAAAggggAACCCCAQBaB2bNnW9euXbOsL8iKjz76iACp\nIGDsiwACCCCAAAIIIIAAAuEU+Pzzz23Hjh3hLFw+SkULUj6Q2AUBBBBAAAEEEEAAgVQQ+PXX\nX+13v/udrVixwoYMGWJnnHGGXXPNNbZu3bqEy/vXv/5lF198sZ1zzjn20EMP2e7du2Pb//rX\nv9r06dNjy3pz++2322uvvWZvvfWWzZw507755huXzw8//GDz5s2ze++91x2j83nHvvDCC9a/\nf3877bTTrG/fvvbSSy8lnDOoBQKkoOTJFwEEEEAAAQQQQAABnwX27Nlj48ePt27dutmGDRtc\nAKTA5vTTT4+V5Prrr7cbbrjBfvOb31j79u3t/vvvtx49esS2qwvde++9F1vWGwU9ajmqVauW\nHXrooVahQgU78cQTrWzZsrZ06VIXZA0dOtSqVKliP/30k40bN84uu+wya9iwofXr18927tzp\nyvTBBx8knDeIhdJBZEqeCCCAAAIIIIAAAgggEJyAWoeGDx/uCtCkSRPr0qWLa0Xatm2bjR07\n1iZPnmyXXnqp267gSMGSWodOPfXUXAvdrFkza9OmjS1fvty1IHk7b9y40bUQtWrVyq268847\n7cEHH7SrrrrKLStYqlmzps2fP99at27tHRbIKwFSIOxkigACCCCAAAIIIIBAcAJq3fHSYYcd\n5t5q3NCHH35okUjE1JLzySefeLtYRkaG25ZXgBQ7INObcuXKWcuWLWNrhw0b5gKyp59+2pYs\nWeLyUsvSzz//HNsnqDd0sQtKnnwRQAABBBBAAAEEEAhIoGLFirGcS5b8X0igwOjHH3+00qVL\nmwIarfd+rr32WjvqqKNix2jf+LRr1674xSzv1bXOy0cbNY6pQYMGds8995hal9RKpe55YUi0\nIIWhFigDAggggAACCCCAAAIhEGjUqJFpIoezzz7bjT9SkTRuaeLEida4cWNXQgVP27dvj5VW\nEzhoUgYvlShRwnub7ataim6++Wb7y1/+Ygq8lJRHnz59bO/evdke4+dKWpD81CYvBBBAAAEE\nEEAAAQRCLNCpUyfTmKQ77rjDFi1a5Lq83XXXXS6gqVSpkiu5AqVZs2a5cUZ6IKwmdFCA47Uq\nVatWzXWf0+QM8bPfeZetFqrq1avb+vXrXUCkCRquu+46++WXX+hi5yHxigACCCCAAAIIIIAA\nAsELlClTxp577jk3q9zRRx9tNWrUcNN3T5o0yb1XCRUQHX744W7ihtq1a7sWp86dO5vXctSh\nQwcrVaqUC7Q0pilzUh6aGW/q1KmuW12dOnXcGKeePXvaxx9/nHl335dLRCO9xA6Evheh+GbY\nKTrQ7JljmlvpPJoRvSvMmDjFe8srAggggAACCCCAgE8CmzZtsgEDBrjn8/iUpctme79evmWX\njO+ZW7ZscS1Aau3JLmma8IMPPthN6Z3ddo1n0tij3JK65ilAUqtSWFJ4ShIWEcqBAAIIIIAA\nAggggAACVrly5VwV1HqUW8orONKxemZS2BJjkMJWI5QHAQQQQAABBBBAAAEEAhMgQAqMnowR\nQAABBBBAAAEEEEAgbAKh7mKnJ/m+9957Wcw0u4YGdylpxoyFCxfa4sWLrWnTplmevJvXdp1j\n9erV9u6775pm3Gjfvr0bJKb1JAQQQAABBBBAAAEEEEgvgVAHSHp678iRI2MzZnhV065dOxcg\nKfgZOHCgm0bw5JNPtunTp5uCp8GDB7td89qunTQjx/jx401PBV67dq1bHjNmjFWtWtXLjlcE\nEEAAAQQQQAABBBBIE4FQB0jLli1zT+wdN25cttWhgEgPqZo2bZrpacCrVq1yD5jq3r27m1Yw\nr+1qOZowYYKNHj3aWkZnpNM87Qq4dD69khBAAAEEEEAAAQQQQCC9BEIfIOlBVTmluXPnWpcu\nXVxwpH00H3uLFi3s1VdfdQFSXtsXLFhgdevWdcGRjtf0gl27drWnnnqKAEkgJAQQQAABBBBA\nAIFCCyRj6u1CF4YD8y0Q+gCpXLlyNmTIEFuyZIk1a9bMrrnmGqtXr567wHXr1rkAJ/5qFfBs\n3Lgx39u9c3nn0PGaK3/v3r1WsuT+OSzef/99e+WVV7zd3OteHiGV4MECAggggAACCCCAAALF\nXSC0AZImaFi/fr17cNSll15qGmM0Y8YMGzRokE2ePNkOOuggF8hUqlQpoQ60vHTpUtddToFO\nTtt1kM6febsedqXgSA/Gih+HpABtypTEB73WigZvQaeCPoCMv2QEXWPkjwACCCCAAAIIIBBm\ngdAGSBkZGfbvf//bzSxXtmxZZ9i8eXPr16+fvfbaa3bOOee4Fh6NG4pPWtZ4pFKlSuW6Xcdo\nJrzsjte2ChUq6CWWzj77bDvhhBNiy3oz6LLLEpZZQAABBBBAAAEEEEDAE6gz62XvbdJf15/V\nNel5pEsGoQ2QSpQo4VqP4iuiYcOGVrNmTTdrnbZrWm61NMWnrVu3uuPy2q5jatSoYStXrow/\n3HS8Wo7UtS8+KS/9xCflQUIAAQQQQAABBBBAAIHUEdg/yCZk16TARa1Fa9asiZVMY46+++67\n2BgkBUyLFi2KbdcbPQ/JG1eU1/YGDRq4sU3xrUg6n3d8wolZQAABBBBAAAEEEEAAgZQXCG2A\ndMQRR7hxRo888oj98MMPrtXo4Ycfdq07p512mquYHj162Jw5c1xQFIlOmDBz5kzbtWuXdevW\nLV/bO3fu7PbT2CKNO1qxYoXNnj3bTRWe8jXPBSKAAAIIIIAAAggggEAWgdB2sVNJ//jHP9rw\n4cPt/PPPdwVXi9DYsWNj44Patm1rPXv2dBM3aDyRWn5uu+020/glpby2qxvdiBEjbNiwYW4C\nhvLly9sFF1xg7du3d8fzDwIIIIAAAggggAACCKSXQKgDpKZNm9qTTz7pZqtTAFS5cuUstdO/\nf3/r3bu3GzukMUWZU17bjzvuOHv22Wdtw4YNbnxT/NTemc/FMgIIIIAAAggggAACCKS2QKgD\nJI8+u8DH26ZXzXKX2z55bdc5ateurRcSAggggAACCCCAAAIIpLFAaMcgpXGdcOkIIIAAAggg\ngAACCCAQkAABUkDwZIsAAggggAACCCCAQHETmDRpkr3yyitFVmw9YudAkuYnWLBgwYGcIsux\nBEhZSFiBAAIIIIAAAggggAAC2QkoQHr55aJ5AK5mj+7a9cAecPu3v/3N5s+fn11RC72OAKnQ\ndByIAAIIIIAAAggggAAChRX4/PPPbceOHYU9PGnHESAljZYTI4AAAggggAACCCAQPoGPP/7Y\nrrjiCtOzRX/3u99l6aK2cOFCt/7000+3P/zhD7Z27docL0Jd5PSYHbUE9enTx1577bUs+6rV\nSdv69u3rnlu6e/due+utt9z7b775xuWl554q5ZX3f/7zH7vyyivtoosuKtKufvGFJkCK1+A9\nAggggAACCCCAAAIpLKBH23Ts2NEOOuggF5iUKFHCTjrpJFuyZIm76tdff93atWtn27dvd0HI\n+++/b8ccc0y2QZJaf44//nh76aWX7Nxzz7XSpUtb9+7dTQGRl+6880677rrr7JBDDrETTjjB\nrr32Whs3bpzVqlXLDj30UPd80xNPPNHNSp1X3urad84551gkEnHn0uN8Vq1a5WVVZK/FYprv\nIrtaToQAAggggAACCCCAQBoLqFvbzp07bdiwYS5IueSSS6xZs2Yu6BDLjTfeaGeeeaY99dRT\nTkktTK1atbKRI0eaJkSIT2PGjLF169bZhx9+6J5X+vvf/94aN25sN910k3tO6fr162348OGu\ntahDhw7u0Lp169ozzzzjgqY2bdrY8uXLXaCmjXnlrdasW2+91e644w53rosvvtjl5xaK8B8C\npCLE5FQIIIAAAggggAACCIRZQEHJkUceab/5zW9MXegUDKnrW/Xq1e2XX36xTz75xLX2DBky\nJHYZpUqVckFQbMW+N5o9rk6dOnbPPffENn377bemVip1nfvss8+sXLlydsopp8S29+jRw/ST\nOeWVt1qrli1bZr/97W9jhzZo0CApARJd7GLEvEEAAQQQQAABBBBAILUFMjIy3JgjBTVqSbr6\n6qutYcOG9sYbb5jGE+3du9e0T8mSJWM/Xbp0sQsvvDALjMYNVahQIbafjqlfv77dcsstbp0C\npfLly5u68eWV8sp727ZtrmwavxSfypQpE79YJO9pQSoSRk6CAAIIIIAAAggggED4BZYuXWof\nfPCBC4wUHCkwUUuSus/NnDnTKlWqZOoGpy51XtLECNkFIo0aNTJt+/Of/+wCIu3/1Vdf2bx5\n86xmzZquperHH3+0jRs3uu582q4JIjQuaerUqQmBk/bPLW+1VOlH+WkMldJ3331nn376qXtf\nlP/QglSUmpwLAQQQQAABBBBAAIGQC1x++eU2Y8YM27NnjwuQ1BKkbndKGkekSRaef/55t/3t\nt992EzBs2rQpy1UNGDDAdaXTeCadQ+ORevXqZbNmzXKTLrRv396aN29uAwcOtBUrVriA5vbb\nb3fBk1qeqlWr5o5R0KaWobzyVrmffPJJe/PNN11+CrQ0YUNRJ1qQilqU8yGAAAIIIIAAAggg\nEFIBTaLwl7/8xU3NrYBDY380A52m6lZS0KEZ7DROSLPS1a5d2026oGm1M6fWrVvblClT3FTg\n9913nxtv1LlzZ9PDW5V0vFqlNMW38lXXPY150sQNSpq4QeObmjRpYu+9916eed99992mQE0z\n5Sm4U8uXJpAo6lQiGnUVfdhV1KUM6fk6tWxpzxzT3Erno1+lLiFj4pQiv5Lt/XoV6JzJKEOB\nCsDOCCCAAAIIIICAzwL6Uq3WDn1Z9zPVmfWyb9mtP6trgfPSLHNVqlRxU35nPvjXX391ky1o\nKu78JE3OoG5yZcuWzXb3zZs3uwBKQVLmpG54KoeX8sr7559/dkFcjRo1vEOK9JUWpCLl5GQI\nIIAAAggggAACCBQPAY3pySlpzFF+gyOdo169ejmdyq3XLHk5pfjgSPvklbee4aSfZCXGICVL\nlvMigAACCCCAAAIIIIBAsRMgQCp2VUaBEUAAAQQQQAABBBBAIFkCBEjJkuW8CCCAAAIIIIAA\nAgggUOwECJCKXZVRYAQQQAABBBBAAAEEEEiWAAFSsmQ5LwIIIIAAAggggAACCBQ7AWaxK3ZV\nRoERQAABBBBAAAEEioNAYabeLg7XleplpAUp1WuY60MAAQQQQAABBBBAAIF8CxAg5ZuKHRFA\nAAEEEEAAAQQQQCDVBehi52MNF+RpyjTJ+lgxZIUAAggggAACCCCAwD4BWpD4KCCAAAIIIIAA\nAggggAAC+wQIkPgoIIAAAggggAACCCCAAAL7BAiQ+CgggAACCCCAAAIIIIAAAvsECJD4KCCA\nAAIIIIAAAggggAAC+wQIkPgoIIAAAggggAACCCCAAAL7BAiQ+CgggAACCCCAAAIIIIAAAvsE\nCJD4KCCAAAIIIIAAAggggAAC+wQIkPgoIIAAAggggAACCCCAAAL7BAiQ+CgggAACCCCAAAII\nIIAAAvsECJD4KCCAAAIIIIAAAggggAAC+wQIkPgoIIAAAggggAACCCCAAAL7BAiQ+CgggAAC\nCCCAAAIIIIAAAvsECJD4KCCAAAIIIIAAAggggAAC+wQIkPgoIIAAAggggAACCCCAAAL7BAiQ\n+CgggAACCCCAAAIIIIAAAvsESiOBQFEIbO/XK9+nyZg4Jd/7siMCCCCAAAIIIIAAAn4K0ILk\npzZ5IYAAAggggAACCCCAQKgFCJBCXT0UDgEEEEAAAQQQQAABBPwUIEDyU5u8EEAAAQQQQAAB\nBBBAINQCBEihrh4KhwACCCCAAAIIIIAAAn4KECD5qU1eCCCAAAIIIIAAAgggEGoBAqRQVw+F\nQwABBBBAAAEEEEAAAT8FCJD81CYvBBBAAAEEEEAAAQQQCLUAAVKoq4fCIYAAAggggAACCCCA\ngJ8CBEh+apMXAggggAACCCCAAAIIhFqAACnU1UPhEEAAAQQQQAABBBBAwE8BAiQ/tckLAQQQ\nQAABBBBAAAEEQi1AgBTq6qFwCCCAAAIIIIAAAggg4KcAAZKf2uSFAAIIIIAAAggggAACoRYg\nQAp19VA4BBBAAAEEEEAAAQQQ8FOAAMlPbfJCAAEEEEAAAQQQQACBUAsQIIW6eigcAggggAAC\nCCCAAAII+ClQ2s/MCpPXzp077d1337W1a9daixYtrFWrVgmnmTdvnu3YsSNhXbNmzax+/fpu\n3Z49e2zhwoW2ePFia9q0qbVu3TphXy2sXr3a5VGtWjVr3769ZWRkZNmHFQgggAACCCCAAAII\nIJD6AqEOkF5++WV74IEH7Oijj7YKFSrYE088YWeddZbdeOONrmYU/Nxxxx128MEHW+nS+y/l\nqquucgGStg8cONDWrVtnJ598sk2fPt06depkgwcPjtXspEmTbPz48Xbqqae6IEzLY8aMsapV\nq8b24Q0CCCCAAAIIIIAAAgikh8D+qCJk17t3716bOHGiC3AuuugiV7q3337bhg4dauedd541\natTI1qxZY7t27bLHH3/cqlevnuUKFBBt377dpk2bZhUrVrRVq1ZZnz59rHv37takSRPXcjRh\nwgQbPXq0tWzZ0nbv3u3y0/4KrEgIIIAAAggggAACCCCQXgKhHYP0/fffu+5wXbp0idXIcccd\n596ru53SsmXLrEaNGtkGR9o+d+5c0/EKjpQOP/xw103v1VdfdcsLFiywunXruuBIK9QK1bVr\nV/O2u534BwEEEEAAAQQQQAABBNJGILQtSAp84rvCqUZee+01K1WqlGv90fLy5ctd97pRo0aZ\nxiKpW1zfvn2tQ4cO2uy61ikAik9a3rhxo1ulrnf16tWL3+wCpk2bNplasEqW3B8/zp8/3156\n6aWEffdGIgnLLCCAAAIIIIAAAggggEDxFghtgJSZ9auvvrJHH33UevXqZbVr13ably5dampp\naty4sZtcQQGMuuDdf//9rvVJgU6lSpUSTqVlHae0fv36LNs1nknB0ZYtWxLGIX355Zc2derU\nhHPVKlcuYZmFYAW29+tVoAJkTJxSoP3ZGQEEEEAAAQQQQCD1BYpFgPTpp5/akCFD7Le//a1d\neeWVsVq56667XDDjTajQtm1b16qkMUR6rxYgjSuKT1r2utyVKVMm2+3aX5NCxKezzz7b2rRp\nE7/KBl5yScIyCwgggAACCCCAAAIIIFC8BUIfIGkc0Z133mkXX3yxDRgwIEG7cuXKCctaaNeu\nnb3zzjtWokQJ07Td27ZtS9hn69atVqdOHbdO3fhWrlyZZbsCrnKZWod0Lv3EJ+VBQgABBBBA\nAAEEEEAAgdQR2D/IJoTX9MYbb7hpvK+77roswZGKe/PNN9uMGTMSSv7JJ5+4cURa2bBhQ1u0\naFHCdj0PyRt31KBBA1uyZElCK5L297YnHMgCAggggAACCCCAAAIIpLxAaAOkzZs327333msd\nO3a0I444whT4eD8ad6SkWe303CLNZvfLL7/YzJkzXcCj1ialHj162Jw5c9xDYiPRCRW0XdOC\nd+vWzW3v3Lmze50yZYrrqrdixQqbPXu2mwrcbeAfBBBAAAEEEEAAAQQQSCuB0Hax04QLO3fu\ndFNuZ552W+OR9Cyjc8891zQ+qX///la2bFnXLU6TNKibnZLGIfXs2dMGDRpkGm+klqHbbrvN\nMjIy3HZ1oxsxYoQNGzbMFCSVL1/eLrjgAjfhg9uBfxBAAAEEEEAAAQQQQCCtBEIbIPXu3dv0\nk1tSQDNy5EjbsWOHG2uk2e0yjwtS8KTzaOyRxhxlTmqFevbZZ23Dhg1Ws2bNhKm9M+/LMgII\nIIAAAggggAACCKS2QGgDpIKwa1Y6b2a67I5T61J2wVH8vt7U4fHreI8AAggggAACCCCAAALp\nJRDaMUjpVQ1cLQIIIIAAAggggAACCIRBgAApDLVAGRBAAAEEEEAAAQQQQCAUAgRIoagGCoEA\nAggggAACCCCAAAJhECBACkMtUAYEEEAAAQQQQAABBBAIhQABUiiqgUIggAACCCCAAAIIIIBA\nGAQIkMJQC5QBAQQQQAABBBBAAAEEQiGQEtN8h0KSQiAQFdjer1eBHDImTinQ/uyMAAIIIIAA\nAgggkFwBWpCS68vZEUAAAQQQQAABBBBAoBgJECAVo8qiqAgggAACCCCAAAIIIJBcAQKk5Ppy\ndgQQQAABBBBAAAEEEChGAgRIxaiyKCoCCCCAAAIIIIAAAggkV4AAKbm+nB0BBBBAAAEEEEAA\nAQSKkQABUjGqLIqKAAIIIIAAAggggAACyRUgQEquL2dHAAEEEEAAAQQQQACBYiRAgFSMKoui\nIoAAAggggAACCCCAQHIFeFBscn05OwKBCBTkgbU8rDaQKiJTBBBAAAEEEAipAC1IIa0YioUA\nAggggAACCCCAAAL+CxAg+W9OjggggAACCCCAAAIIIBBSAQKkkFYMxUIAAQQQQAABBBBAAAH/\nBQiQ/DcnRwQQQAABBBBAAAEEEAipAAFSSCuGYiGAAAIIIIAAAggggID/Asxi5795oDnWmfVy\ngfJff1bXAu3Pzgh4AgWZSU/HMJueJ8crAggggAACCAQpQAtSkPrkjQACCCCAAAIIIIAAAqES\nIEAKVXVQGAQQQAABBBBAAAEEEAhSgAApSH3yRgABBBBAAAEEEEAAgVAJECCFqjooDAIIIIAA\nAggggAACCAQpwCQNQeqTNwIIJFWAiSKSysvJEUAAAQQQSEkBWpBSslq5KAQQQAABBBBAAAEE\nECiMAAFSYdQ4BgEEEEAAAQQQQAABBFJSgAApJauVi0IAAQQQQAABBBBAAIHCCDAGqTBqHIMA\nAggUQKAgY6F4YG4BYNkVAQQQQACBJAjQgpQEVE6JAAIIIIAAAggggAACxVOAAKl41hulRgAB\nBBBAAAEEEEAAgSQI0MUuCaicEgEEEAibAN38wlYjlAcBBBBAIKwCtCCFtWYoFwIIIIAAAggg\ngAACCPguQIDkOzkZIoAAAggggAACCCCAQFgF6GIX1pqhXAgggECKCRSkm58unRn9UuwDwOUg\ngAACxUSAAKmYVFQqFbPOrJcLdDnrz+paoP3ZGQEEEEAAAQQQQACBwgoQIBVWjuMQQAABBIqd\nAK1Yxa7KKDACCCDguwABku/kZIgAAgggkO4CBQnU6GqY7p8Wrh8BBPwWYJIGv8XJDwEEEEAA\nAQQQQAABBEIrQAtSaKuGgiGAAAIIIJA8gYK0YqkUtGQlry44MwIIhEuAAClc9UFpEEAAAQQQ\nSBsBgrS0qWouFIFiJUCAVKyqi8IigAACCCCAQFELFCRQoyWtqPU5HwLhEyBACl+dUCIEEEAA\nAQQQSDOBggRpoiFQS7MPCJfrqwABkq/cZBYmgYI8j4lnMYWp5igLAggggEAyBAjSkqHKOYuj\nAAFScaw1yowAAggggAACCKSgAEFaClZqMbwkpvkuhpVGkRFAAAEEEEAAAQQQQCA5AgRIyXHl\nrAgggAACCCCAAAIIIFAMBehiVwwrjSKnjkBBxkHpqhkLlTp1z5UggAACCCCAQDgFaEEKZ71Q\nKgQQQAABBBBAAAEEEAhAgBakANDJEoEwCdCKFabaoCwIIIAAAgggELQALUhB1wD5I4AAAggg\ngAACCCCAQGgEaEEKTVVQEATSW6AgLVmMxUrvzwpXjwACCCCAQDIFCJCSqcu5EUCgWAkUJEjT\nhRGoFavqpbAIIIAAAgjkS4AAKcq0evVqe/fdd61atWrWvn17y8jIyBceOyGAAAJFLRCGIC0M\nZShqV86HAAIIIIBAfgXSPkCaNGmSjR8/3k499VRbu3ataXnMmDFWtWrV/BqyHwIIIIBAEgQK\nEqglqzWvIGUQQbLKkQReTokAAgggkINAWgdIajmaMGGCjR492lq2bGm7d++2gQMH2rRp09xr\nDmasRgABBBBAwDeBsARpBSlHsgLFgpRBFZSscvhW+WSEAAKBCKR1gLRgwQKrW7euC46kX7p0\naevatas99dRTBEiBfBzJFAEEEEAAgXALhCVIK0g5khUoFqcylNi21Wps2x7uDxelC41AWgdI\n69ats3r16iVUhgKmTZs22d69e61kyf2zoGuM0uzZsxP23RuJ2D0rVlmJEgmrc1woP31qjtsy\nb7ht/tzMq7Jd3r1iZbbrc1pZkDLoHMkoRxjKoGsrSDmS4VDQMmj/ZJSjIA7JKkNBLZLhUNAy\nJMsiDPURhjIUtD74TEjsfykMFmEogzSSUQ7+f+z7oEVfCmKRjLpQSfJdhl9/3V9w3iGQh0CJ\nSDTlsU/Kbh46dKhVqFDB9Oqlzz77zK6++mp7/vnnE8YhTZw40UaOHOnt5l4ffPBBO/jggxPW\nZbewY8cOe/zxx61Ro0bWrVu37HbxZZ1axr7//nsbNGiQL/lll8n8+fNNLXfnn3++1a9fP7td\nkr5uw4YNrhululV26NAh6fnllMFjjz1mZcuWtX79+uW0S9LXz5kzxxYvXmy9e/d2k5QkPcNs\nMvjqq6/sxRdftJNOOsmOP/74bPZI/ir9QWTs2LHuDyYXXnhh8jPMIYdnn33WTRqjrr76bASR\nPvnkE3vrrbfsjDPOsCZNmgRRBNu6dav985//tMaNG7tW/UAKEc108uTJtn379kB7FMybN88+\n+ugj0+cy8x/0/HLR+NwZM2ZYq1at7OSTT/Yr2yz5PPLII1axYkXr06dPlm1+rXjllVfsyy+/\ndPftypUr+5VtQj5Lly61l19+2f3+0u+xINKv0WDj73//u/s9rt/nQaWZM2fat99+677XlCpV\nKs9i6DubPsckBPISSOsWpDJlyrhxR/FIGoekpMApPp1zzjnWtm3b+FXWsGFD0znySvpC/sc/\n/tF159NkEEGlhx56yJYvX+4mpAiqDAsXLrTPP//cbrjhBjdjYBDl+PTTT10ZdJMMsj5uvvlm\n98s+yDLol73q45hjjrEjjzwyiOqwXbt2uTKceeaZgdWHftkrKDnooIMCK4Pw9YcY1Ue7du0C\nm01TYzNVhssvvzwwi2+++cZuvPFGO/zwwwMrg+rj/vvvN/U0CPL/6AcffODqY8iQIda6dWsV\ny/f04YcfujK0adMmUIvBgwdbrVq1Ai3DrFmznIUCk8MOO8z3ulCGCtr1f1TfS4L6bO7cudMF\nJQo4giqDLDTJliwUuAf1RyWVg5R6AmkdINWoUcNWrlyZUKv6y6VmsCtXrlzCeq1jZrsEEhYQ\nQAABBBBAAAEEEEg5gf2DbFLu0vK+oAYNGtiSJUsSWpEWLVoUWDeGvEvMHggggAACCCCAAAII\nIJBMgbQOkDp37uxsp0yZ4iZlWLFihZuIoaj7N2t2PHUVqVmzZjLrMs9zawIKlSPIVKVKFVcG\ndWUKKqkZXg56MHCQSWOwghqH5V139erVnUV+uop6xxT1q7qzqj4qVapU1KfO9/lKRGdaURkO\nOeSQfB+TjB1r167tyhE/QUwy8sntnOoyI4sgH5itz6PKoO5UQSbdM4PqRuVdt3ouyCJzrwZv\nux+vul+rDEHfM1UXQY3D8pzV80QWQd4z9X9TZQhqDJQsdI9SGerUqePRBPKq/FUO3cNJCBSl\nQFpP0iDIjz/+2IYNG2bqT1u+fHk799xzrX///kVpzLkQQAABBBBAAAEEEECgmAikfYDk1ZMm\nUlALT5B/ufXKwisCCCCAAAIIIIAAAggEI0CAFIw7uSKAAAIIIIAAAggggEAIBdJ6DFII64Mi\nIYAAAggggAACCCCAQIACpe6KpgDzT5us9+zZY5MmTXLPTgpisK3GWOnhj3PnzjWVJYjB6D/+\n+KP95z//cTMHanBpfh6ym8wPyL///W838Nnvgcd6FpWeK6IHpHo/P/zwg3tOVjKvN/O5VR+v\nv/66ewilBoL7PUnCq6++6p7L5Rl4r+ru6vfAeOU5e/Zs90wmDfoNYsCv9/BHPZRTk2doTKRf\n6e2333YPkc58X9C9QuM0X3vtNWeTzAHyetijnst11FFHZXvZftxDc8vDz3toTvWh5/S9//77\npu1KmtQjWSmv+lC+yb6H5lQfft9Dc6oPP++h2dWH3/fQnOpDnwW/7qG5lSHIe6gMSKklQIDk\nU32OGzfOBUiaBMLvwEBP3L7mmmtsy5Yt7kcPVtu0aZOvD2rVF/Frr73WIpGI+1L82GOPWbNm\nzXwPCrzqfuGFF2zUqFHWokULa9Sokbfal1d9FqZNm+YebvfRRx+5AEV107FjR1/yVyYKRgYN\nGuQegvnzzz+bHiK8d+9eO+6443wrw+233256COZ///vf2I8CaH0ROPvss30rx8iRI2306NHu\nob16CKRmtTzllFN8/X+qp8EPHTrUPQBSD0n929/+ZieccIIvs7jp4c16aLGCUj0w2Ev6IqKH\n5+r/igLoyZMn2/r1691DbL19iupVD77Uw7T1XDo9/DK75Mc9NKc8/LyH5lQf+jLes2dP9wcm\nBfC6j+u+ceKJJ2bHdUDr8lMfftxDc6oPP++hOdWHn/fQnOrD73toTvXh5z00pzIEeQ89oP9s\nHBxegegXVlISBaJfKCLRJ8JHfvvb30aiT3qORL/8JTG3rKeOfsmJRH+pRqZPnx7bGG1JcmVZ\ntmxZbF0y3+zatSty0UUXRZ566qlYNtEbauSqq66KLfv5Zs2aNZGzzjor0qlTp8hLL73kZ9Yu\nr969e0eif3n1Pd/4DG+44YbILbfcElv13nvvRU4//fRI9EHJsXV+v4kGi5HoE9kjn3zyiW9Z\n6/+A/l9GAzWXZzRIjFxyySWR++67z7cyfPfdd+6z+Oijj8by1P/X6B9TItEvRrF1Rf3m119/\njTzxxBMu72hwHokGQAlZPPnkk+7e4ZUhGrxEooFjJPrsuIT9DnRh/vz5kQsuuMDdI6+88sos\np/PjHppbHn7dQ/OqjzFjxiTcM/V/Vp9dlb0oU171obySfQ/NrT6Uvx/30Lzqw697aH7qQyZK\nybqH5lYfft1DcytDUPfQ/6nzb6oKMAYpybHrvffe61pNol+4kpxT9qf//vvvrXXr1talS5fY\nDl4rgbry+JH0l2i1YMX/ZVh/kVbZ/E7qojJixAjr16+f68Lkd1eqX375xVavXm1NmjTx+9Jj\n+ane1U1HrQNeatOmjU2YMMGCej6Vui/dc889dtlllyW0YnjlS9Zr9EuQO7X3vB19Hg499FD7\n6aefkpVllvN+8cUXpnLEt5rpGW3qdqnWtWQldSl88cUXTX/9ze55XOqOq/tGxYohuwLJAAAR\nJklEQVQVXRH0rBG1uKpbT1Glbdu22a233mpnnnmmXXrppdme1o97aG55+HUPzas+on88sD/9\n6U8xI91DlfQ5KaqUn/rw4x6aW334dQ/NrT78uofmpz68uk/mPTS3+vDrHppbGYK6h3r2vKam\nQOnUvKzwXNWQIUNcP/FVq1YFUig91G7w4MEJeWs8QalSpXz7kq4v3R06dHBl2Lx5sy1YsMCe\neeYZi/61OKFcfixMnDjR9GDSCy+80AUEfuQZn8fXX3/turJF/ypof/3rX12XqmhLll1xxRW+\nPQgy+tdfV/8KBh544AHTZ7N58+Z2+eWXB/bww0ceecRdv9/PIFOgeuyxxzoHdV/S2IbPP//c\nBQ3x9Zbs96oL/Z/0kr50qMujuhsmK5100knWrVs304OsH3744SzZrFu3LksXWD04dePGjVn2\nLewKjbOKtpa5MVf//Oc/sz2NH/fQ3PLw6x6aV3143R8VIKjbl+5lWte4ceNs3QqzMj/14cc9\nNLf68Osemlt9+HUPzU99ePWczHtobvXh1z00tzLIIIh7qGfPa2oK0IKU5HpN5iDawhRd/aaj\nXXmsV69eSR3gm1PZhg8fbvfff7/pS4fGefiZ9MX32WefdX+x1s00iBTtjuCy1ZccjQE67bTT\n7LnnnrMHH3zQt+Jo/JmC1ptuusn9Ujn++OPd5Bl/+MMf3Jdy3wqyLyP9lVQtGT169HBf1v3M\nX889GzBggBvXoflqNK5DdaKgya+ksXhlypSxqVOnmv46rxbXp59+2mWvvwonK2kiCAVH2SWV\nQ5+TzBN3aLkoW36Vv8qRW/LjHlqQPJJ1D82tPuJ9nn/+edPYk0WLFlm0O2iRPrsvr/rw6x6a\nW334dQ/NrT78uofmVR/e5yLZ99Dc6sOve2huZQjqHur585qaAtn/dkzNa037q/r0009Nf4WJ\njocKpPVGFaDB8BpsrEka+vTpYxpYqRntkp30RVNd666//nr3QOBk55fT+aPjfNzge2+2sFat\nWrmWA/31XN0QM38hzek8B7JeX3537Nhhaq25+OKL3ak0IcDVV1/tut61a9fuQE5f4GM1MYO+\nCMjG76TZBNXCqv8X6k6m1jR1ORs2bJgpmPcj6Y8F1113nZsoQ5OZqCWpQYMGpi5tfs5kF3+t\nKoO++OizEp+07HW5i1+fLu/DcA+Njue0888/39555x277bbb3B98unbtmvQq4B66n5h76H4L\n7qH7LXiXWgIESKlVnzlejcYT3Hnnne4Lsf5iHmSqUqWKRSdocNMqRwcamx+/3PVXV/3VT+Mn\nvDEUChI0m5y6Vak1x4+kKd694MjLr23btqYAKToI1ZcAqWbNmi5rjWnwksaWKDjTDGp+J82G\npTEo6vrod3rjjTfctNLqaqakGQ01Duruu+82fSH0q0ya3VJjAz/77DM3HkhTXZ933nl5tq4k\ny0strJr+Xn+Zjk/RSTxM06CnYwrTPVR/UFDXXLW86jPMPZR7KPfQcN1D0/EemWrXTBe7VKvR\nbK5Hv0DvuOMO91fqIIIjTd2rMT/xk0Joaml1JYrOfpJNiYt+lcbY9O3b14210Xv96K/kGlNx\nxBFHFH2GOZxxxowZbkrl+M3RWdtcV7fMgVP8PkX53rteBWReis4CZPry623z1if7VWPS1GUp\nPlhLdp7x59fnMHOLiD4X+guxukH6kVQGBcgZGRnWvXt3N65EQbumcPbGnfhRjsx5NGzY0HXj\nil+/ePFiS+azkOLzCtP7oO+hslAXWD13KD5p+mfuoWbcQ7mHhvEeGv9/lffFT4AAqfjVWYFK\nrC+gmv0lOo2v+/KrXyTeT1GOJcitUPrSrf7DGkSqL316oJwGhatrnVpP/Ej6oqmZ6+J/NA5H\n46D0pdSv1L59e9eNTeOO9CVcz0HSe/0F2K/nYyko1OdB3R31+VCdPP744+6ZOzk9pDNZPgqe\nldSlLIik7qbqIjJnzhw3/krBmp6DpNYcb5awZJdLn0PNVhedctsFZZqVTM+lUktWkK01GhMm\nFwVF+hKu7rDRKfvdxA7JNgnT+cNwD5WHJg3QZ1OfUQXvum9oHJJaDvxI3EP3K3MP3W/BPXS/\nBe9SS4AudqlVn1muJvqcH9dVKL5rmbeTxl34FRzoIZB33XWX6zak2bk0vkIzqPn1JdS75qBf\n9YtV3fnGjh1r0eeauFa0M844I8tMg8kup6YL1rTaatlTi4laBTRRhF9dyrzrU4Ckz4C6XQaR\n9KVT43/0WdRU/GrN0ZTn+r/hZ/I+E5rqWxM2KHD/v//7Pz+LkCUv/fFCM/upbCqTPiMa86KW\nrnRKYbmH6jEJ6oJ5eXS2ybJly7pxe7qvqqtdOiXuoYm1zT30fx5hvIcm1hRLxU2ghB7wVNwK\nTXmLr4CmCFb/eY1vSOek1iNZaIC+vuwElTTORkFButeHgnZ1OVSg5neQGF/3msBEAYj+j4Ql\nqdVI3S/1WSUFL6BudaoPtcrrjxvpmriHhqvmuYeGqz4ozYELECAduCFnQAABBBBAAAEEEEAA\ngRQRYAxSilQkl4EAAggggAACCCCAAAIHLkCAdOCGnAEBBBBAAAEEEEAAAQRSRIAAKUUqkstA\nAAEEEEAAAQQQQACBAxcgQDpwQ86AAAIIIIAAAggggAACKSIQnqmSUgSUy0AAAQTyK6BJRPUs\nGz3bpnHjxtasWbP8Hsp+CCCAAAIIIJAkAVqQkgTLaRFAAIHcBH799Vc79dRT7eijj3bPB9Nz\nqEgIIIAAAgggELwALUjB1wElQACBNBSYM2eOvfPOO9arVy+76aabrFatWmmowCUjgAACCCAQ\nPgECpPDVCSVCAIE0EPj222/dVV511VV27LHHpsEVc4kIIIAAAggUD4FSd0VT8SgqpUQAAQRS\nQ2DcuHH2wgsv2LJly6xMmTL24Ycf2kknnWT/+Mc/bPXq1bZ9+3a79dZb7csvv7QmTZpYxYoV\nbffu3fb444/bI488YtOmTbOvv/7ajjrqKDvooIOyoLz55pv297//3SZNmmQ//vijO8ef//xn\nq1Klih1yyCG2ePFiGzt2rNWvX9+qVasWO37NmjU2atSo2H7ehs8++8zt//DDD9v8+fNdmRs0\naOBtdq8q+4oVK6x27dqm/caMGWPz5s2zSpUquXzid9b16fq13+zZs935DjvsMCtVqpRt3brV\nRo4caVu2bLGmTZvGH2br1q2zv/zlL5aRkWH16tVL2MYCAggggAACRSYQHSRMQgABBBDwUeCK\nK66IRCdliERv5JETTjgh0rFjx8jOnTsjLVu2dO9r1qwZKVmypPv55ptvIhs3bnT7aX8dd955\n50WiwU7k8MMPj0QneUgoeXQskztvNOCKKJ9oQOT217FPPPGE23fGjBlun5deeinh2Llz57r1\n3n7aGA3IImXLlnU/Z599dqRVq1ZunxtvvDHh2NatW0dOPvnkSDSgixx88MGR6PiqSDSwi0SD\nnojy89JPP/3k9osGhpHTTz890qlTJ3ed0Va0SDQIdLtFx2VFosFbZO/evd5h7jUaOEVKlCgR\niU5qkbCeBQQQQAABBIpSwIryZJwLAQQQQCB/AtEWHhdofPTRR7EDFCApkBk8eLALmJYsWeK2\n9e/f361/+umnY/uuWrXKBT+nnHJKbN3bb7/tgo1rr702tm7Dhg2RRo0aueO9wCe/AVK0hcsF\nRgpivvvuu9g5hw4d6s4XHUcVW6cASWWPjqdyZdeGpUuXRqKtPZF27drF9uvTp0+kdOnSEQVj\nXpo1a5Y79tFHH3Wroq1YbvmNN97wdnGv0RalSIcOHRLWsYAAAggggEBRCzCLXfQ3OgkBBBAI\ni0C05cjuvvtuK1++vOsapy5yEyZMsGiQYeeff36smOqSdtlll7mJHj799FO3PhpomI6P7zmt\nyR/UXa8wSV3gdu3aZUOGDLEaNWrETnHDDTe4bnHqKhifypUrZ+rKp7Ir/eY3v3Hjq6LBnFuO\n/gKz5557zi6++GLXpdCtjP7TvXt307mOOOIIt0oTV6jr4eTJk71d7IMPPrBowGiXX355bB1v\nEEAAAQQQSIYAkzQkQ5VzIoAAAoUU0Lig+HFFGqekwEJjcxRYxKdo9zu3GG2psWOOOcY+/vhj\nq1u3bsK4Iu1w4oknxh+W7/caAxXt0ubGRo0fPz7huAoVKpjyjU8qe7Q7XvwqNzufxjwpadyU\nriPaUpawjxauvvrq2DoFdQqaoi1dbuyTPP71r3+5sVgXXXRRbD/eIIAAAgggkAwBWpCSoco5\nEUAAgUIKVK9ePeHITZs2uWW1yqh1KP5HrUiXXHKJRcf8uH02b97sgoiEE0QXqlatmnlVtst7\n9uxJWK+81SoU7RKXkK/K0LVrV2vbtm3C/gqaMicFWArwlLyZ+7zyZt43fjk6fspN1KBWMT0z\naurUqXbhhRe6CRri9+M9AggggAACRS1AC1JRi3I+BBBAoAgFGjZs6M4WnZzBpkyZknBmBTSa\n+c1L0bFG9uKLL7qARIGJl9auXeu9da/eMQo84pNm0ItPynvBggU2fPhwU/7xSbPqKXAqSPJm\nvvMCpfhjn332WdP1KAhS6tatm2t9mj59ugsAFaz169cv/hDeI4AAAgggkBQBWpCSwspJEUAA\ngaIRUJBSp04de+aZZ1z3tPizaqyOpu72xvicdtpptmPHDtc1LX6/p556Kn7RHaMVX3zxRcL6\n119/PWFZU48rqXtbfNKYJ021ff3118evzvO9puZWNzx1nYvOUBfb//vvv3cPzP3b3/4WW6fg\nq3fv3hadac8UJEVn7LPoZBGx7bxBAAEEEEAgWQIESMmS5bwIIIBAEQhosoIHHnjAotNjW3R6\nb3vrrbfchAWaKEHPQ7ruuutc8KCsrrzySjcWSQ+fVVATnQLc7r33XvdMoviiaEySAitNBvHY\nY4+ZAqNrrrnG1J0tPg0YMMCaNWtmf/3rX2306NHufE8++aT17NnTBUi33XZb/O55vler1n33\n3ecmW9B4qvfff98FQJdeeqm7vptvvjnhHOpmp2cmTZw40fr27evGQyXswAICCCCAAAJJEChY\n/4gkFIBTIoAAAgjkLqCWFE1+8Mc//tE6duzodlYLS3T6b4sPUtR1TsGOAgv9qJVGrTYjRoyw\nW265JZaJxgqpFUczwimYUoo+j8mi03a7Wee8HRWcKSAbNGiQRZ975B5Wq22anU6tUtHnNXm7\n5vtVwZDGJOlaZs6c6Y7Tw2U1Y92ZZ56ZcJ4WLVq4culBunSvS6BhAQEEEEAgiQIlor+o/jd6\nNomZcGoEEEAAgaIRWL9+vWkyhiOiU2JHH8Sa40k1W1z0AbOmcUnz5s2z6ENcLfocJBc4xR+0\ncuVK1xoUP413/Hbvvab7Xr58uVWuXNnNlBc/xsnbp6Cva9ascdOIa2ySJn7ILml6cwWHCtRI\nCCCAAAII+CFAC5IfyuSBAAIIFJGAxiPpJ69UqVIl009eSYFWfpKClObNm+dn13zvo/FIuaXo\nw2Rt/vz5Cc9Dym1/tiGAAAIIIFAUAtn/ya4ozsw5EEAAAQQQKISAxkV16NDBzjjjDNfFTlOZ\nkxBAAAEEEPBLgADJL2nyQQABBAIS0FghzXh35JFHBlSCgmWr5zvt3LnT9FDY559/vsDTiRcs\nN/ZGAAEEEEAgUYAxSIkeLCGAAAIIIIAAAggggEAaC9CClMaVz6UjgAACCCCAAAIIIIBAogAB\nUqIHSwgggAACCCCAAAIIIJDGAgRIaVz5XDoCCCCAAAIIIIAAAggkChAgJXqwhAACCCCAAAII\nIIAAAmksQICUxpXPpSOAAAIIIIAAAggggECiAAFSogdLCCCAAAIIIIAAAgggkMYCBEhpXPlc\nOgIIIIAAAggggAACCCQK/D9sgKw1XDyJlQAAAABJRU5ErkJggg=="" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 4 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""We can now use the simulated SFS to infer the DFE parameters and assess how closely the inference recovers the true DFE used to generate the data."" }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-12-12T12:39:58.300627Z"", ""start_time"": ""2025-12-12T12:39:56.786554Z"" } }, ""cell_type"": ""code"", ""source"": [ ""inf = fd$BaseInference(\n"", "" sfs_neut = sim$sfs_neut,\n"", "" sfs_sel = sim$sfs_sel,\n"", "" fixed_params = list(all = list(eps = 0, h = 0.5, p_b = 0, S_b = 1))\n"", "")\n"", ""\n"", ""sfs_modelled <- inf$run()\n"", ""\n"", ""p <- fd$DFE$plot_many(c(sim$dfe, inf$get_dfe()), labels = c('True DFE', 'Inferred DFE'))"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nKfD/m3sZPYGj+P4AAAAASUVORK5CYII="" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 5 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""The DFE is recovered quite well which is expected given the simplicity of the DFE parametrization and lack of demographic complications."" }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""We may want to see how the expected SFS changes as we vary the degree of dominance. Here, we run a second simulation with the same parameters except that we set `h=0.3` so that mutations are partially recessive."" }, { ""cell_type"": ""code"", ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-12-12T12:40:37.220613Z"", ""start_time"": ""2025-12-12T12:39:58.326241Z"" } }, ""source"": [ ""# run simulation with h=0.3\n"", ""sim2 <- fd$Simulation(\n"", "" sfs_neut = fd$Simulation$get_neutral_sfs(n = 20, n_sites = 1e8, theta = 1e-4),\n"", "" params = list(S_d = -300, b = 0.3, p_b = 0, S_b = 1, h = 0.3),\n"", "" model = fd$GammaExpParametrization()\n"", "")\n"", ""\n"", ""sfs_sel <- sim2$run()\n"", ""\n"", ""p <- fd$Spectra$from_spectra(list(\n"", "" neutral = sim$sfs_neut,\n"", "" semidominant = sim$sfs_sel,\n"", "" recessive = sim2$sfs_sel\n"", ""))$plot()"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nFvh/wCbm6CVkDM0AAAAASUVORK5CYII="" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 6 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": ""As expected, partially recessive mutations lead to an excess of rare variants because they are masked in heterozygotes and experience weaker purifying selection. At higher frequencies, the difference from the semidominant case diminishes as derived-allele homozygotes become more common."" }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": ""We can now infer the DFE under the (incorrect) assumption that mutations are semidominant (`h=0.5`) and see how this affects the inference result."" }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-12-12T12:40:38.944551Z"", ""start_time"": ""2025-12-12T12:40:37.239819Z"" } }, ""cell_type"": ""code"", ""source"": [ ""inf <- fd$BaseInference(\n"", "" sfs_neut = sim2$sfs_neut,\n"", "" sfs_sel = sim2$sfs_sel\n"", "")\n"", ""\n"", ""sfs_modelled <- inf$run()\n"", ""\n"", ""p <- fd$DFE$plot_many(c(sim2$dfe, inf$get_dfe()), labels = c('True DFE (h=0.3)', 'Inferred DFE (h=0.5)'))"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nEEgi8P9Fka+NvgmT7QAAAABJRU5ErkJggg=="" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 7 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""Assuming semidominance when mutations are actually partially recessive leads to an inferred DFE shifted toward weaker selection coefficients. This happens because rare variants generated by recessive mutations are misattributed to weaker selection when the dominance reduction in purifying selection is not accounted for."" }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""We can also try to infer the DFE while letting the dominance coefficient `h` vary during the optimization. To optimize `h`, it needs to be discretized; in this example we use the default grid of 21 points between 0 and 1, with intermediate values obtained by linear interpolation. All required values are precomputed before the optimization, but allowing `h` to vary increases the computational cost because the expected SFS must be simulated for each `h` in the grid. To speed up the precomputation step, we instruct {class}`~fastdfe.base_inference.BaseInference` to use a coarser DFE discretization grid than the default, which should be sufficient for most inference scenarios."" }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-12-12T12:41:07.078128Z"", ""start_time"": ""2025-12-12T12:40:38.961602Z"" } }, ""cell_type"": ""code"", ""source"": [ ""inf <- fd$BaseInference(\n"", "" sfs_neut = sim$sfs_neut,\n"", "" sfs_sel = sim$sfs_sel,\n"", "" intervals_h = c(0, 1, 21),\n"", "" intervals_del = c(-1.0e+8, -1.0e-5, 100),\n"", "" intervals_ben = c(1.0e-5, 1.0e4, 100),\n"", "" fixed_params = list(all = list(eps = 0, p_b = 0, S_b = 1))\n"", "")\n"", ""\n"", ""sfs_modelled <- inf$run()\n"", ""\n"", ""p <- fd$DFE$plot_many(c(sim2$dfe, inf$get_dfe()), labels = c('True DFE (h=0.3)', 'Inferred DFE'))"" ], ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nQCA/Av8PDYGSO7Df7b4AAAAASUVORK5CYII="" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 8 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""We see that allowing `h` to vary during inference roughly recovers the true DFE used for the simulation, but with substantially greater uncertainty. Finally, we can examine the bootstrap results to assess how well `h` was estimated."" }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-12-12T12:41:07.119512Z"", ""start_time"": ""2025-12-12T12:41:07.095752Z"" } }, ""cell_type"": ""code"", ""source"": ""hist(inf$bootstraps$h)"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""Plot with title “Histogram of inf$bootstraps$h”"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nwtY+7QAAAABJRU5ErkJggg=="" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 9 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""We see that `h` was estimated with considerable uncertainty, but the bootstrap distribution still puts substantial mass near the true value `h = 0.3`. How well dominance can be inferred from SFS data alone remains an open question, especially when the DFE is more complex or additional nuisance parameters such as demography are included."" }, { ""metadata"": { ""ExecuteTime"": { ""end_time"": ""2025-12-12T12:41:07.155670Z"", ""start_time"": ""2025-12-12T12:41:07.134129Z"" } }, ""cell_type"": ""code"", ""source"": ""plot(abs(inf$bootstraps$S_d), inf$bootstraps$h, log=\""x\"")"", ""outputs"": [ { ""data"": { ""text/plain"": [ ""plot without title"" ], ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nQiAAAQhAAAIQgAAEIACBugn8H69Zl/9u2fTGAAAAAElFTkSuQmCC"" }, ""metadata"": { ""image/png"": { ""width"": 420, ""height"": 180 } }, ""output_type"": ""display_data"", ""jetTransient"": { ""display_id"": null } } ], ""execution_count"": 10 }, { ""metadata"": {}, ""cell_type"": ""markdown"", ""source"": ""Indeed, we see that `h` covaries with `S_d`, with larger `h` associated with less strongly deleterious mutations."" } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""R"", ""language"": ""R"", ""name"": ""ir"" }, ""language_info"": { ""codemirror_mode"": ""r"", ""file_extension"": "".r"", ""mimetype"": ""text/x-r-source"", ""name"": ""R"", ""pygments_lexer"": ""r"", ""version"": ""4.2.3"" } }, ""nbformat"": 4, ""nbformat_minor"": 1 } ","Unknown" "Allele","Sendrowski/fastDFE","docs/reference/Python/example_pendula_complex.ipynb",".ipynb","53942","146","{ ""cells"": [ { ""cell_type"": ""code"", ""execution_count"": 1, ""outputs"": [ { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""Counting sites: 2439037it [00:41, 59006.72it/s]\n"", ""\u001B[32mINFO:fastdfe.Parser: Using stratification: [neutral, selected].[A, C, G, T].\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.Parser: Starting to parse.\u001B[0m\n"", ""Processing sites: 100%|██████████| 2439037/2439037 [05:29<00:00, 7402.38it/s] \n"", ""\u001B[32mINFO:fastdfe.PolyAllelicFiltration: Filtered out 0 sites.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.DegeneracyStratification: Number of sites with valid type: 980934 / 2438327\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.AncestralBaseStratification: Number of sites with valid type: 980934 / 981644\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.Parser: Included 980934 out of 2439037 sites in total.\u001B[0m\n"" ] } ], ""source"": [ ""import fastdfe as fd\n"", ""\n"", ""# instantiate parser\n"", ""p = fd.Parser(\n"", "" n=10,\n"", "" vcf=\""../../resources/genome/betula/all.vcf.gz\"",\n"", "" stratifications=[fd.DegeneracyStratification(), fd.AncestralBaseStratification()]\n"", "")\n"", ""\n"", ""# parse SFS\n"", ""spectra: fd.Spectra = p.parse()"" ], ""metadata"": { ""collapsed"": false, ""ExecuteTime"": { ""end_time"": ""2023-07-19T10:28:11.159868Z"", ""start_time"": ""2023-07-19T10:21:59.120287Z"" } } }, { ""cell_type"": ""code"", ""execution_count"": 2, ""outputs"": [ { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""\u001B[32mINFO:fastdfe.JointInference: Using shared parameters [SharedParams(params=['p_b', 'S_b'], types=['A', 'C', 'G', 'T'])].\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.JointInference: Including covariates: {}.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'all'.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_b': 100} and lower bound for {'all.p_b': 0}, but this might be nothing to worry about.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 90 iterations and 685 function evaluations, obtaining a log-likelihood of -37.51293539207359.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -53949.40796474576, 'all.b': 0.11366118571317227, 'all.p_b': 0.0035695995726279578, 'all.S_b': 100.0, 'all.eps': 0.0}.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inferences for types ['A', 'C', 'G', 'T'].\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'A'.\u001B[0m\n"", ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_b': 100} and lower bound for {'all.S_d': -100000.0, 'all.b': 0.01}, but this might be nothing to worry about.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 18 iterations and 120 function evaluations, obtaining a log-likelihood of -31.8637145820187.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -100000.0, 'all.b': 0.09522023308068508, 'all.p_b': 0.006569641953718728, 'all.S_b': 100.0, 'all.eps': 0.0}.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'C'.\u001B[0m\n"", ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_b': 100} and lower bound for {}, but this might be nothing to worry about.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 85 iterations and 645 function evaluations, obtaining a log-likelihood of -32.31745271402025.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -4185.848942283267, 'all.b': 0.19089043196990704, 'all.p_b': 0.006698568663111203, 'all.S_b': 100.0, 'all.eps': 0.0}.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'G'.\u001B[0m\n"", ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01, 'all.b': 10} and lower bound for {'all.S_b': 0.0001}, but this might be nothing to worry about.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 65 iterations and 460 function evaluations, obtaining a log-likelihood of -39.34106087078578.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -165.01887014239622, 'all.b': 10.0, 'all.p_b': 0.23938783194502647, 'all.S_b': 0.18076846503635546, 'all.eps': 0.0}.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'T'.\u001B[0m\n"", ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {} and lower bound for {'all.S_d': -100000.0, 'all.S_b': 0.0001}, but this might be nothing to worry about.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 46 iterations and 295 function evaluations, obtaining a log-likelihood of -39.58658201021626.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -100000.0, 'all.b': 0.15428875493961483, 'all.p_b': 0.17278065494179437, 'all.S_b': 0.0001, 'all.eps': 0.0}.\u001B[0m\n"", ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {} and lower bound for {'A.S_d': -100000.0, 'A.b': 0.01, 'G.S_d': -100000.0, 'T.S_d': -100000.0, 'T.b': 0.01}, but this might be nothing to worry about.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.JointInference: Successfully finished optimization after 172 iterations and 2365 function evaluations, obtaining a log-likelihood of -146.11003066065462.\u001B[0m\n"", ""\u001B[32mINFO:fastdfe.JointInference: Inferred parameters: {'A.S_d': -100000.0, 'A.b': 0.09494023640538324, 'A.eps': 0.0, 'A.p_b': 0.006134398085142732, 'A.S_b': 44.275753637691146, 'C.S_d': -4941.28735561608, 'C.b': 0.1853951938413811, 'C.eps': 0.0, 'C.p_b': 0.006134398085142732, 'C.S_b': 44.275753637691146, 'G.S_d': -100000.0, 'G.b': 0.12013852605367349, 'G.eps': 0.0, 'G.p_b': 0.006134398085142732, 'G.S_b': 44.275753637691146, 'T.S_d': -100000.0, 'T.b': 0.1005073962112379, 'T.eps': 0.0, 'T.p_b': 0.006134398085142732, 'T.S_b': 44.275753637691146}.\u001B[0m\n"" ] } ], ""source"": [ ""inf = fd.JointInference(\n"", "" sfs_neut=spectra['neutral.*'].merge_groups(1),\n"", "" sfs_sel=spectra['selected.*'].merge_groups(1),\n"", "" shared_params=[fd.SharedParams(params=['p_b', 'S_b'], types='all')],\n"", "" fixed_params=dict(all=dict(eps=0))\n"", "")\n"", ""\n"", ""inf.run()"" ], ""metadata"": { ""collapsed"": false, ""ExecuteTime"": { ""end_time"": ""2023-07-19T10:28:22.897447Z"", ""start_time"": ""2023-07-19T10:28:11.161033Z"" } } }, { ""cell_type"": ""code"", ""execution_count"": 3, ""outputs"": [ { ""data"": { ""text/plain"": ""

	Sample	dash_allele	purity	dash_r	prediction_probability	dash_deletion
0	DNA_54147	hla_a_03_01_01_01	0.80	1.2832544082591297	0.996365	False
1	DNA_54147	hla_a_02_01_01_01	0.80	0.08893851830163127	0.996365	True
2	DNA_54147	hla_b_07_02_01	0.80	1.2852207362043069	0.996365	False
3	DNA_54147	hla_b_40_02_01	0.80	0.10417378556205548	0.996365	True
4	DNA_54147	hla_c_02_02_02	0.80	0.08958876790183208	0.996365	True
5	DNA_54147	hla_c_07_02_01_01	0.80	1.2121310700528591	0.996365	False
0	DNA_124768F-5013	hla_a_25_01_01	0.23	0.6339447508104947	0.993663	True
1	DNA_124768F-5013	hla_a_24_02_01_01	0.23	1.7644244627809802	0.993663	False
2	DNA_124768F-5013	hla_b_38_01_01	0.23	1.6827887259284153	0.991004	False
3	DNA_124768F-5013	hla_b_18_01_01_01	0.23	0.600105028866404	0.991004	True
4	DNA_124768F-5013	hla_c_12_03_01_01	0.23	-	-1.000000	False
5	DNA_124768F-5013	hla_c_12_03_01_01	0.23	-	-1.000000	False
0	DNA_1134036FA1-5013	hla_a_24_02_01_01	0.11	1.095181941055805	0.980240	False
1	DNA_1134036FA1-5013	hla_a_03_01_01_01	0.11	0.8090530472072852	0.980240	True
2	DNA_1134036FA1-5013	hla_b_35_02_01	0.11	1.0600456492935597	0.975443	False
3	DNA_1134036FA1-5013	hla_b_44_02_01_01	0.11	0.8056166363718527	0.975443	True
4	DNA_1134036FA1-5013	hla_c_05_01_01_01	0.11	0.8125731368951117	0.965916	True
5	DNA_1134036FA1-5013	hla_c_04_01_01_01	0.11	1.0052114112023751	0.965916	False
0	DNA_1183384FA1-5013	hla_a_03_01_01_01	0.11	-	-1.000000	False
1	DNA_1183384FA1-5013	hla_a_03_01_01_01	0.11	-	-1.000000	False
2	DNA_1183384FA1-5013	hla_b_35_03_01	0.11	1.1046088903148248	0.022765	False
3	DNA_1183384FA1-5013	hla_b_18_05	0.11	0.8010214441801838	0.022765	False
4	DNA_1183384FA1-5013	hla_c_12_03_01_01	0.11	0.7160499424618622	0.029332	False
5	DNA_1183384FA1-5013	hla_c_04_01_01_01	0.11	1.1188295580518028	0.029332	False
0	DNA_30686F-5013	hla_a_25_01_01	0.66	1.130328147462225	0.000656	False
1	DNA_30686F-5013	hla_a_01_01_01_01	0.66	1.0801429144090111	0.000656	False
2	DNA_30686F-5013	hla_b_57_01_01	0.66	1.0259438976997912	0.000742	False
3	DNA_30686F-5013	hla_b_51_01_01	0.66	1.1267448599895653	0.000742	False
4	DNA_30686F-5013	hla_c_06_02_01_01	0.66	1.0395038337574176	0.000490	False
5	DNA_30686F-5013	hla_c_14_02_01	0.66	1.0801757821861429	0.000490	False
0	DNA_1070865FA1-5013	hla_a_68_01_02	0.17	0.9334184407119052	0.002001	False
1	DNA_1070865FA1-5013	hla_a_32_01_01	0.17	0.9454132380674868	0.002001	False
2	DNA_1070865FA1-5013	hla_b_40_01_02	0.17	0.9333445015783792	0.002071	False
3	DNA_1070865FA1-5013	hla_b_51_01_01	0.17	0.9297037074549122	0.002071	False
4	DNA_1070865FA1-5013	hla_c_03_04_01_01	0.17	0.8913053850261776	0.004971	False
5	DNA_1070865FA1-5013	hla_c_15_02_01	0.17	0.96904021641719	0.004971	False
0	DNA_H2009	hla_a_03_01_01_01	1.00	-	-1.000000	False
1	DNA_H2009	hla_a_03_01_01_01	1.00	-	-1.000000	False
2	DNA_H2009	hla_b_07_02_01	1.00	1.7519400314477998	0.977171	False
3	DNA_H2009	hla_b_51_01_01	1.00	7.321407811840311e-05	0.977171	True
4	DNA_H2009	hla_c_07_02_01_01	1.00	1.4620073579969766	0.975468	False
5	DNA_H2009	hla_c_15_02_01	1.00	6.140662545980678e-05	0.975468	True

	Tissue	Unique Peptides	Unique 9-mer Peptides	Sample	Tissue_letter
0	1070865FA1	8319	5245	DNA_1070865FA1-5013	M
1	1183384FA1	4762	3285	DNA_1183384FA1-5013	N
2	1134036FA1	3135	2143	DNA_1134036FA1-5013	O
3	124768F	6196	4309	DNA_124768F-5013	C
4	30686F	4444	2883	DNA_30686F-5013	P
5	H2009	5546	3321	DNA_H2009	CellLine
6	54147	1039	680	DNA_54147	Q

	Tissue	Unique Peptides	Unique 9-mer Peptides	Sample	Tissue_letter	Fraction 9-mer
6	54147	1039	680	DNA_54147	Q	0.654475
2	1134036FA1	3135	2143	DNA_1134036FA1-5013	O	0.683573
4	30686F	4444	2883	DNA_30686F-5013	P	0.648740
1	1183384FA1	4762	3285	DNA_1183384FA1-5013	N	0.689836
3	124768F	6196	4309	DNA_124768F-5013	C	0.695449
0	1070865FA1	8319	5245	DNA_1070865FA1-5013	M	0.630484

	Tissue	Thresholds	Percent Binding	Sample	Tissue_letter
6	54147	0.1	0.627794	DNA_54147	Q
1	1183384FA1	0.1	0.730891	DNA_1183384FA1-5013	N
2	1134036FA1	0.1	0.770975	DNA_1134036FA1-5013	O
0	1070865FA1	0.1	0.800024	DNA_1070865FA1-5013	M
3	124768F	0.1	0.832383	DNA_124768F-5013	C
4	30686F	0.1	0.867366	DNA_30686F-5013	P

	Value
	count	mean	std	min	25%	50%	75%	max
Sample_type
Control	14852.0	0.001038	0.024482	-0.163618	-0.010781	0.001588	0.013310	0.179460
LOH	15357.0	-0.001234	0.051316	-0.249812	-0.027518	-0.000422	0.025935	0.955912

	all.S_d	all.b	all.S_b	all.h	likelihood
0	-33890.424207	0.130546	1.0	0.5	-35.437968
1	-33898.475526	0.130543	1.0	0.5	-35.437968
2	-33894.520478	0.130544	1.0	0.5	-35.437968
3	-33896.257305	0.130544	1.0	0.5	-35.437968
4	-33893.352524	0.130545	1.0	0.5	-35.437968
5	-33898.090546	0.130543	1.0	0.5	-35.437968
6	-33894.032960	0.130544	1.0	0.5	-35.437968
7	-33887.045393	0.130547	1.0	0.5	-35.437968
8	-33899.733825	0.130542	1.0	0.5	-35.437968
9	-33889.470185	0.130546	1.0	0.5	-35.437968

	S_d	b	p_b	S_b	eps	h	likelihood	i_best_run	likelihoods_std	alpha
0	-100000.000000	0.115271	0.0	1.0	0.0	0.5	-48.666719	1	2.112557e-09	0.0
1	-23100.047602	0.132767	0.0	1.0	0.0	0.5	-39.454392	0	6.220944e-10	0.0
2	-30896.328327	0.126525	0.0	1.0	0.0	0.5	-44.116520	1	5.387903e-10	0.0
3	-100000.000000	0.117041	0.0	1.0	0.0	0.5	-40.332661	1	3.066069e-02	0.0
4	-27268.784916	0.134769	0.0	1.0	0.0	0.5	-38.642477	0	5.865388e-10	0.0
...	...	...	...	...	...	...	...	...	...	...
95	-59604.675726	0.121741	0.0	1.0	0.0	0.5	-38.589821	1	5.672405e-10	0.0
96	-3523.479918	0.172044	0.0	1.0	0.0	0.5	-33.468514	1	2.810907e-10	0.0
97	-100000.000000	0.114860	0.0	1.0	0.0	0.5	-44.168668	1	3.818051e-01	0.0
98	-5645.681207	0.160873	0.0	1.0	0.0	0.5	-34.451027	1	3.464038e-10	0.0
99	-12974.655531	0.146723	0.0	1.0	0.0	0.5	-36.749411	1	1.489667e-09	0.0

	Tissue	Value	Sample Type	Purity	Sample	Tissue_letter
0	1070865FA1	0.022741	Control	0.17	DNA_1070865FA1-5013	M
1	1134036FA1	0.030253	LOH	0.11	DNA_1134036FA1-5013	O
2	1183384FA1	0.031830	Control	0.11	DNA_1183384FA1-5013	N
3	124768F	0.058536	LOH	0.23	DNA_124768F-5013	C
4	30686F	0.022871	Control	0.66	DNA_30686F-5013	P
5	54147	0.029923	LOH	0.80	DNA_54147	Q
6	H2009	0.056113	LOH	1.00	DNA_H2009	CellLine

	Sample	Allele	Peptide	Fold_change	Allele_status	Tissue	Tissue_letter	Gene
0	DNA_1070865FA1-5013	HLA-A32:01	RTFVWPAHF	1.024423	kept	1070865FA1	M	A
1	DNA_1070865FA1-5013	HLA-A32:01	KTWNGGESL	0.996553	kept	1070865FA1	M	A
2	DNA_1070865FA1-5013	HLA-A32:01	RVAEVQQVL	1.036950	kept	1070865FA1	M	A
3	DNA_1070865FA1-5013	HLA-A32:01	KLYGYYVSI	0.962393	kept	1070865FA1	M	A
4	DNA_1070865FA1-5013	HLA-A32:01	KLYGMPTDFGF	1.034859	kept	1070865FA1	M	A

		Fold_change
Sample	Allele_status
DNA_1070865FA1-5013	kept	1.000908
DNA_1134036FA1-5013	kept	1.001027
lost	1.000109
DNA_1183384FA1-5013	homozygous	1.008255
kept	0.995403
DNA_124768F-5013	homozygous	1.002694
kept	0.999187
lost	1.002621
DNA_30686F-5013	kept	1.001858
DNA_54147	kept	1.000423
lost	0.998259
DNA_H2009	homozygous	0.980395
kept	1.001705
lost	1.009894

		Fold_change
Gene	Allele_status
A	homozygous	0.998604
kept	1.001742
lost	1.003306
B	kept	0.999574
lost	1.002826
C	homozygous	1.002694
kept	1.000383
lost	1.004329

	Purity	R1	R2	BAF	Sequenza_Loss	Alternate_Loss	Dash_Loss	Ploidy	consistency_of_coverage	prediction_probability	secondary_check	total_coverage	Gene	Sample	ind
0	1.00	0.000052	1.654309	0.505381	True	True	True	5	0.847826	0.994991	False	1.654356	B	CRL-5922_tumor_p100_rep1	0
1	1.00	0.000051	1.786976	0.496225	True	True	True	5	0.869565	0.995448	False	1.787059	C	CRL-5922_tumor_p100_rep1	1
2	0.77	0.099897	1.578995	0.445050	True	True	True	5	0.847826	0.800964	False	1.644918	B	CRL-5922_tumor_p90_rep1	2
3	0.77	0.098027	1.689733	0.444421	True	True	True	5	0.869565	0.995448	False	1.764339	C	CRL-5922_tumor_p90_rep1	3
4	0.62	0.187041	1.512448	0.390142	True	True	True	5	0.847826	0.800964	False	1.722242	B	CRL-5922_tumor_p81_rep1	4

	Dash_Loss_Ext
real_purity
0	1.000000
2	1.000000
3	1.000000
4	1.000000
5	0.985714
6	0.985714
7	0.985714
8	0.985714
9	1.000000
10	1.000000

	Patient	Total	Long_repeats	Fraction_long_repeats
0	DNA_1070865FA1-5013	8999	77	0.008557
1	DNA_1183384FA1-5013	5095	23	0.004514
2	DNA_1134036FA1-5013	3390	29	0.008555
3	DNA_124768F-5013	6489	43	0.006627
4	DNA_30686F-5013	4656	36	0.007732
5	DNA_H2009	6050	70	0.011570
6	DNA_54147	1338	27	0.020179

	Sample	HLA_A_type1	HLA_A_type2	HLA_type1copyNum_withBAFBin	HLA_type2copyNum_withBAFBin	PVal_unique	LossAllele	KeptAllele	LOH_allele	LOHHLA_Loss	Purity	Ploidy	LOH	real_purity	Sequenza_Loss
0	CRL-5922_tumor_p100_rep1	hla_b_35_03_01	hla_b_44_03_01	0.000000	4.310326	2.697208e-12	hla_b_35_03_01	hla_b_44_03_01	hla_b_35_03_01	True	1.00	5.0	True	100	True
1	CRL-5922_tumor_p100_rep1	hla_c_04_01_01_01	hla_c_16_01_01	0.000000	4.614931	3.156374e-19	hla_c_04_01_01_01	hla_c_16_01_01	hla_c_04_01_01_01	True	1.00	5.0	True	100	True
2	CRL-5922_tumor_p90_rep1	hla_b_35_03_01	hla_b_44_03_01	-0.018408	4.411412	8.178862e-22	hla_b_35_03_01	hla_b_44_03_01	hla_b_35_03_01	True	0.77	5.0	True	90	True
3	CRL-5922_tumor_p90_rep1	hla_c_04_01_01_01	hla_c_16_01_01	0.013947	4.516797	2.758436e-29	hla_c_04_01_01_01	hla_c_16_01_01	hla_c_04_01_01_01	True	0.77	5.0	True	90	True
4	CRL-5922_tumor_p81_rep1	hla_b_35_03_01	hla_b_44_03_01	-0.031231	4.455919	1.603433e-22	hla_b_35_03_01	hla_b_44_03_01	hla_b_35_03_01	True	0.62	5.0	True	81	True

	cell_line	replicate	Gene	real_purity
42	CRL-2314	3	C	8
51	CRL-2314	3	C	7
54	CRL-2314	3	C	6
69	CRL-2314	3	C	5

	IPSLC	SeqIPSLC	adjusted_ploidy	SP	clonality
36	28.0	0.218	5.0	40	70
63	28.0	0.466	5.0	70	40

	old_purity	HLA_LOH_Loss_int
0	1	1
1	10	1
2	100	1
3	12	1
4	14	1

	Sample	HLA_A_type1	HLA_A_type2	HLA_type1copyNum_withBAFBin	HLA_type2copyNum_withBAFBin	PVal_unique	LossAllele	KeptAllele	HLAtype1Log2MedianCoverage	HLAtype2Log2MedianCoverage	purity	ploidy	LOH_allele	LOHHLA_Loss	real_purity	cell_line
0	DNA_VVV_S15_P10_9_tumor_p28_rep2	hla_b_07_02_01	hla_b_51_01_01	3.883982	0.865751	2.480268e-22	hla_b_51_01_01	hla_b_07_02_01	0.242642	-0.473975	0.223	5.0	NaN	False	28	DNA_VVV_S15_P10_9
1	DNA_VVV_S15_P10_9_tumor_p28_rep2	hla_c_07_02_01_01	hla_c_15_02_01	3.508391	0.547507	2.267079e-25	hla_c_15_02_01	hla_c_07_02_01_01	0.192601	-0.482873	0.223	5.0	NaN	False	28	DNA_VVV_S15_P10_9
2	DNA_VVV_S15_P10_9_tumor_p28_rep2	hla_b_07_02_01	hla_b_51_01_01	3.326220	1.516650	2.480268e-22	hla_b_51_01_01	hla_b_07_02_01	0.258454	-0.478776	0.476	5.0	NaN	False	28	DNA_VVV_S15_P10_9
3	DNA_VVV_S15_P10_9_tumor_p28_rep2	hla_c_07_02_01_01	hla_c_15_02_01	3.106763	1.325158	2.267079e-25	hla_c_15_02_01	hla_c_07_02_01_01	0.192601	-0.485471	0.476	5.0	NaN	False	28	DNA_VVV_S15_P10_9
4	DNA_VVV_S15_P10_9_tumor_p10_rep10	hla_b_07_02_01	hla_b_51_01_01	2.252697	-0.060447	1.982009e-07	hla_b_51_01_01	hla_b_07_02_01	0.031694	-0.203305	0.105	3.0	hla_b_51_01_01	True	10	DNA_VVV_S15_P10_9

	Sample	HLA_A_type1	HLA_A_type2	HLA_type1copyNum_withBAFBin	HLA_type2copyNum_withBAFBin	PVal_unique	LossAllele	KeptAllele	HLAtype1Log2MedianCoverage	HLAtype2Log2MedianCoverage	purity	ploidy	LOH_allele	LOHHLA_Loss	real_purity	SP	clonality
152	CRL-5922_tumor_p10_rep1	hla_b_35_03_01	hla_b_44_03_01	2.279822	2.617730	6.829551e-04	hla_b_35_03_01	hla_b_44_03_01	-0.160212	0.101484	1.0	5.0	NaN	False	10	100	10
153	CRL-5922_tumor_p10_rep1	hla_c_04_01_01_01	hla_c_16_01_01	2.118101	2.611270	4.428096e-08	hla_c_04_01_01_01	hla_c_16_01_01	-0.202506	0.057404	1.0	5.0	NaN	False	10	100	10
352	CRL-5922_tumor_p10_rep2	hla_b_35_03_01	hla_b_44_03_01	2.342773	2.511193	1.504245e-04	hla_b_35_03_01	hla_b_44_03_01	-0.216322	0.110179	1.0	5.0	NaN	False	10	100	10
353	CRL-5922_tumor_p10_rep2	hla_c_04_01_01_01	hla_c_16_01_01	2.146837	2.613380	2.331688e-07	hla_c_04_01_01_01	hla_c_16_01_01	-0.234033	0.091357	1.0	5.0	NaN	False	10	100	10
552	CRL-5922_tumor_p10_rep3	hla_b_35_03_01	hla_b_44_03_01	2.215346	2.440746	2.442986e-01	hla_b_35_03_01	hla_b_44_03_01	-0.207890	0.057296	1.0	5.0	NaN	False	10	100	10

	Sample	HLA_A_type1	HLA_A_type2	HLA_type1copyNum_withBAFBin	HLA_type2copyNum_withBAFBin	PVal_unique	LossAllele	KeptAllele	LOH_allele	LOHHLA_Loss	Purity	Ploidy	LOH	old_purity
0	CRL-5922_tumor_p0_rep1_6	hla_b_35_03_01	hla_b_44_03_01	0.994728	0.988523	0.787676	hla_b_35_03_01	hla_b_44_03_01	NaN	False	6	5	True	6
1	CRL-5922_tumor_p0_rep1_6	hla_c_04_01_01_01	hla_c_16_01_01	0.993698	0.992876	0.481454	hla_c_04_01_01_01	hla_c_16_01_01	NaN	False	6	5	True	6
2	CRL-5922_tumor_p0_rep1_28	hla_b_35_03_01	hla_b_44_03_01	0.998870	0.997541	0.787676	hla_b_35_03_01	hla_b_44_03_01	NaN	False	28	5	True	28
3	CRL-5922_tumor_p0_rep1_28	hla_c_04_01_01_01	hla_c_16_01_01	0.998649	0.998474	0.481454	hla_c_04_01_01_01	hla_c_16_01_01	NaN	False	28	5	True	28
4	CRL-5922_tumor_p0_rep1_15	hla_b_35_03_01	hla_b_44_03_01	0.997891	0.995409	0.787676	hla_b_35_03_01	hla_b_44_03_01	NaN	False	15	5	True	15

	Sample	HLA_A_type1	HLA_A_type2	HLA_type1copyNum_withBAFBin	HLA_type2copyNum_withBAFBin	PVal_unique	LossAllele	KeptAllele	LOH_allele	LOHHLA_Loss	Purity	Ploidy	LOH	real_purity	Sequenza_Loss
0	DNA_VVV_S15_P10_9_tumor_p100_rep4	hla_b_07_02_01	hla_b_51_01_01	3.849064	0.000000	1.027994e-28	hla_b_51_01_01	hla_b_07_02_01	hla_b_51_01_01	True	1.00	5.0	True	100	True
1	DNA_VVV_S15_P10_9_tumor_p100_rep4	hla_c_07_02_01_01	hla_c_15_02_01	3.683698	0.000000	3.295002e-39	hla_c_15_02_01	hla_c_07_02_01_01	hla_c_15_02_01	True	1.00	5.0	True	100	True
2	DNA_VVV_S15_P10_9_tumor_p28_rep2	hla_b_07_02_01	hla_b_51_01_01	4.388693	0.269772	2.480268e-22	hla_b_51_01_01	hla_b_07_02_01	hla_b_51_01_01	True	0.15	5.0	True	28	True
3	DNA_VVV_S15_P10_9_tumor_p28_rep2	hla_c_07_02_01_01	hla_c_15_02_01	3.876131	-0.164530	2.267079e-25	hla_c_15_02_01	hla_c_07_02_01_01	hla_c_15_02_01	True	0.15	5.0	True	28	True
4	DNA_VVV_S15_P10_9_tumor_p10_rep10	hla_b_07_02_01	hla_b_51_01_01	1.750909	-0.556740	1.982009e-07	hla_b_51_01_01	hla_b_07_02_01	hla_b_51_01_01	True	0.10	2.0	True	10	True

	Sample	HLA_A_type1	HLA_A_type2	HLA_type1copyNum_withBAFBin	HLA_type2copyNum_withBAFBin	PVal_unique	LossAllele	KeptAllele	LOH_allele	LOHHLA_Loss	Purity	Ploidy	LOH	old_purity
0	DNA_VVV_S15_P10_9_tumor_p0_rep1_4	hla_b_07_02_01	hla_b_51_01_01	0.998497	0.989843	0.027355	hla_b_51_01_01	hla_b_07_02_01	NaN	False	4	5	True	4
1	DNA_VVV_S15_P10_9_tumor_p0_rep1_4	hla_c_07_02_01_01	hla_c_15_02_01	0.981784	0.977126	0.110290	hla_c_07_02_01_01	hla_c_15_02_01	NaN	False	4	5	True	4
2	DNA_VVV_S15_P10_9_tumor_p0_rep1_49	hla_b_07_02_01	hla_b_51_01_01	0.999877	0.999171	0.027355	hla_b_51_01_01	hla_b_07_02_01	NaN	False	49	5	True	49
3	DNA_VVV_S15_P10_9_tumor_p0_rep1_49	hla_c_07_02_01_01	hla_c_15_02_01	0.998513	0.998133	0.110290	hla_c_07_02_01_01	hla_c_15_02_01	NaN	False	49	5	True	49
4	DNA_VVV_S15_P10_9_tumor_p0_rep1_80	hla_b_07_02_01	hla_b_51_01_01	0.999925	0.999492	0.027355	hla_b_51_01_01	hla_b_07_02_01	NaN	False	80	5	True	80

	Assay_Type	FAM_concentration	Patient	Round	Sample_Type	VIC_concentration
0	Kept\\nAllele1	379.0	14.0	2	Normal	685.0
1	Kept\\nAllele1	363.0	14.0	2	Normal	684.0
2	Kept\\nAllele1	337.0	14.0	2	Normal	625.0
3	Kept\\nAllele1	1098.0	14.0	2	Tumor	492.0
4	Kept\\nAllele1	1063.0	14.0	2	Tumor	457.0

	Sample	Purity	Replicate	Assay_Type	FAM_concentration	VIC_concentration
0	P40_R1	40	1	WT	362.0	551.0
1	P40_R1	40	1	WT	330.0	477.0
2	P40_R1	40	1	WT	333.0	503.0
3	P60_R1	60	1	WT	367.0	483.0
4	P60_R1	60	1	WT	358.0	466.0

	Patient	Patient_ID
0	1.0	A
1	2.0	B
2	3.0	C
3	6.0	D
4	7.0	E
5	10.0	F
6	11.0	G
7	13.0	H
8	20.0	I
9	14.0	J
10	5.0	K
11	22.0	L
12	25.0	M
13	26.0	N
14	33.0	O
15	34.0	P
16	36.0	Q
17	37.0	R
18	38.0	S
19	39.0	T
20	41.0	U

	Assay_Type	FAM_concentration	Patient	Round	Sample_Type	VIC_concentration	Ratio_concentration	Patient_ID
36	Kept\\nAllele	510.7	3.0	1	Normal	363.0	2.813774	C
37	Kept\\nAllele	465.5	3.0	1	Normal	352.5	2.641135	C
38	Kept\\nAllele	480.5	3.0	1	Tumor	434.8	2.210212	C
39	Kept\\nAllele	492.2	3.0	1	Tumor	421.7	2.334361	C
40	Lost\\nAllele	222.6	3.0	1	Normal	383.8	1.159979	C

	Sample #	sample_name_tumor	sample_name_normal	Patient	Patient_ID
0	1	DNA_ILS38706PT3-DS1	DNA_ILS38706PA2	1.0	A
1	2	DNA_ILS50527PT6	DNA_ILS50527PA1	2.0	B
2	5	DNA_232313	DNA_232311	5.0	K
3	6	DNA_100831-06T	DNA_100831-06N	6.0	D
4	7	DNA_56968	DNA_56966	7.0	E
5	10	DNA_2NHVSAZI	DNA_2NHVSN6Y	10.0	F
6	11	DNA_9HSGPZ21	DNA_9HSGPY13	11.0	G
7	13	DNA_42812	DNA_42816	13.0	H
8	14	DNA_45171	DNA_45177	14.0	J
9	20	DNA_NGT-LCA-1907001T	DNA_LCA-1907001T	20.0	I
10	22	DNA_EW8FWAXI	DNA_EW8FWN6K	22.0	L
11	25	DNA_AF8RXAL8	DNA_AF8RXN83	25.0	M
12	26	DNA_2GXOFAO6	DNA_2GXOFNE7	26.0	N
13	33	DNA_5AATZAH9	DNA_5AATZN8L	33.0	O
14	34	DNA_FAPZKA7F	DNA_FAPZKNCB	34.0	P
15	36	DNA_9FOC4AQH	DNA_9FOC4NHH	36.0	Q
16	37	DNA_C00084290-1b	DNA_C00084291-2a	37.0	R
17	38	DNA_I8ZZLZ23	DNA_I8ZZLY12	38.0	S
18	39	DNA_B8NNEAZI	DNA_B8NNENKX	39.0	T
19	41	DNA_CLM7SAW1	DNA_CLM7SNIM	41.0	U

	Sample #	hla_locus	sample_name_tumor	sample_name_normal	Patient	Patient_ID	purity	ploidy	dash_adj_baf	dash_r	prediction_probability	secondary_check	LOH
0	1	C	DNA_ILS38706PT3-DS1	DNA_ILS38706PA2	1.0	A	0.22	3.0	0.12209066832047814	1.1432256523256772	0.991455	False	False
1	1	C	DNA_ILS38706PT3-DS1	DNA_ILS38706PA2	1.0	A	0.22	3.0	0.12209066832047814	0.7027455403228664	0.991455	False	True
2	2	C	DNA_ILS50527PT6	DNA_ILS50527PA1	2.0	B	0.66	5.0	0.3645562557758296	0.1550266216782339	0.996365	False	True
3	2	C	DNA_ILS50527PT6	DNA_ILS50527PA1	2.0	B	0.66	5.0	0.3645562557758296	1.2050132144609225	0.996365	False	False
4	5	C	DNA_232313	DNA_232311	5.0	K	0.23	5.0	0.07465950134822613	0.5802426916881673	0.009629	False	False
5	5	C	DNA_232313	DNA_232311	5.0	K	0.23	5.0	0.07465950134822613	0.8033946640667441	0.009629	False	False
6	6	C	DNA_100831-06T	DNA_100831-06N	6.0	D	0.11	3.0	0.1190978310608871	0.6057052585324164	0.994475	False	True
7	6	C	DNA_100831-06T	DNA_100831-06N	6.0	D	0.11	3.0	0.1190978310608871	1.1044943622494665	0.994475	False	False
8	7	C	DNA_56968	DNA_56966	7.0	E	0.68	3.0	0.3603064763982562	0.20524501056740696	0.996421	False	True
9	7	C	DNA_56968	DNA_56966	7.0	E	0.68	3.0	0.3603064763982562	1.4898806290662343	0.996421	False	False
10	10	A	DNA_2NHVSAZI	DNA_2NHVSN6Y	10.0	F	0.19	4.0	0.16115787791800454	0.7154842101862354	0.990590	False	True
11	10	A	DNA_2NHVSAZI	DNA_2NHVSN6Y	10.0	F	0.19	4.0	0.16115787791800454	1.3997837567412788	0.990590	False	False
12	11	A	DNA_9HSGPZ21	DNA_9HSGPY13	11.0	G	0.38	2.0	0.2011437325676032	0.7574194623999879	0.987775	False	True
13	11	A	DNA_9HSGPZ21	DNA_9HSGPY13	11.0	G	0.38	2.0	0.2011437325676032	1.6933496381958737	0.987775	False	False
14	13	A	DNA_42812	DNA_42816	13.0	H	0.25	3.0	0.12822424684809194	1.073581525621316	0.990447	False	False
15	13	A	DNA_42812	DNA_42816	13.0	H	0.25	3.0	0.12822424684809194	0.6244384292858643	0.990447	False	True
16	14	C	DNA_45171	DNA_45177	14.0	J	0.58	6.0	0.3248991661022395	0.6009851657743326	0.317047	False	False
17	14	C	DNA_45171	DNA_45177	14.0	J	0.58	6.0	0.3248991661022395	2.8331078460439514	0.317047	False	False
18	20	C	DNA_NGT-LCA-1907001T	DNA_LCA-1907001T	20.0	I	0.15	2.0	0.005257938080657165	0.9342496405054834	0.734453	True	False
19	20	C	DNA_NGT-LCA-1907001T	DNA_LCA-1907001T	20.0	I	0.15	2.0	0.005257938080657165	0.9213516989603164	0.734453	True	False

	hla_locus	hla_locus_cntr	dash_allele	hla_assign_allele	purity	ploidy	alternate_copy_number	alternate_allelic_imbalance	alternate_deletion	dash_r	dash_adj_baf	raw_dash_deletion	dash_deletion	sequenza_majors	sequenza_minors	consistency_of_coverage	total_coverage	prediction_probability	secondary_check
0	A	1	hla_a_11_01_01	A*11:01:01	0.23	5	-0.126725	8.726933e-08	True	0.593055	0.093541	False	False	2	1	0.729167	0.824607	0.003996	False
1	A	2	hla_a_01_01_01_01	A*01:01:01:01	0.23	5	1.373479	8.726933e-08	False	0.824607	0.093541	False	False	2	1	0.729167	0.824607	0.003996	False
2	B	1	hla_b_08_01_01	B*08:01:01	0.23	5	1.753356	4.579999e-20	False	0.814238	0.089505	False	False	2	1	0.891304	0.593002	0.009629	False
3	B	2	hla_b_35_01_01_01	B*35:01:01:01	0.23	5	-0.295843	4.579999e-20	True	0.593002	0.089505	False	False	2	1	0.891304	0.593002	0.009629	False
4	C	1	hla_c_04_01_01_01	C*04:01:01:01	0.23	5	0.086426	3.696644e-27	True	0.580243	0.074660	False	False	2	1	0.934783	0.803395	0.009629	False
5	C	2	hla_c_07_01_01_01	C*07:01:01:01	0.23	5	1.329288	3.696644e-27	False	0.803395	0.074660	False	False	2	1	0.934783	0.803395	0.009629	False

	sample_name_tumor	AJCC_UICC_Stage_Group	Age	Cancer_type	Sex	Simple_Stage	purity	MATH	MSI_percentage	Cytolytic_score	...	Focal_cnvs	Large_CNVs	LOH_region	Potential_neoantigens	Potential_neoepitopes	BINDING_antigen_strong_count	BINDING_epitope_strong_count	PRESENTATION_antigen_strong_count	PRESENTATION_epitope_strong_count	Has_HLALOH
0	DNA_S000460823	II	72	Bladder	Female	II	0.59	NaN	0.03	7.313060	...	33.0	58.0	0.196398	45.0	2981.0	NaN	NaN	NaN	NaN	False
1	DNA_D00689998_A1	IV	73	Melanoma	Male	IV	0.39	NaN	0.00	2.910320	...	22.0	53.0	0.229302	927.0	34664.0	NaN	NaN	NaN	NaN	False
2	DNA_D00689957_A1	III	64	Colorectal	Female	III	0.50	NaN	0.65	4.947471	...	43.0	62.0	0.137267	129.0	4787.0	NaN	NaN	NaN	NaN	True
3	DNA_D00689946_A2a	III	57	Pancreatic	Female	III	0.16	NaN	0.00	9.277136	...	30.0	50.0	0.140063	44.0	1485.0	NaN	NaN	NaN	NaN	False
4	DNA_S000465410	II	59	Uterine	Female	II	0.31	NaN	0.88	11.480447	...	13.0	45.0	0.034222	385.0	19175.0	NaN	NaN	NaN	NaN	False

	Allele	Lost_count	Kept_count	Total_allele_count	Total_count	Lost_allele_frequency	Allele_frequency
0	A*32:01	5	24	31.0	3429.0	0.161290	0.009041
1	B*53:01	1	7	9.0	3429.0	0.111111	0.002625
2	C*04:01	9	105	123.0	3429.0	0.073171	0.035871
3	A*23:01	1	14	15.0	3429.0	0.066667	0.004374
4	A*31:01	7	21	28.0	3429.0	0.250000	0.008166

	index	Allele	Lost_count	Kept_count	Total_allele_count	Total_count	Lost_allele_frequency	Allele_frequency
13	15	A*02:01	12	175	235.0	3429.0	0.051064	0.068533
6	7	C*07:02	11	119	140.0	3429.0	0.078571	0.040828
9	11	A*24:02	8	113	133.0	3429.0	0.060150	0.038787
2	2	C*04:01	9	105	123.0	3429.0	0.073171	0.035871
8	10	C*06:02	11	96	117.0	3429.0	0.094017	0.034121

	Cancer_type	Total_patients	HLALOH_patients	Fraction
13	Thyroid	2	0.0	0.000000
14	Lung-LCC	1	0.0	0.000000
9	Liver	28	1.0	0.035714
1	Melanoma	84	6.0	0.071429
5	Uterine	39	3.0	0.076923
3	Breast	66	6.0	0.090909
10	Ovarian	28	4.0	0.142857
4	Kidney_RCC	55	9.0	0.163636
2	Colorectal	80	18.0	0.225000
6	Bladder	38	9.0	0.236842
0	NSCLC_adenocarcinoma	88	21.0	0.238636
7	NSCLC_SCC	31	8.0	0.258065
8	Pancreatic	30	8.0	0.266667
12	Cervical	18	7.0	0.388889
11	Head_Neck	20	8.0	0.400000

	Cancer_type	LOH_region
0	Uterine	0.048719
1	Thyroid	0.110709
2	Colorectal	0.126482
3	Melanoma	0.139147
4	Kidney_RCC	0.140382

	Neoepitopes
	count	mean	std	min	25%	50%	75%	max
Allele Status
Kept	180.0	64.033333	93.212912	1.0	17.0	30.0	68.50	521.0
Lost	180.0	67.322222	98.602336	2.0	17.0	33.5	68.25	503.0

	sample	gene	LOH
0	DNA_NGT-LCS-1907004T	B	False
1	DNA_ILS35295PT4	A	False
2	DNA_ILS35295PT4	B	False
3	DNA_NGT-BR-1905002T	C	False
5	DNA_ILS33973PD4	C	False

	sample	gene	purity	ploidy	sequenza_major	sequenza_minor	baf_0	baf_1	baf_2	baf_3	...	minCoverage_median	medCoverage1	medCoverage2	minMedCoverage	a1PercCov	a2PercCov	percCov	Sequenza_Loss	Sequenza_imbalance	Sequenza_difference
0	DNA_S000443705	A	0.64	2	2.0	2.0	NaN	NaN	-0.026054	-0.035957	...	0.703974	0.711237	0.878719	0.711237	0.270833	0.729167	0.729167	False	False	0.0
1	DNA_S000443705	B	0.64	2	2.0	1.0	NaN	NaN	-0.024833	0.002578	...	0.564464	0.671202	0.634174	0.634174	0.500000	0.500000	0.500000	False	True	1.0
2	DNA_S000443705	C	0.64	2	2.0	2.0	0.046311	0.032911	-0.014469	-0.029771	...	0.650248	0.767484	0.842796	0.767484	0.437500	0.562500	0.562500	False	False	0.0
3	DNA_302298	A	0.35	2	1.0	1.0	-0.011801	0.011353	0.059889	0.058102	...	0.970497	1.025303	0.983976	0.983976	0.583333	0.416667	0.583333	False	False	0.0
4	DNA_302298	C	0.35	2	1.0	1.0	-0.024988	-0.025108	-0.029734	-0.065980	...	1.034362	1.089240	1.143182	1.089240	0.375000	0.625000	0.625000	False	False	0.0

	region	HLA_A_type1	HLA_A_type2	HLA_type1copyNum_withBAFBin	HLA_type2copyNum_withBAFBin	PVal_unique	LossAllele	KeptAllele	LOH_allele	LOH	sample	gene	LOHHLA
0	DNA_ILS50527PT6	hla_a_11_01_01	hla_a_33_03_01	4.750606	0.031963	3.913078e-51	hla_a_33_03_01	hla_a_11_01_01	hla_a_33_03_01	True	DNA_ILS50527PT6	A	True
2	DNA_ILS50527PT6	hla_b_15_35	hla_b_58_01_01	4.844561	0.042261	1.321898e-33	hla_b_58_01_01	hla_b_15_35	hla_b_58_01_01	True	DNA_ILS50527PT6	B	True
5	DNA_ILS50527PT6	hla_c_03_02_02_01	hla_c_07_02_01_01	0.159054	4.804306	8.435445e-64	hla_c_03_02_02_01	hla_c_07_02_01_01	hla_c_03_02_02_01	True	DNA_ILS50527PT6	C	True
0	DNA_ILS51039PT2	hla_a_01_01_01_01	hla_a_02_06_01	2.376083	0.922969	3.959785e-09	hla_a_02_06_01	hla_a_01_01_01_01	NaN	False	DNA_ILS51039PT2	A	False
2	DNA_ILS51039PT2	hla_b_35_01_01_01	hla_b_55_02_01	1.125873	2.465880	5.279493e-04	hla_b_35_01_01_01	hla_b_55_02_01	NaN	False	DNA_ILS51039PT2	B	False